mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-04-13 18:14:48 -05:00
161951 lines
7.7 MiB
161951 lines
7.7 MiB
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
|
|
|
|
"use strict";
|
|
var ts = (() => {
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
}) : x)(function(x) {
|
|
if (typeof require !== "undefined")
|
|
return require.apply(this, arguments);
|
|
throw new Error('Dynamic require of "' + x + '" is not supported');
|
|
});
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// src/tsserver/server.ts
|
|
var server_exports = {};
|
|
__export(server_exports, {
|
|
ANONYMOUS: () => ANONYMOUS,
|
|
AccessFlags: () => AccessFlags,
|
|
AssertionLevel: () => AssertionLevel,
|
|
AssignmentDeclarationKind: () => AssignmentDeclarationKind,
|
|
AssignmentKind: () => AssignmentKind,
|
|
Associativity: () => Associativity,
|
|
BreakpointResolver: () => ts_BreakpointResolver_exports,
|
|
BuilderFileEmit: () => BuilderFileEmit,
|
|
BuilderProgramKind: () => BuilderProgramKind,
|
|
BuilderState: () => BuilderState,
|
|
BundleFileSectionKind: () => BundleFileSectionKind,
|
|
CallHierarchy: () => ts_CallHierarchy_exports,
|
|
CharacterCodes: () => CharacterCodes,
|
|
CheckFlags: () => CheckFlags,
|
|
CheckMode: () => CheckMode,
|
|
ClassificationType: () => ClassificationType,
|
|
ClassificationTypeNames: () => ClassificationTypeNames,
|
|
CommentDirectiveType: () => CommentDirectiveType,
|
|
Comparison: () => Comparison,
|
|
CompletionInfoFlags: () => CompletionInfoFlags,
|
|
CompletionTriggerKind: () => CompletionTriggerKind,
|
|
Completions: () => ts_Completions_exports,
|
|
ConfigFileProgramReloadLevel: () => ConfigFileProgramReloadLevel,
|
|
ContextFlags: () => ContextFlags,
|
|
CoreServicesShimHostAdapter: () => CoreServicesShimHostAdapter,
|
|
Debug: () => Debug,
|
|
DiagnosticCategory: () => DiagnosticCategory,
|
|
Diagnostics: () => Diagnostics,
|
|
DocumentHighlights: () => DocumentHighlights,
|
|
ElementFlags: () => ElementFlags,
|
|
EmitFlags: () => EmitFlags,
|
|
EmitHint: () => EmitHint,
|
|
EmitOnly: () => EmitOnly,
|
|
EndOfLineState: () => EndOfLineState,
|
|
EnumKind: () => EnumKind,
|
|
ExitStatus: () => ExitStatus,
|
|
ExportKind: () => ExportKind,
|
|
Extension: () => Extension,
|
|
ExternalEmitHelpers: () => ExternalEmitHelpers,
|
|
FileIncludeKind: () => FileIncludeKind,
|
|
FilePreprocessingDiagnosticsKind: () => FilePreprocessingDiagnosticsKind,
|
|
FileSystemEntryKind: () => FileSystemEntryKind,
|
|
FileWatcherEventKind: () => FileWatcherEventKind,
|
|
FindAllReferences: () => ts_FindAllReferences_exports,
|
|
FlattenLevel: () => FlattenLevel,
|
|
FlowFlags: () => FlowFlags,
|
|
ForegroundColorEscapeSequences: () => ForegroundColorEscapeSequences,
|
|
FunctionFlags: () => FunctionFlags,
|
|
GeneratedIdentifierFlags: () => GeneratedIdentifierFlags,
|
|
GetLiteralTextFlags: () => GetLiteralTextFlags,
|
|
GoToDefinition: () => ts_GoToDefinition_exports,
|
|
HighlightSpanKind: () => HighlightSpanKind,
|
|
ImportKind: () => ImportKind,
|
|
ImportsNotUsedAsValues: () => ImportsNotUsedAsValues,
|
|
IndentStyle: () => IndentStyle,
|
|
IndexKind: () => IndexKind,
|
|
InferenceFlags: () => InferenceFlags,
|
|
InferencePriority: () => InferencePriority,
|
|
InlayHintKind: () => InlayHintKind,
|
|
InlayHints: () => ts_InlayHints_exports,
|
|
InternalSymbolName: () => InternalSymbolName,
|
|
InvalidatedProjectKind: () => InvalidatedProjectKind,
|
|
JsDoc: () => ts_JsDoc_exports,
|
|
JsTyping: () => ts_JsTyping_exports,
|
|
JsxEmit: () => JsxEmit,
|
|
JsxFlags: () => JsxFlags,
|
|
JsxReferenceKind: () => JsxReferenceKind,
|
|
LanguageServiceMode: () => LanguageServiceMode,
|
|
LanguageServiceShimHostAdapter: () => LanguageServiceShimHostAdapter,
|
|
LanguageVariant: () => LanguageVariant,
|
|
LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
|
|
ListFormat: () => ListFormat,
|
|
LogLevel: () => LogLevel,
|
|
MemberOverrideStatus: () => MemberOverrideStatus,
|
|
ModifierFlags: () => ModifierFlags,
|
|
ModuleDetectionKind: () => ModuleDetectionKind,
|
|
ModuleInstanceState: () => ModuleInstanceState,
|
|
ModuleKind: () => ModuleKind,
|
|
ModuleResolutionKind: () => ModuleResolutionKind,
|
|
NavigateTo: () => ts_NavigateTo_exports,
|
|
NavigationBar: () => ts_NavigationBar_exports,
|
|
NewLineKind: () => NewLineKind,
|
|
NodeBuilderFlags: () => NodeBuilderFlags,
|
|
NodeCheckFlags: () => NodeCheckFlags,
|
|
NodeFactoryFlags: () => NodeFactoryFlags,
|
|
NodeFlags: () => NodeFlags,
|
|
NodeResolutionFeatures: () => NodeResolutionFeatures,
|
|
ObjectFlags: () => ObjectFlags,
|
|
OperationCanceledException: () => OperationCanceledException,
|
|
OperatorPrecedence: () => OperatorPrecedence,
|
|
OrganizeImports: () => ts_OrganizeImports_exports,
|
|
OrganizeImportsMode: () => OrganizeImportsMode,
|
|
OuterExpressionKinds: () => OuterExpressionKinds,
|
|
OutliningElementsCollector: () => ts_OutliningElementsCollector_exports,
|
|
OutliningSpanKind: () => OutliningSpanKind,
|
|
OutputFileType: () => OutputFileType,
|
|
PackageJsonAutoImportPreference: () => PackageJsonAutoImportPreference,
|
|
PackageJsonDependencyGroup: () => PackageJsonDependencyGroup,
|
|
PatternMatchKind: () => PatternMatchKind,
|
|
PollingInterval: () => PollingInterval,
|
|
PollingWatchKind: () => PollingWatchKind,
|
|
PragmaKindFlags: () => PragmaKindFlags,
|
|
PrivateIdentifierKind: () => PrivateIdentifierKind2,
|
|
ProcessLevel: () => ProcessLevel,
|
|
QuotePreference: () => QuotePreference,
|
|
RelationComparisonResult: () => RelationComparisonResult,
|
|
Rename: () => ts_Rename_exports,
|
|
ScriptElementKind: () => ScriptElementKind,
|
|
ScriptElementKindModifier: () => ScriptElementKindModifier,
|
|
ScriptKind: () => ScriptKind,
|
|
ScriptSnapshot: () => ScriptSnapshot,
|
|
ScriptTarget: () => ScriptTarget,
|
|
SemanticClassificationFormat: () => SemanticClassificationFormat,
|
|
SemanticMeaning: () => SemanticMeaning,
|
|
SemicolonPreference: () => SemicolonPreference,
|
|
SignatureCheckMode: () => SignatureCheckMode,
|
|
SignatureFlags: () => SignatureFlags,
|
|
SignatureHelp: () => ts_SignatureHelp_exports,
|
|
SignatureKind: () => SignatureKind,
|
|
SmartSelectionRange: () => ts_SmartSelectionRange_exports,
|
|
SnippetKind: () => SnippetKind,
|
|
StructureIsReused: () => StructureIsReused,
|
|
SymbolAccessibility: () => SymbolAccessibility,
|
|
SymbolDisplay: () => ts_SymbolDisplay_exports,
|
|
SymbolDisplayPartKind: () => SymbolDisplayPartKind,
|
|
SymbolFlags: () => SymbolFlags,
|
|
SymbolFormatFlags: () => SymbolFormatFlags,
|
|
SyntaxKind: () => SyntaxKind,
|
|
SyntheticSymbolKind: () => SyntheticSymbolKind,
|
|
Ternary: () => Ternary,
|
|
ThrottledCancellationToken: () => ThrottledCancellationToken,
|
|
TokenClass: () => TokenClass,
|
|
TokenFlags: () => TokenFlags,
|
|
TransformFlags: () => TransformFlags,
|
|
TypeFacts: () => TypeFacts,
|
|
TypeFlags: () => TypeFlags,
|
|
TypeFormatFlags: () => TypeFormatFlags,
|
|
TypeMapKind: () => TypeMapKind,
|
|
TypePredicateKind: () => TypePredicateKind,
|
|
TypeReferenceSerializationKind: () => TypeReferenceSerializationKind,
|
|
TypeScriptServicesFactory: () => TypeScriptServicesFactory,
|
|
UnionReduction: () => UnionReduction,
|
|
UpToDateStatusType: () => UpToDateStatusType,
|
|
VarianceFlags: () => VarianceFlags,
|
|
Version: () => Version,
|
|
VersionRange: () => VersionRange,
|
|
WatchDirectoryFlags: () => WatchDirectoryFlags,
|
|
WatchDirectoryKind: () => WatchDirectoryKind,
|
|
WatchFileKind: () => WatchFileKind,
|
|
WatchLogLevel: () => WatchLogLevel,
|
|
WatchType: () => WatchType,
|
|
addEmitFlags: () => addEmitFlags,
|
|
addEmitHelper: () => addEmitHelper,
|
|
addEmitHelpers: () => addEmitHelpers,
|
|
addNodeFactoryPatcher: () => addNodeFactoryPatcher,
|
|
addRange: () => addRange,
|
|
addRelatedInfo: () => addRelatedInfo,
|
|
addSyntheticLeadingComment: () => addSyntheticLeadingComment,
|
|
addSyntheticTrailingComment: () => addSyntheticTrailingComment,
|
|
addToSeen: () => addToSeen,
|
|
advancedAsyncSuperHelper: () => advancedAsyncSuperHelper,
|
|
affectsDeclarationPathOptionDeclarations: () => affectsDeclarationPathOptionDeclarations,
|
|
affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations,
|
|
allKeysStartWithDot: () => allKeysStartWithDot,
|
|
altDirectorySeparator: () => altDirectorySeparator,
|
|
and: () => and,
|
|
append: () => append,
|
|
appendIfUnique: () => appendIfUnique,
|
|
arrayFrom: () => arrayFrom,
|
|
arrayIsEqualTo: () => arrayIsEqualTo,
|
|
arrayIsHomogeneous: () => arrayIsHomogeneous,
|
|
arrayIsSorted: () => arrayIsSorted,
|
|
arrayIterator: () => arrayIterator,
|
|
arrayOf: () => arrayOf,
|
|
arrayReverseIterator: () => arrayReverseIterator,
|
|
arrayToMap: () => arrayToMap,
|
|
arrayToMultiMap: () => arrayToMultiMap,
|
|
arrayToNumericMap: () => arrayToNumericMap,
|
|
arraysEqual: () => arraysEqual,
|
|
assertType: () => assertType,
|
|
assign: () => assign,
|
|
assignHelper: () => assignHelper,
|
|
asyncDelegator: () => asyncDelegator,
|
|
asyncGeneratorHelper: () => asyncGeneratorHelper,
|
|
asyncSuperHelper: () => asyncSuperHelper,
|
|
asyncValues: () => asyncValues,
|
|
attachFileToDiagnostics: () => attachFileToDiagnostics,
|
|
awaitHelper: () => awaitHelper,
|
|
awaiterHelper: () => awaiterHelper,
|
|
base64decode: () => base64decode,
|
|
base64encode: () => base64encode,
|
|
binarySearch: () => binarySearch,
|
|
binarySearchKey: () => binarySearchKey,
|
|
bindSourceFile: () => bindSourceFile,
|
|
breakIntoCharacterSpans: () => breakIntoCharacterSpans,
|
|
breakIntoWordSpans: () => breakIntoWordSpans,
|
|
buildLinkParts: () => buildLinkParts,
|
|
buildOpts: () => buildOpts,
|
|
buildOverload: () => buildOverload,
|
|
canBeConvertedToAsync: () => canBeConvertedToAsync,
|
|
canHaveDecorators: () => canHaveDecorators,
|
|
canHaveExportModifier: () => canHaveExportModifier,
|
|
canHaveIllegalDecorators: () => canHaveIllegalDecorators,
|
|
canHaveIllegalModifiers: () => canHaveIllegalModifiers,
|
|
canHaveIllegalType: () => canHaveIllegalType,
|
|
canHaveIllegalTypeParameters: () => canHaveIllegalTypeParameters,
|
|
canHaveModifiers: () => canHaveModifiers,
|
|
canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
|
|
canProduceDiagnostics: () => canProduceDiagnostics,
|
|
canWatchDirectoryOrFile: () => canWatchDirectoryOrFile,
|
|
cartesianProduct: () => cartesianProduct,
|
|
cast: () => cast,
|
|
chainBundle: () => chainBundle,
|
|
chainDiagnosticMessages: () => chainDiagnosticMessages,
|
|
changeAnyExtension: () => changeAnyExtension,
|
|
changeCompilerHostLikeToUseCache: () => changeCompilerHostLikeToUseCache,
|
|
changeExtension: () => changeExtension,
|
|
changesAffectModuleResolution: () => changesAffectModuleResolution,
|
|
changesAffectingProgramStructure: () => changesAffectingProgramStructure,
|
|
childIsDecorated: () => childIsDecorated,
|
|
classOrConstructorParameterIsDecorated: () => classOrConstructorParameterIsDecorated,
|
|
classPrivateFieldGetHelper: () => classPrivateFieldGetHelper,
|
|
classPrivateFieldInHelper: () => classPrivateFieldInHelper,
|
|
classPrivateFieldSetHelper: () => classPrivateFieldSetHelper,
|
|
classicNameResolver: () => classicNameResolver,
|
|
classifier: () => ts_classifier_exports,
|
|
cleanExtendedConfigCache: () => cleanExtendedConfigCache,
|
|
clear: () => clear,
|
|
clearMap: () => clearMap,
|
|
clearSharedExtendedConfigFileWatcher: () => clearSharedExtendedConfigFileWatcher,
|
|
climbPastPropertyAccess: () => climbPastPropertyAccess,
|
|
climbPastPropertyOrElementAccess: () => climbPastPropertyOrElementAccess,
|
|
clone: () => clone,
|
|
cloneCompilerOptions: () => cloneCompilerOptions,
|
|
closeFileWatcher: () => closeFileWatcher,
|
|
closeFileWatcherOf: () => closeFileWatcherOf,
|
|
codefix: () => ts_codefix_exports,
|
|
collapseTextChangeRangesAcrossMultipleVersions: () => collapseTextChangeRangesAcrossMultipleVersions,
|
|
collectExternalModuleInfo: () => collectExternalModuleInfo,
|
|
combine: () => combine,
|
|
combinePaths: () => combinePaths,
|
|
commentPragmas: () => commentPragmas,
|
|
commonOptionsWithBuild: () => commonOptionsWithBuild,
|
|
commonPackageFolders: () => commonPackageFolders,
|
|
compact: () => compact,
|
|
compareBooleans: () => compareBooleans,
|
|
compareDataObjects: () => compareDataObjects,
|
|
compareDiagnostics: () => compareDiagnostics,
|
|
compareDiagnosticsSkipRelatedInformation: () => compareDiagnosticsSkipRelatedInformation,
|
|
compareEmitHelpers: () => compareEmitHelpers,
|
|
compareNumberOfDirectorySeparators: () => compareNumberOfDirectorySeparators,
|
|
comparePaths: () => comparePaths,
|
|
comparePathsCaseInsensitive: () => comparePathsCaseInsensitive,
|
|
comparePathsCaseSensitive: () => comparePathsCaseSensitive,
|
|
comparePatternKeys: () => comparePatternKeys,
|
|
compareProperties: () => compareProperties,
|
|
compareStringsCaseInsensitive: () => compareStringsCaseInsensitive,
|
|
compareStringsCaseSensitive: () => compareStringsCaseSensitive,
|
|
compareStringsCaseSensitiveUI: () => compareStringsCaseSensitiveUI,
|
|
compareTextSpans: () => compareTextSpans,
|
|
compareValues: () => compareValues,
|
|
compileOnSaveCommandLineOption: () => compileOnSaveCommandLineOption,
|
|
compilerOptionsAffectDeclarationPath: () => compilerOptionsAffectDeclarationPath,
|
|
compilerOptionsAffectEmit: () => compilerOptionsAffectEmit,
|
|
compilerOptionsAffectSemanticDiagnostics: () => compilerOptionsAffectSemanticDiagnostics,
|
|
compilerOptionsDidYouMeanDiagnostics: () => compilerOptionsDidYouMeanDiagnostics,
|
|
compilerOptionsIndicateEsModules: () => compilerOptionsIndicateEsModules,
|
|
compose: () => compose,
|
|
computeCommonSourceDirectoryOfFilenames: () => computeCommonSourceDirectoryOfFilenames,
|
|
computeLineAndCharacterOfPosition: () => computeLineAndCharacterOfPosition,
|
|
computeLineOfPosition: () => computeLineOfPosition,
|
|
computeLineStarts: () => computeLineStarts,
|
|
computePositionOfLineAndCharacter: () => computePositionOfLineAndCharacter,
|
|
computeSignature: () => computeSignature,
|
|
computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
|
|
computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
|
|
concatenate: () => concatenate,
|
|
concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
|
|
consumesNodeCoreModules: () => consumesNodeCoreModules,
|
|
contains: () => contains,
|
|
containsIgnoredPath: () => containsIgnoredPath,
|
|
containsParseError: () => containsParseError,
|
|
containsPath: () => containsPath,
|
|
convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
|
|
convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
|
|
convertEnableAutoDiscoveryToEnable: () => convertEnableAutoDiscoveryToEnable,
|
|
convertJsonOption: () => convertJsonOption,
|
|
convertToBase64: () => convertToBase64,
|
|
convertToObject: () => convertToObject,
|
|
convertToObjectWorker: () => convertToObjectWorker,
|
|
convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
|
|
convertToRelativePath: () => convertToRelativePath,
|
|
convertToTSConfig: () => convertToTSConfig,
|
|
convertTypeAcquisitionFromJson: () => convertTypeAcquisitionFromJson,
|
|
copyComments: () => copyComments,
|
|
copyEntries: () => copyEntries,
|
|
copyLeadingComments: () => copyLeadingComments,
|
|
copyProperties: () => copyProperties,
|
|
copyTrailingAsLeadingComments: () => copyTrailingAsLeadingComments,
|
|
copyTrailingComments: () => copyTrailingComments,
|
|
couldStartTrivia: () => couldStartTrivia,
|
|
countWhere: () => countWhere,
|
|
createAbstractBuilder: () => createAbstractBuilder,
|
|
createAccessorPropertyBackingField: () => createAccessorPropertyBackingField,
|
|
createAccessorPropertyGetRedirector: () => createAccessorPropertyGetRedirector,
|
|
createAccessorPropertySetRedirector: () => createAccessorPropertySetRedirector,
|
|
createAdd: () => createAdd,
|
|
createArrayBindingPattern: () => createArrayBindingPattern,
|
|
createArrayLiteral: () => createArrayLiteral,
|
|
createArrayTypeNode: () => createArrayTypeNode,
|
|
createArrowFunction: () => createArrowFunction,
|
|
createAsExpression: () => createAsExpression,
|
|
createAssignment: () => createAssignment,
|
|
createAwait: () => createAwait,
|
|
createBaseNodeFactory: () => createBaseNodeFactory,
|
|
createBigIntLiteral: () => createBigIntLiteral,
|
|
createBinary: () => createBinary,
|
|
createBinaryExpressionTrampoline: () => createBinaryExpressionTrampoline,
|
|
createBindingElement: () => createBindingElement,
|
|
createBindingHelper: () => createBindingHelper,
|
|
createBlock: () => createBlock,
|
|
createBreak: () => createBreak,
|
|
createBuildInfo: () => createBuildInfo,
|
|
createBuilderProgram: () => createBuilderProgram,
|
|
createBuilderProgramUsingProgramBuildInfo: () => createBuilderProgramUsingProgramBuildInfo,
|
|
createBuilderStatusReporter: () => createBuilderStatusReporter,
|
|
createBundle: () => createBundle,
|
|
createCacheWithRedirects: () => createCacheWithRedirects,
|
|
createCacheableExportInfoMap: () => createCacheableExportInfoMap,
|
|
createCachedDirectoryStructureHost: () => createCachedDirectoryStructureHost,
|
|
createCall: () => createCall,
|
|
createCallChain: () => createCallChain,
|
|
createCallSignature: () => createCallSignature,
|
|
createCaseBlock: () => createCaseBlock,
|
|
createCaseClause: () => createCaseClause,
|
|
createCatchClause: () => createCatchClause,
|
|
createClassDeclaration: () => createClassDeclaration,
|
|
createClassExpression: () => createClassExpression,
|
|
createClassifier: () => createClassifier,
|
|
createComma: () => createComma,
|
|
createCommaList: () => createCommaList,
|
|
createCommentDirectivesMap: () => createCommentDirectivesMap,
|
|
createCompilerDiagnostic: () => createCompilerDiagnostic,
|
|
createCompilerDiagnosticForInvalidCustomType: () => createCompilerDiagnosticForInvalidCustomType,
|
|
createCompilerDiagnosticFromMessageChain: () => createCompilerDiagnosticFromMessageChain,
|
|
createCompilerHost: () => createCompilerHost,
|
|
createCompilerHostFromProgramHost: () => createCompilerHostFromProgramHost,
|
|
createCompilerHostWorker: () => createCompilerHostWorker,
|
|
createComputedPropertyName: () => createComputedPropertyName,
|
|
createConditional: () => createConditional,
|
|
createConditionalTypeNode: () => createConditionalTypeNode,
|
|
createConstructSignature: () => createConstructSignature,
|
|
createConstructor: () => createConstructor,
|
|
createConstructorTypeNode: () => createConstructorTypeNode,
|
|
createContinue: () => createContinue,
|
|
createDebuggerStatement: () => createDebuggerStatement,
|
|
createDecorator: () => createDecorator,
|
|
createDefaultClause: () => createDefaultClause,
|
|
createDelete: () => createDelete,
|
|
createDetachedDiagnostic: () => createDetachedDiagnostic,
|
|
createDiagnosticCollection: () => createDiagnosticCollection,
|
|
createDiagnosticForFileFromMessageChain: () => createDiagnosticForFileFromMessageChain,
|
|
createDiagnosticForNode: () => createDiagnosticForNode,
|
|
createDiagnosticForNodeArray: () => createDiagnosticForNodeArray,
|
|
createDiagnosticForNodeFromMessageChain: () => createDiagnosticForNodeFromMessageChain,
|
|
createDiagnosticForNodeInSourceFile: () => createDiagnosticForNodeInSourceFile,
|
|
createDiagnosticForRange: () => createDiagnosticForRange,
|
|
createDiagnosticMessageChainFromDiagnostic: () => createDiagnosticMessageChainFromDiagnostic,
|
|
createDiagnosticReporter: () => createDiagnosticReporter,
|
|
createDo: () => createDo,
|
|
createDocumentPositionMapper: () => createDocumentPositionMapper,
|
|
createDocumentRegistry: () => createDocumentRegistry,
|
|
createDocumentRegistryInternal: () => createDocumentRegistryInternal,
|
|
createElementAccess: () => createElementAccess,
|
|
createElementAccessChain: () => createElementAccessChain,
|
|
createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
|
|
createEmitHelperFactory: () => createEmitHelperFactory,
|
|
createEmptyExports: () => createEmptyExports,
|
|
createEmptyStatement: () => createEmptyStatement,
|
|
createEnumDeclaration: () => createEnumDeclaration,
|
|
createEnumMember: () => createEnumMember,
|
|
createExportAssignment: () => createExportAssignment2,
|
|
createExportDeclaration: () => createExportDeclaration,
|
|
createExportDefault: () => createExportDefault,
|
|
createExportSpecifier: () => createExportSpecifier,
|
|
createExpressionForJsxElement: () => createExpressionForJsxElement,
|
|
createExpressionForJsxFragment: () => createExpressionForJsxFragment,
|
|
createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
|
|
createExpressionForPropertyName: () => createExpressionForPropertyName,
|
|
createExpressionFromEntityName: () => createExpressionFromEntityName,
|
|
createExpressionStatement: () => createExpressionStatement,
|
|
createExpressionWithTypeArguments: () => createExpressionWithTypeArguments,
|
|
createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
|
|
createExternalModuleExport: () => createExternalModuleExport,
|
|
createExternalModuleReference: () => createExternalModuleReference,
|
|
createFalse: () => createFalse,
|
|
createFileDiagnostic: () => createFileDiagnostic,
|
|
createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
|
|
createFileLevelUniqueName: () => createFileLevelUniqueName,
|
|
createFor: () => createFor,
|
|
createForIn: () => createForIn,
|
|
createForOf: () => createForOf,
|
|
createForOfBindingStatement: () => createForOfBindingStatement,
|
|
createFunctionDeclaration: () => createFunctionDeclaration,
|
|
createFunctionExpression: () => createFunctionExpression,
|
|
createFunctionTypeNode: () => createFunctionTypeNode,
|
|
createGetAccessor: () => createGetAccessor,
|
|
createGetCanonicalFileName: () => createGetCanonicalFileName,
|
|
createGetSourceFile: () => createGetSourceFile,
|
|
createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
|
|
createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName,
|
|
createGetSymbolWalker: () => createGetSymbolWalker,
|
|
createHeritageClause: () => createHeritageClause,
|
|
createIdentifier: () => createIdentifier,
|
|
createIf: () => createIf,
|
|
createImmediatelyInvokedArrowFunction: () => createImmediatelyInvokedArrowFunction,
|
|
createImmediatelyInvokedFunctionExpression: () => createImmediatelyInvokedFunctionExpression,
|
|
createImportClause: () => createImportClause,
|
|
createImportDeclaration: () => createImportDeclaration,
|
|
createImportEqualsDeclaration: () => createImportEqualsDeclaration,
|
|
createImportSpecifier: () => createImportSpecifier,
|
|
createImportTypeNode: () => createImportTypeNode,
|
|
createIncrementalCompilerHost: () => createIncrementalCompilerHost,
|
|
createIncrementalProgram: () => createIncrementalProgram,
|
|
createIndexSignature: () => createIndexSignature,
|
|
createIndexedAccessTypeNode: () => createIndexedAccessTypeNode,
|
|
createInferTypeNode: () => createInferTypeNode,
|
|
createInputFiles: () => createInputFiles,
|
|
createInputFilesWithFilePaths: () => createInputFilesWithFilePaths,
|
|
createInputFilesWithFileTexts: () => createInputFilesWithFileTexts,
|
|
createInterfaceDeclaration: () => createInterfaceDeclaration,
|
|
createIntersectionTypeNode: () => createIntersectionTypeNode,
|
|
createJSDocAugmentsTag: () => createJSDocAugmentsTag,
|
|
createJSDocAuthorTag: () => createJSDocAuthorTag,
|
|
createJSDocCallbackTag: () => createJSDocCallbackTag,
|
|
createJSDocClassTag: () => createJSDocClassTag,
|
|
createJSDocComment: () => createJSDocComment,
|
|
createJSDocEnumTag: () => createJSDocEnumTag,
|
|
createJSDocImplementsTag: () => createJSDocImplementsTag,
|
|
createJSDocParamTag: () => createJSDocParamTag,
|
|
createJSDocParameterTag: () => createJSDocParameterTag,
|
|
createJSDocPrivateTag: () => createJSDocPrivateTag,
|
|
createJSDocPropertyTag: () => createJSDocPropertyTag,
|
|
createJSDocProtectedTag: () => createJSDocProtectedTag,
|
|
createJSDocPublicTag: () => createJSDocPublicTag,
|
|
createJSDocReadonlyTag: () => createJSDocReadonlyTag,
|
|
createJSDocReturnTag: () => createJSDocReturnTag,
|
|
createJSDocSignature: () => createJSDocSignature,
|
|
createJSDocTag: () => createJSDocTag,
|
|
createJSDocTemplateTag: () => createJSDocTemplateTag,
|
|
createJSDocThisTag: () => createJSDocThisTag,
|
|
createJSDocTypeExpression: () => createJSDocTypeExpression,
|
|
createJSDocTypeLiteral: () => createJSDocTypeLiteral,
|
|
createJSDocTypeTag: () => createJSDocTypeTag,
|
|
createJSDocTypedefTag: () => createJSDocTypedefTag,
|
|
createJsxAttribute: () => createJsxAttribute,
|
|
createJsxAttributes: () => createJsxAttributes,
|
|
createJsxClosingElement: () => createJsxClosingElement,
|
|
createJsxElement: () => createJsxElement,
|
|
createJsxExpression: () => createJsxExpression,
|
|
createJsxFactoryExpression: () => createJsxFactoryExpression,
|
|
createJsxFragment: () => createJsxFragment,
|
|
createJsxJsxClosingFragment: () => createJsxJsxClosingFragment,
|
|
createJsxOpeningElement: () => createJsxOpeningElement,
|
|
createJsxOpeningFragment: () => createJsxOpeningFragment,
|
|
createJsxSelfClosingElement: () => createJsxSelfClosingElement,
|
|
createJsxSpreadAttribute: () => createJsxSpreadAttribute,
|
|
createJsxText: () => createJsxText,
|
|
createKeywordTypeNode: () => createKeywordTypeNode,
|
|
createLabel: () => createLabel,
|
|
createLanguageService: () => createLanguageService,
|
|
createLanguageServiceSourceFile: () => createLanguageServiceSourceFile,
|
|
createLessThan: () => createLessThan,
|
|
createLiteral: () => createLiteral,
|
|
createLiteralTypeNode: () => createLiteralTypeNode,
|
|
createLogicalAnd: () => createLogicalAnd,
|
|
createLogicalNot: () => createLogicalNot,
|
|
createLogicalOr: () => createLogicalOr,
|
|
createLoopVariable: () => createLoopVariable,
|
|
createMappedTypeNode: () => createMappedTypeNode,
|
|
createMemberAccessForPropertyName: () => createMemberAccessForPropertyName,
|
|
createMetaProperty: () => createMetaProperty,
|
|
createMethod: () => createMethod,
|
|
createMethodSignature: () => createMethodSignature,
|
|
createModeAwareCache: () => createModeAwareCache,
|
|
createModifier: () => createModifier,
|
|
createModifiersFromModifierFlags: () => createModifiersFromModifierFlags,
|
|
createModuleBlock: () => createModuleBlock,
|
|
createModuleDeclaration: () => createModuleDeclaration,
|
|
createModuleResolutionCache: () => createModuleResolutionCache,
|
|
createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
|
|
createMultiMap: () => createMultiMap,
|
|
createNamedExports: () => createNamedExports,
|
|
createNamedImports: () => createNamedImports,
|
|
createNamespaceExport: () => createNamespaceExport,
|
|
createNamespaceExportDeclaration: () => createNamespaceExportDeclaration,
|
|
createNamespaceImport: () => createNamespaceImport,
|
|
createNew: () => createNew,
|
|
createNoSubstitutionTemplateLiteral: () => createNoSubstitutionTemplateLiteral,
|
|
createNode: () => createNode2,
|
|
createNodeArray: () => createNodeArray,
|
|
createNodeConverters: () => createNodeConverters,
|
|
createNodeFactory: () => createNodeFactory,
|
|
createNonNullChain: () => createNonNullChain,
|
|
createNonNullExpression: () => createNonNullExpression,
|
|
createNotEmittedStatement: () => createNotEmittedStatement,
|
|
createNull: () => createNull,
|
|
createNumericLiteral: () => createNumericLiteral,
|
|
createObjectBindingPattern: () => createObjectBindingPattern,
|
|
createObjectLiteral: () => createObjectLiteral,
|
|
createOmittedExpression: () => createOmittedExpression,
|
|
createOptimisticUniqueName: () => createOptimisticUniqueName,
|
|
createOptionNameMap: () => createOptionNameMap,
|
|
createOptionalTypeNode: () => createOptionalTypeNode,
|
|
createOverload: () => createOverload,
|
|
createPackageJsonImportFilter: () => createPackageJsonImportFilter,
|
|
createPackageJsonInfo: () => createPackageJsonInfo,
|
|
createParameter: () => createParameter,
|
|
createParen: () => createParen,
|
|
createParenthesizedType: () => createParenthesizedType,
|
|
createParenthesizerRules: () => createParenthesizerRules,
|
|
createPartiallyEmittedExpression: () => createPartiallyEmittedExpression,
|
|
createPatternMatcher: () => createPatternMatcher,
|
|
createPostfix: () => createPostfix,
|
|
createPostfixIncrement: () => createPostfixIncrement,
|
|
createPrefix: () => createPrefix,
|
|
createPrependNodes: () => createPrependNodes,
|
|
createPrinter: () => createPrinter,
|
|
createPrivateIdentifier: () => createPrivateIdentifier,
|
|
createProgram: () => createProgram,
|
|
createProgramHost: () => createProgramHost,
|
|
createProperty: () => createProperty,
|
|
createPropertyAccess: () => createPropertyAccess,
|
|
createPropertyAccessChain: () => createPropertyAccessChain,
|
|
createPropertyAssignment: () => createPropertyAssignment,
|
|
createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral,
|
|
createPropertySignature: () => createPropertySignature,
|
|
createQualifiedName: () => createQualifiedName,
|
|
createQueue: () => createQueue,
|
|
createRange: () => createRange,
|
|
createRedirectedBuilderProgram: () => createRedirectedBuilderProgram,
|
|
createRegularExpressionLiteral: () => createRegularExpressionLiteral,
|
|
createResolutionCache: () => createResolutionCache,
|
|
createRestTypeNode: () => createRestTypeNode,
|
|
createReturn: () => createReturn,
|
|
createRuntimeTypeSerializer: () => createRuntimeTypeSerializer,
|
|
createScanner: () => createScanner,
|
|
createSemanticDiagnosticsBuilderProgram: () => createSemanticDiagnosticsBuilderProgram,
|
|
createSemicolonClassElement: () => createSemicolonClassElement,
|
|
createSet: () => createSet,
|
|
createSetAccessor: () => createSetAccessor,
|
|
createShorthandPropertyAssignment: () => createShorthandPropertyAssignment,
|
|
createSolutionBuilder: () => createSolutionBuilder,
|
|
createSolutionBuilderHost: () => createSolutionBuilderHost,
|
|
createSolutionBuilderWithWatch: () => createSolutionBuilderWithWatch,
|
|
createSolutionBuilderWithWatchHost: () => createSolutionBuilderWithWatchHost,
|
|
createSortedArray: () => createSortedArray,
|
|
createSourceFile: () => createSourceFile,
|
|
createSourceMapGenerator: () => createSourceMapGenerator,
|
|
createSourceMapSource: () => createSourceMapSource,
|
|
createSpread: () => createSpread,
|
|
createSpreadAssignment: () => createSpreadAssignment,
|
|
createStatement: () => createStatement,
|
|
createStrictEquality: () => createStrictEquality,
|
|
createStrictInequality: () => createStrictInequality,
|
|
createStringLiteral: () => createStringLiteral,
|
|
createStringLiteralFromNode: () => createStringLiteralFromNode,
|
|
createSubtract: () => createSubtract,
|
|
createSuper: () => createSuper,
|
|
createSuperAccessVariableStatement: () => createSuperAccessVariableStatement,
|
|
createSwitch: () => createSwitch,
|
|
createSymbolTable: () => createSymbolTable,
|
|
createSymlinkCache: () => createSymlinkCache,
|
|
createSystemWatchFunctions: () => createSystemWatchFunctions,
|
|
createTaggedTemplate: () => createTaggedTemplate,
|
|
createTempVariable: () => createTempVariable,
|
|
createTemplateExpression: () => createTemplateExpression,
|
|
createTemplateHead: () => createTemplateHead,
|
|
createTemplateMiddle: () => createTemplateMiddle,
|
|
createTemplateSpan: () => createTemplateSpan,
|
|
createTemplateTail: () => createTemplateTail,
|
|
createTextChange: () => createTextChange,
|
|
createTextChangeFromStartLength: () => createTextChangeFromStartLength,
|
|
createTextChangeRange: () => createTextChangeRange,
|
|
createTextRangeFromNode: () => createTextRangeFromNode,
|
|
createTextRangeFromSpan: () => createTextRangeFromSpan,
|
|
createTextSpan: () => createTextSpan,
|
|
createTextSpanFromBounds: () => createTextSpanFromBounds,
|
|
createTextSpanFromNode: () => createTextSpanFromNode,
|
|
createTextSpanFromRange: () => createTextSpanFromRange,
|
|
createTextSpanFromStringLiteralLikeContent: () => createTextSpanFromStringLiteralLikeContent,
|
|
createTextWriter: () => createTextWriter,
|
|
createThis: () => createThis,
|
|
createThisTypeNode: () => createThisTypeNode,
|
|
createThrow: () => createThrow,
|
|
createToken: () => createToken,
|
|
createTokenRange: () => createTokenRange,
|
|
createTrue: () => createTrue,
|
|
createTry: () => createTry,
|
|
createTupleTypeNode: () => createTupleTypeNode,
|
|
createTypeAliasDeclaration: () => createTypeAliasDeclaration,
|
|
createTypeAssertion: () => createTypeAssertion,
|
|
createTypeChecker: () => createTypeChecker,
|
|
createTypeLiteralNode: () => createTypeLiteralNode,
|
|
createTypeOf: () => createTypeOf,
|
|
createTypeOperatorNode: () => createTypeOperatorNode,
|
|
createTypeParameterDeclaration: () => createTypeParameterDeclaration,
|
|
createTypePredicateNode: () => createTypePredicateNode,
|
|
createTypePredicateNodeWithModifier: () => createTypePredicateNodeWithModifier,
|
|
createTypeQueryNode: () => createTypeQueryNode,
|
|
createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
|
|
createTypeReferenceNode: () => createTypeReferenceNode,
|
|
createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
|
|
createUnionTypeNode: () => createUnionTypeNode,
|
|
createUniqueName: () => createUniqueName,
|
|
createUnparsedSourceFile: () => createUnparsedSourceFile,
|
|
createVariableDeclaration: () => createVariableDeclaration,
|
|
createVariableDeclarationList: () => createVariableDeclarationList,
|
|
createVariableStatement: () => createVariableStatement,
|
|
createVoid: () => createVoid,
|
|
createVoidZero: () => createVoidZero,
|
|
createWatchCompilerHost: () => createWatchCompilerHost2,
|
|
createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
|
|
createWatchCompilerHostOfFilesAndCompilerOptions: () => createWatchCompilerHostOfFilesAndCompilerOptions,
|
|
createWatchFactory: () => createWatchFactory,
|
|
createWatchHost: () => createWatchHost,
|
|
createWatchProgram: () => createWatchProgram,
|
|
createWatchStatusReporter: () => createWatchStatusReporter,
|
|
createWhile: () => createWhile,
|
|
createWith: () => createWith,
|
|
createWriteFileMeasuringIO: () => createWriteFileMeasuringIO,
|
|
createYield: () => createYield,
|
|
declarationNameToString: () => declarationNameToString,
|
|
decodeMappings: () => decodeMappings,
|
|
decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith,
|
|
decorateHelper: () => decorateHelper,
|
|
deduplicate: () => deduplicate,
|
|
defaultIncludeSpec: () => defaultIncludeSpec,
|
|
defaultInitCompilerOptions: () => defaultInitCompilerOptions,
|
|
defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
|
|
diagnosticCategoryName: () => diagnosticCategoryName,
|
|
diagnosticToString: () => diagnosticToString,
|
|
directoryProbablyExists: () => directoryProbablyExists,
|
|
directorySeparator: () => directorySeparator,
|
|
displayPart: () => displayPart,
|
|
displayPartsToString: () => displayPartsToString,
|
|
disposeEmitNodes: () => disposeEmitNodes,
|
|
documentSpansEqual: () => documentSpansEqual,
|
|
dumpTracingLegend: () => dumpTracingLegend,
|
|
elementAt: () => elementAt,
|
|
elideNodes: () => elideNodes,
|
|
emitComments: () => emitComments,
|
|
emitDetachedComments: () => emitDetachedComments,
|
|
emitFiles: () => emitFiles,
|
|
emitFilesAndReportErrors: () => emitFilesAndReportErrors,
|
|
emitFilesAndReportErrorsAndGetExitStatus: () => emitFilesAndReportErrorsAndGetExitStatus,
|
|
emitNewLineBeforeLeadingCommentOfPosition: () => emitNewLineBeforeLeadingCommentOfPosition,
|
|
emitNewLineBeforeLeadingComments: () => emitNewLineBeforeLeadingComments,
|
|
emitNewLineBeforeLeadingCommentsOfPosition: () => emitNewLineBeforeLeadingCommentsOfPosition,
|
|
emitSkippedWithNoDiagnostics: () => emitSkippedWithNoDiagnostics,
|
|
emitUsingBuildInfo: () => emitUsingBuildInfo,
|
|
emptyArray: () => emptyArray,
|
|
emptyFileSystemEntries: () => emptyFileSystemEntries,
|
|
emptyIterator: () => emptyIterator,
|
|
emptyMap: () => emptyMap,
|
|
emptyOptions: () => emptyOptions,
|
|
emptySet: () => emptySet,
|
|
endsWith: () => endsWith,
|
|
ensurePathIsNonModuleName: () => ensurePathIsNonModuleName,
|
|
ensureScriptKind: () => ensureScriptKind,
|
|
ensureTrailingDirectorySeparator: () => ensureTrailingDirectorySeparator,
|
|
entityNameToString: () => entityNameToString,
|
|
enumerateInsertsAndDeletes: () => enumerateInsertsAndDeletes,
|
|
equalOwnProperties: () => equalOwnProperties,
|
|
equateStringsCaseInsensitive: () => equateStringsCaseInsensitive,
|
|
equateStringsCaseSensitive: () => equateStringsCaseSensitive,
|
|
equateValues: () => equateValues,
|
|
escapeJsxAttributeString: () => escapeJsxAttributeString,
|
|
escapeLeadingUnderscores: () => escapeLeadingUnderscores,
|
|
escapeNonAsciiString: () => escapeNonAsciiString,
|
|
escapeSnippetText: () => escapeSnippetText,
|
|
escapeString: () => escapeString,
|
|
every: () => every,
|
|
expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
|
|
explainFiles: () => explainFiles,
|
|
explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat,
|
|
exportAssignmentIsAlias: () => exportAssignmentIsAlias,
|
|
exportStarHelper: () => exportStarHelper,
|
|
expressionResultIsUnused: () => expressionResultIsUnused,
|
|
extend: () => extend,
|
|
extendsHelper: () => extendsHelper,
|
|
extensionFromPath: () => extensionFromPath,
|
|
extensionIsTS: () => extensionIsTS,
|
|
externalHelpersModuleNameText: () => externalHelpersModuleNameText,
|
|
factory: () => factory,
|
|
fileExtensionIs: () => fileExtensionIs,
|
|
fileExtensionIsOneOf: () => fileExtensionIsOneOf,
|
|
fileIncludeReasonToDiagnostics: () => fileIncludeReasonToDiagnostics,
|
|
fill: () => fill,
|
|
filter: () => filter,
|
|
filterMutate: () => filterMutate,
|
|
filterSemanticDiagnostics: () => filterSemanticDiagnostics,
|
|
find: () => find,
|
|
findAncestor: () => findAncestor,
|
|
findBestPatternMatch: () => findBestPatternMatch,
|
|
findChildOfKind: () => findChildOfKind,
|
|
findConfigFile: () => findConfigFile,
|
|
findContainingList: () => findContainingList,
|
|
findDiagnosticForNode: () => findDiagnosticForNode,
|
|
findFirstNonJsxWhitespaceToken: () => findFirstNonJsxWhitespaceToken,
|
|
findIndex: () => findIndex,
|
|
findLast: () => findLast,
|
|
findLastIndex: () => findLastIndex,
|
|
findListItemInfo: () => findListItemInfo,
|
|
findMap: () => findMap,
|
|
findModifier: () => findModifier,
|
|
findNextToken: () => findNextToken,
|
|
findPackageJson: () => findPackageJson,
|
|
findPackageJsons: () => findPackageJsons,
|
|
findPrecedingMatchingToken: () => findPrecedingMatchingToken,
|
|
findPrecedingToken: () => findPrecedingToken,
|
|
findSuperStatementIndex: () => findSuperStatementIndex,
|
|
findTokenOnLeftOfPosition: () => findTokenOnLeftOfPosition,
|
|
findUseStrictPrologue: () => findUseStrictPrologue,
|
|
first: () => first,
|
|
firstDefined: () => firstDefined,
|
|
firstDefinedIterator: () => firstDefinedIterator,
|
|
firstOrOnly: () => firstOrOnly,
|
|
firstOrUndefined: () => firstOrUndefined,
|
|
fixupCompilerOptions: () => fixupCompilerOptions,
|
|
flatMap: () => flatMap,
|
|
flatMapIterator: () => flatMapIterator,
|
|
flatMapToMutable: () => flatMapToMutable,
|
|
flatten: () => flatten,
|
|
flattenDestructuringAssignment: () => flattenDestructuringAssignment,
|
|
flattenDestructuringBinding: () => flattenDestructuringBinding,
|
|
flattenDiagnosticMessageText: () => flattenDiagnosticMessageText,
|
|
forEach: () => forEach,
|
|
forEachAncestor: () => forEachAncestor,
|
|
forEachAncestorDirectory: () => forEachAncestorDirectory,
|
|
forEachChild: () => forEachChild,
|
|
forEachChildRecursively: () => forEachChildRecursively,
|
|
forEachEmittedFile: () => forEachEmittedFile,
|
|
forEachEnclosingBlockScopeContainer: () => forEachEnclosingBlockScopeContainer,
|
|
forEachEntry: () => forEachEntry,
|
|
forEachExternalModuleToImportFrom: () => forEachExternalModuleToImportFrom,
|
|
forEachImportClauseDeclaration: () => forEachImportClauseDeclaration,
|
|
forEachKey: () => forEachKey,
|
|
forEachLeadingCommentRange: () => forEachLeadingCommentRange,
|
|
forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
|
|
forEachResolvedProjectReference: () => forEachResolvedProjectReference,
|
|
forEachReturnStatement: () => forEachReturnStatement,
|
|
forEachRight: () => forEachRight,
|
|
forEachTrailingCommentRange: () => forEachTrailingCommentRange,
|
|
forEachUnique: () => forEachUnique,
|
|
forEachYieldExpression: () => forEachYieldExpression,
|
|
forSomeAncestorDirectory: () => forSomeAncestorDirectory,
|
|
formatColorAndReset: () => formatColorAndReset,
|
|
formatDiagnostic: () => formatDiagnostic,
|
|
formatDiagnostics: () => formatDiagnostics,
|
|
formatDiagnosticsWithColorAndContext: () => formatDiagnosticsWithColorAndContext,
|
|
formatGeneratedName: () => formatGeneratedName,
|
|
formatGeneratedNamePart: () => formatGeneratedNamePart,
|
|
formatLocation: () => formatLocation,
|
|
formatMessage: () => formatMessage,
|
|
formatStringFromArgs: () => formatStringFromArgs,
|
|
formatting: () => ts_formatting_exports,
|
|
fullTripleSlashAMDReferencePathRegEx: () => fullTripleSlashAMDReferencePathRegEx,
|
|
fullTripleSlashReferencePathRegEx: () => fullTripleSlashReferencePathRegEx,
|
|
generateDjb2Hash: () => generateDjb2Hash,
|
|
generateTSConfig: () => generateTSConfig,
|
|
generatorHelper: () => generatorHelper,
|
|
getAdjustedReferenceLocation: () => getAdjustedReferenceLocation,
|
|
getAdjustedRenameLocation: () => getAdjustedRenameLocation,
|
|
getAliasDeclarationFromName: () => getAliasDeclarationFromName,
|
|
getAllAccessorDeclarations: () => getAllAccessorDeclarations,
|
|
getAllDecoratorsOfClass: () => getAllDecoratorsOfClass,
|
|
getAllDecoratorsOfClassElement: () => getAllDecoratorsOfClassElement,
|
|
getAllJSDocTags: () => getAllJSDocTags,
|
|
getAllJSDocTagsOfKind: () => getAllJSDocTagsOfKind,
|
|
getAllKeys: () => getAllKeys,
|
|
getAllProjectOutputs: () => getAllProjectOutputs,
|
|
getAllSuperTypeNodes: () => getAllSuperTypeNodes,
|
|
getAllUnscopedEmitHelpers: () => getAllUnscopedEmitHelpers,
|
|
getAllowJSCompilerOption: () => getAllowJSCompilerOption,
|
|
getAllowSyntheticDefaultImports: () => getAllowSyntheticDefaultImports,
|
|
getAncestor: () => getAncestor,
|
|
getAnyExtensionFromPath: () => getAnyExtensionFromPath,
|
|
getAreDeclarationMapsEnabled: () => getAreDeclarationMapsEnabled,
|
|
getAssignedExpandoInitializer: () => getAssignedExpandoInitializer,
|
|
getAssignedName: () => getAssignedName,
|
|
getAssignmentDeclarationKind: () => getAssignmentDeclarationKind,
|
|
getAssignmentDeclarationPropertyAccessKind: () => getAssignmentDeclarationPropertyAccessKind,
|
|
getAssignmentTargetKind: () => getAssignmentTargetKind,
|
|
getAutomaticTypeDirectiveNames: () => getAutomaticTypeDirectiveNames,
|
|
getBaseFileName: () => getBaseFileName,
|
|
getBinaryOperatorPrecedence: () => getBinaryOperatorPrecedence,
|
|
getBuildInfo: () => getBuildInfo,
|
|
getBuildInfoFileVersionMap: () => getBuildInfoFileVersionMap,
|
|
getBuildInfoText: () => getBuildInfoText,
|
|
getBuildOrderFromAnyBuildOrder: () => getBuildOrderFromAnyBuildOrder,
|
|
getBuilderCreationParameters: () => getBuilderCreationParameters,
|
|
getBuilderFileEmit: () => getBuilderFileEmit,
|
|
getCheckFlags: () => getCheckFlags,
|
|
getClassExtendsHeritageElement: () => getClassExtendsHeritageElement,
|
|
getClassLikeDeclarationOfSymbol: () => getClassLikeDeclarationOfSymbol,
|
|
getCombinedLocalAndExportSymbolFlags: () => getCombinedLocalAndExportSymbolFlags,
|
|
getCombinedModifierFlags: () => getCombinedModifierFlags,
|
|
getCombinedNodeFlags: () => getCombinedNodeFlags,
|
|
getCombinedNodeFlagsAlwaysIncludeJSDoc: () => getCombinedNodeFlagsAlwaysIncludeJSDoc,
|
|
getCommentRange: () => getCommentRange,
|
|
getCommonSourceDirectory: () => getCommonSourceDirectory,
|
|
getCommonSourceDirectoryOfConfig: () => getCommonSourceDirectoryOfConfig,
|
|
getCompilerOptionValue: () => getCompilerOptionValue,
|
|
getCompilerOptionsDiffValue: () => getCompilerOptionsDiffValue,
|
|
getConfigFileParsingDiagnostics: () => getConfigFileParsingDiagnostics,
|
|
getConstantValue: () => getConstantValue,
|
|
getContainerNode: () => getContainerNode,
|
|
getContainingClass: () => getContainingClass,
|
|
getContainingClassStaticBlock: () => getContainingClassStaticBlock,
|
|
getContainingFunction: () => getContainingFunction,
|
|
getContainingFunctionDeclaration: () => getContainingFunctionDeclaration,
|
|
getContainingFunctionOrClassStaticBlock: () => getContainingFunctionOrClassStaticBlock,
|
|
getContainingNodeArray: () => getContainingNodeArray,
|
|
getContainingObjectLiteralElement: () => getContainingObjectLiteralElement,
|
|
getContextualTypeFromParent: () => getContextualTypeFromParent,
|
|
getContextualTypeFromParentOrAncestorTypeNode: () => getContextualTypeFromParentOrAncestorTypeNode,
|
|
getCurrentTime: () => getCurrentTime,
|
|
getDeclarationDiagnostics: () => getDeclarationDiagnostics,
|
|
getDeclarationEmitExtensionForPath: () => getDeclarationEmitExtensionForPath,
|
|
getDeclarationEmitOutputFilePath: () => getDeclarationEmitOutputFilePath,
|
|
getDeclarationEmitOutputFilePathWorker: () => getDeclarationEmitOutputFilePathWorker,
|
|
getDeclarationFromName: () => getDeclarationFromName,
|
|
getDeclarationModifierFlagsFromSymbol: () => getDeclarationModifierFlagsFromSymbol,
|
|
getDeclarationOfKind: () => getDeclarationOfKind,
|
|
getDeclarationsOfKind: () => getDeclarationsOfKind,
|
|
getDeclaredExpandoInitializer: () => getDeclaredExpandoInitializer,
|
|
getDecorators: () => getDecorators,
|
|
getDefaultCompilerOptions: () => getDefaultCompilerOptions2,
|
|
getDefaultFormatCodeSettings: () => getDefaultFormatCodeSettings,
|
|
getDefaultLibFileName: () => getDefaultLibFileName,
|
|
getDefaultLibFilePath: () => getDefaultLibFilePath,
|
|
getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
|
|
getDiagnosticText: () => getDiagnosticText,
|
|
getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
|
|
getDirectoryPath: () => getDirectoryPath,
|
|
getDocumentPositionMapper: () => getDocumentPositionMapper,
|
|
getESModuleInterop: () => getESModuleInterop,
|
|
getEditsForFileRename: () => getEditsForFileRename,
|
|
getEffectiveBaseTypeNode: () => getEffectiveBaseTypeNode,
|
|
getEffectiveConstraintOfTypeParameter: () => getEffectiveConstraintOfTypeParameter,
|
|
getEffectiveContainerForJSDocTemplateTag: () => getEffectiveContainerForJSDocTemplateTag,
|
|
getEffectiveImplementsTypeNodes: () => getEffectiveImplementsTypeNodes,
|
|
getEffectiveInitializer: () => getEffectiveInitializer,
|
|
getEffectiveJSDocHost: () => getEffectiveJSDocHost,
|
|
getEffectiveModifierFlags: () => getEffectiveModifierFlags,
|
|
getEffectiveModifierFlagsAlwaysIncludeJSDoc: () => getEffectiveModifierFlagsAlwaysIncludeJSDoc,
|
|
getEffectiveModifierFlagsNoCache: () => getEffectiveModifierFlagsNoCache,
|
|
getEffectiveReturnTypeNode: () => getEffectiveReturnTypeNode,
|
|
getEffectiveSetAccessorTypeAnnotationNode: () => getEffectiveSetAccessorTypeAnnotationNode,
|
|
getEffectiveTypeAnnotationNode: () => getEffectiveTypeAnnotationNode,
|
|
getEffectiveTypeParameterDeclarations: () => getEffectiveTypeParameterDeclarations,
|
|
getEffectiveTypeRoots: () => getEffectiveTypeRoots,
|
|
getElementOrPropertyAccessArgumentExpressionOrName: () => getElementOrPropertyAccessArgumentExpressionOrName,
|
|
getElementOrPropertyAccessName: () => getElementOrPropertyAccessName,
|
|
getElementsOfBindingOrAssignmentPattern: () => getElementsOfBindingOrAssignmentPattern,
|
|
getEmitDeclarations: () => getEmitDeclarations,
|
|
getEmitFlags: () => getEmitFlags,
|
|
getEmitHelpers: () => getEmitHelpers,
|
|
getEmitModuleDetectionKind: () => getEmitModuleDetectionKind,
|
|
getEmitModuleKind: () => getEmitModuleKind,
|
|
getEmitModuleResolutionKind: () => getEmitModuleResolutionKind,
|
|
getEmitScriptTarget: () => getEmitScriptTarget,
|
|
getEnclosingBlockScopeContainer: () => getEnclosingBlockScopeContainer,
|
|
getEncodedSemanticClassifications: () => getEncodedSemanticClassifications,
|
|
getEncodedSyntacticClassifications: () => getEncodedSyntacticClassifications,
|
|
getEndLinePosition: () => getEndLinePosition,
|
|
getEntityNameFromTypeNode: () => getEntityNameFromTypeNode,
|
|
getEntries: () => getEntries,
|
|
getEntrypointsFromPackageJsonInfo: () => getEntrypointsFromPackageJsonInfo,
|
|
getErrorCountForSummary: () => getErrorCountForSummary,
|
|
getErrorSpanForNode: () => getErrorSpanForNode,
|
|
getErrorSummaryText: () => getErrorSummaryText,
|
|
getEscapedTextOfIdentifierOrLiteral: () => getEscapedTextOfIdentifierOrLiteral,
|
|
getExpandoInitializer: () => getExpandoInitializer,
|
|
getExportAssignmentExpression: () => getExportAssignmentExpression,
|
|
getExportInfoMap: () => getExportInfoMap,
|
|
getExportNeedsImportStarHelper: () => getExportNeedsImportStarHelper,
|
|
getExpressionAssociativity: () => getExpressionAssociativity,
|
|
getExpressionPrecedence: () => getExpressionPrecedence,
|
|
getExternalHelpersModuleName: () => getExternalHelpersModuleName,
|
|
getExternalModuleImportEqualsDeclarationExpression: () => getExternalModuleImportEqualsDeclarationExpression,
|
|
getExternalModuleName: () => getExternalModuleName,
|
|
getExternalModuleNameFromDeclaration: () => getExternalModuleNameFromDeclaration,
|
|
getExternalModuleNameFromPath: () => getExternalModuleNameFromPath,
|
|
getExternalModuleNameLiteral: () => getExternalModuleNameLiteral,
|
|
getExternalModuleRequireArgument: () => getExternalModuleRequireArgument,
|
|
getFallbackOptions: () => getFallbackOptions,
|
|
getFileEmitOutput: () => getFileEmitOutput,
|
|
getFileMatcherPatterns: () => getFileMatcherPatterns,
|
|
getFileNamesFromConfigSpecs: () => getFileNamesFromConfigSpecs,
|
|
getFileWatcherEventKind: () => getFileWatcherEventKind,
|
|
getFilesInErrorForSummary: () => getFilesInErrorForSummary,
|
|
getFirstConstructorWithBody: () => getFirstConstructorWithBody,
|
|
getFirstIdentifier: () => getFirstIdentifier,
|
|
getFirstNonSpaceCharacterPosition: () => getFirstNonSpaceCharacterPosition,
|
|
getFirstProjectOutput: () => getFirstProjectOutput,
|
|
getFixableErrorSpanExpression: () => getFixableErrorSpanExpression,
|
|
getFormatCodeSettingsForWriting: () => getFormatCodeSettingsForWriting,
|
|
getFullWidth: () => getFullWidth,
|
|
getFunctionFlags: () => getFunctionFlags,
|
|
getGeneratedNameForNode: () => getGeneratedNameForNode,
|
|
getHeritageClause: () => getHeritageClause,
|
|
getHostSignatureFromJSDoc: () => getHostSignatureFromJSDoc,
|
|
getImmediatelyInvokedFunctionExpression: () => getImmediatelyInvokedFunctionExpression,
|
|
getImpliedNodeFormatForFile: () => getImpliedNodeFormatForFile,
|
|
getImpliedNodeFormatForFileWorker: () => getImpliedNodeFormatForFileWorker,
|
|
getImportNeedsImportDefaultHelper: () => getImportNeedsImportDefaultHelper,
|
|
getImportNeedsImportStarHelper: () => getImportNeedsImportStarHelper,
|
|
getIndentSize: () => getIndentSize,
|
|
getIndentString: () => getIndentString,
|
|
getInitializedVariables: () => getInitializedVariables,
|
|
getInitializerOfBinaryExpression: () => getInitializerOfBinaryExpression,
|
|
getInitializerOfBindingOrAssignmentElement: () => getInitializerOfBindingOrAssignmentElement,
|
|
getInterfaceBaseTypeNodes: () => getInterfaceBaseTypeNodes,
|
|
getInvokedExpression: () => getInvokedExpression,
|
|
getIterator: () => getIterator,
|
|
getJSDocAugmentsTag: () => getJSDocAugmentsTag,
|
|
getJSDocClassTag: () => getJSDocClassTag,
|
|
getJSDocCommentRanges: () => getJSDocCommentRanges,
|
|
getJSDocCommentsAndTags: () => getJSDocCommentsAndTags,
|
|
getJSDocDeprecatedTag: () => getJSDocDeprecatedTag,
|
|
getJSDocDeprecatedTagNoCache: () => getJSDocDeprecatedTagNoCache,
|
|
getJSDocEnumTag: () => getJSDocEnumTag,
|
|
getJSDocHost: () => getJSDocHost,
|
|
getJSDocImplementsTags: () => getJSDocImplementsTags,
|
|
getJSDocOverrideTagNoCache: () => getJSDocOverrideTagNoCache,
|
|
getJSDocParameterTags: () => getJSDocParameterTags,
|
|
getJSDocParameterTagsNoCache: () => getJSDocParameterTagsNoCache,
|
|
getJSDocPrivateTag: () => getJSDocPrivateTag,
|
|
getJSDocPrivateTagNoCache: () => getJSDocPrivateTagNoCache,
|
|
getJSDocProtectedTag: () => getJSDocProtectedTag,
|
|
getJSDocProtectedTagNoCache: () => getJSDocProtectedTagNoCache,
|
|
getJSDocPublicTag: () => getJSDocPublicTag,
|
|
getJSDocPublicTagNoCache: () => getJSDocPublicTagNoCache,
|
|
getJSDocReadonlyTag: () => getJSDocReadonlyTag,
|
|
getJSDocReadonlyTagNoCache: () => getJSDocReadonlyTagNoCache,
|
|
getJSDocReturnTag: () => getJSDocReturnTag,
|
|
getJSDocReturnType: () => getJSDocReturnType,
|
|
getJSDocRoot: () => getJSDocRoot,
|
|
getJSDocTags: () => getJSDocTags,
|
|
getJSDocTagsNoCache: () => getJSDocTagsNoCache,
|
|
getJSDocTemplateTag: () => getJSDocTemplateTag,
|
|
getJSDocThisTag: () => getJSDocThisTag,
|
|
getJSDocType: () => getJSDocType,
|
|
getJSDocTypeAliasName: () => getJSDocTypeAliasName,
|
|
getJSDocTypeAssertionType: () => getJSDocTypeAssertionType,
|
|
getJSDocTypeParameterDeclarations: () => getJSDocTypeParameterDeclarations,
|
|
getJSDocTypeParameterTags: () => getJSDocTypeParameterTags,
|
|
getJSDocTypeParameterTagsNoCache: () => getJSDocTypeParameterTagsNoCache,
|
|
getJSDocTypeTag: () => getJSDocTypeTag,
|
|
getJSXImplicitImportBase: () => getJSXImplicitImportBase,
|
|
getJSXRuntimeImport: () => getJSXRuntimeImport,
|
|
getJSXTransformEnabled: () => getJSXTransformEnabled,
|
|
getLanguageVariant: () => getLanguageVariant,
|
|
getLastChild: () => getLastChild,
|
|
getLeadingCommentRanges: () => getLeadingCommentRanges,
|
|
getLeadingCommentRangesOfNode: () => getLeadingCommentRangesOfNode,
|
|
getLeftmostAccessExpression: () => getLeftmostAccessExpression,
|
|
getLeftmostExpression: () => getLeftmostExpression,
|
|
getLineAndCharacterOfPosition: () => getLineAndCharacterOfPosition,
|
|
getLineInfo: () => getLineInfo,
|
|
getLineOfLocalPosition: () => getLineOfLocalPosition,
|
|
getLineOfLocalPositionFromLineMap: () => getLineOfLocalPositionFromLineMap,
|
|
getLineStartPositionForPosition: () => getLineStartPositionForPosition,
|
|
getLineStarts: () => getLineStarts,
|
|
getLinesBetweenPositionAndNextNonWhitespaceCharacter: () => getLinesBetweenPositionAndNextNonWhitespaceCharacter,
|
|
getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter: () => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter,
|
|
getLinesBetweenPositions: () => getLinesBetweenPositions,
|
|
getLinesBetweenRangeEndAndRangeStart: () => getLinesBetweenRangeEndAndRangeStart,
|
|
getLinesBetweenRangeEndPositions: () => getLinesBetweenRangeEndPositions,
|
|
getLiteralText: () => getLiteralText,
|
|
getLocalNameForExternalImport: () => getLocalNameForExternalImport,
|
|
getLocalSymbolForExportDefault: () => getLocalSymbolForExportDefault,
|
|
getLocaleSpecificMessage: () => getLocaleSpecificMessage,
|
|
getLocaleTimeString: () => getLocaleTimeString,
|
|
getMappedContextSpan: () => getMappedContextSpan,
|
|
getMappedDocumentSpan: () => getMappedDocumentSpan,
|
|
getMappedLocation: () => getMappedLocation,
|
|
getMatchedFileSpec: () => getMatchedFileSpec,
|
|
getMatchedIncludeSpec: () => getMatchedIncludeSpec,
|
|
getMeaningFromDeclaration: () => getMeaningFromDeclaration,
|
|
getMeaningFromLocation: () => getMeaningFromLocation,
|
|
getMembersOfDeclaration: () => getMembersOfDeclaration,
|
|
getModeForFileReference: () => getModeForFileReference,
|
|
getModeForResolutionAtIndex: () => getModeForResolutionAtIndex,
|
|
getModeForUsageLocation: () => getModeForUsageLocation,
|
|
getModifiedTime: () => getModifiedTime,
|
|
getModifiers: () => getModifiers,
|
|
getModuleInstanceState: () => getModuleInstanceState,
|
|
getModuleNameStringLiteralAt: () => getModuleNameStringLiteralAt,
|
|
getModuleSpecifierResolverHost: () => getModuleSpecifierResolverHost,
|
|
getMutableClone: () => getMutableClone,
|
|
getNameForExportedSymbol: () => getNameForExportedSymbol,
|
|
getNameFromIndexInfo: () => getNameFromIndexInfo,
|
|
getNameFromPropertyName: () => getNameFromPropertyName,
|
|
getNameOfAccessExpression: () => getNameOfAccessExpression,
|
|
getNameOfCompilerOptionValue: () => getNameOfCompilerOptionValue,
|
|
getNameOfDeclaration: () => getNameOfDeclaration,
|
|
getNameOfExpando: () => getNameOfExpando,
|
|
getNameOfJSDocTypedef: () => getNameOfJSDocTypedef,
|
|
getNameOrArgument: () => getNameOrArgument,
|
|
getNameTable: () => getNameTable,
|
|
getNamesForExportedSymbol: () => getNamesForExportedSymbol,
|
|
getNamespaceDeclarationNode: () => getNamespaceDeclarationNode,
|
|
getNewLineCharacter: () => getNewLineCharacter,
|
|
getNewLineKind: () => getNewLineKind,
|
|
getNewLineOrDefaultFromHost: () => getNewLineOrDefaultFromHost,
|
|
getNewTargetContainer: () => getNewTargetContainer,
|
|
getNextJSDocCommentLocation: () => getNextJSDocCommentLocation,
|
|
getNodeForGeneratedName: () => getNodeForGeneratedName,
|
|
getNodeId: () => getNodeId,
|
|
getNodeKind: () => getNodeKind,
|
|
getNodeMajorVersion: () => getNodeMajorVersion,
|
|
getNodeModifiers: () => getNodeModifiers,
|
|
getNodeModulePathParts: () => getNodeModulePathParts,
|
|
getNonAssignedNameOfDeclaration: () => getNonAssignedNameOfDeclaration,
|
|
getNonAssignmentOperatorForCompoundAssignment: () => getNonAssignmentOperatorForCompoundAssignment,
|
|
getNonAugmentationDeclaration: () => getNonAugmentationDeclaration,
|
|
getNonDecoratorTokenPosOfNode: () => getNonDecoratorTokenPosOfNode,
|
|
getNormalizedAbsolutePath: () => getNormalizedAbsolutePath,
|
|
getNormalizedAbsolutePathWithoutRoot: () => getNormalizedAbsolutePathWithoutRoot,
|
|
getNormalizedPathComponents: () => getNormalizedPathComponents,
|
|
getObjectFlags: () => getObjectFlags,
|
|
getOperator: () => getOperator,
|
|
getOperatorAssociativity: () => getOperatorAssociativity,
|
|
getOperatorPrecedence: () => getOperatorPrecedence,
|
|
getOptionFromName: () => getOptionFromName,
|
|
getOptionsNameMap: () => getOptionsNameMap,
|
|
getOrCreateEmitNode: () => getOrCreateEmitNode,
|
|
getOrCreateExternalHelpersModuleNameIfNeeded: () => getOrCreateExternalHelpersModuleNameIfNeeded,
|
|
getOrUpdate: () => getOrUpdate,
|
|
getOriginalNode: () => getOriginalNode,
|
|
getOriginalNodeId: () => getOriginalNodeId,
|
|
getOriginalSourceFile: () => getOriginalSourceFile,
|
|
getOutputDeclarationFileName: () => getOutputDeclarationFileName,
|
|
getOutputExtension: () => getOutputExtension,
|
|
getOutputFileNames: () => getOutputFileNames,
|
|
getOutputPathsFor: () => getOutputPathsFor,
|
|
getOutputPathsForBundle: () => getOutputPathsForBundle,
|
|
getOwnEmitOutputFilePath: () => getOwnEmitOutputFilePath,
|
|
getOwnKeys: () => getOwnKeys,
|
|
getOwnValues: () => getOwnValues,
|
|
getPackageJsonInfo: () => getPackageJsonInfo,
|
|
getPackageJsonTypesVersionsPaths: () => getPackageJsonTypesVersionsPaths,
|
|
getPackageJsonsVisibleToFile: () => getPackageJsonsVisibleToFile,
|
|
getPackageNameFromTypesPackageName: () => getPackageNameFromTypesPackageName,
|
|
getPackageScopeForPath: () => getPackageScopeForPath,
|
|
getParameterSymbolFromJSDoc: () => getParameterSymbolFromJSDoc,
|
|
getParameterTypeNode: () => getParameterTypeNode,
|
|
getParentNodeInSpan: () => getParentNodeInSpan,
|
|
getParseTreeNode: () => getParseTreeNode,
|
|
getParsedCommandLineOfConfigFile: () => getParsedCommandLineOfConfigFile,
|
|
getPathComponents: () => getPathComponents,
|
|
getPathComponentsRelativeTo: () => getPathComponentsRelativeTo,
|
|
getPathFromPathComponents: () => getPathFromPathComponents,
|
|
getPathUpdater: () => getPathUpdater,
|
|
getPathsBasePath: () => getPathsBasePath,
|
|
getPatternFromSpec: () => getPatternFromSpec,
|
|
getPendingEmitKind: () => getPendingEmitKind,
|
|
getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter,
|
|
getPossibleGenericSignatures: () => getPossibleGenericSignatures,
|
|
getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension,
|
|
getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo,
|
|
getPreEmitDiagnostics: () => getPreEmitDiagnostics,
|
|
getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition,
|
|
getProperties: () => getProperties,
|
|
getProperty: () => getProperty,
|
|
getPropertyArrayElementValue: () => getPropertyArrayElementValue,
|
|
getPropertyAssignment: () => getPropertyAssignment,
|
|
getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
|
|
getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
|
|
getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
|
|
getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
|
|
getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
|
|
getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
|
|
getQuoteFromPreference: () => getQuoteFromPreference,
|
|
getQuotePreference: () => getQuotePreference,
|
|
getRangesWhere: () => getRangesWhere,
|
|
getRefactorContextSpan: () => getRefactorContextSpan,
|
|
getReferencedFileLocation: () => getReferencedFileLocation,
|
|
getRegexFromPattern: () => getRegexFromPattern,
|
|
getRegularExpressionForWildcard: () => getRegularExpressionForWildcard,
|
|
getRegularExpressionsForWildcards: () => getRegularExpressionsForWildcards,
|
|
getRelativePathFromDirectory: () => getRelativePathFromDirectory,
|
|
getRelativePathFromFile: () => getRelativePathFromFile,
|
|
getRelativePathToDirectoryOrUrl: () => getRelativePathToDirectoryOrUrl,
|
|
getRenameLocation: () => getRenameLocation,
|
|
getReplacementSpanForContextToken: () => getReplacementSpanForContextToken,
|
|
getResolutionDiagnostic: () => getResolutionDiagnostic,
|
|
getResolutionMode: () => getResolutionMode,
|
|
getResolutionModeOverrideForClause: () => getResolutionModeOverrideForClause,
|
|
getResolutionName: () => getResolutionName,
|
|
getResolvedExternalModuleName: () => getResolvedExternalModuleName,
|
|
getResolvedModule: () => getResolvedModule,
|
|
getResolvedTypeReferenceDirective: () => getResolvedTypeReferenceDirective,
|
|
getRestIndicatorOfBindingOrAssignmentElement: () => getRestIndicatorOfBindingOrAssignmentElement,
|
|
getRestParameterElementType: () => getRestParameterElementType,
|
|
getRightMostAssignedExpression: () => getRightMostAssignedExpression,
|
|
getRootDeclaration: () => getRootDeclaration,
|
|
getRootLength: () => getRootLength,
|
|
getScriptKind: () => getScriptKind,
|
|
getScriptKindFromFileName: () => getScriptKindFromFileName,
|
|
getScriptTargetFeatures: () => getScriptTargetFeatures,
|
|
getSelectedEffectiveModifierFlags: () => getSelectedEffectiveModifierFlags,
|
|
getSelectedSyntacticModifierFlags: () => getSelectedSyntacticModifierFlags,
|
|
getSemanticClassifications: () => getSemanticClassifications,
|
|
getSemanticJsxChildren: () => getSemanticJsxChildren,
|
|
getSetAccessorTypeAnnotationNode: () => getSetAccessorTypeAnnotationNode,
|
|
getSetAccessorValueParameter: () => getSetAccessorValueParameter,
|
|
getSetExternalModuleIndicator: () => getSetExternalModuleIndicator,
|
|
getShebang: () => getShebang,
|
|
getSingleInitializerOfVariableStatementOrPropertyDeclaration: () => getSingleInitializerOfVariableStatementOrPropertyDeclaration,
|
|
getSingleVariableOfVariableStatement: () => getSingleVariableOfVariableStatement,
|
|
getSnapshotText: () => getSnapshotText,
|
|
getSnippetElement: () => getSnippetElement,
|
|
getSourceFileOfModule: () => getSourceFileOfModule,
|
|
getSourceFileOfNode: () => getSourceFileOfNode,
|
|
getSourceFilePathInNewDir: () => getSourceFilePathInNewDir,
|
|
getSourceFilePathInNewDirWorker: () => getSourceFilePathInNewDirWorker,
|
|
getSourceFileVersionAsHashFromText: () => getSourceFileVersionAsHashFromText,
|
|
getSourceFilesToEmit: () => getSourceFilesToEmit,
|
|
getSourceMapRange: () => getSourceMapRange,
|
|
getSourceMapper: () => getSourceMapper,
|
|
getSourceTextOfNodeFromSourceFile: () => getSourceTextOfNodeFromSourceFile,
|
|
getSpanOfTokenAtPosition: () => getSpanOfTokenAtPosition,
|
|
getSpellingSuggestion: () => getSpellingSuggestion,
|
|
getStartPositionOfLine: () => getStartPositionOfLine,
|
|
getStartPositionOfRange: () => getStartPositionOfRange,
|
|
getStartsOnNewLine: () => getStartsOnNewLine,
|
|
getStaticPropertiesAndClassStaticBlock: () => getStaticPropertiesAndClassStaticBlock,
|
|
getStrictOptionValue: () => getStrictOptionValue,
|
|
getStringComparer: () => getStringComparer,
|
|
getSuperCallFromStatement: () => getSuperCallFromStatement,
|
|
getSuperContainer: () => getSuperContainer,
|
|
getSupportedCodeFixes: () => getSupportedCodeFixes,
|
|
getSupportedExtensions: () => getSupportedExtensions,
|
|
getSupportedExtensionsWithJsonIfResolveJsonModule: () => getSupportedExtensionsWithJsonIfResolveJsonModule,
|
|
getSwitchedType: () => getSwitchedType,
|
|
getSymbolId: () => getSymbolId,
|
|
getSymbolNameForPrivateIdentifier: () => getSymbolNameForPrivateIdentifier,
|
|
getSymbolTarget: () => getSymbolTarget,
|
|
getSyntacticClassifications: () => getSyntacticClassifications,
|
|
getSyntacticModifierFlags: () => getSyntacticModifierFlags,
|
|
getSyntacticModifierFlagsNoCache: () => getSyntacticModifierFlagsNoCache,
|
|
getSynthesizedDeepClone: () => getSynthesizedDeepClone,
|
|
getSynthesizedDeepCloneWithReplacements: () => getSynthesizedDeepCloneWithReplacements,
|
|
getSynthesizedDeepClones: () => getSynthesizedDeepClones,
|
|
getSynthesizedDeepClonesWithReplacements: () => getSynthesizedDeepClonesWithReplacements,
|
|
getSyntheticLeadingComments: () => getSyntheticLeadingComments,
|
|
getSyntheticTrailingComments: () => getSyntheticTrailingComments,
|
|
getTargetLabel: () => getTargetLabel,
|
|
getTargetOfBindingOrAssignmentElement: () => getTargetOfBindingOrAssignmentElement,
|
|
getTemporaryModuleResolutionState: () => getTemporaryModuleResolutionState,
|
|
getTextOfConstantValue: () => getTextOfConstantValue,
|
|
getTextOfIdentifierOrLiteral: () => getTextOfIdentifierOrLiteral,
|
|
getTextOfJSDocComment: () => getTextOfJSDocComment,
|
|
getTextOfNode: () => getTextOfNode,
|
|
getTextOfNodeFromSourceText: () => getTextOfNodeFromSourceText,
|
|
getTextOfPropertyName: () => getTextOfPropertyName,
|
|
getThisContainer: () => getThisContainer,
|
|
getThisParameter: () => getThisParameter,
|
|
getTokenAtPosition: () => getTokenAtPosition,
|
|
getTokenPosOfNode: () => getTokenPosOfNode,
|
|
getTokenSourceMapRange: () => getTokenSourceMapRange,
|
|
getTouchingPropertyName: () => getTouchingPropertyName,
|
|
getTouchingToken: () => getTouchingToken,
|
|
getTrailingCommentRanges: () => getTrailingCommentRanges,
|
|
getTrailingSemicolonDeferringWriter: () => getTrailingSemicolonDeferringWriter,
|
|
getTransformFlagsSubtreeExclusions: () => getTransformFlagsSubtreeExclusions,
|
|
getTransformers: () => getTransformers,
|
|
getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath,
|
|
getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression,
|
|
getTsConfigPropArray: () => getTsConfigPropArray,
|
|
getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue,
|
|
getTypeAnnotationNode: () => getTypeAnnotationNode,
|
|
getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList,
|
|
getTypeKeywordOfTypeOnlyImport: () => getTypeKeywordOfTypeOnlyImport,
|
|
getTypeNode: () => getTypeNode,
|
|
getTypeNodeIfAccessible: () => getTypeNodeIfAccessible,
|
|
getTypeParameterFromJsDoc: () => getTypeParameterFromJsDoc,
|
|
getTypeParameterOwner: () => getTypeParameterOwner,
|
|
getTypesPackageName: () => getTypesPackageName,
|
|
getUILocale: () => getUILocale,
|
|
getUniqueName: () => getUniqueName,
|
|
getUniqueSymbolId: () => getUniqueSymbolId,
|
|
getUseDefineForClassFields: () => getUseDefineForClassFields,
|
|
getWatchErrorSummaryDiagnosticMessage: () => getWatchErrorSummaryDiagnosticMessage,
|
|
getWatchFactory: () => getWatchFactory,
|
|
group: () => group,
|
|
guessIndentation: () => guessIndentation,
|
|
handleNoEmitOptions: () => handleNoEmitOptions,
|
|
hasAbstractModifier: () => hasAbstractModifier,
|
|
hasAccessorModifier: () => hasAccessorModifier,
|
|
hasAmbientModifier: () => hasAmbientModifier,
|
|
hasChangesInResolutions: () => hasChangesInResolutions,
|
|
hasChildOfKind: () => hasChildOfKind,
|
|
hasContextSensitiveParameters: () => hasContextSensitiveParameters,
|
|
hasDecorators: () => hasDecorators,
|
|
hasDocComment: () => hasDocComment,
|
|
hasDynamicName: () => hasDynamicName,
|
|
hasEffectiveModifier: () => hasEffectiveModifier,
|
|
hasEffectiveModifiers: () => hasEffectiveModifiers,
|
|
hasEffectiveReadonlyModifier: () => hasEffectiveReadonlyModifier,
|
|
hasExtension: () => hasExtension,
|
|
hasIndexSignature: () => hasIndexSignature,
|
|
hasInitializer: () => hasInitializer,
|
|
hasInvalidEscape: () => hasInvalidEscape,
|
|
hasJSDocNodes: () => hasJSDocNodes,
|
|
hasJSDocParameterTags: () => hasJSDocParameterTags,
|
|
hasJSFileExtension: () => hasJSFileExtension,
|
|
hasJsonModuleEmitEnabled: () => hasJsonModuleEmitEnabled,
|
|
hasOnlyExpressionInitializer: () => hasOnlyExpressionInitializer,
|
|
hasOverrideModifier: () => hasOverrideModifier,
|
|
hasPossibleExternalModuleReference: () => hasPossibleExternalModuleReference,
|
|
hasProperty: () => hasProperty,
|
|
hasPropertyAccessExpressionWithName: () => hasPropertyAccessExpressionWithName,
|
|
hasQuestionToken: () => hasQuestionToken,
|
|
hasRecordedExternalHelpers: () => hasRecordedExternalHelpers,
|
|
hasRestParameter: () => hasRestParameter,
|
|
hasScopeMarker: () => hasScopeMarker,
|
|
hasStaticModifier: () => hasStaticModifier,
|
|
hasSyntacticModifier: () => hasSyntacticModifier,
|
|
hasSyntacticModifiers: () => hasSyntacticModifiers,
|
|
hasTSFileExtension: () => hasTSFileExtension,
|
|
hasTrailingDirectorySeparator: () => hasTrailingDirectorySeparator,
|
|
hasType: () => hasType,
|
|
hasTypeArguments: () => hasTypeArguments,
|
|
hasZeroOrOneAsteriskCharacter: () => hasZeroOrOneAsteriskCharacter,
|
|
helperString: () => helperString,
|
|
hostGetCanonicalFileName: () => hostGetCanonicalFileName,
|
|
hostUsesCaseSensitiveFileNames: () => hostUsesCaseSensitiveFileNames,
|
|
idText: () => idText,
|
|
identifierIsThisKeyword: () => identifierIsThisKeyword,
|
|
identity: () => identity,
|
|
identitySourceMapConsumer: () => identitySourceMapConsumer,
|
|
ignoreSourceNewlines: () => ignoreSourceNewlines,
|
|
ignoredPaths: () => ignoredPaths,
|
|
importDefaultHelper: () => importDefaultHelper,
|
|
importFromModuleSpecifier: () => importFromModuleSpecifier,
|
|
importStarHelper: () => importStarHelper,
|
|
indexOfAnyCharCode: () => indexOfAnyCharCode,
|
|
indexOfNode: () => indexOfNode,
|
|
indicesOf: () => indicesOf,
|
|
inferredTypesContainingFile: () => inferredTypesContainingFile,
|
|
insertImports: () => insertImports,
|
|
insertLeadingStatement: () => insertLeadingStatement,
|
|
insertSorted: () => insertSorted,
|
|
insertStatementAfterCustomPrologue: () => insertStatementAfterCustomPrologue,
|
|
insertStatementAfterStandardPrologue: () => insertStatementAfterStandardPrologue,
|
|
insertStatementsAfterCustomPrologue: () => insertStatementsAfterCustomPrologue,
|
|
insertStatementsAfterStandardPrologue: () => insertStatementsAfterStandardPrologue,
|
|
intersperse: () => intersperse,
|
|
introducesArgumentsExoticObject: () => introducesArgumentsExoticObject,
|
|
inverseJsxOptionMap: () => inverseJsxOptionMap,
|
|
isAbstractConstructorSymbol: () => isAbstractConstructorSymbol,
|
|
isAbstractModifier: () => isAbstractModifier,
|
|
isAccessExpression: () => isAccessExpression,
|
|
isAccessibilityModifier: () => isAccessibilityModifier,
|
|
isAccessor: () => isAccessor,
|
|
isAccessorModifier: () => isAccessorModifier,
|
|
isAliasSymbolDeclaration: () => isAliasSymbolDeclaration,
|
|
isAliasableExpression: () => isAliasableExpression,
|
|
isAmbientModule: () => isAmbientModule,
|
|
isAmbientPropertyDeclaration: () => isAmbientPropertyDeclaration,
|
|
isAnyDirectorySeparator: () => isAnyDirectorySeparator,
|
|
isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire,
|
|
isAnyImportOrReExport: () => isAnyImportOrReExport,
|
|
isAnyImportSyntax: () => isAnyImportSyntax,
|
|
isAnySupportedFileExtension: () => isAnySupportedFileExtension,
|
|
isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey,
|
|
isArgumentExpressionOfElementAccess: () => isArgumentExpressionOfElementAccess,
|
|
isArray: () => isArray,
|
|
isArrayBindingElement: () => isArrayBindingElement,
|
|
isArrayBindingOrAssignmentPattern: () => isArrayBindingOrAssignmentPattern,
|
|
isArrayBindingPattern: () => isArrayBindingPattern,
|
|
isArrayLiteralExpression: () => isArrayLiteralExpression,
|
|
isArrayLiteralOrObjectLiteralDestructuringPattern: () => isArrayLiteralOrObjectLiteralDestructuringPattern,
|
|
isArrayTypeNode: () => isArrayTypeNode,
|
|
isArrowFunction: () => isArrowFunction,
|
|
isAsExpression: () => isAsExpression,
|
|
isAssertClause: () => isAssertClause,
|
|
isAssertEntry: () => isAssertEntry,
|
|
isAssertionExpression: () => isAssertionExpression,
|
|
isAssertionKey: () => isAssertionKey,
|
|
isAssertsKeyword: () => isAssertsKeyword,
|
|
isAssignmentDeclaration: () => isAssignmentDeclaration,
|
|
isAssignmentExpression: () => isAssignmentExpression,
|
|
isAssignmentOperator: () => isAssignmentOperator,
|
|
isAssignmentPattern: () => isAssignmentPattern,
|
|
isAssignmentTarget: () => isAssignmentTarget,
|
|
isAsteriskToken: () => isAsteriskToken,
|
|
isAsyncFunction: () => isAsyncFunction,
|
|
isAsyncModifier: () => isAsyncModifier,
|
|
isAutoAccessorPropertyDeclaration: () => isAutoAccessorPropertyDeclaration,
|
|
isAwaitExpression: () => isAwaitExpression,
|
|
isAwaitKeyword: () => isAwaitKeyword,
|
|
isBigIntLiteral: () => isBigIntLiteral,
|
|
isBinaryExpression: () => isBinaryExpression,
|
|
isBinaryOperatorToken: () => isBinaryOperatorToken,
|
|
isBindableObjectDefinePropertyCall: () => isBindableObjectDefinePropertyCall,
|
|
isBindableStaticAccessExpression: () => isBindableStaticAccessExpression,
|
|
isBindableStaticElementAccessExpression: () => isBindableStaticElementAccessExpression,
|
|
isBindableStaticNameExpression: () => isBindableStaticNameExpression,
|
|
isBindingElement: () => isBindingElement,
|
|
isBindingName: () => isBindingName,
|
|
isBindingOrAssignmentPattern: () => isBindingOrAssignmentPattern,
|
|
isBindingPattern: () => isBindingPattern,
|
|
isBlock: () => isBlock,
|
|
isBlockOrCatchScoped: () => isBlockOrCatchScoped,
|
|
isBlockScope: () => isBlockScope,
|
|
isBlockScopedContainerTopLevel: () => isBlockScopedContainerTopLevel,
|
|
isBooleanLiteral: () => isBooleanLiteral,
|
|
isBreakOrContinueStatement: () => isBreakOrContinueStatement,
|
|
isBreakStatement: () => isBreakStatement,
|
|
isBuildInfoFile: () => isBuildInfoFile,
|
|
isBuilderProgram: () => isBuilderProgram2,
|
|
isBundle: () => isBundle,
|
|
isBundleFileTextLike: () => isBundleFileTextLike,
|
|
isCallChain: () => isCallChain,
|
|
isCallExpression: () => isCallExpression,
|
|
isCallExpressionTarget: () => isCallExpressionTarget,
|
|
isCallLikeExpression: () => isCallLikeExpression,
|
|
isCallOrNewExpression: () => isCallOrNewExpression,
|
|
isCallOrNewExpressionTarget: () => isCallOrNewExpressionTarget,
|
|
isCallSignatureDeclaration: () => isCallSignatureDeclaration,
|
|
isCallToHelper: () => isCallToHelper,
|
|
isCaseBlock: () => isCaseBlock,
|
|
isCaseClause: () => isCaseClause,
|
|
isCaseOrDefaultClause: () => isCaseOrDefaultClause,
|
|
isCatchClause: () => isCatchClause,
|
|
isCatchClauseVariableDeclaration: () => isCatchClauseVariableDeclaration,
|
|
isCatchClauseVariableDeclarationOrBindingElement: () => isCatchClauseVariableDeclarationOrBindingElement,
|
|
isCheckJsEnabledForFile: () => isCheckJsEnabledForFile,
|
|
isChildOfNodeWithKind: () => isChildOfNodeWithKind,
|
|
isCircularBuildOrder: () => isCircularBuildOrder,
|
|
isClassDeclaration: () => isClassDeclaration,
|
|
isClassElement: () => isClassElement,
|
|
isClassExpression: () => isClassExpression,
|
|
isClassLike: () => isClassLike,
|
|
isClassMemberModifier: () => isClassMemberModifier,
|
|
isClassOrTypeElement: () => isClassOrTypeElement,
|
|
isClassStaticBlockDeclaration: () => isClassStaticBlockDeclaration,
|
|
isCollapsedRange: () => isCollapsedRange,
|
|
isColonToken: () => isColonToken,
|
|
isCommaListExpression: () => isCommaListExpression,
|
|
isCommaSequence: () => isCommaSequence,
|
|
isCommaToken: () => isCommaToken,
|
|
isComment: () => isComment,
|
|
isCommonJsExportPropertyAssignment: () => isCommonJsExportPropertyAssignment,
|
|
isCommonJsExportedExpression: () => isCommonJsExportedExpression,
|
|
isCompoundAssignment: () => isCompoundAssignment,
|
|
isComputedNonLiteralName: () => isComputedNonLiteralName,
|
|
isComputedPropertyName: () => isComputedPropertyName,
|
|
isConciseBody: () => isConciseBody,
|
|
isConditionalExpression: () => isConditionalExpression,
|
|
isConditionalTypeNode: () => isConditionalTypeNode,
|
|
isConstTypeReference: () => isConstTypeReference,
|
|
isConstructSignatureDeclaration: () => isConstructSignatureDeclaration,
|
|
isConstructorDeclaration: () => isConstructorDeclaration,
|
|
isConstructorTypeNode: () => isConstructorTypeNode,
|
|
isContextualKeyword: () => isContextualKeyword,
|
|
isContinueStatement: () => isContinueStatement,
|
|
isCustomPrologue: () => isCustomPrologue,
|
|
isDebuggerStatement: () => isDebuggerStatement,
|
|
isDeclaration: () => isDeclaration,
|
|
isDeclarationBindingElement: () => isDeclarationBindingElement,
|
|
isDeclarationFileName: () => isDeclarationFileName,
|
|
isDeclarationName: () => isDeclarationName,
|
|
isDeclarationNameOfEnumOrNamespace: () => isDeclarationNameOfEnumOrNamespace,
|
|
isDeclarationReadonly: () => isDeclarationReadonly,
|
|
isDeclarationStatement: () => isDeclarationStatement,
|
|
isDeclarationWithTypeParameterChildren: () => isDeclarationWithTypeParameterChildren,
|
|
isDeclarationWithTypeParameters: () => isDeclarationWithTypeParameters,
|
|
isDecorator: () => isDecorator,
|
|
isDecoratorTarget: () => isDecoratorTarget,
|
|
isDefaultClause: () => isDefaultClause,
|
|
isDefaultImport: () => isDefaultImport,
|
|
isDefaultedExpandoInitializer: () => isDefaultedExpandoInitializer,
|
|
isDeleteExpression: () => isDeleteExpression,
|
|
isDeleteTarget: () => isDeleteTarget,
|
|
isDeprecatedDeclaration: () => isDeprecatedDeclaration,
|
|
isDestructuringAssignment: () => isDestructuringAssignment,
|
|
isDiagnosticWithLocation: () => isDiagnosticWithLocation,
|
|
isDiskPathRoot: () => isDiskPathRoot,
|
|
isDoStatement: () => isDoStatement,
|
|
isDotDotDotToken: () => isDotDotDotToken,
|
|
isDottedName: () => isDottedName,
|
|
isDynamicName: () => isDynamicName,
|
|
isESSymbolIdentifier: () => isESSymbolIdentifier,
|
|
isEffectiveExternalModule: () => isEffectiveExternalModule,
|
|
isEffectiveModuleDeclaration: () => isEffectiveModuleDeclaration,
|
|
isEffectiveStrictModeSourceFile: () => isEffectiveStrictModeSourceFile,
|
|
isElementAccessChain: () => isElementAccessChain,
|
|
isElementAccessExpression: () => isElementAccessExpression,
|
|
isEmittedFileOfProgram: () => isEmittedFileOfProgram,
|
|
isEmptyArrayLiteral: () => isEmptyArrayLiteral,
|
|
isEmptyBindingElement: () => isEmptyBindingElement,
|
|
isEmptyBindingPattern: () => isEmptyBindingPattern,
|
|
isEmptyObjectLiteral: () => isEmptyObjectLiteral,
|
|
isEmptyStatement: () => isEmptyStatement,
|
|
isEndOfDeclarationMarker: () => isEndOfDeclarationMarker,
|
|
isEntityName: () => isEntityName,
|
|
isEntityNameExpression: () => isEntityNameExpression,
|
|
isEnumConst: () => isEnumConst,
|
|
isEnumDeclaration: () => isEnumDeclaration,
|
|
isEnumMember: () => isEnumMember,
|
|
isEqualityOperatorKind: () => isEqualityOperatorKind,
|
|
isEqualsGreaterThanToken: () => isEqualsGreaterThanToken,
|
|
isExclamationToken: () => isExclamationToken,
|
|
isExcludedFile: () => isExcludedFile,
|
|
isExclusivelyTypeOnlyImportOrExport: () => isExclusivelyTypeOnlyImportOrExport,
|
|
isExportAssignment: () => isExportAssignment,
|
|
isExportDeclaration: () => isExportDeclaration,
|
|
isExportModifier: () => isExportModifier,
|
|
isExportName: () => isExportName,
|
|
isExportNamespaceAsDefaultDeclaration: () => isExportNamespaceAsDefaultDeclaration,
|
|
isExportSpecifier: () => isExportSpecifier,
|
|
isExportsIdentifier: () => isExportsIdentifier,
|
|
isExportsOrModuleExportsOrAlias: () => isExportsOrModuleExportsOrAlias,
|
|
isExpression: () => isExpression,
|
|
isExpressionNode: () => isExpressionNode,
|
|
isExpressionOfExternalModuleImportEqualsDeclaration: () => isExpressionOfExternalModuleImportEqualsDeclaration,
|
|
isExpressionOfOptionalChainRoot: () => isExpressionOfOptionalChainRoot,
|
|
isExpressionStatement: () => isExpressionStatement,
|
|
isExpressionWithTypeArguments: () => isExpressionWithTypeArguments,
|
|
isExpressionWithTypeArgumentsInClassExtendsClause: () => isExpressionWithTypeArgumentsInClassExtendsClause,
|
|
isExternalModule: () => isExternalModule,
|
|
isExternalModuleAugmentation: () => isExternalModuleAugmentation,
|
|
isExternalModuleImportEqualsDeclaration: () => isExternalModuleImportEqualsDeclaration,
|
|
isExternalModuleIndicator: () => isExternalModuleIndicator,
|
|
isExternalModuleNameRelative: () => isExternalModuleNameRelative,
|
|
isExternalModuleReference: () => isExternalModuleReference,
|
|
isExternalModuleSymbol: () => isExternalModuleSymbol,
|
|
isExternalOrCommonJsModule: () => isExternalOrCommonJsModule,
|
|
isFileLevelUniqueName: () => isFileLevelUniqueName,
|
|
isFileProbablyExternalModule: () => isFileProbablyExternalModule,
|
|
isFirstDeclarationOfSymbolParameter: () => isFirstDeclarationOfSymbolParameter,
|
|
isFixablePromiseHandler: () => isFixablePromiseHandler,
|
|
isForInOrOfStatement: () => isForInOrOfStatement,
|
|
isForInStatement: () => isForInStatement,
|
|
isForInitializer: () => isForInitializer,
|
|
isForOfStatement: () => isForOfStatement,
|
|
isForStatement: () => isForStatement,
|
|
isFunctionBlock: () => isFunctionBlock,
|
|
isFunctionBody: () => isFunctionBody,
|
|
isFunctionDeclaration: () => isFunctionDeclaration,
|
|
isFunctionExpression: () => isFunctionExpression,
|
|
isFunctionExpressionOrArrowFunction: () => isFunctionExpressionOrArrowFunction,
|
|
isFunctionLike: () => isFunctionLike,
|
|
isFunctionLikeDeclaration: () => isFunctionLikeDeclaration,
|
|
isFunctionLikeKind: () => isFunctionLikeKind,
|
|
isFunctionLikeOrClassStaticBlockDeclaration: () => isFunctionLikeOrClassStaticBlockDeclaration,
|
|
isFunctionOrConstructorTypeNode: () => isFunctionOrConstructorTypeNode,
|
|
isFunctionOrModuleBlock: () => isFunctionOrModuleBlock,
|
|
isFunctionSymbol: () => isFunctionSymbol,
|
|
isFunctionTypeNode: () => isFunctionTypeNode,
|
|
isFutureReservedKeyword: () => isFutureReservedKeyword,
|
|
isGeneratedIdentifier: () => isGeneratedIdentifier,
|
|
isGeneratedPrivateIdentifier: () => isGeneratedPrivateIdentifier,
|
|
isGetAccessor: () => isGetAccessor,
|
|
isGetAccessorDeclaration: () => isGetAccessorDeclaration,
|
|
isGetOrSetAccessorDeclaration: () => isGetOrSetAccessorDeclaration,
|
|
isGlobalDeclaration: () => isGlobalDeclaration,
|
|
isGlobalScopeAugmentation: () => isGlobalScopeAugmentation,
|
|
isHeritageClause: () => isHeritageClause,
|
|
isHoistedFunction: () => isHoistedFunction,
|
|
isHoistedVariableStatement: () => isHoistedVariableStatement,
|
|
isIdentifier: () => isIdentifier,
|
|
isIdentifierANonContextualKeyword: () => isIdentifierANonContextualKeyword,
|
|
isIdentifierName: () => isIdentifierName,
|
|
isIdentifierOrPrivateIdentifier: () => isIdentifierOrPrivateIdentifier,
|
|
isIdentifierOrThisTypeNode: () => isIdentifierOrThisTypeNode,
|
|
isIdentifierPart: () => isIdentifierPart,
|
|
isIdentifierStart: () => isIdentifierStart,
|
|
isIdentifierText: () => isIdentifierText,
|
|
isIdentifierTypePredicate: () => isIdentifierTypePredicate,
|
|
isIdentifierTypeReference: () => isIdentifierTypeReference,
|
|
isIfStatement: () => isIfStatement,
|
|
isIgnoredFileFromWildCardWatching: () => isIgnoredFileFromWildCardWatching,
|
|
isImplicitGlob: () => isImplicitGlob,
|
|
isImportCall: () => isImportCall,
|
|
isImportClause: () => isImportClause,
|
|
isImportDeclaration: () => isImportDeclaration,
|
|
isImportEqualsDeclaration: () => isImportEqualsDeclaration,
|
|
isImportKeyword: () => isImportKeyword,
|
|
isImportMeta: () => isImportMeta,
|
|
isImportOrExportSpecifier: () => isImportOrExportSpecifier,
|
|
isImportOrExportSpecifierName: () => isImportOrExportSpecifierName,
|
|
isImportSpecifier: () => isImportSpecifier,
|
|
isImportTypeAssertionContainer: () => isImportTypeAssertionContainer,
|
|
isImportTypeNode: () => isImportTypeNode,
|
|
isImportableFile: () => isImportableFile,
|
|
isInComment: () => isInComment,
|
|
isInExpressionContext: () => isInExpressionContext,
|
|
isInJSDoc: () => isInJSDoc,
|
|
isInJSFile: () => isInJSFile,
|
|
isInJSXText: () => isInJSXText,
|
|
isInJsonFile: () => isInJsonFile,
|
|
isInNonReferenceComment: () => isInNonReferenceComment,
|
|
isInReferenceComment: () => isInReferenceComment,
|
|
isInRightSideOfInternalImportEqualsDeclaration: () => isInRightSideOfInternalImportEqualsDeclaration,
|
|
isInString: () => isInString,
|
|
isInTemplateString: () => isInTemplateString,
|
|
isInTopLevelContext: () => isInTopLevelContext,
|
|
isIncrementalCompilation: () => isIncrementalCompilation,
|
|
isIndexSignatureDeclaration: () => isIndexSignatureDeclaration,
|
|
isIndexedAccessTypeNode: () => isIndexedAccessTypeNode,
|
|
isInferTypeNode: () => isInferTypeNode,
|
|
isInfinityOrNaNString: () => isInfinityOrNaNString,
|
|
isInitializedProperty: () => isInitializedProperty,
|
|
isInsideJsxElement: () => isInsideJsxElement,
|
|
isInsideJsxElementOrAttribute: () => isInsideJsxElementOrAttribute,
|
|
isInsideNodeModules: () => isInsideNodeModules,
|
|
isInsideTemplateLiteral: () => isInsideTemplateLiteral,
|
|
isInstantiatedModule: () => isInstantiatedModule,
|
|
isInterfaceDeclaration: () => isInterfaceDeclaration,
|
|
isInternalDeclaration: () => isInternalDeclaration,
|
|
isInternalModuleImportEqualsDeclaration: () => isInternalModuleImportEqualsDeclaration,
|
|
isInternalName: () => isInternalName,
|
|
isIntersectionTypeNode: () => isIntersectionTypeNode,
|
|
isIntrinsicJsxName: () => isIntrinsicJsxName,
|
|
isIterationStatement: () => isIterationStatement,
|
|
isJSDoc: () => isJSDoc,
|
|
isJSDocAllType: () => isJSDocAllType,
|
|
isJSDocAugmentsTag: () => isJSDocAugmentsTag,
|
|
isJSDocAuthorTag: () => isJSDocAuthorTag,
|
|
isJSDocCallbackTag: () => isJSDocCallbackTag,
|
|
isJSDocClassTag: () => isJSDocClassTag,
|
|
isJSDocCommentContainingNode: () => isJSDocCommentContainingNode,
|
|
isJSDocConstructSignature: () => isJSDocConstructSignature,
|
|
isJSDocDeprecatedTag: () => isJSDocDeprecatedTag,
|
|
isJSDocEnumTag: () => isJSDocEnumTag,
|
|
isJSDocFunctionType: () => isJSDocFunctionType,
|
|
isJSDocImplementsTag: () => isJSDocImplementsTag,
|
|
isJSDocIndexSignature: () => isJSDocIndexSignature,
|
|
isJSDocLikeText: () => isJSDocLikeText,
|
|
isJSDocLink: () => isJSDocLink,
|
|
isJSDocLinkCode: () => isJSDocLinkCode,
|
|
isJSDocLinkLike: () => isJSDocLinkLike,
|
|
isJSDocLinkPlain: () => isJSDocLinkPlain,
|
|
isJSDocMemberName: () => isJSDocMemberName,
|
|
isJSDocNameReference: () => isJSDocNameReference,
|
|
isJSDocNamepathType: () => isJSDocNamepathType,
|
|
isJSDocNamespaceBody: () => isJSDocNamespaceBody,
|
|
isJSDocNode: () => isJSDocNode,
|
|
isJSDocNonNullableType: () => isJSDocNonNullableType,
|
|
isJSDocNullableType: () => isJSDocNullableType,
|
|
isJSDocOptionalType: () => isJSDocOptionalType,
|
|
isJSDocOverrideTag: () => isJSDocOverrideTag,
|
|
isJSDocParameterTag: () => isJSDocParameterTag,
|
|
isJSDocPrivateTag: () => isJSDocPrivateTag,
|
|
isJSDocPropertyLikeTag: () => isJSDocPropertyLikeTag,
|
|
isJSDocPropertyTag: () => isJSDocPropertyTag,
|
|
isJSDocProtectedTag: () => isJSDocProtectedTag,
|
|
isJSDocPublicTag: () => isJSDocPublicTag,
|
|
isJSDocReadonlyTag: () => isJSDocReadonlyTag,
|
|
isJSDocReturnTag: () => isJSDocReturnTag,
|
|
isJSDocSeeTag: () => isJSDocSeeTag,
|
|
isJSDocSignature: () => isJSDocSignature,
|
|
isJSDocTag: () => isJSDocTag,
|
|
isJSDocTemplateTag: () => isJSDocTemplateTag,
|
|
isJSDocThisTag: () => isJSDocThisTag,
|
|
isJSDocTypeAlias: () => isJSDocTypeAlias,
|
|
isJSDocTypeAssertion: () => isJSDocTypeAssertion,
|
|
isJSDocTypeExpression: () => isJSDocTypeExpression,
|
|
isJSDocTypeLiteral: () => isJSDocTypeLiteral,
|
|
isJSDocTypeTag: () => isJSDocTypeTag,
|
|
isJSDocTypedefTag: () => isJSDocTypedefTag,
|
|
isJSDocUnknownTag: () => isJSDocUnknownTag,
|
|
isJSDocUnknownType: () => isJSDocUnknownType,
|
|
isJSDocVariadicType: () => isJSDocVariadicType,
|
|
isJSXTagName: () => isJSXTagName,
|
|
isJsonEqual: () => isJsonEqual,
|
|
isJsonSourceFile: () => isJsonSourceFile,
|
|
isJsxAttribute: () => isJsxAttribute,
|
|
isJsxAttributeLike: () => isJsxAttributeLike,
|
|
isJsxAttributes: () => isJsxAttributes,
|
|
isJsxChild: () => isJsxChild,
|
|
isJsxClosingElement: () => isJsxClosingElement,
|
|
isJsxClosingFragment: () => isJsxClosingFragment,
|
|
isJsxElement: () => isJsxElement,
|
|
isJsxExpression: () => isJsxExpression,
|
|
isJsxFragment: () => isJsxFragment,
|
|
isJsxOpeningElement: () => isJsxOpeningElement,
|
|
isJsxOpeningFragment: () => isJsxOpeningFragment,
|
|
isJsxOpeningLikeElement: () => isJsxOpeningLikeElement,
|
|
isJsxOpeningLikeElementTagName: () => isJsxOpeningLikeElementTagName,
|
|
isJsxSelfClosingElement: () => isJsxSelfClosingElement,
|
|
isJsxSpreadAttribute: () => isJsxSpreadAttribute,
|
|
isJsxTagNameExpression: () => isJsxTagNameExpression,
|
|
isJsxText: () => isJsxText,
|
|
isJumpStatementTarget: () => isJumpStatementTarget,
|
|
isKeyword: () => isKeyword,
|
|
isKnownSymbol: () => isKnownSymbol,
|
|
isLabelName: () => isLabelName,
|
|
isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
|
|
isLabeledStatement: () => isLabeledStatement,
|
|
isLateVisibilityPaintedStatement: () => isLateVisibilityPaintedStatement,
|
|
isLeftHandSideExpression: () => isLeftHandSideExpression,
|
|
isLeftHandSideOfAssignment: () => isLeftHandSideOfAssignment,
|
|
isLet: () => isLet,
|
|
isLineBreak: () => isLineBreak,
|
|
isLiteralComputedPropertyDeclarationName: () => isLiteralComputedPropertyDeclarationName,
|
|
isLiteralExpression: () => isLiteralExpression,
|
|
isLiteralExpressionOfObject: () => isLiteralExpressionOfObject,
|
|
isLiteralImportTypeNode: () => isLiteralImportTypeNode,
|
|
isLiteralKind: () => isLiteralKind,
|
|
isLiteralLikeAccess: () => isLiteralLikeAccess,
|
|
isLiteralLikeElementAccess: () => isLiteralLikeElementAccess,
|
|
isLiteralNameOfPropertyDeclarationOrIndexAccess: () => isLiteralNameOfPropertyDeclarationOrIndexAccess,
|
|
isLiteralTypeLikeExpression: () => isLiteralTypeLikeExpression,
|
|
isLiteralTypeNode: () => isLiteralTypeNode,
|
|
isLocalName: () => isLocalName,
|
|
isLogicalOperator: () => isLogicalOperator,
|
|
isLogicalOrCoalescingAssignmentExpression: () => isLogicalOrCoalescingAssignmentExpression,
|
|
isLogicalOrCoalescingAssignmentOperator: () => isLogicalOrCoalescingAssignmentOperator,
|
|
isMappedTypeNode: () => isMappedTypeNode,
|
|
isMemberName: () => isMemberName,
|
|
isMergeDeclarationMarker: () => isMergeDeclarationMarker,
|
|
isMetaProperty: () => isMetaProperty,
|
|
isMethodDeclaration: () => isMethodDeclaration,
|
|
isMethodOrAccessor: () => isMethodOrAccessor,
|
|
isMethodSignature: () => isMethodSignature,
|
|
isMinusToken: () => isMinusToken,
|
|
isMissingDeclaration: () => isMissingDeclaration,
|
|
isModifier: () => isModifier,
|
|
isModifierKind: () => isModifierKind,
|
|
isModifierLike: () => isModifierLike,
|
|
isModuleAugmentationExternal: () => isModuleAugmentationExternal,
|
|
isModuleBlock: () => isModuleBlock,
|
|
isModuleBody: () => isModuleBody,
|
|
isModuleDeclaration: () => isModuleDeclaration,
|
|
isModuleExportsAccessExpression: () => isModuleExportsAccessExpression,
|
|
isModuleIdentifier: () => isModuleIdentifier,
|
|
isModuleName: () => isModuleName,
|
|
isModuleOrEnumDeclaration: () => isModuleOrEnumDeclaration,
|
|
isModuleReference: () => isModuleReference,
|
|
isModuleSpecifierLike: () => isModuleSpecifierLike,
|
|
isModuleWithStringLiteralName: () => isModuleWithStringLiteralName,
|
|
isNameOfFunctionDeclaration: () => isNameOfFunctionDeclaration,
|
|
isNameOfModuleDeclaration: () => isNameOfModuleDeclaration,
|
|
isNamedClassElement: () => isNamedClassElement,
|
|
isNamedDeclaration: () => isNamedDeclaration,
|
|
isNamedExportBindings: () => isNamedExportBindings,
|
|
isNamedExports: () => isNamedExports,
|
|
isNamedImportBindings: () => isNamedImportBindings,
|
|
isNamedImports: () => isNamedImports,
|
|
isNamedImportsOrExports: () => isNamedImportsOrExports,
|
|
isNamedTupleMember: () => isNamedTupleMember,
|
|
isNamespaceBody: () => isNamespaceBody,
|
|
isNamespaceExport: () => isNamespaceExport,
|
|
isNamespaceExportDeclaration: () => isNamespaceExportDeclaration,
|
|
isNamespaceImport: () => isNamespaceImport,
|
|
isNamespaceReexportDeclaration: () => isNamespaceReexportDeclaration,
|
|
isNewExpression: () => isNewExpression,
|
|
isNewExpressionTarget: () => isNewExpressionTarget,
|
|
isNightly: () => isNightly,
|
|
isNoSubstitutionTemplateLiteral: () => isNoSubstitutionTemplateLiteral,
|
|
isNode: () => isNode,
|
|
isNodeArray: () => isNodeArray,
|
|
isNodeArrayMultiLine: () => isNodeArrayMultiLine,
|
|
isNodeDescendantOf: () => isNodeDescendantOf,
|
|
isNodeKind: () => isNodeKind,
|
|
isNodeLikeSystem: () => isNodeLikeSystem,
|
|
isNodeModulesDirectory: () => isNodeModulesDirectory,
|
|
isNodeWithPossibleHoistedDeclaration: () => isNodeWithPossibleHoistedDeclaration,
|
|
isNonContextualKeyword: () => isNonContextualKeyword,
|
|
isNonGlobalAmbientModule: () => isNonGlobalAmbientModule,
|
|
isNonGlobalDeclaration: () => isNonGlobalDeclaration,
|
|
isNonNullChain: () => isNonNullChain,
|
|
isNonNullExpression: () => isNonNullExpression,
|
|
isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName,
|
|
isNotEmittedOrPartiallyEmittedNode: () => isNotEmittedOrPartiallyEmittedNode,
|
|
isNotEmittedStatement: () => isNotEmittedStatement,
|
|
isNullishCoalesce: () => isNullishCoalesce,
|
|
isNumber: () => isNumber,
|
|
isNumericLiteral: () => isNumericLiteral,
|
|
isNumericLiteralName: () => isNumericLiteralName,
|
|
isObjectBindingElementWithoutPropertyName: () => isObjectBindingElementWithoutPropertyName,
|
|
isObjectBindingOrAssignmentElement: () => isObjectBindingOrAssignmentElement,
|
|
isObjectBindingOrAssignmentPattern: () => isObjectBindingOrAssignmentPattern,
|
|
isObjectBindingPattern: () => isObjectBindingPattern,
|
|
isObjectLiteralElement: () => isObjectLiteralElement,
|
|
isObjectLiteralElementLike: () => isObjectLiteralElementLike,
|
|
isObjectLiteralExpression: () => isObjectLiteralExpression,
|
|
isObjectLiteralMethod: () => isObjectLiteralMethod,
|
|
isObjectLiteralOrClassExpressionMethodOrAccessor: () => isObjectLiteralOrClassExpressionMethodOrAccessor,
|
|
isObjectTypeDeclaration: () => isObjectTypeDeclaration,
|
|
isOctalDigit: () => isOctalDigit,
|
|
isOmittedExpression: () => isOmittedExpression,
|
|
isOptionalChain: () => isOptionalChain,
|
|
isOptionalChainRoot: () => isOptionalChainRoot,
|
|
isOptionalJSDocPropertyLikeTag: () => isOptionalJSDocPropertyLikeTag,
|
|
isOptionalTypeNode: () => isOptionalTypeNode,
|
|
isOuterExpression: () => isOuterExpression,
|
|
isOutermostOptionalChain: () => isOutermostOptionalChain,
|
|
isOverrideModifier: () => isOverrideModifier,
|
|
isPackedArrayLiteral: () => isPackedArrayLiteral,
|
|
isParameter: () => isParameter,
|
|
isParameterDeclaration: () => isParameterDeclaration,
|
|
isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
|
|
isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
|
|
isParameterPropertyModifier: () => isParameterPropertyModifier,
|
|
isParenthesizedExpression: () => isParenthesizedExpression,
|
|
isParenthesizedTypeNode: () => isParenthesizedTypeNode,
|
|
isParseTreeNode: () => isParseTreeNode,
|
|
isPartOfTypeNode: () => isPartOfTypeNode,
|
|
isPartOfTypeQuery: () => isPartOfTypeQuery,
|
|
isPartiallyEmittedExpression: () => isPartiallyEmittedExpression,
|
|
isPatternMatch: () => isPatternMatch,
|
|
isPinnedComment: () => isPinnedComment,
|
|
isPlainJsFile: () => isPlainJsFile,
|
|
isPlusToken: () => isPlusToken,
|
|
isPossiblyTypeArgumentPosition: () => isPossiblyTypeArgumentPosition,
|
|
isPostfixUnaryExpression: () => isPostfixUnaryExpression,
|
|
isPrefixUnaryExpression: () => isPrefixUnaryExpression,
|
|
isPrivateIdentifier: () => isPrivateIdentifier,
|
|
isPrivateIdentifierClassElementDeclaration: () => isPrivateIdentifierClassElementDeclaration,
|
|
isPrivateIdentifierPropertyAccessExpression: () => isPrivateIdentifierPropertyAccessExpression,
|
|
isPrivateIdentifierSymbol: () => isPrivateIdentifierSymbol,
|
|
isProgramBundleEmitBuildInfo: () => isProgramBundleEmitBuildInfo,
|
|
isProgramUptoDate: () => isProgramUptoDate,
|
|
isPrologueDirective: () => isPrologueDirective,
|
|
isPropertyAccessChain: () => isPropertyAccessChain,
|
|
isPropertyAccessEntityNameExpression: () => isPropertyAccessEntityNameExpression,
|
|
isPropertyAccessExpression: () => isPropertyAccessExpression,
|
|
isPropertyAccessOrQualifiedName: () => isPropertyAccessOrQualifiedName,
|
|
isPropertyAccessOrQualifiedNameOrImportTypeNode: () => isPropertyAccessOrQualifiedNameOrImportTypeNode,
|
|
isPropertyAssignment: () => isPropertyAssignment,
|
|
isPropertyDeclaration: () => isPropertyDeclaration,
|
|
isPropertyName: () => isPropertyName,
|
|
isPropertyNameLiteral: () => isPropertyNameLiteral,
|
|
isPropertySignature: () => isPropertySignature,
|
|
isPrototypeAccess: () => isPrototypeAccess,
|
|
isPrototypePropertyAssignment: () => isPrototypePropertyAssignment,
|
|
isPunctuation: () => isPunctuation,
|
|
isPushOrUnshiftIdentifier: () => isPushOrUnshiftIdentifier,
|
|
isQualifiedName: () => isQualifiedName,
|
|
isQuestionDotToken: () => isQuestionDotToken,
|
|
isQuestionOrExclamationToken: () => isQuestionOrExclamationToken,
|
|
isQuestionOrPlusOrMinusToken: () => isQuestionOrPlusOrMinusToken,
|
|
isQuestionToken: () => isQuestionToken,
|
|
isRawSourceMap: () => isRawSourceMap,
|
|
isReadonlyKeyword: () => isReadonlyKeyword,
|
|
isReadonlyKeywordOrPlusOrMinusToken: () => isReadonlyKeywordOrPlusOrMinusToken,
|
|
isRecognizedTripleSlashComment: () => isRecognizedTripleSlashComment,
|
|
isReferenceFileLocation: () => isReferenceFileLocation,
|
|
isReferencedFile: () => isReferencedFile,
|
|
isRegularExpressionLiteral: () => isRegularExpressionLiteral,
|
|
isRequireCall: () => isRequireCall,
|
|
isRequireVariableStatement: () => isRequireVariableStatement,
|
|
isRestParameter: () => isRestParameter,
|
|
isRestTypeNode: () => isRestTypeNode,
|
|
isReturnStatement: () => isReturnStatement,
|
|
isReturnStatementWithFixablePromiseHandler: () => isReturnStatementWithFixablePromiseHandler,
|
|
isRightSideOfAccessExpression: () => isRightSideOfAccessExpression,
|
|
isRightSideOfPropertyAccess: () => isRightSideOfPropertyAccess,
|
|
isRightSideOfQualifiedName: () => isRightSideOfQualifiedName,
|
|
isRightSideOfQualifiedNameOrPropertyAccess: () => isRightSideOfQualifiedNameOrPropertyAccess,
|
|
isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName: () => isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName,
|
|
isRootedDiskPath: () => isRootedDiskPath,
|
|
isSameEntityName: () => isSameEntityName,
|
|
isSatisfiesExpression: () => isSatisfiesExpression,
|
|
isScopeMarker: () => isScopeMarker,
|
|
isSemicolonClassElement: () => isSemicolonClassElement,
|
|
isSetAccessor: () => isSetAccessor,
|
|
isSetAccessorDeclaration: () => isSetAccessorDeclaration,
|
|
isShebangTrivia: () => isShebangTrivia,
|
|
isShorthandAmbientModuleSymbol: () => isShorthandAmbientModuleSymbol,
|
|
isShorthandPropertyAssignment: () => isShorthandPropertyAssignment,
|
|
isSignedNumericLiteral: () => isSignedNumericLiteral,
|
|
isSimpleCopiableExpression: () => isSimpleCopiableExpression,
|
|
isSimpleInlineableExpression: () => isSimpleInlineableExpression,
|
|
isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
|
|
isSourceFile: () => isSourceFile,
|
|
isSourceFileFromLibrary: () => isSourceFileFromLibrary,
|
|
isSourceFileJS: () => isSourceFileJS,
|
|
isSourceFileNotJS: () => isSourceFileNotJS,
|
|
isSourceFileNotJson: () => isSourceFileNotJson,
|
|
isSourceMapping: () => isSourceMapping,
|
|
isSpecialPropertyDeclaration: () => isSpecialPropertyDeclaration,
|
|
isSpreadAssignment: () => isSpreadAssignment,
|
|
isSpreadElement: () => isSpreadElement,
|
|
isStatement: () => isStatement,
|
|
isStatementButNotDeclaration: () => isStatementButNotDeclaration,
|
|
isStatementOrBlock: () => isStatementOrBlock,
|
|
isStatementWithLocals: () => isStatementWithLocals,
|
|
isStatic: () => isStatic,
|
|
isStaticModifier: () => isStaticModifier,
|
|
isString: () => isString,
|
|
isStringAKeyword: () => isStringAKeyword,
|
|
isStringANonContextualKeyword: () => isStringANonContextualKeyword,
|
|
isStringDoubleQuoted: () => isStringDoubleQuoted,
|
|
isStringLiteral: () => isStringLiteral,
|
|
isStringLiteralLike: () => isStringLiteralLike,
|
|
isStringLiteralOrJsxExpression: () => isStringLiteralOrJsxExpression,
|
|
isStringLiteralOrTemplate: () => isStringLiteralOrTemplate,
|
|
isStringOrNumericLiteralLike: () => isStringOrNumericLiteralLike,
|
|
isStringOrRegularExpressionOrTemplateLiteral: () => isStringOrRegularExpressionOrTemplateLiteral,
|
|
isStringTextContainingNode: () => isStringTextContainingNode,
|
|
isSuperCall: () => isSuperCall,
|
|
isSuperKeyword: () => isSuperKeyword,
|
|
isSuperOrSuperProperty: () => isSuperOrSuperProperty,
|
|
isSuperProperty: () => isSuperProperty,
|
|
isSupportedSourceFileName: () => isSupportedSourceFileName,
|
|
isSwitchStatement: () => isSwitchStatement,
|
|
isSyntaxList: () => isSyntaxList,
|
|
isSyntheticExpression: () => isSyntheticExpression,
|
|
isSyntheticReference: () => isSyntheticReference,
|
|
isTagName: () => isTagName,
|
|
isTaggedTemplateExpression: () => isTaggedTemplateExpression,
|
|
isTaggedTemplateTag: () => isTaggedTemplateTag,
|
|
isTemplateExpression: () => isTemplateExpression,
|
|
isTemplateHead: () => isTemplateHead,
|
|
isTemplateLiteral: () => isTemplateLiteral,
|
|
isTemplateLiteralKind: () => isTemplateLiteralKind,
|
|
isTemplateLiteralToken: () => isTemplateLiteralToken,
|
|
isTemplateLiteralTypeNode: () => isTemplateLiteralTypeNode,
|
|
isTemplateLiteralTypeSpan: () => isTemplateLiteralTypeSpan,
|
|
isTemplateMiddle: () => isTemplateMiddle,
|
|
isTemplateMiddleOrTemplateTail: () => isTemplateMiddleOrTemplateTail,
|
|
isTemplateSpan: () => isTemplateSpan,
|
|
isTemplateTail: () => isTemplateTail,
|
|
isTextWhiteSpaceLike: () => isTextWhiteSpaceLike,
|
|
isThis: () => isThis,
|
|
isThisContainerOrFunctionBlock: () => isThisContainerOrFunctionBlock,
|
|
isThisIdentifier: () => isThisIdentifier,
|
|
isThisInTypeQuery: () => isThisInTypeQuery,
|
|
isThisInitializedDeclaration: () => isThisInitializedDeclaration,
|
|
isThisInitializedObjectBindingExpression: () => isThisInitializedObjectBindingExpression,
|
|
isThisProperty: () => isThisProperty,
|
|
isThisTypeNode: () => isThisTypeNode,
|
|
isThisTypeParameter: () => isThisTypeParameter,
|
|
isThisTypePredicate: () => isThisTypePredicate,
|
|
isThrowStatement: () => isThrowStatement,
|
|
isToken: () => isToken,
|
|
isTokenKind: () => isTokenKind,
|
|
isTraceEnabled: () => isTraceEnabled,
|
|
isTransientSymbol: () => isTransientSymbol,
|
|
isTrivia: () => isTrivia,
|
|
isTryStatement: () => isTryStatement,
|
|
isTupleTypeNode: () => isTupleTypeNode,
|
|
isTypeAlias: () => isTypeAlias,
|
|
isTypeAliasDeclaration: () => isTypeAliasDeclaration,
|
|
isTypeAssertion: () => isTypeAssertion,
|
|
isTypeAssertionExpression: () => isTypeAssertionExpression,
|
|
isTypeDeclaration: () => isTypeDeclaration,
|
|
isTypeElement: () => isTypeElement,
|
|
isTypeKeyword: () => isTypeKeyword,
|
|
isTypeKeywordToken: () => isTypeKeywordToken,
|
|
isTypeKeywordTokenOrIdentifier: () => isTypeKeywordTokenOrIdentifier,
|
|
isTypeLiteralNode: () => isTypeLiteralNode,
|
|
isTypeNode: () => isTypeNode,
|
|
isTypeNodeKind: () => isTypeNodeKind,
|
|
isTypeNodeOrTypeParameterDeclaration: () => isTypeNodeOrTypeParameterDeclaration,
|
|
isTypeOfExpression: () => isTypeOfExpression,
|
|
isTypeOnlyImportOrExportDeclaration: () => isTypeOnlyImportOrExportDeclaration,
|
|
isTypeOperatorNode: () => isTypeOperatorNode,
|
|
isTypeParameterDeclaration: () => isTypeParameterDeclaration,
|
|
isTypePredicateNode: () => isTypePredicateNode,
|
|
isTypeQueryNode: () => isTypeQueryNode,
|
|
isTypeReferenceNode: () => isTypeReferenceNode,
|
|
isTypeReferenceType: () => isTypeReferenceType,
|
|
isUMDExportSymbol: () => isUMDExportSymbol,
|
|
isUnaryExpression: () => isUnaryExpression,
|
|
isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
|
|
isUnicodeIdentifierStart: () => isUnicodeIdentifierStart,
|
|
isUnionTypeNode: () => isUnionTypeNode,
|
|
isUnparsedNode: () => isUnparsedNode,
|
|
isUnparsedPrepend: () => isUnparsedPrepend,
|
|
isUnparsedSource: () => isUnparsedSource,
|
|
isUnparsedTextLike: () => isUnparsedTextLike,
|
|
isUrl: () => isUrl,
|
|
isValidESSymbolDeclaration: () => isValidESSymbolDeclaration,
|
|
isValidTypeOnlyAliasUseSite: () => isValidTypeOnlyAliasUseSite,
|
|
isValueSignatureDeclaration: () => isValueSignatureDeclaration,
|
|
isVarConst: () => isVarConst,
|
|
isVariableDeclaration: () => isVariableDeclaration,
|
|
isVariableDeclarationInVariableStatement: () => isVariableDeclarationInVariableStatement,
|
|
isVariableDeclarationInitializedToBareOrAccessedRequire: () => isVariableDeclarationInitializedToBareOrAccessedRequire,
|
|
isVariableDeclarationInitializedToRequire: () => isVariableDeclarationInitializedToRequire,
|
|
isVariableDeclarationList: () => isVariableDeclarationList,
|
|
isVariableLike: () => isVariableLike,
|
|
isVariableLikeOrAccessor: () => isVariableLikeOrAccessor,
|
|
isVariableStatement: () => isVariableStatement,
|
|
isVoidExpression: () => isVoidExpression,
|
|
isWatchSet: () => isWatchSet,
|
|
isWhileStatement: () => isWhileStatement,
|
|
isWhiteSpaceLike: () => isWhiteSpaceLike,
|
|
isWhiteSpaceSingleLine: () => isWhiteSpaceSingleLine,
|
|
isWithStatement: () => isWithStatement,
|
|
isWriteAccess: () => isWriteAccess,
|
|
isWriteOnlyAccess: () => isWriteOnlyAccess,
|
|
isYieldExpression: () => isYieldExpression,
|
|
jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
|
|
keywordPart: () => keywordPart,
|
|
last: () => last,
|
|
lastOrUndefined: () => lastOrUndefined,
|
|
length: () => length,
|
|
libMap: () => libMap,
|
|
libs: () => libs,
|
|
lineBreakPart: () => lineBreakPart,
|
|
linkNamePart: () => linkNamePart,
|
|
linkPart: () => linkPart,
|
|
linkTextPart: () => linkTextPart,
|
|
listFiles: () => listFiles,
|
|
loadModuleFromGlobalCache: () => loadModuleFromGlobalCache,
|
|
loadWithModeAwareCache: () => loadWithModeAwareCache,
|
|
loadWithTypeDirectiveCache: () => loadWithTypeDirectiveCache,
|
|
makeIdentifierFromModuleName: () => makeIdentifierFromModuleName,
|
|
makeImport: () => makeImport,
|
|
makeImportIfNecessary: () => makeImportIfNecessary,
|
|
makeStringLiteral: () => makeStringLiteral,
|
|
mangleScopedPackageName: () => mangleScopedPackageName,
|
|
map: () => map,
|
|
mapAllOrFail: () => mapAllOrFail,
|
|
mapDefined: () => mapDefined,
|
|
mapDefinedEntries: () => mapDefinedEntries,
|
|
mapDefinedIterator: () => mapDefinedIterator,
|
|
mapDefinedValues: () => mapDefinedValues,
|
|
mapEntries: () => mapEntries,
|
|
mapIterator: () => mapIterator,
|
|
mapOneOrMany: () => mapOneOrMany,
|
|
mapToDisplayParts: () => mapToDisplayParts,
|
|
matchFiles: () => matchFiles,
|
|
matchPatternOrExact: () => matchPatternOrExact,
|
|
matchedText: () => matchedText,
|
|
matchesExclude: () => matchesExclude,
|
|
maybeBind: () => maybeBind,
|
|
maybeSetLocalizedDiagnosticMessages: () => maybeSetLocalizedDiagnosticMessages,
|
|
memoize: () => memoize,
|
|
memoizeOne: () => memoizeOne,
|
|
metadataHelper: () => metadataHelper,
|
|
min: () => min,
|
|
minAndMax: () => minAndMax,
|
|
missingFileModifiedTime: () => missingFileModifiedTime,
|
|
modifierToFlag: () => modifierToFlag,
|
|
modifiersToFlags: () => modifiersToFlags,
|
|
moduleOptionDeclaration: () => moduleOptionDeclaration,
|
|
moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo,
|
|
moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
|
|
moduleResolutionRespectsExports: () => moduleResolutionRespectsExports,
|
|
moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
|
|
moduleSpecifiers: () => ts_moduleSpecifiers_exports,
|
|
moveEmitHelpers: () => moveEmitHelpers,
|
|
moveRangeEnd: () => moveRangeEnd,
|
|
moveRangePastDecorators: () => moveRangePastDecorators,
|
|
moveRangePastModifiers: () => moveRangePastModifiers,
|
|
moveRangePos: () => moveRangePos,
|
|
moveSyntheticComments: () => moveSyntheticComments,
|
|
mutateMap: () => mutateMap,
|
|
mutateMapSkippingNewValues: () => mutateMapSkippingNewValues,
|
|
needsParentheses: () => needsParentheses,
|
|
needsScopeMarker: () => needsScopeMarker,
|
|
noEmitNotification: () => noEmitNotification,
|
|
noEmitSubstitution: () => noEmitSubstitution,
|
|
noTransformers: () => noTransformers,
|
|
noTruncationMaximumTruncationLength: () => noTruncationMaximumTruncationLength,
|
|
nodeCanBeDecorated: () => nodeCanBeDecorated,
|
|
nodeHasName: () => nodeHasName,
|
|
nodeIsDecorated: () => nodeIsDecorated,
|
|
nodeIsMissing: () => nodeIsMissing,
|
|
nodeIsPresent: () => nodeIsPresent,
|
|
nodeIsSynthesized: () => nodeIsSynthesized,
|
|
nodeModuleNameResolver: () => nodeModuleNameResolver,
|
|
nodeModulesPathPart: () => nodeModulesPathPart,
|
|
nodeOrChildIsDecorated: () => nodeOrChildIsDecorated,
|
|
nodeOverlapsWithStartEnd: () => nodeOverlapsWithStartEnd,
|
|
nodePosToString: () => nodePosToString,
|
|
nodeSeenTracker: () => nodeSeenTracker,
|
|
nodeStartsNewLexicalEnvironment: () => nodeStartsNewLexicalEnvironment,
|
|
nodeToDisplayParts: () => nodeToDisplayParts,
|
|
noop: () => noop,
|
|
noopFileWatcher: () => noopFileWatcher,
|
|
noopPush: () => noopPush,
|
|
normalizePath: () => normalizePath,
|
|
normalizeSlashes: () => normalizeSlashes,
|
|
not: () => not,
|
|
notImplemented: () => notImplemented,
|
|
notImplementedResolver: () => notImplementedResolver,
|
|
nullNodeConverters: () => nullNodeConverters,
|
|
nullParenthesizerRules: () => nullParenthesizerRules,
|
|
nullTransformationContext: () => nullTransformationContext,
|
|
objectAllocator: () => objectAllocator,
|
|
operatorPart: () => operatorPart,
|
|
optionDeclarations: () => optionDeclarations,
|
|
optionMapToObject: () => optionMapToObject,
|
|
optionsAffectingProgramStructure: () => optionsAffectingProgramStructure,
|
|
optionsForBuild: () => optionsForBuild,
|
|
optionsForWatch: () => optionsForWatch,
|
|
optionsHaveChanges: () => optionsHaveChanges,
|
|
optionsHaveModuleResolutionChanges: () => optionsHaveModuleResolutionChanges,
|
|
or: () => or,
|
|
orderedRemoveItem: () => orderedRemoveItem,
|
|
orderedRemoveItemAt: () => orderedRemoveItemAt,
|
|
outFile: () => outFile,
|
|
packageIdToPackageName: () => packageIdToPackageName,
|
|
packageIdToString: () => packageIdToString,
|
|
padLeft: () => padLeft,
|
|
padRight: () => padRight,
|
|
paramHelper: () => paramHelper,
|
|
parameterIsThisKeyword: () => parameterIsThisKeyword,
|
|
parameterNamePart: () => parameterNamePart,
|
|
parseBaseNodeFactory: () => parseBaseNodeFactory,
|
|
parseBuildCommand: () => parseBuildCommand,
|
|
parseCommandLine: () => parseCommandLine,
|
|
parseCommandLineWorker: () => parseCommandLineWorker,
|
|
parseConfigFileTextToJson: () => parseConfigFileTextToJson,
|
|
parseConfigFileWithSystem: () => parseConfigFileWithSystem,
|
|
parseConfigHostFromCompilerHostLike: () => parseConfigHostFromCompilerHostLike,
|
|
parseCustomTypeOption: () => parseCustomTypeOption,
|
|
parseIsolatedEntityName: () => parseIsolatedEntityName,
|
|
parseIsolatedJSDocComment: () => parseIsolatedJSDocComment,
|
|
parseJSDocTypeExpressionForTests: () => parseJSDocTypeExpressionForTests,
|
|
parseJsonConfigFileContent: () => parseJsonConfigFileContent,
|
|
parseJsonSourceFileConfigFileContent: () => parseJsonSourceFileConfigFileContent,
|
|
parseJsonText: () => parseJsonText,
|
|
parseListTypeOption: () => parseListTypeOption,
|
|
parseNodeFactory: () => parseNodeFactory,
|
|
parseNodeModuleFromPath: () => parseNodeModuleFromPath,
|
|
parsePackageName: () => parsePackageName,
|
|
parsePseudoBigInt: () => parsePseudoBigInt,
|
|
patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory,
|
|
pathContainsNodeModules: () => pathContainsNodeModules,
|
|
pathIsAbsolute: () => pathIsAbsolute,
|
|
pathIsBareSpecifier: () => pathIsBareSpecifier,
|
|
pathIsRelative: () => pathIsRelative,
|
|
patternText: () => patternText,
|
|
perfLogger: () => perfLogger,
|
|
performIncrementalCompilation: () => performIncrementalCompilation,
|
|
performance: () => ts_performance_exports,
|
|
plainJSErrors: () => plainJSErrors,
|
|
positionBelongsToNode: () => positionBelongsToNode,
|
|
positionIsASICandidate: () => positionIsASICandidate,
|
|
positionIsSynthesized: () => positionIsSynthesized,
|
|
positionsAreOnSameLine: () => positionsAreOnSameLine,
|
|
preProcessFile: () => preProcessFile,
|
|
probablyUsesSemicolons: () => probablyUsesSemicolons,
|
|
processCommentPragmas: () => processCommentPragmas,
|
|
processPragmasIntoFields: () => processPragmasIntoFields,
|
|
processTaggedTemplateExpression: () => processTaggedTemplateExpression,
|
|
programContainsEsModules: () => programContainsEsModules,
|
|
programContainsModules: () => programContainsModules,
|
|
projectReferenceIsEqualTo: () => projectReferenceIsEqualTo,
|
|
propertyNamePart: () => propertyNamePart,
|
|
pseudoBigIntToString: () => pseudoBigIntToString,
|
|
punctuationPart: () => punctuationPart,
|
|
pushIfUnique: () => pushIfUnique,
|
|
quote: () => quote,
|
|
quotePreferenceFromString: () => quotePreferenceFromString,
|
|
rangeContainsPosition: () => rangeContainsPosition,
|
|
rangeContainsPositionExclusive: () => rangeContainsPositionExclusive,
|
|
rangeContainsRange: () => rangeContainsRange,
|
|
rangeContainsRangeExclusive: () => rangeContainsRangeExclusive,
|
|
rangeContainsStartEnd: () => rangeContainsStartEnd,
|
|
rangeEndIsOnSameLineAsRangeStart: () => rangeEndIsOnSameLineAsRangeStart,
|
|
rangeEndPositionsAreOnSameLine: () => rangeEndPositionsAreOnSameLine,
|
|
rangeEquals: () => rangeEquals,
|
|
rangeIsOnSingleLine: () => rangeIsOnSingleLine,
|
|
rangeOfNode: () => rangeOfNode,
|
|
rangeOfTypeParameters: () => rangeOfTypeParameters,
|
|
rangeOverlapsWithStartEnd: () => rangeOverlapsWithStartEnd,
|
|
rangeStartIsOnSameLineAsRangeEnd: () => rangeStartIsOnSameLineAsRangeEnd,
|
|
rangeStartPositionsAreOnSameLine: () => rangeStartPositionsAreOnSameLine,
|
|
readBuilderProgram: () => readBuilderProgram,
|
|
readConfigFile: () => readConfigFile,
|
|
readHelper: () => readHelper,
|
|
readJson: () => readJson,
|
|
readJsonConfigFile: () => readJsonConfigFile,
|
|
readJsonOrUndefined: () => readJsonOrUndefined,
|
|
realizeDiagnostics: () => realizeDiagnostics,
|
|
reduceEachLeadingCommentRange: () => reduceEachLeadingCommentRange,
|
|
reduceEachTrailingCommentRange: () => reduceEachTrailingCommentRange,
|
|
reduceLeft: () => reduceLeft,
|
|
reduceLeftIterator: () => reduceLeftIterator,
|
|
reducePathComponents: () => reducePathComponents,
|
|
refactor: () => ts_refactor_exports,
|
|
regExpEscape: () => regExpEscape,
|
|
relativeComplement: () => relativeComplement,
|
|
removeAllComments: () => removeAllComments,
|
|
removeEmitHelper: () => removeEmitHelper,
|
|
removeExtension: () => removeExtension,
|
|
removeFileExtension: () => removeFileExtension,
|
|
removeIgnoredPath: () => removeIgnoredPath,
|
|
removeMinAndVersionNumbers: () => removeMinAndVersionNumbers,
|
|
removeOptionality: () => removeOptionality,
|
|
removePrefix: () => removePrefix,
|
|
removeSuffix: () => removeSuffix,
|
|
removeTrailingDirectorySeparator: () => removeTrailingDirectorySeparator,
|
|
repeatString: () => repeatString,
|
|
replaceElement: () => replaceElement,
|
|
resolutionExtensionIsTSOrJson: () => resolutionExtensionIsTSOrJson,
|
|
resolveConfigFileProjectName: () => resolveConfigFileProjectName,
|
|
resolveJSModule: () => resolveJSModule,
|
|
resolveModuleName: () => resolveModuleName,
|
|
resolveModuleNameFromCache: () => resolveModuleNameFromCache,
|
|
resolvePackageNameToPackageJson: () => resolvePackageNameToPackageJson,
|
|
resolvePath: () => resolvePath,
|
|
resolveProjectReferencePath: () => resolveProjectReferencePath,
|
|
resolveTripleslashReference: () => resolveTripleslashReference,
|
|
resolveTypeReferenceDirective: () => resolveTypeReferenceDirective,
|
|
resolvingEmptyArray: () => resolvingEmptyArray,
|
|
restHelper: () => restHelper,
|
|
returnFalse: () => returnFalse,
|
|
returnNoopFileWatcher: () => returnNoopFileWatcher,
|
|
returnTrue: () => returnTrue,
|
|
returnUndefined: () => returnUndefined,
|
|
returnsPromise: () => returnsPromise,
|
|
sameFlatMap: () => sameFlatMap,
|
|
sameMap: () => sameMap,
|
|
sameMapping: () => sameMapping,
|
|
scanShebangTrivia: () => scanShebangTrivia,
|
|
scanner: () => scanner,
|
|
screenStartingMessageCodes: () => screenStartingMessageCodes,
|
|
semanticDiagnosticsOptionDeclarations: () => semanticDiagnosticsOptionDeclarations,
|
|
serializeCompilerOptions: () => serializeCompilerOptions,
|
|
server: () => ts_server_exports4,
|
|
servicesVersion: () => servicesVersion,
|
|
setCommentRange: () => setCommentRange,
|
|
setConfigFileInOptions: () => setConfigFileInOptions,
|
|
setConstantValue: () => setConstantValue,
|
|
setEachParent: () => setEachParent,
|
|
setEmitFlags: () => setEmitFlags,
|
|
setGetSourceFileAsHashVersioned: () => setGetSourceFileAsHashVersioned,
|
|
setLocalizedDiagnosticMessages: () => setLocalizedDiagnosticMessages,
|
|
setModuleDefaultHelper: () => setModuleDefaultHelper,
|
|
setNodeFlags: () => setNodeFlags,
|
|
setObjectAllocator: () => setObjectAllocator,
|
|
setOriginalNode: () => setOriginalNode,
|
|
setParent: () => setParent,
|
|
setParentRecursive: () => setParentRecursive,
|
|
setResolvedModule: () => setResolvedModule,
|
|
setResolvedTypeReferenceDirective: () => setResolvedTypeReferenceDirective,
|
|
setSnippetElement: () => setSnippetElement,
|
|
setSourceMapRange: () => setSourceMapRange,
|
|
setStackTraceLimit: () => setStackTraceLimit,
|
|
setStartsOnNewLine: () => setStartsOnNewLine,
|
|
setSyntheticLeadingComments: () => setSyntheticLeadingComments,
|
|
setSyntheticTrailingComments: () => setSyntheticTrailingComments,
|
|
setSys: () => setSys,
|
|
setSysLog: () => setSysLog,
|
|
setTextRange: () => setTextRange,
|
|
setTextRangeEnd: () => setTextRangeEnd,
|
|
setTextRangePos: () => setTextRangePos,
|
|
setTextRangePosEnd: () => setTextRangePosEnd,
|
|
setTextRangePosWidth: () => setTextRangePosWidth,
|
|
setTokenSourceMapRange: () => setTokenSourceMapRange,
|
|
setTypeNode: () => setTypeNode,
|
|
setUILocale: () => setUILocale,
|
|
setValueDeclaration: () => setValueDeclaration,
|
|
shouldPreserveConstEnums: () => shouldPreserveConstEnums,
|
|
shouldUseUriStyleNodeCoreModules: () => shouldUseUriStyleNodeCoreModules,
|
|
showModuleSpecifier: () => showModuleSpecifier,
|
|
signatureHasLiteralTypes: () => signatureHasLiteralTypes,
|
|
signatureHasRestParameter: () => signatureHasRestParameter,
|
|
signatureToDisplayParts: () => signatureToDisplayParts,
|
|
single: () => single,
|
|
singleElementArray: () => singleElementArray,
|
|
singleIterator: () => singleIterator,
|
|
singleOrMany: () => singleOrMany,
|
|
singleOrUndefined: () => singleOrUndefined,
|
|
skipAlias: () => skipAlias,
|
|
skipAssertions: () => skipAssertions,
|
|
skipConstraint: () => skipConstraint,
|
|
skipOuterExpressions: () => skipOuterExpressions,
|
|
skipParentheses: () => skipParentheses,
|
|
skipPartiallyEmittedExpressions: () => skipPartiallyEmittedExpressions,
|
|
skipTrivia: () => skipTrivia,
|
|
skipTypeChecking: () => skipTypeChecking,
|
|
skipTypeParentheses: () => skipTypeParentheses,
|
|
sliceAfter: () => sliceAfter,
|
|
some: () => some,
|
|
sort: () => sort,
|
|
sortAndDeduplicate: () => sortAndDeduplicate,
|
|
sortAndDeduplicateDiagnostics: () => sortAndDeduplicateDiagnostics,
|
|
sourceFileAffectingCompilerOptions: () => sourceFileAffectingCompilerOptions,
|
|
sourceFileMayBeEmitted: () => sourceFileMayBeEmitted,
|
|
sourceMapCommentRegExp: () => sourceMapCommentRegExp,
|
|
sourceMapCommentRegExpDontCareLineStart: () => sourceMapCommentRegExpDontCareLineStart,
|
|
spacePart: () => spacePart,
|
|
spanMap: () => spanMap,
|
|
spreadArrayHelper: () => spreadArrayHelper,
|
|
stableSort: () => stableSort,
|
|
startEndContainsRange: () => startEndContainsRange,
|
|
startEndOverlapsWithStartEnd: () => startEndOverlapsWithStartEnd,
|
|
startOnNewLine: () => startOnNewLine,
|
|
startTracing: () => startTracing,
|
|
startsWith: () => startsWith,
|
|
startsWithDirectory: () => startsWithDirectory,
|
|
startsWithUnderscore: () => startsWithUnderscore,
|
|
startsWithUseStrict: () => startsWithUseStrict,
|
|
stringContains: () => stringContains,
|
|
stringContainsAt: () => stringContainsAt,
|
|
stringToToken: () => stringToToken,
|
|
stripQuotes: () => stripQuotes,
|
|
sum: () => sum,
|
|
supportedDeclarationExtensions: () => supportedDeclarationExtensions,
|
|
supportedJSExtensions: () => supportedJSExtensions,
|
|
supportedJSExtensionsFlat: () => supportedJSExtensionsFlat,
|
|
supportedLocaleDirectories: () => supportedLocaleDirectories,
|
|
supportedTSExtensions: () => supportedTSExtensions,
|
|
supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
|
|
supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
|
|
suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
|
|
suppressLeadingTrivia: () => suppressLeadingTrivia,
|
|
suppressTrailingTrivia: () => suppressTrailingTrivia,
|
|
symbolEscapedNameNoDefault: () => symbolEscapedNameNoDefault,
|
|
symbolName: () => symbolName,
|
|
symbolNameNoDefault: () => symbolNameNoDefault,
|
|
symbolPart: () => symbolPart,
|
|
symbolToDisplayParts: () => symbolToDisplayParts,
|
|
syntaxMayBeASICandidate: () => syntaxMayBeASICandidate,
|
|
syntaxRequiresTrailingSemicolonOrASI: () => syntaxRequiresTrailingSemicolonOrASI,
|
|
sys: () => sys,
|
|
sysLog: () => sysLog,
|
|
tagNamesAreEquivalent: () => tagNamesAreEquivalent,
|
|
takeWhile: () => takeWhile,
|
|
targetOptionDeclaration: () => targetOptionDeclaration,
|
|
templateObjectHelper: () => templateObjectHelper,
|
|
testFormatSettings: () => testFormatSettings,
|
|
textChangeRangeIsUnchanged: () => textChangeRangeIsUnchanged,
|
|
textChangeRangeNewSpan: () => textChangeRangeNewSpan,
|
|
textChanges: () => ts_textChanges_exports,
|
|
textOrKeywordPart: () => textOrKeywordPart,
|
|
textPart: () => textPart,
|
|
textRangeContainsPositionInclusive: () => textRangeContainsPositionInclusive,
|
|
textSpanContainsPosition: () => textSpanContainsPosition,
|
|
textSpanContainsTextSpan: () => textSpanContainsTextSpan,
|
|
textSpanEnd: () => textSpanEnd,
|
|
textSpanIntersection: () => textSpanIntersection,
|
|
textSpanIntersectsWith: () => textSpanIntersectsWith,
|
|
textSpanIntersectsWithPosition: () => textSpanIntersectsWithPosition,
|
|
textSpanIntersectsWithTextSpan: () => textSpanIntersectsWithTextSpan,
|
|
textSpanIsEmpty: () => textSpanIsEmpty,
|
|
textSpanOverlap: () => textSpanOverlap,
|
|
textSpanOverlapsWith: () => textSpanOverlapsWith,
|
|
textSpansEqual: () => textSpansEqual,
|
|
textToKeywordObj: () => textToKeywordObj,
|
|
timestamp: () => timestamp,
|
|
toArray: () => toArray,
|
|
toBuilderFileEmit: () => toBuilderFileEmit,
|
|
toBuilderStateFileInfoForMultiEmit: () => toBuilderStateFileInfoForMultiEmit,
|
|
toEditorSettings: () => toEditorSettings,
|
|
toFileNameLowerCase: () => toFileNameLowerCase,
|
|
toLowerCase: () => toLowerCase,
|
|
toPath: () => toPath,
|
|
toProgramEmitPending: () => toProgramEmitPending,
|
|
tokenIsIdentifierOrKeyword: () => tokenIsIdentifierOrKeyword,
|
|
tokenIsIdentifierOrKeywordOrGreaterThan: () => tokenIsIdentifierOrKeywordOrGreaterThan,
|
|
tokenToString: () => tokenToString,
|
|
trace: () => trace,
|
|
tracing: () => tracing,
|
|
tracingEnabled: () => tracingEnabled,
|
|
transform: () => transform,
|
|
transformClassFields: () => transformClassFields,
|
|
transformDeclarations: () => transformDeclarations,
|
|
transformECMAScriptModule: () => transformECMAScriptModule,
|
|
transformES2015: () => transformES2015,
|
|
transformES2016: () => transformES2016,
|
|
transformES2017: () => transformES2017,
|
|
transformES2018: () => transformES2018,
|
|
transformES2019: () => transformES2019,
|
|
transformES2020: () => transformES2020,
|
|
transformES2021: () => transformES2021,
|
|
transformES5: () => transformES5,
|
|
transformESNext: () => transformESNext,
|
|
transformGenerators: () => transformGenerators,
|
|
transformJsx: () => transformJsx,
|
|
transformLegacyDecorators: () => transformLegacyDecorators,
|
|
transformModule: () => transformModule,
|
|
transformNodeModule: () => transformNodeModule,
|
|
transformNodes: () => transformNodes,
|
|
transformSystemModule: () => transformSystemModule,
|
|
transformTypeScript: () => transformTypeScript,
|
|
transpile: () => transpile,
|
|
transpileModule: () => transpileModule,
|
|
transpileOptionValueCompilerOptions: () => transpileOptionValueCompilerOptions,
|
|
trimString: () => trimString,
|
|
trimStringEnd: () => trimStringEnd,
|
|
trimStringStart: () => trimStringStart,
|
|
tryAddToSet: () => tryAddToSet,
|
|
tryAndIgnoreErrors: () => tryAndIgnoreErrors,
|
|
tryCast: () => tryCast,
|
|
tryDirectoryExists: () => tryDirectoryExists,
|
|
tryExtractTSExtension: () => tryExtractTSExtension,
|
|
tryFileExists: () => tryFileExists,
|
|
tryGetClassExtendingExpressionWithTypeArguments: () => tryGetClassExtendingExpressionWithTypeArguments,
|
|
tryGetClassImplementingOrExtendingExpressionWithTypeArguments: () => tryGetClassImplementingOrExtendingExpressionWithTypeArguments,
|
|
tryGetDirectories: () => tryGetDirectories,
|
|
tryGetExtensionFromPath: () => tryGetExtensionFromPath2,
|
|
tryGetImportFromModuleSpecifier: () => tryGetImportFromModuleSpecifier,
|
|
tryGetModuleNameFromFile: () => tryGetModuleNameFromFile,
|
|
tryGetModuleSpecifierFromDeclaration: () => tryGetModuleSpecifierFromDeclaration,
|
|
tryGetNativePerformanceHooks: () => tryGetNativePerformanceHooks,
|
|
tryGetPropertyAccessOrIdentifierToString: () => tryGetPropertyAccessOrIdentifierToString,
|
|
tryGetPropertyNameOfBindingOrAssignmentElement: () => tryGetPropertyNameOfBindingOrAssignmentElement,
|
|
tryGetSourceMappingURL: () => tryGetSourceMappingURL,
|
|
tryGetTextOfPropertyName: () => tryGetTextOfPropertyName,
|
|
tryIOAndConsumeErrors: () => tryIOAndConsumeErrors,
|
|
tryParsePattern: () => tryParsePattern,
|
|
tryParsePatterns: () => tryParsePatterns,
|
|
tryParseRawSourceMap: () => tryParseRawSourceMap,
|
|
tryReadDirectory: () => tryReadDirectory,
|
|
tryReadFile: () => tryReadFile,
|
|
tryRemoveDirectoryPrefix: () => tryRemoveDirectoryPrefix,
|
|
tryRemoveExtension: () => tryRemoveExtension,
|
|
tryRemovePrefix: () => tryRemovePrefix,
|
|
tryRemoveSuffix: () => tryRemoveSuffix,
|
|
typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
|
|
typeAliasNamePart: () => typeAliasNamePart,
|
|
typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
|
|
typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
|
|
typeKeywords: () => typeKeywords,
|
|
typeParameterNamePart: () => typeParameterNamePart,
|
|
typeToDisplayParts: () => typeToDisplayParts,
|
|
unchangedPollThresholds: () => unchangedPollThresholds,
|
|
unchangedTextChangeRange: () => unchangedTextChangeRange,
|
|
unescapeLeadingUnderscores: () => unescapeLeadingUnderscores,
|
|
unmangleScopedPackageName: () => unmangleScopedPackageName,
|
|
unorderedRemoveItem: () => unorderedRemoveItem,
|
|
unorderedRemoveItemAt: () => unorderedRemoveItemAt,
|
|
unreachableCodeIsError: () => unreachableCodeIsError,
|
|
unusedLabelIsError: () => unusedLabelIsError,
|
|
unwrapInnermostStatementOfLabel: () => unwrapInnermostStatementOfLabel,
|
|
updateArrayBindingPattern: () => updateArrayBindingPattern,
|
|
updateArrayLiteral: () => updateArrayLiteral,
|
|
updateArrayTypeNode: () => updateArrayTypeNode,
|
|
updateArrowFunction: () => updateArrowFunction,
|
|
updateAsExpression: () => updateAsExpression,
|
|
updateAwait: () => updateAwait,
|
|
updateBinary: () => updateBinary,
|
|
updateBindingElement: () => updateBindingElement,
|
|
updateBlock: () => updateBlock,
|
|
updateBreak: () => updateBreak,
|
|
updateBundle: () => updateBundle,
|
|
updateCall: () => updateCall,
|
|
updateCallChain: () => updateCallChain,
|
|
updateCallSignature: () => updateCallSignature,
|
|
updateCaseBlock: () => updateCaseBlock,
|
|
updateCaseClause: () => updateCaseClause,
|
|
updateCatchClause: () => updateCatchClause,
|
|
updateClassDeclaration: () => updateClassDeclaration,
|
|
updateClassExpression: () => updateClassExpression,
|
|
updateCommaList: () => updateCommaList,
|
|
updateComputedPropertyName: () => updateComputedPropertyName,
|
|
updateConditional: () => updateConditional,
|
|
updateConditionalTypeNode: () => updateConditionalTypeNode,
|
|
updateConstructSignature: () => updateConstructSignature,
|
|
updateConstructor: () => updateConstructor,
|
|
updateConstructorTypeNode: () => updateConstructorTypeNode,
|
|
updateContinue: () => updateContinue,
|
|
updateDecorator: () => updateDecorator,
|
|
updateDefaultClause: () => updateDefaultClause,
|
|
updateDelete: () => updateDelete,
|
|
updateDo: () => updateDo,
|
|
updateElementAccess: () => updateElementAccess,
|
|
updateElementAccessChain: () => updateElementAccessChain,
|
|
updateEnumDeclaration: () => updateEnumDeclaration,
|
|
updateEnumMember: () => updateEnumMember,
|
|
updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
|
|
updateExportAssignment: () => updateExportAssignment,
|
|
updateExportDeclaration: () => updateExportDeclaration,
|
|
updateExportSpecifier: () => updateExportSpecifier,
|
|
updateExpressionStatement: () => updateExpressionStatement,
|
|
updateExpressionWithTypeArguments: () => updateExpressionWithTypeArguments,
|
|
updateExternalModuleReference: () => updateExternalModuleReference,
|
|
updateFor: () => updateFor,
|
|
updateForIn: () => updateForIn,
|
|
updateForOf: () => updateForOf,
|
|
updateFunctionDeclaration: () => updateFunctionDeclaration,
|
|
updateFunctionExpression: () => updateFunctionExpression,
|
|
updateFunctionTypeNode: () => updateFunctionTypeNode,
|
|
updateGetAccessor: () => updateGetAccessor,
|
|
updateHeritageClause: () => updateHeritageClause,
|
|
updateIf: () => updateIf,
|
|
updateImportClause: () => updateImportClause,
|
|
updateImportDeclaration: () => updateImportDeclaration,
|
|
updateImportEqualsDeclaration: () => updateImportEqualsDeclaration,
|
|
updateImportSpecifier: () => updateImportSpecifier,
|
|
updateImportTypeNode: () => updateImportTypeNode,
|
|
updateIndexSignature: () => updateIndexSignature,
|
|
updateIndexedAccessTypeNode: () => updateIndexedAccessTypeNode,
|
|
updateInferTypeNode: () => updateInferTypeNode,
|
|
updateInterfaceDeclaration: () => updateInterfaceDeclaration,
|
|
updateIntersectionTypeNode: () => updateIntersectionTypeNode,
|
|
updateJsxAttribute: () => updateJsxAttribute,
|
|
updateJsxAttributes: () => updateJsxAttributes,
|
|
updateJsxClosingElement: () => updateJsxClosingElement,
|
|
updateJsxElement: () => updateJsxElement,
|
|
updateJsxExpression: () => updateJsxExpression,
|
|
updateJsxFragment: () => updateJsxFragment,
|
|
updateJsxOpeningElement: () => updateJsxOpeningElement,
|
|
updateJsxSelfClosingElement: () => updateJsxSelfClosingElement,
|
|
updateJsxSpreadAttribute: () => updateJsxSpreadAttribute,
|
|
updateJsxText: () => updateJsxText,
|
|
updateLabel: () => updateLabel,
|
|
updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
|
|
updateLiteralTypeNode: () => updateLiteralTypeNode,
|
|
updateMappedTypeNode: () => updateMappedTypeNode,
|
|
updateMetaProperty: () => updateMetaProperty,
|
|
updateMethod: () => updateMethod,
|
|
updateMethodSignature: () => updateMethodSignature,
|
|
updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
|
|
updateModuleBlock: () => updateModuleBlock,
|
|
updateModuleDeclaration: () => updateModuleDeclaration,
|
|
updateNamedExports: () => updateNamedExports,
|
|
updateNamedImports: () => updateNamedImports,
|
|
updateNamespaceExport: () => updateNamespaceExport,
|
|
updateNamespaceExportDeclaration: () => updateNamespaceExportDeclaration,
|
|
updateNamespaceImport: () => updateNamespaceImport,
|
|
updateNew: () => updateNew,
|
|
updateNonNullChain: () => updateNonNullChain,
|
|
updateNonNullExpression: () => updateNonNullExpression,
|
|
updateObjectBindingPattern: () => updateObjectBindingPattern,
|
|
updateObjectLiteral: () => updateObjectLiteral,
|
|
updateOptionalTypeNode: () => updateOptionalTypeNode,
|
|
updatePackageJsonWatch: () => updatePackageJsonWatch,
|
|
updateParameter: () => updateParameter,
|
|
updateParen: () => updateParen,
|
|
updateParenthesizedType: () => updateParenthesizedType,
|
|
updatePartiallyEmittedExpression: () => updatePartiallyEmittedExpression,
|
|
updatePostfix: () => updatePostfix,
|
|
updatePrefix: () => updatePrefix,
|
|
updateProperty: () => updateProperty,
|
|
updatePropertyAccess: () => updatePropertyAccess,
|
|
updatePropertyAccessChain: () => updatePropertyAccessChain,
|
|
updatePropertyAssignment: () => updatePropertyAssignment,
|
|
updatePropertySignature: () => updatePropertySignature,
|
|
updateQualifiedName: () => updateQualifiedName,
|
|
updateRestTypeNode: () => updateRestTypeNode,
|
|
updateReturn: () => updateReturn,
|
|
updateSetAccessor: () => updateSetAccessor,
|
|
updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
|
|
updateShorthandPropertyAssignment: () => updateShorthandPropertyAssignment,
|
|
updateSourceFile: () => updateSourceFile,
|
|
updateSourceFileNode: () => updateSourceFileNode,
|
|
updateSpread: () => updateSpread,
|
|
updateSpreadAssignment: () => updateSpreadAssignment,
|
|
updateStatement: () => updateStatement,
|
|
updateSwitch: () => updateSwitch,
|
|
updateTaggedTemplate: () => updateTaggedTemplate,
|
|
updateTemplateExpression: () => updateTemplateExpression,
|
|
updateTemplateSpan: () => updateTemplateSpan,
|
|
updateThrow: () => updateThrow,
|
|
updateTry: () => updateTry,
|
|
updateTupleTypeNode: () => updateTupleTypeNode,
|
|
updateTypeAliasDeclaration: () => updateTypeAliasDeclaration,
|
|
updateTypeAssertion: () => updateTypeAssertion,
|
|
updateTypeLiteralNode: () => updateTypeLiteralNode,
|
|
updateTypeOf: () => updateTypeOf,
|
|
updateTypeOperatorNode: () => updateTypeOperatorNode,
|
|
updateTypeParameterDeclaration: () => updateTypeParameterDeclaration,
|
|
updateTypePredicateNode: () => updateTypePredicateNode,
|
|
updateTypePredicateNodeWithModifier: () => updateTypePredicateNodeWithModifier,
|
|
updateTypeQueryNode: () => updateTypeQueryNode,
|
|
updateTypeReferenceNode: () => updateTypeReferenceNode,
|
|
updateUnionTypeNode: () => updateUnionTypeNode,
|
|
updateVariableDeclaration: () => updateVariableDeclaration,
|
|
updateVariableDeclarationList: () => updateVariableDeclarationList,
|
|
updateVariableStatement: () => updateVariableStatement,
|
|
updateVoid: () => updateVoid,
|
|
updateWatchingWildcardDirectories: () => updateWatchingWildcardDirectories,
|
|
updateWhile: () => updateWhile,
|
|
updateWith: () => updateWith,
|
|
updateYield: () => updateYield,
|
|
usingSingleLineStringWriter: () => usingSingleLineStringWriter,
|
|
utf16EncodeAsString: () => utf16EncodeAsString,
|
|
validateLocaleAndSetLanguage: () => validateLocaleAndSetLanguage,
|
|
valuesHelper: () => valuesHelper,
|
|
version: () => version,
|
|
versionMajorMinor: () => versionMajorMinor,
|
|
visitArray: () => visitArray,
|
|
visitEachChild: () => visitEachChild,
|
|
visitFunctionBody: () => visitFunctionBody,
|
|
visitIterationBody: () => visitIterationBody,
|
|
visitLexicalEnvironment: () => visitLexicalEnvironment,
|
|
visitNode: () => visitNode,
|
|
visitNodes: () => visitNodes2,
|
|
visitParameterList: () => visitParameterList,
|
|
walkUpBindingElementsAndPatterns: () => walkUpBindingElementsAndPatterns,
|
|
walkUpParenthesizedExpressions: () => walkUpParenthesizedExpressions,
|
|
walkUpParenthesizedTypes: () => walkUpParenthesizedTypes,
|
|
walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
|
|
whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
|
|
writeCommentRange: () => writeCommentRange,
|
|
writeFile: () => writeFile,
|
|
writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
|
|
zipToIterator: () => zipToIterator,
|
|
zipToMap: () => zipToMap,
|
|
zipToModeAwareCache: () => zipToModeAwareCache,
|
|
zipWith: () => zipWith
|
|
});
|
|
|
|
// src/tsserver/_namespaces/ts.server.ts
|
|
var ts_server_exports4 = {};
|
|
__export(ts_server_exports4, {
|
|
ActionInvalidate: () => ActionInvalidate,
|
|
ActionPackageInstalled: () => ActionPackageInstalled,
|
|
ActionSet: () => ActionSet,
|
|
Arguments: () => Arguments,
|
|
AutoImportProviderProject: () => AutoImportProviderProject,
|
|
BaseLogger: () => BaseLogger,
|
|
CharRangeSection: () => CharRangeSection,
|
|
CommandNames: () => CommandNames,
|
|
ConfigFileDiagEvent: () => ConfigFileDiagEvent,
|
|
ConfiguredProject: () => ConfiguredProject2,
|
|
Errors: () => Errors,
|
|
EventBeginInstallTypes: () => EventBeginInstallTypes,
|
|
EventEndInstallTypes: () => EventEndInstallTypes,
|
|
EventInitializationFailed: () => EventInitializationFailed,
|
|
EventTypesRegistry: () => EventTypesRegistry,
|
|
ExternalProject: () => ExternalProject2,
|
|
GcTimer: () => GcTimer,
|
|
InferredProject: () => InferredProject2,
|
|
LargeFileReferencedEvent: () => LargeFileReferencedEvent,
|
|
LineIndex: () => LineIndex,
|
|
LineLeaf: () => LineLeaf,
|
|
LineNode: () => LineNode,
|
|
LogLevel: () => LogLevel2,
|
|
MainProcessLogger: () => MainProcessLogger,
|
|
Msg: () => Msg,
|
|
OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent,
|
|
Project: () => Project3,
|
|
ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent,
|
|
ProjectKind: () => ProjectKind,
|
|
ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
|
|
ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
|
|
ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
|
|
ProjectReferenceProjectLoadKind: () => ProjectReferenceProjectLoadKind,
|
|
ProjectService: () => ProjectService3,
|
|
ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
|
|
ScriptInfo: () => ScriptInfo,
|
|
ScriptVersionCache: () => ScriptVersionCache,
|
|
Session: () => Session3,
|
|
TextStorage: () => TextStorage,
|
|
ThrottledOperations: () => ThrottledOperations,
|
|
TypingsCache: () => TypingsCache,
|
|
WorkerSession: () => WorkerSession,
|
|
allFilesAreJsOrDts: () => allFilesAreJsOrDts,
|
|
allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
|
|
asNormalizedPath: () => asNormalizedPath,
|
|
convertCompilerOptions: () => convertCompilerOptions,
|
|
convertFormatOptions: () => convertFormatOptions,
|
|
convertScriptKindName: () => convertScriptKindName,
|
|
convertTypeAcquisition: () => convertTypeAcquisition,
|
|
convertUserPreferences: () => convertUserPreferences,
|
|
convertWatchOptions: () => convertWatchOptions,
|
|
countEachFileTypes: () => countEachFileTypes,
|
|
createInstallTypingsRequest: () => createInstallTypingsRequest,
|
|
createModuleSpecifierCache: () => createModuleSpecifierCache,
|
|
createNormalizedPathMap: () => createNormalizedPathMap,
|
|
createPackageJsonCache: () => createPackageJsonCache,
|
|
createSortedArray: () => createSortedArray2,
|
|
createWebSystem: () => createWebSystem,
|
|
emptyArray: () => emptyArray2,
|
|
findArgument: () => findArgument,
|
|
forEachResolvedProjectReferenceProject: () => forEachResolvedProjectReferenceProject,
|
|
formatMessage: () => formatMessage2,
|
|
getBaseConfigFileName: () => getBaseConfigFileName,
|
|
getLocationInNewDocument: () => getLocationInNewDocument,
|
|
getLogLevel: () => getLogLevel,
|
|
hasArgument: () => hasArgument,
|
|
hasNoTypeScriptSource: () => hasNoTypeScriptSource,
|
|
indent: () => indent2,
|
|
initializeNodeSystem: () => initializeNodeSystem,
|
|
initializeWebSystem: () => initializeWebSystem,
|
|
isConfigFile: () => isConfigFile,
|
|
isConfiguredProject: () => isConfiguredProject,
|
|
isDynamicFileName: () => isDynamicFileName,
|
|
isExternalProject: () => isExternalProject,
|
|
isInferredProject: () => isInferredProject,
|
|
isInferredProjectName: () => isInferredProjectName,
|
|
makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName,
|
|
makeAuxiliaryProjectName: () => makeAuxiliaryProjectName,
|
|
makeInferredProjectName: () => makeInferredProjectName,
|
|
maxFileSize: () => maxFileSize,
|
|
maxProgramSizeForNonTsFiles: () => maxProgramSizeForNonTsFiles,
|
|
normalizedPathToPath: () => normalizedPathToPath,
|
|
nowString: () => nowString,
|
|
nullCancellationToken: () => nullCancellationToken,
|
|
nullTypingsInstaller: () => nullTypingsInstaller,
|
|
projectContainsInfoDirectly: () => projectContainsInfoDirectly,
|
|
protocol: () => ts_server_protocol_exports,
|
|
removeSorted: () => removeSorted,
|
|
stringifyIndented: () => stringifyIndented,
|
|
toEvent: () => toEvent,
|
|
toNormalizedPath: () => toNormalizedPath,
|
|
tryConvertScriptKindName: () => tryConvertScriptKindName,
|
|
updateProjectIfDirty: () => updateProjectIfDirty
|
|
});
|
|
|
|
// src/compiler/corePublic.ts
|
|
var versionMajorMinor = "5.0";
|
|
var version = `${versionMajorMinor}.0-dev`;
|
|
var Comparison = /* @__PURE__ */ ((Comparison3) => {
|
|
Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
|
|
Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
|
|
Comparison3[Comparison3["GreaterThan"] = 1] = "GreaterThan";
|
|
return Comparison3;
|
|
})(Comparison || {});
|
|
|
|
// src/compiler/core.ts
|
|
function getIterator(iterable) {
|
|
if (iterable) {
|
|
if (isArray(iterable))
|
|
return arrayIterator(iterable);
|
|
if (iterable instanceof Map)
|
|
return iterable.entries();
|
|
if (iterable instanceof Set)
|
|
return iterable.values();
|
|
throw new Error("Iteration not supported.");
|
|
}
|
|
}
|
|
var emptyArray = [];
|
|
var emptyMap = /* @__PURE__ */ new Map();
|
|
var emptySet = /* @__PURE__ */ new Set();
|
|
function length(array) {
|
|
return array ? array.length : 0;
|
|
}
|
|
function forEach(array, callback) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const result = callback(array[i], i);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function forEachRight(array, callback) {
|
|
if (array) {
|
|
for (let i = array.length - 1; i >= 0; i--) {
|
|
const result = callback(array[i], i);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstDefined(array, callback) {
|
|
if (array === void 0) {
|
|
return void 0;
|
|
}
|
|
for (let i = 0; i < array.length; i++) {
|
|
const result = callback(array[i], i);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstDefinedIterator(iter, callback) {
|
|
while (true) {
|
|
const iterResult = iter.next();
|
|
if (iterResult.done) {
|
|
return void 0;
|
|
}
|
|
const result = callback(iterResult.value);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function reduceLeftIterator(iterator, f, initial) {
|
|
let result = initial;
|
|
if (iterator) {
|
|
for (let step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) {
|
|
result = f(result, step.value, pos);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function zipWith(arrayA, arrayB, callback) {
|
|
const result = [];
|
|
Debug.assertEqual(arrayA.length, arrayB.length);
|
|
for (let i = 0; i < arrayA.length; i++) {
|
|
result.push(callback(arrayA[i], arrayB[i], i));
|
|
}
|
|
return result;
|
|
}
|
|
function zipToIterator(arrayA, arrayB) {
|
|
Debug.assertEqual(arrayA.length, arrayB.length);
|
|
let i = 0;
|
|
return {
|
|
next() {
|
|
if (i === arrayA.length) {
|
|
return { value: void 0, done: true };
|
|
}
|
|
i++;
|
|
return { value: [arrayA[i - 1], arrayB[i - 1]], done: false };
|
|
}
|
|
};
|
|
}
|
|
function zipToMap(keys, values) {
|
|
Debug.assert(keys.length === values.length);
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
map2.set(keys[i], values[i]);
|
|
}
|
|
return map2;
|
|
}
|
|
function intersperse(input, element) {
|
|
if (input.length <= 1) {
|
|
return input;
|
|
}
|
|
const result = [];
|
|
for (let i = 0, n = input.length; i < n; i++) {
|
|
if (i)
|
|
result.push(element);
|
|
result.push(input[i]);
|
|
}
|
|
return result;
|
|
}
|
|
function every(array, callback) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (!callback(array[i], i)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function find(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return void 0;
|
|
for (let i = startIndex != null ? startIndex : 0; i < array.length; i++) {
|
|
const value = array[i];
|
|
if (predicate(value, i)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function findLast(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return void 0;
|
|
for (let i = startIndex != null ? startIndex : array.length - 1; i >= 0; i--) {
|
|
const value = array[i];
|
|
if (predicate(value, i)) {
|
|
return value;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function findIndex(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return -1;
|
|
for (let i = startIndex != null ? startIndex : 0; i < array.length; i++) {
|
|
if (predicate(array[i], i)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function findLastIndex(array, predicate, startIndex) {
|
|
if (array === void 0)
|
|
return -1;
|
|
for (let i = startIndex != null ? startIndex : array.length - 1; i >= 0; i--) {
|
|
if (predicate(array[i], i)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function findMap(array, callback) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const result = callback(array[i], i);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return Debug.fail();
|
|
}
|
|
function contains(array, value, equalityComparer = equateValues) {
|
|
if (array) {
|
|
for (const v of array) {
|
|
if (equalityComparer(v, value)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function arraysEqual(a, b, equalityComparer = equateValues) {
|
|
return a.length === b.length && a.every((x, i) => equalityComparer(x, b[i]));
|
|
}
|
|
function indexOfAnyCharCode(text, charCodes, start2) {
|
|
for (let i = start2 || 0; i < text.length; i++) {
|
|
if (contains(charCodes, text.charCodeAt(i))) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function countWhere(array, predicate) {
|
|
let count = 0;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = array[i];
|
|
if (predicate(v, i)) {
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
function filter(array, f) {
|
|
if (array) {
|
|
const len = array.length;
|
|
let i = 0;
|
|
while (i < len && f(array[i]))
|
|
i++;
|
|
if (i < len) {
|
|
const result = array.slice(0, i);
|
|
i++;
|
|
while (i < len) {
|
|
const item = array[i];
|
|
if (f(item)) {
|
|
result.push(item);
|
|
}
|
|
i++;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function filterMutate(array, f) {
|
|
let outIndex = 0;
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (f(array[i], i, array)) {
|
|
array[outIndex] = array[i];
|
|
outIndex++;
|
|
}
|
|
}
|
|
array.length = outIndex;
|
|
}
|
|
function clear(array) {
|
|
array.length = 0;
|
|
}
|
|
function map(array, f) {
|
|
let result;
|
|
if (array) {
|
|
result = [];
|
|
for (let i = 0; i < array.length; i++) {
|
|
result.push(f(array[i], i));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapIterator(iter, mapFn) {
|
|
return {
|
|
next() {
|
|
const iterRes = iter.next();
|
|
return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false };
|
|
}
|
|
};
|
|
}
|
|
function sameMap(array, f) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const item = array[i];
|
|
const mapped = f(item, i);
|
|
if (item !== mapped) {
|
|
const result = array.slice(0, i);
|
|
result.push(mapped);
|
|
for (i++; i < array.length; i++) {
|
|
result.push(f(array[i], i));
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function flatten(array) {
|
|
const result = [];
|
|
for (const v of array) {
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
addRange(result, v);
|
|
} else {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function flatMap(array, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = mapfn(array[i], i);
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
result = addRange(result, v);
|
|
} else {
|
|
result = append(result, v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function flatMapToMutable(array, mapfn) {
|
|
const result = [];
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = mapfn(array[i], i);
|
|
if (v) {
|
|
if (isArray(v)) {
|
|
addRange(result, v);
|
|
} else {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function flatMapIterator(iter, mapfn) {
|
|
const first2 = iter.next();
|
|
if (first2.done) {
|
|
return emptyIterator;
|
|
}
|
|
let currentIter = getIterator2(first2.value);
|
|
return {
|
|
next() {
|
|
while (true) {
|
|
const currentRes = currentIter.next();
|
|
if (!currentRes.done) {
|
|
return currentRes;
|
|
}
|
|
const iterRes = iter.next();
|
|
if (iterRes.done) {
|
|
return iterRes;
|
|
}
|
|
currentIter = getIterator2(iterRes.value);
|
|
}
|
|
}
|
|
};
|
|
function getIterator2(x) {
|
|
const res = mapfn(x);
|
|
return res === void 0 ? emptyIterator : isArray(res) ? arrayIterator(res) : res;
|
|
}
|
|
}
|
|
function sameFlatMap(array, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const item = array[i];
|
|
const mapped = mapfn(item, i);
|
|
if (result || item !== mapped || isArray(mapped)) {
|
|
if (!result) {
|
|
result = array.slice(0, i);
|
|
}
|
|
if (isArray(mapped)) {
|
|
addRange(result, mapped);
|
|
} else {
|
|
result.push(mapped);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result || array;
|
|
}
|
|
function mapAllOrFail(array, mapFn) {
|
|
const result = [];
|
|
for (let i = 0; i < array.length; i++) {
|
|
const mapped = mapFn(array[i], i);
|
|
if (mapped === void 0) {
|
|
return void 0;
|
|
}
|
|
result.push(mapped);
|
|
}
|
|
return result;
|
|
}
|
|
function mapDefined(array, mapFn) {
|
|
const result = [];
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const mapped = mapFn(array[i], i);
|
|
if (mapped !== void 0) {
|
|
result.push(mapped);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapDefinedIterator(iter, mapFn) {
|
|
return {
|
|
next() {
|
|
while (true) {
|
|
const res = iter.next();
|
|
if (res.done) {
|
|
return res;
|
|
}
|
|
const value = mapFn(res.value);
|
|
if (value !== void 0) {
|
|
return { value, done: false };
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function mapDefinedEntries(map2, f) {
|
|
if (!map2) {
|
|
return void 0;
|
|
}
|
|
const result = /* @__PURE__ */ new Map();
|
|
map2.forEach((value, key) => {
|
|
const entry = f(key, value);
|
|
if (entry !== void 0) {
|
|
const [newKey, newValue] = entry;
|
|
if (newKey !== void 0 && newValue !== void 0) {
|
|
result.set(newKey, newValue);
|
|
}
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function mapDefinedValues(set, f) {
|
|
if (set) {
|
|
const result = /* @__PURE__ */ new Set();
|
|
set.forEach((value) => {
|
|
const newValue = f(value);
|
|
if (newValue !== void 0) {
|
|
result.add(newValue);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
}
|
|
function getOrUpdate(map2, key, callback) {
|
|
if (map2.has(key)) {
|
|
return map2.get(key);
|
|
}
|
|
const value = callback();
|
|
map2.set(key, value);
|
|
return value;
|
|
}
|
|
function tryAddToSet(set, value) {
|
|
if (!set.has(value)) {
|
|
set.add(value);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
var emptyIterator = { next: () => ({ value: void 0, done: true }) };
|
|
function singleIterator(value) {
|
|
let done = false;
|
|
return {
|
|
next() {
|
|
const wasDone = done;
|
|
done = true;
|
|
return wasDone ? { value: void 0, done: true } : { value, done: false };
|
|
}
|
|
};
|
|
}
|
|
function spanMap(array, keyfn, mapfn) {
|
|
let result;
|
|
if (array) {
|
|
result = [];
|
|
const len = array.length;
|
|
let previousKey;
|
|
let key;
|
|
let start2 = 0;
|
|
let pos = 0;
|
|
while (start2 < len) {
|
|
while (pos < len) {
|
|
const value = array[pos];
|
|
key = keyfn(value, pos);
|
|
if (pos === 0) {
|
|
previousKey = key;
|
|
} else if (key !== previousKey) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
if (start2 < pos) {
|
|
const v = mapfn(array.slice(start2, pos), previousKey, start2, pos);
|
|
if (v) {
|
|
result.push(v);
|
|
}
|
|
start2 = pos;
|
|
}
|
|
previousKey = key;
|
|
pos++;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapEntries(map2, f) {
|
|
if (!map2) {
|
|
return void 0;
|
|
}
|
|
const result = /* @__PURE__ */ new Map();
|
|
map2.forEach((value, key) => {
|
|
const [newKey, newValue] = f(key, value);
|
|
result.set(newKey, newValue);
|
|
});
|
|
return result;
|
|
}
|
|
function some(array, predicate) {
|
|
if (array) {
|
|
if (predicate) {
|
|
for (const v of array) {
|
|
if (predicate(v)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
return array.length > 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getRangesWhere(arr, pred, cb) {
|
|
let start2;
|
|
for (let i = 0; i < arr.length; i++) {
|
|
if (pred(arr[i])) {
|
|
start2 = start2 === void 0 ? i : start2;
|
|
} else {
|
|
if (start2 !== void 0) {
|
|
cb(start2, i);
|
|
start2 = void 0;
|
|
}
|
|
}
|
|
}
|
|
if (start2 !== void 0)
|
|
cb(start2, arr.length);
|
|
}
|
|
function concatenate(array1, array2) {
|
|
if (!some(array2))
|
|
return array1;
|
|
if (!some(array1))
|
|
return array2;
|
|
return [...array1, ...array2];
|
|
}
|
|
function selectIndex(_, i) {
|
|
return i;
|
|
}
|
|
function indicesOf(array) {
|
|
return array.map(selectIndex);
|
|
}
|
|
function deduplicateRelational(array, equalityComparer, comparer) {
|
|
const indices = indicesOf(array);
|
|
stableSortIndices(array, indices, comparer);
|
|
let last2 = array[indices[0]];
|
|
const deduplicated = [indices[0]];
|
|
for (let i = 1; i < indices.length; i++) {
|
|
const index = indices[i];
|
|
const item = array[index];
|
|
if (!equalityComparer(last2, item)) {
|
|
deduplicated.push(index);
|
|
last2 = item;
|
|
}
|
|
}
|
|
deduplicated.sort();
|
|
return deduplicated.map((i) => array[i]);
|
|
}
|
|
function deduplicateEquality(array, equalityComparer) {
|
|
const result = [];
|
|
for (const item of array) {
|
|
pushIfUnique(result, item, equalityComparer);
|
|
}
|
|
return result;
|
|
}
|
|
function deduplicate(array, equalityComparer, comparer) {
|
|
return array.length === 0 ? [] : array.length === 1 ? array.slice() : comparer ? deduplicateRelational(array, equalityComparer, comparer) : deduplicateEquality(array, equalityComparer);
|
|
}
|
|
function deduplicateSorted(array, comparer) {
|
|
if (array.length === 0)
|
|
return emptyArray;
|
|
let last2 = array[0];
|
|
const deduplicated = [last2];
|
|
for (let i = 1; i < array.length; i++) {
|
|
const next = array[i];
|
|
switch (comparer(next, last2)) {
|
|
case true:
|
|
case 0 /* EqualTo */:
|
|
continue;
|
|
case -1 /* LessThan */:
|
|
return Debug.fail("Array is unsorted.");
|
|
}
|
|
deduplicated.push(last2 = next);
|
|
}
|
|
return deduplicated;
|
|
}
|
|
function createSortedArray() {
|
|
return [];
|
|
}
|
|
function insertSorted(array, insert, compare, allowDuplicates) {
|
|
if (array.length === 0) {
|
|
array.push(insert);
|
|
return true;
|
|
}
|
|
const insertIndex = binarySearch(array, insert, identity, compare);
|
|
if (insertIndex < 0) {
|
|
array.splice(~insertIndex, 0, insert);
|
|
return true;
|
|
}
|
|
if (allowDuplicates) {
|
|
array.splice(insertIndex, 0, insert);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function sortAndDeduplicate(array, comparer, equalityComparer) {
|
|
return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive);
|
|
}
|
|
function arrayIsSorted(array, comparer) {
|
|
if (array.length < 2)
|
|
return true;
|
|
let prevElement = array[0];
|
|
for (const element of array.slice(1)) {
|
|
if (comparer(prevElement, element) === 1 /* GreaterThan */) {
|
|
return false;
|
|
}
|
|
prevElement = element;
|
|
}
|
|
return true;
|
|
}
|
|
function arrayIsEqualTo(array1, array2, equalityComparer = equateValues) {
|
|
if (!array1 || !array2) {
|
|
return array1 === array2;
|
|
}
|
|
if (array1.length !== array2.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < array1.length; i++) {
|
|
if (!equalityComparer(array1[i], array2[i], i)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function compact(array) {
|
|
let result;
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const v = array[i];
|
|
if (result || !v) {
|
|
if (!result) {
|
|
result = array.slice(0, i);
|
|
}
|
|
if (v) {
|
|
result.push(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result || array;
|
|
}
|
|
function relativeComplement(arrayA, arrayB, comparer) {
|
|
if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0)
|
|
return arrayB;
|
|
const result = [];
|
|
loopB:
|
|
for (let offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) {
|
|
if (offsetB > 0) {
|
|
Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0 /* EqualTo */);
|
|
}
|
|
loopA:
|
|
for (const startA = offsetA; offsetA < arrayA.length; offsetA++) {
|
|
if (offsetA > startA) {
|
|
Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0 /* EqualTo */);
|
|
}
|
|
switch (comparer(arrayB[offsetB], arrayA[offsetA])) {
|
|
case -1 /* LessThan */:
|
|
result.push(arrayB[offsetB]);
|
|
continue loopB;
|
|
case 0 /* EqualTo */:
|
|
continue loopB;
|
|
case 1 /* GreaterThan */:
|
|
continue loopA;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function sum(array, prop) {
|
|
let result = 0;
|
|
for (const v of array) {
|
|
result += v[prop];
|
|
}
|
|
return result;
|
|
}
|
|
function append(to, value) {
|
|
if (value === void 0)
|
|
return to;
|
|
if (to === void 0)
|
|
return [value];
|
|
to.push(value);
|
|
return to;
|
|
}
|
|
function combine(xs, ys) {
|
|
if (xs === void 0)
|
|
return ys;
|
|
if (ys === void 0)
|
|
return xs;
|
|
if (isArray(xs))
|
|
return isArray(ys) ? concatenate(xs, ys) : append(xs, ys);
|
|
if (isArray(ys))
|
|
return append(ys, xs);
|
|
return [xs, ys];
|
|
}
|
|
function toOffset(array, offset) {
|
|
return offset < 0 ? array.length + offset : offset;
|
|
}
|
|
function addRange(to, from, start2, end) {
|
|
if (from === void 0 || from.length === 0)
|
|
return to;
|
|
if (to === void 0)
|
|
return from.slice(start2, end);
|
|
start2 = start2 === void 0 ? 0 : toOffset(from, start2);
|
|
end = end === void 0 ? from.length : toOffset(from, end);
|
|
for (let i = start2; i < end && i < from.length; i++) {
|
|
if (from[i] !== void 0) {
|
|
to.push(from[i]);
|
|
}
|
|
}
|
|
return to;
|
|
}
|
|
function pushIfUnique(array, toAdd, equalityComparer) {
|
|
if (contains(array, toAdd, equalityComparer)) {
|
|
return false;
|
|
} else {
|
|
array.push(toAdd);
|
|
return true;
|
|
}
|
|
}
|
|
function appendIfUnique(array, toAdd, equalityComparer) {
|
|
if (array) {
|
|
pushIfUnique(array, toAdd, equalityComparer);
|
|
return array;
|
|
} else {
|
|
return [toAdd];
|
|
}
|
|
}
|
|
function stableSortIndices(array, indices, comparer) {
|
|
indices.sort((x, y) => comparer(array[x], array[y]) || compareValues(x, y));
|
|
}
|
|
function sort(array, comparer) {
|
|
return array.length === 0 ? array : array.slice().sort(comparer);
|
|
}
|
|
function arrayIterator(array) {
|
|
let i = 0;
|
|
return { next: () => {
|
|
if (i === array.length) {
|
|
return { value: void 0, done: true };
|
|
} else {
|
|
i++;
|
|
return { value: array[i - 1], done: false };
|
|
}
|
|
} };
|
|
}
|
|
function arrayReverseIterator(array) {
|
|
let i = array.length;
|
|
return {
|
|
next: () => {
|
|
if (i === 0) {
|
|
return { value: void 0, done: true };
|
|
} else {
|
|
i--;
|
|
return { value: array[i], done: false };
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function stableSort(array, comparer) {
|
|
const indices = indicesOf(array);
|
|
stableSortIndices(array, indices, comparer);
|
|
return indices.map((i) => array[i]);
|
|
}
|
|
function rangeEquals(array1, array2, pos, end) {
|
|
while (pos < end) {
|
|
if (array1[pos] !== array2[pos]) {
|
|
return false;
|
|
}
|
|
pos++;
|
|
}
|
|
return true;
|
|
}
|
|
function elementAt(array, offset) {
|
|
if (array) {
|
|
offset = toOffset(array, offset);
|
|
if (offset < array.length) {
|
|
return array[offset];
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function firstOrUndefined(array) {
|
|
return array === void 0 || array.length === 0 ? void 0 : array[0];
|
|
}
|
|
function first(array) {
|
|
Debug.assert(array.length !== 0);
|
|
return array[0];
|
|
}
|
|
function lastOrUndefined(array) {
|
|
return array === void 0 || array.length === 0 ? void 0 : array[array.length - 1];
|
|
}
|
|
function last(array) {
|
|
Debug.assert(array.length !== 0);
|
|
return array[array.length - 1];
|
|
}
|
|
function singleOrUndefined(array) {
|
|
return array && array.length === 1 ? array[0] : void 0;
|
|
}
|
|
function single(array) {
|
|
return Debug.checkDefined(singleOrUndefined(array));
|
|
}
|
|
function singleOrMany(array) {
|
|
return array && array.length === 1 ? array[0] : array;
|
|
}
|
|
function replaceElement(array, index, value) {
|
|
const result = array.slice(0);
|
|
result[index] = value;
|
|
return result;
|
|
}
|
|
function binarySearch(array, value, keySelector, keyComparer, offset) {
|
|
return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset);
|
|
}
|
|
function binarySearchKey(array, key, keySelector, keyComparer, offset) {
|
|
if (!some(array)) {
|
|
return -1;
|
|
}
|
|
let low = offset || 0;
|
|
let high = array.length - 1;
|
|
while (low <= high) {
|
|
const middle = low + (high - low >> 1);
|
|
const midKey = keySelector(array[middle], middle);
|
|
switch (keyComparer(midKey, key)) {
|
|
case -1 /* LessThan */:
|
|
low = middle + 1;
|
|
break;
|
|
case 0 /* EqualTo */:
|
|
return middle;
|
|
case 1 /* GreaterThan */:
|
|
high = middle - 1;
|
|
break;
|
|
}
|
|
}
|
|
return ~low;
|
|
}
|
|
function reduceLeft(array, f, initial, start2, count) {
|
|
if (array && array.length > 0) {
|
|
const size = array.length;
|
|
if (size > 0) {
|
|
let pos = start2 === void 0 || start2 < 0 ? 0 : start2;
|
|
const end = count === void 0 || pos + count > size - 1 ? size - 1 : pos + count;
|
|
let result;
|
|
if (arguments.length <= 2) {
|
|
result = array[pos];
|
|
pos++;
|
|
} else {
|
|
result = initial;
|
|
}
|
|
while (pos <= end) {
|
|
result = f(result, array[pos], pos);
|
|
pos++;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
return initial;
|
|
}
|
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
|
function hasProperty(map2, key) {
|
|
return hasOwnProperty.call(map2, key);
|
|
}
|
|
function getProperty(map2, key) {
|
|
return hasOwnProperty.call(map2, key) ? map2[key] : void 0;
|
|
}
|
|
function getOwnKeys(map2) {
|
|
const keys = [];
|
|
for (const key in map2) {
|
|
if (hasOwnProperty.call(map2, key)) {
|
|
keys.push(key);
|
|
}
|
|
}
|
|
return keys;
|
|
}
|
|
function getAllKeys(obj) {
|
|
const result = [];
|
|
do {
|
|
const names = Object.getOwnPropertyNames(obj);
|
|
for (const name of names) {
|
|
pushIfUnique(result, name);
|
|
}
|
|
} while (obj = Object.getPrototypeOf(obj));
|
|
return result;
|
|
}
|
|
function getOwnValues(collection) {
|
|
const values = [];
|
|
for (const key in collection) {
|
|
if (hasOwnProperty.call(collection, key)) {
|
|
values.push(collection[key]);
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
var _entries = Object.entries || ((obj) => {
|
|
const keys = getOwnKeys(obj);
|
|
const result = Array(keys.length);
|
|
for (let i = 0; i < keys.length; i++) {
|
|
result[i] = [keys[i], obj[keys[i]]];
|
|
}
|
|
return result;
|
|
});
|
|
function getEntries(obj) {
|
|
return obj ? _entries(obj) : [];
|
|
}
|
|
function arrayOf(count, f) {
|
|
const result = new Array(count);
|
|
for (let i = 0; i < count; i++) {
|
|
result[i] = f(i);
|
|
}
|
|
return result;
|
|
}
|
|
function arrayFrom(iterator, map2) {
|
|
const result = [];
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
result.push(map2 ? map2(iterResult.value) : iterResult.value);
|
|
}
|
|
return result;
|
|
}
|
|
function assign(t, ...args) {
|
|
for (const arg of args) {
|
|
if (arg === void 0)
|
|
continue;
|
|
for (const p in arg) {
|
|
if (hasProperty(arg, p)) {
|
|
t[p] = arg[p];
|
|
}
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
function equalOwnProperties(left, right, equalityComparer = equateValues) {
|
|
if (left === right)
|
|
return true;
|
|
if (!left || !right)
|
|
return false;
|
|
for (const key in left) {
|
|
if (hasOwnProperty.call(left, key)) {
|
|
if (!hasOwnProperty.call(right, key))
|
|
return false;
|
|
if (!equalityComparer(left[key], right[key]))
|
|
return false;
|
|
}
|
|
}
|
|
for (const key in right) {
|
|
if (hasOwnProperty.call(right, key)) {
|
|
if (!hasOwnProperty.call(left, key))
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function arrayToMap(array, makeKey, makeValue = identity) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
for (const value of array) {
|
|
const key = makeKey(value);
|
|
if (key !== void 0)
|
|
result.set(key, makeValue(value));
|
|
}
|
|
return result;
|
|
}
|
|
function arrayToNumericMap(array, makeKey, makeValue = identity) {
|
|
const result = [];
|
|
for (const value of array) {
|
|
result[makeKey(value)] = makeValue(value);
|
|
}
|
|
return result;
|
|
}
|
|
function arrayToMultiMap(values, makeKey, makeValue = identity) {
|
|
const result = createMultiMap();
|
|
for (const value of values) {
|
|
result.add(makeKey(value), makeValue(value));
|
|
}
|
|
return result;
|
|
}
|
|
function group(values, getGroupId, resultSelector = identity) {
|
|
return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector);
|
|
}
|
|
function clone(object) {
|
|
const result = {};
|
|
for (const id in object) {
|
|
if (hasOwnProperty.call(object, id)) {
|
|
result[id] = object[id];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function extend(first2, second) {
|
|
const result = {};
|
|
for (const id in second) {
|
|
if (hasOwnProperty.call(second, id)) {
|
|
result[id] = second[id];
|
|
}
|
|
}
|
|
for (const id in first2) {
|
|
if (hasOwnProperty.call(first2, id)) {
|
|
result[id] = first2[id];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function copyProperties(first2, second) {
|
|
for (const id in second) {
|
|
if (hasOwnProperty.call(second, id)) {
|
|
first2[id] = second[id];
|
|
}
|
|
}
|
|
}
|
|
function maybeBind(obj, fn) {
|
|
return fn ? fn.bind(obj) : void 0;
|
|
}
|
|
function createMultiMap() {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
map2.add = multiMapAdd;
|
|
map2.remove = multiMapRemove;
|
|
return map2;
|
|
}
|
|
function multiMapAdd(key, value) {
|
|
let values = this.get(key);
|
|
if (values) {
|
|
values.push(value);
|
|
} else {
|
|
this.set(key, values = [value]);
|
|
}
|
|
return values;
|
|
}
|
|
function multiMapRemove(key, value) {
|
|
const values = this.get(key);
|
|
if (values) {
|
|
unorderedRemoveItem(values, value);
|
|
if (!values.length) {
|
|
this.delete(key);
|
|
}
|
|
}
|
|
}
|
|
function createUnderscoreEscapedMultiMap() {
|
|
return createMultiMap();
|
|
}
|
|
function createQueue(items) {
|
|
const elements = (items == null ? void 0 : items.slice()) || [];
|
|
let headIndex = 0;
|
|
function isEmpty() {
|
|
return headIndex === elements.length;
|
|
}
|
|
function enqueue(...items2) {
|
|
elements.push(...items2);
|
|
}
|
|
function dequeue() {
|
|
if (isEmpty()) {
|
|
throw new Error("Queue is empty");
|
|
}
|
|
const result = elements[headIndex];
|
|
elements[headIndex] = void 0;
|
|
headIndex++;
|
|
if (headIndex > 100 && headIndex > elements.length >> 1) {
|
|
const newLength = elements.length - headIndex;
|
|
elements.copyWithin(0, headIndex);
|
|
elements.length = newLength;
|
|
headIndex = 0;
|
|
}
|
|
return result;
|
|
}
|
|
return {
|
|
enqueue,
|
|
dequeue,
|
|
isEmpty
|
|
};
|
|
}
|
|
function createSet(getHashCode, equals) {
|
|
const multiMap = /* @__PURE__ */ new Map();
|
|
let size = 0;
|
|
function getElementIterator() {
|
|
const valueIt = multiMap.values();
|
|
let arrayIt;
|
|
const it = {
|
|
next: () => {
|
|
while (true) {
|
|
if (arrayIt) {
|
|
const n = arrayIt.next();
|
|
if (!n.done) {
|
|
return { value: n.value };
|
|
}
|
|
arrayIt = void 0;
|
|
} else {
|
|
const n = valueIt.next();
|
|
if (n.done) {
|
|
return { value: void 0, done: true };
|
|
}
|
|
if (!isArray(n.value)) {
|
|
return { value: n.value };
|
|
}
|
|
arrayIt = arrayIterator(n.value);
|
|
}
|
|
}
|
|
},
|
|
[Symbol.iterator]: () => {
|
|
return it;
|
|
}
|
|
};
|
|
return it;
|
|
}
|
|
const set = {
|
|
has(element) {
|
|
const hash = getHashCode(element);
|
|
if (!multiMap.has(hash))
|
|
return false;
|
|
const candidates = multiMap.get(hash);
|
|
if (!isArray(candidates))
|
|
return equals(candidates, element);
|
|
for (const candidate of candidates) {
|
|
if (equals(candidate, element)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
add(element) {
|
|
const hash = getHashCode(element);
|
|
if (multiMap.has(hash)) {
|
|
const values = multiMap.get(hash);
|
|
if (isArray(values)) {
|
|
if (!contains(values, element, equals)) {
|
|
values.push(element);
|
|
size++;
|
|
}
|
|
} else {
|
|
const value = values;
|
|
if (!equals(value, element)) {
|
|
multiMap.set(hash, [value, element]);
|
|
size++;
|
|
}
|
|
}
|
|
} else {
|
|
multiMap.set(hash, element);
|
|
size++;
|
|
}
|
|
return this;
|
|
},
|
|
delete(element) {
|
|
const hash = getHashCode(element);
|
|
if (!multiMap.has(hash))
|
|
return false;
|
|
const candidates = multiMap.get(hash);
|
|
if (isArray(candidates)) {
|
|
for (let i = 0; i < candidates.length; i++) {
|
|
if (equals(candidates[i], element)) {
|
|
if (candidates.length === 1) {
|
|
multiMap.delete(hash);
|
|
} else if (candidates.length === 2) {
|
|
multiMap.set(hash, candidates[1 - i]);
|
|
} else {
|
|
unorderedRemoveItemAt(candidates, i);
|
|
}
|
|
size--;
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
const candidate = candidates;
|
|
if (equals(candidate, element)) {
|
|
multiMap.delete(hash);
|
|
size--;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
},
|
|
clear() {
|
|
multiMap.clear();
|
|
size = 0;
|
|
},
|
|
get size() {
|
|
return size;
|
|
},
|
|
forEach(action) {
|
|
for (const elements of arrayFrom(multiMap.values())) {
|
|
if (isArray(elements)) {
|
|
for (const element of elements) {
|
|
action(element, element, set);
|
|
}
|
|
} else {
|
|
const element = elements;
|
|
action(element, element, set);
|
|
}
|
|
}
|
|
},
|
|
keys() {
|
|
return getElementIterator();
|
|
},
|
|
values() {
|
|
return getElementIterator();
|
|
},
|
|
entries() {
|
|
const it = getElementIterator();
|
|
const it2 = {
|
|
next: () => {
|
|
const n = it.next();
|
|
return n.done ? n : { value: [n.value, n.value] };
|
|
},
|
|
[Symbol.iterator]: () => it2
|
|
};
|
|
return it2;
|
|
},
|
|
[Symbol.iterator]: () => {
|
|
return getElementIterator();
|
|
},
|
|
[Symbol.toStringTag]: multiMap[Symbol.toStringTag]
|
|
};
|
|
return set;
|
|
}
|
|
function isArray(value) {
|
|
return Array.isArray ? Array.isArray(value) : value instanceof Array;
|
|
}
|
|
function toArray(value) {
|
|
return isArray(value) ? value : [value];
|
|
}
|
|
function isString(text) {
|
|
return typeof text === "string";
|
|
}
|
|
function isNumber(x) {
|
|
return typeof x === "number";
|
|
}
|
|
function tryCast(value, test) {
|
|
return value !== void 0 && test(value) ? value : void 0;
|
|
}
|
|
function cast(value, test) {
|
|
if (value !== void 0 && test(value))
|
|
return value;
|
|
return Debug.fail(`Invalid cast. The supplied value ${value} did not pass the test '${Debug.getFunctionName(test)}'.`);
|
|
}
|
|
function noop(_) {
|
|
}
|
|
var noopPush = {
|
|
push: noop,
|
|
length: 0
|
|
};
|
|
function returnFalse() {
|
|
return false;
|
|
}
|
|
function returnTrue() {
|
|
return true;
|
|
}
|
|
function returnUndefined() {
|
|
return void 0;
|
|
}
|
|
function identity(x) {
|
|
return x;
|
|
}
|
|
function toLowerCase(x) {
|
|
return x.toLowerCase();
|
|
}
|
|
var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
|
|
function toFileNameLowerCase(x) {
|
|
return fileNameLowerCaseRegExp.test(x) ? x.replace(fileNameLowerCaseRegExp, toLowerCase) : x;
|
|
}
|
|
function notImplemented() {
|
|
throw new Error("Not implemented");
|
|
}
|
|
function memoize(callback) {
|
|
let value;
|
|
return () => {
|
|
if (callback) {
|
|
value = callback();
|
|
callback = void 0;
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
function memoizeOne(callback) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
return (arg) => {
|
|
const key = `${typeof arg}:${arg}`;
|
|
let value = map2.get(key);
|
|
if (value === void 0 && !map2.has(key)) {
|
|
value = callback(arg);
|
|
map2.set(key, value);
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
function compose(a, b, c, d, e) {
|
|
if (!!e) {
|
|
const args = [];
|
|
for (let i = 0; i < arguments.length; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
return (t) => reduceLeft(args, (u, f) => f(u), t);
|
|
} else if (d) {
|
|
return (t) => d(c(b(a(t))));
|
|
} else if (c) {
|
|
return (t) => c(b(a(t)));
|
|
} else if (b) {
|
|
return (t) => b(a(t));
|
|
} else if (a) {
|
|
return (t) => a(t);
|
|
} else {
|
|
return (t) => t;
|
|
}
|
|
}
|
|
var AssertionLevel = /* @__PURE__ */ ((AssertionLevel2) => {
|
|
AssertionLevel2[AssertionLevel2["None"] = 0] = "None";
|
|
AssertionLevel2[AssertionLevel2["Normal"] = 1] = "Normal";
|
|
AssertionLevel2[AssertionLevel2["Aggressive"] = 2] = "Aggressive";
|
|
AssertionLevel2[AssertionLevel2["VeryAggressive"] = 3] = "VeryAggressive";
|
|
return AssertionLevel2;
|
|
})(AssertionLevel || {});
|
|
function equateValues(a, b) {
|
|
return a === b;
|
|
}
|
|
function equateStringsCaseInsensitive(a, b) {
|
|
return a === b || a !== void 0 && b !== void 0 && a.toUpperCase() === b.toUpperCase();
|
|
}
|
|
function equateStringsCaseSensitive(a, b) {
|
|
return equateValues(a, b);
|
|
}
|
|
function compareComparableValues(a, b) {
|
|
return a === b ? 0 /* EqualTo */ : a === void 0 ? -1 /* LessThan */ : b === void 0 ? 1 /* GreaterThan */ : a < b ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
}
|
|
function compareValues(a, b) {
|
|
return compareComparableValues(a, b);
|
|
}
|
|
function compareTextSpans(a, b) {
|
|
return compareValues(a == null ? void 0 : a.start, b == null ? void 0 : b.start) || compareValues(a == null ? void 0 : a.length, b == null ? void 0 : b.length);
|
|
}
|
|
function min(items, compare) {
|
|
return reduceLeft(items, (x, y) => compare(x, y) === -1 /* LessThan */ ? x : y);
|
|
}
|
|
function compareStringsCaseInsensitive(a, b) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
a = a.toUpperCase();
|
|
b = b.toUpperCase();
|
|
return a < b ? -1 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
function compareStringsCaseSensitive(a, b) {
|
|
return compareComparableValues(a, b);
|
|
}
|
|
function getStringComparer(ignoreCase) {
|
|
return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive;
|
|
}
|
|
var createUIStringComparer = (() => {
|
|
let defaultComparer;
|
|
let enUSComparer;
|
|
const stringComparerFactory = getStringComparerFactory();
|
|
return createStringComparer;
|
|
function compareWithCallback(a, b, comparer) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
const value = comparer(a, b);
|
|
return value < 0 ? -1 /* LessThan */ : value > 0 ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
function createIntlCollatorStringComparer(locale) {
|
|
const comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare;
|
|
return (a, b) => compareWithCallback(a, b, comparer);
|
|
}
|
|
function createLocaleCompareStringComparer(locale) {
|
|
if (locale !== void 0)
|
|
return createFallbackStringComparer();
|
|
return (a, b) => compareWithCallback(a, b, compareStrings);
|
|
function compareStrings(a, b) {
|
|
return a.localeCompare(b);
|
|
}
|
|
}
|
|
function createFallbackStringComparer() {
|
|
return (a, b) => compareWithCallback(a, b, compareDictionaryOrder);
|
|
function compareDictionaryOrder(a, b) {
|
|
return compareStrings(a.toUpperCase(), b.toUpperCase()) || compareStrings(a, b);
|
|
}
|
|
function compareStrings(a, b) {
|
|
return a < b ? -1 /* LessThan */ : a > b ? 1 /* GreaterThan */ : 0 /* EqualTo */;
|
|
}
|
|
}
|
|
function getStringComparerFactory() {
|
|
if (typeof Intl === "object" && typeof Intl.Collator === "function") {
|
|
return createIntlCollatorStringComparer;
|
|
}
|
|
if (typeof String.prototype.localeCompare === "function" && typeof String.prototype.toLocaleUpperCase === "function" && "a".localeCompare("B") < 0) {
|
|
return createLocaleCompareStringComparer;
|
|
}
|
|
return createFallbackStringComparer;
|
|
}
|
|
function createStringComparer(locale) {
|
|
if (locale === void 0) {
|
|
return defaultComparer || (defaultComparer = stringComparerFactory(locale));
|
|
} else if (locale === "en-US") {
|
|
return enUSComparer || (enUSComparer = stringComparerFactory(locale));
|
|
} else {
|
|
return stringComparerFactory(locale);
|
|
}
|
|
}
|
|
})();
|
|
var uiComparerCaseSensitive;
|
|
var uiLocale;
|
|
function getUILocale() {
|
|
return uiLocale;
|
|
}
|
|
function setUILocale(value) {
|
|
if (uiLocale !== value) {
|
|
uiLocale = value;
|
|
uiComparerCaseSensitive = void 0;
|
|
}
|
|
}
|
|
function compareStringsCaseSensitiveUI(a, b) {
|
|
const comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = createUIStringComparer(uiLocale));
|
|
return comparer(a, b);
|
|
}
|
|
function compareProperties(a, b, key, comparer) {
|
|
return a === b ? 0 /* EqualTo */ : a === void 0 ? -1 /* LessThan */ : b === void 0 ? 1 /* GreaterThan */ : comparer(a[key], b[key]);
|
|
}
|
|
function compareBooleans(a, b) {
|
|
return compareValues(a ? 1 : 0, b ? 1 : 0);
|
|
}
|
|
function getSpellingSuggestion(name, candidates, getName) {
|
|
const maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34));
|
|
let bestDistance = Math.floor(name.length * 0.4) + 1;
|
|
let bestCandidate;
|
|
for (const candidate of candidates) {
|
|
const candidateName = getName(candidate);
|
|
if (candidateName !== void 0 && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) {
|
|
if (candidateName === name) {
|
|
continue;
|
|
}
|
|
if (candidateName.length < 3 && candidateName.toLowerCase() !== name.toLowerCase()) {
|
|
continue;
|
|
}
|
|
const distance = levenshteinWithMax(name, candidateName, bestDistance - 0.1);
|
|
if (distance === void 0) {
|
|
continue;
|
|
}
|
|
Debug.assert(distance < bestDistance);
|
|
bestDistance = distance;
|
|
bestCandidate = candidate;
|
|
}
|
|
}
|
|
return bestCandidate;
|
|
}
|
|
function levenshteinWithMax(s1, s2, max) {
|
|
let previous = new Array(s2.length + 1);
|
|
let current = new Array(s2.length + 1);
|
|
const big = max + 0.01;
|
|
for (let i = 0; i <= s2.length; i++) {
|
|
previous[i] = i;
|
|
}
|
|
for (let i = 1; i <= s1.length; i++) {
|
|
const c1 = s1.charCodeAt(i - 1);
|
|
const minJ = Math.ceil(i > max ? i - max : 1);
|
|
const maxJ = Math.floor(s2.length > max + i ? max + i : s2.length);
|
|
current[0] = i;
|
|
let colMin = i;
|
|
for (let j = 1; j < minJ; j++) {
|
|
current[j] = big;
|
|
}
|
|
for (let j = minJ; j <= maxJ; j++) {
|
|
const substitutionDistance = s1[i - 1].toLowerCase() === s2[j - 1].toLowerCase() ? previous[j - 1] + 0.1 : previous[j - 1] + 2;
|
|
const dist = c1 === s2.charCodeAt(j - 1) ? previous[j - 1] : Math.min(previous[j] + 1, current[j - 1] + 1, substitutionDistance);
|
|
current[j] = dist;
|
|
colMin = Math.min(colMin, dist);
|
|
}
|
|
for (let j = maxJ + 1; j <= s2.length; j++) {
|
|
current[j] = big;
|
|
}
|
|
if (colMin > max) {
|
|
return void 0;
|
|
}
|
|
const temp = previous;
|
|
previous = current;
|
|
current = temp;
|
|
}
|
|
const res = previous[s2.length];
|
|
return res > max ? void 0 : res;
|
|
}
|
|
function endsWith(str, suffix) {
|
|
const expectedPos = str.length - suffix.length;
|
|
return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
|
|
}
|
|
function removeSuffix(str, suffix) {
|
|
return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str;
|
|
}
|
|
function tryRemoveSuffix(str, suffix) {
|
|
return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : void 0;
|
|
}
|
|
function stringContains(str, substring) {
|
|
return str.indexOf(substring) !== -1;
|
|
}
|
|
function removeMinAndVersionNumbers(fileName) {
|
|
let end = fileName.length;
|
|
for (let pos = end - 1; pos > 0; pos--) {
|
|
let ch = fileName.charCodeAt(pos);
|
|
if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {
|
|
do {
|
|
--pos;
|
|
ch = fileName.charCodeAt(pos);
|
|
} while (pos > 0 && ch >= 48 /* _0 */ && ch <= 57 /* _9 */);
|
|
} else if (pos > 4 && (ch === 110 /* n */ || ch === 78 /* N */)) {
|
|
--pos;
|
|
ch = fileName.charCodeAt(pos);
|
|
if (ch !== 105 /* i */ && ch !== 73 /* I */) {
|
|
break;
|
|
}
|
|
--pos;
|
|
ch = fileName.charCodeAt(pos);
|
|
if (ch !== 109 /* m */ && ch !== 77 /* M */) {
|
|
break;
|
|
}
|
|
--pos;
|
|
ch = fileName.charCodeAt(pos);
|
|
} else {
|
|
break;
|
|
}
|
|
if (ch !== 45 /* minus */ && ch !== 46 /* dot */) {
|
|
break;
|
|
}
|
|
end = pos;
|
|
}
|
|
return end === fileName.length ? fileName : fileName.slice(0, end);
|
|
}
|
|
function orderedRemoveItem(array, item) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (array[i] === item) {
|
|
orderedRemoveItemAt(array, i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function orderedRemoveItemAt(array, index) {
|
|
for (let i = index; i < array.length - 1; i++) {
|
|
array[i] = array[i + 1];
|
|
}
|
|
array.pop();
|
|
}
|
|
function unorderedRemoveItemAt(array, index) {
|
|
array[index] = array[array.length - 1];
|
|
array.pop();
|
|
}
|
|
function unorderedRemoveItem(array, item) {
|
|
return unorderedRemoveFirstItemWhere(array, (element) => element === item);
|
|
}
|
|
function unorderedRemoveFirstItemWhere(array, predicate) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (predicate(array[i])) {
|
|
unorderedRemoveItemAt(array, i);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createGetCanonicalFileName(useCaseSensitiveFileNames) {
|
|
return useCaseSensitiveFileNames ? identity : toFileNameLowerCase;
|
|
}
|
|
function patternText({ prefix, suffix }) {
|
|
return `${prefix}*${suffix}`;
|
|
}
|
|
function matchedText(pattern, candidate) {
|
|
Debug.assert(isPatternMatch(pattern, candidate));
|
|
return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length);
|
|
}
|
|
function findBestPatternMatch(values, getPattern, candidate) {
|
|
let matchedValue;
|
|
let longestMatchPrefixLength = -1;
|
|
for (const v of values) {
|
|
const pattern = getPattern(v);
|
|
if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
|
|
longestMatchPrefixLength = pattern.prefix.length;
|
|
matchedValue = v;
|
|
}
|
|
}
|
|
return matchedValue;
|
|
}
|
|
function startsWith(str, prefix) {
|
|
return str.lastIndexOf(prefix, 0) === 0;
|
|
}
|
|
function removePrefix(str, prefix) {
|
|
return startsWith(str, prefix) ? str.substr(prefix.length) : str;
|
|
}
|
|
function tryRemovePrefix(str, prefix, getCanonicalFileName = identity) {
|
|
return startsWith(getCanonicalFileName(str), getCanonicalFileName(prefix)) ? str.substring(prefix.length) : void 0;
|
|
}
|
|
function isPatternMatch({ prefix, suffix }, candidate) {
|
|
return candidate.length >= prefix.length + suffix.length && startsWith(candidate, prefix) && endsWith(candidate, suffix);
|
|
}
|
|
function and(f, g) {
|
|
return (arg) => f(arg) && g(arg);
|
|
}
|
|
function or(...fs) {
|
|
return (...args) => {
|
|
let lastResult;
|
|
for (const f of fs) {
|
|
lastResult = f(...args);
|
|
if (lastResult) {
|
|
return lastResult;
|
|
}
|
|
}
|
|
return lastResult;
|
|
};
|
|
}
|
|
function not(fn) {
|
|
return (...args) => !fn(...args);
|
|
}
|
|
function assertType(_) {
|
|
}
|
|
function singleElementArray(t) {
|
|
return t === void 0 ? void 0 : [t];
|
|
}
|
|
function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) {
|
|
unchanged = unchanged || noop;
|
|
let newIndex = 0;
|
|
let oldIndex = 0;
|
|
const newLen = newItems.length;
|
|
const oldLen = oldItems.length;
|
|
let hasChanges = false;
|
|
while (newIndex < newLen && oldIndex < oldLen) {
|
|
const newItem = newItems[newIndex];
|
|
const oldItem = oldItems[oldIndex];
|
|
const compareResult = comparer(newItem, oldItem);
|
|
if (compareResult === -1 /* LessThan */) {
|
|
inserted(newItem);
|
|
newIndex++;
|
|
hasChanges = true;
|
|
} else if (compareResult === 1 /* GreaterThan */) {
|
|
deleted(oldItem);
|
|
oldIndex++;
|
|
hasChanges = true;
|
|
} else {
|
|
unchanged(oldItem, newItem);
|
|
newIndex++;
|
|
oldIndex++;
|
|
}
|
|
}
|
|
while (newIndex < newLen) {
|
|
inserted(newItems[newIndex++]);
|
|
hasChanges = true;
|
|
}
|
|
while (oldIndex < oldLen) {
|
|
deleted(oldItems[oldIndex++]);
|
|
hasChanges = true;
|
|
}
|
|
return hasChanges;
|
|
}
|
|
function fill(length2, cb) {
|
|
const result = Array(length2);
|
|
for (let i = 0; i < length2; i++) {
|
|
result[i] = cb(i);
|
|
}
|
|
return result;
|
|
}
|
|
function cartesianProduct(arrays) {
|
|
const result = [];
|
|
cartesianProductWorker(arrays, result, void 0, 0);
|
|
return result;
|
|
}
|
|
function cartesianProductWorker(arrays, result, outer, index) {
|
|
for (const element of arrays[index]) {
|
|
let inner;
|
|
if (outer) {
|
|
inner = outer.slice();
|
|
inner.push(element);
|
|
} else {
|
|
inner = [element];
|
|
}
|
|
if (index === arrays.length - 1) {
|
|
result.push(inner);
|
|
} else {
|
|
cartesianProductWorker(arrays, result, inner, index + 1);
|
|
}
|
|
}
|
|
}
|
|
function padLeft(s, length2, padString = " ") {
|
|
return length2 <= s.length ? s : padString.repeat(length2 - s.length) + s;
|
|
}
|
|
function padRight(s, length2, padString = " ") {
|
|
return length2 <= s.length ? s : s + padString.repeat(length2 - s.length);
|
|
}
|
|
function takeWhile(array, predicate) {
|
|
const len = array.length;
|
|
let index = 0;
|
|
while (index < len && predicate(array[index])) {
|
|
index++;
|
|
}
|
|
return array.slice(0, index);
|
|
}
|
|
var trimString = !!String.prototype.trim ? (s) => s.trim() : (s) => trimStringEnd(trimStringStart(s));
|
|
var trimStringEnd = !!String.prototype.trimEnd ? (s) => s.trimEnd() : trimEndImpl;
|
|
var trimStringStart = !!String.prototype.trimStart ? (s) => s.trimStart() : (s) => s.replace(/^\s+/g, "");
|
|
function trimEndImpl(s) {
|
|
let end = s.length - 1;
|
|
while (end >= 0) {
|
|
if (!isWhiteSpaceLike(s.charCodeAt(end)))
|
|
break;
|
|
end--;
|
|
}
|
|
return s.slice(0, end + 1);
|
|
}
|
|
function isNodeLikeSystem() {
|
|
return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
|
|
}
|
|
|
|
// src/compiler/debug.ts
|
|
var LogLevel = /* @__PURE__ */ ((LogLevel3) => {
|
|
LogLevel3[LogLevel3["Off"] = 0] = "Off";
|
|
LogLevel3[LogLevel3["Error"] = 1] = "Error";
|
|
LogLevel3[LogLevel3["Warning"] = 2] = "Warning";
|
|
LogLevel3[LogLevel3["Info"] = 3] = "Info";
|
|
LogLevel3[LogLevel3["Verbose"] = 4] = "Verbose";
|
|
return LogLevel3;
|
|
})(LogLevel || {});
|
|
var Debug;
|
|
((Debug2) => {
|
|
let currentAssertionLevel = 0 /* None */;
|
|
Debug2.currentLogLevel = 2 /* Warning */;
|
|
Debug2.isDebugging = false;
|
|
function shouldLog(level) {
|
|
return Debug2.currentLogLevel <= level;
|
|
}
|
|
Debug2.shouldLog = shouldLog;
|
|
function logMessage(level, s) {
|
|
if (Debug2.loggingHost && shouldLog(level)) {
|
|
Debug2.loggingHost.log(level, s);
|
|
}
|
|
}
|
|
function log(s) {
|
|
logMessage(3 /* Info */, s);
|
|
}
|
|
Debug2.log = log;
|
|
((_log) => {
|
|
function error(s) {
|
|
logMessage(1 /* Error */, s);
|
|
}
|
|
_log.error = error;
|
|
function warn(s) {
|
|
logMessage(2 /* Warning */, s);
|
|
}
|
|
_log.warn = warn;
|
|
function log2(s) {
|
|
logMessage(3 /* Info */, s);
|
|
}
|
|
_log.log = log2;
|
|
function trace2(s) {
|
|
logMessage(4 /* Verbose */, s);
|
|
}
|
|
_log.trace = trace2;
|
|
})(log = Debug2.log || (Debug2.log = {}));
|
|
const assertionCache = {};
|
|
function getAssertionLevel() {
|
|
return currentAssertionLevel;
|
|
}
|
|
Debug2.getAssertionLevel = getAssertionLevel;
|
|
function setAssertionLevel(level) {
|
|
const prevAssertionLevel = currentAssertionLevel;
|
|
currentAssertionLevel = level;
|
|
if (level > prevAssertionLevel) {
|
|
for (const key of getOwnKeys(assertionCache)) {
|
|
const cachedFunc = assertionCache[key];
|
|
if (cachedFunc !== void 0 && Debug2[key] !== cachedFunc.assertion && level >= cachedFunc.level) {
|
|
Debug2[key] = cachedFunc;
|
|
assertionCache[key] = void 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Debug2.setAssertionLevel = setAssertionLevel;
|
|
function shouldAssert(level) {
|
|
return currentAssertionLevel >= level;
|
|
}
|
|
Debug2.shouldAssert = shouldAssert;
|
|
function shouldAssertFunction(level, name) {
|
|
if (!shouldAssert(level)) {
|
|
assertionCache[name] = { level, assertion: Debug2[name] };
|
|
Debug2[name] = noop;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function fail(message, stackCrawlMark) {
|
|
debugger;
|
|
const e = new Error(message ? `Debug Failure. ${message}` : "Debug Failure.");
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(e, stackCrawlMark || fail);
|
|
}
|
|
throw e;
|
|
}
|
|
Debug2.fail = fail;
|
|
function failBadSyntaxKind(node, message, stackCrawlMark) {
|
|
return fail(
|
|
`${message || "Unexpected node."}\r
|
|
Node ${formatSyntaxKind(node.kind)} was unexpected.`,
|
|
stackCrawlMark || failBadSyntaxKind
|
|
);
|
|
}
|
|
Debug2.failBadSyntaxKind = failBadSyntaxKind;
|
|
function assert(expression, message, verboseDebugInfo, stackCrawlMark) {
|
|
if (!expression) {
|
|
message = message ? `False expression: ${message}` : "False expression.";
|
|
if (verboseDebugInfo) {
|
|
message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
|
|
}
|
|
fail(message, stackCrawlMark || assert);
|
|
}
|
|
}
|
|
Debug2.assert = assert;
|
|
function assertEqual(a, b, msg, msg2, stackCrawlMark) {
|
|
if (a !== b) {
|
|
const message = msg ? msg2 ? `${msg} ${msg2}` : msg : "";
|
|
fail(`Expected ${a} === ${b}. ${message}`, stackCrawlMark || assertEqual);
|
|
}
|
|
}
|
|
Debug2.assertEqual = assertEqual;
|
|
function assertLessThan(a, b, msg, stackCrawlMark) {
|
|
if (a >= b) {
|
|
fail(`Expected ${a} < ${b}. ${msg || ""}`, stackCrawlMark || assertLessThan);
|
|
}
|
|
}
|
|
Debug2.assertLessThan = assertLessThan;
|
|
function assertLessThanOrEqual(a, b, stackCrawlMark) {
|
|
if (a > b) {
|
|
fail(`Expected ${a} <= ${b}`, stackCrawlMark || assertLessThanOrEqual);
|
|
}
|
|
}
|
|
Debug2.assertLessThanOrEqual = assertLessThanOrEqual;
|
|
function assertGreaterThanOrEqual(a, b, stackCrawlMark) {
|
|
if (a < b) {
|
|
fail(`Expected ${a} >= ${b}`, stackCrawlMark || assertGreaterThanOrEqual);
|
|
}
|
|
}
|
|
Debug2.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
|
|
function assertIsDefined(value, message, stackCrawlMark) {
|
|
if (value === void 0 || value === null) {
|
|
fail(message, stackCrawlMark || assertIsDefined);
|
|
}
|
|
}
|
|
Debug2.assertIsDefined = assertIsDefined;
|
|
function checkDefined(value, message, stackCrawlMark) {
|
|
assertIsDefined(value, message, stackCrawlMark || checkDefined);
|
|
return value;
|
|
}
|
|
Debug2.checkDefined = checkDefined;
|
|
function assertEachIsDefined(value, message, stackCrawlMark) {
|
|
for (const v of value) {
|
|
assertIsDefined(v, message, stackCrawlMark || assertEachIsDefined);
|
|
}
|
|
}
|
|
Debug2.assertEachIsDefined = assertEachIsDefined;
|
|
function checkEachDefined(value, message, stackCrawlMark) {
|
|
assertEachIsDefined(value, message, stackCrawlMark || checkEachDefined);
|
|
return value;
|
|
}
|
|
Debug2.checkEachDefined = checkEachDefined;
|
|
function assertNever(member, message = "Illegal value:", stackCrawlMark) {
|
|
const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
|
|
return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
|
|
}
|
|
Debug2.assertNever = assertNever;
|
|
function assertEachNode(nodes, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertEachNode")) {
|
|
assert(
|
|
test === void 0 || every(nodes, test),
|
|
message || "Unexpected node.",
|
|
() => `Node array did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertEachNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertEachNode = assertEachNode;
|
|
function assertNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertNode")) {
|
|
assert(
|
|
node !== void 0 && (test === void 0 || test(node)),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertNode = assertNode;
|
|
function assertNotNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertNotNode")) {
|
|
assert(
|
|
node === void 0 || test === void 0 || !test(node),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node.kind)} should not have passed test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertNotNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertNotNode = assertNotNode;
|
|
function assertOptionalNode(node, test, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertOptionalNode")) {
|
|
assert(
|
|
test === void 0 || node === void 0 || test(node),
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} did not pass test '${getFunctionName(test)}'.`,
|
|
stackCrawlMark || assertOptionalNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertOptionalNode = assertOptionalNode;
|
|
function assertOptionalToken(node, kind, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertOptionalToken")) {
|
|
assert(
|
|
kind === void 0 || node === void 0 || node.kind === kind,
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node == null ? void 0 : node.kind)} was not a '${formatSyntaxKind(kind)}' token.`,
|
|
stackCrawlMark || assertOptionalToken
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertOptionalToken = assertOptionalToken;
|
|
function assertMissingNode(node, message, stackCrawlMark) {
|
|
if (shouldAssertFunction(1 /* Normal */, "assertMissingNode")) {
|
|
assert(
|
|
node === void 0,
|
|
message || "Unexpected node.",
|
|
() => `Node ${formatSyntaxKind(node.kind)} was unexpected'.`,
|
|
stackCrawlMark || assertMissingNode
|
|
);
|
|
}
|
|
}
|
|
Debug2.assertMissingNode = assertMissingNode;
|
|
function type(_value) {
|
|
}
|
|
Debug2.type = type;
|
|
function getFunctionName(func) {
|
|
if (typeof func !== "function") {
|
|
return "";
|
|
} else if (hasProperty(func, "name")) {
|
|
return func.name;
|
|
} else {
|
|
const text = Function.prototype.toString.call(func);
|
|
const match = /^function\s+([\w\$]+)\s*\(/.exec(text);
|
|
return match ? match[1] : "";
|
|
}
|
|
}
|
|
Debug2.getFunctionName = getFunctionName;
|
|
function formatSymbol(symbol) {
|
|
return `{ name: ${unescapeLeadingUnderscores(symbol.escapedName)}; flags: ${formatSymbolFlags(symbol.flags)}; declarations: ${map(symbol.declarations, (node) => formatSyntaxKind(node.kind))} }`;
|
|
}
|
|
Debug2.formatSymbol = formatSymbol;
|
|
function formatEnum(value = 0, enumObject, isFlags) {
|
|
const members = getEnumMembers(enumObject);
|
|
if (value === 0) {
|
|
return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0";
|
|
}
|
|
if (isFlags) {
|
|
const result = [];
|
|
let remainingFlags = value;
|
|
for (const [enumValue, enumName] of members) {
|
|
if (enumValue > value) {
|
|
break;
|
|
}
|
|
if (enumValue !== 0 && enumValue & value) {
|
|
result.push(enumName);
|
|
remainingFlags &= ~enumValue;
|
|
}
|
|
}
|
|
if (remainingFlags === 0) {
|
|
return result.join("|");
|
|
}
|
|
} else {
|
|
for (const [enumValue, enumName] of members) {
|
|
if (enumValue === value) {
|
|
return enumName;
|
|
}
|
|
}
|
|
}
|
|
return value.toString();
|
|
}
|
|
Debug2.formatEnum = formatEnum;
|
|
const enumMemberCache = /* @__PURE__ */ new Map();
|
|
function getEnumMembers(enumObject) {
|
|
const existing = enumMemberCache.get(enumObject);
|
|
if (existing) {
|
|
return existing;
|
|
}
|
|
const result = [];
|
|
for (const name in enumObject) {
|
|
const value = enumObject[name];
|
|
if (typeof value === "number") {
|
|
result.push([value, name]);
|
|
}
|
|
}
|
|
const sorted = stableSort(result, (x, y) => compareValues(x[0], y[0]));
|
|
enumMemberCache.set(enumObject, sorted);
|
|
return sorted;
|
|
}
|
|
function formatSyntaxKind(kind) {
|
|
return formatEnum(kind, SyntaxKind, false);
|
|
}
|
|
Debug2.formatSyntaxKind = formatSyntaxKind;
|
|
function formatSnippetKind(kind) {
|
|
return formatEnum(kind, SnippetKind, false);
|
|
}
|
|
Debug2.formatSnippetKind = formatSnippetKind;
|
|
function formatNodeFlags(flags) {
|
|
return formatEnum(flags, NodeFlags, true);
|
|
}
|
|
Debug2.formatNodeFlags = formatNodeFlags;
|
|
function formatModifierFlags(flags) {
|
|
return formatEnum(flags, ModifierFlags, true);
|
|
}
|
|
Debug2.formatModifierFlags = formatModifierFlags;
|
|
function formatTransformFlags(flags) {
|
|
return formatEnum(flags, TransformFlags, true);
|
|
}
|
|
Debug2.formatTransformFlags = formatTransformFlags;
|
|
function formatEmitFlags(flags) {
|
|
return formatEnum(flags, EmitFlags, true);
|
|
}
|
|
Debug2.formatEmitFlags = formatEmitFlags;
|
|
function formatSymbolFlags(flags) {
|
|
return formatEnum(flags, SymbolFlags, true);
|
|
}
|
|
Debug2.formatSymbolFlags = formatSymbolFlags;
|
|
function formatTypeFlags(flags) {
|
|
return formatEnum(flags, TypeFlags, true);
|
|
}
|
|
Debug2.formatTypeFlags = formatTypeFlags;
|
|
function formatSignatureFlags(flags) {
|
|
return formatEnum(flags, SignatureFlags, true);
|
|
}
|
|
Debug2.formatSignatureFlags = formatSignatureFlags;
|
|
function formatObjectFlags(flags) {
|
|
return formatEnum(flags, ObjectFlags, true);
|
|
}
|
|
Debug2.formatObjectFlags = formatObjectFlags;
|
|
function formatFlowFlags(flags) {
|
|
return formatEnum(flags, FlowFlags, true);
|
|
}
|
|
Debug2.formatFlowFlags = formatFlowFlags;
|
|
function formatRelationComparisonResult(result) {
|
|
return formatEnum(result, RelationComparisonResult, true);
|
|
}
|
|
Debug2.formatRelationComparisonResult = formatRelationComparisonResult;
|
|
function formatCheckMode(mode) {
|
|
return formatEnum(mode, CheckMode, true);
|
|
}
|
|
Debug2.formatCheckMode = formatCheckMode;
|
|
function formatSignatureCheckMode(mode) {
|
|
return formatEnum(mode, SignatureCheckMode, true);
|
|
}
|
|
Debug2.formatSignatureCheckMode = formatSignatureCheckMode;
|
|
function formatTypeFacts(facts) {
|
|
return formatEnum(facts, TypeFacts, true);
|
|
}
|
|
Debug2.formatTypeFacts = formatTypeFacts;
|
|
let isDebugInfoEnabled = false;
|
|
let flowNodeProto;
|
|
function attachFlowNodeDebugInfoWorker(flowNode) {
|
|
if (!("__debugFlowFlags" in flowNode)) {
|
|
Object.defineProperties(flowNode, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const flowHeader = this.flags & 2 /* Start */ ? "FlowStart" : this.flags & 4 /* BranchLabel */ ? "FlowBranchLabel" : this.flags & 8 /* LoopLabel */ ? "FlowLoopLabel" : this.flags & 16 /* Assignment */ ? "FlowAssignment" : this.flags & 32 /* TrueCondition */ ? "FlowTrueCondition" : this.flags & 64 /* FalseCondition */ ? "FlowFalseCondition" : this.flags & 128 /* SwitchClause */ ? "FlowSwitchClause" : this.flags & 256 /* ArrayMutation */ ? "FlowArrayMutation" : this.flags & 512 /* Call */ ? "FlowCall" : this.flags & 1024 /* ReduceLabel */ ? "FlowReduceLabel" : this.flags & 1 /* Unreachable */ ? "FlowUnreachable" : "UnknownFlow";
|
|
const remainingFlags = this.flags & ~(2048 /* Referenced */ - 1);
|
|
return `${flowHeader}${remainingFlags ? ` (${formatFlowFlags(remainingFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlowFlags: { get() {
|
|
return formatEnum(this.flags, FlowFlags, true);
|
|
} },
|
|
__debugToString: { value() {
|
|
return formatControlFlowGraph(this);
|
|
} }
|
|
});
|
|
}
|
|
}
|
|
function attachFlowNodeDebugInfo(flowNode) {
|
|
if (isDebugInfoEnabled) {
|
|
if (typeof Object.setPrototypeOf === "function") {
|
|
if (!flowNodeProto) {
|
|
flowNodeProto = Object.create(Object.prototype);
|
|
attachFlowNodeDebugInfoWorker(flowNodeProto);
|
|
}
|
|
Object.setPrototypeOf(flowNode, flowNodeProto);
|
|
} else {
|
|
attachFlowNodeDebugInfoWorker(flowNode);
|
|
}
|
|
}
|
|
}
|
|
Debug2.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
|
|
let nodeArrayProto;
|
|
function attachNodeArrayDebugInfoWorker(array) {
|
|
if (!("__tsDebuggerDisplay" in array)) {
|
|
Object.defineProperties(array, {
|
|
__tsDebuggerDisplay: {
|
|
value(defaultValue) {
|
|
defaultValue = String(defaultValue).replace(/(?:,[\s\w\d_]+:[^,]+)+\]$/, "]");
|
|
return `NodeArray ${defaultValue}`;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function attachNodeArrayDebugInfo(array) {
|
|
if (isDebugInfoEnabled) {
|
|
if (typeof Object.setPrototypeOf === "function") {
|
|
if (!nodeArrayProto) {
|
|
nodeArrayProto = Object.create(Array.prototype);
|
|
attachNodeArrayDebugInfoWorker(nodeArrayProto);
|
|
}
|
|
Object.setPrototypeOf(array, nodeArrayProto);
|
|
} else {
|
|
attachNodeArrayDebugInfoWorker(array);
|
|
}
|
|
}
|
|
}
|
|
Debug2.attachNodeArrayDebugInfo = attachNodeArrayDebugInfo;
|
|
function enableDebugInfo() {
|
|
if (isDebugInfoEnabled)
|
|
return;
|
|
let weakTypeTextMap;
|
|
let weakNodeTextMap;
|
|
function getWeakTypeTextMap() {
|
|
if (weakTypeTextMap === void 0) {
|
|
if (typeof WeakMap === "function")
|
|
weakTypeTextMap = /* @__PURE__ */ new WeakMap();
|
|
}
|
|
return weakTypeTextMap;
|
|
}
|
|
function getWeakNodeTextMap() {
|
|
if (weakNodeTextMap === void 0) {
|
|
if (typeof WeakMap === "function")
|
|
weakNodeTextMap = /* @__PURE__ */ new WeakMap();
|
|
}
|
|
return weakNodeTextMap;
|
|
}
|
|
Object.defineProperties(objectAllocator.getSymbolConstructor().prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const symbolHeader = this.flags & 33554432 /* Transient */ ? "TransientSymbol" : "Symbol";
|
|
const remainingSymbolFlags = this.flags & ~33554432 /* Transient */;
|
|
return `${symbolHeader} '${symbolName(this)}'${remainingSymbolFlags ? ` (${formatSymbolFlags(remainingSymbolFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlags: { get() {
|
|
return formatSymbolFlags(this.flags);
|
|
} }
|
|
});
|
|
Object.defineProperties(objectAllocator.getTypeConstructor().prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const typeHeader = this.flags & 98304 /* Nullable */ ? "NullableType" : this.flags & 384 /* StringOrNumberLiteral */ ? `LiteralType ${JSON.stringify(this.value)}` : this.flags & 2048 /* BigIntLiteral */ ? `LiteralType ${this.value.negative ? "-" : ""}${this.value.base10Value}n` : this.flags & 8192 /* UniqueESSymbol */ ? "UniqueESSymbolType" : this.flags & 32 /* Enum */ ? "EnumType" : this.flags & 67359327 /* Intrinsic */ ? `IntrinsicType ${this.intrinsicName}` : this.flags & 1048576 /* Union */ ? "UnionType" : this.flags & 2097152 /* Intersection */ ? "IntersectionType" : this.flags & 4194304 /* Index */ ? "IndexType" : this.flags & 8388608 /* IndexedAccess */ ? "IndexedAccessType" : this.flags & 16777216 /* Conditional */ ? "ConditionalType" : this.flags & 33554432 /* Substitution */ ? "SubstitutionType" : this.flags & 262144 /* TypeParameter */ ? "TypeParameter" : this.flags & 524288 /* Object */ ? this.objectFlags & 3 /* ClassOrInterface */ ? "InterfaceType" : this.objectFlags & 4 /* Reference */ ? "TypeReference" : this.objectFlags & 8 /* Tuple */ ? "TupleType" : this.objectFlags & 16 /* Anonymous */ ? "AnonymousType" : this.objectFlags & 32 /* Mapped */ ? "MappedType" : this.objectFlags & 1024 /* ReverseMapped */ ? "ReverseMappedType" : this.objectFlags & 256 /* EvolvingArray */ ? "EvolvingArrayType" : "ObjectType" : "Type";
|
|
const remainingObjectFlags = this.flags & 524288 /* Object */ ? this.objectFlags & ~1343 /* ObjectTypeKindMask */ : 0;
|
|
return `${typeHeader}${this.symbol ? ` '${symbolName(this.symbol)}'` : ""}${remainingObjectFlags ? ` (${formatObjectFlags(remainingObjectFlags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugFlags: { get() {
|
|
return formatTypeFlags(this.flags);
|
|
} },
|
|
__debugObjectFlags: { get() {
|
|
return this.flags & 524288 /* Object */ ? formatObjectFlags(this.objectFlags) : "";
|
|
} },
|
|
__debugTypeToString: {
|
|
value() {
|
|
const map2 = getWeakTypeTextMap();
|
|
let text = map2 == null ? void 0 : map2.get(this);
|
|
if (text === void 0) {
|
|
text = this.checker.typeToString(this);
|
|
map2 == null ? void 0 : map2.set(this, text);
|
|
}
|
|
return text;
|
|
}
|
|
}
|
|
});
|
|
Object.defineProperties(objectAllocator.getSignatureConstructor().prototype, {
|
|
__debugFlags: { get() {
|
|
return formatSignatureFlags(this.flags);
|
|
} },
|
|
__debugSignatureToString: { value() {
|
|
var _a2;
|
|
return (_a2 = this.checker) == null ? void 0 : _a2.signatureToString(this);
|
|
} }
|
|
});
|
|
const nodeConstructors = [
|
|
objectAllocator.getNodeConstructor(),
|
|
objectAllocator.getIdentifierConstructor(),
|
|
objectAllocator.getTokenConstructor(),
|
|
objectAllocator.getSourceFileConstructor()
|
|
];
|
|
for (const ctor of nodeConstructors) {
|
|
if (!hasProperty(ctor.prototype, "__debugKind")) {
|
|
Object.defineProperties(ctor.prototype, {
|
|
__tsDebuggerDisplay: {
|
|
value() {
|
|
const nodeHeader = isGeneratedIdentifier(this) ? "GeneratedIdentifier" : isIdentifier(this) ? `Identifier '${idText(this)}'` : isPrivateIdentifier(this) ? `PrivateIdentifier '${idText(this)}'` : isStringLiteral(this) ? `StringLiteral ${JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...")}` : isNumericLiteral(this) ? `NumericLiteral ${this.text}` : isBigIntLiteral(this) ? `BigIntLiteral ${this.text}n` : isTypeParameterDeclaration(this) ? "TypeParameterDeclaration" : isParameter(this) ? "ParameterDeclaration" : isConstructorDeclaration(this) ? "ConstructorDeclaration" : isGetAccessorDeclaration(this) ? "GetAccessorDeclaration" : isSetAccessorDeclaration(this) ? "SetAccessorDeclaration" : isCallSignatureDeclaration(this) ? "CallSignatureDeclaration" : isConstructSignatureDeclaration(this) ? "ConstructSignatureDeclaration" : isIndexSignatureDeclaration(this) ? "IndexSignatureDeclaration" : isTypePredicateNode(this) ? "TypePredicateNode" : isTypeReferenceNode(this) ? "TypeReferenceNode" : isFunctionTypeNode(this) ? "FunctionTypeNode" : isConstructorTypeNode(this) ? "ConstructorTypeNode" : isTypeQueryNode(this) ? "TypeQueryNode" : isTypeLiteralNode(this) ? "TypeLiteralNode" : isArrayTypeNode(this) ? "ArrayTypeNode" : isTupleTypeNode(this) ? "TupleTypeNode" : isOptionalTypeNode(this) ? "OptionalTypeNode" : isRestTypeNode(this) ? "RestTypeNode" : isUnionTypeNode(this) ? "UnionTypeNode" : isIntersectionTypeNode(this) ? "IntersectionTypeNode" : isConditionalTypeNode(this) ? "ConditionalTypeNode" : isInferTypeNode(this) ? "InferTypeNode" : isParenthesizedTypeNode(this) ? "ParenthesizedTypeNode" : isThisTypeNode(this) ? "ThisTypeNode" : isTypeOperatorNode(this) ? "TypeOperatorNode" : isIndexedAccessTypeNode(this) ? "IndexedAccessTypeNode" : isMappedTypeNode(this) ? "MappedTypeNode" : isLiteralTypeNode(this) ? "LiteralTypeNode" : isNamedTupleMember(this) ? "NamedTupleMember" : isImportTypeNode(this) ? "ImportTypeNode" : formatSyntaxKind(this.kind);
|
|
return `${nodeHeader}${this.flags ? ` (${formatNodeFlags(this.flags)})` : ""}`;
|
|
}
|
|
},
|
|
__debugKind: { get() {
|
|
return formatSyntaxKind(this.kind);
|
|
} },
|
|
__debugNodeFlags: { get() {
|
|
return formatNodeFlags(this.flags);
|
|
} },
|
|
__debugModifierFlags: { get() {
|
|
return formatModifierFlags(getEffectiveModifierFlagsNoCache(this));
|
|
} },
|
|
__debugTransformFlags: { get() {
|
|
return formatTransformFlags(this.transformFlags);
|
|
} },
|
|
__debugIsParseTreeNode: { get() {
|
|
return isParseTreeNode(this);
|
|
} },
|
|
__debugEmitFlags: { get() {
|
|
return formatEmitFlags(getEmitFlags(this));
|
|
} },
|
|
__debugGetText: {
|
|
value(includeTrivia) {
|
|
if (nodeIsSynthesized(this))
|
|
return "";
|
|
const map2 = getWeakNodeTextMap();
|
|
let text = map2 == null ? void 0 : map2.get(this);
|
|
if (text === void 0) {
|
|
const parseNode = getParseTreeNode(this);
|
|
const sourceFile = parseNode && getSourceFileOfNode(parseNode);
|
|
text = sourceFile ? getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : "";
|
|
map2 == null ? void 0 : map2.set(this, text);
|
|
}
|
|
return text;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
isDebugInfoEnabled = true;
|
|
}
|
|
Debug2.enableDebugInfo = enableDebugInfo;
|
|
function formatVariance(varianceFlags) {
|
|
const variance = varianceFlags & 7 /* VarianceMask */;
|
|
let result = variance === 0 /* Invariant */ ? "in out" : variance === 3 /* Bivariant */ ? "[bivariant]" : variance === 2 /* Contravariant */ ? "in" : variance === 1 /* Covariant */ ? "out" : variance === 4 /* Independent */ ? "[independent]" : "";
|
|
if (varianceFlags & 8 /* Unmeasurable */) {
|
|
result += " (unmeasurable)";
|
|
} else if (varianceFlags & 16 /* Unreliable */) {
|
|
result += " (unreliable)";
|
|
}
|
|
return result;
|
|
}
|
|
Debug2.formatVariance = formatVariance;
|
|
class DebugTypeMapper {
|
|
__debugToString() {
|
|
var _a2;
|
|
type(this);
|
|
switch (this.kind) {
|
|
case 3 /* Function */:
|
|
return ((_a2 = this.debugInfo) == null ? void 0 : _a2.call(this)) || "(function mapper)";
|
|
case 0 /* Simple */:
|
|
return `${this.source.__debugTypeToString()} -> ${this.target.__debugTypeToString()}`;
|
|
case 1 /* Array */:
|
|
return zipWith(
|
|
this.sources,
|
|
this.targets || map(this.sources, () => "any"),
|
|
(s, t) => `${s.__debugTypeToString()} -> ${typeof t === "string" ? t : t.__debugTypeToString()}`
|
|
).join(", ");
|
|
case 2 /* Deferred */:
|
|
return zipWith(
|
|
this.sources,
|
|
this.targets,
|
|
(s, t) => `${s.__debugTypeToString()} -> ${t().__debugTypeToString()}`
|
|
).join(", ");
|
|
case 5 /* Merged */:
|
|
case 4 /* Composite */:
|
|
return `m1: ${this.mapper1.__debugToString().split("\n").join("\n ")}
|
|
m2: ${this.mapper2.__debugToString().split("\n").join("\n ")}`;
|
|
default:
|
|
return assertNever(this);
|
|
}
|
|
}
|
|
}
|
|
Debug2.DebugTypeMapper = DebugTypeMapper;
|
|
function attachDebugPrototypeIfDebug(mapper) {
|
|
if (Debug2.isDebugging) {
|
|
return Object.setPrototypeOf(mapper, DebugTypeMapper.prototype);
|
|
}
|
|
return mapper;
|
|
}
|
|
Debug2.attachDebugPrototypeIfDebug = attachDebugPrototypeIfDebug;
|
|
function printControlFlowGraph(flowNode) {
|
|
return console.log(formatControlFlowGraph(flowNode));
|
|
}
|
|
Debug2.printControlFlowGraph = printControlFlowGraph;
|
|
function formatControlFlowGraph(flowNode) {
|
|
let nextDebugFlowId = -1;
|
|
function getDebugFlowNodeId(f) {
|
|
if (!f.id) {
|
|
f.id = nextDebugFlowId;
|
|
nextDebugFlowId--;
|
|
}
|
|
return f.id;
|
|
}
|
|
let BoxCharacter;
|
|
((BoxCharacter2) => {
|
|
BoxCharacter2["lr"] = "\u2500";
|
|
BoxCharacter2["ud"] = "\u2502";
|
|
BoxCharacter2["dr"] = "\u256D";
|
|
BoxCharacter2["dl"] = "\u256E";
|
|
BoxCharacter2["ul"] = "\u256F";
|
|
BoxCharacter2["ur"] = "\u2570";
|
|
BoxCharacter2["udr"] = "\u251C";
|
|
BoxCharacter2["udl"] = "\u2524";
|
|
BoxCharacter2["dlr"] = "\u252C";
|
|
BoxCharacter2["ulr"] = "\u2534";
|
|
BoxCharacter2["udlr"] = "\u256B";
|
|
})(BoxCharacter || (BoxCharacter = {}));
|
|
let Connection;
|
|
((Connection2) => {
|
|
Connection2[Connection2["None"] = 0] = "None";
|
|
Connection2[Connection2["Up"] = 1] = "Up";
|
|
Connection2[Connection2["Down"] = 2] = "Down";
|
|
Connection2[Connection2["Left"] = 4] = "Left";
|
|
Connection2[Connection2["Right"] = 8] = "Right";
|
|
Connection2[Connection2["UpDown"] = 3] = "UpDown";
|
|
Connection2[Connection2["LeftRight"] = 12] = "LeftRight";
|
|
Connection2[Connection2["UpLeft"] = 5] = "UpLeft";
|
|
Connection2[Connection2["UpRight"] = 9] = "UpRight";
|
|
Connection2[Connection2["DownLeft"] = 6] = "DownLeft";
|
|
Connection2[Connection2["DownRight"] = 10] = "DownRight";
|
|
Connection2[Connection2["UpDownLeft"] = 7] = "UpDownLeft";
|
|
Connection2[Connection2["UpDownRight"] = 11] = "UpDownRight";
|
|
Connection2[Connection2["UpLeftRight"] = 13] = "UpLeftRight";
|
|
Connection2[Connection2["DownLeftRight"] = 14] = "DownLeftRight";
|
|
Connection2[Connection2["UpDownLeftRight"] = 15] = "UpDownLeftRight";
|
|
Connection2[Connection2["NoChildren"] = 16] = "NoChildren";
|
|
})(Connection || (Connection = {}));
|
|
const hasAntecedentFlags = 16 /* Assignment */ | 96 /* Condition */ | 128 /* SwitchClause */ | 256 /* ArrayMutation */ | 512 /* Call */ | 1024 /* ReduceLabel */;
|
|
const hasNodeFlags = 2 /* Start */ | 16 /* Assignment */ | 512 /* Call */ | 96 /* Condition */ | 256 /* ArrayMutation */;
|
|
const links = /* @__PURE__ */ Object.create(null);
|
|
const nodes = [];
|
|
const edges = [];
|
|
const root = buildGraphNode(flowNode, /* @__PURE__ */ new Set());
|
|
for (const node of nodes) {
|
|
node.text = renderFlowNode(node.flowNode, node.circular);
|
|
computeLevel(node);
|
|
}
|
|
const height = computeHeight(root);
|
|
const columnWidths = computeColumnWidths(height);
|
|
computeLanes(root, 0);
|
|
return renderGraph();
|
|
function isFlowSwitchClause(f) {
|
|
return !!(f.flags & 128 /* SwitchClause */);
|
|
}
|
|
function hasAntecedents(f) {
|
|
return !!(f.flags & 12 /* Label */) && !!f.antecedents;
|
|
}
|
|
function hasAntecedent(f) {
|
|
return !!(f.flags & hasAntecedentFlags);
|
|
}
|
|
function hasNode(f) {
|
|
return !!(f.flags & hasNodeFlags);
|
|
}
|
|
function getChildren(node) {
|
|
const children = [];
|
|
for (const edge of node.edges) {
|
|
if (edge.source === node) {
|
|
children.push(edge.target);
|
|
}
|
|
}
|
|
return children;
|
|
}
|
|
function getParents(node) {
|
|
const parents = [];
|
|
for (const edge of node.edges) {
|
|
if (edge.target === node) {
|
|
parents.push(edge.source);
|
|
}
|
|
}
|
|
return parents;
|
|
}
|
|
function buildGraphNode(flowNode2, seen) {
|
|
const id = getDebugFlowNodeId(flowNode2);
|
|
let graphNode = links[id];
|
|
if (graphNode && seen.has(flowNode2)) {
|
|
graphNode.circular = true;
|
|
graphNode = {
|
|
id: -1,
|
|
flowNode: flowNode2,
|
|
edges: [],
|
|
text: "",
|
|
lane: -1,
|
|
endLane: -1,
|
|
level: -1,
|
|
circular: "circularity"
|
|
};
|
|
nodes.push(graphNode);
|
|
return graphNode;
|
|
}
|
|
seen.add(flowNode2);
|
|
if (!graphNode) {
|
|
links[id] = graphNode = { id, flowNode: flowNode2, edges: [], text: "", lane: -1, endLane: -1, level: -1, circular: false };
|
|
nodes.push(graphNode);
|
|
if (hasAntecedents(flowNode2)) {
|
|
for (const antecedent of flowNode2.antecedents) {
|
|
buildGraphEdge(graphNode, antecedent, seen);
|
|
}
|
|
} else if (hasAntecedent(flowNode2)) {
|
|
buildGraphEdge(graphNode, flowNode2.antecedent, seen);
|
|
}
|
|
}
|
|
seen.delete(flowNode2);
|
|
return graphNode;
|
|
}
|
|
function buildGraphEdge(source, antecedent, seen) {
|
|
const target = buildGraphNode(antecedent, seen);
|
|
const edge = { source, target };
|
|
edges.push(edge);
|
|
source.edges.push(edge);
|
|
target.edges.push(edge);
|
|
}
|
|
function computeLevel(node) {
|
|
if (node.level !== -1) {
|
|
return node.level;
|
|
}
|
|
let level = 0;
|
|
for (const parent2 of getParents(node)) {
|
|
level = Math.max(level, computeLevel(parent2) + 1);
|
|
}
|
|
return node.level = level;
|
|
}
|
|
function computeHeight(node) {
|
|
let height2 = 0;
|
|
for (const child of getChildren(node)) {
|
|
height2 = Math.max(height2, computeHeight(child));
|
|
}
|
|
return height2 + 1;
|
|
}
|
|
function computeColumnWidths(height2) {
|
|
const columns = fill2(Array(height2), 0);
|
|
for (const node of nodes) {
|
|
columns[node.level] = Math.max(columns[node.level], node.text.length);
|
|
}
|
|
return columns;
|
|
}
|
|
function computeLanes(node, lane) {
|
|
if (node.lane === -1) {
|
|
node.lane = lane;
|
|
node.endLane = lane;
|
|
const children = getChildren(node);
|
|
for (let i = 0; i < children.length; i++) {
|
|
if (i > 0)
|
|
lane++;
|
|
const child = children[i];
|
|
computeLanes(child, lane);
|
|
if (child.endLane > node.endLane) {
|
|
lane = child.endLane;
|
|
}
|
|
}
|
|
node.endLane = lane;
|
|
}
|
|
}
|
|
function getHeader(flags) {
|
|
if (flags & 2 /* Start */)
|
|
return "Start";
|
|
if (flags & 4 /* BranchLabel */)
|
|
return "Branch";
|
|
if (flags & 8 /* LoopLabel */)
|
|
return "Loop";
|
|
if (flags & 16 /* Assignment */)
|
|
return "Assignment";
|
|
if (flags & 32 /* TrueCondition */)
|
|
return "True";
|
|
if (flags & 64 /* FalseCondition */)
|
|
return "False";
|
|
if (flags & 128 /* SwitchClause */)
|
|
return "SwitchClause";
|
|
if (flags & 256 /* ArrayMutation */)
|
|
return "ArrayMutation";
|
|
if (flags & 512 /* Call */)
|
|
return "Call";
|
|
if (flags & 1024 /* ReduceLabel */)
|
|
return "ReduceLabel";
|
|
if (flags & 1 /* Unreachable */)
|
|
return "Unreachable";
|
|
throw new Error();
|
|
}
|
|
function getNodeText(node) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node, false);
|
|
}
|
|
function renderFlowNode(flowNode2, circular) {
|
|
let text = getHeader(flowNode2.flags);
|
|
if (circular) {
|
|
text = `${text}#${getDebugFlowNodeId(flowNode2)}`;
|
|
}
|
|
if (hasNode(flowNode2)) {
|
|
if (flowNode2.node) {
|
|
text += ` (${getNodeText(flowNode2.node)})`;
|
|
}
|
|
} else if (isFlowSwitchClause(flowNode2)) {
|
|
const clauses = [];
|
|
for (let i = flowNode2.clauseStart; i < flowNode2.clauseEnd; i++) {
|
|
const clause = flowNode2.switchStatement.caseBlock.clauses[i];
|
|
if (isDefaultClause(clause)) {
|
|
clauses.push("default");
|
|
} else {
|
|
clauses.push(getNodeText(clause.expression));
|
|
}
|
|
}
|
|
text += ` (${clauses.join(", ")})`;
|
|
}
|
|
return circular === "circularity" ? `Circular(${text})` : text;
|
|
}
|
|
function renderGraph() {
|
|
const columnCount = columnWidths.length;
|
|
const laneCount = nodes.reduce((x, n) => Math.max(x, n.lane), 0) + 1;
|
|
const lanes = fill2(Array(laneCount), "");
|
|
const grid = columnWidths.map(() => Array(laneCount));
|
|
const connectors = columnWidths.map(() => fill2(Array(laneCount), 0));
|
|
for (const node of nodes) {
|
|
grid[node.level][node.lane] = node;
|
|
const children = getChildren(node);
|
|
for (let i = 0; i < children.length; i++) {
|
|
const child = children[i];
|
|
let connector = 8 /* Right */;
|
|
if (child.lane === node.lane)
|
|
connector |= 4 /* Left */;
|
|
if (i > 0)
|
|
connector |= 1 /* Up */;
|
|
if (i < children.length - 1)
|
|
connector |= 2 /* Down */;
|
|
connectors[node.level][child.lane] |= connector;
|
|
}
|
|
if (children.length === 0) {
|
|
connectors[node.level][node.lane] |= 16 /* NoChildren */;
|
|
}
|
|
const parents = getParents(node);
|
|
for (let i = 0; i < parents.length; i++) {
|
|
const parent2 = parents[i];
|
|
let connector = 4 /* Left */;
|
|
if (i > 0)
|
|
connector |= 1 /* Up */;
|
|
if (i < parents.length - 1)
|
|
connector |= 2 /* Down */;
|
|
connectors[node.level - 1][parent2.lane] |= connector;
|
|
}
|
|
}
|
|
for (let column = 0; column < columnCount; column++) {
|
|
for (let lane = 0; lane < laneCount; lane++) {
|
|
const left = column > 0 ? connectors[column - 1][lane] : 0;
|
|
const above = lane > 0 ? connectors[column][lane - 1] : 0;
|
|
let connector = connectors[column][lane];
|
|
if (!connector) {
|
|
if (left & 8 /* Right */)
|
|
connector |= 12 /* LeftRight */;
|
|
if (above & 2 /* Down */)
|
|
connector |= 3 /* UpDown */;
|
|
connectors[column][lane] = connector;
|
|
}
|
|
}
|
|
}
|
|
for (let column = 0; column < columnCount; column++) {
|
|
for (let lane = 0; lane < lanes.length; lane++) {
|
|
const connector = connectors[column][lane];
|
|
const fill3 = connector & 4 /* Left */ ? "\u2500" /* lr */ : " ";
|
|
const node = grid[column][lane];
|
|
if (!node) {
|
|
if (column < columnCount - 1) {
|
|
writeLane(lane, repeat(fill3, columnWidths[column] + 1));
|
|
}
|
|
} else {
|
|
writeLane(lane, node.text);
|
|
if (column < columnCount - 1) {
|
|
writeLane(lane, " ");
|
|
writeLane(lane, repeat(fill3, columnWidths[column] - node.text.length));
|
|
}
|
|
}
|
|
writeLane(lane, getBoxCharacter(connector));
|
|
writeLane(lane, connector & 8 /* Right */ && column < columnCount - 1 && !grid[column + 1][lane] ? "\u2500" /* lr */ : " ");
|
|
}
|
|
}
|
|
return `
|
|
${lanes.join("\n")}
|
|
`;
|
|
function writeLane(lane, text) {
|
|
lanes[lane] += text;
|
|
}
|
|
}
|
|
function getBoxCharacter(connector) {
|
|
switch (connector) {
|
|
case 3 /* UpDown */:
|
|
return "\u2502" /* ud */;
|
|
case 12 /* LeftRight */:
|
|
return "\u2500" /* lr */;
|
|
case 5 /* UpLeft */:
|
|
return "\u256F" /* ul */;
|
|
case 9 /* UpRight */:
|
|
return "\u2570" /* ur */;
|
|
case 6 /* DownLeft */:
|
|
return "\u256E" /* dl */;
|
|
case 10 /* DownRight */:
|
|
return "\u256D" /* dr */;
|
|
case 7 /* UpDownLeft */:
|
|
return "\u2524" /* udl */;
|
|
case 11 /* UpDownRight */:
|
|
return "\u251C" /* udr */;
|
|
case 13 /* UpLeftRight */:
|
|
return "\u2534" /* ulr */;
|
|
case 14 /* DownLeftRight */:
|
|
return "\u252C" /* dlr */;
|
|
case 15 /* UpDownLeftRight */:
|
|
return "\u256B" /* udlr */;
|
|
}
|
|
return " ";
|
|
}
|
|
function fill2(array, value) {
|
|
if (array.fill) {
|
|
array.fill(value);
|
|
} else {
|
|
for (let i = 0; i < array.length; i++) {
|
|
array[i] = value;
|
|
}
|
|
}
|
|
return array;
|
|
}
|
|
function repeat(ch, length2) {
|
|
if (ch.repeat) {
|
|
return length2 > 0 ? ch.repeat(length2) : "";
|
|
}
|
|
let s = "";
|
|
while (s.length < length2) {
|
|
s += ch;
|
|
}
|
|
return s;
|
|
}
|
|
}
|
|
Debug2.formatControlFlowGraph = formatControlFlowGraph;
|
|
})(Debug || (Debug = {}));
|
|
|
|
// src/compiler/semver.ts
|
|
var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
|
|
var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i;
|
|
var prereleasePartRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i;
|
|
var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i;
|
|
var buildPartRegExp = /^[a-z0-9-]+$/i;
|
|
var numericIdentifierRegExp = /^(0|[1-9]\d*)$/;
|
|
var _Version = class {
|
|
constructor(major, minor = 0, patch = 0, prerelease = "", build2 = "") {
|
|
if (typeof major === "string") {
|
|
const result = Debug.checkDefined(tryParseComponents(major), "Invalid version");
|
|
({ major, minor, patch, prerelease, build: build2 } = result);
|
|
}
|
|
Debug.assert(major >= 0, "Invalid argument: major");
|
|
Debug.assert(minor >= 0, "Invalid argument: minor");
|
|
Debug.assert(patch >= 0, "Invalid argument: patch");
|
|
const prereleaseArray = prerelease ? isArray(prerelease) ? prerelease : prerelease.split(".") : emptyArray;
|
|
const buildArray = build2 ? isArray(build2) ? build2 : build2.split(".") : emptyArray;
|
|
Debug.assert(every(prereleaseArray, (s) => prereleasePartRegExp.test(s)), "Invalid argument: prerelease");
|
|
Debug.assert(every(buildArray, (s) => buildPartRegExp.test(s)), "Invalid argument: build");
|
|
this.major = major;
|
|
this.minor = minor;
|
|
this.patch = patch;
|
|
this.prerelease = prereleaseArray;
|
|
this.build = buildArray;
|
|
}
|
|
static tryParse(text) {
|
|
const result = tryParseComponents(text);
|
|
if (!result)
|
|
return void 0;
|
|
const { major, minor, patch, prerelease, build: build2 } = result;
|
|
return new _Version(major, minor, patch, prerelease, build2);
|
|
}
|
|
compareTo(other) {
|
|
if (this === other)
|
|
return 0 /* EqualTo */;
|
|
if (other === void 0)
|
|
return 1 /* GreaterThan */;
|
|
return compareValues(this.major, other.major) || compareValues(this.minor, other.minor) || compareValues(this.patch, other.patch) || comparePrereleaseIdentifiers(this.prerelease, other.prerelease);
|
|
}
|
|
increment(field) {
|
|
switch (field) {
|
|
case "major":
|
|
return new _Version(this.major + 1, 0, 0);
|
|
case "minor":
|
|
return new _Version(this.major, this.minor + 1, 0);
|
|
case "patch":
|
|
return new _Version(this.major, this.minor, this.patch + 1);
|
|
default:
|
|
return Debug.assertNever(field);
|
|
}
|
|
}
|
|
with(fields) {
|
|
const {
|
|
major = this.major,
|
|
minor = this.minor,
|
|
patch = this.patch,
|
|
prerelease = this.prerelease,
|
|
build: build2 = this.build
|
|
} = fields;
|
|
return new _Version(major, minor, patch, prerelease, build2);
|
|
}
|
|
toString() {
|
|
let result = `${this.major}.${this.minor}.${this.patch}`;
|
|
if (some(this.prerelease))
|
|
result += `-${this.prerelease.join(".")}`;
|
|
if (some(this.build))
|
|
result += `+${this.build.join(".")}`;
|
|
return result;
|
|
}
|
|
};
|
|
var Version = _Version;
|
|
Version.zero = new _Version(0, 0, 0, ["0"]);
|
|
function tryParseComponents(text) {
|
|
const match = versionRegExp.exec(text);
|
|
if (!match)
|
|
return void 0;
|
|
const [, major, minor = "0", patch = "0", prerelease = "", build2 = ""] = match;
|
|
if (prerelease && !prereleaseRegExp.test(prerelease))
|
|
return void 0;
|
|
if (build2 && !buildRegExp.test(build2))
|
|
return void 0;
|
|
return {
|
|
major: parseInt(major, 10),
|
|
minor: parseInt(minor, 10),
|
|
patch: parseInt(patch, 10),
|
|
prerelease,
|
|
build: build2
|
|
};
|
|
}
|
|
function comparePrereleaseIdentifiers(left, right) {
|
|
if (left === right)
|
|
return 0 /* EqualTo */;
|
|
if (left.length === 0)
|
|
return right.length === 0 ? 0 /* EqualTo */ : 1 /* GreaterThan */;
|
|
if (right.length === 0)
|
|
return -1 /* LessThan */;
|
|
const length2 = Math.min(left.length, right.length);
|
|
for (let i = 0; i < length2; i++) {
|
|
const leftIdentifier = left[i];
|
|
const rightIdentifier = right[i];
|
|
if (leftIdentifier === rightIdentifier)
|
|
continue;
|
|
const leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier);
|
|
const rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier);
|
|
if (leftIsNumeric || rightIsNumeric) {
|
|
if (leftIsNumeric !== rightIsNumeric)
|
|
return leftIsNumeric ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
const result = compareValues(+leftIdentifier, +rightIdentifier);
|
|
if (result)
|
|
return result;
|
|
} else {
|
|
const result = compareStringsCaseSensitive(leftIdentifier, rightIdentifier);
|
|
if (result)
|
|
return result;
|
|
}
|
|
}
|
|
return compareValues(left.length, right.length);
|
|
}
|
|
var VersionRange = class {
|
|
constructor(spec) {
|
|
this._alternatives = spec ? Debug.checkDefined(parseRange(spec), "Invalid range spec.") : emptyArray;
|
|
}
|
|
static tryParse(text) {
|
|
const sets = parseRange(text);
|
|
if (sets) {
|
|
const range = new VersionRange("");
|
|
range._alternatives = sets;
|
|
return range;
|
|
}
|
|
return void 0;
|
|
}
|
|
test(version2) {
|
|
if (typeof version2 === "string")
|
|
version2 = new Version(version2);
|
|
return testDisjunction(version2, this._alternatives);
|
|
}
|
|
toString() {
|
|
return formatDisjunction(this._alternatives);
|
|
}
|
|
};
|
|
var logicalOrRegExp = /\|\|/g;
|
|
var whitespaceRegExp = /\s+/g;
|
|
var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i;
|
|
var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i;
|
|
var rangeRegExp = /^(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i;
|
|
function parseRange(text) {
|
|
const alternatives = [];
|
|
for (let range of trimString(text).split(logicalOrRegExp)) {
|
|
if (!range)
|
|
continue;
|
|
const comparators = [];
|
|
range = trimString(range);
|
|
const match = hyphenRegExp.exec(range);
|
|
if (match) {
|
|
if (!parseHyphen(match[1], match[2], comparators))
|
|
return void 0;
|
|
} else {
|
|
for (const simple of range.split(whitespaceRegExp)) {
|
|
const match2 = rangeRegExp.exec(trimString(simple));
|
|
if (!match2 || !parseComparator(match2[1], match2[2], comparators))
|
|
return void 0;
|
|
}
|
|
}
|
|
alternatives.push(comparators);
|
|
}
|
|
return alternatives;
|
|
}
|
|
function parsePartial(text) {
|
|
const match = partialRegExp.exec(text);
|
|
if (!match)
|
|
return void 0;
|
|
const [, major, minor = "*", patch = "*", prerelease, build2] = match;
|
|
const version2 = new Version(
|
|
isWildcard(major) ? 0 : parseInt(major, 10),
|
|
isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10),
|
|
isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10),
|
|
prerelease,
|
|
build2
|
|
);
|
|
return { version: version2, major, minor, patch };
|
|
}
|
|
function parseHyphen(left, right, comparators) {
|
|
const leftResult = parsePartial(left);
|
|
if (!leftResult)
|
|
return false;
|
|
const rightResult = parsePartial(right);
|
|
if (!rightResult)
|
|
return false;
|
|
if (!isWildcard(leftResult.major)) {
|
|
comparators.push(createComparator(">=", leftResult.version));
|
|
}
|
|
if (!isWildcard(rightResult.major)) {
|
|
comparators.push(
|
|
isWildcard(rightResult.minor) ? createComparator("<", rightResult.version.increment("major")) : isWildcard(rightResult.patch) ? createComparator("<", rightResult.version.increment("minor")) : createComparator("<=", rightResult.version)
|
|
);
|
|
}
|
|
return true;
|
|
}
|
|
function parseComparator(operator, text, comparators) {
|
|
const result = parsePartial(text);
|
|
if (!result)
|
|
return false;
|
|
const { version: version2, major, minor, patch } = result;
|
|
if (!isWildcard(major)) {
|
|
switch (operator) {
|
|
case "~":
|
|
comparators.push(createComparator(">=", version2));
|
|
comparators.push(createComparator("<", version2.increment(
|
|
isWildcard(minor) ? "major" : "minor"
|
|
)));
|
|
break;
|
|
case "^":
|
|
comparators.push(createComparator(">=", version2));
|
|
comparators.push(createComparator("<", version2.increment(
|
|
version2.major > 0 || isWildcard(minor) ? "major" : version2.minor > 0 || isWildcard(patch) ? "minor" : "patch"
|
|
)));
|
|
break;
|
|
case "<":
|
|
case ">=":
|
|
comparators.push(
|
|
isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version2.with({ prerelease: "0" })) : createComparator(operator, version2)
|
|
);
|
|
break;
|
|
case "<=":
|
|
case ">":
|
|
comparators.push(
|
|
isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("major").with({ prerelease: "0" })) : isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version2.increment("minor").with({ prerelease: "0" })) : createComparator(operator, version2)
|
|
);
|
|
break;
|
|
case "=":
|
|
case void 0:
|
|
if (isWildcard(minor) || isWildcard(patch)) {
|
|
comparators.push(createComparator(">=", version2.with({ prerelease: "0" })));
|
|
comparators.push(createComparator("<", version2.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" })));
|
|
} else {
|
|
comparators.push(createComparator("=", version2));
|
|
}
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
} else if (operator === "<" || operator === ">") {
|
|
comparators.push(createComparator("<", Version.zero));
|
|
}
|
|
return true;
|
|
}
|
|
function isWildcard(part) {
|
|
return part === "*" || part === "x" || part === "X";
|
|
}
|
|
function createComparator(operator, operand) {
|
|
return { operator, operand };
|
|
}
|
|
function testDisjunction(version2, alternatives) {
|
|
if (alternatives.length === 0)
|
|
return true;
|
|
for (const alternative of alternatives) {
|
|
if (testAlternative(version2, alternative))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function testAlternative(version2, comparators) {
|
|
for (const comparator of comparators) {
|
|
if (!testComparator(version2, comparator.operator, comparator.operand))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function testComparator(version2, operator, operand) {
|
|
const cmp = version2.compareTo(operand);
|
|
switch (operator) {
|
|
case "<":
|
|
return cmp < 0;
|
|
case "<=":
|
|
return cmp <= 0;
|
|
case ">":
|
|
return cmp > 0;
|
|
case ">=":
|
|
return cmp >= 0;
|
|
case "=":
|
|
return cmp === 0;
|
|
default:
|
|
return Debug.assertNever(operator);
|
|
}
|
|
}
|
|
function formatDisjunction(alternatives) {
|
|
return map(alternatives, formatAlternative).join(" || ") || "*";
|
|
}
|
|
function formatAlternative(comparators) {
|
|
return map(comparators, formatComparator).join(" ");
|
|
}
|
|
function formatComparator(comparator) {
|
|
return `${comparator.operator}${comparator.operand}`;
|
|
}
|
|
|
|
// src/compiler/performanceCore.ts
|
|
function hasRequiredAPI(performance2, PerformanceObserver2) {
|
|
return typeof performance2 === "object" && typeof performance2.timeOrigin === "number" && typeof performance2.mark === "function" && typeof performance2.measure === "function" && typeof performance2.now === "function" && typeof performance2.clearMarks === "function" && typeof performance2.clearMeasures === "function" && typeof PerformanceObserver2 === "function";
|
|
}
|
|
function tryGetWebPerformanceHooks() {
|
|
if (typeof performance === "object" && typeof PerformanceObserver === "function" && hasRequiredAPI(performance, PerformanceObserver)) {
|
|
return {
|
|
shouldWriteNativeEvents: true,
|
|
performance,
|
|
PerformanceObserver
|
|
};
|
|
}
|
|
}
|
|
function tryGetNodePerformanceHooks() {
|
|
if (isNodeLikeSystem()) {
|
|
try {
|
|
let performance2;
|
|
const { performance: nodePerformance, PerformanceObserver: PerformanceObserver2 } = require("perf_hooks");
|
|
if (hasRequiredAPI(nodePerformance, PerformanceObserver2)) {
|
|
performance2 = nodePerformance;
|
|
const version2 = new Version(process.versions.node);
|
|
const range = new VersionRange("<12.16.3 || 13 <13.13");
|
|
if (range.test(version2)) {
|
|
performance2 = {
|
|
get timeOrigin() {
|
|
return nodePerformance.timeOrigin;
|
|
},
|
|
now() {
|
|
return nodePerformance.now();
|
|
},
|
|
mark(name) {
|
|
return nodePerformance.mark(name);
|
|
},
|
|
measure(name, start2 = "nodeStart", end) {
|
|
if (end === void 0) {
|
|
end = "__performance.measure-fix__";
|
|
nodePerformance.mark(end);
|
|
}
|
|
nodePerformance.measure(name, start2, end);
|
|
if (end === "__performance.measure-fix__") {
|
|
nodePerformance.clearMarks("__performance.measure-fix__");
|
|
}
|
|
},
|
|
clearMarks(name) {
|
|
return nodePerformance.clearMarks(name);
|
|
},
|
|
clearMeasures(name) {
|
|
return nodePerformance.clearMeasures(name);
|
|
}
|
|
};
|
|
}
|
|
return {
|
|
shouldWriteNativeEvents: false,
|
|
performance: performance2,
|
|
PerformanceObserver: PerformanceObserver2
|
|
};
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
}
|
|
var nativePerformanceHooks = tryGetWebPerformanceHooks() || tryGetNodePerformanceHooks();
|
|
var nativePerformance = nativePerformanceHooks == null ? void 0 : nativePerformanceHooks.performance;
|
|
function tryGetNativePerformanceHooks() {
|
|
return nativePerformanceHooks;
|
|
}
|
|
var timestamp = nativePerformance ? () => nativePerformance.now() : Date.now ? Date.now : () => +new Date();
|
|
|
|
// src/compiler/perfLogger.ts
|
|
var nullLogger = {
|
|
logEvent: noop,
|
|
logErrEvent: noop,
|
|
logPerfEvent: noop,
|
|
logInfoEvent: noop,
|
|
logStartCommand: noop,
|
|
logStopCommand: noop,
|
|
logStartUpdateProgram: noop,
|
|
logStopUpdateProgram: noop,
|
|
logStartUpdateGraph: noop,
|
|
logStopUpdateGraph: noop,
|
|
logStartResolveModule: noop,
|
|
logStopResolveModule: noop,
|
|
logStartParseSourceFile: noop,
|
|
logStopParseSourceFile: noop,
|
|
logStartReadFile: noop,
|
|
logStopReadFile: noop,
|
|
logStartBindFile: noop,
|
|
logStopBindFile: noop,
|
|
logStartScheduledOperation: noop,
|
|
logStopScheduledOperation: noop
|
|
};
|
|
var etwModule;
|
|
var _a;
|
|
try {
|
|
const etwModulePath = (_a = process.env.TS_ETW_MODULE_PATH) != null ? _a : "./node_modules/@microsoft/typescript-etw";
|
|
etwModule = require(etwModulePath);
|
|
} catch (e) {
|
|
etwModule = void 0;
|
|
}
|
|
var perfLogger = (etwModule == null ? void 0 : etwModule.logEvent) ? etwModule : nullLogger;
|
|
|
|
// src/compiler/_namespaces/ts.performance.ts
|
|
var ts_performance_exports = {};
|
|
__export(ts_performance_exports, {
|
|
clearMarks: () => clearMarks,
|
|
clearMeasures: () => clearMeasures,
|
|
createTimer: () => createTimer,
|
|
createTimerIf: () => createTimerIf,
|
|
disable: () => disable,
|
|
enable: () => enable,
|
|
forEachMark: () => forEachMark,
|
|
forEachMeasure: () => forEachMeasure,
|
|
getCount: () => getCount,
|
|
getDuration: () => getDuration,
|
|
isEnabled: () => isEnabled,
|
|
mark: () => mark,
|
|
measure: () => measure,
|
|
nullTimer: () => nullTimer
|
|
});
|
|
|
|
// src/compiler/performance.ts
|
|
var perfHooks;
|
|
var performanceImpl;
|
|
function createTimerIf(condition, measureName, startMarkName, endMarkName) {
|
|
return condition ? createTimer(measureName, startMarkName, endMarkName) : nullTimer;
|
|
}
|
|
function createTimer(measureName, startMarkName, endMarkName) {
|
|
let enterCount = 0;
|
|
return {
|
|
enter,
|
|
exit
|
|
};
|
|
function enter() {
|
|
if (++enterCount === 1) {
|
|
mark(startMarkName);
|
|
}
|
|
}
|
|
function exit() {
|
|
if (--enterCount === 0) {
|
|
mark(endMarkName);
|
|
measure(measureName, startMarkName, endMarkName);
|
|
} else if (enterCount < 0) {
|
|
Debug.fail("enter/exit count does not match.");
|
|
}
|
|
}
|
|
}
|
|
var nullTimer = { enter: noop, exit: noop };
|
|
var enabled = false;
|
|
var timeorigin = timestamp();
|
|
var marks = /* @__PURE__ */ new Map();
|
|
var counts = /* @__PURE__ */ new Map();
|
|
var durations = /* @__PURE__ */ new Map();
|
|
function mark(markName) {
|
|
var _a2;
|
|
if (enabled) {
|
|
const count = (_a2 = counts.get(markName)) != null ? _a2 : 0;
|
|
counts.set(markName, count + 1);
|
|
marks.set(markName, timestamp());
|
|
performanceImpl == null ? void 0 : performanceImpl.mark(markName);
|
|
}
|
|
}
|
|
function measure(measureName, startMarkName, endMarkName) {
|
|
var _a2, _b;
|
|
if (enabled) {
|
|
const end = (_a2 = endMarkName !== void 0 ? marks.get(endMarkName) : void 0) != null ? _a2 : timestamp();
|
|
const start2 = (_b = startMarkName !== void 0 ? marks.get(startMarkName) : void 0) != null ? _b : timeorigin;
|
|
const previousDuration = durations.get(measureName) || 0;
|
|
durations.set(measureName, previousDuration + (end - start2));
|
|
performanceImpl == null ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName);
|
|
}
|
|
}
|
|
function getCount(markName) {
|
|
return counts.get(markName) || 0;
|
|
}
|
|
function getDuration(measureName) {
|
|
return durations.get(measureName) || 0;
|
|
}
|
|
function forEachMeasure(cb) {
|
|
durations.forEach((duration, measureName) => cb(measureName, duration));
|
|
}
|
|
function forEachMark(cb) {
|
|
marks.forEach((_time, markName) => cb(markName));
|
|
}
|
|
function clearMeasures(name) {
|
|
if (name !== void 0)
|
|
durations.delete(name);
|
|
else
|
|
durations.clear();
|
|
performanceImpl == null ? void 0 : performanceImpl.clearMeasures(name);
|
|
}
|
|
function clearMarks(name) {
|
|
if (name !== void 0) {
|
|
counts.delete(name);
|
|
marks.delete(name);
|
|
} else {
|
|
counts.clear();
|
|
marks.clear();
|
|
}
|
|
performanceImpl == null ? void 0 : performanceImpl.clearMarks(name);
|
|
}
|
|
function isEnabled() {
|
|
return enabled;
|
|
}
|
|
function enable(system = sys) {
|
|
var _a2;
|
|
if (!enabled) {
|
|
enabled = true;
|
|
perfHooks || (perfHooks = tryGetNativePerformanceHooks());
|
|
if (perfHooks) {
|
|
timeorigin = perfHooks.performance.timeOrigin;
|
|
if (perfHooks.shouldWriteNativeEvents || ((_a2 = system == null ? void 0 : system.cpuProfilingEnabled) == null ? void 0 : _a2.call(system)) || (system == null ? void 0 : system.debugMode)) {
|
|
performanceImpl = perfHooks.performance;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function disable() {
|
|
if (enabled) {
|
|
marks.clear();
|
|
counts.clear();
|
|
durations.clear();
|
|
performanceImpl = void 0;
|
|
enabled = false;
|
|
}
|
|
}
|
|
|
|
// src/compiler/tracing.ts
|
|
var tracing;
|
|
var tracingEnabled;
|
|
((tracingEnabled2) => {
|
|
let fs;
|
|
let traceCount = 0;
|
|
let traceFd = 0;
|
|
let mode;
|
|
const typeCatalog = [];
|
|
let legendPath;
|
|
const legend = [];
|
|
function startTracing2(tracingMode, traceDir, configFilePath) {
|
|
Debug.assert(!tracing, "Tracing already started");
|
|
if (fs === void 0) {
|
|
try {
|
|
fs = require("fs");
|
|
} catch (e) {
|
|
throw new Error(`tracing requires having fs
|
|
(original error: ${e.message || e})`);
|
|
}
|
|
}
|
|
mode = tracingMode;
|
|
typeCatalog.length = 0;
|
|
if (legendPath === void 0) {
|
|
legendPath = combinePaths(traceDir, "legend.json");
|
|
}
|
|
if (!fs.existsSync(traceDir)) {
|
|
fs.mkdirSync(traceDir, { recursive: true });
|
|
}
|
|
const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
|
|
const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
|
|
const typesPath = combinePaths(traceDir, `types${countPart}.json`);
|
|
legend.push({
|
|
configFilePath,
|
|
tracePath,
|
|
typesPath
|
|
});
|
|
traceFd = fs.openSync(tracePath, "w");
|
|
tracing = tracingEnabled2;
|
|
const meta = { cat: "__metadata", ph: "M", ts: 1e3 * timestamp(), pid: 1, tid: 1 };
|
|
fs.writeSync(
|
|
traceFd,
|
|
"[\n" + [
|
|
{ name: "process_name", args: { name: "tsc" }, ...meta },
|
|
{ name: "thread_name", args: { name: "Main" }, ...meta },
|
|
{ name: "TracingStartedInBrowser", ...meta, cat: "disabled-by-default-devtools.timeline" }
|
|
].map((v) => JSON.stringify(v)).join(",\n")
|
|
);
|
|
}
|
|
tracingEnabled2.startTracing = startTracing2;
|
|
function stopTracing() {
|
|
Debug.assert(tracing, "Tracing is not in progress");
|
|
Debug.assert(!!typeCatalog.length === (mode !== "server"));
|
|
fs.writeSync(traceFd, `
|
|
]
|
|
`);
|
|
fs.closeSync(traceFd);
|
|
tracing = void 0;
|
|
if (typeCatalog.length) {
|
|
dumpTypes(typeCatalog);
|
|
} else {
|
|
legend[legend.length - 1].typesPath = void 0;
|
|
}
|
|
}
|
|
tracingEnabled2.stopTracing = stopTracing;
|
|
function recordType(type) {
|
|
if (mode !== "server") {
|
|
typeCatalog.push(type);
|
|
}
|
|
}
|
|
tracingEnabled2.recordType = recordType;
|
|
let Phase;
|
|
((Phase2) => {
|
|
Phase2["Parse"] = "parse";
|
|
Phase2["Program"] = "program";
|
|
Phase2["Bind"] = "bind";
|
|
Phase2["Check"] = "check";
|
|
Phase2["CheckTypes"] = "checkTypes";
|
|
Phase2["Emit"] = "emit";
|
|
Phase2["Session"] = "session";
|
|
})(Phase = tracingEnabled2.Phase || (tracingEnabled2.Phase = {}));
|
|
function instant(phase, name, args) {
|
|
writeEvent("I", phase, name, args, `"s":"g"`);
|
|
}
|
|
tracingEnabled2.instant = instant;
|
|
const eventStack = [];
|
|
function push(phase, name, args, separateBeginAndEnd = false) {
|
|
if (separateBeginAndEnd) {
|
|
writeEvent("B", phase, name, args);
|
|
}
|
|
eventStack.push({ phase, name, args, time: 1e3 * timestamp(), separateBeginAndEnd });
|
|
}
|
|
tracingEnabled2.push = push;
|
|
function pop(results) {
|
|
Debug.assert(eventStack.length > 0);
|
|
writeStackEvent(eventStack.length - 1, 1e3 * timestamp(), results);
|
|
eventStack.length--;
|
|
}
|
|
tracingEnabled2.pop = pop;
|
|
function popAll() {
|
|
const endTime = 1e3 * timestamp();
|
|
for (let i = eventStack.length - 1; i >= 0; i--) {
|
|
writeStackEvent(i, endTime);
|
|
}
|
|
eventStack.length = 0;
|
|
}
|
|
tracingEnabled2.popAll = popAll;
|
|
const sampleInterval = 1e3 * 10;
|
|
function writeStackEvent(index, endTime, results) {
|
|
const { phase, name, args, time, separateBeginAndEnd } = eventStack[index];
|
|
if (separateBeginAndEnd) {
|
|
Debug.assert(!results, "`results` are not supported for events with `separateBeginAndEnd`");
|
|
writeEvent("E", phase, name, args, void 0, endTime);
|
|
} else if (sampleInterval - time % sampleInterval <= endTime - time) {
|
|
writeEvent("X", phase, name, { ...args, results }, `"dur":${endTime - time}`, time);
|
|
}
|
|
}
|
|
function writeEvent(eventType, phase, name, args, extras, time = 1e3 * timestamp()) {
|
|
if (mode === "server" && phase === "checkTypes" /* CheckTypes */)
|
|
return;
|
|
mark("beginTracing");
|
|
fs.writeSync(traceFd, `,
|
|
{"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time},"name":"${name}"`);
|
|
if (extras)
|
|
fs.writeSync(traceFd, `,${extras}`);
|
|
if (args)
|
|
fs.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
|
|
fs.writeSync(traceFd, `}`);
|
|
mark("endTracing");
|
|
measure("Tracing", "beginTracing", "endTracing");
|
|
}
|
|
function getLocation(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return !file ? void 0 : {
|
|
path: file.path,
|
|
start: indexFromOne(getLineAndCharacterOfPosition(file, node.pos)),
|
|
end: indexFromOne(getLineAndCharacterOfPosition(file, node.end))
|
|
};
|
|
function indexFromOne(lc) {
|
|
return {
|
|
line: lc.line + 1,
|
|
character: lc.character + 1
|
|
};
|
|
}
|
|
}
|
|
function dumpTypes(types) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v;
|
|
mark("beginDumpTypes");
|
|
const typesPath = legend[legend.length - 1].typesPath;
|
|
const typesFd = fs.openSync(typesPath, "w");
|
|
const recursionIdentityMap = /* @__PURE__ */ new Map();
|
|
fs.writeSync(typesFd, "[");
|
|
const numTypes = types.length;
|
|
for (let i = 0; i < numTypes; i++) {
|
|
const type = types[i];
|
|
const objectFlags = type.objectFlags;
|
|
const symbol = (_a2 = type.aliasSymbol) != null ? _a2 : type.symbol;
|
|
let display;
|
|
if (objectFlags & 16 /* Anonymous */ | type.flags & 2944 /* Literal */) {
|
|
try {
|
|
display = (_b = type.checker) == null ? void 0 : _b.typeToString(type);
|
|
} catch (e) {
|
|
display = void 0;
|
|
}
|
|
}
|
|
let indexedAccessProperties = {};
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
const indexedAccessType = type;
|
|
indexedAccessProperties = {
|
|
indexedAccessObjectType: (_c = indexedAccessType.objectType) == null ? void 0 : _c.id,
|
|
indexedAccessIndexType: (_d = indexedAccessType.indexType) == null ? void 0 : _d.id
|
|
};
|
|
}
|
|
let referenceProperties = {};
|
|
if (objectFlags & 4 /* Reference */) {
|
|
const referenceType = type;
|
|
referenceProperties = {
|
|
instantiatedType: (_e = referenceType.target) == null ? void 0 : _e.id,
|
|
typeArguments: (_f = referenceType.resolvedTypeArguments) == null ? void 0 : _f.map((t) => t.id),
|
|
referenceLocation: getLocation(referenceType.node)
|
|
};
|
|
}
|
|
let conditionalProperties = {};
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
const conditionalType = type;
|
|
conditionalProperties = {
|
|
conditionalCheckType: (_g = conditionalType.checkType) == null ? void 0 : _g.id,
|
|
conditionalExtendsType: (_h = conditionalType.extendsType) == null ? void 0 : _h.id,
|
|
conditionalTrueType: (_j = (_i = conditionalType.resolvedTrueType) == null ? void 0 : _i.id) != null ? _j : -1,
|
|
conditionalFalseType: (_l = (_k = conditionalType.resolvedFalseType) == null ? void 0 : _k.id) != null ? _l : -1
|
|
};
|
|
}
|
|
let substitutionProperties = {};
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
const substitutionType = type;
|
|
substitutionProperties = {
|
|
substitutionBaseType: (_m = substitutionType.baseType) == null ? void 0 : _m.id,
|
|
constraintType: (_n = substitutionType.constraint) == null ? void 0 : _n.id
|
|
};
|
|
}
|
|
let reverseMappedProperties = {};
|
|
if (objectFlags & 1024 /* ReverseMapped */) {
|
|
const reverseMappedType = type;
|
|
reverseMappedProperties = {
|
|
reverseMappedSourceType: (_o = reverseMappedType.source) == null ? void 0 : _o.id,
|
|
reverseMappedMappedType: (_p = reverseMappedType.mappedType) == null ? void 0 : _p.id,
|
|
reverseMappedConstraintType: (_q = reverseMappedType.constraintType) == null ? void 0 : _q.id
|
|
};
|
|
}
|
|
let evolvingArrayProperties = {};
|
|
if (objectFlags & 256 /* EvolvingArray */) {
|
|
const evolvingArrayType = type;
|
|
evolvingArrayProperties = {
|
|
evolvingArrayElementType: evolvingArrayType.elementType.id,
|
|
evolvingArrayFinalType: (_r = evolvingArrayType.finalArrayType) == null ? void 0 : _r.id
|
|
};
|
|
}
|
|
let recursionToken;
|
|
const recursionIdentity = type.checker.getRecursionIdentity(type);
|
|
if (recursionIdentity) {
|
|
recursionToken = recursionIdentityMap.get(recursionIdentity);
|
|
if (!recursionToken) {
|
|
recursionToken = recursionIdentityMap.size;
|
|
recursionIdentityMap.set(recursionIdentity, recursionToken);
|
|
}
|
|
}
|
|
const descriptor = {
|
|
id: type.id,
|
|
intrinsicName: type.intrinsicName,
|
|
symbolName: (symbol == null ? void 0 : symbol.escapedName) && unescapeLeadingUnderscores(symbol.escapedName),
|
|
recursionId: recursionToken,
|
|
isTuple: objectFlags & 8 /* Tuple */ ? true : void 0,
|
|
unionTypes: type.flags & 1048576 /* Union */ ? (_s = type.types) == null ? void 0 : _s.map((t) => t.id) : void 0,
|
|
intersectionTypes: type.flags & 2097152 /* Intersection */ ? type.types.map((t) => t.id) : void 0,
|
|
aliasTypeArguments: (_t = type.aliasTypeArguments) == null ? void 0 : _t.map((t) => t.id),
|
|
keyofType: type.flags & 4194304 /* Index */ ? (_u = type.type) == null ? void 0 : _u.id : void 0,
|
|
...indexedAccessProperties,
|
|
...referenceProperties,
|
|
...conditionalProperties,
|
|
...substitutionProperties,
|
|
...reverseMappedProperties,
|
|
...evolvingArrayProperties,
|
|
destructuringPattern: getLocation(type.pattern),
|
|
firstDeclaration: getLocation((_v = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _v[0]),
|
|
flags: Debug.formatTypeFlags(type.flags).split("|"),
|
|
display
|
|
};
|
|
fs.writeSync(typesFd, JSON.stringify(descriptor));
|
|
if (i < numTypes - 1) {
|
|
fs.writeSync(typesFd, ",\n");
|
|
}
|
|
}
|
|
fs.writeSync(typesFd, "]\n");
|
|
fs.closeSync(typesFd);
|
|
mark("endDumpTypes");
|
|
measure("Dump types", "beginDumpTypes", "endDumpTypes");
|
|
}
|
|
function dumpLegend() {
|
|
if (!legendPath) {
|
|
return;
|
|
}
|
|
fs.writeFileSync(legendPath, JSON.stringify(legend));
|
|
}
|
|
tracingEnabled2.dumpLegend = dumpLegend;
|
|
})(tracingEnabled || (tracingEnabled = {}));
|
|
var startTracing = tracingEnabled.startTracing;
|
|
var dumpTracingLegend = tracingEnabled.dumpLegend;
|
|
|
|
// src/compiler/types.ts
|
|
var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
|
|
SyntaxKind5[SyntaxKind5["Unknown"] = 0] = "Unknown";
|
|
SyntaxKind5[SyntaxKind5["EndOfFileToken"] = 1] = "EndOfFileToken";
|
|
SyntaxKind5[SyntaxKind5["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia";
|
|
SyntaxKind5[SyntaxKind5["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia";
|
|
SyntaxKind5[SyntaxKind5["NewLineTrivia"] = 4] = "NewLineTrivia";
|
|
SyntaxKind5[SyntaxKind5["WhitespaceTrivia"] = 5] = "WhitespaceTrivia";
|
|
SyntaxKind5[SyntaxKind5["ShebangTrivia"] = 6] = "ShebangTrivia";
|
|
SyntaxKind5[SyntaxKind5["ConflictMarkerTrivia"] = 7] = "ConflictMarkerTrivia";
|
|
SyntaxKind5[SyntaxKind5["NumericLiteral"] = 8] = "NumericLiteral";
|
|
SyntaxKind5[SyntaxKind5["BigIntLiteral"] = 9] = "BigIntLiteral";
|
|
SyntaxKind5[SyntaxKind5["StringLiteral"] = 10] = "StringLiteral";
|
|
SyntaxKind5[SyntaxKind5["JsxText"] = 11] = "JsxText";
|
|
SyntaxKind5[SyntaxKind5["JsxTextAllWhiteSpaces"] = 12] = "JsxTextAllWhiteSpaces";
|
|
SyntaxKind5[SyntaxKind5["RegularExpressionLiteral"] = 13] = "RegularExpressionLiteral";
|
|
SyntaxKind5[SyntaxKind5["NoSubstitutionTemplateLiteral"] = 14] = "NoSubstitutionTemplateLiteral";
|
|
SyntaxKind5[SyntaxKind5["TemplateHead"] = 15] = "TemplateHead";
|
|
SyntaxKind5[SyntaxKind5["TemplateMiddle"] = 16] = "TemplateMiddle";
|
|
SyntaxKind5[SyntaxKind5["TemplateTail"] = 17] = "TemplateTail";
|
|
SyntaxKind5[SyntaxKind5["OpenBraceToken"] = 18] = "OpenBraceToken";
|
|
SyntaxKind5[SyntaxKind5["CloseBraceToken"] = 19] = "CloseBraceToken";
|
|
SyntaxKind5[SyntaxKind5["OpenParenToken"] = 20] = "OpenParenToken";
|
|
SyntaxKind5[SyntaxKind5["CloseParenToken"] = 21] = "CloseParenToken";
|
|
SyntaxKind5[SyntaxKind5["OpenBracketToken"] = 22] = "OpenBracketToken";
|
|
SyntaxKind5[SyntaxKind5["CloseBracketToken"] = 23] = "CloseBracketToken";
|
|
SyntaxKind5[SyntaxKind5["DotToken"] = 24] = "DotToken";
|
|
SyntaxKind5[SyntaxKind5["DotDotDotToken"] = 25] = "DotDotDotToken";
|
|
SyntaxKind5[SyntaxKind5["SemicolonToken"] = 26] = "SemicolonToken";
|
|
SyntaxKind5[SyntaxKind5["CommaToken"] = 27] = "CommaToken";
|
|
SyntaxKind5[SyntaxKind5["QuestionDotToken"] = 28] = "QuestionDotToken";
|
|
SyntaxKind5[SyntaxKind5["LessThanToken"] = 29] = "LessThanToken";
|
|
SyntaxKind5[SyntaxKind5["LessThanSlashToken"] = 30] = "LessThanSlashToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanToken"] = 31] = "GreaterThanToken";
|
|
SyntaxKind5[SyntaxKind5["LessThanEqualsToken"] = 32] = "LessThanEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanEqualsToken"] = 33] = "GreaterThanEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["EqualsEqualsToken"] = 34] = "EqualsEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["ExclamationEqualsToken"] = 35] = "ExclamationEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["EqualsEqualsEqualsToken"] = 36] = "EqualsEqualsEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["ExclamationEqualsEqualsToken"] = 37] = "ExclamationEqualsEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["EqualsGreaterThanToken"] = 38] = "EqualsGreaterThanToken";
|
|
SyntaxKind5[SyntaxKind5["PlusToken"] = 39] = "PlusToken";
|
|
SyntaxKind5[SyntaxKind5["MinusToken"] = 40] = "MinusToken";
|
|
SyntaxKind5[SyntaxKind5["AsteriskToken"] = 41] = "AsteriskToken";
|
|
SyntaxKind5[SyntaxKind5["AsteriskAsteriskToken"] = 42] = "AsteriskAsteriskToken";
|
|
SyntaxKind5[SyntaxKind5["SlashToken"] = 43] = "SlashToken";
|
|
SyntaxKind5[SyntaxKind5["PercentToken"] = 44] = "PercentToken";
|
|
SyntaxKind5[SyntaxKind5["PlusPlusToken"] = 45] = "PlusPlusToken";
|
|
SyntaxKind5[SyntaxKind5["MinusMinusToken"] = 46] = "MinusMinusToken";
|
|
SyntaxKind5[SyntaxKind5["LessThanLessThanToken"] = 47] = "LessThanLessThanToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanGreaterThanToken"] = 48] = "GreaterThanGreaterThanToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanGreaterThanGreaterThanToken"] = 49] = "GreaterThanGreaterThanGreaterThanToken";
|
|
SyntaxKind5[SyntaxKind5["AmpersandToken"] = 50] = "AmpersandToken";
|
|
SyntaxKind5[SyntaxKind5["BarToken"] = 51] = "BarToken";
|
|
SyntaxKind5[SyntaxKind5["CaretToken"] = 52] = "CaretToken";
|
|
SyntaxKind5[SyntaxKind5["ExclamationToken"] = 53] = "ExclamationToken";
|
|
SyntaxKind5[SyntaxKind5["TildeToken"] = 54] = "TildeToken";
|
|
SyntaxKind5[SyntaxKind5["AmpersandAmpersandToken"] = 55] = "AmpersandAmpersandToken";
|
|
SyntaxKind5[SyntaxKind5["BarBarToken"] = 56] = "BarBarToken";
|
|
SyntaxKind5[SyntaxKind5["QuestionToken"] = 57] = "QuestionToken";
|
|
SyntaxKind5[SyntaxKind5["ColonToken"] = 58] = "ColonToken";
|
|
SyntaxKind5[SyntaxKind5["AtToken"] = 59] = "AtToken";
|
|
SyntaxKind5[SyntaxKind5["QuestionQuestionToken"] = 60] = "QuestionQuestionToken";
|
|
SyntaxKind5[SyntaxKind5["BacktickToken"] = 61] = "BacktickToken";
|
|
SyntaxKind5[SyntaxKind5["HashToken"] = 62] = "HashToken";
|
|
SyntaxKind5[SyntaxKind5["EqualsToken"] = 63] = "EqualsToken";
|
|
SyntaxKind5[SyntaxKind5["PlusEqualsToken"] = 64] = "PlusEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["MinusEqualsToken"] = 65] = "MinusEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["AsteriskEqualsToken"] = 66] = "AsteriskEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["AsteriskAsteriskEqualsToken"] = 67] = "AsteriskAsteriskEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["SlashEqualsToken"] = 68] = "SlashEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["PercentEqualsToken"] = 69] = "PercentEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["LessThanLessThanEqualsToken"] = 70] = "LessThanLessThanEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanGreaterThanEqualsToken"] = 71] = "GreaterThanGreaterThanEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["GreaterThanGreaterThanGreaterThanEqualsToken"] = 72] = "GreaterThanGreaterThanGreaterThanEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["AmpersandEqualsToken"] = 73] = "AmpersandEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["BarEqualsToken"] = 74] = "BarEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["BarBarEqualsToken"] = 75] = "BarBarEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["AmpersandAmpersandEqualsToken"] = 76] = "AmpersandAmpersandEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["QuestionQuestionEqualsToken"] = 77] = "QuestionQuestionEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["CaretEqualsToken"] = 78] = "CaretEqualsToken";
|
|
SyntaxKind5[SyntaxKind5["Identifier"] = 79] = "Identifier";
|
|
SyntaxKind5[SyntaxKind5["PrivateIdentifier"] = 80] = "PrivateIdentifier";
|
|
SyntaxKind5[SyntaxKind5["BreakKeyword"] = 81] = "BreakKeyword";
|
|
SyntaxKind5[SyntaxKind5["CaseKeyword"] = 82] = "CaseKeyword";
|
|
SyntaxKind5[SyntaxKind5["CatchKeyword"] = 83] = "CatchKeyword";
|
|
SyntaxKind5[SyntaxKind5["ClassKeyword"] = 84] = "ClassKeyword";
|
|
SyntaxKind5[SyntaxKind5["ConstKeyword"] = 85] = "ConstKeyword";
|
|
SyntaxKind5[SyntaxKind5["ContinueKeyword"] = 86] = "ContinueKeyword";
|
|
SyntaxKind5[SyntaxKind5["DebuggerKeyword"] = 87] = "DebuggerKeyword";
|
|
SyntaxKind5[SyntaxKind5["DefaultKeyword"] = 88] = "DefaultKeyword";
|
|
SyntaxKind5[SyntaxKind5["DeleteKeyword"] = 89] = "DeleteKeyword";
|
|
SyntaxKind5[SyntaxKind5["DoKeyword"] = 90] = "DoKeyword";
|
|
SyntaxKind5[SyntaxKind5["ElseKeyword"] = 91] = "ElseKeyword";
|
|
SyntaxKind5[SyntaxKind5["EnumKeyword"] = 92] = "EnumKeyword";
|
|
SyntaxKind5[SyntaxKind5["ExportKeyword"] = 93] = "ExportKeyword";
|
|
SyntaxKind5[SyntaxKind5["ExtendsKeyword"] = 94] = "ExtendsKeyword";
|
|
SyntaxKind5[SyntaxKind5["FalseKeyword"] = 95] = "FalseKeyword";
|
|
SyntaxKind5[SyntaxKind5["FinallyKeyword"] = 96] = "FinallyKeyword";
|
|
SyntaxKind5[SyntaxKind5["ForKeyword"] = 97] = "ForKeyword";
|
|
SyntaxKind5[SyntaxKind5["FunctionKeyword"] = 98] = "FunctionKeyword";
|
|
SyntaxKind5[SyntaxKind5["IfKeyword"] = 99] = "IfKeyword";
|
|
SyntaxKind5[SyntaxKind5["ImportKeyword"] = 100] = "ImportKeyword";
|
|
SyntaxKind5[SyntaxKind5["InKeyword"] = 101] = "InKeyword";
|
|
SyntaxKind5[SyntaxKind5["InstanceOfKeyword"] = 102] = "InstanceOfKeyword";
|
|
SyntaxKind5[SyntaxKind5["NewKeyword"] = 103] = "NewKeyword";
|
|
SyntaxKind5[SyntaxKind5["NullKeyword"] = 104] = "NullKeyword";
|
|
SyntaxKind5[SyntaxKind5["ReturnKeyword"] = 105] = "ReturnKeyword";
|
|
SyntaxKind5[SyntaxKind5["SuperKeyword"] = 106] = "SuperKeyword";
|
|
SyntaxKind5[SyntaxKind5["SwitchKeyword"] = 107] = "SwitchKeyword";
|
|
SyntaxKind5[SyntaxKind5["ThisKeyword"] = 108] = "ThisKeyword";
|
|
SyntaxKind5[SyntaxKind5["ThrowKeyword"] = 109] = "ThrowKeyword";
|
|
SyntaxKind5[SyntaxKind5["TrueKeyword"] = 110] = "TrueKeyword";
|
|
SyntaxKind5[SyntaxKind5["TryKeyword"] = 111] = "TryKeyword";
|
|
SyntaxKind5[SyntaxKind5["TypeOfKeyword"] = 112] = "TypeOfKeyword";
|
|
SyntaxKind5[SyntaxKind5["VarKeyword"] = 113] = "VarKeyword";
|
|
SyntaxKind5[SyntaxKind5["VoidKeyword"] = 114] = "VoidKeyword";
|
|
SyntaxKind5[SyntaxKind5["WhileKeyword"] = 115] = "WhileKeyword";
|
|
SyntaxKind5[SyntaxKind5["WithKeyword"] = 116] = "WithKeyword";
|
|
SyntaxKind5[SyntaxKind5["ImplementsKeyword"] = 117] = "ImplementsKeyword";
|
|
SyntaxKind5[SyntaxKind5["InterfaceKeyword"] = 118] = "InterfaceKeyword";
|
|
SyntaxKind5[SyntaxKind5["LetKeyword"] = 119] = "LetKeyword";
|
|
SyntaxKind5[SyntaxKind5["PackageKeyword"] = 120] = "PackageKeyword";
|
|
SyntaxKind5[SyntaxKind5["PrivateKeyword"] = 121] = "PrivateKeyword";
|
|
SyntaxKind5[SyntaxKind5["ProtectedKeyword"] = 122] = "ProtectedKeyword";
|
|
SyntaxKind5[SyntaxKind5["PublicKeyword"] = 123] = "PublicKeyword";
|
|
SyntaxKind5[SyntaxKind5["StaticKeyword"] = 124] = "StaticKeyword";
|
|
SyntaxKind5[SyntaxKind5["YieldKeyword"] = 125] = "YieldKeyword";
|
|
SyntaxKind5[SyntaxKind5["AbstractKeyword"] = 126] = "AbstractKeyword";
|
|
SyntaxKind5[SyntaxKind5["AccessorKeyword"] = 127] = "AccessorKeyword";
|
|
SyntaxKind5[SyntaxKind5["AsKeyword"] = 128] = "AsKeyword";
|
|
SyntaxKind5[SyntaxKind5["AssertsKeyword"] = 129] = "AssertsKeyword";
|
|
SyntaxKind5[SyntaxKind5["AssertKeyword"] = 130] = "AssertKeyword";
|
|
SyntaxKind5[SyntaxKind5["AnyKeyword"] = 131] = "AnyKeyword";
|
|
SyntaxKind5[SyntaxKind5["AsyncKeyword"] = 132] = "AsyncKeyword";
|
|
SyntaxKind5[SyntaxKind5["AwaitKeyword"] = 133] = "AwaitKeyword";
|
|
SyntaxKind5[SyntaxKind5["BooleanKeyword"] = 134] = "BooleanKeyword";
|
|
SyntaxKind5[SyntaxKind5["ConstructorKeyword"] = 135] = "ConstructorKeyword";
|
|
SyntaxKind5[SyntaxKind5["DeclareKeyword"] = 136] = "DeclareKeyword";
|
|
SyntaxKind5[SyntaxKind5["GetKeyword"] = 137] = "GetKeyword";
|
|
SyntaxKind5[SyntaxKind5["InferKeyword"] = 138] = "InferKeyword";
|
|
SyntaxKind5[SyntaxKind5["IntrinsicKeyword"] = 139] = "IntrinsicKeyword";
|
|
SyntaxKind5[SyntaxKind5["IsKeyword"] = 140] = "IsKeyword";
|
|
SyntaxKind5[SyntaxKind5["KeyOfKeyword"] = 141] = "KeyOfKeyword";
|
|
SyntaxKind5[SyntaxKind5["ModuleKeyword"] = 142] = "ModuleKeyword";
|
|
SyntaxKind5[SyntaxKind5["NamespaceKeyword"] = 143] = "NamespaceKeyword";
|
|
SyntaxKind5[SyntaxKind5["NeverKeyword"] = 144] = "NeverKeyword";
|
|
SyntaxKind5[SyntaxKind5["OutKeyword"] = 145] = "OutKeyword";
|
|
SyntaxKind5[SyntaxKind5["ReadonlyKeyword"] = 146] = "ReadonlyKeyword";
|
|
SyntaxKind5[SyntaxKind5["RequireKeyword"] = 147] = "RequireKeyword";
|
|
SyntaxKind5[SyntaxKind5["NumberKeyword"] = 148] = "NumberKeyword";
|
|
SyntaxKind5[SyntaxKind5["ObjectKeyword"] = 149] = "ObjectKeyword";
|
|
SyntaxKind5[SyntaxKind5["SatisfiesKeyword"] = 150] = "SatisfiesKeyword";
|
|
SyntaxKind5[SyntaxKind5["SetKeyword"] = 151] = "SetKeyword";
|
|
SyntaxKind5[SyntaxKind5["StringKeyword"] = 152] = "StringKeyword";
|
|
SyntaxKind5[SyntaxKind5["SymbolKeyword"] = 153] = "SymbolKeyword";
|
|
SyntaxKind5[SyntaxKind5["TypeKeyword"] = 154] = "TypeKeyword";
|
|
SyntaxKind5[SyntaxKind5["UndefinedKeyword"] = 155] = "UndefinedKeyword";
|
|
SyntaxKind5[SyntaxKind5["UniqueKeyword"] = 156] = "UniqueKeyword";
|
|
SyntaxKind5[SyntaxKind5["UnknownKeyword"] = 157] = "UnknownKeyword";
|
|
SyntaxKind5[SyntaxKind5["FromKeyword"] = 158] = "FromKeyword";
|
|
SyntaxKind5[SyntaxKind5["GlobalKeyword"] = 159] = "GlobalKeyword";
|
|
SyntaxKind5[SyntaxKind5["BigIntKeyword"] = 160] = "BigIntKeyword";
|
|
SyntaxKind5[SyntaxKind5["OverrideKeyword"] = 161] = "OverrideKeyword";
|
|
SyntaxKind5[SyntaxKind5["OfKeyword"] = 162] = "OfKeyword";
|
|
SyntaxKind5[SyntaxKind5["QualifiedName"] = 163] = "QualifiedName";
|
|
SyntaxKind5[SyntaxKind5["ComputedPropertyName"] = 164] = "ComputedPropertyName";
|
|
SyntaxKind5[SyntaxKind5["TypeParameter"] = 165] = "TypeParameter";
|
|
SyntaxKind5[SyntaxKind5["Parameter"] = 166] = "Parameter";
|
|
SyntaxKind5[SyntaxKind5["Decorator"] = 167] = "Decorator";
|
|
SyntaxKind5[SyntaxKind5["PropertySignature"] = 168] = "PropertySignature";
|
|
SyntaxKind5[SyntaxKind5["PropertyDeclaration"] = 169] = "PropertyDeclaration";
|
|
SyntaxKind5[SyntaxKind5["MethodSignature"] = 170] = "MethodSignature";
|
|
SyntaxKind5[SyntaxKind5["MethodDeclaration"] = 171] = "MethodDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ClassStaticBlockDeclaration"] = 172] = "ClassStaticBlockDeclaration";
|
|
SyntaxKind5[SyntaxKind5["Constructor"] = 173] = "Constructor";
|
|
SyntaxKind5[SyntaxKind5["GetAccessor"] = 174] = "GetAccessor";
|
|
SyntaxKind5[SyntaxKind5["SetAccessor"] = 175] = "SetAccessor";
|
|
SyntaxKind5[SyntaxKind5["CallSignature"] = 176] = "CallSignature";
|
|
SyntaxKind5[SyntaxKind5["ConstructSignature"] = 177] = "ConstructSignature";
|
|
SyntaxKind5[SyntaxKind5["IndexSignature"] = 178] = "IndexSignature";
|
|
SyntaxKind5[SyntaxKind5["TypePredicate"] = 179] = "TypePredicate";
|
|
SyntaxKind5[SyntaxKind5["TypeReference"] = 180] = "TypeReference";
|
|
SyntaxKind5[SyntaxKind5["FunctionType"] = 181] = "FunctionType";
|
|
SyntaxKind5[SyntaxKind5["ConstructorType"] = 182] = "ConstructorType";
|
|
SyntaxKind5[SyntaxKind5["TypeQuery"] = 183] = "TypeQuery";
|
|
SyntaxKind5[SyntaxKind5["TypeLiteral"] = 184] = "TypeLiteral";
|
|
SyntaxKind5[SyntaxKind5["ArrayType"] = 185] = "ArrayType";
|
|
SyntaxKind5[SyntaxKind5["TupleType"] = 186] = "TupleType";
|
|
SyntaxKind5[SyntaxKind5["OptionalType"] = 187] = "OptionalType";
|
|
SyntaxKind5[SyntaxKind5["RestType"] = 188] = "RestType";
|
|
SyntaxKind5[SyntaxKind5["UnionType"] = 189] = "UnionType";
|
|
SyntaxKind5[SyntaxKind5["IntersectionType"] = 190] = "IntersectionType";
|
|
SyntaxKind5[SyntaxKind5["ConditionalType"] = 191] = "ConditionalType";
|
|
SyntaxKind5[SyntaxKind5["InferType"] = 192] = "InferType";
|
|
SyntaxKind5[SyntaxKind5["ParenthesizedType"] = 193] = "ParenthesizedType";
|
|
SyntaxKind5[SyntaxKind5["ThisType"] = 194] = "ThisType";
|
|
SyntaxKind5[SyntaxKind5["TypeOperator"] = 195] = "TypeOperator";
|
|
SyntaxKind5[SyntaxKind5["IndexedAccessType"] = 196] = "IndexedAccessType";
|
|
SyntaxKind5[SyntaxKind5["MappedType"] = 197] = "MappedType";
|
|
SyntaxKind5[SyntaxKind5["LiteralType"] = 198] = "LiteralType";
|
|
SyntaxKind5[SyntaxKind5["NamedTupleMember"] = 199] = "NamedTupleMember";
|
|
SyntaxKind5[SyntaxKind5["TemplateLiteralType"] = 200] = "TemplateLiteralType";
|
|
SyntaxKind5[SyntaxKind5["TemplateLiteralTypeSpan"] = 201] = "TemplateLiteralTypeSpan";
|
|
SyntaxKind5[SyntaxKind5["ImportType"] = 202] = "ImportType";
|
|
SyntaxKind5[SyntaxKind5["ObjectBindingPattern"] = 203] = "ObjectBindingPattern";
|
|
SyntaxKind5[SyntaxKind5["ArrayBindingPattern"] = 204] = "ArrayBindingPattern";
|
|
SyntaxKind5[SyntaxKind5["BindingElement"] = 205] = "BindingElement";
|
|
SyntaxKind5[SyntaxKind5["ArrayLiteralExpression"] = 206] = "ArrayLiteralExpression";
|
|
SyntaxKind5[SyntaxKind5["ObjectLiteralExpression"] = 207] = "ObjectLiteralExpression";
|
|
SyntaxKind5[SyntaxKind5["PropertyAccessExpression"] = 208] = "PropertyAccessExpression";
|
|
SyntaxKind5[SyntaxKind5["ElementAccessExpression"] = 209] = "ElementAccessExpression";
|
|
SyntaxKind5[SyntaxKind5["CallExpression"] = 210] = "CallExpression";
|
|
SyntaxKind5[SyntaxKind5["NewExpression"] = 211] = "NewExpression";
|
|
SyntaxKind5[SyntaxKind5["TaggedTemplateExpression"] = 212] = "TaggedTemplateExpression";
|
|
SyntaxKind5[SyntaxKind5["TypeAssertionExpression"] = 213] = "TypeAssertionExpression";
|
|
SyntaxKind5[SyntaxKind5["ParenthesizedExpression"] = 214] = "ParenthesizedExpression";
|
|
SyntaxKind5[SyntaxKind5["FunctionExpression"] = 215] = "FunctionExpression";
|
|
SyntaxKind5[SyntaxKind5["ArrowFunction"] = 216] = "ArrowFunction";
|
|
SyntaxKind5[SyntaxKind5["DeleteExpression"] = 217] = "DeleteExpression";
|
|
SyntaxKind5[SyntaxKind5["TypeOfExpression"] = 218] = "TypeOfExpression";
|
|
SyntaxKind5[SyntaxKind5["VoidExpression"] = 219] = "VoidExpression";
|
|
SyntaxKind5[SyntaxKind5["AwaitExpression"] = 220] = "AwaitExpression";
|
|
SyntaxKind5[SyntaxKind5["PrefixUnaryExpression"] = 221] = "PrefixUnaryExpression";
|
|
SyntaxKind5[SyntaxKind5["PostfixUnaryExpression"] = 222] = "PostfixUnaryExpression";
|
|
SyntaxKind5[SyntaxKind5["BinaryExpression"] = 223] = "BinaryExpression";
|
|
SyntaxKind5[SyntaxKind5["ConditionalExpression"] = 224] = "ConditionalExpression";
|
|
SyntaxKind5[SyntaxKind5["TemplateExpression"] = 225] = "TemplateExpression";
|
|
SyntaxKind5[SyntaxKind5["YieldExpression"] = 226] = "YieldExpression";
|
|
SyntaxKind5[SyntaxKind5["SpreadElement"] = 227] = "SpreadElement";
|
|
SyntaxKind5[SyntaxKind5["ClassExpression"] = 228] = "ClassExpression";
|
|
SyntaxKind5[SyntaxKind5["OmittedExpression"] = 229] = "OmittedExpression";
|
|
SyntaxKind5[SyntaxKind5["ExpressionWithTypeArguments"] = 230] = "ExpressionWithTypeArguments";
|
|
SyntaxKind5[SyntaxKind5["AsExpression"] = 231] = "AsExpression";
|
|
SyntaxKind5[SyntaxKind5["NonNullExpression"] = 232] = "NonNullExpression";
|
|
SyntaxKind5[SyntaxKind5["MetaProperty"] = 233] = "MetaProperty";
|
|
SyntaxKind5[SyntaxKind5["SyntheticExpression"] = 234] = "SyntheticExpression";
|
|
SyntaxKind5[SyntaxKind5["SatisfiesExpression"] = 235] = "SatisfiesExpression";
|
|
SyntaxKind5[SyntaxKind5["TemplateSpan"] = 236] = "TemplateSpan";
|
|
SyntaxKind5[SyntaxKind5["SemicolonClassElement"] = 237] = "SemicolonClassElement";
|
|
SyntaxKind5[SyntaxKind5["Block"] = 238] = "Block";
|
|
SyntaxKind5[SyntaxKind5["EmptyStatement"] = 239] = "EmptyStatement";
|
|
SyntaxKind5[SyntaxKind5["VariableStatement"] = 240] = "VariableStatement";
|
|
SyntaxKind5[SyntaxKind5["ExpressionStatement"] = 241] = "ExpressionStatement";
|
|
SyntaxKind5[SyntaxKind5["IfStatement"] = 242] = "IfStatement";
|
|
SyntaxKind5[SyntaxKind5["DoStatement"] = 243] = "DoStatement";
|
|
SyntaxKind5[SyntaxKind5["WhileStatement"] = 244] = "WhileStatement";
|
|
SyntaxKind5[SyntaxKind5["ForStatement"] = 245] = "ForStatement";
|
|
SyntaxKind5[SyntaxKind5["ForInStatement"] = 246] = "ForInStatement";
|
|
SyntaxKind5[SyntaxKind5["ForOfStatement"] = 247] = "ForOfStatement";
|
|
SyntaxKind5[SyntaxKind5["ContinueStatement"] = 248] = "ContinueStatement";
|
|
SyntaxKind5[SyntaxKind5["BreakStatement"] = 249] = "BreakStatement";
|
|
SyntaxKind5[SyntaxKind5["ReturnStatement"] = 250] = "ReturnStatement";
|
|
SyntaxKind5[SyntaxKind5["WithStatement"] = 251] = "WithStatement";
|
|
SyntaxKind5[SyntaxKind5["SwitchStatement"] = 252] = "SwitchStatement";
|
|
SyntaxKind5[SyntaxKind5["LabeledStatement"] = 253] = "LabeledStatement";
|
|
SyntaxKind5[SyntaxKind5["ThrowStatement"] = 254] = "ThrowStatement";
|
|
SyntaxKind5[SyntaxKind5["TryStatement"] = 255] = "TryStatement";
|
|
SyntaxKind5[SyntaxKind5["DebuggerStatement"] = 256] = "DebuggerStatement";
|
|
SyntaxKind5[SyntaxKind5["VariableDeclaration"] = 257] = "VariableDeclaration";
|
|
SyntaxKind5[SyntaxKind5["VariableDeclarationList"] = 258] = "VariableDeclarationList";
|
|
SyntaxKind5[SyntaxKind5["FunctionDeclaration"] = 259] = "FunctionDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ClassDeclaration"] = 260] = "ClassDeclaration";
|
|
SyntaxKind5[SyntaxKind5["InterfaceDeclaration"] = 261] = "InterfaceDeclaration";
|
|
SyntaxKind5[SyntaxKind5["TypeAliasDeclaration"] = 262] = "TypeAliasDeclaration";
|
|
SyntaxKind5[SyntaxKind5["EnumDeclaration"] = 263] = "EnumDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ModuleDeclaration"] = 264] = "ModuleDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ModuleBlock"] = 265] = "ModuleBlock";
|
|
SyntaxKind5[SyntaxKind5["CaseBlock"] = 266] = "CaseBlock";
|
|
SyntaxKind5[SyntaxKind5["NamespaceExportDeclaration"] = 267] = "NamespaceExportDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ImportEqualsDeclaration"] = 268] = "ImportEqualsDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ImportDeclaration"] = 269] = "ImportDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ImportClause"] = 270] = "ImportClause";
|
|
SyntaxKind5[SyntaxKind5["NamespaceImport"] = 271] = "NamespaceImport";
|
|
SyntaxKind5[SyntaxKind5["NamedImports"] = 272] = "NamedImports";
|
|
SyntaxKind5[SyntaxKind5["ImportSpecifier"] = 273] = "ImportSpecifier";
|
|
SyntaxKind5[SyntaxKind5["ExportAssignment"] = 274] = "ExportAssignment";
|
|
SyntaxKind5[SyntaxKind5["ExportDeclaration"] = 275] = "ExportDeclaration";
|
|
SyntaxKind5[SyntaxKind5["NamedExports"] = 276] = "NamedExports";
|
|
SyntaxKind5[SyntaxKind5["NamespaceExport"] = 277] = "NamespaceExport";
|
|
SyntaxKind5[SyntaxKind5["ExportSpecifier"] = 278] = "ExportSpecifier";
|
|
SyntaxKind5[SyntaxKind5["MissingDeclaration"] = 279] = "MissingDeclaration";
|
|
SyntaxKind5[SyntaxKind5["ExternalModuleReference"] = 280] = "ExternalModuleReference";
|
|
SyntaxKind5[SyntaxKind5["JsxElement"] = 281] = "JsxElement";
|
|
SyntaxKind5[SyntaxKind5["JsxSelfClosingElement"] = 282] = "JsxSelfClosingElement";
|
|
SyntaxKind5[SyntaxKind5["JsxOpeningElement"] = 283] = "JsxOpeningElement";
|
|
SyntaxKind5[SyntaxKind5["JsxClosingElement"] = 284] = "JsxClosingElement";
|
|
SyntaxKind5[SyntaxKind5["JsxFragment"] = 285] = "JsxFragment";
|
|
SyntaxKind5[SyntaxKind5["JsxOpeningFragment"] = 286] = "JsxOpeningFragment";
|
|
SyntaxKind5[SyntaxKind5["JsxClosingFragment"] = 287] = "JsxClosingFragment";
|
|
SyntaxKind5[SyntaxKind5["JsxAttribute"] = 288] = "JsxAttribute";
|
|
SyntaxKind5[SyntaxKind5["JsxAttributes"] = 289] = "JsxAttributes";
|
|
SyntaxKind5[SyntaxKind5["JsxSpreadAttribute"] = 290] = "JsxSpreadAttribute";
|
|
SyntaxKind5[SyntaxKind5["JsxExpression"] = 291] = "JsxExpression";
|
|
SyntaxKind5[SyntaxKind5["CaseClause"] = 292] = "CaseClause";
|
|
SyntaxKind5[SyntaxKind5["DefaultClause"] = 293] = "DefaultClause";
|
|
SyntaxKind5[SyntaxKind5["HeritageClause"] = 294] = "HeritageClause";
|
|
SyntaxKind5[SyntaxKind5["CatchClause"] = 295] = "CatchClause";
|
|
SyntaxKind5[SyntaxKind5["AssertClause"] = 296] = "AssertClause";
|
|
SyntaxKind5[SyntaxKind5["AssertEntry"] = 297] = "AssertEntry";
|
|
SyntaxKind5[SyntaxKind5["ImportTypeAssertionContainer"] = 298] = "ImportTypeAssertionContainer";
|
|
SyntaxKind5[SyntaxKind5["PropertyAssignment"] = 299] = "PropertyAssignment";
|
|
SyntaxKind5[SyntaxKind5["ShorthandPropertyAssignment"] = 300] = "ShorthandPropertyAssignment";
|
|
SyntaxKind5[SyntaxKind5["SpreadAssignment"] = 301] = "SpreadAssignment";
|
|
SyntaxKind5[SyntaxKind5["EnumMember"] = 302] = "EnumMember";
|
|
SyntaxKind5[SyntaxKind5["UnparsedPrologue"] = 303] = "UnparsedPrologue";
|
|
SyntaxKind5[SyntaxKind5["UnparsedPrepend"] = 304] = "UnparsedPrepend";
|
|
SyntaxKind5[SyntaxKind5["UnparsedText"] = 305] = "UnparsedText";
|
|
SyntaxKind5[SyntaxKind5["UnparsedInternalText"] = 306] = "UnparsedInternalText";
|
|
SyntaxKind5[SyntaxKind5["UnparsedSyntheticReference"] = 307] = "UnparsedSyntheticReference";
|
|
SyntaxKind5[SyntaxKind5["SourceFile"] = 308] = "SourceFile";
|
|
SyntaxKind5[SyntaxKind5["Bundle"] = 309] = "Bundle";
|
|
SyntaxKind5[SyntaxKind5["UnparsedSource"] = 310] = "UnparsedSource";
|
|
SyntaxKind5[SyntaxKind5["InputFiles"] = 311] = "InputFiles";
|
|
SyntaxKind5[SyntaxKind5["JSDocTypeExpression"] = 312] = "JSDocTypeExpression";
|
|
SyntaxKind5[SyntaxKind5["JSDocNameReference"] = 313] = "JSDocNameReference";
|
|
SyntaxKind5[SyntaxKind5["JSDocMemberName"] = 314] = "JSDocMemberName";
|
|
SyntaxKind5[SyntaxKind5["JSDocAllType"] = 315] = "JSDocAllType";
|
|
SyntaxKind5[SyntaxKind5["JSDocUnknownType"] = 316] = "JSDocUnknownType";
|
|
SyntaxKind5[SyntaxKind5["JSDocNullableType"] = 317] = "JSDocNullableType";
|
|
SyntaxKind5[SyntaxKind5["JSDocNonNullableType"] = 318] = "JSDocNonNullableType";
|
|
SyntaxKind5[SyntaxKind5["JSDocOptionalType"] = 319] = "JSDocOptionalType";
|
|
SyntaxKind5[SyntaxKind5["JSDocFunctionType"] = 320] = "JSDocFunctionType";
|
|
SyntaxKind5[SyntaxKind5["JSDocVariadicType"] = 321] = "JSDocVariadicType";
|
|
SyntaxKind5[SyntaxKind5["JSDocNamepathType"] = 322] = "JSDocNamepathType";
|
|
SyntaxKind5[SyntaxKind5["JSDoc"] = 323] = "JSDoc";
|
|
SyntaxKind5[SyntaxKind5["JSDocComment"] = 323 /* JSDoc */] = "JSDocComment";
|
|
SyntaxKind5[SyntaxKind5["JSDocText"] = 324] = "JSDocText";
|
|
SyntaxKind5[SyntaxKind5["JSDocTypeLiteral"] = 325] = "JSDocTypeLiteral";
|
|
SyntaxKind5[SyntaxKind5["JSDocSignature"] = 326] = "JSDocSignature";
|
|
SyntaxKind5[SyntaxKind5["JSDocLink"] = 327] = "JSDocLink";
|
|
SyntaxKind5[SyntaxKind5["JSDocLinkCode"] = 328] = "JSDocLinkCode";
|
|
SyntaxKind5[SyntaxKind5["JSDocLinkPlain"] = 329] = "JSDocLinkPlain";
|
|
SyntaxKind5[SyntaxKind5["JSDocTag"] = 330] = "JSDocTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocAugmentsTag"] = 331] = "JSDocAugmentsTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocImplementsTag"] = 332] = "JSDocImplementsTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocAuthorTag"] = 333] = "JSDocAuthorTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocDeprecatedTag"] = 334] = "JSDocDeprecatedTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocClassTag"] = 335] = "JSDocClassTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocPublicTag"] = 336] = "JSDocPublicTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocPrivateTag"] = 337] = "JSDocPrivateTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocProtectedTag"] = 338] = "JSDocProtectedTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocReadonlyTag"] = 339] = "JSDocReadonlyTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocOverrideTag"] = 340] = "JSDocOverrideTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocCallbackTag"] = 341] = "JSDocCallbackTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocEnumTag"] = 342] = "JSDocEnumTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocParameterTag"] = 343] = "JSDocParameterTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocReturnTag"] = 344] = "JSDocReturnTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocThisTag"] = 345] = "JSDocThisTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocTypeTag"] = 346] = "JSDocTypeTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocTemplateTag"] = 347] = "JSDocTemplateTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocTypedefTag"] = 348] = "JSDocTypedefTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocSeeTag"] = 349] = "JSDocSeeTag";
|
|
SyntaxKind5[SyntaxKind5["JSDocPropertyTag"] = 350] = "JSDocPropertyTag";
|
|
SyntaxKind5[SyntaxKind5["SyntaxList"] = 351] = "SyntaxList";
|
|
SyntaxKind5[SyntaxKind5["NotEmittedStatement"] = 352] = "NotEmittedStatement";
|
|
SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 353] = "PartiallyEmittedExpression";
|
|
SyntaxKind5[SyntaxKind5["CommaListExpression"] = 354] = "CommaListExpression";
|
|
SyntaxKind5[SyntaxKind5["MergeDeclarationMarker"] = 355] = "MergeDeclarationMarker";
|
|
SyntaxKind5[SyntaxKind5["EndOfDeclarationMarker"] = 356] = "EndOfDeclarationMarker";
|
|
SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression";
|
|
SyntaxKind5[SyntaxKind5["Count"] = 358] = "Count";
|
|
SyntaxKind5[SyntaxKind5["FirstAssignment"] = 63 /* EqualsToken */] = "FirstAssignment";
|
|
SyntaxKind5[SyntaxKind5["LastAssignment"] = 78 /* CaretEqualsToken */] = "LastAssignment";
|
|
SyntaxKind5[SyntaxKind5["FirstCompoundAssignment"] = 64 /* PlusEqualsToken */] = "FirstCompoundAssignment";
|
|
SyntaxKind5[SyntaxKind5["LastCompoundAssignment"] = 78 /* CaretEqualsToken */] = "LastCompoundAssignment";
|
|
SyntaxKind5[SyntaxKind5["FirstReservedWord"] = 81 /* BreakKeyword */] = "FirstReservedWord";
|
|
SyntaxKind5[SyntaxKind5["LastReservedWord"] = 116 /* WithKeyword */] = "LastReservedWord";
|
|
SyntaxKind5[SyntaxKind5["FirstKeyword"] = 81 /* BreakKeyword */] = "FirstKeyword";
|
|
SyntaxKind5[SyntaxKind5["LastKeyword"] = 162 /* OfKeyword */] = "LastKeyword";
|
|
SyntaxKind5[SyntaxKind5["FirstFutureReservedWord"] = 117 /* ImplementsKeyword */] = "FirstFutureReservedWord";
|
|
SyntaxKind5[SyntaxKind5["LastFutureReservedWord"] = 125 /* YieldKeyword */] = "LastFutureReservedWord";
|
|
SyntaxKind5[SyntaxKind5["FirstTypeNode"] = 179 /* TypePredicate */] = "FirstTypeNode";
|
|
SyntaxKind5[SyntaxKind5["LastTypeNode"] = 202 /* ImportType */] = "LastTypeNode";
|
|
SyntaxKind5[SyntaxKind5["FirstPunctuation"] = 18 /* OpenBraceToken */] = "FirstPunctuation";
|
|
SyntaxKind5[SyntaxKind5["LastPunctuation"] = 78 /* CaretEqualsToken */] = "LastPunctuation";
|
|
SyntaxKind5[SyntaxKind5["FirstToken"] = 0 /* Unknown */] = "FirstToken";
|
|
SyntaxKind5[SyntaxKind5["LastToken"] = 162 /* LastKeyword */] = "LastToken";
|
|
SyntaxKind5[SyntaxKind5["FirstTriviaToken"] = 2 /* SingleLineCommentTrivia */] = "FirstTriviaToken";
|
|
SyntaxKind5[SyntaxKind5["LastTriviaToken"] = 7 /* ConflictMarkerTrivia */] = "LastTriviaToken";
|
|
SyntaxKind5[SyntaxKind5["FirstLiteralToken"] = 8 /* NumericLiteral */] = "FirstLiteralToken";
|
|
SyntaxKind5[SyntaxKind5["LastLiteralToken"] = 14 /* NoSubstitutionTemplateLiteral */] = "LastLiteralToken";
|
|
SyntaxKind5[SyntaxKind5["FirstTemplateToken"] = 14 /* NoSubstitutionTemplateLiteral */] = "FirstTemplateToken";
|
|
SyntaxKind5[SyntaxKind5["LastTemplateToken"] = 17 /* TemplateTail */] = "LastTemplateToken";
|
|
SyntaxKind5[SyntaxKind5["FirstBinaryOperator"] = 29 /* LessThanToken */] = "FirstBinaryOperator";
|
|
SyntaxKind5[SyntaxKind5["LastBinaryOperator"] = 78 /* CaretEqualsToken */] = "LastBinaryOperator";
|
|
SyntaxKind5[SyntaxKind5["FirstStatement"] = 240 /* VariableStatement */] = "FirstStatement";
|
|
SyntaxKind5[SyntaxKind5["LastStatement"] = 256 /* DebuggerStatement */] = "LastStatement";
|
|
SyntaxKind5[SyntaxKind5["FirstNode"] = 163 /* QualifiedName */] = "FirstNode";
|
|
SyntaxKind5[SyntaxKind5["FirstJSDocNode"] = 312 /* JSDocTypeExpression */] = "FirstJSDocNode";
|
|
SyntaxKind5[SyntaxKind5["LastJSDocNode"] = 350 /* JSDocPropertyTag */] = "LastJSDocNode";
|
|
SyntaxKind5[SyntaxKind5["FirstJSDocTagNode"] = 330 /* JSDocTag */] = "FirstJSDocTagNode";
|
|
SyntaxKind5[SyntaxKind5["LastJSDocTagNode"] = 350 /* JSDocPropertyTag */] = "LastJSDocTagNode";
|
|
SyntaxKind5[SyntaxKind5["FirstContextualKeyword"] = 126 /* AbstractKeyword */] = "FirstContextualKeyword";
|
|
SyntaxKind5[SyntaxKind5["LastContextualKeyword"] = 162 /* OfKeyword */] = "LastContextualKeyword";
|
|
return SyntaxKind5;
|
|
})(SyntaxKind || {});
|
|
var NodeFlags = /* @__PURE__ */ ((NodeFlags4) => {
|
|
NodeFlags4[NodeFlags4["None"] = 0] = "None";
|
|
NodeFlags4[NodeFlags4["Let"] = 1] = "Let";
|
|
NodeFlags4[NodeFlags4["Const"] = 2] = "Const";
|
|
NodeFlags4[NodeFlags4["NestedNamespace"] = 4] = "NestedNamespace";
|
|
NodeFlags4[NodeFlags4["Synthesized"] = 8] = "Synthesized";
|
|
NodeFlags4[NodeFlags4["Namespace"] = 16] = "Namespace";
|
|
NodeFlags4[NodeFlags4["OptionalChain"] = 32] = "OptionalChain";
|
|
NodeFlags4[NodeFlags4["ExportContext"] = 64] = "ExportContext";
|
|
NodeFlags4[NodeFlags4["ContainsThis"] = 128] = "ContainsThis";
|
|
NodeFlags4[NodeFlags4["HasImplicitReturn"] = 256] = "HasImplicitReturn";
|
|
NodeFlags4[NodeFlags4["HasExplicitReturn"] = 512] = "HasExplicitReturn";
|
|
NodeFlags4[NodeFlags4["GlobalAugmentation"] = 1024] = "GlobalAugmentation";
|
|
NodeFlags4[NodeFlags4["HasAsyncFunctions"] = 2048] = "HasAsyncFunctions";
|
|
NodeFlags4[NodeFlags4["DisallowInContext"] = 4096] = "DisallowInContext";
|
|
NodeFlags4[NodeFlags4["YieldContext"] = 8192] = "YieldContext";
|
|
NodeFlags4[NodeFlags4["DecoratorContext"] = 16384] = "DecoratorContext";
|
|
NodeFlags4[NodeFlags4["AwaitContext"] = 32768] = "AwaitContext";
|
|
NodeFlags4[NodeFlags4["DisallowConditionalTypesContext"] = 65536] = "DisallowConditionalTypesContext";
|
|
NodeFlags4[NodeFlags4["ThisNodeHasError"] = 131072] = "ThisNodeHasError";
|
|
NodeFlags4[NodeFlags4["JavaScriptFile"] = 262144] = "JavaScriptFile";
|
|
NodeFlags4[NodeFlags4["ThisNodeOrAnySubNodesHasError"] = 524288] = "ThisNodeOrAnySubNodesHasError";
|
|
NodeFlags4[NodeFlags4["HasAggregatedChildData"] = 1048576] = "HasAggregatedChildData";
|
|
NodeFlags4[NodeFlags4["PossiblyContainsDynamicImport"] = 2097152] = "PossiblyContainsDynamicImport";
|
|
NodeFlags4[NodeFlags4["PossiblyContainsImportMeta"] = 4194304] = "PossiblyContainsImportMeta";
|
|
NodeFlags4[NodeFlags4["JSDoc"] = 8388608] = "JSDoc";
|
|
NodeFlags4[NodeFlags4["Ambient"] = 16777216] = "Ambient";
|
|
NodeFlags4[NodeFlags4["InWithStatement"] = 33554432] = "InWithStatement";
|
|
NodeFlags4[NodeFlags4["JsonFile"] = 67108864] = "JsonFile";
|
|
NodeFlags4[NodeFlags4["TypeCached"] = 134217728] = "TypeCached";
|
|
NodeFlags4[NodeFlags4["Deprecated"] = 268435456] = "Deprecated";
|
|
NodeFlags4[NodeFlags4["BlockScoped"] = 3] = "BlockScoped";
|
|
NodeFlags4[NodeFlags4["ReachabilityCheckFlags"] = 768] = "ReachabilityCheckFlags";
|
|
NodeFlags4[NodeFlags4["ReachabilityAndEmitFlags"] = 2816] = "ReachabilityAndEmitFlags";
|
|
NodeFlags4[NodeFlags4["ContextFlags"] = 50720768] = "ContextFlags";
|
|
NodeFlags4[NodeFlags4["TypeExcludesFlags"] = 40960] = "TypeExcludesFlags";
|
|
NodeFlags4[NodeFlags4["PermanentlySetIncrementalFlags"] = 6291456] = "PermanentlySetIncrementalFlags";
|
|
return NodeFlags4;
|
|
})(NodeFlags || {});
|
|
var ModifierFlags = /* @__PURE__ */ ((ModifierFlags3) => {
|
|
ModifierFlags3[ModifierFlags3["None"] = 0] = "None";
|
|
ModifierFlags3[ModifierFlags3["Export"] = 1] = "Export";
|
|
ModifierFlags3[ModifierFlags3["Ambient"] = 2] = "Ambient";
|
|
ModifierFlags3[ModifierFlags3["Public"] = 4] = "Public";
|
|
ModifierFlags3[ModifierFlags3["Private"] = 8] = "Private";
|
|
ModifierFlags3[ModifierFlags3["Protected"] = 16] = "Protected";
|
|
ModifierFlags3[ModifierFlags3["Static"] = 32] = "Static";
|
|
ModifierFlags3[ModifierFlags3["Readonly"] = 64] = "Readonly";
|
|
ModifierFlags3[ModifierFlags3["Accessor"] = 128] = "Accessor";
|
|
ModifierFlags3[ModifierFlags3["Abstract"] = 256] = "Abstract";
|
|
ModifierFlags3[ModifierFlags3["Async"] = 512] = "Async";
|
|
ModifierFlags3[ModifierFlags3["Default"] = 1024] = "Default";
|
|
ModifierFlags3[ModifierFlags3["Const"] = 2048] = "Const";
|
|
ModifierFlags3[ModifierFlags3["HasComputedJSDocModifiers"] = 4096] = "HasComputedJSDocModifiers";
|
|
ModifierFlags3[ModifierFlags3["Deprecated"] = 8192] = "Deprecated";
|
|
ModifierFlags3[ModifierFlags3["Override"] = 16384] = "Override";
|
|
ModifierFlags3[ModifierFlags3["In"] = 32768] = "In";
|
|
ModifierFlags3[ModifierFlags3["Out"] = 65536] = "Out";
|
|
ModifierFlags3[ModifierFlags3["Decorator"] = 131072] = "Decorator";
|
|
ModifierFlags3[ModifierFlags3["HasComputedFlags"] = 536870912] = "HasComputedFlags";
|
|
ModifierFlags3[ModifierFlags3["AccessibilityModifier"] = 28] = "AccessibilityModifier";
|
|
ModifierFlags3[ModifierFlags3["ParameterPropertyModifier"] = 16476] = "ParameterPropertyModifier";
|
|
ModifierFlags3[ModifierFlags3["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier";
|
|
ModifierFlags3[ModifierFlags3["TypeScriptModifier"] = 117086] = "TypeScriptModifier";
|
|
ModifierFlags3[ModifierFlags3["ExportDefault"] = 1025] = "ExportDefault";
|
|
ModifierFlags3[ModifierFlags3["All"] = 258047] = "All";
|
|
ModifierFlags3[ModifierFlags3["Modifier"] = 126975] = "Modifier";
|
|
return ModifierFlags3;
|
|
})(ModifierFlags || {});
|
|
var JsxFlags = /* @__PURE__ */ ((JsxFlags2) => {
|
|
JsxFlags2[JsxFlags2["None"] = 0] = "None";
|
|
JsxFlags2[JsxFlags2["IntrinsicNamedElement"] = 1] = "IntrinsicNamedElement";
|
|
JsxFlags2[JsxFlags2["IntrinsicIndexedElement"] = 2] = "IntrinsicIndexedElement";
|
|
JsxFlags2[JsxFlags2["IntrinsicElement"] = 3] = "IntrinsicElement";
|
|
return JsxFlags2;
|
|
})(JsxFlags || {});
|
|
var RelationComparisonResult = /* @__PURE__ */ ((RelationComparisonResult3) => {
|
|
RelationComparisonResult3[RelationComparisonResult3["Succeeded"] = 1] = "Succeeded";
|
|
RelationComparisonResult3[RelationComparisonResult3["Failed"] = 2] = "Failed";
|
|
RelationComparisonResult3[RelationComparisonResult3["Reported"] = 4] = "Reported";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsUnmeasurable"] = 8] = "ReportsUnmeasurable";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsUnreliable"] = 16] = "ReportsUnreliable";
|
|
RelationComparisonResult3[RelationComparisonResult3["ReportsMask"] = 24] = "ReportsMask";
|
|
return RelationComparisonResult3;
|
|
})(RelationComparisonResult || {});
|
|
var GeneratedIdentifierFlags = /* @__PURE__ */ ((GeneratedIdentifierFlags3) => {
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["None"] = 0] = "None";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["Auto"] = 1] = "Auto";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["Loop"] = 2] = "Loop";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["Unique"] = 3] = "Unique";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["Node"] = 4] = "Node";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["KindMask"] = 7] = "KindMask";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["ReservedInNestedScopes"] = 8] = "ReservedInNestedScopes";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["Optimistic"] = 16] = "Optimistic";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["FileLevel"] = 32] = "FileLevel";
|
|
GeneratedIdentifierFlags3[GeneratedIdentifierFlags3["AllowNameSubstitution"] = 64] = "AllowNameSubstitution";
|
|
return GeneratedIdentifierFlags3;
|
|
})(GeneratedIdentifierFlags || {});
|
|
var TokenFlags = /* @__PURE__ */ ((TokenFlags2) => {
|
|
TokenFlags2[TokenFlags2["None"] = 0] = "None";
|
|
TokenFlags2[TokenFlags2["PrecedingLineBreak"] = 1] = "PrecedingLineBreak";
|
|
TokenFlags2[TokenFlags2["PrecedingJSDocComment"] = 2] = "PrecedingJSDocComment";
|
|
TokenFlags2[TokenFlags2["Unterminated"] = 4] = "Unterminated";
|
|
TokenFlags2[TokenFlags2["ExtendedUnicodeEscape"] = 8] = "ExtendedUnicodeEscape";
|
|
TokenFlags2[TokenFlags2["Scientific"] = 16] = "Scientific";
|
|
TokenFlags2[TokenFlags2["Octal"] = 32] = "Octal";
|
|
TokenFlags2[TokenFlags2["HexSpecifier"] = 64] = "HexSpecifier";
|
|
TokenFlags2[TokenFlags2["BinarySpecifier"] = 128] = "BinarySpecifier";
|
|
TokenFlags2[TokenFlags2["OctalSpecifier"] = 256] = "OctalSpecifier";
|
|
TokenFlags2[TokenFlags2["ContainsSeparator"] = 512] = "ContainsSeparator";
|
|
TokenFlags2[TokenFlags2["UnicodeEscape"] = 1024] = "UnicodeEscape";
|
|
TokenFlags2[TokenFlags2["ContainsInvalidEscape"] = 2048] = "ContainsInvalidEscape";
|
|
TokenFlags2[TokenFlags2["BinaryOrOctalSpecifier"] = 384] = "BinaryOrOctalSpecifier";
|
|
TokenFlags2[TokenFlags2["NumericLiteralFlags"] = 1008] = "NumericLiteralFlags";
|
|
TokenFlags2[TokenFlags2["TemplateLiteralLikeFlags"] = 2048 /* ContainsInvalidEscape */] = "TemplateLiteralLikeFlags";
|
|
return TokenFlags2;
|
|
})(TokenFlags || {});
|
|
var FlowFlags = /* @__PURE__ */ ((FlowFlags2) => {
|
|
FlowFlags2[FlowFlags2["Unreachable"] = 1] = "Unreachable";
|
|
FlowFlags2[FlowFlags2["Start"] = 2] = "Start";
|
|
FlowFlags2[FlowFlags2["BranchLabel"] = 4] = "BranchLabel";
|
|
FlowFlags2[FlowFlags2["LoopLabel"] = 8] = "LoopLabel";
|
|
FlowFlags2[FlowFlags2["Assignment"] = 16] = "Assignment";
|
|
FlowFlags2[FlowFlags2["TrueCondition"] = 32] = "TrueCondition";
|
|
FlowFlags2[FlowFlags2["FalseCondition"] = 64] = "FalseCondition";
|
|
FlowFlags2[FlowFlags2["SwitchClause"] = 128] = "SwitchClause";
|
|
FlowFlags2[FlowFlags2["ArrayMutation"] = 256] = "ArrayMutation";
|
|
FlowFlags2[FlowFlags2["Call"] = 512] = "Call";
|
|
FlowFlags2[FlowFlags2["ReduceLabel"] = 1024] = "ReduceLabel";
|
|
FlowFlags2[FlowFlags2["Referenced"] = 2048] = "Referenced";
|
|
FlowFlags2[FlowFlags2["Shared"] = 4096] = "Shared";
|
|
FlowFlags2[FlowFlags2["Label"] = 12] = "Label";
|
|
FlowFlags2[FlowFlags2["Condition"] = 96] = "Condition";
|
|
return FlowFlags2;
|
|
})(FlowFlags || {});
|
|
var CommentDirectiveType = /* @__PURE__ */ ((CommentDirectiveType2) => {
|
|
CommentDirectiveType2[CommentDirectiveType2["ExpectError"] = 0] = "ExpectError";
|
|
CommentDirectiveType2[CommentDirectiveType2["Ignore"] = 1] = "Ignore";
|
|
return CommentDirectiveType2;
|
|
})(CommentDirectiveType || {});
|
|
var OperationCanceledException = class {
|
|
};
|
|
var FileIncludeKind = /* @__PURE__ */ ((FileIncludeKind2) => {
|
|
FileIncludeKind2[FileIncludeKind2["RootFile"] = 0] = "RootFile";
|
|
FileIncludeKind2[FileIncludeKind2["SourceFromProjectReference"] = 1] = "SourceFromProjectReference";
|
|
FileIncludeKind2[FileIncludeKind2["OutputFromProjectReference"] = 2] = "OutputFromProjectReference";
|
|
FileIncludeKind2[FileIncludeKind2["Import"] = 3] = "Import";
|
|
FileIncludeKind2[FileIncludeKind2["ReferenceFile"] = 4] = "ReferenceFile";
|
|
FileIncludeKind2[FileIncludeKind2["TypeReferenceDirective"] = 5] = "TypeReferenceDirective";
|
|
FileIncludeKind2[FileIncludeKind2["LibFile"] = 6] = "LibFile";
|
|
FileIncludeKind2[FileIncludeKind2["LibReferenceDirective"] = 7] = "LibReferenceDirective";
|
|
FileIncludeKind2[FileIncludeKind2["AutomaticTypeDirectiveFile"] = 8] = "AutomaticTypeDirectiveFile";
|
|
return FileIncludeKind2;
|
|
})(FileIncludeKind || {});
|
|
var FilePreprocessingDiagnosticsKind = /* @__PURE__ */ ((FilePreprocessingDiagnosticsKind2) => {
|
|
FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic";
|
|
FilePreprocessingDiagnosticsKind2[FilePreprocessingDiagnosticsKind2["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic";
|
|
return FilePreprocessingDiagnosticsKind2;
|
|
})(FilePreprocessingDiagnosticsKind || {});
|
|
var EmitOnly = /* @__PURE__ */ ((EmitOnly4) => {
|
|
EmitOnly4[EmitOnly4["Js"] = 0] = "Js";
|
|
EmitOnly4[EmitOnly4["Dts"] = 1] = "Dts";
|
|
return EmitOnly4;
|
|
})(EmitOnly || {});
|
|
var StructureIsReused = /* @__PURE__ */ ((StructureIsReused2) => {
|
|
StructureIsReused2[StructureIsReused2["Not"] = 0] = "Not";
|
|
StructureIsReused2[StructureIsReused2["SafeModules"] = 1] = "SafeModules";
|
|
StructureIsReused2[StructureIsReused2["Completely"] = 2] = "Completely";
|
|
return StructureIsReused2;
|
|
})(StructureIsReused || {});
|
|
var ExitStatus = /* @__PURE__ */ ((ExitStatus2) => {
|
|
ExitStatus2[ExitStatus2["Success"] = 0] = "Success";
|
|
ExitStatus2[ExitStatus2["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped";
|
|
ExitStatus2[ExitStatus2["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated";
|
|
ExitStatus2[ExitStatus2["InvalidProject_OutputsSkipped"] = 3] = "InvalidProject_OutputsSkipped";
|
|
ExitStatus2[ExitStatus2["ProjectReferenceCycle_OutputsSkipped"] = 4] = "ProjectReferenceCycle_OutputsSkipped";
|
|
ExitStatus2[ExitStatus2["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped";
|
|
return ExitStatus2;
|
|
})(ExitStatus || {});
|
|
var MemberOverrideStatus = /* @__PURE__ */ ((MemberOverrideStatus2) => {
|
|
MemberOverrideStatus2[MemberOverrideStatus2["Ok"] = 0] = "Ok";
|
|
MemberOverrideStatus2[MemberOverrideStatus2["NeedsOverride"] = 1] = "NeedsOverride";
|
|
MemberOverrideStatus2[MemberOverrideStatus2["HasInvalidOverride"] = 2] = "HasInvalidOverride";
|
|
return MemberOverrideStatus2;
|
|
})(MemberOverrideStatus || {});
|
|
var UnionReduction = /* @__PURE__ */ ((UnionReduction2) => {
|
|
UnionReduction2[UnionReduction2["None"] = 0] = "None";
|
|
UnionReduction2[UnionReduction2["Literal"] = 1] = "Literal";
|
|
UnionReduction2[UnionReduction2["Subtype"] = 2] = "Subtype";
|
|
return UnionReduction2;
|
|
})(UnionReduction || {});
|
|
var ContextFlags = /* @__PURE__ */ ((ContextFlags2) => {
|
|
ContextFlags2[ContextFlags2["None"] = 0] = "None";
|
|
ContextFlags2[ContextFlags2["Signature"] = 1] = "Signature";
|
|
ContextFlags2[ContextFlags2["NoConstraints"] = 2] = "NoConstraints";
|
|
ContextFlags2[ContextFlags2["Completions"] = 4] = "Completions";
|
|
ContextFlags2[ContextFlags2["SkipBindingPatterns"] = 8] = "SkipBindingPatterns";
|
|
return ContextFlags2;
|
|
})(ContextFlags || {});
|
|
var NodeBuilderFlags = /* @__PURE__ */ ((NodeBuilderFlags2) => {
|
|
NodeBuilderFlags2[NodeBuilderFlags2["None"] = 0] = "None";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["NoTruncation"] = 1] = "NoTruncation";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["GenerateNamesForShadowedTypeParams"] = 4] = "GenerateNamesForShadowedTypeParams";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseStructuralFallback"] = 8] = "UseStructuralFallback";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["ForbidIndexedAccessSymbolReferences"] = 16] = "ForbidIndexedAccessSymbolReferences";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseOnlyExternalAliasing"] = 128] = "UseOnlyExternalAliasing";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["WriteTypeParametersInQualifiedName"] = 512] = "WriteTypeParametersInQualifiedName";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["NoTypeReduction"] = 536870912] = "NoTypeReduction";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["OmitThisParameter"] = 33554432] = "OmitThisParameter";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowQualifiedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifiedNameInPlaceOfIdentifier";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowQualifedNameInPlaceOfIdentifier"] = 65536 /* AllowQualifiedNameInPlaceOfIdentifier */] = "AllowQualifedNameInPlaceOfIdentifier";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowAnonymousIdentifier"] = 131072] = "AllowAnonymousIdentifier";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyUnionOrIntersection"] = 262144] = "AllowEmptyUnionOrIntersection";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["WriteComputedProps"] = 1073741824] = "WriteComputedProps";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["IgnoreErrors"] = 70221824] = "IgnoreErrors";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["InTypeAlias"] = 8388608] = "InTypeAlias";
|
|
NodeBuilderFlags2[NodeBuilderFlags2["InInitialEntityName"] = 16777216] = "InInitialEntityName";
|
|
return NodeBuilderFlags2;
|
|
})(NodeBuilderFlags || {});
|
|
var TypeFormatFlags = /* @__PURE__ */ ((TypeFormatFlags2) => {
|
|
TypeFormatFlags2[TypeFormatFlags2["None"] = 0] = "None";
|
|
TypeFormatFlags2[TypeFormatFlags2["NoTruncation"] = 1] = "NoTruncation";
|
|
TypeFormatFlags2[TypeFormatFlags2["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
|
|
TypeFormatFlags2[TypeFormatFlags2["UseStructuralFallback"] = 8] = "UseStructuralFallback";
|
|
TypeFormatFlags2[TypeFormatFlags2["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
|
|
TypeFormatFlags2[TypeFormatFlags2["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
|
|
TypeFormatFlags2[TypeFormatFlags2["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
|
|
TypeFormatFlags2[TypeFormatFlags2["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
|
|
TypeFormatFlags2[TypeFormatFlags2["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral";
|
|
TypeFormatFlags2[TypeFormatFlags2["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
|
|
TypeFormatFlags2[TypeFormatFlags2["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
|
|
TypeFormatFlags2[TypeFormatFlags2["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
|
|
TypeFormatFlags2[TypeFormatFlags2["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
|
|
TypeFormatFlags2[TypeFormatFlags2["NoTypeReduction"] = 536870912] = "NoTypeReduction";
|
|
TypeFormatFlags2[TypeFormatFlags2["OmitThisParameter"] = 33554432] = "OmitThisParameter";
|
|
TypeFormatFlags2[TypeFormatFlags2["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
|
|
TypeFormatFlags2[TypeFormatFlags2["AddUndefined"] = 131072] = "AddUndefined";
|
|
TypeFormatFlags2[TypeFormatFlags2["WriteArrowStyleSignature"] = 262144] = "WriteArrowStyleSignature";
|
|
TypeFormatFlags2[TypeFormatFlags2["InArrayType"] = 524288] = "InArrayType";
|
|
TypeFormatFlags2[TypeFormatFlags2["InElementType"] = 2097152] = "InElementType";
|
|
TypeFormatFlags2[TypeFormatFlags2["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument";
|
|
TypeFormatFlags2[TypeFormatFlags2["InTypeAlias"] = 8388608] = "InTypeAlias";
|
|
TypeFormatFlags2[TypeFormatFlags2["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike";
|
|
TypeFormatFlags2[TypeFormatFlags2["NodeBuilderFlagsMask"] = 848330091] = "NodeBuilderFlagsMask";
|
|
return TypeFormatFlags2;
|
|
})(TypeFormatFlags || {});
|
|
var SymbolFormatFlags = /* @__PURE__ */ ((SymbolFormatFlags2) => {
|
|
SymbolFormatFlags2[SymbolFormatFlags2["None"] = 0] = "None";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["AllowAnyNodeKind"] = 4] = "AllowAnyNodeKind";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["UseAliasDefinedOutsideCurrentScope"] = 8] = "UseAliasDefinedOutsideCurrentScope";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["WriteComputedProps"] = 16] = "WriteComputedProps";
|
|
SymbolFormatFlags2[SymbolFormatFlags2["DoNotIncludeSymbolChain"] = 32] = "DoNotIncludeSymbolChain";
|
|
return SymbolFormatFlags2;
|
|
})(SymbolFormatFlags || {});
|
|
var SymbolAccessibility = /* @__PURE__ */ ((SymbolAccessibility2) => {
|
|
SymbolAccessibility2[SymbolAccessibility2["Accessible"] = 0] = "Accessible";
|
|
SymbolAccessibility2[SymbolAccessibility2["NotAccessible"] = 1] = "NotAccessible";
|
|
SymbolAccessibility2[SymbolAccessibility2["CannotBeNamed"] = 2] = "CannotBeNamed";
|
|
return SymbolAccessibility2;
|
|
})(SymbolAccessibility || {});
|
|
var SyntheticSymbolKind = /* @__PURE__ */ ((SyntheticSymbolKind2) => {
|
|
SyntheticSymbolKind2[SyntheticSymbolKind2["UnionOrIntersection"] = 0] = "UnionOrIntersection";
|
|
SyntheticSymbolKind2[SyntheticSymbolKind2["Spread"] = 1] = "Spread";
|
|
return SyntheticSymbolKind2;
|
|
})(SyntheticSymbolKind || {});
|
|
var TypePredicateKind = /* @__PURE__ */ ((TypePredicateKind2) => {
|
|
TypePredicateKind2[TypePredicateKind2["This"] = 0] = "This";
|
|
TypePredicateKind2[TypePredicateKind2["Identifier"] = 1] = "Identifier";
|
|
TypePredicateKind2[TypePredicateKind2["AssertsThis"] = 2] = "AssertsThis";
|
|
TypePredicateKind2[TypePredicateKind2["AssertsIdentifier"] = 3] = "AssertsIdentifier";
|
|
return TypePredicateKind2;
|
|
})(TypePredicateKind || {});
|
|
var TypeReferenceSerializationKind = /* @__PURE__ */ ((TypeReferenceSerializationKind2) => {
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["Unknown"] = 0] = "Unknown";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["VoidNullableOrNeverType"] = 2] = "VoidNullableOrNeverType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["NumberLikeType"] = 3] = "NumberLikeType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["BigIntLikeType"] = 4] = "BigIntLikeType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["StringLikeType"] = 5] = "StringLikeType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["BooleanType"] = 6] = "BooleanType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["ArrayLikeType"] = 7] = "ArrayLikeType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["ESSymbolType"] = 8] = "ESSymbolType";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["Promise"] = 9] = "Promise";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["TypeWithCallSignature"] = 10] = "TypeWithCallSignature";
|
|
TypeReferenceSerializationKind2[TypeReferenceSerializationKind2["ObjectType"] = 11] = "ObjectType";
|
|
return TypeReferenceSerializationKind2;
|
|
})(TypeReferenceSerializationKind || {});
|
|
var SymbolFlags = /* @__PURE__ */ ((SymbolFlags3) => {
|
|
SymbolFlags3[SymbolFlags3["None"] = 0] = "None";
|
|
SymbolFlags3[SymbolFlags3["FunctionScopedVariable"] = 1] = "FunctionScopedVariable";
|
|
SymbolFlags3[SymbolFlags3["BlockScopedVariable"] = 2] = "BlockScopedVariable";
|
|
SymbolFlags3[SymbolFlags3["Property"] = 4] = "Property";
|
|
SymbolFlags3[SymbolFlags3["EnumMember"] = 8] = "EnumMember";
|
|
SymbolFlags3[SymbolFlags3["Function"] = 16] = "Function";
|
|
SymbolFlags3[SymbolFlags3["Class"] = 32] = "Class";
|
|
SymbolFlags3[SymbolFlags3["Interface"] = 64] = "Interface";
|
|
SymbolFlags3[SymbolFlags3["ConstEnum"] = 128] = "ConstEnum";
|
|
SymbolFlags3[SymbolFlags3["RegularEnum"] = 256] = "RegularEnum";
|
|
SymbolFlags3[SymbolFlags3["ValueModule"] = 512] = "ValueModule";
|
|
SymbolFlags3[SymbolFlags3["NamespaceModule"] = 1024] = "NamespaceModule";
|
|
SymbolFlags3[SymbolFlags3["TypeLiteral"] = 2048] = "TypeLiteral";
|
|
SymbolFlags3[SymbolFlags3["ObjectLiteral"] = 4096] = "ObjectLiteral";
|
|
SymbolFlags3[SymbolFlags3["Method"] = 8192] = "Method";
|
|
SymbolFlags3[SymbolFlags3["Constructor"] = 16384] = "Constructor";
|
|
SymbolFlags3[SymbolFlags3["GetAccessor"] = 32768] = "GetAccessor";
|
|
SymbolFlags3[SymbolFlags3["SetAccessor"] = 65536] = "SetAccessor";
|
|
SymbolFlags3[SymbolFlags3["Signature"] = 131072] = "Signature";
|
|
SymbolFlags3[SymbolFlags3["TypeParameter"] = 262144] = "TypeParameter";
|
|
SymbolFlags3[SymbolFlags3["TypeAlias"] = 524288] = "TypeAlias";
|
|
SymbolFlags3[SymbolFlags3["ExportValue"] = 1048576] = "ExportValue";
|
|
SymbolFlags3[SymbolFlags3["Alias"] = 2097152] = "Alias";
|
|
SymbolFlags3[SymbolFlags3["Prototype"] = 4194304] = "Prototype";
|
|
SymbolFlags3[SymbolFlags3["ExportStar"] = 8388608] = "ExportStar";
|
|
SymbolFlags3[SymbolFlags3["Optional"] = 16777216] = "Optional";
|
|
SymbolFlags3[SymbolFlags3["Transient"] = 33554432] = "Transient";
|
|
SymbolFlags3[SymbolFlags3["Assignment"] = 67108864] = "Assignment";
|
|
SymbolFlags3[SymbolFlags3["ModuleExports"] = 134217728] = "ModuleExports";
|
|
SymbolFlags3[SymbolFlags3["All"] = 67108863] = "All";
|
|
SymbolFlags3[SymbolFlags3["Enum"] = 384] = "Enum";
|
|
SymbolFlags3[SymbolFlags3["Variable"] = 3] = "Variable";
|
|
SymbolFlags3[SymbolFlags3["Value"] = 111551] = "Value";
|
|
SymbolFlags3[SymbolFlags3["Type"] = 788968] = "Type";
|
|
SymbolFlags3[SymbolFlags3["Namespace"] = 1920] = "Namespace";
|
|
SymbolFlags3[SymbolFlags3["Module"] = 1536] = "Module";
|
|
SymbolFlags3[SymbolFlags3["Accessor"] = 98304] = "Accessor";
|
|
SymbolFlags3[SymbolFlags3["FunctionScopedVariableExcludes"] = 111550] = "FunctionScopedVariableExcludes";
|
|
SymbolFlags3[SymbolFlags3["BlockScopedVariableExcludes"] = 111551 /* Value */] = "BlockScopedVariableExcludes";
|
|
SymbolFlags3[SymbolFlags3["ParameterExcludes"] = 111551 /* Value */] = "ParameterExcludes";
|
|
SymbolFlags3[SymbolFlags3["PropertyExcludes"] = 0 /* None */] = "PropertyExcludes";
|
|
SymbolFlags3[SymbolFlags3["EnumMemberExcludes"] = 900095] = "EnumMemberExcludes";
|
|
SymbolFlags3[SymbolFlags3["FunctionExcludes"] = 110991] = "FunctionExcludes";
|
|
SymbolFlags3[SymbolFlags3["ClassExcludes"] = 899503] = "ClassExcludes";
|
|
SymbolFlags3[SymbolFlags3["InterfaceExcludes"] = 788872] = "InterfaceExcludes";
|
|
SymbolFlags3[SymbolFlags3["RegularEnumExcludes"] = 899327] = "RegularEnumExcludes";
|
|
SymbolFlags3[SymbolFlags3["ConstEnumExcludes"] = 899967] = "ConstEnumExcludes";
|
|
SymbolFlags3[SymbolFlags3["ValueModuleExcludes"] = 110735] = "ValueModuleExcludes";
|
|
SymbolFlags3[SymbolFlags3["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes";
|
|
SymbolFlags3[SymbolFlags3["MethodExcludes"] = 103359] = "MethodExcludes";
|
|
SymbolFlags3[SymbolFlags3["GetAccessorExcludes"] = 46015] = "GetAccessorExcludes";
|
|
SymbolFlags3[SymbolFlags3["SetAccessorExcludes"] = 78783] = "SetAccessorExcludes";
|
|
SymbolFlags3[SymbolFlags3["AccessorExcludes"] = 13247] = "AccessorExcludes";
|
|
SymbolFlags3[SymbolFlags3["TypeParameterExcludes"] = 526824] = "TypeParameterExcludes";
|
|
SymbolFlags3[SymbolFlags3["TypeAliasExcludes"] = 788968 /* Type */] = "TypeAliasExcludes";
|
|
SymbolFlags3[SymbolFlags3["AliasExcludes"] = 2097152 /* Alias */] = "AliasExcludes";
|
|
SymbolFlags3[SymbolFlags3["ModuleMember"] = 2623475] = "ModuleMember";
|
|
SymbolFlags3[SymbolFlags3["ExportHasLocal"] = 944] = "ExportHasLocal";
|
|
SymbolFlags3[SymbolFlags3["BlockScoped"] = 418] = "BlockScoped";
|
|
SymbolFlags3[SymbolFlags3["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor";
|
|
SymbolFlags3[SymbolFlags3["ClassMember"] = 106500] = "ClassMember";
|
|
SymbolFlags3[SymbolFlags3["ExportSupportsDefaultModifier"] = 112] = "ExportSupportsDefaultModifier";
|
|
SymbolFlags3[SymbolFlags3["ExportDoesNotSupportDefaultModifier"] = -113] = "ExportDoesNotSupportDefaultModifier";
|
|
SymbolFlags3[SymbolFlags3["Classifiable"] = 2885600] = "Classifiable";
|
|
SymbolFlags3[SymbolFlags3["LateBindingContainer"] = 6256] = "LateBindingContainer";
|
|
return SymbolFlags3;
|
|
})(SymbolFlags || {});
|
|
var EnumKind = /* @__PURE__ */ ((EnumKind2) => {
|
|
EnumKind2[EnumKind2["Numeric"] = 0] = "Numeric";
|
|
EnumKind2[EnumKind2["Literal"] = 1] = "Literal";
|
|
return EnumKind2;
|
|
})(EnumKind || {});
|
|
var CheckFlags = /* @__PURE__ */ ((CheckFlags2) => {
|
|
CheckFlags2[CheckFlags2["None"] = 0] = "None";
|
|
CheckFlags2[CheckFlags2["Instantiated"] = 1] = "Instantiated";
|
|
CheckFlags2[CheckFlags2["SyntheticProperty"] = 2] = "SyntheticProperty";
|
|
CheckFlags2[CheckFlags2["SyntheticMethod"] = 4] = "SyntheticMethod";
|
|
CheckFlags2[CheckFlags2["Readonly"] = 8] = "Readonly";
|
|
CheckFlags2[CheckFlags2["ReadPartial"] = 16] = "ReadPartial";
|
|
CheckFlags2[CheckFlags2["WritePartial"] = 32] = "WritePartial";
|
|
CheckFlags2[CheckFlags2["HasNonUniformType"] = 64] = "HasNonUniformType";
|
|
CheckFlags2[CheckFlags2["HasLiteralType"] = 128] = "HasLiteralType";
|
|
CheckFlags2[CheckFlags2["ContainsPublic"] = 256] = "ContainsPublic";
|
|
CheckFlags2[CheckFlags2["ContainsProtected"] = 512] = "ContainsProtected";
|
|
CheckFlags2[CheckFlags2["ContainsPrivate"] = 1024] = "ContainsPrivate";
|
|
CheckFlags2[CheckFlags2["ContainsStatic"] = 2048] = "ContainsStatic";
|
|
CheckFlags2[CheckFlags2["Late"] = 4096] = "Late";
|
|
CheckFlags2[CheckFlags2["ReverseMapped"] = 8192] = "ReverseMapped";
|
|
CheckFlags2[CheckFlags2["OptionalParameter"] = 16384] = "OptionalParameter";
|
|
CheckFlags2[CheckFlags2["RestParameter"] = 32768] = "RestParameter";
|
|
CheckFlags2[CheckFlags2["DeferredType"] = 65536] = "DeferredType";
|
|
CheckFlags2[CheckFlags2["HasNeverType"] = 131072] = "HasNeverType";
|
|
CheckFlags2[CheckFlags2["Mapped"] = 262144] = "Mapped";
|
|
CheckFlags2[CheckFlags2["StripOptional"] = 524288] = "StripOptional";
|
|
CheckFlags2[CheckFlags2["Unresolved"] = 1048576] = "Unresolved";
|
|
CheckFlags2[CheckFlags2["Synthetic"] = 6] = "Synthetic";
|
|
CheckFlags2[CheckFlags2["Discriminant"] = 192] = "Discriminant";
|
|
CheckFlags2[CheckFlags2["Partial"] = 48] = "Partial";
|
|
return CheckFlags2;
|
|
})(CheckFlags || {});
|
|
var InternalSymbolName = /* @__PURE__ */ ((InternalSymbolName2) => {
|
|
InternalSymbolName2["Call"] = "__call";
|
|
InternalSymbolName2["Constructor"] = "__constructor";
|
|
InternalSymbolName2["New"] = "__new";
|
|
InternalSymbolName2["Index"] = "__index";
|
|
InternalSymbolName2["ExportStar"] = "__export";
|
|
InternalSymbolName2["Global"] = "__global";
|
|
InternalSymbolName2["Missing"] = "__missing";
|
|
InternalSymbolName2["Type"] = "__type";
|
|
InternalSymbolName2["Object"] = "__object";
|
|
InternalSymbolName2["JSXAttributes"] = "__jsxAttributes";
|
|
InternalSymbolName2["Class"] = "__class";
|
|
InternalSymbolName2["Function"] = "__function";
|
|
InternalSymbolName2["Computed"] = "__computed";
|
|
InternalSymbolName2["Resolving"] = "__resolving__";
|
|
InternalSymbolName2["ExportEquals"] = "export=";
|
|
InternalSymbolName2["Default"] = "default";
|
|
InternalSymbolName2["This"] = "this";
|
|
return InternalSymbolName2;
|
|
})(InternalSymbolName || {});
|
|
var NodeCheckFlags = /* @__PURE__ */ ((NodeCheckFlags2) => {
|
|
NodeCheckFlags2[NodeCheckFlags2["None"] = 0] = "None";
|
|
NodeCheckFlags2[NodeCheckFlags2["TypeChecked"] = 1] = "TypeChecked";
|
|
NodeCheckFlags2[NodeCheckFlags2["LexicalThis"] = 2] = "LexicalThis";
|
|
NodeCheckFlags2[NodeCheckFlags2["CaptureThis"] = 4] = "CaptureThis";
|
|
NodeCheckFlags2[NodeCheckFlags2["CaptureNewTarget"] = 8] = "CaptureNewTarget";
|
|
NodeCheckFlags2[NodeCheckFlags2["SuperInstance"] = 16] = "SuperInstance";
|
|
NodeCheckFlags2[NodeCheckFlags2["SuperStatic"] = 32] = "SuperStatic";
|
|
NodeCheckFlags2[NodeCheckFlags2["ContextChecked"] = 64] = "ContextChecked";
|
|
NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAccessInAsync"] = 128] = "MethodWithSuperPropertyAccessInAsync";
|
|
NodeCheckFlags2[NodeCheckFlags2["MethodWithSuperPropertyAssignmentInAsync"] = 256] = "MethodWithSuperPropertyAssignmentInAsync";
|
|
NodeCheckFlags2[NodeCheckFlags2["CaptureArguments"] = 512] = "CaptureArguments";
|
|
NodeCheckFlags2[NodeCheckFlags2["EnumValuesComputed"] = 1024] = "EnumValuesComputed";
|
|
NodeCheckFlags2[NodeCheckFlags2["LexicalModuleMergesWithClass"] = 2048] = "LexicalModuleMergesWithClass";
|
|
NodeCheckFlags2[NodeCheckFlags2["LoopWithCapturedBlockScopedBinding"] = 4096] = "LoopWithCapturedBlockScopedBinding";
|
|
NodeCheckFlags2[NodeCheckFlags2["ContainsCapturedBlockScopeBinding"] = 8192] = "ContainsCapturedBlockScopeBinding";
|
|
NodeCheckFlags2[NodeCheckFlags2["CapturedBlockScopedBinding"] = 16384] = "CapturedBlockScopedBinding";
|
|
NodeCheckFlags2[NodeCheckFlags2["BlockScopedBindingInLoop"] = 32768] = "BlockScopedBindingInLoop";
|
|
NodeCheckFlags2[NodeCheckFlags2["ClassWithBodyScopedClassBinding"] = 65536] = "ClassWithBodyScopedClassBinding";
|
|
NodeCheckFlags2[NodeCheckFlags2["BodyScopedClassBinding"] = 131072] = "BodyScopedClassBinding";
|
|
NodeCheckFlags2[NodeCheckFlags2["NeedsLoopOutParameter"] = 262144] = "NeedsLoopOutParameter";
|
|
NodeCheckFlags2[NodeCheckFlags2["AssignmentsMarked"] = 524288] = "AssignmentsMarked";
|
|
NodeCheckFlags2[NodeCheckFlags2["ClassWithConstructorReference"] = 1048576] = "ClassWithConstructorReference";
|
|
NodeCheckFlags2[NodeCheckFlags2["ConstructorReferenceInClass"] = 2097152] = "ConstructorReferenceInClass";
|
|
NodeCheckFlags2[NodeCheckFlags2["ContainsClassWithPrivateIdentifiers"] = 4194304] = "ContainsClassWithPrivateIdentifiers";
|
|
NodeCheckFlags2[NodeCheckFlags2["ContainsSuperPropertyInStaticInitializer"] = 8388608] = "ContainsSuperPropertyInStaticInitializer";
|
|
NodeCheckFlags2[NodeCheckFlags2["InCheckIdentifier"] = 16777216] = "InCheckIdentifier";
|
|
return NodeCheckFlags2;
|
|
})(NodeCheckFlags || {});
|
|
var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
|
|
TypeFlags2[TypeFlags2["Any"] = 1] = "Any";
|
|
TypeFlags2[TypeFlags2["Unknown"] = 2] = "Unknown";
|
|
TypeFlags2[TypeFlags2["String"] = 4] = "String";
|
|
TypeFlags2[TypeFlags2["Number"] = 8] = "Number";
|
|
TypeFlags2[TypeFlags2["Boolean"] = 16] = "Boolean";
|
|
TypeFlags2[TypeFlags2["Enum"] = 32] = "Enum";
|
|
TypeFlags2[TypeFlags2["BigInt"] = 64] = "BigInt";
|
|
TypeFlags2[TypeFlags2["StringLiteral"] = 128] = "StringLiteral";
|
|
TypeFlags2[TypeFlags2["NumberLiteral"] = 256] = "NumberLiteral";
|
|
TypeFlags2[TypeFlags2["BooleanLiteral"] = 512] = "BooleanLiteral";
|
|
TypeFlags2[TypeFlags2["EnumLiteral"] = 1024] = "EnumLiteral";
|
|
TypeFlags2[TypeFlags2["BigIntLiteral"] = 2048] = "BigIntLiteral";
|
|
TypeFlags2[TypeFlags2["ESSymbol"] = 4096] = "ESSymbol";
|
|
TypeFlags2[TypeFlags2["UniqueESSymbol"] = 8192] = "UniqueESSymbol";
|
|
TypeFlags2[TypeFlags2["Void"] = 16384] = "Void";
|
|
TypeFlags2[TypeFlags2["Undefined"] = 32768] = "Undefined";
|
|
TypeFlags2[TypeFlags2["Null"] = 65536] = "Null";
|
|
TypeFlags2[TypeFlags2["Never"] = 131072] = "Never";
|
|
TypeFlags2[TypeFlags2["TypeParameter"] = 262144] = "TypeParameter";
|
|
TypeFlags2[TypeFlags2["Object"] = 524288] = "Object";
|
|
TypeFlags2[TypeFlags2["Union"] = 1048576] = "Union";
|
|
TypeFlags2[TypeFlags2["Intersection"] = 2097152] = "Intersection";
|
|
TypeFlags2[TypeFlags2["Index"] = 4194304] = "Index";
|
|
TypeFlags2[TypeFlags2["IndexedAccess"] = 8388608] = "IndexedAccess";
|
|
TypeFlags2[TypeFlags2["Conditional"] = 16777216] = "Conditional";
|
|
TypeFlags2[TypeFlags2["Substitution"] = 33554432] = "Substitution";
|
|
TypeFlags2[TypeFlags2["NonPrimitive"] = 67108864] = "NonPrimitive";
|
|
TypeFlags2[TypeFlags2["TemplateLiteral"] = 134217728] = "TemplateLiteral";
|
|
TypeFlags2[TypeFlags2["StringMapping"] = 268435456] = "StringMapping";
|
|
TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
|
|
TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
|
|
TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
|
|
TypeFlags2[TypeFlags2["Unit"] = 109440] = "Unit";
|
|
TypeFlags2[TypeFlags2["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
|
|
TypeFlags2[TypeFlags2["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique";
|
|
TypeFlags2[TypeFlags2["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
|
|
TypeFlags2[TypeFlags2["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
|
|
TypeFlags2[TypeFlags2["Intrinsic"] = 67359327] = "Intrinsic";
|
|
TypeFlags2[TypeFlags2["Primitive"] = 131068] = "Primitive";
|
|
TypeFlags2[TypeFlags2["StringLike"] = 402653316] = "StringLike";
|
|
TypeFlags2[TypeFlags2["NumberLike"] = 296] = "NumberLike";
|
|
TypeFlags2[TypeFlags2["BigIntLike"] = 2112] = "BigIntLike";
|
|
TypeFlags2[TypeFlags2["BooleanLike"] = 528] = "BooleanLike";
|
|
TypeFlags2[TypeFlags2["EnumLike"] = 1056] = "EnumLike";
|
|
TypeFlags2[TypeFlags2["ESSymbolLike"] = 12288] = "ESSymbolLike";
|
|
TypeFlags2[TypeFlags2["VoidLike"] = 49152] = "VoidLike";
|
|
TypeFlags2[TypeFlags2["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable";
|
|
TypeFlags2[TypeFlags2["DisjointDomains"] = 469892092] = "DisjointDomains";
|
|
TypeFlags2[TypeFlags2["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
|
|
TypeFlags2[TypeFlags2["StructuredType"] = 3670016] = "StructuredType";
|
|
TypeFlags2[TypeFlags2["TypeVariable"] = 8650752] = "TypeVariable";
|
|
TypeFlags2[TypeFlags2["InstantiableNonPrimitive"] = 58982400] = "InstantiableNonPrimitive";
|
|
TypeFlags2[TypeFlags2["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive";
|
|
TypeFlags2[TypeFlags2["Instantiable"] = 465829888] = "Instantiable";
|
|
TypeFlags2[TypeFlags2["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable";
|
|
TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
|
|
TypeFlags2[TypeFlags2["Simplifiable"] = 25165824] = "Simplifiable";
|
|
TypeFlags2[TypeFlags2["Singleton"] = 67358815] = "Singleton";
|
|
TypeFlags2[TypeFlags2["Narrowable"] = 536624127] = "Narrowable";
|
|
TypeFlags2[TypeFlags2["IncludesMask"] = 205258751] = "IncludesMask";
|
|
TypeFlags2[TypeFlags2["IncludesMissingType"] = 262144 /* TypeParameter */] = "IncludesMissingType";
|
|
TypeFlags2[TypeFlags2["IncludesNonWideningType"] = 4194304 /* Index */] = "IncludesNonWideningType";
|
|
TypeFlags2[TypeFlags2["IncludesWildcard"] = 8388608 /* IndexedAccess */] = "IncludesWildcard";
|
|
TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
|
|
TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
|
|
TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion";
|
|
return TypeFlags2;
|
|
})(TypeFlags || {});
|
|
var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
|
|
ObjectFlags3[ObjectFlags3["None"] = 0] = "None";
|
|
ObjectFlags3[ObjectFlags3["Class"] = 1] = "Class";
|
|
ObjectFlags3[ObjectFlags3["Interface"] = 2] = "Interface";
|
|
ObjectFlags3[ObjectFlags3["Reference"] = 4] = "Reference";
|
|
ObjectFlags3[ObjectFlags3["Tuple"] = 8] = "Tuple";
|
|
ObjectFlags3[ObjectFlags3["Anonymous"] = 16] = "Anonymous";
|
|
ObjectFlags3[ObjectFlags3["Mapped"] = 32] = "Mapped";
|
|
ObjectFlags3[ObjectFlags3["Instantiated"] = 64] = "Instantiated";
|
|
ObjectFlags3[ObjectFlags3["ObjectLiteral"] = 128] = "ObjectLiteral";
|
|
ObjectFlags3[ObjectFlags3["EvolvingArray"] = 256] = "EvolvingArray";
|
|
ObjectFlags3[ObjectFlags3["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties";
|
|
ObjectFlags3[ObjectFlags3["ReverseMapped"] = 1024] = "ReverseMapped";
|
|
ObjectFlags3[ObjectFlags3["JsxAttributes"] = 2048] = "JsxAttributes";
|
|
ObjectFlags3[ObjectFlags3["JSLiteral"] = 4096] = "JSLiteral";
|
|
ObjectFlags3[ObjectFlags3["FreshLiteral"] = 8192] = "FreshLiteral";
|
|
ObjectFlags3[ObjectFlags3["ArrayLiteral"] = 16384] = "ArrayLiteral";
|
|
ObjectFlags3[ObjectFlags3["PrimitiveUnion"] = 32768] = "PrimitiveUnion";
|
|
ObjectFlags3[ObjectFlags3["ContainsWideningType"] = 65536] = "ContainsWideningType";
|
|
ObjectFlags3[ObjectFlags3["ContainsObjectOrArrayLiteral"] = 131072] = "ContainsObjectOrArrayLiteral";
|
|
ObjectFlags3[ObjectFlags3["NonInferrableType"] = 262144] = "NonInferrableType";
|
|
ObjectFlags3[ObjectFlags3["CouldContainTypeVariablesComputed"] = 524288] = "CouldContainTypeVariablesComputed";
|
|
ObjectFlags3[ObjectFlags3["CouldContainTypeVariables"] = 1048576] = "CouldContainTypeVariables";
|
|
ObjectFlags3[ObjectFlags3["ClassOrInterface"] = 3] = "ClassOrInterface";
|
|
ObjectFlags3[ObjectFlags3["RequiresWidening"] = 196608] = "RequiresWidening";
|
|
ObjectFlags3[ObjectFlags3["PropagatingFlags"] = 458752] = "PropagatingFlags";
|
|
ObjectFlags3[ObjectFlags3["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask";
|
|
ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
|
|
ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
|
|
ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
|
|
ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
|
|
ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
|
|
ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
|
|
ObjectFlags3[ObjectFlags3["IsGenericTypeComputed"] = 2097152] = "IsGenericTypeComputed";
|
|
ObjectFlags3[ObjectFlags3["IsGenericObjectType"] = 4194304] = "IsGenericObjectType";
|
|
ObjectFlags3[ObjectFlags3["IsGenericIndexType"] = 8388608] = "IsGenericIndexType";
|
|
ObjectFlags3[ObjectFlags3["IsGenericType"] = 12582912] = "IsGenericType";
|
|
ObjectFlags3[ObjectFlags3["ContainsIntersections"] = 16777216] = "ContainsIntersections";
|
|
ObjectFlags3[ObjectFlags3["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed";
|
|
ObjectFlags3[ObjectFlags3["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion";
|
|
ObjectFlags3[ObjectFlags3["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed";
|
|
ObjectFlags3[ObjectFlags3["IsNeverIntersection"] = 33554432] = "IsNeverIntersection";
|
|
return ObjectFlags3;
|
|
})(ObjectFlags || {});
|
|
var VarianceFlags = /* @__PURE__ */ ((VarianceFlags2) => {
|
|
VarianceFlags2[VarianceFlags2["Invariant"] = 0] = "Invariant";
|
|
VarianceFlags2[VarianceFlags2["Covariant"] = 1] = "Covariant";
|
|
VarianceFlags2[VarianceFlags2["Contravariant"] = 2] = "Contravariant";
|
|
VarianceFlags2[VarianceFlags2["Bivariant"] = 3] = "Bivariant";
|
|
VarianceFlags2[VarianceFlags2["Independent"] = 4] = "Independent";
|
|
VarianceFlags2[VarianceFlags2["VarianceMask"] = 7] = "VarianceMask";
|
|
VarianceFlags2[VarianceFlags2["Unmeasurable"] = 8] = "Unmeasurable";
|
|
VarianceFlags2[VarianceFlags2["Unreliable"] = 16] = "Unreliable";
|
|
VarianceFlags2[VarianceFlags2["AllowsStructuralFallback"] = 24] = "AllowsStructuralFallback";
|
|
return VarianceFlags2;
|
|
})(VarianceFlags || {});
|
|
var ElementFlags = /* @__PURE__ */ ((ElementFlags2) => {
|
|
ElementFlags2[ElementFlags2["Required"] = 1] = "Required";
|
|
ElementFlags2[ElementFlags2["Optional"] = 2] = "Optional";
|
|
ElementFlags2[ElementFlags2["Rest"] = 4] = "Rest";
|
|
ElementFlags2[ElementFlags2["Variadic"] = 8] = "Variadic";
|
|
ElementFlags2[ElementFlags2["Fixed"] = 3] = "Fixed";
|
|
ElementFlags2[ElementFlags2["Variable"] = 12] = "Variable";
|
|
ElementFlags2[ElementFlags2["NonRequired"] = 14] = "NonRequired";
|
|
ElementFlags2[ElementFlags2["NonRest"] = 11] = "NonRest";
|
|
return ElementFlags2;
|
|
})(ElementFlags || {});
|
|
var AccessFlags = /* @__PURE__ */ ((AccessFlags2) => {
|
|
AccessFlags2[AccessFlags2["None"] = 0] = "None";
|
|
AccessFlags2[AccessFlags2["IncludeUndefined"] = 1] = "IncludeUndefined";
|
|
AccessFlags2[AccessFlags2["NoIndexSignatures"] = 2] = "NoIndexSignatures";
|
|
AccessFlags2[AccessFlags2["Writing"] = 4] = "Writing";
|
|
AccessFlags2[AccessFlags2["CacheSymbol"] = 8] = "CacheSymbol";
|
|
AccessFlags2[AccessFlags2["NoTupleBoundsCheck"] = 16] = "NoTupleBoundsCheck";
|
|
AccessFlags2[AccessFlags2["ExpressionPosition"] = 32] = "ExpressionPosition";
|
|
AccessFlags2[AccessFlags2["ReportDeprecated"] = 64] = "ReportDeprecated";
|
|
AccessFlags2[AccessFlags2["SuppressNoImplicitAnyError"] = 128] = "SuppressNoImplicitAnyError";
|
|
AccessFlags2[AccessFlags2["Contextual"] = 256] = "Contextual";
|
|
AccessFlags2[AccessFlags2["Persistent"] = 1 /* IncludeUndefined */] = "Persistent";
|
|
return AccessFlags2;
|
|
})(AccessFlags || {});
|
|
var JsxReferenceKind = /* @__PURE__ */ ((JsxReferenceKind2) => {
|
|
JsxReferenceKind2[JsxReferenceKind2["Component"] = 0] = "Component";
|
|
JsxReferenceKind2[JsxReferenceKind2["Function"] = 1] = "Function";
|
|
JsxReferenceKind2[JsxReferenceKind2["Mixed"] = 2] = "Mixed";
|
|
return JsxReferenceKind2;
|
|
})(JsxReferenceKind || {});
|
|
var SignatureKind = /* @__PURE__ */ ((SignatureKind2) => {
|
|
SignatureKind2[SignatureKind2["Call"] = 0] = "Call";
|
|
SignatureKind2[SignatureKind2["Construct"] = 1] = "Construct";
|
|
return SignatureKind2;
|
|
})(SignatureKind || {});
|
|
var SignatureFlags = /* @__PURE__ */ ((SignatureFlags5) => {
|
|
SignatureFlags5[SignatureFlags5["None"] = 0] = "None";
|
|
SignatureFlags5[SignatureFlags5["HasRestParameter"] = 1] = "HasRestParameter";
|
|
SignatureFlags5[SignatureFlags5["HasLiteralTypes"] = 2] = "HasLiteralTypes";
|
|
SignatureFlags5[SignatureFlags5["Abstract"] = 4] = "Abstract";
|
|
SignatureFlags5[SignatureFlags5["IsInnerCallChain"] = 8] = "IsInnerCallChain";
|
|
SignatureFlags5[SignatureFlags5["IsOuterCallChain"] = 16] = "IsOuterCallChain";
|
|
SignatureFlags5[SignatureFlags5["IsUntypedSignatureInJSFile"] = 32] = "IsUntypedSignatureInJSFile";
|
|
SignatureFlags5[SignatureFlags5["PropagatingFlags"] = 39] = "PropagatingFlags";
|
|
SignatureFlags5[SignatureFlags5["CallChainFlags"] = 24] = "CallChainFlags";
|
|
return SignatureFlags5;
|
|
})(SignatureFlags || {});
|
|
var IndexKind = /* @__PURE__ */ ((IndexKind2) => {
|
|
IndexKind2[IndexKind2["String"] = 0] = "String";
|
|
IndexKind2[IndexKind2["Number"] = 1] = "Number";
|
|
return IndexKind2;
|
|
})(IndexKind || {});
|
|
var TypeMapKind = /* @__PURE__ */ ((TypeMapKind2) => {
|
|
TypeMapKind2[TypeMapKind2["Simple"] = 0] = "Simple";
|
|
TypeMapKind2[TypeMapKind2["Array"] = 1] = "Array";
|
|
TypeMapKind2[TypeMapKind2["Deferred"] = 2] = "Deferred";
|
|
TypeMapKind2[TypeMapKind2["Function"] = 3] = "Function";
|
|
TypeMapKind2[TypeMapKind2["Composite"] = 4] = "Composite";
|
|
TypeMapKind2[TypeMapKind2["Merged"] = 5] = "Merged";
|
|
return TypeMapKind2;
|
|
})(TypeMapKind || {});
|
|
var InferencePriority = /* @__PURE__ */ ((InferencePriority2) => {
|
|
InferencePriority2[InferencePriority2["None"] = 0] = "None";
|
|
InferencePriority2[InferencePriority2["NakedTypeVariable"] = 1] = "NakedTypeVariable";
|
|
InferencePriority2[InferencePriority2["SpeculativeTuple"] = 2] = "SpeculativeTuple";
|
|
InferencePriority2[InferencePriority2["SubstituteSource"] = 4] = "SubstituteSource";
|
|
InferencePriority2[InferencePriority2["HomomorphicMappedType"] = 8] = "HomomorphicMappedType";
|
|
InferencePriority2[InferencePriority2["PartialHomomorphicMappedType"] = 16] = "PartialHomomorphicMappedType";
|
|
InferencePriority2[InferencePriority2["MappedTypeConstraint"] = 32] = "MappedTypeConstraint";
|
|
InferencePriority2[InferencePriority2["ContravariantConditional"] = 64] = "ContravariantConditional";
|
|
InferencePriority2[InferencePriority2["ReturnType"] = 128] = "ReturnType";
|
|
InferencePriority2[InferencePriority2["LiteralKeyof"] = 256] = "LiteralKeyof";
|
|
InferencePriority2[InferencePriority2["NoConstraints"] = 512] = "NoConstraints";
|
|
InferencePriority2[InferencePriority2["AlwaysStrict"] = 1024] = "AlwaysStrict";
|
|
InferencePriority2[InferencePriority2["MaxValue"] = 2048] = "MaxValue";
|
|
InferencePriority2[InferencePriority2["PriorityImpliesCombination"] = 416] = "PriorityImpliesCombination";
|
|
InferencePriority2[InferencePriority2["Circularity"] = -1] = "Circularity";
|
|
return InferencePriority2;
|
|
})(InferencePriority || {});
|
|
var InferenceFlags = /* @__PURE__ */ ((InferenceFlags2) => {
|
|
InferenceFlags2[InferenceFlags2["None"] = 0] = "None";
|
|
InferenceFlags2[InferenceFlags2["NoDefault"] = 1] = "NoDefault";
|
|
InferenceFlags2[InferenceFlags2["AnyDefault"] = 2] = "AnyDefault";
|
|
InferenceFlags2[InferenceFlags2["SkippedGenericFunction"] = 4] = "SkippedGenericFunction";
|
|
return InferenceFlags2;
|
|
})(InferenceFlags || {});
|
|
var Ternary = /* @__PURE__ */ ((Ternary2) => {
|
|
Ternary2[Ternary2["False"] = 0] = "False";
|
|
Ternary2[Ternary2["Unknown"] = 1] = "Unknown";
|
|
Ternary2[Ternary2["Maybe"] = 3] = "Maybe";
|
|
Ternary2[Ternary2["True"] = -1] = "True";
|
|
return Ternary2;
|
|
})(Ternary || {});
|
|
var AssignmentDeclarationKind = /* @__PURE__ */ ((AssignmentDeclarationKind2) => {
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["None"] = 0] = "None";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ExportsProperty"] = 1] = "ExportsProperty";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ModuleExports"] = 2] = "ModuleExports";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["PrototypeProperty"] = 3] = "PrototypeProperty";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ThisProperty"] = 4] = "ThisProperty";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["Property"] = 5] = "Property";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["Prototype"] = 6] = "Prototype";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ObjectDefinePropertyValue"] = 7] = "ObjectDefinePropertyValue";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ObjectDefinePropertyExports"] = 8] = "ObjectDefinePropertyExports";
|
|
AssignmentDeclarationKind2[AssignmentDeclarationKind2["ObjectDefinePrototypeProperty"] = 9] = "ObjectDefinePrototypeProperty";
|
|
return AssignmentDeclarationKind2;
|
|
})(AssignmentDeclarationKind || {});
|
|
var DiagnosticCategory = /* @__PURE__ */ ((DiagnosticCategory2) => {
|
|
DiagnosticCategory2[DiagnosticCategory2["Warning"] = 0] = "Warning";
|
|
DiagnosticCategory2[DiagnosticCategory2["Error"] = 1] = "Error";
|
|
DiagnosticCategory2[DiagnosticCategory2["Suggestion"] = 2] = "Suggestion";
|
|
DiagnosticCategory2[DiagnosticCategory2["Message"] = 3] = "Message";
|
|
return DiagnosticCategory2;
|
|
})(DiagnosticCategory || {});
|
|
function diagnosticCategoryName(d, lowerCase = true) {
|
|
const name = DiagnosticCategory[d.category];
|
|
return lowerCase ? name.toLowerCase() : name;
|
|
}
|
|
var ModuleResolutionKind = /* @__PURE__ */ ((ModuleResolutionKind3) => {
|
|
ModuleResolutionKind3[ModuleResolutionKind3["Classic"] = 1] = "Classic";
|
|
ModuleResolutionKind3[ModuleResolutionKind3["NodeJs"] = 2] = "NodeJs";
|
|
ModuleResolutionKind3[ModuleResolutionKind3["Node16"] = 3] = "Node16";
|
|
ModuleResolutionKind3[ModuleResolutionKind3["NodeNext"] = 99] = "NodeNext";
|
|
return ModuleResolutionKind3;
|
|
})(ModuleResolutionKind || {});
|
|
var ModuleDetectionKind = /* @__PURE__ */ ((ModuleDetectionKind2) => {
|
|
ModuleDetectionKind2[ModuleDetectionKind2["Legacy"] = 1] = "Legacy";
|
|
ModuleDetectionKind2[ModuleDetectionKind2["Auto"] = 2] = "Auto";
|
|
ModuleDetectionKind2[ModuleDetectionKind2["Force"] = 3] = "Force";
|
|
return ModuleDetectionKind2;
|
|
})(ModuleDetectionKind || {});
|
|
var WatchFileKind = /* @__PURE__ */ ((WatchFileKind3) => {
|
|
WatchFileKind3[WatchFileKind3["FixedPollingInterval"] = 0] = "FixedPollingInterval";
|
|
WatchFileKind3[WatchFileKind3["PriorityPollingInterval"] = 1] = "PriorityPollingInterval";
|
|
WatchFileKind3[WatchFileKind3["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling";
|
|
WatchFileKind3[WatchFileKind3["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling";
|
|
WatchFileKind3[WatchFileKind3["UseFsEvents"] = 4] = "UseFsEvents";
|
|
WatchFileKind3[WatchFileKind3["UseFsEventsOnParentDirectory"] = 5] = "UseFsEventsOnParentDirectory";
|
|
return WatchFileKind3;
|
|
})(WatchFileKind || {});
|
|
var WatchDirectoryKind = /* @__PURE__ */ ((WatchDirectoryKind3) => {
|
|
WatchDirectoryKind3[WatchDirectoryKind3["UseFsEvents"] = 0] = "UseFsEvents";
|
|
WatchDirectoryKind3[WatchDirectoryKind3["FixedPollingInterval"] = 1] = "FixedPollingInterval";
|
|
WatchDirectoryKind3[WatchDirectoryKind3["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling";
|
|
WatchDirectoryKind3[WatchDirectoryKind3["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling";
|
|
return WatchDirectoryKind3;
|
|
})(WatchDirectoryKind || {});
|
|
var PollingWatchKind = /* @__PURE__ */ ((PollingWatchKind3) => {
|
|
PollingWatchKind3[PollingWatchKind3["FixedInterval"] = 0] = "FixedInterval";
|
|
PollingWatchKind3[PollingWatchKind3["PriorityInterval"] = 1] = "PriorityInterval";
|
|
PollingWatchKind3[PollingWatchKind3["DynamicPriority"] = 2] = "DynamicPriority";
|
|
PollingWatchKind3[PollingWatchKind3["FixedChunkSize"] = 3] = "FixedChunkSize";
|
|
return PollingWatchKind3;
|
|
})(PollingWatchKind || {});
|
|
var ModuleKind = /* @__PURE__ */ ((ModuleKind3) => {
|
|
ModuleKind3[ModuleKind3["None"] = 0] = "None";
|
|
ModuleKind3[ModuleKind3["CommonJS"] = 1] = "CommonJS";
|
|
ModuleKind3[ModuleKind3["AMD"] = 2] = "AMD";
|
|
ModuleKind3[ModuleKind3["UMD"] = 3] = "UMD";
|
|
ModuleKind3[ModuleKind3["System"] = 4] = "System";
|
|
ModuleKind3[ModuleKind3["ES2015"] = 5] = "ES2015";
|
|
ModuleKind3[ModuleKind3["ES2020"] = 6] = "ES2020";
|
|
ModuleKind3[ModuleKind3["ES2022"] = 7] = "ES2022";
|
|
ModuleKind3[ModuleKind3["ESNext"] = 99] = "ESNext";
|
|
ModuleKind3[ModuleKind3["Node16"] = 100] = "Node16";
|
|
ModuleKind3[ModuleKind3["NodeNext"] = 199] = "NodeNext";
|
|
return ModuleKind3;
|
|
})(ModuleKind || {});
|
|
var JsxEmit = /* @__PURE__ */ ((JsxEmit3) => {
|
|
JsxEmit3[JsxEmit3["None"] = 0] = "None";
|
|
JsxEmit3[JsxEmit3["Preserve"] = 1] = "Preserve";
|
|
JsxEmit3[JsxEmit3["React"] = 2] = "React";
|
|
JsxEmit3[JsxEmit3["ReactNative"] = 3] = "ReactNative";
|
|
JsxEmit3[JsxEmit3["ReactJSX"] = 4] = "ReactJSX";
|
|
JsxEmit3[JsxEmit3["ReactJSXDev"] = 5] = "ReactJSXDev";
|
|
return JsxEmit3;
|
|
})(JsxEmit || {});
|
|
var ImportsNotUsedAsValues = /* @__PURE__ */ ((ImportsNotUsedAsValues2) => {
|
|
ImportsNotUsedAsValues2[ImportsNotUsedAsValues2["Remove"] = 0] = "Remove";
|
|
ImportsNotUsedAsValues2[ImportsNotUsedAsValues2["Preserve"] = 1] = "Preserve";
|
|
ImportsNotUsedAsValues2[ImportsNotUsedAsValues2["Error"] = 2] = "Error";
|
|
return ImportsNotUsedAsValues2;
|
|
})(ImportsNotUsedAsValues || {});
|
|
var NewLineKind = /* @__PURE__ */ ((NewLineKind3) => {
|
|
NewLineKind3[NewLineKind3["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed";
|
|
NewLineKind3[NewLineKind3["LineFeed"] = 1] = "LineFeed";
|
|
return NewLineKind3;
|
|
})(NewLineKind || {});
|
|
var ScriptKind = /* @__PURE__ */ ((ScriptKind6) => {
|
|
ScriptKind6[ScriptKind6["Unknown"] = 0] = "Unknown";
|
|
ScriptKind6[ScriptKind6["JS"] = 1] = "JS";
|
|
ScriptKind6[ScriptKind6["JSX"] = 2] = "JSX";
|
|
ScriptKind6[ScriptKind6["TS"] = 3] = "TS";
|
|
ScriptKind6[ScriptKind6["TSX"] = 4] = "TSX";
|
|
ScriptKind6[ScriptKind6["External"] = 5] = "External";
|
|
ScriptKind6[ScriptKind6["JSON"] = 6] = "JSON";
|
|
ScriptKind6[ScriptKind6["Deferred"] = 7] = "Deferred";
|
|
return ScriptKind6;
|
|
})(ScriptKind || {});
|
|
var ScriptTarget = /* @__PURE__ */ ((ScriptTarget11) => {
|
|
ScriptTarget11[ScriptTarget11["ES3"] = 0] = "ES3";
|
|
ScriptTarget11[ScriptTarget11["ES5"] = 1] = "ES5";
|
|
ScriptTarget11[ScriptTarget11["ES2015"] = 2] = "ES2015";
|
|
ScriptTarget11[ScriptTarget11["ES2016"] = 3] = "ES2016";
|
|
ScriptTarget11[ScriptTarget11["ES2017"] = 4] = "ES2017";
|
|
ScriptTarget11[ScriptTarget11["ES2018"] = 5] = "ES2018";
|
|
ScriptTarget11[ScriptTarget11["ES2019"] = 6] = "ES2019";
|
|
ScriptTarget11[ScriptTarget11["ES2020"] = 7] = "ES2020";
|
|
ScriptTarget11[ScriptTarget11["ES2021"] = 8] = "ES2021";
|
|
ScriptTarget11[ScriptTarget11["ES2022"] = 9] = "ES2022";
|
|
ScriptTarget11[ScriptTarget11["ESNext"] = 99] = "ESNext";
|
|
ScriptTarget11[ScriptTarget11["JSON"] = 100] = "JSON";
|
|
ScriptTarget11[ScriptTarget11["Latest"] = 99 /* ESNext */] = "Latest";
|
|
return ScriptTarget11;
|
|
})(ScriptTarget || {});
|
|
var LanguageVariant = /* @__PURE__ */ ((LanguageVariant4) => {
|
|
LanguageVariant4[LanguageVariant4["Standard"] = 0] = "Standard";
|
|
LanguageVariant4[LanguageVariant4["JSX"] = 1] = "JSX";
|
|
return LanguageVariant4;
|
|
})(LanguageVariant || {});
|
|
var WatchDirectoryFlags = /* @__PURE__ */ ((WatchDirectoryFlags4) => {
|
|
WatchDirectoryFlags4[WatchDirectoryFlags4["None"] = 0] = "None";
|
|
WatchDirectoryFlags4[WatchDirectoryFlags4["Recursive"] = 1] = "Recursive";
|
|
return WatchDirectoryFlags4;
|
|
})(WatchDirectoryFlags || {});
|
|
var CharacterCodes = /* @__PURE__ */ ((CharacterCodes2) => {
|
|
CharacterCodes2[CharacterCodes2["nullCharacter"] = 0] = "nullCharacter";
|
|
CharacterCodes2[CharacterCodes2["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
|
|
CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
|
|
CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
|
|
CharacterCodes2[CharacterCodes2["lineSeparator"] = 8232] = "lineSeparator";
|
|
CharacterCodes2[CharacterCodes2["paragraphSeparator"] = 8233] = "paragraphSeparator";
|
|
CharacterCodes2[CharacterCodes2["nextLine"] = 133] = "nextLine";
|
|
CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
|
|
CharacterCodes2[CharacterCodes2["nonBreakingSpace"] = 160] = "nonBreakingSpace";
|
|
CharacterCodes2[CharacterCodes2["enQuad"] = 8192] = "enQuad";
|
|
CharacterCodes2[CharacterCodes2["emQuad"] = 8193] = "emQuad";
|
|
CharacterCodes2[CharacterCodes2["enSpace"] = 8194] = "enSpace";
|
|
CharacterCodes2[CharacterCodes2["emSpace"] = 8195] = "emSpace";
|
|
CharacterCodes2[CharacterCodes2["threePerEmSpace"] = 8196] = "threePerEmSpace";
|
|
CharacterCodes2[CharacterCodes2["fourPerEmSpace"] = 8197] = "fourPerEmSpace";
|
|
CharacterCodes2[CharacterCodes2["sixPerEmSpace"] = 8198] = "sixPerEmSpace";
|
|
CharacterCodes2[CharacterCodes2["figureSpace"] = 8199] = "figureSpace";
|
|
CharacterCodes2[CharacterCodes2["punctuationSpace"] = 8200] = "punctuationSpace";
|
|
CharacterCodes2[CharacterCodes2["thinSpace"] = 8201] = "thinSpace";
|
|
CharacterCodes2[CharacterCodes2["hairSpace"] = 8202] = "hairSpace";
|
|
CharacterCodes2[CharacterCodes2["zeroWidthSpace"] = 8203] = "zeroWidthSpace";
|
|
CharacterCodes2[CharacterCodes2["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace";
|
|
CharacterCodes2[CharacterCodes2["ideographicSpace"] = 12288] = "ideographicSpace";
|
|
CharacterCodes2[CharacterCodes2["mathematicalSpace"] = 8287] = "mathematicalSpace";
|
|
CharacterCodes2[CharacterCodes2["ogham"] = 5760] = "ogham";
|
|
CharacterCodes2[CharacterCodes2["_"] = 95] = "_";
|
|
CharacterCodes2[CharacterCodes2["$"] = 36] = "$";
|
|
CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
|
|
CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
|
|
CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
|
|
CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
|
|
CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
|
|
CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
|
|
CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
|
|
CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
|
|
CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
|
|
CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
|
|
CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
|
|
CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
|
|
CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
|
|
CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
|
|
CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
|
|
CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
|
|
CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
|
|
CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
|
|
CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
|
|
CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
|
|
CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
|
|
CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
|
|
CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
|
|
CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
|
|
CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
|
|
CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
|
|
CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
|
|
CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
|
|
CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
|
|
CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
|
|
CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
|
|
CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
|
|
CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
|
|
CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
|
|
CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
|
|
CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
|
|
CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
|
|
CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
|
|
CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
|
|
CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
|
|
CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
|
|
CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
|
|
CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
|
|
CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
|
|
CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
|
|
CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
|
|
CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
|
|
CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
|
|
CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
|
|
CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
|
|
CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
|
|
CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
|
|
CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
|
|
CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
|
|
CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
|
|
CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
|
|
CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
|
|
CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
|
|
CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
|
|
CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
|
|
CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
|
|
CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
|
|
CharacterCodes2[CharacterCodes2["ampersand"] = 38] = "ampersand";
|
|
CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
|
|
CharacterCodes2[CharacterCodes2["at"] = 64] = "at";
|
|
CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
|
|
CharacterCodes2[CharacterCodes2["backtick"] = 96] = "backtick";
|
|
CharacterCodes2[CharacterCodes2["bar"] = 124] = "bar";
|
|
CharacterCodes2[CharacterCodes2["caret"] = 94] = "caret";
|
|
CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
|
|
CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
|
|
CharacterCodes2[CharacterCodes2["closeParen"] = 41] = "closeParen";
|
|
CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
|
|
CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
|
|
CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
|
|
CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
|
|
CharacterCodes2[CharacterCodes2["equals"] = 61] = "equals";
|
|
CharacterCodes2[CharacterCodes2["exclamation"] = 33] = "exclamation";
|
|
CharacterCodes2[CharacterCodes2["greaterThan"] = 62] = "greaterThan";
|
|
CharacterCodes2[CharacterCodes2["hash"] = 35] = "hash";
|
|
CharacterCodes2[CharacterCodes2["lessThan"] = 60] = "lessThan";
|
|
CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
|
|
CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
|
|
CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
|
|
CharacterCodes2[CharacterCodes2["openParen"] = 40] = "openParen";
|
|
CharacterCodes2[CharacterCodes2["percent"] = 37] = "percent";
|
|
CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
|
|
CharacterCodes2[CharacterCodes2["question"] = 63] = "question";
|
|
CharacterCodes2[CharacterCodes2["semicolon"] = 59] = "semicolon";
|
|
CharacterCodes2[CharacterCodes2["singleQuote"] = 39] = "singleQuote";
|
|
CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
|
|
CharacterCodes2[CharacterCodes2["tilde"] = 126] = "tilde";
|
|
CharacterCodes2[CharacterCodes2["backspace"] = 8] = "backspace";
|
|
CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
|
|
CharacterCodes2[CharacterCodes2["byteOrderMark"] = 65279] = "byteOrderMark";
|
|
CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
|
|
CharacterCodes2[CharacterCodes2["verticalTab"] = 11] = "verticalTab";
|
|
return CharacterCodes2;
|
|
})(CharacterCodes || {});
|
|
var Extension = /* @__PURE__ */ ((Extension2) => {
|
|
Extension2["Ts"] = ".ts";
|
|
Extension2["Tsx"] = ".tsx";
|
|
Extension2["Dts"] = ".d.ts";
|
|
Extension2["Js"] = ".js";
|
|
Extension2["Jsx"] = ".jsx";
|
|
Extension2["Json"] = ".json";
|
|
Extension2["TsBuildInfo"] = ".tsbuildinfo";
|
|
Extension2["Mjs"] = ".mjs";
|
|
Extension2["Mts"] = ".mts";
|
|
Extension2["Dmts"] = ".d.mts";
|
|
Extension2["Cjs"] = ".cjs";
|
|
Extension2["Cts"] = ".cts";
|
|
Extension2["Dcts"] = ".d.cts";
|
|
return Extension2;
|
|
})(Extension || {});
|
|
var TransformFlags = /* @__PURE__ */ ((TransformFlags3) => {
|
|
TransformFlags3[TransformFlags3["None"] = 0] = "None";
|
|
TransformFlags3[TransformFlags3["ContainsTypeScript"] = 1] = "ContainsTypeScript";
|
|
TransformFlags3[TransformFlags3["ContainsJsx"] = 2] = "ContainsJsx";
|
|
TransformFlags3[TransformFlags3["ContainsESNext"] = 4] = "ContainsESNext";
|
|
TransformFlags3[TransformFlags3["ContainsES2022"] = 8] = "ContainsES2022";
|
|
TransformFlags3[TransformFlags3["ContainsES2021"] = 16] = "ContainsES2021";
|
|
TransformFlags3[TransformFlags3["ContainsES2020"] = 32] = "ContainsES2020";
|
|
TransformFlags3[TransformFlags3["ContainsES2019"] = 64] = "ContainsES2019";
|
|
TransformFlags3[TransformFlags3["ContainsES2018"] = 128] = "ContainsES2018";
|
|
TransformFlags3[TransformFlags3["ContainsES2017"] = 256] = "ContainsES2017";
|
|
TransformFlags3[TransformFlags3["ContainsES2016"] = 512] = "ContainsES2016";
|
|
TransformFlags3[TransformFlags3["ContainsES2015"] = 1024] = "ContainsES2015";
|
|
TransformFlags3[TransformFlags3["ContainsGenerator"] = 2048] = "ContainsGenerator";
|
|
TransformFlags3[TransformFlags3["ContainsDestructuringAssignment"] = 4096] = "ContainsDestructuringAssignment";
|
|
TransformFlags3[TransformFlags3["ContainsTypeScriptClassSyntax"] = 8192] = "ContainsTypeScriptClassSyntax";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalThis"] = 16384] = "ContainsLexicalThis";
|
|
TransformFlags3[TransformFlags3["ContainsRestOrSpread"] = 32768] = "ContainsRestOrSpread";
|
|
TransformFlags3[TransformFlags3["ContainsObjectRestOrSpread"] = 65536] = "ContainsObjectRestOrSpread";
|
|
TransformFlags3[TransformFlags3["ContainsComputedPropertyName"] = 131072] = "ContainsComputedPropertyName";
|
|
TransformFlags3[TransformFlags3["ContainsBlockScopedBinding"] = 262144] = "ContainsBlockScopedBinding";
|
|
TransformFlags3[TransformFlags3["ContainsBindingPattern"] = 524288] = "ContainsBindingPattern";
|
|
TransformFlags3[TransformFlags3["ContainsYield"] = 1048576] = "ContainsYield";
|
|
TransformFlags3[TransformFlags3["ContainsAwait"] = 2097152] = "ContainsAwait";
|
|
TransformFlags3[TransformFlags3["ContainsHoistedDeclarationOrCompletion"] = 4194304] = "ContainsHoistedDeclarationOrCompletion";
|
|
TransformFlags3[TransformFlags3["ContainsDynamicImport"] = 8388608] = "ContainsDynamicImport";
|
|
TransformFlags3[TransformFlags3["ContainsClassFields"] = 16777216] = "ContainsClassFields";
|
|
TransformFlags3[TransformFlags3["ContainsDecorators"] = 33554432] = "ContainsDecorators";
|
|
TransformFlags3[TransformFlags3["ContainsPossibleTopLevelAwait"] = 67108864] = "ContainsPossibleTopLevelAwait";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalSuper"] = 134217728] = "ContainsLexicalSuper";
|
|
TransformFlags3[TransformFlags3["ContainsUpdateExpressionForIdentifier"] = 268435456] = "ContainsUpdateExpressionForIdentifier";
|
|
TransformFlags3[TransformFlags3["ContainsPrivateIdentifierInExpression"] = 536870912] = "ContainsPrivateIdentifierInExpression";
|
|
TransformFlags3[TransformFlags3["HasComputedFlags"] = -2147483648] = "HasComputedFlags";
|
|
TransformFlags3[TransformFlags3["AssertTypeScript"] = 1 /* ContainsTypeScript */] = "AssertTypeScript";
|
|
TransformFlags3[TransformFlags3["AssertJsx"] = 2 /* ContainsJsx */] = "AssertJsx";
|
|
TransformFlags3[TransformFlags3["AssertESNext"] = 4 /* ContainsESNext */] = "AssertESNext";
|
|
TransformFlags3[TransformFlags3["AssertES2022"] = 8 /* ContainsES2022 */] = "AssertES2022";
|
|
TransformFlags3[TransformFlags3["AssertES2021"] = 16 /* ContainsES2021 */] = "AssertES2021";
|
|
TransformFlags3[TransformFlags3["AssertES2020"] = 32 /* ContainsES2020 */] = "AssertES2020";
|
|
TransformFlags3[TransformFlags3["AssertES2019"] = 64 /* ContainsES2019 */] = "AssertES2019";
|
|
TransformFlags3[TransformFlags3["AssertES2018"] = 128 /* ContainsES2018 */] = "AssertES2018";
|
|
TransformFlags3[TransformFlags3["AssertES2017"] = 256 /* ContainsES2017 */] = "AssertES2017";
|
|
TransformFlags3[TransformFlags3["AssertES2016"] = 512 /* ContainsES2016 */] = "AssertES2016";
|
|
TransformFlags3[TransformFlags3["AssertES2015"] = 1024 /* ContainsES2015 */] = "AssertES2015";
|
|
TransformFlags3[TransformFlags3["AssertGenerator"] = 2048 /* ContainsGenerator */] = "AssertGenerator";
|
|
TransformFlags3[TransformFlags3["AssertDestructuringAssignment"] = 4096 /* ContainsDestructuringAssignment */] = "AssertDestructuringAssignment";
|
|
TransformFlags3[TransformFlags3["OuterExpressionExcludes"] = -2147483648 /* HasComputedFlags */] = "OuterExpressionExcludes";
|
|
TransformFlags3[TransformFlags3["PropertyAccessExcludes"] = -2147483648 /* OuterExpressionExcludes */] = "PropertyAccessExcludes";
|
|
TransformFlags3[TransformFlags3["NodeExcludes"] = -2147483648 /* PropertyAccessExcludes */] = "NodeExcludes";
|
|
TransformFlags3[TransformFlags3["ArrowFunctionExcludes"] = -2072174592] = "ArrowFunctionExcludes";
|
|
TransformFlags3[TransformFlags3["FunctionExcludes"] = -1937940480] = "FunctionExcludes";
|
|
TransformFlags3[TransformFlags3["ConstructorExcludes"] = -1937948672] = "ConstructorExcludes";
|
|
TransformFlags3[TransformFlags3["MethodOrAccessorExcludes"] = -2005057536] = "MethodOrAccessorExcludes";
|
|
TransformFlags3[TransformFlags3["PropertyExcludes"] = -2013249536] = "PropertyExcludes";
|
|
TransformFlags3[TransformFlags3["ClassExcludes"] = -2147344384] = "ClassExcludes";
|
|
TransformFlags3[TransformFlags3["ModuleExcludes"] = -1941676032] = "ModuleExcludes";
|
|
TransformFlags3[TransformFlags3["TypeExcludes"] = -2] = "TypeExcludes";
|
|
TransformFlags3[TransformFlags3["ObjectLiteralExcludes"] = -2147278848] = "ObjectLiteralExcludes";
|
|
TransformFlags3[TransformFlags3["ArrayLiteralOrCallOrNewExcludes"] = -2147450880] = "ArrayLiteralOrCallOrNewExcludes";
|
|
TransformFlags3[TransformFlags3["VariableDeclarationListExcludes"] = -2146893824] = "VariableDeclarationListExcludes";
|
|
TransformFlags3[TransformFlags3["ParameterExcludes"] = -2147483648 /* NodeExcludes */] = "ParameterExcludes";
|
|
TransformFlags3[TransformFlags3["CatchClauseExcludes"] = -2147418112] = "CatchClauseExcludes";
|
|
TransformFlags3[TransformFlags3["BindingPatternExcludes"] = -2147450880] = "BindingPatternExcludes";
|
|
TransformFlags3[TransformFlags3["ContainsLexicalThisOrSuper"] = 134234112] = "ContainsLexicalThisOrSuper";
|
|
TransformFlags3[TransformFlags3["PropertyNamePropagatingFlags"] = 134234112] = "PropertyNamePropagatingFlags";
|
|
return TransformFlags3;
|
|
})(TransformFlags || {});
|
|
var SnippetKind = /* @__PURE__ */ ((SnippetKind3) => {
|
|
SnippetKind3[SnippetKind3["TabStop"] = 0] = "TabStop";
|
|
SnippetKind3[SnippetKind3["Placeholder"] = 1] = "Placeholder";
|
|
SnippetKind3[SnippetKind3["Choice"] = 2] = "Choice";
|
|
SnippetKind3[SnippetKind3["Variable"] = 3] = "Variable";
|
|
return SnippetKind3;
|
|
})(SnippetKind || {});
|
|
var EmitFlags = /* @__PURE__ */ ((EmitFlags3) => {
|
|
EmitFlags3[EmitFlags3["None"] = 0] = "None";
|
|
EmitFlags3[EmitFlags3["SingleLine"] = 1] = "SingleLine";
|
|
EmitFlags3[EmitFlags3["MultiLine"] = 2] = "MultiLine";
|
|
EmitFlags3[EmitFlags3["AdviseOnEmitNode"] = 4] = "AdviseOnEmitNode";
|
|
EmitFlags3[EmitFlags3["NoSubstitution"] = 8] = "NoSubstitution";
|
|
EmitFlags3[EmitFlags3["CapturesThis"] = 16] = "CapturesThis";
|
|
EmitFlags3[EmitFlags3["NoLeadingSourceMap"] = 32] = "NoLeadingSourceMap";
|
|
EmitFlags3[EmitFlags3["NoTrailingSourceMap"] = 64] = "NoTrailingSourceMap";
|
|
EmitFlags3[EmitFlags3["NoSourceMap"] = 96] = "NoSourceMap";
|
|
EmitFlags3[EmitFlags3["NoNestedSourceMaps"] = 128] = "NoNestedSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenLeadingSourceMaps"] = 256] = "NoTokenLeadingSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenTrailingSourceMaps"] = 512] = "NoTokenTrailingSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoTokenSourceMaps"] = 768] = "NoTokenSourceMaps";
|
|
EmitFlags3[EmitFlags3["NoLeadingComments"] = 1024] = "NoLeadingComments";
|
|
EmitFlags3[EmitFlags3["NoTrailingComments"] = 2048] = "NoTrailingComments";
|
|
EmitFlags3[EmitFlags3["NoComments"] = 3072] = "NoComments";
|
|
EmitFlags3[EmitFlags3["NoNestedComments"] = 4096] = "NoNestedComments";
|
|
EmitFlags3[EmitFlags3["HelperName"] = 8192] = "HelperName";
|
|
EmitFlags3[EmitFlags3["ExportName"] = 16384] = "ExportName";
|
|
EmitFlags3[EmitFlags3["LocalName"] = 32768] = "LocalName";
|
|
EmitFlags3[EmitFlags3["InternalName"] = 65536] = "InternalName";
|
|
EmitFlags3[EmitFlags3["Indented"] = 131072] = "Indented";
|
|
EmitFlags3[EmitFlags3["NoIndentation"] = 262144] = "NoIndentation";
|
|
EmitFlags3[EmitFlags3["AsyncFunctionBody"] = 524288] = "AsyncFunctionBody";
|
|
EmitFlags3[EmitFlags3["ReuseTempVariableScope"] = 1048576] = "ReuseTempVariableScope";
|
|
EmitFlags3[EmitFlags3["CustomPrologue"] = 2097152] = "CustomPrologue";
|
|
EmitFlags3[EmitFlags3["NoHoisting"] = 4194304] = "NoHoisting";
|
|
EmitFlags3[EmitFlags3["HasEndOfDeclarationMarker"] = 8388608] = "HasEndOfDeclarationMarker";
|
|
EmitFlags3[EmitFlags3["Iterator"] = 16777216] = "Iterator";
|
|
EmitFlags3[EmitFlags3["NoAsciiEscaping"] = 33554432] = "NoAsciiEscaping";
|
|
EmitFlags3[EmitFlags3["TypeScriptClassWrapper"] = 67108864] = "TypeScriptClassWrapper";
|
|
EmitFlags3[EmitFlags3["NeverApplyImportHelper"] = 134217728] = "NeverApplyImportHelper";
|
|
EmitFlags3[EmitFlags3["IgnoreSourceNewlines"] = 268435456] = "IgnoreSourceNewlines";
|
|
EmitFlags3[EmitFlags3["Immutable"] = 536870912] = "Immutable";
|
|
EmitFlags3[EmitFlags3["IndirectCall"] = 1073741824] = "IndirectCall";
|
|
return EmitFlags3;
|
|
})(EmitFlags || {});
|
|
var ExternalEmitHelpers = /* @__PURE__ */ ((ExternalEmitHelpers2) => {
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Extends"] = 1] = "Extends";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Assign"] = 2] = "Assign";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Rest"] = 4] = "Rest";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Decorate"] = 8] = "Decorate";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Metadata"] = 16] = "Metadata";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Param"] = 32] = "Param";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Awaiter"] = 64] = "Awaiter";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Generator"] = 128] = "Generator";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Values"] = 256] = "Values";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Read"] = 512] = "Read";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["SpreadArray"] = 1024] = "SpreadArray";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["Await"] = 2048] = "Await";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["AsyncGenerator"] = 4096] = "AsyncGenerator";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["AsyncDelegator"] = 8192] = "AsyncDelegator";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["AsyncValues"] = 16384] = "AsyncValues";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ExportStar"] = 32768] = "ExportStar";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ImportStar"] = 65536] = "ImportStar";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ImportDefault"] = 131072] = "ImportDefault";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["MakeTemplateObject"] = 262144] = "MakeTemplateObject";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ClassPrivateFieldGet"] = 524288] = "ClassPrivateFieldGet";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ClassPrivateFieldSet"] = 1048576] = "ClassPrivateFieldSet";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ClassPrivateFieldIn"] = 2097152] = "ClassPrivateFieldIn";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["CreateBinding"] = 4194304] = "CreateBinding";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["FirstEmitHelper"] = 1 /* Extends */] = "FirstEmitHelper";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["LastEmitHelper"] = 4194304 /* CreateBinding */] = "LastEmitHelper";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ForOfIncludes"] = 256 /* Values */] = "ForOfIncludes";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["ForAwaitOfIncludes"] = 16384 /* AsyncValues */] = "ForAwaitOfIncludes";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["AsyncGeneratorIncludes"] = 6144] = "AsyncGeneratorIncludes";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["AsyncDelegatorIncludes"] = 26624] = "AsyncDelegatorIncludes";
|
|
ExternalEmitHelpers2[ExternalEmitHelpers2["SpreadIncludes"] = 1536] = "SpreadIncludes";
|
|
return ExternalEmitHelpers2;
|
|
})(ExternalEmitHelpers || {});
|
|
var EmitHint = /* @__PURE__ */ ((EmitHint6) => {
|
|
EmitHint6[EmitHint6["SourceFile"] = 0] = "SourceFile";
|
|
EmitHint6[EmitHint6["Expression"] = 1] = "Expression";
|
|
EmitHint6[EmitHint6["IdentifierName"] = 2] = "IdentifierName";
|
|
EmitHint6[EmitHint6["MappedTypeParameter"] = 3] = "MappedTypeParameter";
|
|
EmitHint6[EmitHint6["Unspecified"] = 4] = "Unspecified";
|
|
EmitHint6[EmitHint6["EmbeddedStatement"] = 5] = "EmbeddedStatement";
|
|
EmitHint6[EmitHint6["JsxAttributeValue"] = 6] = "JsxAttributeValue";
|
|
return EmitHint6;
|
|
})(EmitHint || {});
|
|
var OuterExpressionKinds = /* @__PURE__ */ ((OuterExpressionKinds2) => {
|
|
OuterExpressionKinds2[OuterExpressionKinds2["Parentheses"] = 1] = "Parentheses";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["TypeAssertions"] = 2] = "TypeAssertions";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["NonNullAssertions"] = 4] = "NonNullAssertions";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["PartiallyEmittedExpressions"] = 8] = "PartiallyEmittedExpressions";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["Assertions"] = 6] = "Assertions";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["All"] = 15] = "All";
|
|
OuterExpressionKinds2[OuterExpressionKinds2["ExcludeJSDocTypeAssertion"] = 16] = "ExcludeJSDocTypeAssertion";
|
|
return OuterExpressionKinds2;
|
|
})(OuterExpressionKinds || {});
|
|
var LexicalEnvironmentFlags = /* @__PURE__ */ ((LexicalEnvironmentFlags2) => {
|
|
LexicalEnvironmentFlags2[LexicalEnvironmentFlags2["None"] = 0] = "None";
|
|
LexicalEnvironmentFlags2[LexicalEnvironmentFlags2["InParameters"] = 1] = "InParameters";
|
|
LexicalEnvironmentFlags2[LexicalEnvironmentFlags2["VariablesHoistedInParameters"] = 2] = "VariablesHoistedInParameters";
|
|
return LexicalEnvironmentFlags2;
|
|
})(LexicalEnvironmentFlags || {});
|
|
var BundleFileSectionKind = /* @__PURE__ */ ((BundleFileSectionKind2) => {
|
|
BundleFileSectionKind2["Prologue"] = "prologue";
|
|
BundleFileSectionKind2["EmitHelpers"] = "emitHelpers";
|
|
BundleFileSectionKind2["NoDefaultLib"] = "no-default-lib";
|
|
BundleFileSectionKind2["Reference"] = "reference";
|
|
BundleFileSectionKind2["Type"] = "type";
|
|
BundleFileSectionKind2["TypeResolutionModeRequire"] = "type-require";
|
|
BundleFileSectionKind2["TypeResolutionModeImport"] = "type-import";
|
|
BundleFileSectionKind2["Lib"] = "lib";
|
|
BundleFileSectionKind2["Prepend"] = "prepend";
|
|
BundleFileSectionKind2["Text"] = "text";
|
|
BundleFileSectionKind2["Internal"] = "internal";
|
|
return BundleFileSectionKind2;
|
|
})(BundleFileSectionKind || {});
|
|
var ListFormat = /* @__PURE__ */ ((ListFormat2) => {
|
|
ListFormat2[ListFormat2["None"] = 0] = "None";
|
|
ListFormat2[ListFormat2["SingleLine"] = 0] = "SingleLine";
|
|
ListFormat2[ListFormat2["MultiLine"] = 1] = "MultiLine";
|
|
ListFormat2[ListFormat2["PreserveLines"] = 2] = "PreserveLines";
|
|
ListFormat2[ListFormat2["LinesMask"] = 3] = "LinesMask";
|
|
ListFormat2[ListFormat2["NotDelimited"] = 0] = "NotDelimited";
|
|
ListFormat2[ListFormat2["BarDelimited"] = 4] = "BarDelimited";
|
|
ListFormat2[ListFormat2["AmpersandDelimited"] = 8] = "AmpersandDelimited";
|
|
ListFormat2[ListFormat2["CommaDelimited"] = 16] = "CommaDelimited";
|
|
ListFormat2[ListFormat2["AsteriskDelimited"] = 32] = "AsteriskDelimited";
|
|
ListFormat2[ListFormat2["DelimitersMask"] = 60] = "DelimitersMask";
|
|
ListFormat2[ListFormat2["AllowTrailingComma"] = 64] = "AllowTrailingComma";
|
|
ListFormat2[ListFormat2["Indented"] = 128] = "Indented";
|
|
ListFormat2[ListFormat2["SpaceBetweenBraces"] = 256] = "SpaceBetweenBraces";
|
|
ListFormat2[ListFormat2["SpaceBetweenSiblings"] = 512] = "SpaceBetweenSiblings";
|
|
ListFormat2[ListFormat2["Braces"] = 1024] = "Braces";
|
|
ListFormat2[ListFormat2["Parenthesis"] = 2048] = "Parenthesis";
|
|
ListFormat2[ListFormat2["AngleBrackets"] = 4096] = "AngleBrackets";
|
|
ListFormat2[ListFormat2["SquareBrackets"] = 8192] = "SquareBrackets";
|
|
ListFormat2[ListFormat2["BracketsMask"] = 15360] = "BracketsMask";
|
|
ListFormat2[ListFormat2["OptionalIfUndefined"] = 16384] = "OptionalIfUndefined";
|
|
ListFormat2[ListFormat2["OptionalIfEmpty"] = 32768] = "OptionalIfEmpty";
|
|
ListFormat2[ListFormat2["Optional"] = 49152] = "Optional";
|
|
ListFormat2[ListFormat2["PreferNewLine"] = 65536] = "PreferNewLine";
|
|
ListFormat2[ListFormat2["NoTrailingNewLine"] = 131072] = "NoTrailingNewLine";
|
|
ListFormat2[ListFormat2["NoInterveningComments"] = 262144] = "NoInterveningComments";
|
|
ListFormat2[ListFormat2["NoSpaceIfEmpty"] = 524288] = "NoSpaceIfEmpty";
|
|
ListFormat2[ListFormat2["SingleElement"] = 1048576] = "SingleElement";
|
|
ListFormat2[ListFormat2["SpaceAfterList"] = 2097152] = "SpaceAfterList";
|
|
ListFormat2[ListFormat2["Modifiers"] = 2359808] = "Modifiers";
|
|
ListFormat2[ListFormat2["HeritageClauses"] = 512] = "HeritageClauses";
|
|
ListFormat2[ListFormat2["SingleLineTypeLiteralMembers"] = 768] = "SingleLineTypeLiteralMembers";
|
|
ListFormat2[ListFormat2["MultiLineTypeLiteralMembers"] = 32897] = "MultiLineTypeLiteralMembers";
|
|
ListFormat2[ListFormat2["SingleLineTupleTypeElements"] = 528] = "SingleLineTupleTypeElements";
|
|
ListFormat2[ListFormat2["MultiLineTupleTypeElements"] = 657] = "MultiLineTupleTypeElements";
|
|
ListFormat2[ListFormat2["UnionTypeConstituents"] = 516] = "UnionTypeConstituents";
|
|
ListFormat2[ListFormat2["IntersectionTypeConstituents"] = 520] = "IntersectionTypeConstituents";
|
|
ListFormat2[ListFormat2["ObjectBindingPatternElements"] = 525136] = "ObjectBindingPatternElements";
|
|
ListFormat2[ListFormat2["ArrayBindingPatternElements"] = 524880] = "ArrayBindingPatternElements";
|
|
ListFormat2[ListFormat2["ObjectLiteralExpressionProperties"] = 526226] = "ObjectLiteralExpressionProperties";
|
|
ListFormat2[ListFormat2["ImportClauseEntries"] = 526226] = "ImportClauseEntries";
|
|
ListFormat2[ListFormat2["ArrayLiteralExpressionElements"] = 8914] = "ArrayLiteralExpressionElements";
|
|
ListFormat2[ListFormat2["CommaListElements"] = 528] = "CommaListElements";
|
|
ListFormat2[ListFormat2["CallExpressionArguments"] = 2576] = "CallExpressionArguments";
|
|
ListFormat2[ListFormat2["NewExpressionArguments"] = 18960] = "NewExpressionArguments";
|
|
ListFormat2[ListFormat2["TemplateExpressionSpans"] = 262144] = "TemplateExpressionSpans";
|
|
ListFormat2[ListFormat2["SingleLineBlockStatements"] = 768] = "SingleLineBlockStatements";
|
|
ListFormat2[ListFormat2["MultiLineBlockStatements"] = 129] = "MultiLineBlockStatements";
|
|
ListFormat2[ListFormat2["VariableDeclarationList"] = 528] = "VariableDeclarationList";
|
|
ListFormat2[ListFormat2["SingleLineFunctionBodyStatements"] = 768] = "SingleLineFunctionBodyStatements";
|
|
ListFormat2[ListFormat2["MultiLineFunctionBodyStatements"] = 1 /* MultiLine */] = "MultiLineFunctionBodyStatements";
|
|
ListFormat2[ListFormat2["ClassHeritageClauses"] = 0 /* SingleLine */] = "ClassHeritageClauses";
|
|
ListFormat2[ListFormat2["ClassMembers"] = 129] = "ClassMembers";
|
|
ListFormat2[ListFormat2["InterfaceMembers"] = 129] = "InterfaceMembers";
|
|
ListFormat2[ListFormat2["EnumMembers"] = 145] = "EnumMembers";
|
|
ListFormat2[ListFormat2["CaseBlockClauses"] = 129] = "CaseBlockClauses";
|
|
ListFormat2[ListFormat2["NamedImportsOrExportsElements"] = 525136] = "NamedImportsOrExportsElements";
|
|
ListFormat2[ListFormat2["JsxElementOrFragmentChildren"] = 262144] = "JsxElementOrFragmentChildren";
|
|
ListFormat2[ListFormat2["JsxElementAttributes"] = 262656] = "JsxElementAttributes";
|
|
ListFormat2[ListFormat2["CaseOrDefaultClauseStatements"] = 163969] = "CaseOrDefaultClauseStatements";
|
|
ListFormat2[ListFormat2["HeritageClauseTypes"] = 528] = "HeritageClauseTypes";
|
|
ListFormat2[ListFormat2["SourceFileStatements"] = 131073] = "SourceFileStatements";
|
|
ListFormat2[ListFormat2["Decorators"] = 2146305] = "Decorators";
|
|
ListFormat2[ListFormat2["TypeArguments"] = 53776] = "TypeArguments";
|
|
ListFormat2[ListFormat2["TypeParameters"] = 53776] = "TypeParameters";
|
|
ListFormat2[ListFormat2["Parameters"] = 2576] = "Parameters";
|
|
ListFormat2[ListFormat2["IndexSignatureParameters"] = 8848] = "IndexSignatureParameters";
|
|
ListFormat2[ListFormat2["JSDocComment"] = 33] = "JSDocComment";
|
|
return ListFormat2;
|
|
})(ListFormat || {});
|
|
var PragmaKindFlags = /* @__PURE__ */ ((PragmaKindFlags2) => {
|
|
PragmaKindFlags2[PragmaKindFlags2["None"] = 0] = "None";
|
|
PragmaKindFlags2[PragmaKindFlags2["TripleSlashXML"] = 1] = "TripleSlashXML";
|
|
PragmaKindFlags2[PragmaKindFlags2["SingleLine"] = 2] = "SingleLine";
|
|
PragmaKindFlags2[PragmaKindFlags2["MultiLine"] = 4] = "MultiLine";
|
|
PragmaKindFlags2[PragmaKindFlags2["All"] = 7] = "All";
|
|
PragmaKindFlags2[PragmaKindFlags2["Default"] = 7 /* All */] = "Default";
|
|
return PragmaKindFlags2;
|
|
})(PragmaKindFlags || {});
|
|
var commentPragmas = {
|
|
"reference": {
|
|
args: [
|
|
{ name: "types", optional: true, captureSpan: true },
|
|
{ name: "lib", optional: true, captureSpan: true },
|
|
{ name: "path", optional: true, captureSpan: true },
|
|
{ name: "no-default-lib", optional: true },
|
|
{ name: "resolution-mode", optional: true }
|
|
],
|
|
kind: 1 /* TripleSlashXML */
|
|
},
|
|
"amd-dependency": {
|
|
args: [{ name: "path" }, { name: "name", optional: true }],
|
|
kind: 1 /* TripleSlashXML */
|
|
},
|
|
"amd-module": {
|
|
args: [{ name: "name" }],
|
|
kind: 1 /* TripleSlashXML */
|
|
},
|
|
"ts-check": {
|
|
kind: 2 /* SingleLine */
|
|
},
|
|
"ts-nocheck": {
|
|
kind: 2 /* SingleLine */
|
|
},
|
|
"jsx": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsxfrag": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsximportsource": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
},
|
|
"jsxruntime": {
|
|
args: [{ name: "factory" }],
|
|
kind: 4 /* MultiLine */
|
|
}
|
|
};
|
|
|
|
// src/compiler/sys.ts
|
|
function generateDjb2Hash(data) {
|
|
let acc = 5381;
|
|
for (let i = 0; i < data.length; i++) {
|
|
acc = (acc << 5) + acc + data.charCodeAt(i);
|
|
}
|
|
return acc.toString();
|
|
}
|
|
function setStackTraceLimit() {
|
|
if (Error.stackTraceLimit < 100) {
|
|
Error.stackTraceLimit = 100;
|
|
}
|
|
}
|
|
var FileWatcherEventKind = /* @__PURE__ */ ((FileWatcherEventKind2) => {
|
|
FileWatcherEventKind2[FileWatcherEventKind2["Created"] = 0] = "Created";
|
|
FileWatcherEventKind2[FileWatcherEventKind2["Changed"] = 1] = "Changed";
|
|
FileWatcherEventKind2[FileWatcherEventKind2["Deleted"] = 2] = "Deleted";
|
|
return FileWatcherEventKind2;
|
|
})(FileWatcherEventKind || {});
|
|
var PollingInterval = /* @__PURE__ */ ((PollingInterval3) => {
|
|
PollingInterval3[PollingInterval3["High"] = 2e3] = "High";
|
|
PollingInterval3[PollingInterval3["Medium"] = 500] = "Medium";
|
|
PollingInterval3[PollingInterval3["Low"] = 250] = "Low";
|
|
return PollingInterval3;
|
|
})(PollingInterval || {});
|
|
var missingFileModifiedTime = new Date(0);
|
|
function getModifiedTime(host, fileName) {
|
|
return host.getModifiedTime(fileName) || missingFileModifiedTime;
|
|
}
|
|
function createPollingIntervalBasedLevels(levels) {
|
|
return {
|
|
[250 /* Low */]: levels.Low,
|
|
[500 /* Medium */]: levels.Medium,
|
|
[2e3 /* High */]: levels.High
|
|
};
|
|
}
|
|
var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 };
|
|
var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels);
|
|
var unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
|
|
function setCustomPollingValues(system) {
|
|
if (!system.getEnvironmentVariable) {
|
|
return;
|
|
}
|
|
const pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval);
|
|
pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize;
|
|
unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || unchangedPollThresholds;
|
|
function getLevel(envVar, level) {
|
|
return system.getEnvironmentVariable(`${envVar}_${level.toUpperCase()}`);
|
|
}
|
|
function getCustomLevels(baseVariable) {
|
|
let customLevels;
|
|
setCustomLevel("Low");
|
|
setCustomLevel("Medium");
|
|
setCustomLevel("High");
|
|
return customLevels;
|
|
function setCustomLevel(level) {
|
|
const customLevel = getLevel(baseVariable, level);
|
|
if (customLevel) {
|
|
(customLevels || (customLevels = {}))[level] = Number(customLevel);
|
|
}
|
|
}
|
|
}
|
|
function setCustomLevels(baseVariable, levels) {
|
|
const customLevels = getCustomLevels(baseVariable);
|
|
if (customLevels) {
|
|
setLevel("Low");
|
|
setLevel("Medium");
|
|
setLevel("High");
|
|
return true;
|
|
}
|
|
return false;
|
|
function setLevel(level) {
|
|
levels[level] = customLevels[level] || levels[level];
|
|
}
|
|
}
|
|
function getCustomPollingBasedLevels(baseVariable, defaultLevels) {
|
|
const customLevels = getCustomLevels(baseVariable);
|
|
return (pollingIntervalChanged || customLevels) && createPollingIntervalBasedLevels(customLevels ? { ...defaultLevels, ...customLevels } : defaultLevels);
|
|
}
|
|
}
|
|
function pollWatchedFileQueue(host, queue, pollIndex, chunkSize, callbackOnWatchFileStat) {
|
|
let definedValueCopyToIndex = pollIndex;
|
|
for (let canVisit = queue.length; chunkSize && canVisit; nextPollIndex(), canVisit--) {
|
|
const watchedFile = queue[pollIndex];
|
|
if (!watchedFile) {
|
|
continue;
|
|
} else if (watchedFile.isClosed) {
|
|
queue[pollIndex] = void 0;
|
|
continue;
|
|
}
|
|
chunkSize--;
|
|
const fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(host, watchedFile.fileName));
|
|
if (watchedFile.isClosed) {
|
|
queue[pollIndex] = void 0;
|
|
continue;
|
|
}
|
|
callbackOnWatchFileStat == null ? void 0 : callbackOnWatchFileStat(watchedFile, pollIndex, fileChanged);
|
|
if (queue[pollIndex]) {
|
|
if (definedValueCopyToIndex < pollIndex) {
|
|
queue[definedValueCopyToIndex] = watchedFile;
|
|
queue[pollIndex] = void 0;
|
|
}
|
|
definedValueCopyToIndex++;
|
|
}
|
|
}
|
|
return pollIndex;
|
|
function nextPollIndex() {
|
|
pollIndex++;
|
|
if (pollIndex === queue.length) {
|
|
if (definedValueCopyToIndex < pollIndex) {
|
|
queue.length = definedValueCopyToIndex;
|
|
}
|
|
pollIndex = 0;
|
|
definedValueCopyToIndex = 0;
|
|
}
|
|
}
|
|
}
|
|
function createDynamicPriorityPollingWatchFile(host) {
|
|
const watchedFiles = [];
|
|
const changedFilesInLastPoll = [];
|
|
const lowPollingIntervalQueue = createPollingIntervalQueue(250 /* Low */);
|
|
const mediumPollingIntervalQueue = createPollingIntervalQueue(500 /* Medium */);
|
|
const highPollingIntervalQueue = createPollingIntervalQueue(2e3 /* High */);
|
|
return watchFile2;
|
|
function watchFile2(fileName, callback, defaultPollingInterval) {
|
|
const file = {
|
|
fileName,
|
|
callback,
|
|
unchangedPolls: 0,
|
|
mtime: getModifiedTime(host, fileName)
|
|
};
|
|
watchedFiles.push(file);
|
|
addToPollingIntervalQueue(file, defaultPollingInterval);
|
|
return {
|
|
close: () => {
|
|
file.isClosed = true;
|
|
unorderedRemoveItem(watchedFiles, file);
|
|
}
|
|
};
|
|
}
|
|
function createPollingIntervalQueue(pollingInterval) {
|
|
const queue = [];
|
|
queue.pollingInterval = pollingInterval;
|
|
queue.pollIndex = 0;
|
|
queue.pollScheduled = false;
|
|
return queue;
|
|
}
|
|
function pollPollingIntervalQueue(queue) {
|
|
queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]);
|
|
if (queue.length) {
|
|
scheduleNextPoll(queue.pollingInterval);
|
|
} else {
|
|
Debug.assert(queue.pollIndex === 0);
|
|
queue.pollScheduled = false;
|
|
}
|
|
}
|
|
function pollLowPollingIntervalQueue(queue) {
|
|
pollQueue(changedFilesInLastPoll, 250 /* Low */, 0, changedFilesInLastPoll.length);
|
|
pollPollingIntervalQueue(queue);
|
|
if (!queue.pollScheduled && changedFilesInLastPoll.length) {
|
|
scheduleNextPoll(250 /* Low */);
|
|
}
|
|
}
|
|
function pollQueue(queue, pollingInterval, pollIndex, chunkSize) {
|
|
return pollWatchedFileQueue(
|
|
host,
|
|
queue,
|
|
pollIndex,
|
|
chunkSize,
|
|
onWatchFileStat
|
|
);
|
|
function onWatchFileStat(watchedFile, pollIndex2, fileChanged) {
|
|
if (fileChanged) {
|
|
watchedFile.unchangedPolls = 0;
|
|
if (queue !== changedFilesInLastPoll) {
|
|
queue[pollIndex2] = void 0;
|
|
addChangedFileToLowPollingIntervalQueue(watchedFile);
|
|
}
|
|
} else if (watchedFile.unchangedPolls !== unchangedPollThresholds[pollingInterval]) {
|
|
watchedFile.unchangedPolls++;
|
|
} else if (queue === changedFilesInLastPoll) {
|
|
watchedFile.unchangedPolls = 1;
|
|
queue[pollIndex2] = void 0;
|
|
addToPollingIntervalQueue(watchedFile, 250 /* Low */);
|
|
} else if (pollingInterval !== 2e3 /* High */) {
|
|
watchedFile.unchangedPolls++;
|
|
queue[pollIndex2] = void 0;
|
|
addToPollingIntervalQueue(watchedFile, pollingInterval === 250 /* Low */ ? 500 /* Medium */ : 2e3 /* High */);
|
|
}
|
|
}
|
|
}
|
|
function pollingIntervalQueue(pollingInterval) {
|
|
switch (pollingInterval) {
|
|
case 250 /* Low */:
|
|
return lowPollingIntervalQueue;
|
|
case 500 /* Medium */:
|
|
return mediumPollingIntervalQueue;
|
|
case 2e3 /* High */:
|
|
return highPollingIntervalQueue;
|
|
}
|
|
}
|
|
function addToPollingIntervalQueue(file, pollingInterval) {
|
|
pollingIntervalQueue(pollingInterval).push(file);
|
|
scheduleNextPollIfNotAlreadyScheduled(pollingInterval);
|
|
}
|
|
function addChangedFileToLowPollingIntervalQueue(file) {
|
|
changedFilesInLastPoll.push(file);
|
|
scheduleNextPollIfNotAlreadyScheduled(250 /* Low */);
|
|
}
|
|
function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) {
|
|
if (!pollingIntervalQueue(pollingInterval).pollScheduled) {
|
|
scheduleNextPoll(pollingInterval);
|
|
}
|
|
}
|
|
function scheduleNextPoll(pollingInterval) {
|
|
pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === 250 /* Low */ ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval));
|
|
}
|
|
}
|
|
function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) {
|
|
const fileWatcherCallbacks = createMultiMap();
|
|
const dirWatchers = /* @__PURE__ */ new Map();
|
|
const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return nonPollingWatchFile;
|
|
function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) {
|
|
const filePath = toCanonicalName(fileName);
|
|
fileWatcherCallbacks.add(filePath, callback);
|
|
const dirPath = getDirectoryPath(filePath) || ".";
|
|
const watcher = dirWatchers.get(dirPath) || createDirectoryWatcher(getDirectoryPath(fileName) || ".", dirPath, fallbackOptions);
|
|
watcher.referenceCount++;
|
|
return {
|
|
close: () => {
|
|
if (watcher.referenceCount === 1) {
|
|
watcher.close();
|
|
dirWatchers.delete(dirPath);
|
|
} else {
|
|
watcher.referenceCount--;
|
|
}
|
|
fileWatcherCallbacks.remove(filePath, callback);
|
|
}
|
|
};
|
|
}
|
|
function createDirectoryWatcher(dirName, dirPath, fallbackOptions) {
|
|
const watcher = fsWatch(
|
|
dirName,
|
|
FileSystemEntryKind.Directory,
|
|
(_eventName, relativeFileName, modifiedTime) => {
|
|
if (!isString(relativeFileName))
|
|
return;
|
|
const fileName = getNormalizedAbsolutePath(relativeFileName, dirName);
|
|
const callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName));
|
|
if (callbacks) {
|
|
for (const fileCallback of callbacks) {
|
|
fileCallback(fileName, 1 /* Changed */, modifiedTime);
|
|
}
|
|
}
|
|
},
|
|
false,
|
|
500 /* Medium */,
|
|
fallbackOptions
|
|
);
|
|
watcher.referenceCount = 0;
|
|
dirWatchers.set(dirPath, watcher);
|
|
return watcher;
|
|
}
|
|
}
|
|
function createFixedChunkSizePollingWatchFile(host) {
|
|
const watchedFiles = [];
|
|
let pollIndex = 0;
|
|
let pollScheduled;
|
|
return watchFile2;
|
|
function watchFile2(fileName, callback) {
|
|
const file = {
|
|
fileName,
|
|
callback,
|
|
mtime: getModifiedTime(host, fileName)
|
|
};
|
|
watchedFiles.push(file);
|
|
scheduleNextPoll();
|
|
return {
|
|
close: () => {
|
|
file.isClosed = true;
|
|
unorderedRemoveItem(watchedFiles, file);
|
|
}
|
|
};
|
|
}
|
|
function pollQueue() {
|
|
pollScheduled = void 0;
|
|
pollIndex = pollWatchedFileQueue(host, watchedFiles, pollIndex, pollingChunkSize[250 /* Low */]);
|
|
scheduleNextPoll();
|
|
}
|
|
function scheduleNextPoll() {
|
|
if (!watchedFiles.length || pollScheduled)
|
|
return;
|
|
pollScheduled = host.setTimeout(pollQueue, 2e3 /* High */);
|
|
}
|
|
}
|
|
function createSingleWatcherPerName(cache, useCaseSensitiveFileNames, name, callback, createWatcher) {
|
|
const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
const path = toCanonicalFileName(name);
|
|
const existing = cache.get(path);
|
|
if (existing) {
|
|
existing.callbacks.push(callback);
|
|
} else {
|
|
cache.set(path, {
|
|
watcher: createWatcher((param1, param2, param3) => {
|
|
var _a2;
|
|
return (_a2 = cache.get(path)) == null ? void 0 : _a2.callbacks.slice().forEach((cb) => cb(param1, param2, param3));
|
|
}),
|
|
callbacks: [callback]
|
|
});
|
|
}
|
|
return {
|
|
close: () => {
|
|
const watcher = cache.get(path);
|
|
if (!watcher)
|
|
return;
|
|
if (!orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length)
|
|
return;
|
|
cache.delete(path);
|
|
closeFileWatcherOf(watcher);
|
|
}
|
|
};
|
|
}
|
|
function onWatchedFileStat(watchedFile, modifiedTime) {
|
|
const oldTime = watchedFile.mtime.getTime();
|
|
const newTime = modifiedTime.getTime();
|
|
if (oldTime !== newTime) {
|
|
watchedFile.mtime = modifiedTime;
|
|
watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime), modifiedTime);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getFileWatcherEventKind(oldTime, newTime) {
|
|
return oldTime === 0 ? 0 /* Created */ : newTime === 0 ? 2 /* Deleted */ : 1 /* Changed */;
|
|
}
|
|
var ignoredPaths = ["/node_modules/.", "/.git", "/.#"];
|
|
var curSysLog = noop;
|
|
function sysLog(s) {
|
|
return curSysLog(s);
|
|
}
|
|
function setSysLog(logger) {
|
|
curSysLog = logger;
|
|
}
|
|
function createDirectoryWatcherSupportingRecursive({
|
|
watchDirectory,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
getAccessibleSortedChildDirectories,
|
|
fileSystemEntryExists,
|
|
realpath,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2
|
|
}) {
|
|
const cache = /* @__PURE__ */ new Map();
|
|
const callbackCache = createMultiMap();
|
|
const cacheToUpdateChildWatches = /* @__PURE__ */ new Map();
|
|
let timerToUpdateChildWatches;
|
|
const filePathComparer = getStringComparer(!useCaseSensitiveFileNames);
|
|
const toCanonicalFilePath = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return (dirName, callback, recursive, options) => recursive ? createDirectoryWatcher(dirName, options, callback) : watchDirectory(dirName, callback, recursive, options);
|
|
function createDirectoryWatcher(dirName, options, callback) {
|
|
const dirPath = toCanonicalFilePath(dirName);
|
|
let directoryWatcher = cache.get(dirPath);
|
|
if (directoryWatcher) {
|
|
directoryWatcher.refCount++;
|
|
} else {
|
|
directoryWatcher = {
|
|
watcher: watchDirectory(dirName, (fileName) => {
|
|
if (isIgnoredPath(fileName, options))
|
|
return;
|
|
if (options == null ? void 0 : options.synchronousWatchDirectory) {
|
|
invokeCallbacks(dirPath, fileName);
|
|
updateChildWatches(dirName, dirPath, options);
|
|
} else {
|
|
nonSyncUpdateChildWatches(dirName, dirPath, fileName, options);
|
|
}
|
|
}, false, options),
|
|
refCount: 1,
|
|
childWatches: emptyArray
|
|
};
|
|
cache.set(dirPath, directoryWatcher);
|
|
updateChildWatches(dirName, dirPath, options);
|
|
}
|
|
const callbackToAdd = callback && { dirName, callback };
|
|
if (callbackToAdd) {
|
|
callbackCache.add(dirPath, callbackToAdd);
|
|
}
|
|
return {
|
|
dirName,
|
|
close: () => {
|
|
const directoryWatcher2 = Debug.checkDefined(cache.get(dirPath));
|
|
if (callbackToAdd)
|
|
callbackCache.remove(dirPath, callbackToAdd);
|
|
directoryWatcher2.refCount--;
|
|
if (directoryWatcher2.refCount)
|
|
return;
|
|
cache.delete(dirPath);
|
|
closeFileWatcherOf(directoryWatcher2);
|
|
directoryWatcher2.childWatches.forEach(closeFileWatcher);
|
|
}
|
|
};
|
|
}
|
|
function invokeCallbacks(dirPath, fileNameOrInvokeMap, fileNames) {
|
|
let fileName;
|
|
let invokeMap;
|
|
if (isString(fileNameOrInvokeMap)) {
|
|
fileName = fileNameOrInvokeMap;
|
|
} else {
|
|
invokeMap = fileNameOrInvokeMap;
|
|
}
|
|
callbackCache.forEach((callbacks, rootDirName) => {
|
|
if (invokeMap && invokeMap.get(rootDirName) === true)
|
|
return;
|
|
if (rootDirName === dirPath || startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === directorySeparator) {
|
|
if (invokeMap) {
|
|
if (fileNames) {
|
|
const existing = invokeMap.get(rootDirName);
|
|
if (existing) {
|
|
existing.push(...fileNames);
|
|
} else {
|
|
invokeMap.set(rootDirName, fileNames.slice());
|
|
}
|
|
} else {
|
|
invokeMap.set(rootDirName, true);
|
|
}
|
|
} else {
|
|
callbacks.forEach(({ callback }) => callback(fileName));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) {
|
|
const parentWatcher = cache.get(dirPath);
|
|
if (parentWatcher && fileSystemEntryExists(dirName, FileSystemEntryKind.Directory)) {
|
|
scheduleUpdateChildWatches(dirName, dirPath, fileName, options);
|
|
return;
|
|
}
|
|
invokeCallbacks(dirPath, fileName);
|
|
removeChildWatches(parentWatcher);
|
|
}
|
|
function scheduleUpdateChildWatches(dirName, dirPath, fileName, options) {
|
|
const existing = cacheToUpdateChildWatches.get(dirPath);
|
|
if (existing) {
|
|
existing.fileNames.push(fileName);
|
|
} else {
|
|
cacheToUpdateChildWatches.set(dirPath, { dirName, options, fileNames: [fileName] });
|
|
}
|
|
if (timerToUpdateChildWatches) {
|
|
clearTimeout2(timerToUpdateChildWatches);
|
|
timerToUpdateChildWatches = void 0;
|
|
}
|
|
timerToUpdateChildWatches = setTimeout2(onTimerToUpdateChildWatches, 1e3);
|
|
}
|
|
function onTimerToUpdateChildWatches() {
|
|
timerToUpdateChildWatches = void 0;
|
|
sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
|
|
const start2 = timestamp();
|
|
const invokeMap = /* @__PURE__ */ new Map();
|
|
while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
|
|
const result = cacheToUpdateChildWatches.entries().next();
|
|
Debug.assert(!result.done);
|
|
const { value: [dirPath, { dirName, options, fileNames }] } = result;
|
|
cacheToUpdateChildWatches.delete(dirPath);
|
|
const hasChanges = updateChildWatches(dirName, dirPath, options);
|
|
invokeCallbacks(dirPath, invokeMap, hasChanges ? void 0 : fileNames);
|
|
}
|
|
sysLog(`sysLog:: invokingWatchers:: Elapsed:: ${timestamp() - start2}ms:: ${cacheToUpdateChildWatches.size}`);
|
|
callbackCache.forEach((callbacks, rootDirName) => {
|
|
const existing = invokeMap.get(rootDirName);
|
|
if (existing) {
|
|
callbacks.forEach(({ callback, dirName }) => {
|
|
if (isArray(existing)) {
|
|
existing.forEach(callback);
|
|
} else {
|
|
callback(dirName);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
const elapsed = timestamp() - start2;
|
|
sysLog(`sysLog:: Elapsed:: ${elapsed}ms:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size} ${timerToUpdateChildWatches}`);
|
|
}
|
|
function removeChildWatches(parentWatcher) {
|
|
if (!parentWatcher)
|
|
return;
|
|
const existingChildWatches = parentWatcher.childWatches;
|
|
parentWatcher.childWatches = emptyArray;
|
|
for (const childWatcher of existingChildWatches) {
|
|
childWatcher.close();
|
|
removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName)));
|
|
}
|
|
}
|
|
function updateChildWatches(parentDir, parentDirPath, options) {
|
|
const parentWatcher = cache.get(parentDirPath);
|
|
if (!parentWatcher)
|
|
return false;
|
|
let newChildWatches;
|
|
const hasChanges = enumerateInsertsAndDeletes(
|
|
fileSystemEntryExists(parentDir, FileSystemEntryKind.Directory) ? mapDefined(getAccessibleSortedChildDirectories(parentDir), (child) => {
|
|
const childFullName = getNormalizedAbsolutePath(child, parentDir);
|
|
return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, normalizePath(realpath(childFullName))) === 0 /* EqualTo */ ? childFullName : void 0;
|
|
}) : emptyArray,
|
|
parentWatcher.childWatches,
|
|
(child, childWatcher) => filePathComparer(child, childWatcher.dirName),
|
|
createAndAddChildDirectoryWatcher,
|
|
closeFileWatcher,
|
|
addChildDirectoryWatcher
|
|
);
|
|
parentWatcher.childWatches = newChildWatches || emptyArray;
|
|
return hasChanges;
|
|
function createAndAddChildDirectoryWatcher(childName) {
|
|
const result = createDirectoryWatcher(childName, options);
|
|
addChildDirectoryWatcher(result);
|
|
}
|
|
function addChildDirectoryWatcher(childWatcher) {
|
|
(newChildWatches || (newChildWatches = [])).push(childWatcher);
|
|
}
|
|
}
|
|
function isIgnoredPath(path, options) {
|
|
return some(ignoredPaths, (searchPath) => isInPath(path, searchPath)) || isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory);
|
|
}
|
|
function isInPath(path, searchPath) {
|
|
if (stringContains(path, searchPath))
|
|
return true;
|
|
if (useCaseSensitiveFileNames)
|
|
return false;
|
|
return stringContains(toCanonicalFilePath(path), searchPath);
|
|
}
|
|
}
|
|
var FileSystemEntryKind = /* @__PURE__ */ ((FileSystemEntryKind2) => {
|
|
FileSystemEntryKind2[FileSystemEntryKind2["File"] = 0] = "File";
|
|
FileSystemEntryKind2[FileSystemEntryKind2["Directory"] = 1] = "Directory";
|
|
return FileSystemEntryKind2;
|
|
})(FileSystemEntryKind || {});
|
|
function createFileWatcherCallback(callback) {
|
|
return (_fileName, eventKind, modifiedTime) => callback(eventKind === 1 /* Changed */ ? "change" : "rename", "", modifiedTime);
|
|
}
|
|
function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime3) {
|
|
return (eventName, _relativeFileName, modifiedTime) => {
|
|
if (eventName === "rename") {
|
|
modifiedTime || (modifiedTime = getModifiedTime3(fileName) || missingFileModifiedTime);
|
|
callback(fileName, modifiedTime !== missingFileModifiedTime ? 0 /* Created */ : 2 /* Deleted */, modifiedTime);
|
|
} else {
|
|
callback(fileName, 1 /* Changed */, modifiedTime);
|
|
}
|
|
};
|
|
}
|
|
function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames, getCurrentDirectory) {
|
|
return ((options == null ? void 0 : options.excludeDirectories) || (options == null ? void 0 : options.excludeFiles)) && (matchesExclude(pathToCheck, options == null ? void 0 : options.excludeFiles, useCaseSensitiveFileNames, getCurrentDirectory()) || matchesExclude(pathToCheck, options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames, getCurrentDirectory()));
|
|
}
|
|
function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory) {
|
|
return (eventName, relativeFileName) => {
|
|
if (eventName === "rename") {
|
|
const fileName = !relativeFileName ? directoryName : normalizePath(combinePaths(directoryName, relativeFileName));
|
|
if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames, getCurrentDirectory)) {
|
|
callback(fileName);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function createSystemWatchFunctions({
|
|
pollingWatchFileWorker,
|
|
getModifiedTime: getModifiedTime3,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2,
|
|
fsWatchWorker,
|
|
fileSystemEntryExists,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fsSupportsRecursiveFsWatch,
|
|
getAccessibleSortedChildDirectories,
|
|
realpath,
|
|
tscWatchFile,
|
|
useNonPollingWatchers,
|
|
tscWatchDirectory,
|
|
inodeWatching,
|
|
sysLog: sysLog2
|
|
}) {
|
|
const pollingWatches = /* @__PURE__ */ new Map();
|
|
const fsWatches = /* @__PURE__ */ new Map();
|
|
const fsWatchesRecursive = /* @__PURE__ */ new Map();
|
|
let dynamicPollingWatchFile;
|
|
let fixedChunkSizePollingWatchFile;
|
|
let nonPollingWatchFile;
|
|
let hostRecursiveDirectoryWatcher;
|
|
let hitSystemWatcherLimit = false;
|
|
return {
|
|
watchFile: watchFile2,
|
|
watchDirectory
|
|
};
|
|
function watchFile2(fileName, callback, pollingInterval, options) {
|
|
options = updateOptionsForWatchFile(options, useNonPollingWatchers);
|
|
const watchFileKind = Debug.checkDefined(options.watchFile);
|
|
switch (watchFileKind) {
|
|
case 0 /* FixedPollingInterval */:
|
|
return pollingWatchFile(fileName, callback, 250 /* Low */, void 0);
|
|
case 1 /* PriorityPollingInterval */:
|
|
return pollingWatchFile(fileName, callback, pollingInterval, void 0);
|
|
case 2 /* DynamicPriorityPolling */:
|
|
return ensureDynamicPollingWatchFile()(fileName, callback, pollingInterval, void 0);
|
|
case 3 /* FixedChunkSizePolling */:
|
|
return ensureFixedChunkSizePollingWatchFile()(fileName, callback, void 0, void 0);
|
|
case 4 /* UseFsEvents */:
|
|
return fsWatch(
|
|
fileName,
|
|
0 /* File */,
|
|
createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime3),
|
|
false,
|
|
pollingInterval,
|
|
getFallbackOptions(options)
|
|
);
|
|
case 5 /* UseFsEventsOnParentDirectory */:
|
|
if (!nonPollingWatchFile) {
|
|
nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames);
|
|
}
|
|
return nonPollingWatchFile(fileName, callback, pollingInterval, getFallbackOptions(options));
|
|
default:
|
|
Debug.assertNever(watchFileKind);
|
|
}
|
|
}
|
|
function ensureDynamicPollingWatchFile() {
|
|
return dynamicPollingWatchFile || (dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime3, setTimeout: setTimeout2 }));
|
|
}
|
|
function ensureFixedChunkSizePollingWatchFile() {
|
|
return fixedChunkSizePollingWatchFile || (fixedChunkSizePollingWatchFile = createFixedChunkSizePollingWatchFile({ getModifiedTime: getModifiedTime3, setTimeout: setTimeout2 }));
|
|
}
|
|
function updateOptionsForWatchFile(options, useNonPollingWatchers2) {
|
|
if (options && options.watchFile !== void 0)
|
|
return options;
|
|
switch (tscWatchFile) {
|
|
case "PriorityPollingInterval":
|
|
return { watchFile: 1 /* PriorityPollingInterval */ };
|
|
case "DynamicPriorityPolling":
|
|
return { watchFile: 2 /* DynamicPriorityPolling */ };
|
|
case "UseFsEvents":
|
|
return generateWatchFileOptions(4 /* UseFsEvents */, 1 /* PriorityInterval */, options);
|
|
case "UseFsEventsWithFallbackDynamicPolling":
|
|
return generateWatchFileOptions(4 /* UseFsEvents */, 2 /* DynamicPriority */, options);
|
|
case "UseFsEventsOnParentDirectory":
|
|
useNonPollingWatchers2 = true;
|
|
default:
|
|
return useNonPollingWatchers2 ? generateWatchFileOptions(5 /* UseFsEventsOnParentDirectory */, 1 /* PriorityInterval */, options) : { watchFile: 4 /* UseFsEvents */ };
|
|
}
|
|
}
|
|
function generateWatchFileOptions(watchFile3, fallbackPolling, options) {
|
|
const defaultFallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchFile: watchFile3,
|
|
fallbackPolling: defaultFallbackPolling === void 0 ? fallbackPolling : defaultFallbackPolling
|
|
};
|
|
}
|
|
function watchDirectory(directoryName, callback, recursive, options) {
|
|
if (fsSupportsRecursiveFsWatch) {
|
|
return fsWatch(
|
|
directoryName,
|
|
1 /* Directory */,
|
|
createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
|
|
recursive,
|
|
500 /* Medium */,
|
|
getFallbackOptions(options)
|
|
);
|
|
}
|
|
if (!hostRecursiveDirectoryWatcher) {
|
|
hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fileSystemEntryExists,
|
|
getAccessibleSortedChildDirectories,
|
|
watchDirectory: nonRecursiveWatchDirectory,
|
|
realpath,
|
|
setTimeout: setTimeout2,
|
|
clearTimeout: clearTimeout2
|
|
});
|
|
}
|
|
return hostRecursiveDirectoryWatcher(directoryName, callback, recursive, options);
|
|
}
|
|
function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) {
|
|
Debug.assert(!recursive);
|
|
const watchDirectoryOptions = updateOptionsForWatchDirectory(options);
|
|
const watchDirectoryKind = Debug.checkDefined(watchDirectoryOptions.watchDirectory);
|
|
switch (watchDirectoryKind) {
|
|
case 1 /* FixedPollingInterval */:
|
|
return pollingWatchFile(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
500 /* Medium */,
|
|
void 0
|
|
);
|
|
case 2 /* DynamicPriorityPolling */:
|
|
return ensureDynamicPollingWatchFile()(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
500 /* Medium */,
|
|
void 0
|
|
);
|
|
case 3 /* FixedChunkSizePolling */:
|
|
return ensureFixedChunkSizePollingWatchFile()(
|
|
directoryName,
|
|
() => callback(directoryName),
|
|
void 0,
|
|
void 0
|
|
);
|
|
case 0 /* UseFsEvents */:
|
|
return fsWatch(
|
|
directoryName,
|
|
1 /* Directory */,
|
|
createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory),
|
|
recursive,
|
|
500 /* Medium */,
|
|
getFallbackOptions(watchDirectoryOptions)
|
|
);
|
|
default:
|
|
Debug.assertNever(watchDirectoryKind);
|
|
}
|
|
}
|
|
function updateOptionsForWatchDirectory(options) {
|
|
if (options && options.watchDirectory !== void 0)
|
|
return options;
|
|
switch (tscWatchDirectory) {
|
|
case "RecursiveDirectoryUsingFsWatchFile":
|
|
return { watchDirectory: 1 /* FixedPollingInterval */ };
|
|
case "RecursiveDirectoryUsingDynamicPriorityPolling":
|
|
return { watchDirectory: 2 /* DynamicPriorityPolling */ };
|
|
default:
|
|
const defaultFallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchDirectory: 0 /* UseFsEvents */,
|
|
fallbackPolling: defaultFallbackPolling !== void 0 ? defaultFallbackPolling : void 0
|
|
};
|
|
}
|
|
}
|
|
function pollingWatchFile(fileName, callback, pollingInterval, options) {
|
|
return createSingleWatcherPerName(
|
|
pollingWatches,
|
|
useCaseSensitiveFileNames,
|
|
fileName,
|
|
callback,
|
|
(cb) => pollingWatchFileWorker(fileName, cb, pollingInterval, options)
|
|
);
|
|
}
|
|
function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
|
|
return createSingleWatcherPerName(
|
|
recursive ? fsWatchesRecursive : fsWatches,
|
|
useCaseSensitiveFileNames,
|
|
fileOrDirectory,
|
|
callback,
|
|
(cb) => fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions)
|
|
);
|
|
}
|
|
function fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
|
|
let lastDirectoryPartWithDirectorySeparator;
|
|
let lastDirectoryPart;
|
|
if (inodeWatching) {
|
|
lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substring(fileOrDirectory.lastIndexOf(directorySeparator));
|
|
lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(directorySeparator.length);
|
|
}
|
|
let watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ? watchMissingFileSystemEntry() : watchPresentFileSystemEntry();
|
|
return {
|
|
close: () => {
|
|
if (watcher) {
|
|
watcher.close();
|
|
watcher = void 0;
|
|
}
|
|
}
|
|
};
|
|
function updateWatcher(createWatcher) {
|
|
if (watcher) {
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Changing watcher to ${createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing"}FileSystemEntryWatcher`);
|
|
watcher.close();
|
|
watcher = createWatcher();
|
|
}
|
|
}
|
|
function watchPresentFileSystemEntry() {
|
|
if (hitSystemWatcherLimit) {
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Defaulting to watchFile`);
|
|
return watchPresentFileSystemEntryWithFsWatchFile();
|
|
}
|
|
try {
|
|
const presentWatcher = fsWatchWorker(
|
|
fileOrDirectory,
|
|
recursive,
|
|
inodeWatching ? callbackChangingToMissingFileSystemEntry : callback
|
|
);
|
|
presentWatcher.on("error", () => {
|
|
callback("rename", "");
|
|
updateWatcher(watchMissingFileSystemEntry);
|
|
});
|
|
return presentWatcher;
|
|
} catch (e) {
|
|
hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC");
|
|
sysLog2(`sysLog:: ${fileOrDirectory}:: Changing to watchFile`);
|
|
return watchPresentFileSystemEntryWithFsWatchFile();
|
|
}
|
|
}
|
|
function callbackChangingToMissingFileSystemEntry(event, relativeName) {
|
|
let originalRelativeName;
|
|
if (relativeName && endsWith(relativeName, "~")) {
|
|
originalRelativeName = relativeName;
|
|
relativeName = relativeName.slice(0, relativeName.length - 1);
|
|
}
|
|
if (event === "rename" && (!relativeName || relativeName === lastDirectoryPart || endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) {
|
|
const modifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime;
|
|
if (originalRelativeName)
|
|
callback(event, originalRelativeName, modifiedTime);
|
|
callback(event, relativeName, modifiedTime);
|
|
if (inodeWatching) {
|
|
updateWatcher(modifiedTime === missingFileModifiedTime ? watchMissingFileSystemEntry : watchPresentFileSystemEntry);
|
|
} else if (modifiedTime === missingFileModifiedTime) {
|
|
updateWatcher(watchMissingFileSystemEntry);
|
|
}
|
|
} else {
|
|
if (originalRelativeName)
|
|
callback(event, originalRelativeName);
|
|
callback(event, relativeName);
|
|
}
|
|
}
|
|
function watchPresentFileSystemEntryWithFsWatchFile() {
|
|
return watchFile2(
|
|
fileOrDirectory,
|
|
createFileWatcherCallback(callback),
|
|
fallbackPollingInterval,
|
|
fallbackOptions
|
|
);
|
|
}
|
|
function watchMissingFileSystemEntry() {
|
|
return watchFile2(
|
|
fileOrDirectory,
|
|
(_fileName, eventKind, modifiedTime) => {
|
|
if (eventKind === 0 /* Created */) {
|
|
modifiedTime || (modifiedTime = getModifiedTime3(fileOrDirectory) || missingFileModifiedTime);
|
|
if (modifiedTime !== missingFileModifiedTime) {
|
|
callback("rename", "", modifiedTime);
|
|
updateWatcher(watchPresentFileSystemEntry);
|
|
}
|
|
}
|
|
},
|
|
fallbackPollingInterval,
|
|
fallbackOptions
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function patchWriteFileEnsuringDirectory(sys2) {
|
|
const originalWriteFile = sys2.writeFile;
|
|
sys2.writeFile = (path, data, writeBom) => writeFileEnsuringDirectories(
|
|
path,
|
|
data,
|
|
!!writeBom,
|
|
(path2, data2, writeByteOrderMark) => originalWriteFile.call(sys2, path2, data2, writeByteOrderMark),
|
|
(path2) => sys2.createDirectory(path2),
|
|
(path2) => sys2.directoryExists(path2)
|
|
);
|
|
}
|
|
function getNodeMajorVersion() {
|
|
if (typeof process === "undefined") {
|
|
return void 0;
|
|
}
|
|
const version2 = process.version;
|
|
if (!version2) {
|
|
return void 0;
|
|
}
|
|
const dot = version2.indexOf(".");
|
|
if (dot === -1) {
|
|
return void 0;
|
|
}
|
|
return parseInt(version2.substring(1, dot));
|
|
}
|
|
var sys = (() => {
|
|
const byteOrderMarkIndicator = "\uFEFF";
|
|
function getNodeSystem() {
|
|
const nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/;
|
|
const _fs = require("fs");
|
|
const _path = require("path");
|
|
const _os = require("os");
|
|
let _crypto;
|
|
try {
|
|
_crypto = require("crypto");
|
|
} catch (e) {
|
|
_crypto = void 0;
|
|
}
|
|
let activeSession;
|
|
let profilePath = "./profile.cpuprofile";
|
|
const Buffer2 = require("buffer").Buffer;
|
|
const nodeVersion = getNodeMajorVersion();
|
|
const isNode4OrLater = nodeVersion >= 4;
|
|
const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
|
|
const platform = _os.platform();
|
|
const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
|
|
const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
|
|
const executingFilePath = __filename.endsWith("sys.js") ? _path.join(_path.dirname(__dirname), "__fake__.js") : __filename;
|
|
const fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
|
|
const getCurrentDirectory = memoize(() => process.cwd());
|
|
const { watchFile: watchFile2, watchDirectory } = createSystemWatchFunctions({
|
|
pollingWatchFileWorker: fsWatchFileWorker,
|
|
getModifiedTime: getModifiedTime3,
|
|
setTimeout,
|
|
clearTimeout,
|
|
fsWatchWorker,
|
|
useCaseSensitiveFileNames,
|
|
getCurrentDirectory,
|
|
fileSystemEntryExists,
|
|
fsSupportsRecursiveFsWatch,
|
|
getAccessibleSortedChildDirectories: (path) => getAccessibleFileSystemEntries(path).directories,
|
|
realpath,
|
|
tscWatchFile: process.env.TSC_WATCHFILE,
|
|
useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
|
|
tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
|
|
inodeWatching: isLinuxOrMacOs,
|
|
sysLog
|
|
});
|
|
const nodeSystem = {
|
|
args: process.argv.slice(2),
|
|
newLine: _os.EOL,
|
|
useCaseSensitiveFileNames,
|
|
write(s) {
|
|
process.stdout.write(s);
|
|
},
|
|
getWidthOfTerminal() {
|
|
return process.stdout.columns;
|
|
},
|
|
writeOutputIsTTY() {
|
|
return process.stdout.isTTY;
|
|
},
|
|
readFile,
|
|
writeFile: writeFile2,
|
|
watchFile: watchFile2,
|
|
watchDirectory,
|
|
resolvePath: (path) => _path.resolve(path),
|
|
fileExists,
|
|
directoryExists,
|
|
createDirectory(directoryName) {
|
|
if (!nodeSystem.directoryExists(directoryName)) {
|
|
try {
|
|
_fs.mkdirSync(directoryName);
|
|
} catch (e) {
|
|
if (e.code !== "EEXIST") {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
getExecutingFilePath() {
|
|
return executingFilePath;
|
|
},
|
|
getCurrentDirectory,
|
|
getDirectories,
|
|
getEnvironmentVariable(name) {
|
|
return process.env[name] || "";
|
|
},
|
|
readDirectory,
|
|
getModifiedTime: getModifiedTime3,
|
|
setModifiedTime,
|
|
deleteFile,
|
|
createHash: _crypto ? createSHA256Hash : generateDjb2Hash,
|
|
createSHA256Hash: _crypto ? createSHA256Hash : void 0,
|
|
getMemoryUsage() {
|
|
if (global.gc) {
|
|
global.gc();
|
|
}
|
|
return process.memoryUsage().heapUsed;
|
|
},
|
|
getFileSize(path) {
|
|
try {
|
|
const stat = statSync(path);
|
|
if (stat == null ? void 0 : stat.isFile()) {
|
|
return stat.size;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return 0;
|
|
},
|
|
exit(exitCode) {
|
|
disableCPUProfiler(() => process.exit(exitCode));
|
|
},
|
|
enableCPUProfiler,
|
|
disableCPUProfiler,
|
|
cpuProfilingEnabled: () => !!activeSession || contains(process.execArgv, "--cpu-prof") || contains(process.execArgv, "--prof"),
|
|
realpath,
|
|
debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || some(process.execArgv, (arg) => /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg)),
|
|
tryEnableSourceMapsForHost() {
|
|
try {
|
|
require("source-map-support").install();
|
|
} catch (e) {
|
|
}
|
|
},
|
|
setTimeout,
|
|
clearTimeout,
|
|
clearScreen: () => {
|
|
process.stdout.write("\x1Bc");
|
|
},
|
|
setBlocking: () => {
|
|
if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) {
|
|
process.stdout._handle.setBlocking(true);
|
|
}
|
|
},
|
|
bufferFrom,
|
|
base64decode: (input) => bufferFrom(input, "base64").toString("utf8"),
|
|
base64encode: (input) => bufferFrom(input).toString("base64"),
|
|
require: (baseDir, moduleName) => {
|
|
try {
|
|
const modulePath = resolveJSModule(moduleName, baseDir, nodeSystem);
|
|
return { module: require(modulePath), modulePath, error: void 0 };
|
|
} catch (error) {
|
|
return { module: void 0, modulePath: void 0, error };
|
|
}
|
|
}
|
|
};
|
|
return nodeSystem;
|
|
function statSync(path) {
|
|
return _fs.statSync(path, { throwIfNoEntry: false });
|
|
}
|
|
function enableCPUProfiler(path, cb) {
|
|
if (activeSession) {
|
|
cb();
|
|
return false;
|
|
}
|
|
const inspector = require("inspector");
|
|
if (!inspector || !inspector.Session) {
|
|
cb();
|
|
return false;
|
|
}
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
session.post("Profiler.enable", () => {
|
|
session.post("Profiler.start", () => {
|
|
activeSession = session;
|
|
profilePath = path;
|
|
cb();
|
|
});
|
|
});
|
|
return true;
|
|
}
|
|
function cleanupPaths(profile) {
|
|
let externalFileCounter = 0;
|
|
const remappedPaths = /* @__PURE__ */ new Map();
|
|
const normalizedDir = normalizeSlashes(_path.dirname(executingFilePath));
|
|
const fileUrlRoot = `file://${getRootLength(normalizedDir) === 1 ? "" : "/"}${normalizedDir}`;
|
|
for (const node of profile.nodes) {
|
|
if (node.callFrame.url) {
|
|
const url = normalizeSlashes(node.callFrame.url);
|
|
if (containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) {
|
|
node.callFrame.url = getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, createGetCanonicalFileName(useCaseSensitiveFileNames), true);
|
|
} else if (!nativePattern.test(url)) {
|
|
node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, `external${externalFileCounter}.js`)).get(url);
|
|
externalFileCounter++;
|
|
}
|
|
}
|
|
}
|
|
return profile;
|
|
}
|
|
function disableCPUProfiler(cb) {
|
|
if (activeSession && activeSession !== "stopping") {
|
|
const s = activeSession;
|
|
activeSession.post("Profiler.stop", (err, { profile }) => {
|
|
var _a2;
|
|
if (!err) {
|
|
try {
|
|
if ((_a2 = statSync(profilePath)) == null ? void 0 : _a2.isDirectory()) {
|
|
profilePath = _path.join(profilePath, `${new Date().toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
|
|
}
|
|
} catch (e) {
|
|
}
|
|
try {
|
|
_fs.mkdirSync(_path.dirname(profilePath), { recursive: true });
|
|
} catch (e) {
|
|
}
|
|
_fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile)));
|
|
}
|
|
activeSession = void 0;
|
|
s.disconnect();
|
|
cb();
|
|
});
|
|
activeSession = "stopping";
|
|
return true;
|
|
} else {
|
|
cb();
|
|
return false;
|
|
}
|
|
}
|
|
function bufferFrom(input, encoding) {
|
|
return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
|
|
}
|
|
function isFileSystemCaseSensitive() {
|
|
if (platform === "win32" || platform === "win64") {
|
|
return false;
|
|
}
|
|
return !fileExists(swapCase(__filename));
|
|
}
|
|
function swapCase(s) {
|
|
return s.replace(/\w/g, (ch) => {
|
|
const up = ch.toUpperCase();
|
|
return ch === up ? ch.toLowerCase() : up;
|
|
});
|
|
}
|
|
function fsWatchFileWorker(fileName, callback, pollingInterval) {
|
|
_fs.watchFile(fileName, { persistent: true, interval: pollingInterval }, fileChanged);
|
|
let eventKind;
|
|
return {
|
|
close: () => _fs.unwatchFile(fileName, fileChanged)
|
|
};
|
|
function fileChanged(curr, prev) {
|
|
const isPreviouslyDeleted = +prev.mtime === 0 || eventKind === 2 /* Deleted */;
|
|
if (+curr.mtime === 0) {
|
|
if (isPreviouslyDeleted) {
|
|
return;
|
|
}
|
|
eventKind = 2 /* Deleted */;
|
|
} else if (isPreviouslyDeleted) {
|
|
eventKind = 0 /* Created */;
|
|
} else if (+curr.mtime === +prev.mtime) {
|
|
return;
|
|
} else {
|
|
eventKind = 1 /* Changed */;
|
|
}
|
|
callback(fileName, eventKind, curr.mtime);
|
|
}
|
|
}
|
|
function fsWatchWorker(fileOrDirectory, recursive, callback) {
|
|
return _fs.watch(
|
|
fileOrDirectory,
|
|
fsSupportsRecursiveFsWatch ? { persistent: true, recursive: !!recursive } : { persistent: true },
|
|
callback
|
|
);
|
|
}
|
|
function readFileWorker(fileName, _encoding) {
|
|
let buffer;
|
|
try {
|
|
buffer = _fs.readFileSync(fileName);
|
|
} catch (e) {
|
|
return void 0;
|
|
}
|
|
let len = buffer.length;
|
|
if (len >= 2 && buffer[0] === 254 && buffer[1] === 255) {
|
|
len &= ~1;
|
|
for (let i = 0; i < len; i += 2) {
|
|
const temp = buffer[i];
|
|
buffer[i] = buffer[i + 1];
|
|
buffer[i + 1] = temp;
|
|
}
|
|
return buffer.toString("utf16le", 2);
|
|
}
|
|
if (len >= 2 && buffer[0] === 255 && buffer[1] === 254) {
|
|
return buffer.toString("utf16le", 2);
|
|
}
|
|
if (len >= 3 && buffer[0] === 239 && buffer[1] === 187 && buffer[2] === 191) {
|
|
return buffer.toString("utf8", 3);
|
|
}
|
|
return buffer.toString("utf8");
|
|
}
|
|
function readFile(fileName, _encoding) {
|
|
perfLogger.logStartReadFile(fileName);
|
|
const file = readFileWorker(fileName, _encoding);
|
|
perfLogger.logStopReadFile();
|
|
return file;
|
|
}
|
|
function writeFile2(fileName, data, writeByteOrderMark) {
|
|
perfLogger.logEvent("WriteFile: " + fileName);
|
|
if (writeByteOrderMark) {
|
|
data = byteOrderMarkIndicator + data;
|
|
}
|
|
let fd;
|
|
try {
|
|
fd = _fs.openSync(fileName, "w");
|
|
_fs.writeSync(fd, data, void 0, "utf8");
|
|
} finally {
|
|
if (fd !== void 0) {
|
|
_fs.closeSync(fd);
|
|
}
|
|
}
|
|
}
|
|
function getAccessibleFileSystemEntries(path) {
|
|
perfLogger.logEvent("ReadDir: " + (path || "."));
|
|
try {
|
|
const entries = _fs.readdirSync(path || ".", { withFileTypes: true });
|
|
const files = [];
|
|
const directories = [];
|
|
for (const dirent of entries) {
|
|
const entry = typeof dirent === "string" ? dirent : dirent.name;
|
|
if (entry === "." || entry === "..") {
|
|
continue;
|
|
}
|
|
let stat;
|
|
if (typeof dirent === "string" || dirent.isSymbolicLink()) {
|
|
const name = combinePaths(path, entry);
|
|
try {
|
|
stat = statSync(name);
|
|
if (!stat) {
|
|
continue;
|
|
}
|
|
} catch (e) {
|
|
continue;
|
|
}
|
|
} else {
|
|
stat = dirent;
|
|
}
|
|
if (stat.isFile()) {
|
|
files.push(entry);
|
|
} else if (stat.isDirectory()) {
|
|
directories.push(entry);
|
|
}
|
|
}
|
|
files.sort();
|
|
directories.sort();
|
|
return { files, directories };
|
|
} catch (e) {
|
|
return emptyFileSystemEntries;
|
|
}
|
|
}
|
|
function readDirectory(path, extensions, excludes, includes, depth) {
|
|
return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
|
|
}
|
|
function fileSystemEntryExists(path, entryKind) {
|
|
const originalStackTraceLimit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 0;
|
|
try {
|
|
const stat = statSync(path);
|
|
if (!stat) {
|
|
return false;
|
|
}
|
|
switch (entryKind) {
|
|
case 0 /* File */:
|
|
return stat.isFile();
|
|
case 1 /* Directory */:
|
|
return stat.isDirectory();
|
|
default:
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
return false;
|
|
} finally {
|
|
Error.stackTraceLimit = originalStackTraceLimit;
|
|
}
|
|
}
|
|
function fileExists(path) {
|
|
return fileSystemEntryExists(path, 0 /* File */);
|
|
}
|
|
function directoryExists(path) {
|
|
return fileSystemEntryExists(path, 1 /* Directory */);
|
|
}
|
|
function getDirectories(path) {
|
|
return getAccessibleFileSystemEntries(path).directories.slice();
|
|
}
|
|
function fsRealPathHandlingLongPath(path) {
|
|
return path.length < 260 ? _fs.realpathSync.native(path) : _fs.realpathSync(path);
|
|
}
|
|
function realpath(path) {
|
|
try {
|
|
return fsRealpath(path);
|
|
} catch (e) {
|
|
return path;
|
|
}
|
|
}
|
|
function getModifiedTime3(path) {
|
|
var _a2;
|
|
const originalStackTraceLimit = Error.stackTraceLimit;
|
|
Error.stackTraceLimit = 0;
|
|
try {
|
|
return (_a2 = statSync(path)) == null ? void 0 : _a2.mtime;
|
|
} catch (e) {
|
|
return void 0;
|
|
} finally {
|
|
Error.stackTraceLimit = originalStackTraceLimit;
|
|
}
|
|
}
|
|
function setModifiedTime(path, time) {
|
|
try {
|
|
_fs.utimesSync(path, time, time);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
}
|
|
function deleteFile(path) {
|
|
try {
|
|
return _fs.unlinkSync(path);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
}
|
|
function createSHA256Hash(data) {
|
|
const hash = _crypto.createHash("sha256");
|
|
hash.update(data);
|
|
return hash.digest("hex");
|
|
}
|
|
}
|
|
let sys2;
|
|
if (isNodeLikeSystem()) {
|
|
sys2 = getNodeSystem();
|
|
}
|
|
if (sys2) {
|
|
patchWriteFileEnsuringDirectory(sys2);
|
|
}
|
|
return sys2;
|
|
})();
|
|
function setSys(s) {
|
|
sys = s;
|
|
}
|
|
if (sys && sys.getEnvironmentVariable) {
|
|
setCustomPollingValues(sys);
|
|
Debug.setAssertionLevel(/^development$/i.test(sys.getEnvironmentVariable("NODE_ENV")) ? 1 /* Normal */ : 0 /* None */);
|
|
}
|
|
if (sys && sys.debugMode) {
|
|
Debug.isDebugging = true;
|
|
}
|
|
|
|
// src/compiler/path.ts
|
|
var directorySeparator = "/";
|
|
var altDirectorySeparator = "\\";
|
|
var urlSchemeSeparator = "://";
|
|
var backslashRegExp = /\\/g;
|
|
function isAnyDirectorySeparator(charCode) {
|
|
return charCode === 47 /* slash */ || charCode === 92 /* backslash */;
|
|
}
|
|
function isUrl(path) {
|
|
return getEncodedRootLength(path) < 0;
|
|
}
|
|
function isRootedDiskPath(path) {
|
|
return getEncodedRootLength(path) > 0;
|
|
}
|
|
function isDiskPathRoot(path) {
|
|
const rootLength = getEncodedRootLength(path);
|
|
return rootLength > 0 && rootLength === path.length;
|
|
}
|
|
function pathIsAbsolute(path) {
|
|
return getEncodedRootLength(path) !== 0;
|
|
}
|
|
function pathIsRelative(path) {
|
|
return /^\.\.?($|[\\/])/.test(path);
|
|
}
|
|
function pathIsBareSpecifier(path) {
|
|
return !pathIsAbsolute(path) && !pathIsRelative(path);
|
|
}
|
|
function hasExtension(fileName) {
|
|
return stringContains(getBaseFileName(fileName), ".");
|
|
}
|
|
function fileExtensionIs(path, extension) {
|
|
return path.length > extension.length && endsWith(path, extension);
|
|
}
|
|
function fileExtensionIsOneOf(path, extensions) {
|
|
for (const extension of extensions) {
|
|
if (fileExtensionIs(path, extension)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function hasTrailingDirectorySeparator(path) {
|
|
return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
|
|
}
|
|
function isVolumeCharacter(charCode) {
|
|
return charCode >= 97 /* a */ && charCode <= 122 /* z */ || charCode >= 65 /* A */ && charCode <= 90 /* Z */;
|
|
}
|
|
function getFileUrlVolumeSeparatorEnd(url, start2) {
|
|
const ch0 = url.charCodeAt(start2);
|
|
if (ch0 === 58 /* colon */)
|
|
return start2 + 1;
|
|
if (ch0 === 37 /* percent */ && url.charCodeAt(start2 + 1) === 51 /* _3 */) {
|
|
const ch2 = url.charCodeAt(start2 + 2);
|
|
if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
|
|
return start2 + 3;
|
|
}
|
|
return -1;
|
|
}
|
|
function getEncodedRootLength(path) {
|
|
if (!path)
|
|
return 0;
|
|
const ch0 = path.charCodeAt(0);
|
|
if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
|
|
if (path.charCodeAt(1) !== ch0)
|
|
return 1;
|
|
const p1 = path.indexOf(ch0 === 47 /* slash */ ? directorySeparator : altDirectorySeparator, 2);
|
|
if (p1 < 0)
|
|
return path.length;
|
|
return p1 + 1;
|
|
}
|
|
if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
|
|
const ch2 = path.charCodeAt(2);
|
|
if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
|
|
return 3;
|
|
if (path.length === 2)
|
|
return 2;
|
|
}
|
|
const schemeEnd = path.indexOf(urlSchemeSeparator);
|
|
if (schemeEnd !== -1) {
|
|
const authorityStart = schemeEnd + urlSchemeSeparator.length;
|
|
const authorityEnd = path.indexOf(directorySeparator, authorityStart);
|
|
if (authorityEnd !== -1) {
|
|
const scheme = path.slice(0, schemeEnd);
|
|
const authority = path.slice(authorityStart, authorityEnd);
|
|
if (scheme === "file" && (authority === "" || authority === "localhost") && isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
|
|
const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
|
|
if (volumeSeparatorEnd !== -1) {
|
|
if (path.charCodeAt(volumeSeparatorEnd) === 47 /* slash */) {
|
|
return ~(volumeSeparatorEnd + 1);
|
|
}
|
|
if (volumeSeparatorEnd === path.length) {
|
|
return ~volumeSeparatorEnd;
|
|
}
|
|
}
|
|
}
|
|
return ~(authorityEnd + 1);
|
|
}
|
|
return ~path.length;
|
|
}
|
|
return 0;
|
|
}
|
|
function getRootLength(path) {
|
|
const rootLength = getEncodedRootLength(path);
|
|
return rootLength < 0 ? ~rootLength : rootLength;
|
|
}
|
|
function getDirectoryPath(path) {
|
|
path = normalizeSlashes(path);
|
|
const rootLength = getRootLength(path);
|
|
if (rootLength === path.length)
|
|
return path;
|
|
path = removeTrailingDirectorySeparator(path);
|
|
return path.slice(0, Math.max(rootLength, path.lastIndexOf(directorySeparator)));
|
|
}
|
|
function getBaseFileName(path, extensions, ignoreCase) {
|
|
path = normalizeSlashes(path);
|
|
const rootLength = getRootLength(path);
|
|
if (rootLength === path.length)
|
|
return "";
|
|
path = removeTrailingDirectorySeparator(path);
|
|
const name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(directorySeparator) + 1));
|
|
const extension = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(name, extensions, ignoreCase) : void 0;
|
|
return extension ? name.slice(0, name.length - extension.length) : name;
|
|
}
|
|
function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
|
|
if (!startsWith(extension, "."))
|
|
extension = "." + extension;
|
|
if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* dot */) {
|
|
const pathExtension = path.slice(path.length - extension.length);
|
|
if (stringEqualityComparer(pathExtension, extension)) {
|
|
return pathExtension;
|
|
}
|
|
}
|
|
}
|
|
function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
|
|
if (typeof extensions === "string") {
|
|
return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
|
|
}
|
|
for (const extension of extensions) {
|
|
const result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return "";
|
|
}
|
|
function getAnyExtensionFromPath(path, extensions, ignoreCase) {
|
|
if (extensions) {
|
|
return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
|
|
}
|
|
const baseFileName = getBaseFileName(path);
|
|
const extensionIndex = baseFileName.lastIndexOf(".");
|
|
if (extensionIndex >= 0) {
|
|
return baseFileName.substring(extensionIndex);
|
|
}
|
|
return "";
|
|
}
|
|
function pathComponents(path, rootLength) {
|
|
const root = path.substring(0, rootLength);
|
|
const rest = path.substring(rootLength).split(directorySeparator);
|
|
if (rest.length && !lastOrUndefined(rest))
|
|
rest.pop();
|
|
return [root, ...rest];
|
|
}
|
|
function getPathComponents(path, currentDirectory = "") {
|
|
path = combinePaths(currentDirectory, path);
|
|
return pathComponents(path, getRootLength(path));
|
|
}
|
|
function getPathFromPathComponents(pathComponents2) {
|
|
if (pathComponents2.length === 0)
|
|
return "";
|
|
const root = pathComponents2[0] && ensureTrailingDirectorySeparator(pathComponents2[0]);
|
|
return root + pathComponents2.slice(1).join(directorySeparator);
|
|
}
|
|
function normalizeSlashes(path) {
|
|
return path.indexOf("\\") !== -1 ? path.replace(backslashRegExp, directorySeparator) : path;
|
|
}
|
|
function reducePathComponents(components) {
|
|
if (!some(components))
|
|
return [];
|
|
const reduced = [components[0]];
|
|
for (let i = 1; i < components.length; i++) {
|
|
const component = components[i];
|
|
if (!component)
|
|
continue;
|
|
if (component === ".")
|
|
continue;
|
|
if (component === "..") {
|
|
if (reduced.length > 1) {
|
|
if (reduced[reduced.length - 1] !== "..") {
|
|
reduced.pop();
|
|
continue;
|
|
}
|
|
} else if (reduced[0])
|
|
continue;
|
|
}
|
|
reduced.push(component);
|
|
}
|
|
return reduced;
|
|
}
|
|
function combinePaths(path, ...paths) {
|
|
if (path)
|
|
path = normalizeSlashes(path);
|
|
for (let relativePath of paths) {
|
|
if (!relativePath)
|
|
continue;
|
|
relativePath = normalizeSlashes(relativePath);
|
|
if (!path || getRootLength(relativePath) !== 0) {
|
|
path = relativePath;
|
|
} else {
|
|
path = ensureTrailingDirectorySeparator(path) + relativePath;
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
function resolvePath(path, ...paths) {
|
|
return normalizePath(some(paths) ? combinePaths(path, ...paths) : normalizeSlashes(path));
|
|
}
|
|
function getNormalizedPathComponents(path, currentDirectory) {
|
|
return reducePathComponents(getPathComponents(path, currentDirectory));
|
|
}
|
|
function getNormalizedAbsolutePath(fileName, currentDirectory) {
|
|
return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
|
|
}
|
|
function normalizePath(path) {
|
|
path = normalizeSlashes(path);
|
|
if (!relativePathSegmentRegExp.test(path)) {
|
|
return path;
|
|
}
|
|
const simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, "");
|
|
if (simplified !== path) {
|
|
path = simplified;
|
|
if (!relativePathSegmentRegExp.test(path)) {
|
|
return path;
|
|
}
|
|
}
|
|
const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
|
|
return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
|
|
}
|
|
function getPathWithoutRoot(pathComponents2) {
|
|
if (pathComponents2.length === 0)
|
|
return "";
|
|
return pathComponents2.slice(1).join(directorySeparator);
|
|
}
|
|
function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) {
|
|
return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory));
|
|
}
|
|
function toPath(fileName, basePath, getCanonicalFileName) {
|
|
const nonCanonicalizedPath = isRootedDiskPath(fileName) ? normalizePath(fileName) : getNormalizedAbsolutePath(fileName, basePath);
|
|
return getCanonicalFileName(nonCanonicalizedPath);
|
|
}
|
|
function removeTrailingDirectorySeparator(path) {
|
|
if (hasTrailingDirectorySeparator(path)) {
|
|
return path.substr(0, path.length - 1);
|
|
}
|
|
return path;
|
|
}
|
|
function ensureTrailingDirectorySeparator(path) {
|
|
if (!hasTrailingDirectorySeparator(path)) {
|
|
return path + directorySeparator;
|
|
}
|
|
return path;
|
|
}
|
|
function ensurePathIsNonModuleName(path) {
|
|
return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
|
|
}
|
|
function changeAnyExtension(path, ext, extensions, ignoreCase) {
|
|
const pathext = extensions !== void 0 && ignoreCase !== void 0 ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path);
|
|
return pathext ? path.slice(0, path.length - pathext.length) + (startsWith(ext, ".") ? ext : "." + ext) : path;
|
|
}
|
|
var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/;
|
|
function comparePathsWorker(a, b, componentComparer) {
|
|
if (a === b)
|
|
return 0 /* EqualTo */;
|
|
if (a === void 0)
|
|
return -1 /* LessThan */;
|
|
if (b === void 0)
|
|
return 1 /* GreaterThan */;
|
|
const aRoot = a.substring(0, getRootLength(a));
|
|
const bRoot = b.substring(0, getRootLength(b));
|
|
const result = compareStringsCaseInsensitive(aRoot, bRoot);
|
|
if (result !== 0 /* EqualTo */) {
|
|
return result;
|
|
}
|
|
const aRest = a.substring(aRoot.length);
|
|
const bRest = b.substring(bRoot.length);
|
|
if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
|
|
return componentComparer(aRest, bRest);
|
|
}
|
|
const aComponents = reducePathComponents(getPathComponents(a));
|
|
const bComponents = reducePathComponents(getPathComponents(b));
|
|
const sharedLength = Math.min(aComponents.length, bComponents.length);
|
|
for (let i = 1; i < sharedLength; i++) {
|
|
const result2 = componentComparer(aComponents[i], bComponents[i]);
|
|
if (result2 !== 0 /* EqualTo */) {
|
|
return result2;
|
|
}
|
|
}
|
|
return compareValues(aComponents.length, bComponents.length);
|
|
}
|
|
function comparePathsCaseSensitive(a, b) {
|
|
return comparePathsWorker(a, b, compareStringsCaseSensitive);
|
|
}
|
|
function comparePathsCaseInsensitive(a, b) {
|
|
return comparePathsWorker(a, b, compareStringsCaseInsensitive);
|
|
}
|
|
function comparePaths(a, b, currentDirectory, ignoreCase) {
|
|
if (typeof currentDirectory === "string") {
|
|
a = combinePaths(currentDirectory, a);
|
|
b = combinePaths(currentDirectory, b);
|
|
} else if (typeof currentDirectory === "boolean") {
|
|
ignoreCase = currentDirectory;
|
|
}
|
|
return comparePathsWorker(a, b, getStringComparer(ignoreCase));
|
|
}
|
|
function containsPath(parent2, child, currentDirectory, ignoreCase) {
|
|
if (typeof currentDirectory === "string") {
|
|
parent2 = combinePaths(currentDirectory, parent2);
|
|
child = combinePaths(currentDirectory, child);
|
|
} else if (typeof currentDirectory === "boolean") {
|
|
ignoreCase = currentDirectory;
|
|
}
|
|
if (parent2 === void 0 || child === void 0)
|
|
return false;
|
|
if (parent2 === child)
|
|
return true;
|
|
const parentComponents = reducePathComponents(getPathComponents(parent2));
|
|
const childComponents = reducePathComponents(getPathComponents(child));
|
|
if (childComponents.length < parentComponents.length) {
|
|
return false;
|
|
}
|
|
const componentEqualityComparer = ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive;
|
|
for (let i = 0; i < parentComponents.length; i++) {
|
|
const equalityComparer = i === 0 ? equateStringsCaseInsensitive : componentEqualityComparer;
|
|
if (!equalityComparer(parentComponents[i], childComponents[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function startsWithDirectory(fileName, directoryName, getCanonicalFileName) {
|
|
const canonicalFileName = getCanonicalFileName(fileName);
|
|
const canonicalDirectoryName = getCanonicalFileName(directoryName);
|
|
return startsWith(canonicalFileName, canonicalDirectoryName + "/") || startsWith(canonicalFileName, canonicalDirectoryName + "\\");
|
|
}
|
|
function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
|
|
const fromComponents = reducePathComponents(getPathComponents(from));
|
|
const toComponents = reducePathComponents(getPathComponents(to));
|
|
let start2;
|
|
for (start2 = 0; start2 < fromComponents.length && start2 < toComponents.length; start2++) {
|
|
const fromComponent = getCanonicalFileName(fromComponents[start2]);
|
|
const toComponent = getCanonicalFileName(toComponents[start2]);
|
|
const comparer = start2 === 0 ? equateStringsCaseInsensitive : stringEqualityComparer;
|
|
if (!comparer(fromComponent, toComponent))
|
|
break;
|
|
}
|
|
if (start2 === 0) {
|
|
return toComponents;
|
|
}
|
|
const components = toComponents.slice(start2);
|
|
const relative = [];
|
|
for (; start2 < fromComponents.length; start2++) {
|
|
relative.push("..");
|
|
}
|
|
return ["", ...relative, ...components];
|
|
}
|
|
function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
|
|
Debug.assert(getRootLength(fromDirectory) > 0 === getRootLength(to) > 0, "Paths must either both be absolute or both be relative");
|
|
const getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : identity;
|
|
const ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
|
|
const pathComponents2 = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive, getCanonicalFileName);
|
|
return getPathFromPathComponents(pathComponents2);
|
|
}
|
|
function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) {
|
|
return !isRootedDiskPath(absoluteOrRelativePath) ? absoluteOrRelativePath : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false);
|
|
}
|
|
function getRelativePathFromFile(from, to, getCanonicalFileName) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName));
|
|
}
|
|
function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) {
|
|
const pathComponents2 = getPathComponentsRelativeTo(
|
|
resolvePath(currentDirectory, directoryPathOrUrl),
|
|
resolvePath(currentDirectory, relativeOrAbsolutePath),
|
|
equateStringsCaseSensitive,
|
|
getCanonicalFileName
|
|
);
|
|
const firstComponent = pathComponents2[0];
|
|
if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) {
|
|
const prefix = firstComponent.charAt(0) === directorySeparator ? "file://" : "file:///";
|
|
pathComponents2[0] = prefix + firstComponent;
|
|
}
|
|
return getPathFromPathComponents(pathComponents2);
|
|
}
|
|
function forEachAncestorDirectory(directory, callback) {
|
|
while (true) {
|
|
const result = callback(directory);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
const parentPath = getDirectoryPath(directory);
|
|
if (parentPath === directory) {
|
|
return void 0;
|
|
}
|
|
directory = parentPath;
|
|
}
|
|
}
|
|
function isNodeModulesDirectory(dirPath) {
|
|
return endsWith(dirPath, "/node_modules");
|
|
}
|
|
|
|
// src/compiler/diagnosticInformationMap.generated.ts
|
|
function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated) {
|
|
return { code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated };
|
|
}
|
|
var Diagnostics = {
|
|
Unterminated_string_literal: diag(1002, 1 /* Error */, "Unterminated_string_literal_1002", "Unterminated string literal."),
|
|
Identifier_expected: diag(1003, 1 /* Error */, "Identifier_expected_1003", "Identifier expected."),
|
|
_0_expected: diag(1005, 1 /* Error */, "_0_expected_1005", "'{0}' expected."),
|
|
A_file_cannot_have_a_reference_to_itself: diag(1006, 1 /* Error */, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."),
|
|
The_parser_expected_to_find_a_1_to_match_the_0_token_here: diag(1007, 1 /* Error */, "The_parser_expected_to_find_a_1_to_match_the_0_token_here_1007", "The parser expected to find a '{1}' to match the '{0}' token here."),
|
|
Trailing_comma_not_allowed: diag(1009, 1 /* Error */, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."),
|
|
Asterisk_Slash_expected: diag(1010, 1 /* Error */, "Asterisk_Slash_expected_1010", "'*/' expected."),
|
|
An_element_access_expression_should_take_an_argument: diag(1011, 1 /* Error */, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."),
|
|
Unexpected_token: diag(1012, 1 /* Error */, "Unexpected_token_1012", "Unexpected token."),
|
|
A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, 1 /* Error */, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."),
|
|
A_rest_parameter_must_be_last_in_a_parameter_list: diag(1014, 1 /* Error */, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."),
|
|
Parameter_cannot_have_question_mark_and_initializer: diag(1015, 1 /* Error */, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."),
|
|
A_required_parameter_cannot_follow_an_optional_parameter: diag(1016, 1 /* Error */, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."),
|
|
An_index_signature_cannot_have_a_rest_parameter: diag(1017, 1 /* Error */, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."),
|
|
An_index_signature_parameter_cannot_have_an_accessibility_modifier: diag(1018, 1 /* Error */, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."),
|
|
An_index_signature_parameter_cannot_have_a_question_mark: diag(1019, 1 /* Error */, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."),
|
|
An_index_signature_parameter_cannot_have_an_initializer: diag(1020, 1 /* Error */, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."),
|
|
An_index_signature_must_have_a_type_annotation: diag(1021, 1 /* Error */, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."),
|
|
An_index_signature_parameter_must_have_a_type_annotation: diag(1022, 1 /* Error */, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."),
|
|
readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: diag(1024, 1 /* Error */, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."),
|
|
An_index_signature_cannot_have_a_trailing_comma: diag(1025, 1 /* Error */, "An_index_signature_cannot_have_a_trailing_comma_1025", "An index signature cannot have a trailing comma."),
|
|
Accessibility_modifier_already_seen: diag(1028, 1 /* Error */, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."),
|
|
_0_modifier_must_precede_1_modifier: diag(1029, 1 /* Error */, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."),
|
|
_0_modifier_already_seen: diag(1030, 1 /* Error */, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."),
|
|
_0_modifier_cannot_appear_on_class_elements_of_this_kind: diag(1031, 1 /* Error */, "_0_modifier_cannot_appear_on_class_elements_of_this_kind_1031", "'{0}' modifier cannot appear on class elements of this kind."),
|
|
super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, 1 /* Error */, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."),
|
|
Only_ambient_modules_can_use_quoted_names: diag(1035, 1 /* Error */, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."),
|
|
Statements_are_not_allowed_in_ambient_contexts: diag(1036, 1 /* Error */, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."),
|
|
A_declare_modifier_cannot_be_used_in_an_already_ambient_context: diag(1038, 1 /* Error */, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."),
|
|
Initializers_are_not_allowed_in_ambient_contexts: diag(1039, 1 /* Error */, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."),
|
|
_0_modifier_cannot_be_used_in_an_ambient_context: diag(1040, 1 /* Error */, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."),
|
|
_0_modifier_cannot_be_used_here: diag(1042, 1 /* Error */, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."),
|
|
_0_modifier_cannot_appear_on_a_module_or_namespace_element: diag(1044, 1 /* Error */, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."),
|
|
Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier: diag(1046, 1 /* Error */, "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046", "Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier."),
|
|
A_rest_parameter_cannot_be_optional: diag(1047, 1 /* Error */, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."),
|
|
A_rest_parameter_cannot_have_an_initializer: diag(1048, 1 /* Error */, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."),
|
|
A_set_accessor_must_have_exactly_one_parameter: diag(1049, 1 /* Error */, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."),
|
|
A_set_accessor_cannot_have_an_optional_parameter: diag(1051, 1 /* Error */, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."),
|
|
A_set_accessor_parameter_cannot_have_an_initializer: diag(1052, 1 /* Error */, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."),
|
|
A_set_accessor_cannot_have_rest_parameter: diag(1053, 1 /* Error */, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."),
|
|
A_get_accessor_cannot_have_parameters: diag(1054, 1 /* Error */, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."),
|
|
Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: diag(1055, 1 /* Error */, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Prom_1055", "Type '{0}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value."),
|
|
Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: diag(1056, 1 /* Error */, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."),
|
|
The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1058, 1 /* Error */, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."),
|
|
A_promise_must_have_a_then_method: diag(1059, 1 /* Error */, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."),
|
|
The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: diag(1060, 1 /* Error */, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."),
|
|
Enum_member_must_have_initializer: diag(1061, 1 /* Error */, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."),
|
|
Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
|
|
An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
|
|
The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
|
|
In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
|
|
Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
|
|
Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
|
|
_0_modifier_cannot_appear_on_a_type_member: diag(1070, 1 /* Error */, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."),
|
|
_0_modifier_cannot_appear_on_an_index_signature: diag(1071, 1 /* Error */, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."),
|
|
A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, 1 /* Error */, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."),
|
|
Invalid_reference_directive_syntax: diag(1084, 1 /* Error */, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."),
|
|
Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, 1 /* Error */, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."),
|
|
_0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, 1 /* Error */, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."),
|
|
_0_modifier_cannot_appear_on_a_parameter: diag(1090, 1 /* Error */, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."),
|
|
Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, 1 /* Error */, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."),
|
|
Type_parameters_cannot_appear_on_a_constructor_declaration: diag(1092, 1 /* Error */, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."),
|
|
Type_annotation_cannot_appear_on_a_constructor_declaration: diag(1093, 1 /* Error */, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."),
|
|
An_accessor_cannot_have_type_parameters: diag(1094, 1 /* Error */, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."),
|
|
A_set_accessor_cannot_have_a_return_type_annotation: diag(1095, 1 /* Error */, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."),
|
|
An_index_signature_must_have_exactly_one_parameter: diag(1096, 1 /* Error */, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."),
|
|
_0_list_cannot_be_empty: diag(1097, 1 /* Error */, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."),
|
|
Type_parameter_list_cannot_be_empty: diag(1098, 1 /* Error */, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."),
|
|
Type_argument_list_cannot_be_empty: diag(1099, 1 /* Error */, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."),
|
|
Invalid_use_of_0_in_strict_mode: diag(1100, 1 /* 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, 1 /* 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, 1 /* Error */, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."),
|
|
for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1103, 1 /* 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, 1 /* 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, 1 /* 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."),
|
|
The_left_hand_side_of_a_for_of_statement_may_not_be_async: diag(1106, 1 /* Error */, "The_left_hand_side_of_a_for_of_statement_may_not_be_async_1106", "The left-hand side of a 'for...of' statement may not be 'async'."),
|
|
Jump_target_cannot_cross_function_boundary: diag(1107, 1 /* Error */, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."),
|
|
A_return_statement_can_only_be_used_within_a_function_body: diag(1108, 1 /* Error */, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."),
|
|
Expression_expected: diag(1109, 1 /* Error */, "Expression_expected_1109", "Expression expected."),
|
|
Type_expected: diag(1110, 1 /* Error */, "Type_expected_1110", "Type expected."),
|
|
A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, 1 /* Error */, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."),
|
|
Duplicate_label_0: diag(1114, 1 /* Error */, "Duplicate_label_0_1114", "Duplicate label '{0}'."),
|
|
A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, 1 /* Error */, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."),
|
|
A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, 1 /* Error */, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."),
|
|
An_object_literal_cannot_have_multiple_properties_with_the_same_name: diag(1117, 1 /* Error */, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_1117", "An object literal cannot have multiple properties with the same name."),
|
|
An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, 1 /* Error */, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."),
|
|
An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, 1 /* Error */, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."),
|
|
An_export_assignment_cannot_have_modifiers: diag(1120, 1 /* Error */, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."),
|
|
Octal_literals_are_not_allowed_in_strict_mode: diag(1121, 1 /* Error */, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."),
|
|
Variable_declaration_list_cannot_be_empty: diag(1123, 1 /* Error */, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."),
|
|
Digit_expected: diag(1124, 1 /* Error */, "Digit_expected_1124", "Digit expected."),
|
|
Hexadecimal_digit_expected: diag(1125, 1 /* Error */, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."),
|
|
Unexpected_end_of_text: diag(1126, 1 /* Error */, "Unexpected_end_of_text_1126", "Unexpected end of text."),
|
|
Invalid_character: diag(1127, 1 /* Error */, "Invalid_character_1127", "Invalid character."),
|
|
Declaration_or_statement_expected: diag(1128, 1 /* Error */, "Declaration_or_statement_expected_1128", "Declaration or statement expected."),
|
|
Statement_expected: diag(1129, 1 /* Error */, "Statement_expected_1129", "Statement expected."),
|
|
case_or_default_expected: diag(1130, 1 /* Error */, "case_or_default_expected_1130", "'case' or 'default' expected."),
|
|
Property_or_signature_expected: diag(1131, 1 /* Error */, "Property_or_signature_expected_1131", "Property or signature expected."),
|
|
Enum_member_expected: diag(1132, 1 /* Error */, "Enum_member_expected_1132", "Enum member expected."),
|
|
Variable_declaration_expected: diag(1134, 1 /* Error */, "Variable_declaration_expected_1134", "Variable declaration expected."),
|
|
Argument_expression_expected: diag(1135, 1 /* Error */, "Argument_expression_expected_1135", "Argument expression expected."),
|
|
Property_assignment_expected: diag(1136, 1 /* Error */, "Property_assignment_expected_1136", "Property assignment expected."),
|
|
Expression_or_comma_expected: diag(1137, 1 /* Error */, "Expression_or_comma_expected_1137", "Expression or comma expected."),
|
|
Parameter_declaration_expected: diag(1138, 1 /* Error */, "Parameter_declaration_expected_1138", "Parameter declaration expected."),
|
|
Type_parameter_declaration_expected: diag(1139, 1 /* Error */, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."),
|
|
Type_argument_expected: diag(1140, 1 /* Error */, "Type_argument_expected_1140", "Type argument expected."),
|
|
String_literal_expected: diag(1141, 1 /* Error */, "String_literal_expected_1141", "String literal expected."),
|
|
Line_break_not_permitted_here: diag(1142, 1 /* Error */, "Line_break_not_permitted_here_1142", "Line break not permitted here."),
|
|
or_expected: diag(1144, 1 /* Error */, "or_expected_1144", "'{' or ';' expected."),
|
|
or_JSX_element_expected: diag(1145, 1 /* Error */, "or_JSX_element_expected_1145", "'{' or JSX element expected."),
|
|
Declaration_expected: diag(1146, 1 /* Error */, "Declaration_expected_1146", "Declaration expected."),
|
|
Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, 1 /* Error */, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."),
|
|
Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, 1 /* Error */, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."),
|
|
File_name_0_differs_from_already_included_file_name_1_only_in_casing: diag(1149, 1 /* Error */, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."),
|
|
const_declarations_must_be_initialized: diag(1155, 1 /* Error */, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."),
|
|
const_declarations_can_only_be_declared_inside_a_block: diag(1156, 1 /* Error */, "const_declarations_can_only_be_declared_inside_a_block_1156", "'const' declarations can only be declared inside a block."),
|
|
let_declarations_can_only_be_declared_inside_a_block: diag(1157, 1 /* Error */, "let_declarations_can_only_be_declared_inside_a_block_1157", "'let' declarations can only be declared inside a block."),
|
|
Unterminated_template_literal: diag(1160, 1 /* Error */, "Unterminated_template_literal_1160", "Unterminated template literal."),
|
|
Unterminated_regular_expression_literal: diag(1161, 1 /* Error */, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."),
|
|
An_object_member_cannot_be_declared_optional: diag(1162, 1 /* Error */, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."),
|
|
A_yield_expression_is_only_allowed_in_a_generator_body: diag(1163, 1 /* Error */, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."),
|
|
Computed_property_names_are_not_allowed_in_enums: diag(1164, 1 /* Error */, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."),
|
|
A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1165, 1 /* Error */, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."),
|
|
A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type: diag(1166, 1 /* Error */, "A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_1166", "A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type."),
|
|
A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1168, 1 /* Error */, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."),
|
|
A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1169, 1 /* Error */, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."),
|
|
A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1170, 1 /* Error */, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."),
|
|
A_comma_expression_is_not_allowed_in_a_computed_property_name: diag(1171, 1 /* Error */, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."),
|
|
extends_clause_already_seen: diag(1172, 1 /* Error */, "extends_clause_already_seen_1172", "'extends' clause already seen."),
|
|
extends_clause_must_precede_implements_clause: diag(1173, 1 /* Error */, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."),
|
|
Classes_can_only_extend_a_single_class: diag(1174, 1 /* Error */, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."),
|
|
implements_clause_already_seen: diag(1175, 1 /* Error */, "implements_clause_already_seen_1175", "'implements' clause already seen."),
|
|
Interface_declaration_cannot_have_implements_clause: diag(1176, 1 /* Error */, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."),
|
|
Binary_digit_expected: diag(1177, 1 /* Error */, "Binary_digit_expected_1177", "Binary digit expected."),
|
|
Octal_digit_expected: diag(1178, 1 /* Error */, "Octal_digit_expected_1178", "Octal digit expected."),
|
|
Unexpected_token_expected: diag(1179, 1 /* Error */, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."),
|
|
Property_destructuring_pattern_expected: diag(1180, 1 /* Error */, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."),
|
|
Array_element_destructuring_pattern_expected: diag(1181, 1 /* Error */, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."),
|
|
A_destructuring_declaration_must_have_an_initializer: diag(1182, 1 /* Error */, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."),
|
|
An_implementation_cannot_be_declared_in_ambient_contexts: diag(1183, 1 /* Error */, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."),
|
|
Modifiers_cannot_appear_here: diag(1184, 1 /* Error */, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."),
|
|
Merge_conflict_marker_encountered: diag(1185, 1 /* Error */, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."),
|
|
A_rest_element_cannot_have_an_initializer: diag(1186, 1 /* Error */, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."),
|
|
A_parameter_property_may_not_be_declared_using_a_binding_pattern: diag(1187, 1 /* Error */, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."),
|
|
Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: diag(1188, 1 /* Error */, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."),
|
|
The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: diag(1189, 1 /* Error */, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."),
|
|
The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: diag(1190, 1 /* Error */, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."),
|
|
An_import_declaration_cannot_have_modifiers: diag(1191, 1 /* Error */, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."),
|
|
Module_0_has_no_default_export: diag(1192, 1 /* Error */, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."),
|
|
An_export_declaration_cannot_have_modifiers: diag(1193, 1 /* Error */, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."),
|
|
Export_declarations_are_not_permitted_in_a_namespace: diag(1194, 1 /* Error */, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."),
|
|
export_Asterisk_does_not_re_export_a_default: diag(1195, 1 /* Error */, "export_Asterisk_does_not_re_export_a_default_1195", "'export *' does not re-export a default."),
|
|
Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified: diag(1196, 1 /* Error */, "Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified_1196", "Catch clause variable type annotation must be 'any' or 'unknown' if specified."),
|
|
Catch_clause_variable_cannot_have_an_initializer: diag(1197, 1 /* Error */, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."),
|
|
An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, 1 /* Error */, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."),
|
|
Unterminated_Unicode_escape_sequence: diag(1199, 1 /* Error */, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."),
|
|
Line_terminator_not_permitted_before_arrow: diag(1200, 1 /* Error */, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."),
|
|
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: diag(1202, 1 /* Error */, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", `Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from "mod"', 'import {a} from "mod"', 'import d from "mod"', or another module format instead.`),
|
|
Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: diag(1203, 1 /* Error */, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."),
|
|
Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type: diag(1205, 1 /* Error */, "Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type_1205", "Re-exporting a type when the '--isolatedModules' flag is provided requires using 'export type'."),
|
|
Decorators_are_not_valid_here: diag(1206, 1 /* Error */, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."),
|
|
Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, 1 /* Error */, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."),
|
|
_0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module: diag(1208, 1 /* Error */, "_0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_imp_1208", "'{0}' cannot be compiled under '--isolatedModules' because it is considered a global script file. Add an import, export, or an empty 'export {}' statement to make it a module."),
|
|
Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0: diag(1209, 1 /* Error */, "Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0_1209", "Invalid optional chain from new expression. Did you mean to call '{0}()'?"),
|
|
Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode: diag(1210, 1 /* Error */, "Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of__1210", "Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of '{0}'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode."),
|
|
A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, 1 /* Error */, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."),
|
|
Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, 1 /* Error */, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."),
|
|
Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: diag(1213, 1 /* Error */, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."),
|
|
Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: diag(1214, 1 /* Error */, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."),
|
|
Invalid_use_of_0_Modules_are_automatically_in_strict_mode: diag(1215, 1 /* Error */, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."),
|
|
Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: diag(1216, 1 /* Error */, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."),
|
|
Export_assignment_is_not_supported_when_module_flag_is_system: diag(1218, 1 /* Error */, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."),
|
|
Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning: diag(1219, 1 /* Error */, "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option in your 'tsconfig' or 'jsconfig' to remove this warning."),
|
|
Generators_are_not_allowed_in_an_ambient_context: diag(1221, 1 /* Error */, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."),
|
|
An_overload_signature_cannot_be_declared_as_a_generator: diag(1222, 1 /* Error */, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."),
|
|
_0_tag_already_specified: diag(1223, 1 /* Error */, "_0_tag_already_specified_1223", "'{0}' tag already specified."),
|
|
Signature_0_must_be_a_type_predicate: diag(1224, 1 /* Error */, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."),
|
|
Cannot_find_parameter_0: diag(1225, 1 /* Error */, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."),
|
|
Type_predicate_0_is_not_assignable_to_1: diag(1226, 1 /* Error */, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."),
|
|
Parameter_0_is_not_in_the_same_position_as_parameter_1: diag(1227, 1 /* Error */, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."),
|
|
A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: diag(1228, 1 /* Error */, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."),
|
|
A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, 1 /* Error */, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."),
|
|
A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, 1 /* Error */, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."),
|
|
An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1231, 1 /* Error */, "An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration_1231", "An export assignment must be at the top level of a file or module declaration."),
|
|
An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1232, 1 /* Error */, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1232", "An import declaration can only be used at the top level of a namespace or module."),
|
|
An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1233, 1 /* Error */, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1233", "An export declaration can only be used at the top level of a namespace or module."),
|
|
An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, 1 /* Error */, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."),
|
|
A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module: diag(1235, 1 /* Error */, "A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module_1235", "A namespace declaration is only allowed at the top level of a namespace or module."),
|
|
The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, 1 /* Error */, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."),
|
|
The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, 1 /* Error */, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."),
|
|
Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, 1 /* Error */, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."),
|
|
Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: diag(1239, 1 /* Error */, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."),
|
|
Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: diag(1240, 1 /* Error */, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."),
|
|
Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: diag(1241, 1 /* Error */, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."),
|
|
abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: diag(1242, 1 /* Error */, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."),
|
|
_0_modifier_cannot_be_used_with_1_modifier: diag(1243, 1 /* Error */, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."),
|
|
Abstract_methods_can_only_appear_within_an_abstract_class: diag(1244, 1 /* Error */, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."),
|
|
Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: diag(1245, 1 /* Error */, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."),
|
|
An_interface_property_cannot_have_an_initializer: diag(1246, 1 /* Error */, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."),
|
|
A_type_literal_property_cannot_have_an_initializer: diag(1247, 1 /* Error */, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."),
|
|
A_class_member_cannot_have_the_0_keyword: diag(1248, 1 /* Error */, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."),
|
|
A_decorator_can_only_decorate_a_method_implementation_not_an_overload: diag(1249, 1 /* Error */, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."),
|
|
Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."),
|
|
Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."),
|
|
Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."),
|
|
A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, 1 /* 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, 1 /* Error */, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."),
|
|
A_required_element_cannot_follow_an_optional_element: diag(1257, 1 /* Error */, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."),
|
|
A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1258, 1 /* Error */, "A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration_1258", "A default export must be at the top level of a file or module declaration."),
|
|
Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, 1 /* 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, 1 /* Error */, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."),
|
|
Already_included_file_name_0_differs_from_file_name_1_only_in_casing: diag(1261, 1 /* Error */, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."),
|
|
Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module: diag(1262, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."),
|
|
Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, 1 /* Error */, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."),
|
|
An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, 1 /* Error */, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."),
|
|
Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, 1 /* Error */, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."),
|
|
Decorator_function_return_type_0_is_not_assignable_to_type_1: diag(1270, 1 /* Error */, "Decorator_function_return_type_0_is_not_assignable_to_type_1_1270", "Decorator function return type '{0}' is not assignable to type '{1}'."),
|
|
Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any: diag(1271, 1 /* Error */, "Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any_1271", "Decorator function return type is '{0}' but is expected to be 'void' or 'any'."),
|
|
A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled: diag(1272, 1 /* Error */, "A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_w_1272", "A type referenced in a decorated signature must be imported with 'import type' or a namespace import when 'isolatedModules' and 'emitDecoratorMetadata' are enabled."),
|
|
_0_modifier_cannot_appear_on_a_type_parameter: diag(1273, 1 /* Error */, "_0_modifier_cannot_appear_on_a_type_parameter_1273", "'{0}' modifier cannot appear on a type parameter"),
|
|
_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: diag(1274, 1 /* Error */, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"),
|
|
accessor_modifier_can_only_appear_on_a_property_declaration: diag(1275, 1 /* Error */, "accessor_modifier_can_only_appear_on_a_property_declaration_1275", "'accessor' modifier can only appear on a property declaration."),
|
|
An_accessor_property_cannot_be_declared_optional: diag(1276, 1 /* Error */, "An_accessor_property_cannot_be_declared_optional_1276", "An 'accessor' property cannot be declared optional."),
|
|
with_statements_are_not_allowed_in_an_async_function_block: diag(1300, 1 /* 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, 1 /* 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."),
|
|
The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, 1 /* Error */, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."),
|
|
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, 1 /* 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."),
|
|
The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, 1 /* Error */, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."),
|
|
Global_module_exports_may_only_appear_in_module_files: diag(1314, 1 /* Error */, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."),
|
|
Global_module_exports_may_only_appear_in_declaration_files: diag(1315, 1 /* Error */, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."),
|
|
Global_module_exports_may_only_appear_at_top_level: diag(1316, 1 /* Error */, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."),
|
|
A_parameter_property_cannot_be_declared_using_a_rest_parameter: diag(1317, 1 /* Error */, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."),
|
|
An_abstract_accessor_cannot_have_an_implementation: diag(1318, 1 /* Error */, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."),
|
|
A_default_export_can_only_be_used_in_an_ECMAScript_style_module: diag(1319, 1 /* Error */, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."),
|
|
Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, 1 /* Error */, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."),
|
|
Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, 1 /* Error */, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."),
|
|
Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, 1 /* Error */, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."),
|
|
Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext: diag(1323, 1 /* Error */, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', or 'nodenext'."),
|
|
Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext: diag(1324, 1 /* Error */, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nod_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', or 'nodenext'."),
|
|
Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, 1 /* Error */, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
|
|
This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, 1 /* Error */, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."),
|
|
String_literal_with_double_quotes_expected: diag(1327, 1 /* Error */, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."),
|
|
Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, 1 /* Error */, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."),
|
|
_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, 1 /* Error */, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"),
|
|
A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: diag(1330, 1 /* Error */, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."),
|
|
A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: diag(1331, 1 /* Error */, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."),
|
|
A_variable_whose_type_is_a_unique_symbol_type_must_be_const: diag(1332, 1 /* Error */, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."),
|
|
unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: diag(1333, 1 /* Error */, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."),
|
|
unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: diag(1334, 1 /* Error */, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."),
|
|
unique_symbol_types_are_not_allowed_here: diag(1335, 1 /* Error */, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."),
|
|
An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead: diag(1337, 1 /* Error */, "An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_o_1337", "An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead."),
|
|
infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: diag(1338, 1 /* Error */, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."),
|
|
Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, 1 /* Error */, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."),
|
|
Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, 1 /* Error */, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"),
|
|
Class_constructor_may_not_be_an_accessor: diag(1341, 1 /* Error */, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."),
|
|
Type_arguments_cannot_be_used_here: diag(1342, 1 /* Error */, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."),
|
|
The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext: diag(1343, 1 /* Error */, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'."),
|
|
A_label_is_not_allowed_here: diag(1344, 1 /* Error */, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."),
|
|
An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, 1 /* Error */, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."),
|
|
This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, 1 /* Error */, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."),
|
|
use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, 1 /* Error */, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."),
|
|
Non_simple_parameter_declared_here: diag(1348, 1 /* Error */, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."),
|
|
use_strict_directive_used_here: diag(1349, 1 /* Error */, "use_strict_directive_used_here_1349", "'use strict' directive used here."),
|
|
Print_the_final_configuration_instead_of_building: diag(1350, 3 /* Message */, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."),
|
|
An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: diag(1351, 1 /* Error */, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."),
|
|
A_bigint_literal_cannot_use_exponential_notation: diag(1352, 1 /* Error */, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."),
|
|
A_bigint_literal_must_be_an_integer: diag(1353, 1 /* Error */, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."),
|
|
readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: diag(1354, 1 /* Error */, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."),
|
|
A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals: diag(1355, 1 /* Error */, "A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array__1355", "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals."),
|
|
Did_you_mean_to_mark_this_function_as_async: diag(1356, 1 /* Error */, "Did_you_mean_to_mark_this_function_as_async_1356", "Did you mean to mark this function as 'async'?"),
|
|
An_enum_member_name_must_be_followed_by_a_or: diag(1357, 1 /* Error */, "An_enum_member_name_must_be_followed_by_a_or_1357", "An enum member name must be followed by a ',', '=', or '}'."),
|
|
Tagged_template_expressions_are_not_permitted_in_an_optional_chain: diag(1358, 1 /* Error */, "Tagged_template_expressions_are_not_permitted_in_an_optional_chain_1358", "Tagged template expressions are not permitted in an optional chain."),
|
|
Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here: diag(1359, 1 /* Error */, "Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here_1359", "Identifier expected. '{0}' is a reserved word that cannot be used here."),
|
|
Type_0_does_not_satisfy_the_expected_type_1: diag(1360, 1 /* Error */, "Type_0_does_not_satisfy_the_expected_type_1_1360", "Type '{0}' does not satisfy the expected type '{1}'."),
|
|
_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type: diag(1361, 1 /* Error */, "_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type_1361", "'{0}' cannot be used as a value because it was imported using 'import type'."),
|
|
_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type: diag(1362, 1 /* Error */, "_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type_1362", "'{0}' cannot be used as a value because it was exported using 'export type'."),
|
|
A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both: diag(1363, 1 /* Error */, "A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both_1363", "A type-only import can specify a default import or named bindings, but not both."),
|
|
Convert_to_type_only_export: diag(1364, 3 /* Message */, "Convert_to_type_only_export_1364", "Convert to type-only export"),
|
|
Convert_all_re_exported_types_to_type_only_exports: diag(1365, 3 /* Message */, "Convert_all_re_exported_types_to_type_only_exports_1365", "Convert all re-exported types to type-only exports"),
|
|
Split_into_two_separate_import_declarations: diag(1366, 3 /* Message */, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"),
|
|
Split_all_invalid_type_only_imports: diag(1367, 3 /* Message */, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"),
|
|
Class_constructor_may_not_be_a_generator: diag(1368, 1 /* Error */, "Class_constructor_may_not_be_a_generator_1368", "Class constructor may not be a generator."),
|
|
Did_you_mean_0: diag(1369, 3 /* Message */, "Did_you_mean_0_1369", "Did you mean '{0}'?"),
|
|
This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error: diag(1371, 1 /* 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, 3 /* 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, 3 /* 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, 1 /* 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."),
|
|
_0_was_imported_here: diag(1376, 3 /* Message */, "_0_was_imported_here_1376", "'{0}' was imported here."),
|
|
_0_was_exported_here: diag(1377, 3 /* Message */, "_0_was_exported_here_1377", "'{0}' was exported here."),
|
|
Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, 1 /* Error */, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
|
|
An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, 1 /* Error */, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."),
|
|
An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, 1 /* Error */, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."),
|
|
Unexpected_token_Did_you_mean_or_rbrace: diag(1381, 1 /* Error */, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"),
|
|
Unexpected_token_Did_you_mean_or_gt: diag(1382, 1 /* Error */, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"),
|
|
Only_named_exports_may_use_export_type: diag(1383, 1 /* Error */, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."),
|
|
Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1385, 1 /* Error */, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."),
|
|
Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1386, 1 /* Error */, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."),
|
|
Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, 1 /* 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, 1 /* 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, 1 /* Error */, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."),
|
|
_0_is_not_allowed_as_a_parameter_name: diag(1390, 1 /* Error */, "_0_is_not_allowed_as_a_parameter_name_1390", "'{0}' is not allowed as a parameter name."),
|
|
An_import_alias_cannot_use_import_type: diag(1392, 1 /* Error */, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"),
|
|
Imported_via_0_from_file_1: diag(1393, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "File_is_included_via_import_here_1399", "File is included via import here."),
|
|
Referenced_via_0_from_file_1: diag(1400, 3 /* Message */, "Referenced_via_0_from_file_1_1400", "Referenced via '{0}' from file '{1}'"),
|
|
File_is_included_via_reference_here: diag(1401, 3 /* Message */, "File_is_included_via_reference_here_1401", "File is included via reference here."),
|
|
Type_library_referenced_via_0_from_file_1: diag(1402, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Library_0_specified_in_compilerOptions_1422", "Library '{0}' specified in compilerOptions"),
|
|
File_is_library_specified_here: diag(1423, 3 /* Message */, "File_is_library_specified_here_1423", "File is library specified here."),
|
|
Default_library: diag(1424, 3 /* Message */, "Default_library_1424", "Default library"),
|
|
Default_library_for_target_0: diag(1425, 3 /* Message */, "Default_library_for_target_0_1425", "Default library for target '{0}'"),
|
|
File_is_default_library_for_target_specified_here: diag(1426, 3 /* 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, 3 /* Message */, "Root_file_specified_for_compilation_1427", "Root file specified for compilation"),
|
|
File_is_output_of_project_reference_source_0: diag(1428, 3 /* 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, 3 /* Message */, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"),
|
|
The_file_is_in_the_program_because_Colon: diag(1430, 3 /* 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, 1 /* 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_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, 1 /* Error */, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."),
|
|
Decorators_may_not_be_applied_to_this_parameters: diag(1433, 1 /* Error */, "Decorators_may_not_be_applied_to_this_parameters_1433", "Decorators may not be applied to 'this' parameters."),
|
|
Unexpected_keyword_or_identifier: diag(1434, 1 /* Error */, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."),
|
|
Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, 1 /* Error */, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"),
|
|
Decorators_must_precede_the_name_and_all_keywords_of_property_declarations: diag(1436, 1 /* Error */, "Decorators_must_precede_the_name_and_all_keywords_of_property_declarations_1436", "Decorators must precede the name and all keywords of property declarations."),
|
|
Namespace_must_be_given_a_name: diag(1437, 1 /* Error */, "Namespace_must_be_given_a_name_1437", "Namespace must be given a name."),
|
|
Interface_must_be_given_a_name: diag(1438, 1 /* Error */, "Interface_must_be_given_a_name_1438", "Interface must be given a name."),
|
|
Type_alias_must_be_given_a_name: diag(1439, 1 /* Error */, "Type_alias_must_be_given_a_name_1439", "Type alias must be given a name."),
|
|
Variable_declaration_not_allowed_at_this_location: diag(1440, 1 /* Error */, "Variable_declaration_not_allowed_at_this_location_1440", "Variable declaration not allowed at this location."),
|
|
Cannot_start_a_function_call_in_a_type_annotation: diag(1441, 1 /* Error */, "Cannot_start_a_function_call_in_a_type_annotation_1441", "Cannot start a function call in a type annotation."),
|
|
Expected_for_property_initializer: diag(1442, 1 /* Error */, "Expected_for_property_initializer_1442", "Expected '=' for property initializer."),
|
|
Module_declaration_names_may_only_use_or_quoted_strings: diag(1443, 1 /* Error */, "Module_declaration_names_may_only_use_or_quoted_strings_1443", `Module declaration names may only use ' or " quoted strings.`),
|
|
_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled: diag(1444, 1 /* Error */, "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedMod_1444", "'{0}' is a type and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled."),
|
|
_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled: diag(1446, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveVa_1446", "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled."),
|
|
_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled: diag(1448, 1 /* Error */, "_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isol_1448", "'{0}' resolves to a type-only declaration and must be re-exported using a type-only re-export when 'isolatedModules' is enabled."),
|
|
Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: diag(1449, 3 /* Message */, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."),
|
|
Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments: diag(1450, 3 /* Message */, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional assertion as arguments"),
|
|
Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: diag(1451, 1 /* Error */, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"),
|
|
resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext: diag(1452, 1 /* Error */, "resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext_1452", "'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`."),
|
|
resolution_mode_should_be_either_require_or_import: diag(1453, 1 /* Error */, "resolution_mode_should_be_either_require_or_import_1453", "`resolution-mode` should be either `require` or `import`."),
|
|
resolution_mode_can_only_be_set_for_type_only_imports: diag(1454, 1 /* Error */, "resolution_mode_can_only_be_set_for_type_only_imports_1454", "`resolution-mode` can only be set for type-only imports."),
|
|
resolution_mode_is_the_only_valid_key_for_type_import_assertions: diag(1455, 1 /* Error */, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."),
|
|
Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: diag(1456, 1 /* Error */, "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456", "Type import assertions should have exactly one key - `resolution-mode` - with value `import` or `require`."),
|
|
Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk: diag(1457, 3 /* Message */, "Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk_1457", "Matched by default include pattern '**/*'"),
|
|
File_is_ECMAScript_module_because_0_has_field_type_with_value_module: diag(1458, 3 /* Message */, "File_is_ECMAScript_module_because_0_has_field_type_with_value_module_1458", `File is ECMAScript module because '{0}' has field "type" with value "module"`),
|
|
File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module: diag(1459, 3 /* Message */, "File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module_1459", `File is CommonJS module because '{0}' has field "type" whose value is not "module"`),
|
|
File_is_CommonJS_module_because_0_does_not_have_field_type: diag(1460, 3 /* Message */, "File_is_CommonJS_module_because_0_does_not_have_field_type_1460", `File is CommonJS module because '{0}' does not have field "type"`),
|
|
File_is_CommonJS_module_because_package_json_was_not_found: diag(1461, 3 /* Message */, "File_is_CommonJS_module_because_package_json_was_not_found_1461", "File is CommonJS module because 'package.json' was not found"),
|
|
The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, 1 /* Error */, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."),
|
|
Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead: diag(1471, 1 /* Error */, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported with 'require'. Use an ECMAScript import instead."),
|
|
catch_or_finally_expected: diag(1472, 1 /* Error */, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."),
|
|
An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, 1 /* Error */, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."),
|
|
An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, 1 /* Error */, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."),
|
|
Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, 3 /* Message */, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."),
|
|
auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, 3 /* Message */, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", '"auto": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules.'),
|
|
An_instantiation_expression_cannot_be_followed_by_a_property_access: diag(1477, 1 /* Error */, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."),
|
|
Identifier_or_string_literal_expected: diag(1478, 1 /* Error */, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."),
|
|
The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead: diag(1479, 1 /* Error */, "The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_reference_1479", `The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import("{0}")' call instead.`),
|
|
To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module: diag(1480, 3 /* Message */, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_packag_1480", 'To convert this file to an ECMAScript module, change its file extension to \'{0}\' or create a local package.json file with `{ "type": "module" }`.'),
|
|
To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1: diag(1481, 3 /* Message */, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Co_1481", `To convert this file to an ECMAScript module, change its file extension to '{0}', or add the field \`"type": "module"\` to '{1}'.`),
|
|
To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0: diag(1482, 3 /* Message */, "To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0_1482", 'To convert this file to an ECMAScript module, add the field `"type": "module"` to \'{0}\'.'),
|
|
To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module: diag(1483, 3 /* Message */, "To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module_1483", 'To convert this file to an ECMAScript module, create a local package.json file with `{ "type": "module" }`.'),
|
|
The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* 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, 1 /* 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, 1 /* Error */, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", void 0, true),
|
|
Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, 1 /* Error */, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", void 0, true),
|
|
Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, 1 /* Error */, "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", void 0, true),
|
|
Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, 1 /* Error */, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", void 0, true),
|
|
The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, 1 /* Error */, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
|
|
The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, 1 /* Error */, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
|
|
This_type_parameter_might_need_an_extends_0_constraint: diag(2208, 1 /* Error */, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
|
|
The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, 1 /* Error */, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
|
|
The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, 1 /* Error */, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
|
|
Add_extends_constraint: diag(2211, 3 /* Message */, "Add_extends_constraint_2211", "Add `extends` constraint."),
|
|
Add_extends_constraint_to_all_type_parameters: diag(2212, 3 /* Message */, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
|
|
Duplicate_identifier_0: diag(2300, 1 /* Error */, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
|
|
Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, 1 /* Error */, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
|
|
Static_members_cannot_reference_class_type_parameters: diag(2302, 1 /* Error */, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
|
|
Circular_definition_of_import_alias_0: diag(2303, 1 /* Error */, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."),
|
|
Cannot_find_name_0: diag(2304, 1 /* Error */, "Cannot_find_name_0_2304", "Cannot find name '{0}'."),
|
|
Module_0_has_no_exported_member_1: diag(2305, 1 /* Error */, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."),
|
|
File_0_is_not_a_module: diag(2306, 1 /* Error */, "File_0_is_not_a_module_2306", "File '{0}' is not a module."),
|
|
Cannot_find_module_0_or_its_corresponding_type_declarations: diag(2307, 1 /* Error */, "Cannot_find_module_0_or_its_corresponding_type_declarations_2307", "Cannot find module '{0}' or its corresponding type declarations."),
|
|
Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, 1 /* Error */, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."),
|
|
An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."),
|
|
Type_0_recursively_references_itself_as_a_base_type: diag(2310, 1 /* Error */, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."),
|
|
Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function: diag(2311, 1 /* Error */, "Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function_2311", "Cannot find name '{0}'. Did you mean to write this in an async function?"),
|
|
An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, 1 /* Error */, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."),
|
|
Type_parameter_0_has_a_circular_constraint: diag(2313, 1 /* Error */, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."),
|
|
Generic_type_0_requires_1_type_argument_s: diag(2314, 1 /* Error */, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."),
|
|
Type_0_is_not_generic: diag(2315, 1 /* Error */, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."),
|
|
Global_type_0_must_be_a_class_or_interface_type: diag(2316, 1 /* Error */, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."),
|
|
Global_type_0_must_have_1_type_parameter_s: diag(2317, 1 /* Error */, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."),
|
|
Cannot_find_global_type_0: diag(2318, 1 /* Error */, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."),
|
|
Named_property_0_of_types_1_and_2_are_not_identical: diag(2319, 1 /* Error */, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."),
|
|
Interface_0_cannot_simultaneously_extend_types_1_and_2: diag(2320, 1 /* Error */, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."),
|
|
Excessive_stack_depth_comparing_types_0_and_1: diag(2321, 1 /* Error */, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."),
|
|
Type_0_is_not_assignable_to_type_1: diag(2322, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."),
|
|
Cannot_redeclare_exported_variable_0: diag(2323, 1 /* Error */, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."),
|
|
Property_0_is_missing_in_type_1: diag(2324, 1 /* Error */, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."),
|
|
Property_0_is_private_in_type_1_but_not_in_type_2: diag(2325, 1 /* Error */, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."),
|
|
Types_of_property_0_are_incompatible: diag(2326, 1 /* Error */, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."),
|
|
Property_0_is_optional_in_type_1_but_required_in_type_2: diag(2327, 1 /* Error */, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."),
|
|
Types_of_parameters_0_and_1_are_incompatible: diag(2328, 1 /* Error */, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."),
|
|
Index_signature_for_type_0_is_missing_in_type_1: diag(2329, 1 /* Error */, "Index_signature_for_type_0_is_missing_in_type_1_2329", "Index signature for type '{0}' is missing in type '{1}'."),
|
|
_0_and_1_index_signatures_are_incompatible: diag(2330, 1 /* Error */, "_0_and_1_index_signatures_are_incompatible_2330", "'{0}' and '{1}' index signatures are incompatible."),
|
|
this_cannot_be_referenced_in_a_module_or_namespace_body: diag(2331, 1 /* Error */, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."),
|
|
this_cannot_be_referenced_in_current_location: diag(2332, 1 /* Error */, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."),
|
|
this_cannot_be_referenced_in_constructor_arguments: diag(2333, 1 /* Error */, "this_cannot_be_referenced_in_constructor_arguments_2333", "'this' cannot be referenced in constructor arguments."),
|
|
this_cannot_be_referenced_in_a_static_property_initializer: diag(2334, 1 /* Error */, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."),
|
|
super_can_only_be_referenced_in_a_derived_class: diag(2335, 1 /* Error */, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."),
|
|
super_cannot_be_referenced_in_constructor_arguments: diag(2336, 1 /* Error */, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."),
|
|
Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: diag(2337, 1 /* Error */, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."),
|
|
super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: diag(2338, 1 /* Error */, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."),
|
|
Property_0_does_not_exist_on_type_1: diag(2339, 1 /* Error */, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."),
|
|
Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: diag(2340, 1 /* Error */, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."),
|
|
Property_0_is_private_and_only_accessible_within_class_1: diag(2341, 1 /* Error */, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."),
|
|
This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: diag(2343, 1 /* Error */, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."),
|
|
Type_0_does_not_satisfy_the_constraint_1: diag(2344, 1 /* Error */, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."),
|
|
Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, 1 /* Error */, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."),
|
|
Call_target_does_not_contain_any_signatures: diag(2346, 1 /* Error */, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."),
|
|
Untyped_function_calls_may_not_accept_type_arguments: diag(2347, 1 /* Error */, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."),
|
|
Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, 1 /* Error */, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"),
|
|
This_expression_is_not_callable: diag(2349, 1 /* Error */, "This_expression_is_not_callable_2349", "This expression is not callable."),
|
|
Only_a_void_function_can_be_called_with_the_new_keyword: diag(2350, 1 /* Error */, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."),
|
|
This_expression_is_not_constructable: diag(2351, 1 /* Error */, "This_expression_is_not_constructable_2351", "This expression is not constructable."),
|
|
Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: diag(2352, 1 /* Error */, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."),
|
|
Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: diag(2353, 1 /* Error */, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."),
|
|
This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: diag(2354, 1 /* Error */, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."),
|
|
A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: diag(2355, 1 /* Error */, "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'void' nor 'any' must return a value."),
|
|
An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2356, 1 /* Error */, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."),
|
|
The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, 1 /* Error */, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."),
|
|
The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, 1 /* 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, 1 /* 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_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, 1 /* 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, 1 /* 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, 1 /* 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."),
|
|
Operator_0_cannot_be_applied_to_types_1_and_2: diag(2365, 1 /* Error */, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."),
|
|
Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: diag(2366, 1 /* Error */, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."),
|
|
This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap: diag(2367, 1 /* Error */, "This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap_2367", "This comparison appears to be unintentional because the types '{0}' and '{1}' have no overlap."),
|
|
Type_parameter_name_cannot_be_0: diag(2368, 1 /* Error */, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."),
|
|
A_parameter_property_is_only_allowed_in_a_constructor_implementation: diag(2369, 1 /* Error */, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."),
|
|
A_rest_parameter_must_be_of_an_array_type: diag(2370, 1 /* Error */, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."),
|
|
A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: diag(2371, 1 /* Error */, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."),
|
|
Parameter_0_cannot_reference_itself: diag(2372, 1 /* Error */, "Parameter_0_cannot_reference_itself_2372", "Parameter '{0}' cannot reference itself."),
|
|
Parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, 1 /* Error */, "Parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Parameter '{0}' cannot reference identifier '{1}' declared after it."),
|
|
Duplicate_index_signature_for_type_0: diag(2374, 1 /* Error */, "Duplicate_index_signature_for_type_0_2374", "Duplicate index signature for type '{0}'."),
|
|
Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2375, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2375", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
|
|
A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, 1 /* Error */, "A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_2376", "A 'super' call must be the first statement in the constructor to refer to 'super' or 'this' when a derived class contains initialized properties, parameter properties, or private identifiers."),
|
|
Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, 1 /* Error */, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."),
|
|
A_get_accessor_must_return_a_value: diag(2378, 1 /* Error */, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."),
|
|
Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2379, 1 /* Error */, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_tr_2379", "Argument of type '{0}' is not assignable to parameter of type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."),
|
|
The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type: diag(2380, 1 /* Error */, "The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type_2380", "The return type of a 'get' accessor must be assignable to its 'set' accessor type"),
|
|
Overload_signatures_must_all_be_exported_or_non_exported: diag(2383, 1 /* Error */, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."),
|
|
Overload_signatures_must_all_be_ambient_or_non_ambient: diag(2384, 1 /* Error */, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."),
|
|
Overload_signatures_must_all_be_public_private_or_protected: diag(2385, 1 /* Error */, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."),
|
|
Overload_signatures_must_all_be_optional_or_required: diag(2386, 1 /* Error */, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."),
|
|
Function_overload_must_be_static: diag(2387, 1 /* Error */, "Function_overload_must_be_static_2387", "Function overload must be static."),
|
|
Function_overload_must_not_be_static: diag(2388, 1 /* Error */, "Function_overload_must_not_be_static_2388", "Function overload must not be static."),
|
|
Function_implementation_name_must_be_0: diag(2389, 1 /* Error */, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."),
|
|
Constructor_implementation_is_missing: diag(2390, 1 /* Error */, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."),
|
|
Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, 1 /* Error */, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."),
|
|
Multiple_constructor_implementations_are_not_allowed: diag(2392, 1 /* Error */, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."),
|
|
Duplicate_function_implementation: diag(2393, 1 /* Error */, "Duplicate_function_implementation_2393", "Duplicate function implementation."),
|
|
This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, 1 /* Error */, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."),
|
|
Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: diag(2395, 1 /* Error */, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."),
|
|
Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: diag(2396, 1 /* Error */, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."),
|
|
Declaration_name_conflicts_with_built_in_global_identifier_0: diag(2397, 1 /* Error */, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."),
|
|
constructor_cannot_be_used_as_a_parameter_property_name: diag(2398, 1 /* Error */, "constructor_cannot_be_used_as_a_parameter_property_name_2398", "'constructor' cannot be used as a parameter property name."),
|
|
Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, 1 /* Error */, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."),
|
|
Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, 1 /* Error */, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."),
|
|
A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2401, 1 /* Error */, "A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_in_2401", "A 'super' call must be a root-level statement within a constructor of a derived class that contains initialized properties, parameter properties, or private identifiers."),
|
|
Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, 1 /* Error */, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."),
|
|
Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, 1 /* Error */, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'."),
|
|
The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."),
|
|
The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: diag(2405, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."),
|
|
The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: diag(2406, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."),
|
|
The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: diag(2407, 1 /* Error */, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."),
|
|
Setters_cannot_return_a_value: diag(2408, 1 /* Error */, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."),
|
|
Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: diag(2409, 1 /* Error */, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."),
|
|
The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: diag(2410, 1 /* Error */, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."),
|
|
Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target: diag(2412, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2412", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target."),
|
|
Property_0_of_type_1_is_not_assignable_to_2_index_type_3: diag(2411, 1 /* Error */, "Property_0_of_type_1_is_not_assignable_to_2_index_type_3_2411", "Property '{0}' of type '{1}' is not assignable to '{2}' index type '{3}'."),
|
|
_0_index_type_1_is_not_assignable_to_2_index_type_3: diag(2413, 1 /* Error */, "_0_index_type_1_is_not_assignable_to_2_index_type_3_2413", "'{0}' index type '{1}' is not assignable to '{2}' index type '{3}'."),
|
|
Class_name_cannot_be_0: diag(2414, 1 /* Error */, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."),
|
|
Class_0_incorrectly_extends_base_class_1: diag(2415, 1 /* Error */, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."),
|
|
Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, 1 /* Error */, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."),
|
|
Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, 1 /* Error */, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."),
|
|
Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, 1 /* Error */, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."),
|
|
Types_of_construct_signatures_are_incompatible: diag(2419, 1 /* Error */, "Types_of_construct_signatures_are_incompatible_2419", "Types of construct signatures are incompatible."),
|
|
Class_0_incorrectly_implements_interface_1: diag(2420, 1 /* Error */, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."),
|
|
A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, 1 /* Error */, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."),
|
|
Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, 1 /* Error */, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."),
|
|
Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2425, 1 /* Error */, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."),
|
|
Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2426, 1 /* Error */, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."),
|
|
Interface_name_cannot_be_0: diag(2427, 1 /* Error */, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."),
|
|
All_declarations_of_0_must_have_identical_type_parameters: diag(2428, 1 /* Error */, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."),
|
|
Interface_0_incorrectly_extends_interface_1: diag(2430, 1 /* Error */, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."),
|
|
Enum_name_cannot_be_0: diag(2431, 1 /* Error */, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."),
|
|
In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: diag(2432, 1 /* Error */, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."),
|
|
A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: diag(2433, 1 /* Error */, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."),
|
|
A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: diag(2434, 1 /* Error */, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."),
|
|
Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: diag(2435, 1 /* Error */, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."),
|
|
Ambient_module_declaration_cannot_specify_relative_module_name: diag(2436, 1 /* Error */, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."),
|
|
Module_0_is_hidden_by_a_local_declaration_with_the_same_name: diag(2437, 1 /* Error */, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."),
|
|
Import_name_cannot_be_0: diag(2438, 1 /* Error */, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."),
|
|
Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: diag(2439, 1 /* Error */, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."),
|
|
Import_declaration_conflicts_with_local_declaration_of_0: diag(2440, 1 /* Error */, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."),
|
|
Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: diag(2441, 1 /* Error */, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."),
|
|
Types_have_separate_declarations_of_a_private_property_0: diag(2442, 1 /* Error */, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."),
|
|
Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: diag(2443, 1 /* Error */, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."),
|
|
Property_0_is_protected_in_type_1_but_public_in_type_2: diag(2444, 1 /* Error */, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."),
|
|
Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: diag(2445, 1 /* Error */, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."),
|
|
Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2: diag(2446, 1 /* Error */, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_cl_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'. This is an instance of class '{2}'."),
|
|
The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: diag(2447, 1 /* Error */, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."),
|
|
Block_scoped_variable_0_used_before_its_declaration: diag(2448, 1 /* Error */, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."),
|
|
Class_0_used_before_its_declaration: diag(2449, 1 /* Error */, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."),
|
|
Enum_0_used_before_its_declaration: diag(2450, 1 /* Error */, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."),
|
|
Cannot_redeclare_block_scoped_variable_0: diag(2451, 1 /* Error */, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."),
|
|
An_enum_member_cannot_have_a_numeric_name: diag(2452, 1 /* Error */, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."),
|
|
Variable_0_is_used_before_being_assigned: diag(2454, 1 /* Error */, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."),
|
|
Type_alias_0_circularly_references_itself: diag(2456, 1 /* Error */, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."),
|
|
Type_alias_name_cannot_be_0: diag(2457, 1 /* Error */, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."),
|
|
An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, 1 /* Error */, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."),
|
|
Module_0_declares_1_locally_but_it_is_not_exported: diag(2459, 1 /* Error */, "Module_0_declares_1_locally_but_it_is_not_exported_2459", "Module '{0}' declares '{1}' locally, but it is not exported."),
|
|
Module_0_declares_1_locally_but_it_is_exported_as_2: diag(2460, 1 /* Error */, "Module_0_declares_1_locally_but_it_is_exported_as_2_2460", "Module '{0}' declares '{1}' locally, but it is exported as '{2}'."),
|
|
Type_0_is_not_an_array_type: diag(2461, 1 /* Error */, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."),
|
|
A_rest_element_must_be_last_in_a_destructuring_pattern: diag(2462, 1 /* Error */, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."),
|
|
A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: diag(2463, 1 /* Error */, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."),
|
|
A_computed_property_name_must_be_of_type_string_number_symbol_or_any: diag(2464, 1 /* Error */, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."),
|
|
this_cannot_be_referenced_in_a_computed_property_name: diag(2465, 1 /* Error */, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."),
|
|
super_cannot_be_referenced_in_a_computed_property_name: diag(2466, 1 /* Error */, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."),
|
|
A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: diag(2467, 1 /* Error */, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."),
|
|
Cannot_find_global_value_0: diag(2468, 1 /* Error */, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."),
|
|
The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, 1 /* Error */, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."),
|
|
Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, 1 /* Error */, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."),
|
|
Enum_declarations_must_all_be_const_or_non_const: diag(2473, 1 /* Error */, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."),
|
|
const_enum_member_initializers_must_be_constant_expressions: diag(2474, 1 /* Error */, "const_enum_member_initializers_must_be_constant_expressions_2474", "const enum member initializers must be constant expressions."),
|
|
const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, 1 /* Error */, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."),
|
|
A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, 1 /* Error */, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."),
|
|
const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, 1 /* Error */, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."),
|
|
const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: diag(2478, 1 /* Error */, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."),
|
|
let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: diag(2480, 1 /* Error */, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."),
|
|
Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: diag(2481, 1 /* Error */, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."),
|
|
The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: diag(2483, 1 /* Error */, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."),
|
|
Export_declaration_conflicts_with_exported_declaration_of_0: diag(2484, 1 /* Error */, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."),
|
|
The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: diag(2487, 1 /* Error */, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."),
|
|
Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2488, 1 /* Error */, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."),
|
|
An_iterator_must_have_a_next_method: diag(2489, 1 /* Error */, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."),
|
|
The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property: diag(2490, 1 /* Error */, "The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the '{0}()' method of an iterator must have a 'value' property."),
|
|
The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: diag(2491, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."),
|
|
Cannot_redeclare_identifier_0_in_catch_clause: diag(2492, 1 /* Error */, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."),
|
|
Tuple_type_0_of_length_1_has_no_element_at_index_2: diag(2493, 1 /* Error */, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."),
|
|
Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: diag(2494, 1 /* Error */, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."),
|
|
Type_0_is_not_an_array_type_or_a_string_type: diag(2495, 1 /* Error */, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."),
|
|
The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: diag(2496, 1 /* Error */, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression."),
|
|
This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: diag(2497, 1 /* Error */, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."),
|
|
Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: diag(2498, 1 /* Error */, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."),
|
|
An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2499, 1 /* Error */, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."),
|
|
A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2500, 1 /* Error */, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."),
|
|
A_rest_element_cannot_contain_a_binding_pattern: diag(2501, 1 /* Error */, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."),
|
|
_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: diag(2502, 1 /* Error */, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."),
|
|
Cannot_find_namespace_0: diag(2503, 1 /* Error */, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."),
|
|
Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: diag(2504, 1 /* Error */, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."),
|
|
A_generator_cannot_have_a_void_type_annotation: diag(2505, 1 /* Error */, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."),
|
|
_0_is_referenced_directly_or_indirectly_in_its_own_base_expression: diag(2506, 1 /* Error */, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."),
|
|
Type_0_is_not_a_constructor_function_type: diag(2507, 1 /* Error */, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."),
|
|
No_base_constructor_has_the_specified_number_of_type_arguments: diag(2508, 1 /* Error */, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."),
|
|
Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2509, 1 /* Error */, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."),
|
|
Base_constructors_must_all_have_the_same_return_type: diag(2510, 1 /* Error */, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."),
|
|
Cannot_create_an_instance_of_an_abstract_class: diag(2511, 1 /* Error */, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."),
|
|
Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, 1 /* Error */, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."),
|
|
Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, 1 /* Error */, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."),
|
|
A_tuple_type_cannot_be_indexed_with_a_negative_value: diag(2514, 1 /* Error */, "A_tuple_type_cannot_be_indexed_with_a_negative_value_2514", "A tuple type cannot be indexed with a negative value."),
|
|
Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, 1 /* Error */, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."),
|
|
All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, 1 /* Error */, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."),
|
|
Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, 1 /* Error */, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."),
|
|
A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, 1 /* Error */, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."),
|
|
An_async_iterator_must_have_a_next_method: diag(2519, 1 /* Error */, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."),
|
|
Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: diag(2520, 1 /* Error */, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."),
|
|
The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method: diag(2522, 1 /* Error */, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_usi_2522", "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method."),
|
|
yield_expressions_cannot_be_used_in_a_parameter_initializer: diag(2523, 1 /* Error */, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."),
|
|
await_expressions_cannot_be_used_in_a_parameter_initializer: diag(2524, 1 /* Error */, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."),
|
|
Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: diag(2525, 1 /* Error */, "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", "Initializer provides no value for this binding element and the binding element has no default value."),
|
|
A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: diag(2526, 1 /* Error */, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."),
|
|
The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: diag(2527, 1 /* Error */, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."),
|
|
A_module_cannot_have_multiple_default_exports: diag(2528, 1 /* Error */, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."),
|
|
Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: diag(2529, 1 /* Error */, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."),
|
|
Property_0_is_incompatible_with_index_signature: diag(2530, 1 /* Error */, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."),
|
|
Object_is_possibly_null: diag(2531, 1 /* Error */, "Object_is_possibly_null_2531", "Object is possibly 'null'."),
|
|
Object_is_possibly_undefined: diag(2532, 1 /* Error */, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."),
|
|
Object_is_possibly_null_or_undefined: diag(2533, 1 /* Error */, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."),
|
|
A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, 1 /* Error */, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."),
|
|
Type_0_cannot_be_used_to_index_type_1: diag(2536, 1 /* Error */, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."),
|
|
Type_0_has_no_matching_index_signature_for_type_1: diag(2537, 1 /* Error */, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."),
|
|
Type_0_cannot_be_used_as_an_index_type: diag(2538, 1 /* Error */, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."),
|
|
Cannot_assign_to_0_because_it_is_not_a_variable: diag(2539, 1 /* Error */, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."),
|
|
Cannot_assign_to_0_because_it_is_a_read_only_property: diag(2540, 1 /* Error */, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."),
|
|
Index_signature_in_type_0_only_permits_reading: diag(2542, 1 /* Error */, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."),
|
|
Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: diag(2543, 1 /* Error */, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."),
|
|
Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: diag(2544, 1 /* Error */, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."),
|
|
A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: diag(2545, 1 /* Error */, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."),
|
|
The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, 1 /* Error */, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."),
|
|
Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, 1 /* Error */, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
|
|
Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, 1 /* Error */, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."),
|
|
Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later: diag(2550, 1 /* Error */, "Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_c_2550", "Property '{0}' does not exist on type '{1}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{2}' or later."),
|
|
Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, 1 /* Error */, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"),
|
|
Cannot_find_name_0_Did_you_mean_1: diag(2552, 1 /* Error */, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"),
|
|
Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, 1 /* Error */, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."),
|
|
Expected_0_arguments_but_got_1: diag(2554, 1 /* Error */, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."),
|
|
Expected_at_least_0_arguments_but_got_1: diag(2555, 1 /* Error */, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."),
|
|
A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter: diag(2556, 1 /* Error */, "A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter_2556", "A spread argument must either have a tuple type or be passed to a rest parameter."),
|
|
Expected_0_type_arguments_but_got_1: diag(2558, 1 /* Error */, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."),
|
|
Type_0_has_no_properties_in_common_with_type_1: diag(2559, 1 /* Error */, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."),
|
|
Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: diag(2560, 1 /* Error */, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"),
|
|
Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: diag(2561, 1 /* Error */, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"),
|
|
Base_class_expressions_cannot_reference_class_type_parameters: diag(2562, 1 /* Error */, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."),
|
|
The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: diag(2563, 1 /* Error */, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."),
|
|
Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: diag(2564, 1 /* Error */, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."),
|
|
Property_0_is_used_before_being_assigned: diag(2565, 1 /* Error */, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."),
|
|
A_rest_element_cannot_have_a_property_name: diag(2566, 1 /* Error */, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."),
|
|
Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, 1 /* Error */, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."),
|
|
Property_0_may_not_exist_on_type_1_Did_you_mean_2: diag(2568, 1 /* Error */, "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568", "Property '{0}' may not exist on type '{1}'. Did you mean '{2}'?"),
|
|
Could_not_find_name_0_Did_you_mean_1: diag(2570, 1 /* Error */, "Could_not_find_name_0_Did_you_mean_1_2570", "Could not find name '{0}'. Did you mean '{1}'?"),
|
|
Object_is_of_type_unknown: diag(2571, 1 /* Error */, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
|
|
A_rest_element_type_must_be_an_array_type: diag(2574, 1 /* 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, 1 /* 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_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead: diag(2576, 1 /* 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, 1 /* Error */, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."),
|
|
Unused_ts_expect_error_directive: diag(2578, 1 /* 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, 1 /* 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`."),
|
|
Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery: diag(2581, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery`."),
|
|
Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha: diag(2582, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha`."),
|
|
Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later: diag(2583, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{1}' or later."),
|
|
Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'."),
|
|
_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, 1 /* Error */, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later."),
|
|
Cannot_assign_to_0_because_it_is_a_constant: diag(2588, 1 /* Error */, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."),
|
|
Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, 1 /* Error */, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."),
|
|
Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, 1 /* Error */, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."),
|
|
Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig."),
|
|
Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery` and then add 'jquery' to the types field in your tsconfig."),
|
|
Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, 1 /* Error */, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha` and then add 'jest' or 'mocha' to the types field in your tsconfig."),
|
|
This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, 1 /* Error */, "This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag_2594", "This module is declared with 'export =', and can only be used with a default import when using the '{0}' flag."),
|
|
_0_can_only_be_imported_by_using_a_default_import: diag(2595, 1 /* Error */, "_0_can_only_be_imported_by_using_a_default_import_2595", "'{0}' can only be imported by using a default import."),
|
|
_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2596, 1 /* Error */, "_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import_2596", "'{0}' can only be imported by turning on the 'esModuleInterop' flag and using a default import."),
|
|
_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import: diag(2597, 1 /* Error */, "_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import_2597", "'{0}' can only be imported by using a 'require' call or by using a default import."),
|
|
_0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2598, 1 /* Error */, "_0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using__2598", "'{0}' can only be imported by using a 'require' call or by turning on the 'esModuleInterop' flag and using a default import."),
|
|
JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: diag(2602, 1 /* Error */, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."),
|
|
Property_0_in_type_1_is_not_assignable_to_type_2: diag(2603, 1 /* Error */, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."),
|
|
JSX_element_type_0_does_not_have_any_construct_or_call_signatures: diag(2604, 1 /* Error */, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."),
|
|
Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: diag(2606, 1 /* Error */, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."),
|
|
JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: diag(2607, 1 /* Error */, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."),
|
|
The_global_type_JSX_0_may_not_have_more_than_one_property: diag(2608, 1 /* Error */, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."),
|
|
JSX_spread_child_must_be_an_array_type: diag(2609, 1 /* Error */, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."),
|
|
_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property: diag(2610, 1 /* Error */, "_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property_2610", "'{0}' is defined as an accessor in class '{1}', but is overridden here in '{2}' as an instance property."),
|
|
_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor: diag(2611, 1 /* Error */, "_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor_2611", "'{0}' is defined as a property in class '{1}', but is overridden here in '{2}' as an accessor."),
|
|
Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration: diag(2612, 1 /* Error */, "Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_2612", "Property '{0}' will overwrite the base property in '{1}'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration."),
|
|
Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead: diag(2613, 1 /* Error */, "Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead_2613", "Module '{0}' has no default export. Did you mean to use 'import { {1} } from {0}' instead?"),
|
|
Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead: diag(2614, 1 /* Error */, "Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead_2614", "Module '{0}' has no exported member '{1}'. Did you mean to use 'import {1} from {0}' instead?"),
|
|
Type_of_property_0_circularly_references_itself_in_mapped_type_1: diag(2615, 1 /* Error */, "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615", "Type of property '{0}' circularly references itself in mapped type '{1}'."),
|
|
_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import: diag(2616, 1 /* Error */, "_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import_2616", "'{0}' can only be imported by using 'import {1} = require({2})' or a default import."),
|
|
_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2617, 1 /* Error */, "_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_us_2617", "'{0}' can only be imported by using 'import {1} = require({2})' or by turning on the 'esModuleInterop' flag and using a default import."),
|
|
Source_has_0_element_s_but_target_requires_1: diag(2618, 1 /* Error */, "Source_has_0_element_s_but_target_requires_1_2618", "Source has {0} element(s) but target requires {1}."),
|
|
Source_has_0_element_s_but_target_allows_only_1: diag(2619, 1 /* 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, 1 /* 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, 1 /* Error */, "Target_allows_only_0_element_s_but_source_may_have_more_2621", "Target allows only {0} element(s) but source may have more."),
|
|
Source_provides_no_match_for_required_element_at_position_0_in_target: diag(2623, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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_assign_to_0_because_it_is_an_enum: diag(2628, 1 /* Error */, "Cannot_assign_to_0_because_it_is_an_enum_2628", "Cannot assign to '{0}' because it is an enum."),
|
|
Cannot_assign_to_0_because_it_is_a_class: diag(2629, 1 /* Error */, "Cannot_assign_to_0_because_it_is_a_class_2629", "Cannot assign to '{0}' because it is a class."),
|
|
Cannot_assign_to_0_because_it_is_a_function: diag(2630, 1 /* Error */, "Cannot_assign_to_0_because_it_is_a_function_2630", "Cannot assign to '{0}' because it is a function."),
|
|
Cannot_assign_to_0_because_it_is_a_namespace: diag(2631, 1 /* Error */, "Cannot_assign_to_0_because_it_is_a_namespace_2631", "Cannot assign to '{0}' because it is a namespace."),
|
|
Cannot_assign_to_0_because_it_is_an_import: diag(2632, 1 /* Error */, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."),
|
|
JSX_property_access_expressions_cannot_include_JSX_namespace_names: diag(2633, 1 /* Error */, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"),
|
|
_0_index_signatures_are_incompatible: diag(2634, 1 /* Error */, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
|
|
Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, 1 /* Error */, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
|
|
Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: diag(2636, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."),
|
|
Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: diag(2637, 1 /* Error */, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."),
|
|
Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator: diag(2638, 1 /* Error */, "Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operato_2638", "Type '{0}' may represent a primitive value, which is not permitted as the right operand of the 'in' operator."),
|
|
Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, 1 /* 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, 1 /* 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, 1 /* 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."),
|
|
Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, 1 /* Error */, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."),
|
|
JSX_expressions_must_have_one_parent_element: diag(2657, 1 /* Error */, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."),
|
|
Type_0_provides_no_match_for_the_signature_1: diag(2658, 1 /* Error */, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."),
|
|
super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, 1 /* Error */, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."),
|
|
super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: diag(2660, 1 /* Error */, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."),
|
|
Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: diag(2661, 1 /* Error */, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."),
|
|
Cannot_find_name_0_Did_you_mean_the_static_member_1_0: diag(2662, 1 /* Error */, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"),
|
|
Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: diag(2663, 1 /* Error */, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"),
|
|
Invalid_module_name_in_augmentation_module_0_cannot_be_found: diag(2664, 1 /* Error */, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."),
|
|
Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: diag(2665, 1 /* Error */, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."),
|
|
Exports_and_export_assignments_are_not_permitted_in_module_augmentations: diag(2666, 1 /* Error */, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."),
|
|
Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: diag(2667, 1 /* Error */, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."),
|
|
export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: diag(2668, 1 /* Error */, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."),
|
|
Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: diag(2669, 1 /* Error */, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."),
|
|
Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: diag(2670, 1 /* Error */, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."),
|
|
Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: diag(2671, 1 /* Error */, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."),
|
|
Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: diag(2672, 1 /* Error */, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."),
|
|
Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: diag(2673, 1 /* Error */, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."),
|
|
Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: diag(2674, 1 /* Error */, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."),
|
|
Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: diag(2675, 1 /* Error */, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."),
|
|
Accessors_must_both_be_abstract_or_non_abstract: diag(2676, 1 /* Error */, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."),
|
|
A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: diag(2677, 1 /* Error */, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."),
|
|
Type_0_is_not_comparable_to_type_1: diag(2678, 1 /* Error */, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."),
|
|
A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: diag(2679, 1 /* Error */, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."),
|
|
A_0_parameter_must_be_the_first_parameter: diag(2680, 1 /* Error */, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."),
|
|
A_constructor_cannot_have_a_this_parameter: diag(2681, 1 /* Error */, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."),
|
|
this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: diag(2683, 1 /* Error */, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."),
|
|
The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: diag(2684, 1 /* Error */, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."),
|
|
The_this_types_of_each_signature_are_incompatible: diag(2685, 1 /* Error */, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."),
|
|
_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: diag(2686, 1 /* Error */, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."),
|
|
All_declarations_of_0_must_have_identical_modifiers: diag(2687, 1 /* Error */, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."),
|
|
Cannot_find_type_definition_file_for_0: diag(2688, 1 /* Error */, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."),
|
|
Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, 1 /* Error */, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"),
|
|
_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0: diag(2690, 1 /* Error */, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0_2690", "'{0}' only refers to a type, but is being used as a value here. Did you mean to use '{1} in {0}'?"),
|
|
An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, 1 /* Error */, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."),
|
|
_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, 1 /* Error */, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."),
|
|
_0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, 1 /* Error */, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."),
|
|
Namespace_0_has_no_exported_member_1: diag(2694, 1 /* Error */, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."),
|
|
Left_side_of_comma_operator_is_unused_and_has_no_side_effects: diag(2695, 1 /* Error */, "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", "Left side of comma operator is unused and has no side effects.", true),
|
|
The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, 1 /* Error */, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"),
|
|
An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2697, 1 /* Error */, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."),
|
|
Spread_types_may_only_be_created_from_object_types: diag(2698, 1 /* Error */, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."),
|
|
Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: diag(2699, 1 /* Error */, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."),
|
|
Rest_types_may_only_be_created_from_object_types: diag(2700, 1 /* Error */, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."),
|
|
The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: diag(2701, 1 /* Error */, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."),
|
|
_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: diag(2702, 1 /* Error */, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."),
|
|
The_operand_of_a_delete_operator_must_be_a_property_reference: diag(2703, 1 /* Error */, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a 'delete' operator must be a property reference."),
|
|
The_operand_of_a_delete_operator_cannot_be_a_read_only_property: diag(2704, 1 /* Error */, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a 'delete' operator cannot be a read-only property."),
|
|
An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2705, 1 /* Error */, "An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_de_2705", "An async function or method in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."),
|
|
Required_type_parameters_may_not_follow_optional_type_parameters: diag(2706, 1 /* Error */, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."),
|
|
Generic_type_0_requires_between_1_and_2_type_arguments: diag(2707, 1 /* Error */, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."),
|
|
Cannot_use_namespace_0_as_a_value: diag(2708, 1 /* Error */, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."),
|
|
Cannot_use_namespace_0_as_a_type: diag(2709, 1 /* Error */, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."),
|
|
_0_are_specified_twice_The_attribute_named_0_will_be_overwritten: diag(2710, 1 /* Error */, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."),
|
|
A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2711, 1 /* Error */, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."),
|
|
A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2712, 1 /* Error */, "A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declarat_2712", "A dynamic import call in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."),
|
|
Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: diag(2713, 1 /* Error */, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", `Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}["{1}"]'?`),
|
|
The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: diag(2714, 1 /* Error */, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."),
|
|
Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: diag(2715, 1 /* Error */, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."),
|
|
Type_parameter_0_has_a_circular_default: diag(2716, 1 /* Error */, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."),
|
|
Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: diag(2717, 1 /* Error */, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type. Property '{0}' must be of type '{1}', but here has type '{2}'."),
|
|
Duplicate_property_0: diag(2718, 1 /* Error */, "Duplicate_property_0_2718", "Duplicate property '{0}'."),
|
|
Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: diag(2719, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."),
|
|
Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: diag(2720, 1 /* Error */, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"),
|
|
Cannot_invoke_an_object_which_is_possibly_null: diag(2721, 1 /* Error */, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."),
|
|
Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, 1 /* Error */, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."),
|
|
Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, 1 /* Error */, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."),
|
|
_0_has_no_exported_member_named_1_Did_you_mean_2: diag(2724, 1 /* Error */, "_0_has_no_exported_member_named_1_Did_you_mean_2_2724", "'{0}' has no exported member named '{1}'. Did you mean '{2}'?"),
|
|
Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, 1 /* Error */, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."),
|
|
Cannot_find_lib_definition_for_0: diag(2726, 1 /* Error */, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."),
|
|
Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, 1 /* Error */, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"),
|
|
_0_is_declared_here: diag(2728, 3 /* Message */, "_0_is_declared_here_2728", "'{0}' is declared here."),
|
|
Property_0_is_used_before_its_initialization: diag(2729, 1 /* Error */, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."),
|
|
An_arrow_function_cannot_have_a_this_parameter: diag(2730, 1 /* Error */, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."),
|
|
Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, 1 /* Error */, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."),
|
|
Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, 1 /* Error */, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension."),
|
|
Property_0_was_also_declared_here: diag(2733, 1 /* Error */, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."),
|
|
Are_you_missing_a_semicolon: diag(2734, 1 /* Error */, "Are_you_missing_a_semicolon_2734", "Are you missing a semicolon?"),
|
|
Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, 1 /* Error */, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"),
|
|
Operator_0_cannot_be_applied_to_type_1: diag(2736, 1 /* Error */, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."),
|
|
BigInt_literals_are_not_available_when_targeting_lower_than_ES2020: diag(2737, 1 /* Error */, "BigInt_literals_are_not_available_when_targeting_lower_than_ES2020_2737", "BigInt literals are not available when targeting lower than ES2020."),
|
|
An_outer_value_of_this_is_shadowed_by_this_container: diag(2738, 3 /* Message */, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."),
|
|
Type_0_is_missing_the_following_properties_from_type_1_Colon_2: diag(2739, 1 /* Error */, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"),
|
|
Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: diag(2740, 1 /* Error */, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."),
|
|
Property_0_is_missing_in_type_1_but_required_in_type_2: diag(2741, 1 /* Error */, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."),
|
|
The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2742, 1 /* Error */, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."),
|
|
No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: diag(2743, 1 /* Error */, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."),
|
|
Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: diag(2744, 1 /* Error */, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."),
|
|
This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: diag(2745, 1 /* Error */, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."),
|
|
This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: diag(2746, 1 /* Error */, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."),
|
|
_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: diag(2747, 1 /* Error */, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."),
|
|
Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided: diag(2748, 1 /* Error */, "Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided_2748", "Cannot access ambient const enums when the '--isolatedModules' flag is provided."),
|
|
_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0: diag(2749, 1 /* Error */, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0_2749", "'{0}' refers to a value, but is being used as a type here. Did you mean 'typeof {0}'?"),
|
|
The_implementation_signature_is_declared_here: diag(2750, 1 /* Error */, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."),
|
|
Circularity_originates_in_type_at_this_location: diag(2751, 1 /* Error */, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."),
|
|
The_first_export_default_is_here: diag(2752, 1 /* Error */, "The_first_export_default_is_here_2752", "The first export default is here."),
|
|
Another_export_default_is_here: diag(2753, 1 /* Error */, "Another_export_default_is_here_2753", "Another export default is here."),
|
|
super_may_not_use_type_arguments: diag(2754, 1 /* Error */, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."),
|
|
No_constituent_of_type_0_is_callable: diag(2755, 1 /* Error */, "No_constituent_of_type_0_is_callable_2755", "No constituent of type '{0}' is callable."),
|
|
Not_all_constituents_of_type_0_are_callable: diag(2756, 1 /* Error */, "Not_all_constituents_of_type_0_are_callable_2756", "Not all constituents of type '{0}' are callable."),
|
|
Type_0_has_no_call_signatures: diag(2757, 1 /* Error */, "Type_0_has_no_call_signatures_2757", "Type '{0}' has no call signatures."),
|
|
Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2758, 1 /* Error */, "Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_2758", "Each member of the union type '{0}' has signatures, but none of those signatures are compatible with each other."),
|
|
No_constituent_of_type_0_is_constructable: diag(2759, 1 /* Error */, "No_constituent_of_type_0_is_constructable_2759", "No constituent of type '{0}' is constructable."),
|
|
Not_all_constituents_of_type_0_are_constructable: diag(2760, 1 /* Error */, "Not_all_constituents_of_type_0_are_constructable_2760", "Not all constituents of type '{0}' are constructable."),
|
|
Type_0_has_no_construct_signatures: diag(2761, 1 /* Error */, "Type_0_has_no_construct_signatures_2761", "Type '{0}' has no construct signatures."),
|
|
Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2762, 1 /* Error */, "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762", "Each member of the union type '{0}' has construct signatures, but none of those signatures are compatible with each other."),
|
|
Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0: diag(2763, 1 /* Error */, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_s_2763", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'."),
|
|
Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0: diag(2764, 1 /* Error */, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_al_2764", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'."),
|
|
Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0: diag(2765, 1 /* Error */, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring__2765", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'."),
|
|
Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0: diag(2766, 1 /* Error */, "Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_co_2766", "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'."),
|
|
The_0_property_of_an_iterator_must_be_a_method: diag(2767, 1 /* Error */, "The_0_property_of_an_iterator_must_be_a_method_2767", "The '{0}' property of an iterator must be a method."),
|
|
The_0_property_of_an_async_iterator_must_be_a_method: diag(2768, 1 /* Error */, "The_0_property_of_an_async_iterator_must_be_a_method_2768", "The '{0}' property of an async iterator must be a method."),
|
|
No_overload_matches_this_call: diag(2769, 1 /* Error */, "No_overload_matches_this_call_2769", "No overload matches this call."),
|
|
The_last_overload_gave_the_following_error: diag(2770, 1 /* Error */, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."),
|
|
The_last_overload_is_declared_here: diag(2771, 1 /* Error */, "The_last_overload_is_declared_here_2771", "The last overload is declared here."),
|
|
Overload_0_of_1_2_gave_the_following_error: diag(2772, 1 /* Error */, "Overload_0_of_1_2_gave_the_following_error_2772", "Overload {0} of {1}, '{2}', gave the following error."),
|
|
Did_you_forget_to_use_await: diag(2773, 1 /* Error */, "Did_you_forget_to_use_await_2773", "Did you forget to use 'await'?"),
|
|
This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead: diag(2774, 1 /* Error */, "This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_2774", "This condition will always return true since this function is always defined. Did you mean to call it instead?"),
|
|
Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation: diag(2775, 1 /* Error */, "Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation_2775", "Assertions require every name in the call target to be declared with an explicit type annotation."),
|
|
Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name: diag(2776, 1 /* Error */, "Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name_2776", "Assertions require the call target to be an identifier or qualified name."),
|
|
The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access: diag(2777, 1 /* Error */, "The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access_2777", "The operand of an increment or decrement operator may not be an optional property access."),
|
|
The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access: diag(2778, 1 /* Error */, "The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access_2778", "The target of an object rest assignment may not be an optional property access."),
|
|
The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access: diag(2779, 1 /* Error */, "The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access_2779", "The left-hand side of an assignment expression may not be an optional property access."),
|
|
The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access: diag(2780, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access_2780", "The left-hand side of a 'for...in' statement may not be an optional property access."),
|
|
The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access: diag(2781, 1 /* Error */, "The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access_2781", "The left-hand side of a 'for...of' statement may not be an optional property access."),
|
|
_0_needs_an_explicit_type_annotation: diag(2782, 3 /* Message */, "_0_needs_an_explicit_type_annotation_2782", "'{0}' needs an explicit type annotation."),
|
|
_0_is_specified_more_than_once_so_this_usage_will_be_overwritten: diag(2783, 1 /* Error */, "_0_is_specified_more_than_once_so_this_usage_will_be_overwritten_2783", "'{0}' is specified more than once, so this usage will be overwritten."),
|
|
get_and_set_accessors_cannot_declare_this_parameters: diag(2784, 1 /* Error */, "get_and_set_accessors_cannot_declare_this_parameters_2784", "'get' and 'set' accessors cannot declare 'this' parameters."),
|
|
This_spread_always_overwrites_this_property: diag(2785, 1 /* Error */, "This_spread_always_overwrites_this_property_2785", "This spread always overwrites this property."),
|
|
_0_cannot_be_used_as_a_JSX_component: diag(2786, 1 /* Error */, "_0_cannot_be_used_as_a_JSX_component_2786", "'{0}' cannot be used as a JSX component."),
|
|
Its_return_type_0_is_not_a_valid_JSX_element: diag(2787, 1 /* Error */, "Its_return_type_0_is_not_a_valid_JSX_element_2787", "Its return type '{0}' is not a valid JSX element."),
|
|
Its_instance_type_0_is_not_a_valid_JSX_element: diag(2788, 1 /* Error */, "Its_instance_type_0_is_not_a_valid_JSX_element_2788", "Its instance type '{0}' is not a valid JSX element."),
|
|
Its_element_type_0_is_not_a_valid_JSX_element: diag(2789, 1 /* Error */, "Its_element_type_0_is_not_a_valid_JSX_element_2789", "Its element type '{0}' is not a valid JSX element."),
|
|
The_operand_of_a_delete_operator_must_be_optional: diag(2790, 1 /* Error */, "The_operand_of_a_delete_operator_must_be_optional_2790", "The operand of a 'delete' operator must be optional."),
|
|
Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later: diag(2791, 1 /* Error */, "Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_lat_2791", "Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later."),
|
|
Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option: diag(2792, 1 /* Error */, "Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_th_2792", "Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option to 'node', or to add aliases to the 'paths' option?"),
|
|
The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible: diag(2793, 1 /* Error */, "The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_2793", "The call would have succeeded against this implementation, but implementation signatures of overloads are not externally visible."),
|
|
Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise: diag(2794, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Expression_produces_a_tuple_type_that_is_too_large_to_represent_2800", "Expression produces a tuple type that is too large to represent."),
|
|
This_condition_will_always_return_true_since_this_0_is_always_defined: diag(2801, 1 /* Error */, "This_condition_will_always_return_true_since_this_0_is_always_defined_2801", "This condition will always return true since this '{0}' is always defined."),
|
|
Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: diag(2802, 1 /* Error */, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."),
|
|
Cannot_assign_to_private_method_0_Private_methods_are_not_writable: diag(2803, 1 /* Error */, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."),
|
|
Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: diag(2804, 1 /* Error */, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."),
|
|
Private_accessor_was_defined_without_a_getter: diag(2806, 1 /* Error */, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."),
|
|
This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, 1 /* Error */, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."),
|
|
A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, 1 /* Error */, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"),
|
|
Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, 1 /* Error */, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."),
|
|
Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments: diag(2810, 1 /* Error */, "Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_2810", "Expected 1 argument, but got 0. 'new Promise()' needs a JSDoc hint to produce a 'resolve' that can be called without arguments."),
|
|
Initializer_for_property_0: diag(2811, 1 /* Error */, "Initializer_for_property_0_2811", "Initializer for property '{0}'"),
|
|
Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, 1 /* Error */, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."),
|
|
Class_declaration_cannot_implement_overload_list_for_0: diag(2813, 1 /* Error */, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."),
|
|
Function_with_bodies_can_only_merge_with_classes_that_are_ambient: diag(2814, 1 /* Error */, "Function_with_bodies_can_only_merge_with_classes_that_are_ambient_2814", "Function with bodies can only merge with classes that are ambient."),
|
|
arguments_cannot_be_referenced_in_property_initializers: diag(2815, 1 /* Error */, "arguments_cannot_be_referenced_in_property_initializers_2815", "'arguments' cannot be referenced in property initializers."),
|
|
Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class: diag(2816, 1 /* Error */, "Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class_2816", "Cannot use 'this' in a static property initializer of a decorated class."),
|
|
Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block: diag(2817, 1 /* Error */, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block_2817", "Property '{0}' has no initializer and is not definitely assigned in a class static block."),
|
|
Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, 1 /* Error */, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."),
|
|
Namespace_name_cannot_be_0: diag(2819, 1 /* Error */, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."),
|
|
Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"),
|
|
Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext: diag(2821, 1 /* Error */, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."),
|
|
Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, 1 /* Error */, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
|
|
Cannot_find_namespace_0_Did_you_mean_1: diag(2833, 1 /* Error */, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
|
|
Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, 1 /* Error */, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Consider adding an extension to the import path."),
|
|
Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0: diag(2835, 1 /* Error */, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean '{0}'?"),
|
|
Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, 1 /* Error */, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."),
|
|
Import_assertion_values_must_be_string_literal_expressions: diag(2837, 1 /* Error */, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."),
|
|
All_declarations_of_0_must_have_identical_constraints: diag(2838, 1 /* Error */, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."),
|
|
This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, 1 /* Error */, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
|
|
An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, 1 /* Error */, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
|
|
The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, 1 /* Error */, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
|
|
_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, 1 /* Error */, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
|
|
We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, 1 /* Error */, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
|
|
Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, 1 /* Error */, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
|
|
This_condition_will_always_return_0: diag(2845, 1 /* Error */, "This_condition_will_always_return_0_2845", "This condition will always return '{0}'."),
|
|
Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* 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, 1 /* 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, 1 /* 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}'."),
|
|
Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4006, 1 /* Error */, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."),
|
|
Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4008, 1 /* Error */, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."),
|
|
Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4010, 1 /* Error */, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."),
|
|
Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4012, 1 /* Error */, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."),
|
|
Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4014, 1 /* Error */, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."),
|
|
Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, 1 /* Error */, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."),
|
|
Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, 1 /* Error */, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."),
|
|
extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, 1 /* Error */, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."),
|
|
extends_clause_of_exported_class_has_or_is_using_private_name_0: diag(4021, 1 /* Error */, "extends_clause_of_exported_class_has_or_is_using_private_name_0_4021", "'extends' clause of exported class has or is using private name '{0}'."),
|
|
extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, 1 /* Error */, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."),
|
|
Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, 1 /* Error */, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, 1 /* Error */, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."),
|
|
Exported_variable_0_has_or_is_using_private_name_1: diag(4025, 1 /* Error */, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."),
|
|
Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4026, 1 /* Error */, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4027, 1 /* Error */, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
|
|
Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4028, 1 /* Error */, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."),
|
|
Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4029, 1 /* Error */, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4030, 1 /* Error */, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
|
|
Public_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4031, 1 /* Error */, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."),
|
|
Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4032, 1 /* Error */, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."),
|
|
Property_0_of_exported_interface_has_or_is_using_private_name_1: diag(4033, 1 /* Error */, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."),
|
|
Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4034, 1 /* Error */, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4035, 1 /* Error */, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."),
|
|
Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4036, 1 /* Error */, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4037, 1 /* Error */, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."),
|
|
Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4038, 1 /* Error */, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4039, 1 /* Error */, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4040, 1 /* Error */, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."),
|
|
Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4041, 1 /* Error */, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4042, 1 /* Error */, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4043, 1 /* Error */, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."),
|
|
Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4044, 1 /* Error */, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4045, 1 /* Error */, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."),
|
|
Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4046, 1 /* Error */, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4047, 1 /* Error */, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."),
|
|
Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4048, 1 /* Error */, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4049, 1 /* Error */, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."),
|
|
Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4050, 1 /* Error */, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."),
|
|
Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4051, 1 /* Error */, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: diag(4052, 1 /* Error */, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."),
|
|
Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4053, 1 /* Error */, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."),
|
|
Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4054, 1 /* Error */, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: diag(4055, 1 /* Error */, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."),
|
|
Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4056, 1 /* Error */, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: diag(4057, 1 /* Error */, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."),
|
|
Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4058, 1 /* Error */, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."),
|
|
Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: diag(4059, 1 /* Error */, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."),
|
|
Return_type_of_exported_function_has_or_is_using_private_name_0: diag(4060, 1 /* Error */, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."),
|
|
Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4061, 1 /* Error */, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4062, 1 /* Error */, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: diag(4063, 1 /* Error */, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."),
|
|
Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4064, 1 /* Error */, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4065, 1 /* Error */, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."),
|
|
Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4066, 1 /* Error */, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4067, 1 /* Error */, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."),
|
|
Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4068, 1 /* Error */, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4069, 1 /* Error */, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4070, 1 /* Error */, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."),
|
|
Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4071, 1 /* Error */, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4072, 1 /* Error */, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4073, 1 /* Error */, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."),
|
|
Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4074, 1 /* Error */, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4075, 1 /* Error */, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."),
|
|
Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4076, 1 /* Error */, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: diag(4077, 1 /* Error */, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4078, 1 /* Error */, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."),
|
|
Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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}'."),
|
|
Property_0_of_exported_class_expression_may_not_be_private_or_protected: diag(4094, 1 /* Error */, "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094", "Property '{0}' of exported class expression may not be private or protected."),
|
|
Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4095, 1 /* Error */, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4096, 1 /* Error */, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
|
|
Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4097, 1 /* Error */, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."),
|
|
Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4098, 1 /* Error */, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."),
|
|
Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4099, 1 /* Error */, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."),
|
|
Public_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4100, 1 /* Error */, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."),
|
|
Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4101, 1 /* Error */, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."),
|
|
Method_0_of_exported_interface_has_or_is_using_private_name_1: diag(4102, 1 /* Error */, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."),
|
|
Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: diag(4103, 1 /* Error */, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."),
|
|
The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1: diag(4104, 1 /* Error */, "The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1_4104", "The type '{0}' is 'readonly' and cannot be assigned to the mutable type '{1}'."),
|
|
Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter: diag(4105, 1 /* Error */, "Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter_4105", "Private or protected member '{0}' cannot be accessed on a type parameter."),
|
|
Parameter_0_of_accessor_has_or_is_using_private_name_1: diag(4106, 1 /* Error */, "Parameter_0_of_accessor_has_or_is_using_private_name_1_4106", "Parameter '{0}' of accessor has or is using private name '{1}'."),
|
|
Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2: diag(4107, 1 /* Error */, "Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2_4107", "Parameter '{0}' of accessor has or is using name '{1}' from private module '{2}'."),
|
|
Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4108, 1 /* 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, 1 /* Error */, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."),
|
|
Tuple_type_arguments_circularly_reference_themselves: diag(4110, 1 /* 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, 1 /* 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}']."),
|
|
This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class: diag(4112, 1 /* Error */, "This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another__4112", "This member cannot have an 'override' modifier because its containing class '{0}' does not extend another class."),
|
|
This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0: diag(4113, 1 /* Error */, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_4113", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'."),
|
|
This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0: diag(4114, 1 /* Error */, "This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0_4114", "This member must have an 'override' modifier because it overrides a member in the base class '{0}'."),
|
|
This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0: diag(4115, 1 /* Error */, "This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0_4115", "This parameter property must have an 'override' modifier because it overrides a member in base class '{0}'."),
|
|
This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0: diag(4116, 1 /* Error */, "This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared__4116", "This member must have an 'override' modifier because it overrides an abstract method that is declared in the base class '{0}'."),
|
|
This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4117, 1 /* Error */, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you__4117", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'. Did you mean '{1}'?"),
|
|
The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized: diag(4118, 1 /* Error */, "The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized_4118", "The type of this node cannot be serialized because its property '{0}' cannot be serialized."),
|
|
This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: diag(4119, 1 /* Error */, "This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_4119", "This member must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."),
|
|
This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: diag(4120, 1 /* Error */, "This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_4120", "This parameter property must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."),
|
|
This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class: diag(4121, 1 /* Error */, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_4121", "This member cannot have a JSDoc comment with an '@override' tag because its containing class '{0}' does not extend another class."),
|
|
This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: diag(4122, 1 /* Error */, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."),
|
|
This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4123, 1 /* Error */, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"),
|
|
Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, 1 /* Error */, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
|
|
resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4125, 1 /* Error */, "resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_wi_4125", "'resolution-mode' assertions are unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
|
|
The_current_host_does_not_support_the_0_option: diag(5001, 1 /* 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, 1 /* 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, 1 /* 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}'."),
|
|
Cannot_read_file_0_Colon_1: diag(5012, 1 /* Error */, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."),
|
|
Failed_to_parse_file_0_Colon_1: diag(5014, 1 /* Error */, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."),
|
|
Unknown_compiler_option_0: diag(5023, 1 /* Error */, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."),
|
|
Compiler_option_0_requires_a_value_of_type_1: diag(5024, 1 /* Error */, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."),
|
|
Unknown_compiler_option_0_Did_you_mean_1: diag(5025, 1 /* Error */, "Unknown_compiler_option_0_Did_you_mean_1_5025", "Unknown compiler option '{0}'. Did you mean '{1}'?"),
|
|
Could_not_write_file_0_Colon_1: diag(5033, 1 /* Error */, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."),
|
|
Option_project_cannot_be_mixed_with_source_files_on_a_command_line: diag(5042, 1 /* Error */, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."),
|
|
Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: diag(5047, 1 /* Error */, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."),
|
|
Option_0_cannot_be_specified_when_option_target_is_ES3: diag(5048, 1 /* Error */, "Option_0_cannot_be_specified_when_option_target_is_ES3_5048", "Option '{0}' cannot be specified when option 'target' is 'ES3'."),
|
|
Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: diag(5051, 1 /* Error */, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."),
|
|
Option_0_cannot_be_specified_without_specifying_option_1: diag(5052, 1 /* Error */, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."),
|
|
Option_0_cannot_be_specified_with_option_1: diag(5053, 1 /* Error */, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."),
|
|
A_tsconfig_json_file_is_already_defined_at_Colon_0: diag(5054, 1 /* Error */, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."),
|
|
Cannot_write_file_0_because_it_would_overwrite_input_file: diag(5055, 1 /* Error */, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."),
|
|
Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: diag(5056, 1 /* Error */, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."),
|
|
Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, 1 /* Error */, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."),
|
|
The_specified_path_does_not_exist_Colon_0: diag(5058, 1 /* Error */, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."),
|
|
Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, 1 /* Error */, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."),
|
|
Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, 1 /* Error */, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."),
|
|
Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: diag(5062, 1 /* Error */, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."),
|
|
Substitutions_for_pattern_0_should_be_an_array: diag(5063, 1 /* Error */, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."),
|
|
Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: diag(5064, 1 /* Error */, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."),
|
|
File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5065, 1 /* Error */, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."),
|
|
Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: diag(5066, 1 /* Error */, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."),
|
|
Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(5067, 1 /* Error */, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."),
|
|
Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: diag(5068, 1 /* Error */, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."),
|
|
Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: diag(5069, 1 /* Error */, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."),
|
|
Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy: diag(5070, 1 /* Error */, "Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy_5070", "Option '--resolveJsonModule' cannot be specified without 'node' module resolution strategy."),
|
|
Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext: diag(5071, 1 /* Error */, "Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_5071", "Option '--resolveJsonModule' can only be specified when module code generation is 'commonjs', 'amd', 'es2015' or 'esNext'."),
|
|
Unknown_build_option_0: diag(5072, 1 /* Error */, "Unknown_build_option_0_5072", "Unknown build option '{0}'."),
|
|
Build_option_0_requires_a_value_of_type_1: diag(5073, 1 /* Error */, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."),
|
|
Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified: diag(5074, 1 /* Error */, "Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBui_5074", "Option '--incremental' can only be specified using tsconfig, emitting to single file or when option '--tsBuildInfoFile' is specified."),
|
|
_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2: diag(5075, 1 /* Error */, "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075", "'{0}' is assignable to the constraint of type '{1}', but '{1}' could be instantiated with a different subtype of constraint '{2}'."),
|
|
_0_and_1_operations_cannot_be_mixed_without_parentheses: diag(5076, 1 /* Error */, "_0_and_1_operations_cannot_be_mixed_without_parentheses_5076", "'{0}' and '{1}' operations cannot be mixed without parentheses."),
|
|
Unknown_build_option_0_Did_you_mean_1: diag(5077, 1 /* Error */, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"),
|
|
Unknown_watch_option_0: diag(5078, 1 /* Error */, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."),
|
|
Unknown_watch_option_0_Did_you_mean_1: diag(5079, 1 /* Error */, "Unknown_watch_option_0_Did_you_mean_1_5079", "Unknown watch option '{0}'. Did you mean '{1}'?"),
|
|
Watch_option_0_requires_a_value_of_type_1: diag(5080, 1 /* Error */, "Watch_option_0_requires_a_value_of_type_1_5080", "Watch option '{0}' requires a value of type {1}."),
|
|
Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, 1 /* Error */, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."),
|
|
_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1: diag(5082, 1 /* Error */, "_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1_5082", "'{0}' could be instantiated with an arbitrary type which could be unrelated to '{1}'."),
|
|
Cannot_read_file_0: diag(5083, 1 /* Error */, "Cannot_read_file_0_5083", "Cannot read file '{0}'."),
|
|
Tuple_members_must_all_have_names_or_all_not_have_names: diag(5084, 1 /* Error */, "Tuple_members_must_all_have_names_or_all_not_have_names_5084", "Tuple members must all have names or all not have names."),
|
|
A_tuple_member_cannot_be_both_optional_and_rest: diag(5085, 1 /* Error */, "A_tuple_member_cannot_be_both_optional_and_rest_5085", "A tuple member cannot be both optional and rest."),
|
|
A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type: diag(5086, 1 /* Error */, "A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_c_5086", "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type."),
|
|
A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type: diag(5087, 1 /* Error */, "A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type_5087", "A labeled tuple element is declared as rest with a '...' before the name, rather than before the type."),
|
|
The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary: diag(5088, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* Error */, "Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled_5091", "Option 'preserveConstEnums' cannot be disabled when 'isolatedModules' is enabled."),
|
|
The_root_value_of_a_0_file_must_be_an_object: diag(5092, 1 /* Error */, "The_root_value_of_a_0_file_must_be_an_object_5092", "The root value of a '{0}' file must be an object."),
|
|
Compiler_option_0_may_only_be_used_with_build: diag(5093, 1 /* Error */, "Compiler_option_0_may_only_be_used_with_build_5093", "Compiler option '--{0}' may only be used with '--build'."),
|
|
Compiler_option_0_may_not_be_used_with_build: diag(5094, 1 /* Error */, "Compiler_option_0_may_not_be_used_with_build_5094", "Compiler option '--{0}' may not be used with '--build'."),
|
|
Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later: diag(5095, 1 /* Error */, "Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later_5095", "Option 'preserveValueImports' can only be used when 'module' is set to 'es2015' or later."),
|
|
Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6e3, 3 /* 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, 3 /* Message */, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."),
|
|
Generates_corresponding_d_ts_file: diag(6002, 3 /* Message */, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."),
|
|
Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: diag(6004, 3 /* Message */, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."),
|
|
Watch_input_files: diag(6005, 3 /* Message */, "Watch_input_files_6005", "Watch input files."),
|
|
Redirect_output_structure_to_the_directory: diag(6006, 3 /* Message */, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."),
|
|
Do_not_erase_const_enum_declarations_in_generated_code: diag(6007, 3 /* Message */, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."),
|
|
Do_not_emit_outputs_if_any_errors_were_reported: diag(6008, 3 /* Message */, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."),
|
|
Do_not_emit_comments_to_output: diag(6009, 3 /* Message */, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."),
|
|
Do_not_emit_outputs: diag(6010, 3 /* Message */, "Do_not_emit_outputs_6010", "Do not emit outputs."),
|
|
Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: diag(6011, 3 /* Message */, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."),
|
|
Skip_type_checking_of_declaration_files: diag(6012, 3 /* Message */, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."),
|
|
Do_not_resolve_the_real_path_of_symlinks: diag(6013, 3 /* Message */, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."),
|
|
Only_emit_d_ts_declaration_files: diag(6014, 3 /* Message */, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."),
|
|
Specify_ECMAScript_target_version: diag(6015, 3 /* Message */, "Specify_ECMAScript_target_version_6015", "Specify ECMAScript target version."),
|
|
Specify_module_code_generation: diag(6016, 3 /* Message */, "Specify_module_code_generation_6016", "Specify module code generation."),
|
|
Print_this_message: diag(6017, 3 /* Message */, "Print_this_message_6017", "Print this message."),
|
|
Print_the_compiler_s_version: diag(6019, 3 /* Message */, "Print_the_compiler_s_version_6019", "Print the compiler's version."),
|
|
Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: diag(6020, 3 /* Message */, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."),
|
|
Syntax_Colon_0: diag(6023, 3 /* Message */, "Syntax_Colon_0_6023", "Syntax: {0}"),
|
|
options: diag(6024, 3 /* Message */, "options_6024", "options"),
|
|
file: diag(6025, 3 /* Message */, "file_6025", "file"),
|
|
Examples_Colon_0: diag(6026, 3 /* Message */, "Examples_Colon_0_6026", "Examples: {0}"),
|
|
Options_Colon: diag(6027, 3 /* Message */, "Options_Colon_6027", "Options:"),
|
|
Version_0: diag(6029, 3 /* Message */, "Version_0_6029", "Version {0}"),
|
|
Insert_command_line_options_and_files_from_a_file: diag(6030, 3 /* Message */, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."),
|
|
Starting_compilation_in_watch_mode: diag(6031, 3 /* Message */, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."),
|
|
File_change_detected_Starting_incremental_compilation: diag(6032, 3 /* Message */, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."),
|
|
KIND: diag(6034, 3 /* Message */, "KIND_6034", "KIND"),
|
|
FILE: diag(6035, 3 /* Message */, "FILE_6035", "FILE"),
|
|
VERSION: diag(6036, 3 /* Message */, "VERSION_6036", "VERSION"),
|
|
LOCATION: diag(6037, 3 /* Message */, "LOCATION_6037", "LOCATION"),
|
|
DIRECTORY: diag(6038, 3 /* Message */, "DIRECTORY_6038", "DIRECTORY"),
|
|
STRATEGY: diag(6039, 3 /* Message */, "STRATEGY_6039", "STRATEGY"),
|
|
FILE_OR_DIRECTORY: diag(6040, 3 /* Message */, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"),
|
|
Errors_Files: diag(6041, 3 /* Message */, "Errors_Files_6041", "Errors Files"),
|
|
Generates_corresponding_map_file: diag(6043, 3 /* Message */, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."),
|
|
Compiler_option_0_expects_an_argument: diag(6044, 1 /* Error */, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."),
|
|
Unterminated_quoted_string_in_response_file_0: diag(6045, 1 /* Error */, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."),
|
|
Argument_for_0_option_must_be_Colon_1: diag(6046, 1 /* Error */, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."),
|
|
Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: diag(6048, 1 /* Error */, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'."),
|
|
Unable_to_open_file_0: diag(6050, 1 /* Error */, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."),
|
|
Corrupted_locale_file_0: diag(6051, 1 /* Error */, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."),
|
|
Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, 3 /* Message */, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."),
|
|
File_0_not_found: diag(6053, 1 /* Error */, "File_0_not_found_6053", "File '{0}' not found."),
|
|
File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, 1 /* Error */, "File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has an unsupported extension. The only supported extensions are {1}."),
|
|
Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: diag(6055, 3 /* Message */, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."),
|
|
Do_not_emit_declarations_for_code_that_has_an_internal_annotation: diag(6056, 3 /* Message */, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."),
|
|
Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: diag(6058, 3 /* Message */, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."),
|
|
File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: diag(6059, 1 /* Error */, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."),
|
|
Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: diag(6060, 3 /* Message */, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."),
|
|
NEWLINE: diag(6061, 3 /* Message */, "NEWLINE_6061", "NEWLINE"),
|
|
Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: diag(6064, 1 /* Error */, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line_6064", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'null' on command line."),
|
|
Enables_experimental_support_for_ES7_decorators: diag(6065, 3 /* Message */, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."),
|
|
Enables_experimental_support_for_emitting_type_metadata_for_decorators: diag(6066, 3 /* Message */, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."),
|
|
Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: diag(6069, 3 /* Message */, "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)."),
|
|
Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: diag(6070, 3 /* Message */, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."),
|
|
Successfully_created_a_tsconfig_json_file: diag(6071, 3 /* Message */, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."),
|
|
Suppress_excess_property_checks_for_object_literals: diag(6072, 3 /* Message */, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."),
|
|
Stylize_errors_and_messages_using_color_and_context_experimental: diag(6073, 3 /* Message */, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."),
|
|
Do_not_report_errors_on_unused_labels: diag(6074, 3 /* Message */, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."),
|
|
Report_error_when_not_all_code_paths_in_function_return_a_value: diag(6075, 3 /* Message */, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."),
|
|
Report_errors_for_fallthrough_cases_in_switch_statement: diag(6076, 3 /* Message */, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."),
|
|
Do_not_report_errors_on_unreachable_code: diag(6077, 3 /* 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, 3 /* 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, 3 /* Message */, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."),
|
|
Specify_JSX_code_generation: diag(6080, 3 /* Message */, "Specify_JSX_code_generation_6080", "Specify JSX code generation."),
|
|
File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, 3 /* 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, 1 /* 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, 3 /* Message */, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."),
|
|
Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: diag(6084, 3 /* Message */, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"),
|
|
Enable_tracing_of_the_name_resolution_process: diag(6085, 3 /* Message */, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."),
|
|
Resolving_module_0_from_1: diag(6086, 3 /* Message */, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"),
|
|
Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, 3 /* Message */, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."),
|
|
Module_resolution_kind_is_not_specified_using_0: diag(6088, 3 /* Message */, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."),
|
|
Module_name_0_was_successfully_resolved_to_1: diag(6089, 3 /* Message */, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"),
|
|
Module_name_0_was_not_resolved: diag(6090, 3 /* Message */, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"),
|
|
paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: diag(6091, 3 /* Message */, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."),
|
|
Module_name_0_matched_pattern_1: diag(6092, 3 /* Message */, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."),
|
|
Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, 3 /* Message */, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."),
|
|
Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, 3 /* Message */, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."),
|
|
Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1: diag(6095, 3 /* Message */, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1_6095", "Loading module as file / folder, candidate module location '{0}', target file types: {1}."),
|
|
File_0_does_not_exist: diag(6096, 3 /* Message */, "File_0_does_not_exist_6096", "File '{0}' does not exist."),
|
|
File_0_exist_use_it_as_a_name_resolution_result: diag(6097, 3 /* Message */, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."),
|
|
Loading_module_0_from_node_modules_folder_target_file_types_Colon_1: diag(6098, 3 /* Message */, "Loading_module_0_from_node_modules_folder_target_file_types_Colon_1_6098", "Loading module '{0}' from 'node_modules' folder, target file types: {1}."),
|
|
Found_package_json_at_0: diag(6099, 3 /* Message */, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."),
|
|
package_json_does_not_have_a_0_field: diag(6100, 3 /* Message */, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."),
|
|
package_json_has_0_field_1_that_references_2: diag(6101, 3 /* Message */, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."),
|
|
Allow_javascript_files_to_be_compiled: diag(6102, 3 /* Message */, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."),
|
|
Checking_if_0_is_the_longest_matching_prefix_for_1_2: diag(6104, 3 /* Message */, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."),
|
|
Expected_type_of_0_field_in_package_json_to_be_1_got_2: diag(6105, 3 /* Message */, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."),
|
|
baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: diag(6106, 3 /* Message */, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."),
|
|
rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: diag(6107, 3 /* Message */, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."),
|
|
Longest_matching_prefix_for_0_is_1: diag(6108, 3 /* Message */, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."),
|
|
Loading_0_from_the_root_dir_1_candidate_location_2: diag(6109, 3 /* Message */, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."),
|
|
Trying_other_entries_in_rootDirs: diag(6110, 3 /* Message */, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."),
|
|
Module_resolution_using_rootDirs_has_failed: diag(6111, 3 /* Message */, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."),
|
|
Do_not_emit_use_strict_directives_in_module_output: diag(6112, 3 /* Message */, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."),
|
|
Enable_strict_null_checks: diag(6113, 3 /* Message */, "Enable_strict_null_checks_6113", "Enable strict null checks."),
|
|
Unknown_option_excludes_Did_you_mean_exclude: diag(6114, 1 /* Error */, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"),
|
|
Raise_error_on_this_expressions_with_an_implied_any_type: diag(6115, 3 /* Message */, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."),
|
|
Resolving_type_reference_directive_0_containing_file_1_root_directory_2: diag(6116, 3 /* Message */, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"),
|
|
Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: diag(6119, 3 /* Message */, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"),
|
|
Type_reference_directive_0_was_not_resolved: diag(6120, 3 /* Message */, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"),
|
|
Resolving_with_primary_search_path_0: diag(6121, 3 /* Message */, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."),
|
|
Root_directory_cannot_be_determined_skipping_primary_search_paths: diag(6122, 3 /* Message */, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."),
|
|
Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: diag(6123, 3 /* Message */, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"),
|
|
Type_declaration_files_to_be_included_in_compilation: diag(6124, 3 /* Message */, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."),
|
|
Looking_up_in_node_modules_folder_initial_location_0: diag(6125, 3 /* Message */, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."),
|
|
Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: diag(6126, 3 /* Message */, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."),
|
|
Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: diag(6127, 3 /* Message */, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"),
|
|
Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: diag(6128, 3 /* Message */, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"),
|
|
Resolving_real_path_for_0_result_1: diag(6130, 3 /* Message */, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."),
|
|
Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: diag(6131, 1 /* Error */, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."),
|
|
File_name_0_has_a_1_extension_stripping_it: diag(6132, 3 /* Message */, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."),
|
|
_0_is_declared_but_its_value_is_never_read: diag(6133, 1 /* Error */, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", true),
|
|
Report_errors_on_unused_locals: diag(6134, 3 /* Message */, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."),
|
|
Report_errors_on_unused_parameters: diag(6135, 3 /* Message */, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."),
|
|
The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: diag(6136, 3 /* Message */, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."),
|
|
Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: diag(6137, 1 /* Error */, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."),
|
|
Property_0_is_declared_but_its_value_is_never_read: diag(6138, 1 /* Error */, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", true),
|
|
Import_emit_helpers_from_tslib: diag(6139, 3 /* Message */, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."),
|
|
Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: diag(6140, 1 /* Error */, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."),
|
|
Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: diag(6141, 3 /* Message */, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", 'Parse in strict mode and emit "use strict" for each source file.'),
|
|
Module_0_was_resolved_to_1_but_jsx_is_not_set: diag(6142, 1 /* Error */, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."),
|
|
Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: diag(6144, 3 /* Message */, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."),
|
|
Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified: diag(6145, 3 /* Message */, "Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified_6145", "Module '{0}' was resolved as ambient module declared in '{1}' since this file was not modified."),
|
|
Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: diag(6146, 3 /* Message */, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."),
|
|
Resolution_for_module_0_was_found_in_cache_from_location_1: diag(6147, 3 /* Message */, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."),
|
|
Directory_0_does_not_exist_skipping_all_lookups_in_it: diag(6148, 3 /* Message */, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."),
|
|
Show_diagnostic_information: diag(6149, 3 /* Message */, "Show_diagnostic_information_6149", "Show diagnostic information."),
|
|
Show_verbose_diagnostic_information: diag(6150, 3 /* Message */, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."),
|
|
Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: diag(6151, 3 /* Message */, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."),
|
|
Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: diag(6152, 3 /* Message */, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."),
|
|
Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: diag(6153, 3 /* Message */, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts.transpileModule')."),
|
|
Print_names_of_generated_files_part_of_the_compilation: diag(6154, 3 /* Message */, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."),
|
|
Print_names_of_files_part_of_the_compilation: diag(6155, 3 /* Message */, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."),
|
|
The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: diag(6156, 3 /* Message */, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"),
|
|
Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: diag(6157, 3 /* Message */, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."),
|
|
Do_not_include_the_default_library_file_lib_d_ts: diag(6158, 3 /* Message */, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."),
|
|
Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: diag(6159, 3 /* Message */, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."),
|
|
Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: diag(6160, 3 /* Message */, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."),
|
|
List_of_folders_to_include_type_definitions_from: diag(6161, 3 /* Message */, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."),
|
|
Disable_size_limitations_on_JavaScript_projects: diag(6162, 3 /* Message */, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."),
|
|
The_character_set_of_the_input_files: diag(6163, 3 /* Message */, "The_character_set_of_the_input_files_6163", "The character set of the input files."),
|
|
Do_not_truncate_error_messages: diag(6165, 3 /* Message */, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."),
|
|
Output_directory_for_generated_declaration_files: diag(6166, 3 /* Message */, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."),
|
|
A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: diag(6167, 3 /* Message */, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."),
|
|
List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: diag(6168, 3 /* Message */, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."),
|
|
Show_all_compiler_options: diag(6169, 3 /* Message */, "Show_all_compiler_options_6169", "Show all compiler options."),
|
|
Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, 3 /* Message */, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"),
|
|
Command_line_Options: diag(6171, 3 /* Message */, "Command_line_Options_6171", "Command-line Options"),
|
|
Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3: diag(6179, 3 /* Message */, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'."),
|
|
Enable_all_strict_type_checking_options: diag(6180, 3 /* Message */, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."),
|
|
Scoped_package_detected_looking_in_0: diag(6182, 3 /* Message */, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"),
|
|
Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2: diag(6183, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_6183", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."),
|
|
Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: diag(6184, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package__6184", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."),
|
|
Enable_strict_checking_of_function_types: diag(6186, 3 /* Message */, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."),
|
|
Enable_strict_checking_of_property_initialization_in_classes: diag(6187, 3 /* Message */, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."),
|
|
Numeric_separators_are_not_allowed_here: diag(6188, 1 /* Error */, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."),
|
|
Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, 1 /* Error */, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."),
|
|
Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: diag(6191, 3 /* Message */, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."),
|
|
All_imports_in_import_declaration_are_unused: diag(6192, 1 /* Error */, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", true),
|
|
Found_1_error_Watching_for_file_changes: diag(6193, 3 /* Message */, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."),
|
|
Found_0_errors_Watching_for_file_changes: diag(6194, 3 /* Message */, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."),
|
|
Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: diag(6195, 3 /* Message */, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."),
|
|
_0_is_declared_but_never_used: diag(6196, 1 /* Error */, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", true),
|
|
Include_modules_imported_with_json_extension: diag(6197, 3 /* Message */, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"),
|
|
All_destructured_elements_are_unused: diag(6198, 1 /* Error */, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", true),
|
|
All_variables_are_unused: diag(6199, 1 /* Error */, "All_variables_are_unused_6199", "All variables are unused.", true),
|
|
Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, 1 /* Error */, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"),
|
|
Conflicts_are_in_this_file: diag(6201, 3 /* Message */, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."),
|
|
Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, 1 /* Error */, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"),
|
|
_0_was_also_declared_here: diag(6203, 3 /* Message */, "_0_was_also_declared_here_6203", "'{0}' was also declared here."),
|
|
and_here: diag(6204, 3 /* Message */, "and_here_6204", "and here."),
|
|
All_type_parameters_are_unused: diag(6205, 1 /* Error */, "All_type_parameters_are_unused_6205", "All type parameters are unused."),
|
|
package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, 3 /* Message */, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."),
|
|
package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, 3 /* Message */, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."),
|
|
package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, 3 /* Message */, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."),
|
|
package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: diag(6209, 3 /* Message */, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."),
|
|
An_argument_for_0_was_not_provided: diag(6210, 3 /* Message */, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."),
|
|
An_argument_matching_this_binding_pattern_was_not_provided: diag(6211, 3 /* Message */, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."),
|
|
Did_you_mean_to_call_this_expression: diag(6212, 3 /* Message */, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"),
|
|
Did_you_mean_to_use_new_with_this_expression: diag(6213, 3 /* Message */, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"),
|
|
Enable_strict_bind_call_and_apply_methods_on_functions: diag(6214, 3 /* Message */, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."),
|
|
Using_compiler_options_of_project_reference_redirect_0: diag(6215, 3 /* Message */, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."),
|
|
Found_1_error: diag(6216, 3 /* Message */, "Found_1_error_6216", "Found 1 error."),
|
|
Found_0_errors: diag(6217, 3 /* Message */, "Found_0_errors_6217", "Found {0} errors."),
|
|
Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: diag(6218, 3 /* Message */, "Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2_6218", "======== Module name '{0}' was successfully resolved to '{1}' with Package ID '{2}'. ========"),
|
|
Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3: diag(6219, 3 /* Message */, "Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3_6219", "======== Type reference directive '{0}' was successfully resolved to '{1}' with Package ID '{2}', primary: {3}. ========"),
|
|
package_json_had_a_falsy_0_field: diag(6220, 3 /* Message */, "package_json_had_a_falsy_0_field_6220", "'package.json' had a falsy '{0}' field."),
|
|
Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects: diag(6221, 3 /* Message */, "Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects_6221", "Disable use of source files instead of declaration files from referenced projects."),
|
|
Emit_class_fields_with_Define_instead_of_Set: diag(6222, 3 /* Message */, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."),
|
|
Generates_a_CPU_profile: diag(6223, 3 /* Message */, "Generates_a_CPU_profile_6223", "Generates a CPU profile."),
|
|
Disable_solution_searching_for_this_project: diag(6224, 3 /* Message */, "Disable_solution_searching_for_this_project_6224", "Disable solution searching for this project."),
|
|
Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling_UseFsEvents_UseFsEventsOnParentDirectory: diag(6225, 3 /* Message */, "Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_Dynami_6225", "Specify strategy for watching file: 'FixedPollingInterval' (default), 'PriorityPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling', 'UseFsEvents', 'UseFsEventsOnParentDirectory'."),
|
|
Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling: diag(6226, 3 /* Message */, "Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively__6226", "Specify strategy for watching directory on platforms that don't support recursive watching natively: 'UseFsEvents' (default), 'FixedPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling'."),
|
|
Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority_FixedChunkSize: diag(6227, 3 /* Message */, "Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_6227", "Specify strategy for creating a polling watch when it fails to create using file system events: 'FixedInterval' (default), 'PriorityInterval', 'DynamicPriority', 'FixedChunkSize'."),
|
|
Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3: diag(6229, 1 /* Error */, "Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3_6229", "Tag '{0}' expects at least '{1}' arguments, but the JSX factory '{2}' provides at most '{3}'."),
|
|
Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line: diag(6230, 1 /* Error */, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line_6230", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'false' or 'null' on command line."),
|
|
Could_not_resolve_the_path_0_with_the_extensions_Colon_1: diag(6231, 1 /* Error */, "Could_not_resolve_the_path_0_with_the_extensions_Colon_1_6231", "Could not resolve the path '{0}' with the extensions: {1}."),
|
|
Declaration_augments_declaration_in_another_file_This_cannot_be_serialized: diag(6232, 1 /* Error */, "Declaration_augments_declaration_in_another_file_This_cannot_be_serialized_6232", "Declaration augments declaration in another file. This cannot be serialized."),
|
|
This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file: diag(6233, 1 /* Error */, "This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_fil_6233", "This is the declaration being augmented. Consider moving the augmenting declaration into the same file."),
|
|
This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without: diag(6234, 1 /* Error */, "This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without_6234", "This expression is not callable because it is a 'get' accessor. Did you mean to use it without '()'?"),
|
|
Disable_loading_referenced_projects: diag(6235, 3 /* Message */, "Disable_loading_referenced_projects_6235", "Disable loading referenced projects."),
|
|
Arguments_for_the_rest_parameter_0_were_not_provided: diag(6236, 1 /* Error */, "Arguments_for_the_rest_parameter_0_were_not_provided_6236", "Arguments for the rest parameter '{0}' were not provided."),
|
|
Generates_an_event_trace_and_a_list_of_types: diag(6237, 3 /* Message */, "Generates_an_event_trace_and_a_list_of_types_6237", "Generates an event trace and a list of types."),
|
|
Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react: diag(6238, 1 /* Error */, "Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react_6238", "Specify the module specifier to be used to import the 'jsx' and 'jsxs' factory functions from. eg, react"),
|
|
File_0_exists_according_to_earlier_cached_lookups: diag(6239, 3 /* Message */, "File_0_exists_according_to_earlier_cached_lookups_6239", "File '{0}' exists according to earlier cached lookups."),
|
|
File_0_does_not_exist_according_to_earlier_cached_lookups: diag(6240, 3 /* Message */, "File_0_does_not_exist_according_to_earlier_cached_lookups_6240", "File '{0}' does not exist according to earlier cached lookups."),
|
|
Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1: diag(6241, 3 /* Message */, "Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1_6241", "Resolution for type reference directive '{0}' was found in cache from location '{1}'."),
|
|
Resolving_type_reference_directive_0_containing_file_1: diag(6242, 3 /* Message */, "Resolving_type_reference_directive_0_containing_file_1_6242", "======== Resolving type reference directive '{0}', containing file '{1}'. ========"),
|
|
Interpret_optional_property_types_as_written_rather_than_adding_undefined: diag(6243, 3 /* Message */, "Interpret_optional_property_types_as_written_rather_than_adding_undefined_6243", "Interpret optional property types as written, rather than adding 'undefined'."),
|
|
Modules: diag(6244, 3 /* Message */, "Modules_6244", "Modules"),
|
|
File_Management: diag(6245, 3 /* Message */, "File_Management_6245", "File Management"),
|
|
Emit: diag(6246, 3 /* Message */, "Emit_6246", "Emit"),
|
|
JavaScript_Support: diag(6247, 3 /* Message */, "JavaScript_Support_6247", "JavaScript Support"),
|
|
Type_Checking: diag(6248, 3 /* Message */, "Type_Checking_6248", "Type Checking"),
|
|
Editor_Support: diag(6249, 3 /* Message */, "Editor_Support_6249", "Editor Support"),
|
|
Watch_and_Build_Modes: diag(6250, 3 /* Message */, "Watch_and_Build_Modes_6250", "Watch and Build Modes"),
|
|
Compiler_Diagnostics: diag(6251, 3 /* Message */, "Compiler_Diagnostics_6251", "Compiler Diagnostics"),
|
|
Interop_Constraints: diag(6252, 3 /* Message */, "Interop_Constraints_6252", "Interop Constraints"),
|
|
Backwards_Compatibility: diag(6253, 3 /* Message */, "Backwards_Compatibility_6253", "Backwards Compatibility"),
|
|
Language_and_Environment: diag(6254, 3 /* Message */, "Language_and_Environment_6254", "Language and Environment"),
|
|
Projects: diag(6255, 3 /* Message */, "Projects_6255", "Projects"),
|
|
Output_Formatting: diag(6256, 3 /* Message */, "Output_Formatting_6256", "Output Formatting"),
|
|
Completeness: diag(6257, 3 /* Message */, "Completeness_6257", "Completeness"),
|
|
_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, 1 /* Error */, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"),
|
|
Found_1_error_in_1: diag(6259, 3 /* Message */, "Found_1_error_in_1_6259", "Found 1 error in {1}"),
|
|
Found_0_errors_in_the_same_file_starting_at_Colon_1: diag(6260, 3 /* Message */, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"),
|
|
Found_0_errors_in_1_files: diag(6261, 3 /* Message */, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."),
|
|
Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
|
|
Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
|
|
Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
|
|
package_json_scope_0_has_no_imports_defined: diag(6273, 3 /* Message */, "package_json_scope_0_has_no_imports_defined_6273", "package.json scope '{0}' has no imports defined."),
|
|
package_json_scope_0_explicitly_maps_specifier_1_to_null: diag(6274, 3 /* Message */, "package_json_scope_0_explicitly_maps_specifier_1_to_null_6274", "package.json scope '{0}' explicitly maps specifier '{1}' to null."),
|
|
package_json_scope_0_has_invalid_type_for_target_of_specifier_1: diag(6275, 3 /* Message */, "package_json_scope_0_has_invalid_type_for_target_of_specifier_1_6275", "package.json scope '{0}' has invalid type for target of specifier '{1}'"),
|
|
Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6276, 3 /* Message */, "Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6276", "Export specifier '{0}' does not exist in package.json scope at path '{1}'."),
|
|
Enable_project_compilation: diag(6302, 3 /* Message */, "Enable_project_compilation_6302", "Enable project compilation"),
|
|
Composite_projects_may_not_disable_declaration_emit: diag(6304, 1 /* Error */, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."),
|
|
Output_file_0_has_not_been_built_from_source_file_1: diag(6305, 1 /* Error */, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."),
|
|
Referenced_project_0_must_have_setting_composite_Colon_true: diag(6306, 1 /* Error */, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", `Referenced project '{0}' must have setting "composite": true.`),
|
|
File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, 1 /* Error */, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."),
|
|
Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, 1 /* Error */, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"),
|
|
Output_file_0_from_project_1_does_not_exist: diag(6309, 1 /* Error */, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"),
|
|
Referenced_project_0_may_not_disable_emit: diag(6310, 1 /* Error */, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."),
|
|
Project_0_is_out_of_date_because_output_1_is_older_than_input_2: diag(6350, 3 /* Message */, "Project_0_is_out_of_date_because_output_1_is_older_than_input_2_6350", "Project '{0}' is out of date because output '{1}' is older than input '{2}'"),
|
|
Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2: diag(6351, 3 /* Message */, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than output '{2}'"),
|
|
Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, 3 /* Message */, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"),
|
|
Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, 3 /* Message */, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"),
|
|
Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, 3 /* Message */, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"),
|
|
Projects_in_this_build_Colon_0: diag(6355, 3 /* Message */, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"),
|
|
A_non_dry_build_would_delete_the_following_files_Colon_0: diag(6356, 3 /* Message */, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"),
|
|
A_non_dry_build_would_build_project_0: diag(6357, 3 /* Message */, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"),
|
|
Building_project_0: diag(6358, 3 /* Message */, "Building_project_0_6358", "Building project '{0}'..."),
|
|
Updating_output_timestamps_of_project_0: diag(6359, 3 /* Message */, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."),
|
|
Project_0_is_up_to_date: diag(6361, 3 /* Message */, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"),
|
|
Skipping_build_of_project_0_because_its_dependency_1_has_errors: diag(6362, 3 /* Message */, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"),
|
|
Project_0_can_t_be_built_because_its_dependency_1_has_errors: diag(6363, 3 /* Message */, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"),
|
|
Build_one_or_more_projects_and_their_dependencies_if_out_of_date: diag(6364, 3 /* Message */, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"),
|
|
Delete_the_outputs_of_all_projects: diag(6365, 3 /* Message */, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects."),
|
|
Show_what_would_be_built_or_deleted_if_specified_with_clean: diag(6367, 3 /* Message */, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"),
|
|
Option_build_must_be_the_first_command_line_argument: diag(6369, 1 /* Error */, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."),
|
|
Options_0_and_1_cannot_be_combined: diag(6370, 1 /* Error */, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."),
|
|
Updating_unchanged_output_timestamps_of_project_0: diag(6371, 3 /* Message */, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."),
|
|
Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed: diag(6372, 3 /* Message */, "Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed_6372", "Project '{0}' is out of date because output of its dependency '{1}' has changed"),
|
|
Updating_output_of_project_0: diag(6373, 3 /* Message */, "Updating_output_of_project_0_6373", "Updating output of project '{0}'..."),
|
|
A_non_dry_build_would_update_timestamps_for_output_of_project_0: diag(6374, 3 /* Message */, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"),
|
|
A_non_dry_build_would_update_output_of_project_0: diag(6375, 3 /* Message */, "A_non_dry_build_would_update_output_of_project_0_6375", "A non-dry build would update output of project '{0}'"),
|
|
Cannot_update_output_of_project_0_because_there_was_error_reading_file_1: diag(6376, 3 /* Message */, "Cannot_update_output_of_project_0_because_there_was_error_reading_file_1_6376", "Cannot update output of project '{0}' because there was error reading file '{1}'"),
|
|
Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: diag(6377, 1 /* Error */, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"),
|
|
Composite_projects_may_not_disable_incremental_compilation: diag(6379, 1 /* Error */, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."),
|
|
Specify_file_to_store_incremental_compilation_information: diag(6380, 3 /* Message */, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"),
|
|
Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: diag(6381, 3 /* Message */, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"),
|
|
Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, 3 /* 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, 3 /* 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, 3 /* 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, 2 /* Suggestion */, "_0_is_deprecated_6385", "'{0}' is deprecated.", void 0, void 0, 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, 3 /* 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, 2 /* Suggestion */, "The_signature_0_of_1_is_deprecated_6387", "The signature '{0}' of '{1}' is deprecated.", void 0, void 0, true),
|
|
Project_0_is_being_forcibly_rebuilt: diag(6388, 3 /* Message */, "Project_0_is_being_forcibly_rebuilt_6388", "Project '{0}' is being forcibly rebuilt"),
|
|
Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved: diag(6389, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved_6389", "Reusing resolution of module '{0}' from '{1}' of old program, it was not resolved."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2: diag(6390, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6390", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: diag(6391, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6391", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved: diag(6392, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved_6392", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was not resolved."),
|
|
Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6393, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6393", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."),
|
|
Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6394, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6394", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."),
|
|
Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6395, 3 /* Message */, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved_6395", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was not resolved."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6396, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6396", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6397, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."),
|
|
Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6398, 3 /* Message */, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."),
|
|
Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted: diag(6399, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitte_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes were not emitted"),
|
|
Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files: diag(6400, 3 /* Message */, "Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs to update timestamps of output files that are older than input files"),
|
|
Project_0_is_out_of_date_because_there_was_error_reading_file_1: diag(6401, 3 /* Message */, "Project_0_is_out_of_date_because_there_was_error_reading_file_1_6401", "Project '{0}' is out of date because there was error reading file '{1}'"),
|
|
Resolving_in_0_mode_with_conditions_1: diag(6402, 3 /* Message */, "Resolving_in_0_mode_with_conditions_1_6402", "Resolving in {0} mode with conditions {1}."),
|
|
Matched_0_condition_1: diag(6403, 3 /* Message */, "Matched_0_condition_1_6403", "Matched '{0}' condition '{1}'."),
|
|
Using_0_subpath_1_with_target_2: diag(6404, 3 /* Message */, "Using_0_subpath_1_with_target_2_6404", "Using '{0}' subpath '{1}' with target '{2}'."),
|
|
Saw_non_matching_condition_0: diag(6405, 3 /* Message */, "Saw_non_matching_condition_0_6405", "Saw non-matching condition '{0}'."),
|
|
Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions: diag(6406, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions_6406", "Project '{0}' is out of date because buildinfo file '{1}' indicates there is change in compilerOptions"),
|
|
The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* 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, 1 /* 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, 3 /* 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."),
|
|
Consider_adding_a_declare_modifier_to_this_class: diag(6506, 3 /* Message */, "Consider_adding_a_declare_modifier_to_this_class_6506", "Consider adding a 'declare' modifier to this class."),
|
|
Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files: diag(6600, 3 /* Message */, "Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these__6600", "Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files."),
|
|
Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export: diag(6601, 3 /* Message */, "Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export_6601", "Allow 'import x from y' when a module doesn't have a default export."),
|
|
Allow_accessing_UMD_globals_from_modules: diag(6602, 3 /* Message */, "Allow_accessing_UMD_globals_from_modules_6602", "Allow accessing UMD globals from modules."),
|
|
Disable_error_reporting_for_unreachable_code: diag(6603, 3 /* Message */, "Disable_error_reporting_for_unreachable_code_6603", "Disable error reporting for unreachable code."),
|
|
Disable_error_reporting_for_unused_labels: diag(6604, 3 /* Message */, "Disable_error_reporting_for_unused_labels_6604", "Disable error reporting for unused labels."),
|
|
Ensure_use_strict_is_always_emitted: diag(6605, 3 /* Message */, "Ensure_use_strict_is_always_emitted_6605", "Ensure 'use strict' is always emitted."),
|
|
Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6606, 3 /* Message */, "Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_wi_6606", "Have recompiles in projects that use 'incremental' and 'watch' mode assume that changes within a file will only affect files directly depending on it."),
|
|
Specify_the_base_directory_to_resolve_non_relative_module_names: diag(6607, 3 /* Message */, "Specify_the_base_directory_to_resolve_non_relative_module_names_6607", "Specify the base directory to resolve non-relative module names."),
|
|
No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files: diag(6608, 3 /* Message */, "No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files_6608", "No longer supported. In early versions, manually set the text encoding for reading files."),
|
|
Enable_error_reporting_in_type_checked_JavaScript_files: diag(6609, 3 /* Message */, "Enable_error_reporting_in_type_checked_JavaScript_files_6609", "Enable error reporting in type-checked JavaScript files."),
|
|
Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references: diag(6611, 3 /* Message */, "Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references_6611", "Enable constraints that allow a TypeScript project to be used with project references."),
|
|
Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project: diag(6612, 3 /* Message */, "Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project_6612", "Generate .d.ts files from TypeScript and JavaScript files in your project."),
|
|
Specify_the_output_directory_for_generated_declaration_files: diag(6613, 3 /* Message */, "Specify_the_output_directory_for_generated_declaration_files_6613", "Specify the output directory for generated declaration files."),
|
|
Create_sourcemaps_for_d_ts_files: diag(6614, 3 /* Message */, "Create_sourcemaps_for_d_ts_files_6614", "Create sourcemaps for d.ts files."),
|
|
Output_compiler_performance_information_after_building: diag(6615, 3 /* Message */, "Output_compiler_performance_information_after_building_6615", "Output compiler performance information after building."),
|
|
Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project: diag(6616, 3 /* Message */, "Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project_6616", "Disables inference for type acquisition by looking at filenames in a project."),
|
|
Reduce_the_number_of_projects_loaded_automatically_by_TypeScript: diag(6617, 3 /* Message */, "Reduce_the_number_of_projects_loaded_automatically_by_TypeScript_6617", "Reduce the number of projects loaded automatically by TypeScript."),
|
|
Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server: diag(6618, 3 /* Message */, "Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server_6618", "Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server."),
|
|
Opt_a_project_out_of_multi_project_reference_checking_when_editing: diag(6619, 3 /* Message */, "Opt_a_project_out_of_multi_project_reference_checking_when_editing_6619", "Opt a project out of multi-project reference checking when editing."),
|
|
Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects: diag(6620, 3 /* Message */, "Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects_6620", "Disable preferring source files instead of declaration files when referencing composite projects."),
|
|
Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration: diag(6621, 3 /* Message */, "Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration_6621", "Emit more compliant, but verbose and less performant JavaScript for iteration."),
|
|
Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: diag(6622, 3 /* Message */, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6622", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."),
|
|
Only_output_d_ts_files_and_not_JavaScript_files: diag(6623, 3 /* Message */, "Only_output_d_ts_files_and_not_JavaScript_files_6623", "Only output d.ts files and not JavaScript files."),
|
|
Emit_design_type_metadata_for_decorated_declarations_in_source_files: diag(6624, 3 /* Message */, "Emit_design_type_metadata_for_decorated_declarations_in_source_files_6624", "Emit design-type metadata for decorated declarations in source files."),
|
|
Disable_the_type_acquisition_for_JavaScript_projects: diag(6625, 3 /* Message */, "Disable_the_type_acquisition_for_JavaScript_projects_6625", "Disable the type acquisition for JavaScript projects"),
|
|
Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility: diag(6626, 3 /* Message */, "Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheti_6626", "Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility."),
|
|
Filters_results_from_the_include_option: diag(6627, 3 /* Message */, "Filters_results_from_the_include_option_6627", "Filters results from the `include` option."),
|
|
Remove_a_list_of_directories_from_the_watch_process: diag(6628, 3 /* Message */, "Remove_a_list_of_directories_from_the_watch_process_6628", "Remove a list of directories from the watch process."),
|
|
Remove_a_list_of_files_from_the_watch_mode_s_processing: diag(6629, 3 /* Message */, "Remove_a_list_of_files_from_the_watch_mode_s_processing_6629", "Remove a list of files from the watch mode's processing."),
|
|
Enable_experimental_support_for_TC39_stage_2_draft_decorators: diag(6630, 3 /* Message */, "Enable_experimental_support_for_TC39_stage_2_draft_decorators_6630", "Enable experimental support for TC39 stage 2 draft decorators."),
|
|
Print_files_read_during_the_compilation_including_why_it_was_included: diag(6631, 3 /* Message */, "Print_files_read_during_the_compilation_including_why_it_was_included_6631", "Print files read during the compilation including why it was included."),
|
|
Output_more_detailed_compiler_performance_information_after_building: diag(6632, 3 /* Message */, "Output_more_detailed_compiler_performance_information_after_building_6632", "Output more detailed compiler performance information after building."),
|
|
Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_are_inherited: diag(6633, 3 /* Message */, "Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_a_6633", "Specify one or more path or node module references to base configuration files from which settings are inherited."),
|
|
Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers: diag(6634, 3 /* Message */, "Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers_6634", "Specify what approach the watcher should use if the system runs out of native file watchers."),
|
|
Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include: diag(6635, 3 /* Message */, "Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include_6635", "Include a list of files. This does not support glob patterns, as opposed to `include`."),
|
|
Build_all_projects_including_those_that_appear_to_be_up_to_date: diag(6636, 3 /* Message */, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6636", "Build all projects, including those that appear to be up to date."),
|
|
Ensure_that_casing_is_correct_in_imports: diag(6637, 3 /* Message */, "Ensure_that_casing_is_correct_in_imports_6637", "Ensure that casing is correct in imports."),
|
|
Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging: diag(6638, 3 /* Message */, "Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging_6638", "Emit a v8 CPU profile of the compiler run for debugging."),
|
|
Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file: diag(6639, 3 /* Message */, "Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file_6639", "Allow importing helper functions from tslib once per project, instead of including them per-file."),
|
|
Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation: diag(6641, 3 /* Message */, "Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation_6641", "Specify a list of glob patterns that match files to be included in compilation."),
|
|
Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects: diag(6642, 3 /* Message */, "Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects_6642", "Save .tsbuildinfo files to allow for incremental compilation of projects."),
|
|
Include_sourcemap_files_inside_the_emitted_JavaScript: diag(6643, 3 /* Message */, "Include_sourcemap_files_inside_the_emitted_JavaScript_6643", "Include sourcemap files inside the emitted JavaScript."),
|
|
Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript: diag(6644, 3 /* Message */, "Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript_6644", "Include source code in the sourcemaps inside the emitted JavaScript."),
|
|
Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports: diag(6645, 3 /* Message */, "Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports_6645", "Ensure that each file can be safely transpiled without relying on other imports."),
|
|
Specify_what_JSX_code_is_generated: diag(6646, 3 /* Message */, "Specify_what_JSX_code_is_generated_6646", "Specify what JSX code is generated."),
|
|
Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h: diag(6647, 3 /* Message */, "Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h_6647", "Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'."),
|
|
Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment: diag(6648, 3 /* Message */, "Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragme_6648", "Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'."),
|
|
Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk: diag(6649, 3 /* Message */, "Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Ast_6649", "Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'."),
|
|
Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option: diag(6650, 3 /* Message */, "Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option_6650", "Make keyof only return strings instead of string, numbers or symbols. Legacy option."),
|
|
Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment: diag(6651, 3 /* Message */, "Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment_6651", "Specify a set of bundled library declaration files that describe the target runtime environment."),
|
|
Print_the_names_of_emitted_files_after_a_compilation: diag(6652, 3 /* Message */, "Print_the_names_of_emitted_files_after_a_compilation_6652", "Print the names of emitted files after a compilation."),
|
|
Print_all_of_the_files_read_during_the_compilation: diag(6653, 3 /* Message */, "Print_all_of_the_files_read_during_the_compilation_6653", "Print all of the files read during the compilation."),
|
|
Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit: diag(6654, 3 /* Message */, "Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit_6654", "Set the language of the messaging from TypeScript. This does not affect emit."),
|
|
Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: diag(6655, 3 /* Message */, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6655", "Specify the location where debugger should locate map files instead of generated locations."),
|
|
Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs: diag(6656, 3 /* Message */, "Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicabl_6656", "Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'."),
|
|
Specify_what_module_code_is_generated: diag(6657, 3 /* Message */, "Specify_what_module_code_is_generated_6657", "Specify what module code is generated."),
|
|
Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier: diag(6658, 3 /* Message */, "Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier_6658", "Specify how TypeScript looks up a file from a given module specifier."),
|
|
Set_the_newline_character_for_emitting_files: diag(6659, 3 /* Message */, "Set_the_newline_character_for_emitting_files_6659", "Set the newline character for emitting files."),
|
|
Disable_emitting_files_from_a_compilation: diag(6660, 3 /* Message */, "Disable_emitting_files_from_a_compilation_6660", "Disable emitting files from a compilation."),
|
|
Disable_generating_custom_helper_functions_like_extends_in_compiled_output: diag(6661, 3 /* Message */, "Disable_generating_custom_helper_functions_like_extends_in_compiled_output_6661", "Disable generating custom helper functions like '__extends' in compiled output."),
|
|
Disable_emitting_files_if_any_type_checking_errors_are_reported: diag(6662, 3 /* Message */, "Disable_emitting_files_if_any_type_checking_errors_are_reported_6662", "Disable emitting files if any type checking errors are reported."),
|
|
Disable_truncating_types_in_error_messages: diag(6663, 3 /* Message */, "Disable_truncating_types_in_error_messages_6663", "Disable truncating types in error messages."),
|
|
Enable_error_reporting_for_fallthrough_cases_in_switch_statements: diag(6664, 3 /* Message */, "Enable_error_reporting_for_fallthrough_cases_in_switch_statements_6664", "Enable error reporting for fallthrough cases in switch statements."),
|
|
Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type: diag(6665, 3 /* Message */, "Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type_6665", "Enable error reporting for expressions and declarations with an implied 'any' type."),
|
|
Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier: diag(6666, 3 /* Message */, "Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier_6666", "Ensure overriding members in derived classes are marked with an override modifier."),
|
|
Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function: diag(6667, 3 /* Message */, "Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function_6667", "Enable error reporting for codepaths that do not explicitly return in a function."),
|
|
Enable_error_reporting_when_this_is_given_the_type_any: diag(6668, 3 /* Message */, "Enable_error_reporting_when_this_is_given_the_type_any_6668", "Enable error reporting when 'this' is given the type 'any'."),
|
|
Disable_adding_use_strict_directives_in_emitted_JavaScript_files: diag(6669, 3 /* Message */, "Disable_adding_use_strict_directives_in_emitted_JavaScript_files_6669", "Disable adding 'use strict' directives in emitted JavaScript files."),
|
|
Disable_including_any_library_files_including_the_default_lib_d_ts: diag(6670, 3 /* Message */, "Disable_including_any_library_files_including_the_default_lib_d_ts_6670", "Disable including any library files, including the default lib.d.ts."),
|
|
Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type: diag(6671, 3 /* Message */, "Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type_6671", "Enforces using indexed accessors for keys declared using an indexed type."),
|
|
Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project: diag(6672, 3 /* Message */, "Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add__6672", "Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project."),
|
|
Disable_strict_checking_of_generic_signatures_in_function_types: diag(6673, 3 /* Message */, "Disable_strict_checking_of_generic_signatures_in_function_types_6673", "Disable strict checking of generic signatures in function types."),
|
|
Add_undefined_to_a_type_when_accessed_using_an_index: diag(6674, 3 /* Message */, "Add_undefined_to_a_type_when_accessed_using_an_index_6674", "Add 'undefined' to a type when accessed using an index."),
|
|
Enable_error_reporting_when_local_variables_aren_t_read: diag(6675, 3 /* Message */, "Enable_error_reporting_when_local_variables_aren_t_read_6675", "Enable error reporting when local variables aren't read."),
|
|
Raise_an_error_when_a_function_parameter_isn_t_read: diag(6676, 3 /* Message */, "Raise_an_error_when_a_function_parameter_isn_t_read_6676", "Raise an error when a function parameter isn't read."),
|
|
Deprecated_setting_Use_outFile_instead: diag(6677, 3 /* Message */, "Deprecated_setting_Use_outFile_instead_6677", "Deprecated setting. Use 'outFile' instead."),
|
|
Specify_an_output_folder_for_all_emitted_files: diag(6678, 3 /* Message */, "Specify_an_output_folder_for_all_emitted_files_6678", "Specify an output folder for all emitted files."),
|
|
Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output: diag(6679, 3 /* Message */, "Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designa_6679", "Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output."),
|
|
Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations: diag(6680, 3 /* Message */, "Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations_6680", "Specify a set of entries that re-map imports to additional lookup locations."),
|
|
Specify_a_list_of_language_service_plugins_to_include: diag(6681, 3 /* Message */, "Specify_a_list_of_language_service_plugins_to_include_6681", "Specify a list of language service plugins to include."),
|
|
Disable_erasing_const_enum_declarations_in_generated_code: diag(6682, 3 /* Message */, "Disable_erasing_const_enum_declarations_in_generated_code_6682", "Disable erasing 'const enum' declarations in generated code."),
|
|
Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node: diag(6683, 3 /* Message */, "Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node_6683", "Disable resolving symlinks to their realpath. This correlates to the same flag in node."),
|
|
Disable_wiping_the_console_in_watch_mode: diag(6684, 3 /* Message */, "Disable_wiping_the_console_in_watch_mode_6684", "Disable wiping the console in watch mode."),
|
|
Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read: diag(6685, 3 /* Message */, "Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read_6685", "Enable color and formatting in TypeScript's output to make compiler errors easier to read."),
|
|
Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit: diag(6686, 3 /* Message */, "Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit_6686", "Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit."),
|
|
Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references: diag(6687, 3 /* Message */, "Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references_6687", "Specify an array of objects that specify paths for projects. Used in project references."),
|
|
Disable_emitting_comments: diag(6688, 3 /* Message */, "Disable_emitting_comments_6688", "Disable emitting comments."),
|
|
Enable_importing_json_files: diag(6689, 3 /* Message */, "Enable_importing_json_files_6689", "Enable importing .json files."),
|
|
Specify_the_root_folder_within_your_source_files: diag(6690, 3 /* Message */, "Specify_the_root_folder_within_your_source_files_6690", "Specify the root folder within your source files."),
|
|
Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules: diag(6691, 3 /* Message */, "Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules_6691", "Allow multiple folders to be treated as one when resolving modules."),
|
|
Skip_type_checking_d_ts_files_that_are_included_with_TypeScript: diag(6692, 3 /* Message */, "Skip_type_checking_d_ts_files_that_are_included_with_TypeScript_6692", "Skip type checking .d.ts files that are included with TypeScript."),
|
|
Skip_type_checking_all_d_ts_files: diag(6693, 3 /* Message */, "Skip_type_checking_all_d_ts_files_6693", "Skip type checking all .d.ts files."),
|
|
Create_source_map_files_for_emitted_JavaScript_files: diag(6694, 3 /* Message */, "Create_source_map_files_for_emitted_JavaScript_files_6694", "Create source map files for emitted JavaScript files."),
|
|
Specify_the_root_path_for_debuggers_to_find_the_reference_source_code: diag(6695, 3 /* Message */, "Specify_the_root_path_for_debuggers_to_find_the_reference_source_code_6695", "Specify the root path for debuggers to find the reference source code."),
|
|
Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function: diag(6697, 3 /* Message */, "Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function_6697", "Check that the arguments for 'bind', 'call', and 'apply' methods match the original function."),
|
|
When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible: diag(6698, 3 /* Message */, "When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible_6698", "When assigning functions, check to ensure parameters and the return values are subtype-compatible."),
|
|
When_type_checking_take_into_account_null_and_undefined: diag(6699, 3 /* Message */, "When_type_checking_take_into_account_null_and_undefined_6699", "When type checking, take into account 'null' and 'undefined'."),
|
|
Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor: diag(6700, 3 /* Message */, "Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor_6700", "Check for class properties that are declared but not set in the constructor."),
|
|
Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments: diag(6701, 3 /* Message */, "Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments_6701", "Disable emitting declarations that have '@internal' in their JSDoc comments."),
|
|
Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals: diag(6702, 3 /* Message */, "Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals_6702", "Disable reporting of excess property errors during the creation of object literals."),
|
|
Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures: diag(6703, 3 /* Message */, "Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures_6703", "Suppress 'noImplicitAny' errors when indexing objects that lack index signatures."),
|
|
Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively: diag(6704, 3 /* Message */, "Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_supp_6704", "Synchronously call callbacks and update the state of directory watchers on platforms that don`t support recursive watching natively."),
|
|
Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations: diag(6705, 3 /* Message */, "Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declaratio_6705", "Set the JavaScript language version for emitted JavaScript and include compatible library declarations."),
|
|
Log_paths_used_during_the_moduleResolution_process: diag(6706, 3 /* Message */, "Log_paths_used_during_the_moduleResolution_process_6706", "Log paths used during the 'moduleResolution' process."),
|
|
Specify_the_path_to_tsbuildinfo_incremental_compilation_file: diag(6707, 3 /* Message */, "Specify_the_path_to_tsbuildinfo_incremental_compilation_file_6707", "Specify the path to .tsbuildinfo incremental compilation file."),
|
|
Specify_options_for_automatic_acquisition_of_declaration_files: diag(6709, 3 /* Message */, "Specify_options_for_automatic_acquisition_of_declaration_files_6709", "Specify options for automatic acquisition of declaration files."),
|
|
Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types: diag(6710, 3 /* Message */, "Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types_6710", "Specify multiple folders that act like './node_modules/@types'."),
|
|
Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file: diag(6711, 3 /* Message */, "Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file_6711", "Specify type package names to be included without being referenced in a source file."),
|
|
Emit_ECMAScript_standard_compliant_class_fields: diag(6712, 3 /* Message */, "Emit_ECMAScript_standard_compliant_class_fields_6712", "Emit ECMAScript-standard-compliant class fields."),
|
|
Enable_verbose_logging: diag(6713, 3 /* Message */, "Enable_verbose_logging_6713", "Enable verbose logging."),
|
|
Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality: diag(6714, 3 /* Message */, "Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality_6714", "Specify how directories are watched on systems that lack recursive file-watching functionality."),
|
|
Specify_how_the_TypeScript_watch_mode_works: diag(6715, 3 /* Message */, "Specify_how_the_TypeScript_watch_mode_works_6715", "Specify how the TypeScript watch mode works."),
|
|
Require_undeclared_properties_from_index_signatures_to_use_element_accesses: diag(6717, 3 /* Message */, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6717", "Require undeclared properties from index signatures to use element accesses."),
|
|
Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, 3 /* Message */, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."),
|
|
Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, 3 /* Message */, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."),
|
|
one_of_Colon: diag(6900, 3 /* Message */, "one_of_Colon_6900", "one of:"),
|
|
one_or_more_Colon: diag(6901, 3 /* Message */, "one_or_more_Colon_6901", "one or more:"),
|
|
type_Colon: diag(6902, 3 /* Message */, "type_Colon_6902", "type:"),
|
|
default_Colon: diag(6903, 3 /* Message */, "default_Colon_6903", "default:"),
|
|
module_system_or_esModuleInterop: diag(6904, 3 /* Message */, "module_system_or_esModuleInterop_6904", 'module === "system" or esModuleInterop'),
|
|
false_unless_strict_is_set: diag(6905, 3 /* Message */, "false_unless_strict_is_set_6905", "`false`, unless `strict` is set"),
|
|
false_unless_composite_is_set: diag(6906, 3 /* Message */, "false_unless_composite_is_set_6906", "`false`, unless `composite` is set"),
|
|
node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified: diag(6907, 3 /* Message */, "node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified_6907", '`["node_modules", "bower_components", "jspm_packages"]`, plus the value of `outDir` if one is specified.'),
|
|
if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk: diag(6908, 3 /* Message */, "if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk_6908", '`[]` if `files` is specified, otherwise `["**/*"]`'),
|
|
true_if_composite_false_otherwise: diag(6909, 3 /* Message */, "true_if_composite_false_otherwise_6909", "`true` if `composite`, `false` otherwise"),
|
|
module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node: diag(69010, 3 /* Message */, "module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node_69010", "module === `AMD` or `UMD` or `System` or `ES6`, then `Classic`, Otherwise `Node`"),
|
|
Computed_from_the_list_of_input_files: diag(6911, 3 /* Message */, "Computed_from_the_list_of_input_files_6911", "Computed from the list of input files"),
|
|
Platform_specific: diag(6912, 3 /* Message */, "Platform_specific_6912", "Platform specific"),
|
|
You_can_learn_about_all_of_the_compiler_options_at_0: diag(6913, 3 /* Message */, "You_can_learn_about_all_of_the_compiler_options_at_0_6913", "You can learn about all of the compiler options at {0}"),
|
|
Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon: diag(6914, 3 /* Message */, "Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_conf_6914", "Including --watch, -w will start watching the current project for the file changes. Once set, you can config watch mode with:"),
|
|
Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0: diag(6915, 3 /* Message */, "Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_tr_6915", "Using --build, -b will make tsc behave more like a build orchestrator than a compiler. This is used to trigger building composite projects which you can learn more about at {0}"),
|
|
COMMON_COMMANDS: diag(6916, 3 /* Message */, "COMMON_COMMANDS_6916", "COMMON COMMANDS"),
|
|
ALL_COMPILER_OPTIONS: diag(6917, 3 /* Message */, "ALL_COMPILER_OPTIONS_6917", "ALL COMPILER OPTIONS"),
|
|
WATCH_OPTIONS: diag(6918, 3 /* Message */, "WATCH_OPTIONS_6918", "WATCH OPTIONS"),
|
|
BUILD_OPTIONS: diag(6919, 3 /* Message */, "BUILD_OPTIONS_6919", "BUILD OPTIONS"),
|
|
COMMON_COMPILER_OPTIONS: diag(6920, 3 /* Message */, "COMMON_COMPILER_OPTIONS_6920", "COMMON COMPILER OPTIONS"),
|
|
COMMAND_LINE_FLAGS: diag(6921, 3 /* Message */, "COMMAND_LINE_FLAGS_6921", "COMMAND LINE FLAGS"),
|
|
tsc_Colon_The_TypeScript_Compiler: diag(6922, 3 /* Message */, "tsc_Colon_The_TypeScript_Compiler_6922", "tsc: The TypeScript Compiler"),
|
|
Compiles_the_current_project_tsconfig_json_in_the_working_directory: diag(6923, 3 /* Message */, "Compiles_the_current_project_tsconfig_json_in_the_working_directory_6923", "Compiles the current project (tsconfig.json in the working directory.)"),
|
|
Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options: diag(6924, 3 /* Message */, "Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options_6924", "Ignoring tsconfig.json, compiles the specified files with default compiler options."),
|
|
Build_a_composite_project_in_the_working_directory: diag(6925, 3 /* Message */, "Build_a_composite_project_in_the_working_directory_6925", "Build a composite project in the working directory."),
|
|
Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory: diag(6926, 3 /* Message */, "Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory_6926", "Creates a tsconfig.json with the recommended settings in the working directory."),
|
|
Compiles_the_TypeScript_project_located_at_the_specified_path: diag(6927, 3 /* Message */, "Compiles_the_TypeScript_project_located_at_the_specified_path_6927", "Compiles the TypeScript project located at the specified path."),
|
|
An_expanded_version_of_this_information_showing_all_possible_compiler_options: diag(6928, 3 /* Message */, "An_expanded_version_of_this_information_showing_all_possible_compiler_options_6928", "An expanded version of this information, showing all possible compiler options"),
|
|
Compiles_the_current_project_with_additional_settings: diag(6929, 3 /* Message */, "Compiles_the_current_project_with_additional_settings_6929", "Compiles the current project, with additional settings."),
|
|
true_for_ES2022_and_above_including_ESNext: diag(6930, 3 /* Message */, "true_for_ES2022_and_above_including_ESNext_6930", "`true` for ES2022 and above, including ESNext."),
|
|
List_of_file_name_suffixes_to_search_when_resolving_a_module: diag(6931, 1 /* Error */, "List_of_file_name_suffixes_to_search_when_resolving_a_module_6931", "List of file name suffixes to search when resolving a module."),
|
|
Variable_0_implicitly_has_an_1_type: diag(7005, 1 /* 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, 1 /* Error */, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."),
|
|
Member_0_implicitly_has_an_1_type: diag(7008, 1 /* Error */, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."),
|
|
new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: diag(7009, 1 /* Error */, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."),
|
|
_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: diag(7010, 1 /* Error */, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."),
|
|
Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7011, 1 /* Error */, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."),
|
|
Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7013, 1 /* Error */, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."),
|
|
Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7014, 1 /* Error */, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."),
|
|
Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: diag(7015, 1 /* Error */, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."),
|
|
Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: diag(7016, 1 /* Error */, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."),
|
|
Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: diag(7017, 1 /* Error */, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."),
|
|
Object_literal_s_property_0_implicitly_has_an_1_type: diag(7018, 1 /* Error */, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."),
|
|
Rest_parameter_0_implicitly_has_an_any_type: diag(7019, 1 /* Error */, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."),
|
|
Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7020, 1 /* Error */, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."),
|
|
_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, 1 /* Error */, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."),
|
|
_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, 1 /* Error */, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."),
|
|
Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, 1 /* Error */, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."),
|
|
Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation: diag(7025, 1 /* Error */, "Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_retu_7025", "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation."),
|
|
JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, 1 /* Error */, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."),
|
|
Unreachable_code_detected: diag(7027, 1 /* Error */, "Unreachable_code_detected_7027", "Unreachable code detected.", true),
|
|
Unused_label: diag(7028, 1 /* Error */, "Unused_label_7028", "Unused label.", true),
|
|
Fallthrough_case_in_switch: diag(7029, 1 /* Error */, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."),
|
|
Not_all_code_paths_return_a_value: diag(7030, 1 /* Error */, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."),
|
|
Binding_element_0_implicitly_has_an_1_type: diag(7031, 1 /* Error */, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."),
|
|
Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, 1 /* Error */, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."),
|
|
Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, 1 /* Error */, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."),
|
|
Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, 1 /* Error */, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."),
|
|
Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, 1 /* Error */, "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035", "Try `npm i --save-dev @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"),
|
|
Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, 1 /* Error */, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."),
|
|
Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, 3 /* Message */, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."),
|
|
Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, 3 /* Message */, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."),
|
|
Mapped_object_type_implicitly_has_an_any_template_type: diag(7039, 1 /* Error */, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."),
|
|
If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: diag(7040, 1 /* Error */, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}'"),
|
|
The_containing_arrow_function_captures_the_global_value_of_this: diag(7041, 1 /* Error */, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."),
|
|
Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: diag(7042, 1 /* Error */, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."),
|
|
Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7043, 2 /* Suggestion */, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
|
|
Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7044, 2 /* Suggestion */, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
|
|
Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7045, 2 /* Suggestion */, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."),
|
|
Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: diag(7046, 2 /* Suggestion */, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."),
|
|
Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: diag(7047, 2 /* Suggestion */, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."),
|
|
Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: diag(7048, 2 /* Suggestion */, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."),
|
|
Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: diag(7049, 2 /* Suggestion */, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."),
|
|
_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: diag(7050, 2 /* Suggestion */, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."),
|
|
Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: diag(7051, 1 /* Error */, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"),
|
|
Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1: diag(7052, 1 /* Error */, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1_7052", "Element implicitly has an 'any' type because type '{0}' has no index signature. Did you mean to call '{1}'?"),
|
|
Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: diag(7053, 1 /* Error */, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."),
|
|
No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, 1 /* 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, 1 /* 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, 1 /* 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, 1 /* 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."),
|
|
If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1: diag(7058, 1 /* Error */, "If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_decl_7058", "If the '{0}' package actually exposes this module, try adding a new declaration (.d.ts) file containing `declare module '{1}';`"),
|
|
This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, 1 /* Error */, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."),
|
|
This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, 1 /* Error */, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."),
|
|
A_mapped_type_may_not_declare_properties_or_methods: diag(7061, 1 /* Error */, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."),
|
|
You_cannot_rename_this_element: diag(8e3, 1 /* 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, 1 /* 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, 1 /* Error */, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
|
|
export_can_only_be_used_in_TypeScript_files: diag(8003, 1 /* Error */, "export_can_only_be_used_in_TypeScript_files_8003", "'export =' can only be used in TypeScript files."),
|
|
Type_parameter_declarations_can_only_be_used_in_TypeScript_files: diag(8004, 1 /* Error */, "Type_parameter_declarations_can_only_be_used_in_TypeScript_files_8004", "Type parameter declarations can only be used in TypeScript files."),
|
|
implements_clauses_can_only_be_used_in_TypeScript_files: diag(8005, 1 /* Error */, "implements_clauses_can_only_be_used_in_TypeScript_files_8005", "'implements' clauses can only be used in TypeScript files."),
|
|
_0_declarations_can_only_be_used_in_TypeScript_files: diag(8006, 1 /* Error */, "_0_declarations_can_only_be_used_in_TypeScript_files_8006", "'{0}' declarations can only be used in TypeScript files."),
|
|
Type_aliases_can_only_be_used_in_TypeScript_files: diag(8008, 1 /* Error */, "Type_aliases_can_only_be_used_in_TypeScript_files_8008", "Type aliases can only be used in TypeScript files."),
|
|
The_0_modifier_can_only_be_used_in_TypeScript_files: diag(8009, 1 /* Error */, "The_0_modifier_can_only_be_used_in_TypeScript_files_8009", "The '{0}' modifier can only be used in TypeScript files."),
|
|
Type_annotations_can_only_be_used_in_TypeScript_files: diag(8010, 1 /* Error */, "Type_annotations_can_only_be_used_in_TypeScript_files_8010", "Type annotations can only be used in TypeScript files."),
|
|
Type_arguments_can_only_be_used_in_TypeScript_files: diag(8011, 1 /* Error */, "Type_arguments_can_only_be_used_in_TypeScript_files_8011", "Type arguments can only be used in TypeScript files."),
|
|
Parameter_modifiers_can_only_be_used_in_TypeScript_files: diag(8012, 1 /* Error */, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."),
|
|
Non_null_assertions_can_only_be_used_in_TypeScript_files: diag(8013, 1 /* Error */, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."),
|
|
Type_assertion_expressions_can_only_be_used_in_TypeScript_files: diag(8016, 1 /* Error */, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."),
|
|
Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, 1 /* Error */, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."),
|
|
Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, 1 /* Error */, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."),
|
|
Report_errors_in_js_files: diag(8019, 3 /* Message */, "Report_errors_in_js_files_8019", "Report errors in .js files."),
|
|
JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, 1 /* Error */, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."),
|
|
JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, 1 /* Error */, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."),
|
|
JSDoc_0_is_not_attached_to_a_class: diag(8022, 1 /* Error */, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."),
|
|
JSDoc_0_1_does_not_match_the_extends_2_clause: diag(8023, 1 /* Error */, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."),
|
|
JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: diag(8024, 1 /* Error */, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."),
|
|
Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: diag(8025, 1 /* Error */, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one '@augments' or '@extends' tag."),
|
|
Expected_0_type_arguments_provide_these_with_an_extends_tag: diag(8026, 1 /* Error */, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."),
|
|
Expected_0_1_type_arguments_provide_these_with_an_extends_tag: diag(8027, 1 /* Error */, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."),
|
|
JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: diag(8028, 1 /* Error */, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."),
|
|
JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: diag(8029, 1 /* Error */, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."),
|
|
The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, 1 /* Error */, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."),
|
|
You_cannot_rename_a_module_via_a_global_import: diag(8031, 1 /* Error */, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."),
|
|
Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, 1 /* Error */, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."),
|
|
A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: diag(8033, 1 /* Error */, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."),
|
|
The_tag_was_first_specified_here: diag(8034, 1 /* Error */, "The_tag_was_first_specified_here_8034", "The tag was first specified here."),
|
|
You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: diag(8035, 1 /* Error */, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."),
|
|
You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, 1 /* Error */, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."),
|
|
Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files: diag(8037, 1 /* Error */, "Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files_8037", "Type satisfaction expressions can only be used in TypeScript files."),
|
|
Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."),
|
|
Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, 1 /* Error */, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
|
|
JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17e3, 1 /* Error */, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
|
|
JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, 1 /* Error */, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."),
|
|
Expected_corresponding_JSX_closing_tag_for_0: diag(17002, 1 /* Error */, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."),
|
|
Cannot_use_JSX_unless_the_jsx_flag_is_provided: diag(17004, 1 /* Error */, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."),
|
|
A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: diag(17005, 1 /* Error */, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."),
|
|
An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17006, 1 /* Error */, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."),
|
|
A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17007, 1 /* Error */, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."),
|
|
JSX_element_0_has_no_corresponding_closing_tag: diag(17008, 1 /* Error */, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."),
|
|
super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: diag(17009, 1 /* Error */, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."),
|
|
Unknown_type_acquisition_option_0: diag(17010, 1 /* Error */, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."),
|
|
super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: diag(17011, 1 /* Error */, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."),
|
|
_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: diag(17012, 1 /* Error */, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"),
|
|
Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, 1 /* Error */, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."),
|
|
JSX_fragment_has_no_corresponding_closing_tag: diag(17014, 1 /* Error */, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."),
|
|
Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, 1 /* Error */, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."),
|
|
The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option: diag(17016, 1 /* Error */, "The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_com_17016", "The 'jsxFragmentFactory' compiler option must be provided to use JSX fragments with the 'jsxFactory' compiler option."),
|
|
An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments: diag(17017, 1 /* Error */, "An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments_17017", "An @jsxFrag pragma is required when using an @jsx pragma with JSX fragments."),
|
|
Unknown_type_acquisition_option_0_Did_you_mean_1: diag(17018, 1 /* Error */, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"),
|
|
Circularity_detected_while_resolving_configuration_Colon_0: diag(18e3, 1 /* Error */, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"),
|
|
The_files_list_in_config_file_0_is_empty: diag(18002, 1 /* Error */, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."),
|
|
No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: diag(18003, 1 /* Error */, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."),
|
|
File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module: diag(80001, 2 /* Suggestion */, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module_80001", "File is a CommonJS module; it may be converted to an ES module."),
|
|
This_constructor_function_may_be_converted_to_a_class_declaration: diag(80002, 2 /* Suggestion */, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."),
|
|
Import_may_be_converted_to_a_default_import: diag(80003, 2 /* Suggestion */, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."),
|
|
JSDoc_types_may_be_moved_to_TypeScript_types: diag(80004, 2 /* Suggestion */, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."),
|
|
require_call_may_be_converted_to_an_import: diag(80005, 2 /* Suggestion */, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."),
|
|
This_may_be_converted_to_an_async_function: diag(80006, 2 /* Suggestion */, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."),
|
|
await_has_no_effect_on_the_type_of_this_expression: diag(80007, 2 /* Suggestion */, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."),
|
|
Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, 2 /* Suggestion */, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."),
|
|
Add_missing_super_call: diag(90001, 3 /* Message */, "Add_missing_super_call_90001", "Add missing 'super()' call"),
|
|
Make_super_call_the_first_statement_in_the_constructor: diag(90002, 3 /* Message */, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"),
|
|
Change_extends_to_implements: diag(90003, 3 /* Message */, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"),
|
|
Remove_unused_declaration_for_Colon_0: diag(90004, 3 /* Message */, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"),
|
|
Remove_import_from_0: diag(90005, 3 /* Message */, "Remove_import_from_0_90005", "Remove import from '{0}'"),
|
|
Implement_interface_0: diag(90006, 3 /* Message */, "Implement_interface_0_90006", "Implement interface '{0}'"),
|
|
Implement_inherited_abstract_class: diag(90007, 3 /* Message */, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"),
|
|
Add_0_to_unresolved_variable: diag(90008, 3 /* Message */, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"),
|
|
Remove_variable_statement: diag(90010, 3 /* Message */, "Remove_variable_statement_90010", "Remove variable statement"),
|
|
Remove_template_tag: diag(90011, 3 /* Message */, "Remove_template_tag_90011", "Remove template tag"),
|
|
Remove_type_parameters: diag(90012, 3 /* Message */, "Remove_type_parameters_90012", "Remove type parameters"),
|
|
Import_0_from_1: diag(90013, 3 /* Message */, "Import_0_from_1_90013", `Import '{0}' from "{1}"`),
|
|
Change_0_to_1: diag(90014, 3 /* Message */, "Change_0_to_1_90014", "Change '{0}' to '{1}'"),
|
|
Declare_property_0: diag(90016, 3 /* Message */, "Declare_property_0_90016", "Declare property '{0}'"),
|
|
Add_index_signature_for_property_0: diag(90017, 3 /* Message */, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"),
|
|
Disable_checking_for_this_file: diag(90018, 3 /* Message */, "Disable_checking_for_this_file_90018", "Disable checking for this file"),
|
|
Ignore_this_error_message: diag(90019, 3 /* Message */, "Ignore_this_error_message_90019", "Ignore this error message"),
|
|
Initialize_property_0_in_the_constructor: diag(90020, 3 /* Message */, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"),
|
|
Initialize_static_property_0: diag(90021, 3 /* Message */, "Initialize_static_property_0_90021", "Initialize static property '{0}'"),
|
|
Change_spelling_to_0: diag(90022, 3 /* Message */, "Change_spelling_to_0_90022", "Change spelling to '{0}'"),
|
|
Declare_method_0: diag(90023, 3 /* Message */, "Declare_method_0_90023", "Declare method '{0}'"),
|
|
Declare_static_method_0: diag(90024, 3 /* Message */, "Declare_static_method_0_90024", "Declare static method '{0}'"),
|
|
Prefix_0_with_an_underscore: diag(90025, 3 /* Message */, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"),
|
|
Rewrite_as_the_indexed_access_type_0: diag(90026, 3 /* Message */, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"),
|
|
Declare_static_property_0: diag(90027, 3 /* Message */, "Declare_static_property_0_90027", "Declare static property '{0}'"),
|
|
Call_decorator_expression: diag(90028, 3 /* Message */, "Call_decorator_expression_90028", "Call decorator expression"),
|
|
Add_async_modifier_to_containing_function: diag(90029, 3 /* Message */, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"),
|
|
Replace_infer_0_with_unknown: diag(90030, 3 /* Message */, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"),
|
|
Replace_all_unused_infer_with_unknown: diag(90031, 3 /* Message */, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"),
|
|
Add_parameter_name: diag(90034, 3 /* Message */, "Add_parameter_name_90034", "Add parameter name"),
|
|
Declare_private_property_0: diag(90035, 3 /* Message */, "Declare_private_property_0_90035", "Declare private property '{0}'"),
|
|
Replace_0_with_Promise_1: diag(90036, 3 /* Message */, "Replace_0_with_Promise_1_90036", "Replace '{0}' with 'Promise<{1}>'"),
|
|
Fix_all_incorrect_return_type_of_an_async_functions: diag(90037, 3 /* Message */, "Fix_all_incorrect_return_type_of_an_async_functions_90037", "Fix all incorrect return type of an async functions"),
|
|
Declare_private_method_0: diag(90038, 3 /* Message */, "Declare_private_method_0_90038", "Declare private method '{0}'"),
|
|
Remove_unused_destructuring_declaration: diag(90039, 3 /* Message */, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"),
|
|
Remove_unused_declarations_for_Colon_0: diag(90041, 3 /* Message */, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
|
|
Declare_a_private_field_named_0: diag(90053, 3 /* Message */, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
|
|
Includes_imports_of_types_referenced_by_0: diag(90054, 3 /* Message */, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
|
|
Remove_type_from_import_declaration_from_0: diag(90055, 3 /* Message */, "Remove_type_from_import_declaration_from_0_90055", `Remove 'type' from import declaration from "{0}"`),
|
|
Remove_type_from_import_of_0_from_1: diag(90056, 3 /* Message */, "Remove_type_from_import_of_0_from_1_90056", `Remove 'type' from import of '{0}' from "{1}"`),
|
|
Add_import_from_0: diag(90057, 3 /* Message */, "Add_import_from_0_90057", 'Add import from "{0}"'),
|
|
Update_import_from_0: diag(90058, 3 /* Message */, "Update_import_from_0_90058", 'Update import from "{0}"'),
|
|
Export_0_from_module_1: diag(90059, 3 /* Message */, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
|
|
Export_all_referenced_locals: diag(90060, 3 /* Message */, "Export_all_referenced_locals_90060", "Export all referenced locals"),
|
|
Convert_function_to_an_ES2015_class: diag(95001, 3 /* Message */, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
|
|
Convert_0_to_1_in_0: diag(95003, 3 /* Message */, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
|
|
Extract_to_0_in_1: diag(95004, 3 /* Message */, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
|
|
Extract_function: diag(95005, 3 /* Message */, "Extract_function_95005", "Extract function"),
|
|
Extract_constant: diag(95006, 3 /* Message */, "Extract_constant_95006", "Extract constant"),
|
|
Extract_to_0_in_enclosing_scope: diag(95007, 3 /* Message */, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"),
|
|
Extract_to_0_in_1_scope: diag(95008, 3 /* Message */, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"),
|
|
Annotate_with_type_from_JSDoc: diag(95009, 3 /* Message */, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"),
|
|
Infer_type_of_0_from_usage: diag(95011, 3 /* Message */, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"),
|
|
Infer_parameter_types_from_usage: diag(95012, 3 /* Message */, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"),
|
|
Convert_to_default_import: diag(95013, 3 /* Message */, "Convert_to_default_import_95013", "Convert to default import"),
|
|
Install_0: diag(95014, 3 /* Message */, "Install_0_95014", "Install '{0}'"),
|
|
Replace_import_with_0: diag(95015, 3 /* Message */, "Replace_import_with_0_95015", "Replace import with '{0}'."),
|
|
Use_synthetic_default_member: diag(95016, 3 /* Message */, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."),
|
|
Convert_to_ES_module: diag(95017, 3 /* Message */, "Convert_to_ES_module_95017", "Convert to ES module"),
|
|
Add_undefined_type_to_property_0: diag(95018, 3 /* Message */, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"),
|
|
Add_initializer_to_property_0: diag(95019, 3 /* Message */, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"),
|
|
Add_definite_assignment_assertion_to_property_0: diag(95020, 3 /* Message */, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"),
|
|
Convert_all_type_literals_to_mapped_type: diag(95021, 3 /* Message */, "Convert_all_type_literals_to_mapped_type_95021", "Convert all type literals to mapped type"),
|
|
Add_all_missing_members: diag(95022, 3 /* Message */, "Add_all_missing_members_95022", "Add all missing members"),
|
|
Infer_all_types_from_usage: diag(95023, 3 /* Message */, "Infer_all_types_from_usage_95023", "Infer all types from usage"),
|
|
Delete_all_unused_declarations: diag(95024, 3 /* Message */, "Delete_all_unused_declarations_95024", "Delete all unused declarations"),
|
|
Prefix_all_unused_declarations_with_where_possible: diag(95025, 3 /* Message */, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"),
|
|
Fix_all_detected_spelling_errors: diag(95026, 3 /* Message */, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"),
|
|
Add_initializers_to_all_uninitialized_properties: diag(95027, 3 /* Message */, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"),
|
|
Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, 3 /* Message */, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"),
|
|
Add_undefined_type_to_all_uninitialized_properties: diag(95029, 3 /* Message */, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"),
|
|
Change_all_jsdoc_style_types_to_TypeScript: diag(95030, 3 /* Message */, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"),
|
|
Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: diag(95031, 3 /* Message */, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"),
|
|
Implement_all_unimplemented_interfaces: diag(95032, 3 /* Message */, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"),
|
|
Install_all_missing_types_packages: diag(95033, 3 /* Message */, "Install_all_missing_types_packages_95033", "Install all missing types packages"),
|
|
Rewrite_all_as_indexed_access_types: diag(95034, 3 /* Message */, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"),
|
|
Convert_all_to_default_imports: diag(95035, 3 /* Message */, "Convert_all_to_default_imports_95035", "Convert all to default imports"),
|
|
Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, 3 /* Message */, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"),
|
|
Add_qualifier_to_all_unresolved_variables_matching_a_member_name: diag(95037, 3 /* Message */, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"),
|
|
Change_all_extended_interfaces_to_implements: diag(95038, 3 /* Message */, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"),
|
|
Add_all_missing_super_calls: diag(95039, 3 /* Message */, "Add_all_missing_super_calls_95039", "Add all missing super calls"),
|
|
Implement_all_inherited_abstract_classes: diag(95040, 3 /* Message */, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"),
|
|
Add_all_missing_async_modifiers: diag(95041, 3 /* Message */, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"),
|
|
Add_ts_ignore_to_all_error_messages: diag(95042, 3 /* Message */, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"),
|
|
Annotate_everything_with_types_from_JSDoc: diag(95043, 3 /* Message */, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"),
|
|
Add_to_all_uncalled_decorators: diag(95044, 3 /* Message */, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"),
|
|
Convert_all_constructor_functions_to_classes: diag(95045, 3 /* Message */, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"),
|
|
Generate_get_and_set_accessors: diag(95046, 3 /* Message */, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"),
|
|
Convert_require_to_import: diag(95047, 3 /* Message */, "Convert_require_to_import_95047", "Convert 'require' to 'import'"),
|
|
Convert_all_require_to_import: diag(95048, 3 /* Message */, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"),
|
|
Move_to_a_new_file: diag(95049, 3 /* Message */, "Move_to_a_new_file_95049", "Move to a new file"),
|
|
Remove_unreachable_code: diag(95050, 3 /* Message */, "Remove_unreachable_code_95050", "Remove unreachable code"),
|
|
Remove_all_unreachable_code: diag(95051, 3 /* Message */, "Remove_all_unreachable_code_95051", "Remove all unreachable code"),
|
|
Add_missing_typeof: diag(95052, 3 /* Message */, "Add_missing_typeof_95052", "Add missing 'typeof'"),
|
|
Remove_unused_label: diag(95053, 3 /* Message */, "Remove_unused_label_95053", "Remove unused label"),
|
|
Remove_all_unused_labels: diag(95054, 3 /* Message */, "Remove_all_unused_labels_95054", "Remove all unused labels"),
|
|
Convert_0_to_mapped_object_type: diag(95055, 3 /* Message */, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"),
|
|
Convert_namespace_import_to_named_imports: diag(95056, 3 /* Message */, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"),
|
|
Convert_named_imports_to_namespace_import: diag(95057, 3 /* Message */, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"),
|
|
Add_or_remove_braces_in_an_arrow_function: diag(95058, 3 /* Message */, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"),
|
|
Add_braces_to_arrow_function: diag(95059, 3 /* Message */, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"),
|
|
Remove_braces_from_arrow_function: diag(95060, 3 /* Message */, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"),
|
|
Convert_default_export_to_named_export: diag(95061, 3 /* Message */, "Convert_default_export_to_named_export_95061", "Convert default export to named export"),
|
|
Convert_named_export_to_default_export: diag(95062, 3 /* Message */, "Convert_named_export_to_default_export_95062", "Convert named export to default export"),
|
|
Add_missing_enum_member_0: diag(95063, 3 /* Message */, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"),
|
|
Add_all_missing_imports: diag(95064, 3 /* Message */, "Add_all_missing_imports_95064", "Add all missing imports"),
|
|
Convert_to_async_function: diag(95065, 3 /* Message */, "Convert_to_async_function_95065", "Convert to async function"),
|
|
Convert_all_to_async_functions: diag(95066, 3 /* Message */, "Convert_all_to_async_functions_95066", "Convert all to async functions"),
|
|
Add_missing_call_parentheses: diag(95067, 3 /* Message */, "Add_missing_call_parentheses_95067", "Add missing call parentheses"),
|
|
Add_all_missing_call_parentheses: diag(95068, 3 /* Message */, "Add_all_missing_call_parentheses_95068", "Add all missing call parentheses"),
|
|
Add_unknown_conversion_for_non_overlapping_types: diag(95069, 3 /* Message */, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"),
|
|
Add_unknown_to_all_conversions_of_non_overlapping_types: diag(95070, 3 /* Message */, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"),
|
|
Add_missing_new_operator_to_call: diag(95071, 3 /* Message */, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"),
|
|
Add_missing_new_operator_to_all_calls: diag(95072, 3 /* Message */, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"),
|
|
Add_names_to_all_parameters_without_names: diag(95073, 3 /* Message */, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"),
|
|
Enable_the_experimentalDecorators_option_in_your_configuration_file: diag(95074, 3 /* Message */, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"),
|
|
Convert_parameters_to_destructured_object: diag(95075, 3 /* Message */, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"),
|
|
Extract_type: diag(95077, 3 /* Message */, "Extract_type_95077", "Extract type"),
|
|
Extract_to_type_alias: diag(95078, 3 /* Message */, "Extract_to_type_alias_95078", "Extract to type alias"),
|
|
Extract_to_typedef: diag(95079, 3 /* Message */, "Extract_to_typedef_95079", "Extract to typedef"),
|
|
Infer_this_type_of_0_from_usage: diag(95080, 3 /* Message */, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"),
|
|
Add_const_to_unresolved_variable: diag(95081, 3 /* Message */, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"),
|
|
Add_const_to_all_unresolved_variables: diag(95082, 3 /* Message */, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"),
|
|
Add_await: diag(95083, 3 /* Message */, "Add_await_95083", "Add 'await'"),
|
|
Add_await_to_initializer_for_0: diag(95084, 3 /* Message */, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"),
|
|
Fix_all_expressions_possibly_missing_await: diag(95085, 3 /* Message */, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"),
|
|
Remove_unnecessary_await: diag(95086, 3 /* Message */, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"),
|
|
Remove_all_unnecessary_uses_of_await: diag(95087, 3 /* Message */, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"),
|
|
Enable_the_jsx_flag_in_your_configuration_file: diag(95088, 3 /* Message */, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"),
|
|
Add_await_to_initializers: diag(95089, 3 /* Message */, "Add_await_to_initializers_95089", "Add 'await' to initializers"),
|
|
Extract_to_interface: diag(95090, 3 /* Message */, "Extract_to_interface_95090", "Extract to interface"),
|
|
Convert_to_a_bigint_numeric_literal: diag(95091, 3 /* Message */, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"),
|
|
Convert_all_to_bigint_numeric_literals: diag(95092, 3 /* Message */, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"),
|
|
Convert_const_to_let: diag(95093, 3 /* Message */, "Convert_const_to_let_95093", "Convert 'const' to 'let'"),
|
|
Prefix_with_declare: diag(95094, 3 /* Message */, "Prefix_with_declare_95094", "Prefix with 'declare'"),
|
|
Prefix_all_incorrect_property_declarations_with_declare: diag(95095, 3 /* Message */, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"),
|
|
Convert_to_template_string: diag(95096, 3 /* Message */, "Convert_to_template_string_95096", "Convert to template string"),
|
|
Add_export_to_make_this_file_into_a_module: diag(95097, 3 /* Message */, "Add_export_to_make_this_file_into_a_module_95097", "Add 'export {}' to make this file into a module"),
|
|
Set_the_target_option_in_your_configuration_file_to_0: diag(95098, 3 /* Message */, "Set_the_target_option_in_your_configuration_file_to_0_95098", "Set the 'target' option in your configuration file to '{0}'"),
|
|
Set_the_module_option_in_your_configuration_file_to_0: diag(95099, 3 /* Message */, "Set_the_module_option_in_your_configuration_file_to_0_95099", "Set the 'module' option in your configuration file to '{0}'"),
|
|
Convert_invalid_character_to_its_html_entity_code: diag(95100, 3 /* Message */, "Convert_invalid_character_to_its_html_entity_code_95100", "Convert invalid character to its html entity code"),
|
|
Convert_all_invalid_characters_to_HTML_entity_code: diag(95101, 3 /* Message */, "Convert_all_invalid_characters_to_HTML_entity_code_95101", "Convert all invalid characters to HTML entity code"),
|
|
Convert_all_const_to_let: diag(95102, 3 /* Message */, "Convert_all_const_to_let_95102", "Convert all 'const' to 'let'"),
|
|
Convert_function_expression_0_to_arrow_function: diag(95105, 3 /* Message */, "Convert_function_expression_0_to_arrow_function_95105", "Convert function expression '{0}' to arrow function"),
|
|
Convert_function_declaration_0_to_arrow_function: diag(95106, 3 /* Message */, "Convert_function_declaration_0_to_arrow_function_95106", "Convert function declaration '{0}' to arrow function"),
|
|
Fix_all_implicit_this_errors: diag(95107, 3 /* Message */, "Fix_all_implicit_this_errors_95107", "Fix all implicit-'this' errors"),
|
|
Wrap_invalid_character_in_an_expression_container: diag(95108, 3 /* Message */, "Wrap_invalid_character_in_an_expression_container_95108", "Wrap invalid character in an expression container"),
|
|
Wrap_all_invalid_characters_in_an_expression_container: diag(95109, 3 /* Message */, "Wrap_all_invalid_characters_in_an_expression_container_95109", "Wrap all invalid characters in an expression container"),
|
|
Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file: diag(95110, 3 /* Message */, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig to read more about this file"),
|
|
Add_a_return_statement: diag(95111, 3 /* Message */, "Add_a_return_statement_95111", "Add a return statement"),
|
|
Remove_braces_from_arrow_function_body: diag(95112, 3 /* Message */, "Remove_braces_from_arrow_function_body_95112", "Remove braces from arrow function body"),
|
|
Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal: diag(95113, 3 /* Message */, "Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal_95113", "Wrap the following body with parentheses which should be an object literal"),
|
|
Add_all_missing_return_statement: diag(95114, 3 /* Message */, "Add_all_missing_return_statement_95114", "Add all missing return statement"),
|
|
Remove_braces_from_all_arrow_function_bodies_with_relevant_issues: diag(95115, 3 /* Message */, "Remove_braces_from_all_arrow_function_bodies_with_relevant_issues_95115", "Remove braces from all arrow function bodies with relevant issues"),
|
|
Wrap_all_object_literal_with_parentheses: diag(95116, 3 /* Message */, "Wrap_all_object_literal_with_parentheses_95116", "Wrap all object literal with parentheses"),
|
|
Move_labeled_tuple_element_modifiers_to_labels: diag(95117, 3 /* Message */, "Move_labeled_tuple_element_modifiers_to_labels_95117", "Move labeled tuple element modifiers to labels"),
|
|
Convert_overload_list_to_single_signature: diag(95118, 3 /* Message */, "Convert_overload_list_to_single_signature_95118", "Convert overload list to single signature"),
|
|
Generate_get_and_set_accessors_for_all_overriding_properties: diag(95119, 3 /* Message */, "Generate_get_and_set_accessors_for_all_overriding_properties_95119", "Generate 'get' and 'set' accessors for all overriding properties"),
|
|
Wrap_in_JSX_fragment: diag(95120, 3 /* Message */, "Wrap_in_JSX_fragment_95120", "Wrap in JSX fragment"),
|
|
Wrap_all_unparented_JSX_in_JSX_fragment: diag(95121, 3 /* Message */, "Wrap_all_unparented_JSX_in_JSX_fragment_95121", "Wrap all unparented JSX in JSX fragment"),
|
|
Convert_arrow_function_or_function_expression: diag(95122, 3 /* Message */, "Convert_arrow_function_or_function_expression_95122", "Convert arrow function or function expression"),
|
|
Convert_to_anonymous_function: diag(95123, 3 /* Message */, "Convert_to_anonymous_function_95123", "Convert to anonymous function"),
|
|
Convert_to_named_function: diag(95124, 3 /* Message */, "Convert_to_named_function_95124", "Convert to named function"),
|
|
Convert_to_arrow_function: diag(95125, 3 /* Message */, "Convert_to_arrow_function_95125", "Convert to arrow function"),
|
|
Remove_parentheses: diag(95126, 3 /* Message */, "Remove_parentheses_95126", "Remove parentheses"),
|
|
Could_not_find_a_containing_arrow_function: diag(95127, 3 /* Message */, "Could_not_find_a_containing_arrow_function_95127", "Could not find a containing arrow function"),
|
|
Containing_function_is_not_an_arrow_function: diag(95128, 3 /* Message */, "Containing_function_is_not_an_arrow_function_95128", "Containing function is not an arrow function"),
|
|
Could_not_find_export_statement: diag(95129, 3 /* Message */, "Could_not_find_export_statement_95129", "Could not find export statement"),
|
|
This_file_already_has_a_default_export: diag(95130, 3 /* Message */, "This_file_already_has_a_default_export_95130", "This file already has a default export"),
|
|
Could_not_find_import_clause: diag(95131, 3 /* Message */, "Could_not_find_import_clause_95131", "Could not find import clause"),
|
|
Could_not_find_namespace_import_or_named_imports: diag(95132, 3 /* Message */, "Could_not_find_namespace_import_or_named_imports_95132", "Could not find namespace import or named imports"),
|
|
Selection_is_not_a_valid_type_node: diag(95133, 3 /* Message */, "Selection_is_not_a_valid_type_node_95133", "Selection is not a valid type node"),
|
|
No_type_could_be_extracted_from_this_type_node: diag(95134, 3 /* Message */, "No_type_could_be_extracted_from_this_type_node_95134", "No type could be extracted from this type node"),
|
|
Could_not_find_property_for_which_to_generate_accessor: diag(95135, 3 /* Message */, "Could_not_find_property_for_which_to_generate_accessor_95135", "Could not find property for which to generate accessor"),
|
|
Name_is_not_valid: diag(95136, 3 /* Message */, "Name_is_not_valid_95136", "Name is not valid"),
|
|
Can_only_convert_property_with_modifier: diag(95137, 3 /* Message */, "Can_only_convert_property_with_modifier_95137", "Can only convert property with modifier"),
|
|
Switch_each_misused_0_to_1: diag(95138, 3 /* Message */, "Switch_each_misused_0_to_1_95138", "Switch each misused '{0}' to '{1}'"),
|
|
Convert_to_optional_chain_expression: diag(95139, 3 /* Message */, "Convert_to_optional_chain_expression_95139", "Convert to optional chain expression"),
|
|
Could_not_find_convertible_access_expression: diag(95140, 3 /* Message */, "Could_not_find_convertible_access_expression_95140", "Could not find convertible access expression"),
|
|
Could_not_find_matching_access_expressions: diag(95141, 3 /* Message */, "Could_not_find_matching_access_expressions_95141", "Could not find matching access expressions"),
|
|
Can_only_convert_logical_AND_access_chains: diag(95142, 3 /* 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, 3 /* 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, 3 /* 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, 3 /* Message */, "Use_element_access_for_0_95145", "Use element access for '{0}'"),
|
|
Use_element_access_for_all_undeclared_properties: diag(95146, 3 /* Message */, "Use_element_access_for_all_undeclared_properties_95146", "Use element access for all undeclared properties."),
|
|
Delete_all_unused_imports: diag(95147, 3 /* Message */, "Delete_all_unused_imports_95147", "Delete all unused imports"),
|
|
Infer_function_return_type: diag(95148, 3 /* Message */, "Infer_function_return_type_95148", "Infer function return type"),
|
|
Return_type_must_be_inferred_from_a_function: diag(95149, 3 /* 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, 3 /* Message */, "Could_not_determine_function_return_type_95150", "Could not determine function return type"),
|
|
Could_not_convert_to_arrow_function: diag(95151, 3 /* Message */, "Could_not_convert_to_arrow_function_95151", "Could not convert to arrow function"),
|
|
Could_not_convert_to_named_function: diag(95152, 3 /* Message */, "Could_not_convert_to_named_function_95152", "Could not convert to named function"),
|
|
Could_not_convert_to_anonymous_function: diag(95153, 3 /* Message */, "Could_not_convert_to_anonymous_function_95153", "Could not convert to anonymous function"),
|
|
Can_only_convert_string_concatenation: diag(95154, 3 /* Message */, "Can_only_convert_string_concatenation_95154", "Can only convert string concatenation"),
|
|
Selection_is_not_a_valid_statement_or_statements: diag(95155, 3 /* 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, 3 /* Message */, "Add_missing_function_declaration_0_95156", "Add missing function declaration '{0}'"),
|
|
Add_all_missing_function_declarations: diag(95157, 3 /* Message */, "Add_all_missing_function_declarations_95157", "Add all missing function declarations"),
|
|
Method_not_implemented: diag(95158, 3 /* Message */, "Method_not_implemented_95158", "Method not implemented."),
|
|
Function_not_implemented: diag(95159, 3 /* Message */, "Function_not_implemented_95159", "Function not implemented."),
|
|
Add_override_modifier: diag(95160, 3 /* Message */, "Add_override_modifier_95160", "Add 'override' modifier"),
|
|
Remove_override_modifier: diag(95161, 3 /* Message */, "Remove_override_modifier_95161", "Remove 'override' modifier"),
|
|
Add_all_missing_override_modifiers: diag(95162, 3 /* Message */, "Add_all_missing_override_modifiers_95162", "Add all missing 'override' modifiers"),
|
|
Remove_all_unnecessary_override_modifiers: diag(95163, 3 /* Message */, "Remove_all_unnecessary_override_modifiers_95163", "Remove all unnecessary 'override' modifiers"),
|
|
Can_only_convert_named_export: diag(95164, 3 /* Message */, "Can_only_convert_named_export_95164", "Can only convert named export"),
|
|
Add_missing_properties: diag(95165, 3 /* Message */, "Add_missing_properties_95165", "Add missing properties"),
|
|
Add_all_missing_properties: diag(95166, 3 /* Message */, "Add_all_missing_properties_95166", "Add all missing properties"),
|
|
Add_missing_attributes: diag(95167, 3 /* Message */, "Add_missing_attributes_95167", "Add missing attributes"),
|
|
Add_all_missing_attributes: diag(95168, 3 /* Message */, "Add_all_missing_attributes_95168", "Add all missing attributes"),
|
|
Add_undefined_to_optional_property_type: diag(95169, 3 /* Message */, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
|
|
Convert_named_imports_to_default_import: diag(95170, 3 /* Message */, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
|
|
Delete_unused_param_tag_0: diag(95171, 3 /* Message */, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"),
|
|
Delete_all_unused_param_tags: diag(95172, 3 /* Message */, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"),
|
|
Rename_param_tag_name_0_to_1: diag(95173, 3 /* Message */, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"),
|
|
Use_0: diag(95174, 3 /* Message */, "Use_0_95174", "Use `{0}`."),
|
|
Use_Number_isNaN_in_all_conditions: diag(95175, 3 /* Message */, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."),
|
|
No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* 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, 1 /* 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, 1 /* 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?"),
|
|
Private_identifiers_cannot_be_used_as_parameters: diag(18009, 1 /* Error */, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters."),
|
|
An_accessibility_modifier_cannot_be_used_with_a_private_identifier: diag(18010, 1 /* Error */, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."),
|
|
The_operand_of_a_delete_operator_cannot_be_a_private_identifier: diag(18011, 1 /* Error */, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."),
|
|
constructor_is_a_reserved_word: diag(18012, 1 /* Error */, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."),
|
|
Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier: diag(18013, 1 /* Error */, "Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier_18013", "Property '{0}' is not accessible outside class '{1}' because it has a private identifier."),
|
|
The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling: diag(18014, 1 /* Error */, "The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_priv_18014", "The property '{0}' cannot be accessed on type '{1}' within this class because it is shadowed by another private identifier with the same spelling."),
|
|
Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2: diag(18015, 1 /* Error */, "Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2_18015", "Property '{0}' in type '{1}' refers to a different member that cannot be accessed from within type '{2}'."),
|
|
Private_identifiers_are_not_allowed_outside_class_bodies: diag(18016, 1 /* Error */, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."),
|
|
The_shadowing_declaration_of_0_is_defined_here: diag(18017, 1 /* Error */, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"),
|
|
The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: diag(18018, 1 /* Error */, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"),
|
|
_0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, 1 /* Error */, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier."),
|
|
An_enum_member_cannot_be_named_with_a_private_identifier: diag(18024, 1 /* Error */, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."),
|
|
can_only_be_used_at_the_start_of_a_file: diag(18026, 1 /* Error */, "can_only_be_used_at_the_start_of_a_file_18026", "'#!' can only be used at the start of a file."),
|
|
Compiler_reserves_name_0_when_emitting_private_identifier_downlevel: diag(18027, 1 /* Error */, "Compiler_reserves_name_0_when_emitting_private_identifier_downlevel_18027", "Compiler reserves name '{0}' when emitting private identifier downlevel."),
|
|
Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18028, 1 /* Error */, "Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher_18028", "Private identifiers are only available when targeting ECMAScript 2015 and higher."),
|
|
Private_identifiers_are_not_allowed_in_variable_declarations: diag(18029, 1 /* Error */, "Private_identifiers_are_not_allowed_in_variable_declarations_18029", "Private identifiers are not allowed in variable declarations."),
|
|
An_optional_chain_cannot_contain_private_identifiers: diag(18030, 1 /* Error */, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."),
|
|
The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: diag(18031, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."),
|
|
The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: diag(18032, 1 /* Error */, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."),
|
|
Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values: diag(18033, 1 /* Error */, "Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values_18033", "Type '{0}' is not assignable to type '{1}' as required for computed enum member values."),
|
|
Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, 3 /* Message */, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."),
|
|
Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(18035, 1 /* Error */, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."),
|
|
Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator: diag(18036, 1 /* Error */, "Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_dec_18036", "Class decorators can't be used with static private identifier. Consider removing the experimental decorator."),
|
|
Await_expression_cannot_be_used_inside_a_class_static_block: diag(18037, 1 /* Error */, "Await_expression_cannot_be_used_inside_a_class_static_block_18037", "Await expression cannot be used inside a class static block."),
|
|
For_await_loops_cannot_be_used_inside_a_class_static_block: diag(18038, 1 /* Error */, "For_await_loops_cannot_be_used_inside_a_class_static_block_18038", "'For await' loops cannot be used inside a class static block."),
|
|
Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block: diag(18039, 1 /* Error */, "Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block_18039", "Invalid use of '{0}'. It cannot be used inside a class static block."),
|
|
A_return_statement_cannot_be_used_inside_a_class_static_block: diag(18041, 1 /* Error */, "A_return_statement_cannot_be_used_inside_a_class_static_block_18041", "A 'return' statement cannot be used inside a class static block."),
|
|
_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation: diag(18042, 1 /* Error */, "_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation_18042", "'{0}' is a type and cannot be imported in JavaScript files. Use '{1}' in a JSDoc type annotation."),
|
|
Types_cannot_appear_in_export_declarations_in_JavaScript_files: diag(18043, 1 /* Error */, "Types_cannot_appear_in_export_declarations_in_JavaScript_files_18043", "Types cannot appear in export declarations in JavaScript files."),
|
|
_0_is_automatically_exported_here: diag(18044, 3 /* Message */, "_0_is_automatically_exported_here_18044", "'{0}' is automatically exported here."),
|
|
Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18045, 1 /* Error */, "Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher_18045", "Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher."),
|
|
_0_is_of_type_unknown: diag(18046, 1 /* Error */, "_0_is_of_type_unknown_18046", "'{0}' is of type 'unknown'."),
|
|
_0_is_possibly_null: diag(18047, 1 /* Error */, "_0_is_possibly_null_18047", "'{0}' is possibly 'null'."),
|
|
_0_is_possibly_undefined: diag(18048, 1 /* Error */, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."),
|
|
_0_is_possibly_null_or_undefined: diag(18049, 1 /* Error */, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."),
|
|
The_value_0_cannot_be_used_here: diag(18050, 1 /* Error */, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here.")
|
|
};
|
|
|
|
// src/compiler/scanner.ts
|
|
function tokenIsIdentifierOrKeyword(token) {
|
|
return token >= 79 /* Identifier */;
|
|
}
|
|
function tokenIsIdentifierOrKeywordOrGreaterThan(token) {
|
|
return token === 31 /* GreaterThanToken */ || tokenIsIdentifierOrKeyword(token);
|
|
}
|
|
var textToKeywordObj = {
|
|
abstract: 126 /* AbstractKeyword */,
|
|
accessor: 127 /* AccessorKeyword */,
|
|
any: 131 /* AnyKeyword */,
|
|
as: 128 /* AsKeyword */,
|
|
asserts: 129 /* AssertsKeyword */,
|
|
assert: 130 /* AssertKeyword */,
|
|
bigint: 160 /* BigIntKeyword */,
|
|
boolean: 134 /* BooleanKeyword */,
|
|
break: 81 /* BreakKeyword */,
|
|
case: 82 /* CaseKeyword */,
|
|
catch: 83 /* CatchKeyword */,
|
|
class: 84 /* ClassKeyword */,
|
|
continue: 86 /* ContinueKeyword */,
|
|
const: 85 /* ConstKeyword */,
|
|
["constructor"]: 135 /* ConstructorKeyword */,
|
|
debugger: 87 /* DebuggerKeyword */,
|
|
declare: 136 /* DeclareKeyword */,
|
|
default: 88 /* DefaultKeyword */,
|
|
delete: 89 /* DeleteKeyword */,
|
|
do: 90 /* DoKeyword */,
|
|
else: 91 /* ElseKeyword */,
|
|
enum: 92 /* EnumKeyword */,
|
|
export: 93 /* ExportKeyword */,
|
|
extends: 94 /* ExtendsKeyword */,
|
|
false: 95 /* FalseKeyword */,
|
|
finally: 96 /* FinallyKeyword */,
|
|
for: 97 /* ForKeyword */,
|
|
from: 158 /* FromKeyword */,
|
|
function: 98 /* FunctionKeyword */,
|
|
get: 137 /* GetKeyword */,
|
|
if: 99 /* IfKeyword */,
|
|
implements: 117 /* ImplementsKeyword */,
|
|
import: 100 /* ImportKeyword */,
|
|
in: 101 /* InKeyword */,
|
|
infer: 138 /* InferKeyword */,
|
|
instanceof: 102 /* InstanceOfKeyword */,
|
|
interface: 118 /* InterfaceKeyword */,
|
|
intrinsic: 139 /* IntrinsicKeyword */,
|
|
is: 140 /* IsKeyword */,
|
|
keyof: 141 /* KeyOfKeyword */,
|
|
let: 119 /* LetKeyword */,
|
|
module: 142 /* ModuleKeyword */,
|
|
namespace: 143 /* NamespaceKeyword */,
|
|
never: 144 /* NeverKeyword */,
|
|
new: 103 /* NewKeyword */,
|
|
null: 104 /* NullKeyword */,
|
|
number: 148 /* NumberKeyword */,
|
|
object: 149 /* ObjectKeyword */,
|
|
package: 120 /* PackageKeyword */,
|
|
private: 121 /* PrivateKeyword */,
|
|
protected: 122 /* ProtectedKeyword */,
|
|
public: 123 /* PublicKeyword */,
|
|
override: 161 /* OverrideKeyword */,
|
|
out: 145 /* OutKeyword */,
|
|
readonly: 146 /* ReadonlyKeyword */,
|
|
require: 147 /* RequireKeyword */,
|
|
global: 159 /* GlobalKeyword */,
|
|
return: 105 /* ReturnKeyword */,
|
|
satisfies: 150 /* SatisfiesKeyword */,
|
|
set: 151 /* SetKeyword */,
|
|
static: 124 /* StaticKeyword */,
|
|
string: 152 /* StringKeyword */,
|
|
super: 106 /* SuperKeyword */,
|
|
switch: 107 /* SwitchKeyword */,
|
|
symbol: 153 /* SymbolKeyword */,
|
|
this: 108 /* ThisKeyword */,
|
|
throw: 109 /* ThrowKeyword */,
|
|
true: 110 /* TrueKeyword */,
|
|
try: 111 /* TryKeyword */,
|
|
type: 154 /* TypeKeyword */,
|
|
typeof: 112 /* TypeOfKeyword */,
|
|
undefined: 155 /* UndefinedKeyword */,
|
|
unique: 156 /* UniqueKeyword */,
|
|
unknown: 157 /* UnknownKeyword */,
|
|
var: 113 /* VarKeyword */,
|
|
void: 114 /* VoidKeyword */,
|
|
while: 115 /* WhileKeyword */,
|
|
with: 116 /* WithKeyword */,
|
|
yield: 125 /* YieldKeyword */,
|
|
async: 132 /* AsyncKeyword */,
|
|
await: 133 /* AwaitKeyword */,
|
|
of: 162 /* OfKeyword */
|
|
};
|
|
var textToKeyword = new Map(getEntries(textToKeywordObj));
|
|
var textToToken = new Map(getEntries({
|
|
...textToKeywordObj,
|
|
"{": 18 /* OpenBraceToken */,
|
|
"}": 19 /* CloseBraceToken */,
|
|
"(": 20 /* OpenParenToken */,
|
|
")": 21 /* CloseParenToken */,
|
|
"[": 22 /* OpenBracketToken */,
|
|
"]": 23 /* CloseBracketToken */,
|
|
".": 24 /* DotToken */,
|
|
"...": 25 /* DotDotDotToken */,
|
|
";": 26 /* SemicolonToken */,
|
|
",": 27 /* CommaToken */,
|
|
"<": 29 /* LessThanToken */,
|
|
">": 31 /* GreaterThanToken */,
|
|
"<=": 32 /* LessThanEqualsToken */,
|
|
">=": 33 /* GreaterThanEqualsToken */,
|
|
"==": 34 /* EqualsEqualsToken */,
|
|
"!=": 35 /* ExclamationEqualsToken */,
|
|
"===": 36 /* EqualsEqualsEqualsToken */,
|
|
"!==": 37 /* ExclamationEqualsEqualsToken */,
|
|
"=>": 38 /* EqualsGreaterThanToken */,
|
|
"+": 39 /* PlusToken */,
|
|
"-": 40 /* MinusToken */,
|
|
"**": 42 /* AsteriskAsteriskToken */,
|
|
"*": 41 /* AsteriskToken */,
|
|
"/": 43 /* SlashToken */,
|
|
"%": 44 /* PercentToken */,
|
|
"++": 45 /* PlusPlusToken */,
|
|
"--": 46 /* MinusMinusToken */,
|
|
"<<": 47 /* LessThanLessThanToken */,
|
|
"</": 30 /* LessThanSlashToken */,
|
|
">>": 48 /* GreaterThanGreaterThanToken */,
|
|
">>>": 49 /* GreaterThanGreaterThanGreaterThanToken */,
|
|
"&": 50 /* AmpersandToken */,
|
|
"|": 51 /* BarToken */,
|
|
"^": 52 /* CaretToken */,
|
|
"!": 53 /* ExclamationToken */,
|
|
"~": 54 /* TildeToken */,
|
|
"&&": 55 /* AmpersandAmpersandToken */,
|
|
"||": 56 /* BarBarToken */,
|
|
"?": 57 /* QuestionToken */,
|
|
"??": 60 /* QuestionQuestionToken */,
|
|
"?.": 28 /* QuestionDotToken */,
|
|
":": 58 /* ColonToken */,
|
|
"=": 63 /* EqualsToken */,
|
|
"+=": 64 /* PlusEqualsToken */,
|
|
"-=": 65 /* MinusEqualsToken */,
|
|
"*=": 66 /* AsteriskEqualsToken */,
|
|
"**=": 67 /* AsteriskAsteriskEqualsToken */,
|
|
"/=": 68 /* SlashEqualsToken */,
|
|
"%=": 69 /* PercentEqualsToken */,
|
|
"<<=": 70 /* LessThanLessThanEqualsToken */,
|
|
">>=": 71 /* GreaterThanGreaterThanEqualsToken */,
|
|
">>>=": 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */,
|
|
"&=": 73 /* AmpersandEqualsToken */,
|
|
"|=": 74 /* BarEqualsToken */,
|
|
"^=": 78 /* CaretEqualsToken */,
|
|
"||=": 75 /* BarBarEqualsToken */,
|
|
"&&=": 76 /* AmpersandAmpersandEqualsToken */,
|
|
"??=": 77 /* QuestionQuestionEqualsToken */,
|
|
"@": 59 /* AtToken */,
|
|
"#": 62 /* HashToken */,
|
|
"`": 61 /* BacktickToken */
|
|
}));
|
|
var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
|
|
var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
|
|
var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
|
|
var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43e3, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500];
|
|
var unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2208, 2228, 2230, 2237, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6e3, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69376, 69404, 69415, 69415, 69424, 69445, 69600, 69622, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70751, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71680, 71723, 71840, 71903, 71935, 71935, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 123136, 123180, 123191, 123197, 123214, 123214, 123584, 123627, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101];
|
|
var unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2208, 2228, 2230, 2237, 2259, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3328, 3331, 3333, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6e3, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7673, 7675, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43047, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69376, 69404, 69415, 69415, 69424, 69456, 69600, 69622, 69632, 69702, 69734, 69743, 69759, 69818, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69958, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70096, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70206, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70751, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71680, 71738, 71840, 71913, 71935, 71935, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123584, 123641, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999];
|
|
var commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/;
|
|
var commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/;
|
|
function lookupInUnicodeMap(code, map2) {
|
|
if (code < map2[0]) {
|
|
return false;
|
|
}
|
|
let lo = 0;
|
|
let hi = map2.length;
|
|
let mid;
|
|
while (lo + 1 < hi) {
|
|
mid = lo + (hi - lo) / 2;
|
|
mid -= mid % 2;
|
|
if (map2[mid] <= code && code <= map2[mid + 1]) {
|
|
return true;
|
|
}
|
|
if (code < map2[mid]) {
|
|
hi = mid;
|
|
} else {
|
|
lo = mid + 2;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isUnicodeIdentifierStart(code, languageVersion) {
|
|
return languageVersion >= 2 /* ES2015 */ ? lookupInUnicodeMap(code, unicodeESNextIdentifierStart) : languageVersion === 1 /* ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : lookupInUnicodeMap(code, unicodeES3IdentifierStart);
|
|
}
|
|
function isUnicodeIdentifierPart(code, languageVersion) {
|
|
return languageVersion >= 2 /* ES2015 */ ? lookupInUnicodeMap(code, unicodeESNextIdentifierPart) : languageVersion === 1 /* ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : lookupInUnicodeMap(code, unicodeES3IdentifierPart);
|
|
}
|
|
function makeReverseMap(source) {
|
|
const result = [];
|
|
source.forEach((value, name) => {
|
|
result[value] = name;
|
|
});
|
|
return result;
|
|
}
|
|
var tokenStrings = makeReverseMap(textToToken);
|
|
function tokenToString(t) {
|
|
return tokenStrings[t];
|
|
}
|
|
function stringToToken(s) {
|
|
return textToToken.get(s);
|
|
}
|
|
function computeLineStarts(text) {
|
|
const result = [];
|
|
let pos = 0;
|
|
let lineStart = 0;
|
|
while (pos < text.length) {
|
|
const ch = text.charCodeAt(pos);
|
|
pos++;
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
result.push(lineStart);
|
|
lineStart = pos;
|
|
break;
|
|
default:
|
|
if (ch > 127 /* maxAsciiCharacter */ && isLineBreak(ch)) {
|
|
result.push(lineStart);
|
|
lineStart = pos;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
result.push(lineStart);
|
|
return result;
|
|
}
|
|
function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) {
|
|
return sourceFile.getPositionOfLineAndCharacter ? sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) : computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits);
|
|
}
|
|
function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) {
|
|
if (line < 0 || line >= lineStarts.length) {
|
|
if (allowEdits) {
|
|
line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line;
|
|
} else {
|
|
Debug.fail(`Bad line number. Line: ${line}, lineStarts.length: ${lineStarts.length} , line map is correct? ${debugText !== void 0 ? arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown"}`);
|
|
}
|
|
}
|
|
const res = lineStarts[line] + character;
|
|
if (allowEdits) {
|
|
return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res;
|
|
}
|
|
if (line < lineStarts.length - 1) {
|
|
Debug.assert(res < lineStarts[line + 1]);
|
|
} else if (debugText !== void 0) {
|
|
Debug.assert(res <= debugText.length);
|
|
}
|
|
return res;
|
|
}
|
|
function getLineStarts(sourceFile) {
|
|
return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text));
|
|
}
|
|
function computeLineAndCharacterOfPosition(lineStarts, position) {
|
|
const lineNumber = computeLineOfPosition(lineStarts, position);
|
|
return {
|
|
line: lineNumber,
|
|
character: position - lineStarts[lineNumber]
|
|
};
|
|
}
|
|
function computeLineOfPosition(lineStarts, position, lowerBound) {
|
|
let lineNumber = binarySearch(lineStarts, position, identity, compareValues, lowerBound);
|
|
if (lineNumber < 0) {
|
|
lineNumber = ~lineNumber - 1;
|
|
Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file");
|
|
}
|
|
return lineNumber;
|
|
}
|
|
function getLinesBetweenPositions(sourceFile, pos1, pos2) {
|
|
if (pos1 === pos2)
|
|
return 0;
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
const lower = Math.min(pos1, pos2);
|
|
const isNegative = lower === pos2;
|
|
const upper = isNegative ? pos1 : pos2;
|
|
const lowerLine = computeLineOfPosition(lineStarts, lower);
|
|
const upperLine = computeLineOfPosition(lineStarts, upper, lowerLine);
|
|
return isNegative ? lowerLine - upperLine : upperLine - lowerLine;
|
|
}
|
|
function getLineAndCharacterOfPosition(sourceFile, position) {
|
|
return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position);
|
|
}
|
|
function isWhiteSpaceLike(ch) {
|
|
return isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
|
|
}
|
|
function isWhiteSpaceSingleLine(ch) {
|
|
return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ || ch === 160 /* nonBreakingSpace */ || ch === 133 /* nextLine */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ || ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;
|
|
}
|
|
function isLineBreak(ch) {
|
|
return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;
|
|
}
|
|
function isDigit(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
|
|
}
|
|
function isHexDigit(ch) {
|
|
return isDigit(ch) || ch >= 65 /* A */ && ch <= 70 /* F */ || ch >= 97 /* a */ && ch <= 102 /* f */;
|
|
}
|
|
function isCodePoint(code) {
|
|
return code <= 1114111;
|
|
}
|
|
function isOctalDigit(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 55 /* _7 */;
|
|
}
|
|
function couldStartTrivia(text, pos) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
case 10 /* lineFeed */:
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
case 47 /* slash */:
|
|
case 60 /* lessThan */:
|
|
case 124 /* bar */:
|
|
case 61 /* equals */:
|
|
case 62 /* greaterThan */:
|
|
return true;
|
|
case 35 /* hash */:
|
|
return pos === 0;
|
|
default:
|
|
return ch > 127 /* maxAsciiCharacter */;
|
|
}
|
|
}
|
|
function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) {
|
|
if (positionIsSynthesized(pos)) {
|
|
return pos;
|
|
}
|
|
let canConsumeStar = false;
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
pos++;
|
|
if (stopAfterLineBreak) {
|
|
return pos;
|
|
}
|
|
canConsumeStar = !!inJSDoc;
|
|
continue;
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
pos++;
|
|
continue;
|
|
case 47 /* slash */:
|
|
if (stopAtComments) {
|
|
break;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
while (pos < text.length) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
pos += 2;
|
|
while (pos < text.length) {
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 60 /* lessThan */:
|
|
case 124 /* bar */:
|
|
case 61 /* equals */:
|
|
case 62 /* greaterThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos);
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 35 /* hash */:
|
|
if (pos === 0 && isShebangTrivia(text, pos)) {
|
|
pos = scanShebangTrivia(text, pos);
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
case 42 /* asterisk */:
|
|
if (canConsumeStar) {
|
|
pos++;
|
|
canConsumeStar = false;
|
|
continue;
|
|
}
|
|
break;
|
|
default:
|
|
if (ch > 127 /* maxAsciiCharacter */ && isWhiteSpaceLike(ch)) {
|
|
pos++;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
return pos;
|
|
}
|
|
}
|
|
var mergeConflictMarkerLength = "<<<<<<<".length;
|
|
function isConflictMarkerTrivia(text, pos) {
|
|
Debug.assert(pos >= 0);
|
|
if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (pos + mergeConflictMarkerLength < text.length) {
|
|
for (let i = 0; i < mergeConflictMarkerLength; i++) {
|
|
if (text.charCodeAt(pos + i) !== ch) {
|
|
return false;
|
|
}
|
|
}
|
|
return ch === 61 /* equals */ || text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* space */;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function scanConflictMarkerTrivia(text, pos, error) {
|
|
if (error) {
|
|
error(Diagnostics.Merge_conflict_marker_encountered, pos, mergeConflictMarkerLength);
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
const len = text.length;
|
|
if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) {
|
|
while (pos < len && !isLineBreak(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
} else {
|
|
Debug.assert(ch === 124 /* bar */ || ch === 61 /* equals */);
|
|
while (pos < len) {
|
|
const currentChar = text.charCodeAt(pos);
|
|
if ((currentChar === 61 /* equals */ || currentChar === 62 /* greaterThan */) && currentChar !== ch && isConflictMarkerTrivia(text, pos)) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
}
|
|
return pos;
|
|
}
|
|
var shebangTriviaRegex = /^#!.*/;
|
|
function isShebangTrivia(text, pos) {
|
|
Debug.assert(pos === 0);
|
|
return shebangTriviaRegex.test(text);
|
|
}
|
|
function scanShebangTrivia(text, pos) {
|
|
const shebang = shebangTriviaRegex.exec(text)[0];
|
|
pos = pos + shebang.length;
|
|
return pos;
|
|
}
|
|
function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) {
|
|
let pendingPos;
|
|
let pendingEnd;
|
|
let pendingKind;
|
|
let pendingHasTrailingNewLine;
|
|
let hasPendingCommentRange = false;
|
|
let collecting = trailing;
|
|
let accumulator = initial;
|
|
if (pos === 0) {
|
|
collecting = true;
|
|
const shebang = getShebang(text);
|
|
if (shebang) {
|
|
pos = shebang.length;
|
|
}
|
|
}
|
|
scan:
|
|
while (pos >= 0 && pos < text.length) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
pos++;
|
|
if (trailing) {
|
|
break scan;
|
|
}
|
|
collecting = true;
|
|
if (hasPendingCommentRange) {
|
|
pendingHasTrailingNewLine = true;
|
|
}
|
|
continue;
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
pos++;
|
|
continue;
|
|
case 47 /* slash */:
|
|
const nextChar = text.charCodeAt(pos + 1);
|
|
let hasTrailingNewLine = false;
|
|
if (nextChar === 47 /* slash */ || nextChar === 42 /* asterisk */) {
|
|
const kind = nextChar === 47 /* slash */ ? 2 /* SingleLineCommentTrivia */ : 3 /* MultiLineCommentTrivia */;
|
|
const startPos = pos;
|
|
pos += 2;
|
|
if (nextChar === 47 /* slash */) {
|
|
while (pos < text.length) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
hasTrailingNewLine = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
} else {
|
|
while (pos < text.length) {
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
}
|
|
if (collecting) {
|
|
if (hasPendingCommentRange) {
|
|
accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
|
|
if (!reduce && accumulator) {
|
|
return accumulator;
|
|
}
|
|
}
|
|
pendingPos = startPos;
|
|
pendingEnd = pos;
|
|
pendingKind = kind;
|
|
pendingHasTrailingNewLine = hasTrailingNewLine;
|
|
hasPendingCommentRange = true;
|
|
}
|
|
continue;
|
|
}
|
|
break scan;
|
|
default:
|
|
if (ch > 127 /* maxAsciiCharacter */ && isWhiteSpaceLike(ch)) {
|
|
if (hasPendingCommentRange && isLineBreak(ch)) {
|
|
pendingHasTrailingNewLine = true;
|
|
}
|
|
pos++;
|
|
continue;
|
|
}
|
|
break scan;
|
|
}
|
|
}
|
|
if (hasPendingCommentRange) {
|
|
accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator);
|
|
}
|
|
return accumulator;
|
|
}
|
|
function forEachLeadingCommentRange(text, pos, cb, state) {
|
|
return iterateCommentRanges(false, text, pos, false, cb, state);
|
|
}
|
|
function forEachTrailingCommentRange(text, pos, cb, state) {
|
|
return iterateCommentRanges(false, text, pos, true, cb, state);
|
|
}
|
|
function reduceEachLeadingCommentRange(text, pos, cb, state, initial) {
|
|
return iterateCommentRanges(true, text, pos, false, cb, state, initial);
|
|
}
|
|
function reduceEachTrailingCommentRange(text, pos, cb, state, initial) {
|
|
return iterateCommentRanges(true, text, pos, true, cb, state, initial);
|
|
}
|
|
function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) {
|
|
if (!comments) {
|
|
comments = [];
|
|
}
|
|
comments.push({ kind, pos, end, hasTrailingNewLine });
|
|
return comments;
|
|
}
|
|
function getLeadingCommentRanges(text, pos) {
|
|
return reduceEachLeadingCommentRange(text, pos, appendCommentRange, void 0, void 0);
|
|
}
|
|
function getTrailingCommentRanges(text, pos) {
|
|
return reduceEachTrailingCommentRange(text, pos, appendCommentRange, void 0, void 0);
|
|
}
|
|
function getShebang(text) {
|
|
const match = shebangTriviaRegex.exec(text);
|
|
if (match) {
|
|
return match[0];
|
|
}
|
|
}
|
|
function isIdentifierStart(ch, languageVersion) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch === 36 /* $ */ || ch === 95 /* _ */ || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion);
|
|
}
|
|
function isIdentifierPart(ch, languageVersion, identifierVariant) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ || ch >= 97 /* a */ && ch <= 122 /* z */ || ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch === 36 /* $ */ || ch === 95 /* _ */ || (identifierVariant === 1 /* JSX */ ? ch === 45 /* minus */ || ch === 58 /* colon */ : false) || ch > 127 /* maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion);
|
|
}
|
|
function isIdentifierText(name, languageVersion, identifierVariant) {
|
|
let ch = codePointAt(name, 0);
|
|
if (!isIdentifierStart(ch, languageVersion)) {
|
|
return false;
|
|
}
|
|
for (let i = charSize(ch); i < name.length; i += charSize(ch)) {
|
|
if (!isIdentifierPart(ch = codePointAt(name, i), languageVersion, identifierVariant)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Standard */, textInitial, onError, start2, length2) {
|
|
let text = textInitial;
|
|
let pos;
|
|
let end;
|
|
let startPos;
|
|
let tokenPos;
|
|
let token;
|
|
let tokenValue;
|
|
let tokenFlags;
|
|
let commentDirectives;
|
|
let inJSDocType = 0;
|
|
setText(text, start2, length2);
|
|
const scanner2 = {
|
|
getStartPos: () => startPos,
|
|
getTextPos: () => pos,
|
|
getToken: () => token,
|
|
getTokenPos: () => tokenPos,
|
|
getTokenText: () => text.substring(tokenPos, pos),
|
|
getTokenValue: () => tokenValue,
|
|
hasUnicodeEscape: () => (tokenFlags & 1024 /* UnicodeEscape */) !== 0,
|
|
hasExtendedUnicodeEscape: () => (tokenFlags & 8 /* ExtendedUnicodeEscape */) !== 0,
|
|
hasPrecedingLineBreak: () => (tokenFlags & 1 /* PrecedingLineBreak */) !== 0,
|
|
hasPrecedingJSDocComment: () => (tokenFlags & 2 /* PrecedingJSDocComment */) !== 0,
|
|
isIdentifier: () => token === 79 /* Identifier */ || token > 116 /* LastReservedWord */,
|
|
isReservedWord: () => token >= 81 /* FirstReservedWord */ && token <= 116 /* LastReservedWord */,
|
|
isUnterminated: () => (tokenFlags & 4 /* Unterminated */) !== 0,
|
|
getCommentDirectives: () => commentDirectives,
|
|
getNumericLiteralFlags: () => tokenFlags & 1008 /* NumericLiteralFlags */,
|
|
getTokenFlags: () => tokenFlags,
|
|
reScanGreaterToken,
|
|
reScanAsteriskEqualsToken,
|
|
reScanSlashToken,
|
|
reScanTemplateToken,
|
|
reScanTemplateHeadOrNoSubstitutionTemplate,
|
|
scanJsxIdentifier,
|
|
scanJsxAttributeValue,
|
|
reScanJsxAttributeValue,
|
|
reScanJsxToken,
|
|
reScanLessThanToken,
|
|
reScanHashToken,
|
|
reScanQuestionToken,
|
|
reScanInvalidIdentifier,
|
|
scanJsxToken,
|
|
scanJsDocToken,
|
|
scan,
|
|
getText,
|
|
clearCommentDirectives,
|
|
setText,
|
|
setScriptTarget,
|
|
setLanguageVariant,
|
|
setOnError,
|
|
setTextPos,
|
|
setInJSDocType,
|
|
tryScan,
|
|
lookAhead,
|
|
scanRange
|
|
};
|
|
if (Debug.isDebugging) {
|
|
Object.defineProperty(scanner2, "__debugShowCurrentPositionInText", {
|
|
get: () => {
|
|
const text2 = scanner2.getText();
|
|
return text2.slice(0, scanner2.getStartPos()) + "\u2551" + text2.slice(scanner2.getStartPos());
|
|
}
|
|
});
|
|
}
|
|
return scanner2;
|
|
function error(message, errPos = pos, length3) {
|
|
if (onError) {
|
|
const oldPos = pos;
|
|
pos = errPos;
|
|
onError(message, length3 || 0);
|
|
pos = oldPos;
|
|
}
|
|
}
|
|
function scanNumberFragment() {
|
|
let start3 = pos;
|
|
let allowSeparator = false;
|
|
let isPreviousTokenSeparator = false;
|
|
let result = "";
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (allowSeparator) {
|
|
allowSeparator = false;
|
|
isPreviousTokenSeparator = true;
|
|
result += text.substring(start3, pos);
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
start3 = pos;
|
|
continue;
|
|
}
|
|
if (isDigit(ch)) {
|
|
allowSeparator = true;
|
|
isPreviousTokenSeparator = false;
|
|
pos++;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return result + text.substring(start3, pos);
|
|
}
|
|
function scanNumber() {
|
|
const start3 = pos;
|
|
const mainFragment = scanNumberFragment();
|
|
let decimalFragment;
|
|
let scientificFragment;
|
|
if (text.charCodeAt(pos) === 46 /* dot */) {
|
|
pos++;
|
|
decimalFragment = scanNumberFragment();
|
|
}
|
|
let end2 = pos;
|
|
if (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */) {
|
|
pos++;
|
|
tokenFlags |= 16 /* Scientific */;
|
|
if (text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */)
|
|
pos++;
|
|
const preNumericPart = pos;
|
|
const finalFragment = scanNumberFragment();
|
|
if (!finalFragment) {
|
|
error(Diagnostics.Digit_expected);
|
|
} else {
|
|
scientificFragment = text.substring(end2, preNumericPart) + finalFragment;
|
|
end2 = pos;
|
|
}
|
|
}
|
|
let result;
|
|
if (tokenFlags & 512 /* ContainsSeparator */) {
|
|
result = mainFragment;
|
|
if (decimalFragment) {
|
|
result += "." + decimalFragment;
|
|
}
|
|
if (scientificFragment) {
|
|
result += scientificFragment;
|
|
}
|
|
} else {
|
|
result = text.substring(start3, end2);
|
|
}
|
|
if (decimalFragment !== void 0 || tokenFlags & 16 /* Scientific */) {
|
|
checkForIdentifierStartAfterNumericLiteral(start3, decimalFragment === void 0 && !!(tokenFlags & 16 /* Scientific */));
|
|
return {
|
|
type: 8 /* NumericLiteral */,
|
|
value: "" + +result
|
|
};
|
|
} else {
|
|
tokenValue = result;
|
|
const type = checkBigIntSuffix();
|
|
checkForIdentifierStartAfterNumericLiteral(start3);
|
|
return { type, value: tokenValue };
|
|
}
|
|
}
|
|
function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) {
|
|
if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) {
|
|
return;
|
|
}
|
|
const identifierStart = pos;
|
|
const { length: length3 } = scanIdentifierParts();
|
|
if (length3 === 1 && text[identifierStart] === "n") {
|
|
if (isScientific) {
|
|
error(Diagnostics.A_bigint_literal_cannot_use_exponential_notation, numericStart, identifierStart - numericStart + 1);
|
|
} else {
|
|
error(Diagnostics.A_bigint_literal_must_be_an_integer, numericStart, identifierStart - numericStart + 1);
|
|
}
|
|
} else {
|
|
error(Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, identifierStart, length3);
|
|
pos = identifierStart;
|
|
}
|
|
}
|
|
function scanOctalDigits() {
|
|
const start3 = pos;
|
|
while (isOctalDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return +text.substring(start3, pos);
|
|
}
|
|
function scanExactNumberOfHexDigits(count, canHaveSeparators) {
|
|
const valueString = scanHexDigits(count, false, canHaveSeparators);
|
|
return valueString ? parseInt(valueString, 16) : -1;
|
|
}
|
|
function scanMinimumNumberOfHexDigits(count, canHaveSeparators) {
|
|
return scanHexDigits(count, true, canHaveSeparators);
|
|
}
|
|
function scanHexDigits(minCount, scanAsManyAsPossible, canHaveSeparators) {
|
|
let valueChars = [];
|
|
let allowSeparator = false;
|
|
let isPreviousTokenSeparator = false;
|
|
while (valueChars.length < minCount || scanAsManyAsPossible) {
|
|
let ch = text.charCodeAt(pos);
|
|
if (canHaveSeparators && ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (allowSeparator) {
|
|
allowSeparator = false;
|
|
isPreviousTokenSeparator = true;
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
continue;
|
|
}
|
|
allowSeparator = canHaveSeparators;
|
|
if (ch >= 65 /* A */ && ch <= 70 /* F */) {
|
|
ch += 97 /* a */ - 65 /* A */;
|
|
} else if (!(ch >= 48 /* _0 */ && ch <= 57 /* _9 */ || ch >= 97 /* a */ && ch <= 102 /* f */)) {
|
|
break;
|
|
}
|
|
valueChars.push(ch);
|
|
pos++;
|
|
isPreviousTokenSeparator = false;
|
|
}
|
|
if (valueChars.length < minCount) {
|
|
valueChars = [];
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return String.fromCharCode(...valueChars);
|
|
}
|
|
function scanString(jsxAttributeString = false) {
|
|
const quote2 = text.charCodeAt(pos);
|
|
pos++;
|
|
let result = "";
|
|
let start3 = pos;
|
|
while (true) {
|
|
if (pos >= end) {
|
|
result += text.substring(start3, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_string_literal);
|
|
break;
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === quote2) {
|
|
result += text.substring(start3, pos);
|
|
pos++;
|
|
break;
|
|
}
|
|
if (ch === 92 /* backslash */ && !jsxAttributeString) {
|
|
result += text.substring(start3, pos);
|
|
result += scanEscapeSequence();
|
|
start3 = pos;
|
|
continue;
|
|
}
|
|
if (isLineBreak(ch) && !jsxAttributeString) {
|
|
result += text.substring(start3, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_string_literal);
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
return result;
|
|
}
|
|
function scanTemplateAndSetTokenValue(isTaggedTemplate) {
|
|
const startedWithBacktick = text.charCodeAt(pos) === 96 /* backtick */;
|
|
pos++;
|
|
let start3 = pos;
|
|
let contents = "";
|
|
let resultingToken;
|
|
while (true) {
|
|
if (pos >= end) {
|
|
contents += text.substring(start3, pos);
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_template_literal);
|
|
resultingToken = startedWithBacktick ? 14 /* NoSubstitutionTemplateLiteral */ : 17 /* TemplateTail */;
|
|
break;
|
|
}
|
|
const currChar = text.charCodeAt(pos);
|
|
if (currChar === 96 /* backtick */) {
|
|
contents += text.substring(start3, pos);
|
|
pos++;
|
|
resultingToken = startedWithBacktick ? 14 /* NoSubstitutionTemplateLiteral */ : 17 /* TemplateTail */;
|
|
break;
|
|
}
|
|
if (currChar === 36 /* $ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* openBrace */) {
|
|
contents += text.substring(start3, pos);
|
|
pos += 2;
|
|
resultingToken = startedWithBacktick ? 15 /* TemplateHead */ : 16 /* TemplateMiddle */;
|
|
break;
|
|
}
|
|
if (currChar === 92 /* backslash */) {
|
|
contents += text.substring(start3, pos);
|
|
contents += scanEscapeSequence(isTaggedTemplate);
|
|
start3 = pos;
|
|
continue;
|
|
}
|
|
if (currChar === 13 /* carriageReturn */) {
|
|
contents += text.substring(start3, pos);
|
|
pos++;
|
|
if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
contents += "\n";
|
|
start3 = pos;
|
|
continue;
|
|
}
|
|
pos++;
|
|
}
|
|
Debug.assert(resultingToken !== void 0);
|
|
tokenValue = contents;
|
|
return resultingToken;
|
|
}
|
|
function scanEscapeSequence(isTaggedTemplate) {
|
|
const start3 = pos;
|
|
pos++;
|
|
if (pos >= end) {
|
|
error(Diagnostics.Unexpected_end_of_text);
|
|
return "";
|
|
}
|
|
const ch = text.charCodeAt(pos);
|
|
pos++;
|
|
switch (ch) {
|
|
case 48 /* _0 */:
|
|
if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) {
|
|
pos++;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
}
|
|
return "\0";
|
|
case 98 /* b */:
|
|
return "\b";
|
|
case 116 /* t */:
|
|
return " ";
|
|
case 110 /* n */:
|
|
return "\n";
|
|
case 118 /* v */:
|
|
return "\v";
|
|
case 102 /* f */:
|
|
return "\f";
|
|
case 114 /* r */:
|
|
return "\r";
|
|
case 39 /* singleQuote */:
|
|
return "'";
|
|
case 34 /* doubleQuote */:
|
|
return '"';
|
|
case 117 /* u */:
|
|
if (isTaggedTemplate) {
|
|
for (let escapePos = pos; escapePos < pos + 4; escapePos++) {
|
|
if (escapePos < end && !isHexDigit(text.charCodeAt(escapePos)) && text.charCodeAt(escapePos) !== 123 /* openBrace */) {
|
|
pos = escapePos;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
}
|
|
}
|
|
}
|
|
if (pos < end && text.charCodeAt(pos) === 123 /* openBrace */) {
|
|
pos++;
|
|
if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
}
|
|
if (isTaggedTemplate) {
|
|
const savePos = pos;
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== 125 /* closeBrace */) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
} else {
|
|
pos = savePos;
|
|
}
|
|
}
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
return scanExtendedUnicodeEscape();
|
|
}
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
return scanHexadecimalEscape(4);
|
|
case 120 /* x */:
|
|
if (isTaggedTemplate) {
|
|
if (!isHexDigit(text.charCodeAt(pos))) {
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
} else if (!isHexDigit(text.charCodeAt(pos + 1))) {
|
|
pos++;
|
|
tokenFlags |= 2048 /* ContainsInvalidEscape */;
|
|
return text.substring(start3, pos);
|
|
}
|
|
}
|
|
return scanHexadecimalEscape(2);
|
|
case 13 /* carriageReturn */:
|
|
if (pos < end && text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
case 8232 /* lineSeparator */:
|
|
case 8233 /* paragraphSeparator */:
|
|
return "";
|
|
default:
|
|
return String.fromCharCode(ch);
|
|
}
|
|
}
|
|
function scanHexadecimalEscape(numDigits) {
|
|
const escapedValue = scanExactNumberOfHexDigits(numDigits, false);
|
|
if (escapedValue >= 0) {
|
|
return String.fromCharCode(escapedValue);
|
|
} else {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
return "";
|
|
}
|
|
}
|
|
function scanExtendedUnicodeEscape() {
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
let isInvalidExtendedEscape = false;
|
|
if (escapedValue < 0) {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
isInvalidExtendedEscape = true;
|
|
} else if (escapedValue > 1114111) {
|
|
error(Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive);
|
|
isInvalidExtendedEscape = true;
|
|
}
|
|
if (pos >= end) {
|
|
error(Diagnostics.Unexpected_end_of_text);
|
|
isInvalidExtendedEscape = true;
|
|
} else if (text.charCodeAt(pos) === 125 /* closeBrace */) {
|
|
pos++;
|
|
} else {
|
|
error(Diagnostics.Unterminated_Unicode_escape_sequence);
|
|
isInvalidExtendedEscape = true;
|
|
}
|
|
if (isInvalidExtendedEscape) {
|
|
return "";
|
|
}
|
|
return utf16EncodeAsString(escapedValue);
|
|
}
|
|
function peekUnicodeEscape() {
|
|
if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* u */) {
|
|
const start3 = pos;
|
|
pos += 2;
|
|
const value = scanExactNumberOfHexDigits(4, false);
|
|
pos = start3;
|
|
return value;
|
|
}
|
|
return -1;
|
|
}
|
|
function peekExtendedUnicodeEscape() {
|
|
if (codePointAt(text, pos + 1) === 117 /* u */ && codePointAt(text, pos + 2) === 123 /* openBrace */) {
|
|
const start3 = pos;
|
|
pos += 3;
|
|
const escapedValueString = scanMinimumNumberOfHexDigits(1, false);
|
|
const escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1;
|
|
pos = start3;
|
|
return escapedValue;
|
|
}
|
|
return -1;
|
|
}
|
|
function scanIdentifierParts() {
|
|
let result = "";
|
|
let start3 = pos;
|
|
while (pos < end) {
|
|
let ch = codePointAt(text, pos);
|
|
if (isIdentifierPart(ch, languageVersion)) {
|
|
pos += charSize(ch);
|
|
} else if (ch === 92 /* backslash */) {
|
|
ch = peekExtendedUnicodeEscape();
|
|
if (ch >= 0 && isIdentifierPart(ch, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
result += scanExtendedUnicodeEscape();
|
|
start3 = pos;
|
|
continue;
|
|
}
|
|
ch = peekUnicodeEscape();
|
|
if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) {
|
|
break;
|
|
}
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
result += text.substring(start3, pos);
|
|
result += utf16EncodeAsString(ch);
|
|
pos += 6;
|
|
start3 = pos;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
result += text.substring(start3, pos);
|
|
return result;
|
|
}
|
|
function getIdentifierToken() {
|
|
const len = tokenValue.length;
|
|
if (len >= 2 && len <= 12) {
|
|
const ch = tokenValue.charCodeAt(0);
|
|
if (ch >= 97 /* a */ && ch <= 122 /* z */) {
|
|
const keyword = textToKeyword.get(tokenValue);
|
|
if (keyword !== void 0) {
|
|
return token = keyword;
|
|
}
|
|
}
|
|
}
|
|
return token = 79 /* Identifier */;
|
|
}
|
|
function scanBinaryOrOctalDigits(base) {
|
|
let value = "";
|
|
let separatorAllowed = false;
|
|
let isPreviousTokenSeparator = false;
|
|
while (true) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 95 /* _ */) {
|
|
tokenFlags |= 512 /* ContainsSeparator */;
|
|
if (separatorAllowed) {
|
|
separatorAllowed = false;
|
|
isPreviousTokenSeparator = true;
|
|
} else if (isPreviousTokenSeparator) {
|
|
error(Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1);
|
|
} else {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1);
|
|
}
|
|
pos++;
|
|
continue;
|
|
}
|
|
separatorAllowed = true;
|
|
if (!isDigit(ch) || ch - 48 /* _0 */ >= base) {
|
|
break;
|
|
}
|
|
value += text[pos];
|
|
pos++;
|
|
isPreviousTokenSeparator = false;
|
|
}
|
|
if (text.charCodeAt(pos - 1) === 95 /* _ */) {
|
|
error(Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1);
|
|
}
|
|
return value;
|
|
}
|
|
function checkBigIntSuffix() {
|
|
if (text.charCodeAt(pos) === 110 /* n */) {
|
|
tokenValue += "n";
|
|
if (tokenFlags & 384 /* BinaryOrOctalSpecifier */) {
|
|
tokenValue = parsePseudoBigInt(tokenValue) + "n";
|
|
}
|
|
pos++;
|
|
return 9 /* BigIntLiteral */;
|
|
} else {
|
|
const numericValue = tokenFlags & 128 /* BinarySpecifier */ ? parseInt(tokenValue.slice(2), 2) : tokenFlags & 256 /* OctalSpecifier */ ? parseInt(tokenValue.slice(2), 8) : +tokenValue;
|
|
tokenValue = "" + numericValue;
|
|
return 8 /* NumericLiteral */;
|
|
}
|
|
}
|
|
function scan() {
|
|
startPos = pos;
|
|
tokenFlags = 0 /* None */;
|
|
let asteriskSeen = false;
|
|
while (true) {
|
|
tokenPos = pos;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
const ch = codePointAt(text, pos);
|
|
if (ch === 35 /* hash */ && pos === 0 && isShebangTrivia(text, pos)) {
|
|
pos = scanShebangTrivia(text, pos);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 6 /* ShebangTrivia */;
|
|
}
|
|
}
|
|
switch (ch) {
|
|
case 10 /* lineFeed */:
|
|
case 13 /* carriageReturn */:
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
if (skipTrivia2) {
|
|
pos++;
|
|
continue;
|
|
} else {
|
|
if (ch === 13 /* carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
|
|
pos += 2;
|
|
} else {
|
|
pos++;
|
|
}
|
|
return token = 4 /* NewLineTrivia */;
|
|
}
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
case 160 /* nonBreakingSpace */:
|
|
case 5760 /* ogham */:
|
|
case 8192 /* enQuad */:
|
|
case 8193 /* emQuad */:
|
|
case 8194 /* enSpace */:
|
|
case 8195 /* emSpace */:
|
|
case 8196 /* threePerEmSpace */:
|
|
case 8197 /* fourPerEmSpace */:
|
|
case 8198 /* sixPerEmSpace */:
|
|
case 8199 /* figureSpace */:
|
|
case 8200 /* punctuationSpace */:
|
|
case 8201 /* thinSpace */:
|
|
case 8202 /* hairSpace */:
|
|
case 8203 /* zeroWidthSpace */:
|
|
case 8239 /* narrowNoBreakSpace */:
|
|
case 8287 /* mathematicalSpace */:
|
|
case 12288 /* ideographicSpace */:
|
|
case 65279 /* byteOrderMark */:
|
|
if (skipTrivia2) {
|
|
pos++;
|
|
continue;
|
|
} else {
|
|
while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return token = 5 /* WhitespaceTrivia */;
|
|
}
|
|
case 33 /* exclamation */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 37 /* ExclamationEqualsEqualsToken */;
|
|
}
|
|
return pos += 2, token = 35 /* ExclamationEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 53 /* ExclamationToken */;
|
|
case 34 /* doubleQuote */:
|
|
case 39 /* singleQuote */:
|
|
tokenValue = scanString();
|
|
return token = 10 /* StringLiteral */;
|
|
case 96 /* backtick */:
|
|
return token = scanTemplateAndSetTokenValue(false);
|
|
case 37 /* percent */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 69 /* PercentEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 44 /* PercentToken */;
|
|
case 38 /* ampersand */:
|
|
if (text.charCodeAt(pos + 1) === 38 /* ampersand */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 76 /* AmpersandAmpersandEqualsToken */;
|
|
}
|
|
return pos += 2, token = 55 /* AmpersandAmpersandToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 73 /* AmpersandEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 50 /* AmpersandToken */;
|
|
case 40 /* openParen */:
|
|
pos++;
|
|
return token = 20 /* OpenParenToken */;
|
|
case 41 /* closeParen */:
|
|
pos++;
|
|
return token = 21 /* CloseParenToken */;
|
|
case 42 /* asterisk */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 66 /* AsteriskEqualsToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 67 /* AsteriskAsteriskEqualsToken */;
|
|
}
|
|
return pos += 2, token = 42 /* AsteriskAsteriskToken */;
|
|
}
|
|
pos++;
|
|
if (inJSDocType && !asteriskSeen && tokenFlags & 1 /* PrecedingLineBreak */) {
|
|
asteriskSeen = true;
|
|
continue;
|
|
}
|
|
return token = 41 /* AsteriskToken */;
|
|
case 43 /* plus */:
|
|
if (text.charCodeAt(pos + 1) === 43 /* plus */) {
|
|
return pos += 2, token = 45 /* PlusPlusToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 64 /* PlusEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 39 /* PlusToken */;
|
|
case 44 /* comma */:
|
|
pos++;
|
|
return token = 27 /* CommaToken */;
|
|
case 45 /* minus */:
|
|
if (text.charCodeAt(pos + 1) === 45 /* minus */) {
|
|
return pos += 2, token = 46 /* MinusMinusToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 65 /* MinusEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 40 /* MinusToken */;
|
|
case 46 /* dot */:
|
|
if (isDigit(text.charCodeAt(pos + 1))) {
|
|
tokenValue = scanNumber().value;
|
|
return token = 8 /* NumericLiteral */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 46 /* dot */ && text.charCodeAt(pos + 2) === 46 /* dot */) {
|
|
return pos += 3, token = 25 /* DotDotDotToken */;
|
|
}
|
|
pos++;
|
|
return token = 24 /* DotToken */;
|
|
case 47 /* slash */:
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
while (pos < end) {
|
|
if (isLineBreak(text.charCodeAt(pos))) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
commentDirectives = appendIfCommentDirective(
|
|
commentDirectives,
|
|
text.slice(tokenPos, pos),
|
|
commentDirectiveRegExSingleLine,
|
|
tokenPos
|
|
);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 2 /* SingleLineCommentTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {
|
|
pos += 2;
|
|
if (text.charCodeAt(pos) === 42 /* asterisk */ && text.charCodeAt(pos + 1) !== 47 /* slash */) {
|
|
tokenFlags |= 2 /* PrecedingJSDocComment */;
|
|
}
|
|
let commentClosed = false;
|
|
let lastLineStart = tokenPos;
|
|
while (pos < end) {
|
|
const ch2 = text.charCodeAt(pos);
|
|
if (ch2 === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
commentClosed = true;
|
|
break;
|
|
}
|
|
pos++;
|
|
if (isLineBreak(ch2)) {
|
|
lastLineStart = pos;
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
}
|
|
}
|
|
commentDirectives = appendIfCommentDirective(commentDirectives, text.slice(lastLineStart, pos), commentDirectiveRegExMultiLine, lastLineStart);
|
|
if (!commentClosed) {
|
|
error(Diagnostics.Asterisk_Slash_expected);
|
|
}
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
if (!commentClosed) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
}
|
|
return token = 3 /* MultiLineCommentTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 68 /* SlashEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 43 /* SlashToken */;
|
|
case 48 /* _0 */:
|
|
if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* X */ || text.charCodeAt(pos + 1) === 120 /* x */)) {
|
|
pos += 2;
|
|
tokenValue = scanMinimumNumberOfHexDigits(1, true);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Hexadecimal_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0x" + tokenValue;
|
|
tokenFlags |= 64 /* HexSpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
} else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* B */ || text.charCodeAt(pos + 1) === 98 /* b */)) {
|
|
pos += 2;
|
|
tokenValue = scanBinaryOrOctalDigits(2);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Binary_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0b" + tokenValue;
|
|
tokenFlags |= 128 /* BinarySpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
} else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* O */ || text.charCodeAt(pos + 1) === 111 /* o */)) {
|
|
pos += 2;
|
|
tokenValue = scanBinaryOrOctalDigits(8);
|
|
if (!tokenValue) {
|
|
error(Diagnostics.Octal_digit_expected);
|
|
tokenValue = "0";
|
|
}
|
|
tokenValue = "0o" + tokenValue;
|
|
tokenFlags |= 256 /* OctalSpecifier */;
|
|
return token = checkBigIntSuffix();
|
|
}
|
|
if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) {
|
|
tokenValue = "" + scanOctalDigits();
|
|
tokenFlags |= 32 /* Octal */;
|
|
return token = 8 /* NumericLiteral */;
|
|
}
|
|
case 49 /* _1 */:
|
|
case 50 /* _2 */:
|
|
case 51 /* _3 */:
|
|
case 52 /* _4 */:
|
|
case 53 /* _5 */:
|
|
case 54 /* _6 */:
|
|
case 55 /* _7 */:
|
|
case 56 /* _8 */:
|
|
case 57 /* _9 */:
|
|
({ type: token, value: tokenValue } = scanNumber());
|
|
return token;
|
|
case 58 /* colon */:
|
|
pos++;
|
|
return token = 58 /* ColonToken */;
|
|
case 59 /* semicolon */:
|
|
pos++;
|
|
return token = 26 /* SemicolonToken */;
|
|
case 60 /* lessThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 60 /* lessThan */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 70 /* LessThanLessThanEqualsToken */;
|
|
}
|
|
return pos += 2, token = 47 /* LessThanLessThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 32 /* LessThanEqualsToken */;
|
|
}
|
|
if (languageVariant === 1 /* JSX */ && text.charCodeAt(pos + 1) === 47 /* slash */ && text.charCodeAt(pos + 2) !== 42 /* asterisk */) {
|
|
return pos += 2, token = 30 /* LessThanSlashToken */;
|
|
}
|
|
pos++;
|
|
return token = 29 /* LessThanToken */;
|
|
case 61 /* equals */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 36 /* EqualsEqualsEqualsToken */;
|
|
}
|
|
return pos += 2, token = 34 /* EqualsEqualsToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
|
|
return pos += 2, token = 38 /* EqualsGreaterThanToken */;
|
|
}
|
|
pos++;
|
|
return token = 63 /* EqualsToken */;
|
|
case 62 /* greaterThan */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
pos++;
|
|
return token = 31 /* GreaterThanToken */;
|
|
case 63 /* question */:
|
|
if (text.charCodeAt(pos + 1) === 46 /* dot */ && !isDigit(text.charCodeAt(pos + 2))) {
|
|
return pos += 2, token = 28 /* QuestionDotToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 63 /* question */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 77 /* QuestionQuestionEqualsToken */;
|
|
}
|
|
return pos += 2, token = 60 /* QuestionQuestionToken */;
|
|
}
|
|
pos++;
|
|
return token = 57 /* QuestionToken */;
|
|
case 91 /* openBracket */:
|
|
pos++;
|
|
return token = 22 /* OpenBracketToken */;
|
|
case 93 /* closeBracket */:
|
|
pos++;
|
|
return token = 23 /* CloseBracketToken */;
|
|
case 94 /* caret */:
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 78 /* CaretEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 52 /* CaretToken */;
|
|
case 123 /* openBrace */:
|
|
pos++;
|
|
return token = 18 /* OpenBraceToken */;
|
|
case 124 /* bar */:
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
if (skipTrivia2) {
|
|
continue;
|
|
} else {
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 124 /* bar */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 75 /* BarBarEqualsToken */;
|
|
}
|
|
return pos += 2, token = 56 /* BarBarToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 74 /* BarEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 51 /* BarToken */;
|
|
case 125 /* closeBrace */:
|
|
pos++;
|
|
return token = 19 /* CloseBraceToken */;
|
|
case 126 /* tilde */:
|
|
pos++;
|
|
return token = 54 /* TildeToken */;
|
|
case 64 /* at */:
|
|
pos++;
|
|
return token = 59 /* AtToken */;
|
|
case 92 /* backslash */:
|
|
const extendedCookedChar = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
const cookedChar = peekUnicodeEscape();
|
|
if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
error(Diagnostics.Invalid_character);
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
case 35 /* hash */:
|
|
if (pos !== 0 && text[pos + 1] === "!") {
|
|
error(Diagnostics.can_only_be_used_at_the_start_of_a_file);
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
const charAfterHash = codePointAt(text, pos + 1);
|
|
if (charAfterHash === 92 /* backslash */) {
|
|
pos++;
|
|
const extendedCookedChar2 = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar2 >= 0 && isIdentifierStart(extendedCookedChar2, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = 80 /* PrivateIdentifier */;
|
|
}
|
|
const cookedChar2 = peekUnicodeEscape();
|
|
if (cookedChar2 >= 0 && isIdentifierStart(cookedChar2, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = "#" + String.fromCharCode(cookedChar2) + scanIdentifierParts();
|
|
return token = 80 /* PrivateIdentifier */;
|
|
}
|
|
pos--;
|
|
}
|
|
if (isIdentifierStart(charAfterHash, languageVersion)) {
|
|
pos++;
|
|
scanIdentifier(charAfterHash, languageVersion);
|
|
} else {
|
|
tokenValue = "#";
|
|
error(Diagnostics.Invalid_character, pos++, charSize(ch));
|
|
}
|
|
return token = 80 /* PrivateIdentifier */;
|
|
default:
|
|
const identifierKind = scanIdentifier(ch, languageVersion);
|
|
if (identifierKind) {
|
|
return token = identifierKind;
|
|
} else if (isWhiteSpaceSingleLine(ch)) {
|
|
pos += charSize(ch);
|
|
continue;
|
|
} else if (isLineBreak(ch)) {
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
pos += charSize(ch);
|
|
continue;
|
|
}
|
|
const size = charSize(ch);
|
|
error(Diagnostics.Invalid_character, pos, size);
|
|
pos += size;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
}
|
|
}
|
|
function reScanInvalidIdentifier() {
|
|
Debug.assert(token === 0 /* Unknown */, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'.");
|
|
pos = tokenPos = startPos;
|
|
tokenFlags = 0;
|
|
const ch = codePointAt(text, pos);
|
|
const identifierKind = scanIdentifier(ch, 99 /* ESNext */);
|
|
if (identifierKind) {
|
|
return token = identifierKind;
|
|
}
|
|
pos += charSize(ch);
|
|
return token;
|
|
}
|
|
function scanIdentifier(startCharacter, languageVersion2) {
|
|
let ch = startCharacter;
|
|
if (isIdentifierStart(ch, languageVersion2)) {
|
|
pos += charSize(ch);
|
|
while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion2))
|
|
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 */) {
|
|
if (text.charCodeAt(pos + 1) === 62 /* greaterThan */) {
|
|
if (text.charCodeAt(pos + 2) === 61 /* equals */) {
|
|
return pos += 3, token = 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */;
|
|
}
|
|
return pos += 2, token = 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos + 1) === 61 /* equals */) {
|
|
return pos += 2, token = 71 /* GreaterThanGreaterThanEqualsToken */;
|
|
}
|
|
pos++;
|
|
return token = 48 /* GreaterThanGreaterThanToken */;
|
|
}
|
|
if (text.charCodeAt(pos) === 61 /* equals */) {
|
|
pos++;
|
|
return token = 33 /* GreaterThanEqualsToken */;
|
|
}
|
|
}
|
|
return token;
|
|
}
|
|
function reScanAsteriskEqualsToken() {
|
|
Debug.assert(token === 66 /* AsteriskEqualsToken */, "'reScanAsteriskEqualsToken' should only be called on a '*='");
|
|
pos = tokenPos + 1;
|
|
return token = 63 /* EqualsToken */;
|
|
}
|
|
function reScanSlashToken() {
|
|
if (token === 43 /* SlashToken */ || token === 68 /* SlashEqualsToken */) {
|
|
let p = tokenPos + 1;
|
|
let inEscape = false;
|
|
let inCharacterClass = false;
|
|
while (true) {
|
|
if (p >= end) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_regular_expression_literal);
|
|
break;
|
|
}
|
|
const ch = text.charCodeAt(p);
|
|
if (isLineBreak(ch)) {
|
|
tokenFlags |= 4 /* Unterminated */;
|
|
error(Diagnostics.Unterminated_regular_expression_literal);
|
|
break;
|
|
}
|
|
if (inEscape) {
|
|
inEscape = false;
|
|
} else if (ch === 47 /* slash */ && !inCharacterClass) {
|
|
p++;
|
|
break;
|
|
} else if (ch === 91 /* openBracket */) {
|
|
inCharacterClass = true;
|
|
} else if (ch === 92 /* backslash */) {
|
|
inEscape = true;
|
|
} else if (ch === 93 /* closeBracket */) {
|
|
inCharacterClass = false;
|
|
}
|
|
p++;
|
|
}
|
|
while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) {
|
|
p++;
|
|
}
|
|
pos = p;
|
|
tokenValue = text.substring(tokenPos, pos);
|
|
token = 13 /* RegularExpressionLiteral */;
|
|
}
|
|
return token;
|
|
}
|
|
function appendIfCommentDirective(commentDirectives2, text2, commentDirectiveRegEx, lineStart) {
|
|
const type = getDirectiveFromComment(trimStringStart(text2), commentDirectiveRegEx);
|
|
if (type === void 0) {
|
|
return commentDirectives2;
|
|
}
|
|
return append(
|
|
commentDirectives2,
|
|
{
|
|
range: { pos: lineStart, end: pos },
|
|
type
|
|
}
|
|
);
|
|
}
|
|
function getDirectiveFromComment(text2, commentDirectiveRegEx) {
|
|
const match = commentDirectiveRegEx.exec(text2);
|
|
if (!match) {
|
|
return void 0;
|
|
}
|
|
switch (match[1]) {
|
|
case "ts-expect-error":
|
|
return 0 /* ExpectError */;
|
|
case "ts-ignore":
|
|
return 1 /* Ignore */;
|
|
}
|
|
return void 0;
|
|
}
|
|
function reScanTemplateToken(isTaggedTemplate) {
|
|
Debug.assert(token === 19 /* CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'");
|
|
pos = tokenPos;
|
|
return token = scanTemplateAndSetTokenValue(isTaggedTemplate);
|
|
}
|
|
function reScanTemplateHeadOrNoSubstitutionTemplate() {
|
|
pos = tokenPos;
|
|
return token = scanTemplateAndSetTokenValue(true);
|
|
}
|
|
function reScanJsxToken(allowMultilineJsxText = true) {
|
|
pos = tokenPos = startPos;
|
|
return token = scanJsxToken(allowMultilineJsxText);
|
|
}
|
|
function reScanLessThanToken() {
|
|
if (token === 47 /* LessThanLessThanToken */) {
|
|
pos = tokenPos + 1;
|
|
return token = 29 /* LessThanToken */;
|
|
}
|
|
return token;
|
|
}
|
|
function reScanHashToken() {
|
|
if (token === 80 /* PrivateIdentifier */) {
|
|
pos = tokenPos + 1;
|
|
return token = 62 /* HashToken */;
|
|
}
|
|
return token;
|
|
}
|
|
function reScanQuestionToken() {
|
|
Debug.assert(token === 60 /* QuestionQuestionToken */, "'reScanQuestionToken' should only be called on a '??'");
|
|
pos = tokenPos + 1;
|
|
return token = 57 /* QuestionToken */;
|
|
}
|
|
function scanJsxToken(allowMultilineJsxText = true) {
|
|
startPos = tokenPos = pos;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
let char = text.charCodeAt(pos);
|
|
if (char === 60 /* lessThan */) {
|
|
if (text.charCodeAt(pos + 1) === 47 /* slash */) {
|
|
pos += 2;
|
|
return token = 30 /* LessThanSlashToken */;
|
|
}
|
|
pos++;
|
|
return token = 29 /* LessThanToken */;
|
|
}
|
|
if (char === 123 /* openBrace */) {
|
|
pos++;
|
|
return token = 18 /* OpenBraceToken */;
|
|
}
|
|
let firstNonWhitespace = 0;
|
|
while (pos < end) {
|
|
char = text.charCodeAt(pos);
|
|
if (char === 123 /* openBrace */) {
|
|
break;
|
|
}
|
|
if (char === 60 /* lessThan */) {
|
|
if (isConflictMarkerTrivia(text, pos)) {
|
|
pos = scanConflictMarkerTrivia(text, pos, error);
|
|
return token = 7 /* ConflictMarkerTrivia */;
|
|
}
|
|
break;
|
|
}
|
|
if (char === 62 /* greaterThan */) {
|
|
error(Diagnostics.Unexpected_token_Did_you_mean_or_gt, pos, 1);
|
|
}
|
|
if (char === 125 /* closeBrace */) {
|
|
error(Diagnostics.Unexpected_token_Did_you_mean_or_rbrace, pos, 1);
|
|
}
|
|
if (isLineBreak(char) && firstNonWhitespace === 0) {
|
|
firstNonWhitespace = -1;
|
|
} else if (!allowMultilineJsxText && isLineBreak(char) && firstNonWhitespace > 0) {
|
|
break;
|
|
} else if (!isWhiteSpaceLike(char)) {
|
|
firstNonWhitespace = pos;
|
|
}
|
|
pos++;
|
|
}
|
|
tokenValue = text.substring(startPos, pos);
|
|
return firstNonWhitespace === -1 ? 12 /* JsxTextAllWhiteSpaces */ : 11 /* JsxText */;
|
|
}
|
|
function scanJsxIdentifier() {
|
|
if (tokenIsIdentifierOrKeyword(token)) {
|
|
let namespaceSeparator = false;
|
|
while (pos < end) {
|
|
const ch = text.charCodeAt(pos);
|
|
if (ch === 45 /* minus */) {
|
|
tokenValue += "-";
|
|
pos++;
|
|
continue;
|
|
} else if (ch === 58 /* colon */ && !namespaceSeparator) {
|
|
tokenValue += ":";
|
|
pos++;
|
|
namespaceSeparator = true;
|
|
token = 79 /* Identifier */;
|
|
continue;
|
|
}
|
|
const oldPos = pos;
|
|
tokenValue += scanIdentifierParts();
|
|
if (pos === oldPos) {
|
|
break;
|
|
}
|
|
}
|
|
if (tokenValue.slice(-1) === ":") {
|
|
tokenValue = tokenValue.slice(0, -1);
|
|
pos--;
|
|
}
|
|
return getIdentifierToken();
|
|
}
|
|
return token;
|
|
}
|
|
function scanJsxAttributeValue() {
|
|
startPos = pos;
|
|
switch (text.charCodeAt(pos)) {
|
|
case 34 /* doubleQuote */:
|
|
case 39 /* singleQuote */:
|
|
tokenValue = scanString(true);
|
|
return token = 10 /* StringLiteral */;
|
|
default:
|
|
return scan();
|
|
}
|
|
}
|
|
function reScanJsxAttributeValue() {
|
|
pos = tokenPos = startPos;
|
|
return scanJsxAttributeValue();
|
|
}
|
|
function scanJsDocToken() {
|
|
startPos = tokenPos = pos;
|
|
tokenFlags = 0 /* None */;
|
|
if (pos >= end) {
|
|
return token = 1 /* EndOfFileToken */;
|
|
}
|
|
const ch = codePointAt(text, pos);
|
|
pos += charSize(ch);
|
|
switch (ch) {
|
|
case 9 /* tab */:
|
|
case 11 /* verticalTab */:
|
|
case 12 /* formFeed */:
|
|
case 32 /* space */:
|
|
while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) {
|
|
pos++;
|
|
}
|
|
return token = 5 /* WhitespaceTrivia */;
|
|
case 64 /* at */:
|
|
return token = 59 /* AtToken */;
|
|
case 13 /* carriageReturn */:
|
|
if (text.charCodeAt(pos) === 10 /* lineFeed */) {
|
|
pos++;
|
|
}
|
|
case 10 /* lineFeed */:
|
|
tokenFlags |= 1 /* PrecedingLineBreak */;
|
|
return token = 4 /* NewLineTrivia */;
|
|
case 42 /* asterisk */:
|
|
return token = 41 /* AsteriskToken */;
|
|
case 123 /* openBrace */:
|
|
return token = 18 /* OpenBraceToken */;
|
|
case 125 /* closeBrace */:
|
|
return token = 19 /* CloseBraceToken */;
|
|
case 91 /* openBracket */:
|
|
return token = 22 /* OpenBracketToken */;
|
|
case 93 /* closeBracket */:
|
|
return token = 23 /* CloseBracketToken */;
|
|
case 60 /* lessThan */:
|
|
return token = 29 /* LessThanToken */;
|
|
case 62 /* greaterThan */:
|
|
return token = 31 /* GreaterThanToken */;
|
|
case 61 /* equals */:
|
|
return token = 63 /* EqualsToken */;
|
|
case 44 /* comma */:
|
|
return token = 27 /* CommaToken */;
|
|
case 46 /* dot */:
|
|
return token = 24 /* DotToken */;
|
|
case 96 /* backtick */:
|
|
return token = 61 /* BacktickToken */;
|
|
case 35 /* hash */:
|
|
return token = 62 /* HashToken */;
|
|
case 92 /* backslash */:
|
|
pos--;
|
|
const extendedCookedChar = peekExtendedUnicodeEscape();
|
|
if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) {
|
|
pos += 3;
|
|
tokenFlags |= 8 /* ExtendedUnicodeEscape */;
|
|
tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
const cookedChar = peekUnicodeEscape();
|
|
if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) {
|
|
pos += 6;
|
|
tokenFlags |= 1024 /* UnicodeEscape */;
|
|
tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts();
|
|
return token = getIdentifierToken();
|
|
}
|
|
pos++;
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
if (isIdentifierStart(ch, languageVersion)) {
|
|
let char = ch;
|
|
while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45 /* minus */)
|
|
pos += charSize(char);
|
|
tokenValue = text.substring(tokenPos, pos);
|
|
if (char === 92 /* backslash */) {
|
|
tokenValue += scanIdentifierParts();
|
|
}
|
|
return token = getIdentifierToken();
|
|
} else {
|
|
return token = 0 /* Unknown */;
|
|
}
|
|
}
|
|
function speculationHelper(callback, isLookahead) {
|
|
const savePos = pos;
|
|
const saveStartPos = startPos;
|
|
const saveTokenPos = tokenPos;
|
|
const saveToken = token;
|
|
const saveTokenValue = tokenValue;
|
|
const saveTokenFlags = tokenFlags;
|
|
const result = callback();
|
|
if (!result || isLookahead) {
|
|
pos = savePos;
|
|
startPos = saveStartPos;
|
|
tokenPos = saveTokenPos;
|
|
token = saveToken;
|
|
tokenValue = saveTokenValue;
|
|
tokenFlags = saveTokenFlags;
|
|
}
|
|
return result;
|
|
}
|
|
function scanRange(start3, length3, callback) {
|
|
const saveEnd = end;
|
|
const savePos = pos;
|
|
const saveStartPos = startPos;
|
|
const saveTokenPos = tokenPos;
|
|
const saveToken = token;
|
|
const saveTokenValue = tokenValue;
|
|
const saveTokenFlags = tokenFlags;
|
|
const saveErrorExpectations = commentDirectives;
|
|
setText(text, start3, length3);
|
|
const result = callback();
|
|
end = saveEnd;
|
|
pos = savePos;
|
|
startPos = saveStartPos;
|
|
tokenPos = saveTokenPos;
|
|
token = saveToken;
|
|
tokenValue = saveTokenValue;
|
|
tokenFlags = saveTokenFlags;
|
|
commentDirectives = saveErrorExpectations;
|
|
return result;
|
|
}
|
|
function lookAhead(callback) {
|
|
return speculationHelper(callback, true);
|
|
}
|
|
function tryScan(callback) {
|
|
return speculationHelper(callback, false);
|
|
}
|
|
function getText() {
|
|
return text;
|
|
}
|
|
function clearCommentDirectives() {
|
|
commentDirectives = void 0;
|
|
}
|
|
function setText(newText, start3, length3) {
|
|
text = newText || "";
|
|
end = length3 === void 0 ? text.length : start3 + length3;
|
|
setTextPos(start3 || 0);
|
|
}
|
|
function setOnError(errorCallback) {
|
|
onError = errorCallback;
|
|
}
|
|
function setScriptTarget(scriptTarget) {
|
|
languageVersion = scriptTarget;
|
|
}
|
|
function setLanguageVariant(variant) {
|
|
languageVariant = variant;
|
|
}
|
|
function setTextPos(textPos) {
|
|
Debug.assert(textPos >= 0);
|
|
pos = textPos;
|
|
startPos = textPos;
|
|
tokenPos = textPos;
|
|
token = 0 /* Unknown */;
|
|
tokenValue = void 0;
|
|
tokenFlags = 0 /* None */;
|
|
}
|
|
function setInJSDocType(inType) {
|
|
inJSDocType += inType ? 1 : -1;
|
|
}
|
|
}
|
|
var codePointAt = String.prototype.codePointAt ? (s, i) => s.codePointAt(i) : function codePointAt2(str, i) {
|
|
const size = str.length;
|
|
if (i < 0 || i >= size) {
|
|
return void 0;
|
|
}
|
|
const first2 = str.charCodeAt(i);
|
|
if (first2 >= 55296 && first2 <= 56319 && size > i + 1) {
|
|
const second = str.charCodeAt(i + 1);
|
|
if (second >= 56320 && second <= 57343) {
|
|
return (first2 - 55296) * 1024 + second - 56320 + 65536;
|
|
}
|
|
}
|
|
return first2;
|
|
};
|
|
function charSize(ch) {
|
|
if (ch >= 65536) {
|
|
return 2;
|
|
}
|
|
return 1;
|
|
}
|
|
function utf16EncodeAsStringFallback(codePoint) {
|
|
Debug.assert(0 <= codePoint && codePoint <= 1114111);
|
|
if (codePoint <= 65535) {
|
|
return String.fromCharCode(codePoint);
|
|
}
|
|
const codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 55296;
|
|
const codeUnit2 = (codePoint - 65536) % 1024 + 56320;
|
|
return String.fromCharCode(codeUnit1, codeUnit2);
|
|
}
|
|
var utf16EncodeAsStringWorker = String.fromCodePoint ? (codePoint) => String.fromCodePoint(codePoint) : utf16EncodeAsStringFallback;
|
|
function utf16EncodeAsString(codePoint) {
|
|
return utf16EncodeAsStringWorker(codePoint);
|
|
}
|
|
|
|
// src/compiler/utilitiesPublic.ts
|
|
function isExternalModuleNameRelative(moduleName) {
|
|
return pathIsRelative(moduleName) || isRootedDiskPath(moduleName);
|
|
}
|
|
function sortAndDeduplicateDiagnostics(diagnostics) {
|
|
return sortAndDeduplicate(diagnostics, compareDiagnostics);
|
|
}
|
|
function getDefaultLibFileName(options) {
|
|
switch (getEmitScriptTarget(options)) {
|
|
case 99 /* ESNext */:
|
|
return "lib.esnext.full.d.ts";
|
|
case 9 /* ES2022 */:
|
|
return "lib.es2022.full.d.ts";
|
|
case 8 /* ES2021 */:
|
|
return "lib.es2021.full.d.ts";
|
|
case 7 /* ES2020 */:
|
|
return "lib.es2020.full.d.ts";
|
|
case 6 /* ES2019 */:
|
|
return "lib.es2019.full.d.ts";
|
|
case 5 /* ES2018 */:
|
|
return "lib.es2018.full.d.ts";
|
|
case 4 /* ES2017 */:
|
|
return "lib.es2017.full.d.ts";
|
|
case 3 /* ES2016 */:
|
|
return "lib.es2016.full.d.ts";
|
|
case 2 /* ES2015 */:
|
|
return "lib.es6.d.ts";
|
|
default:
|
|
return "lib.d.ts";
|
|
}
|
|
}
|
|
function textSpanEnd(span) {
|
|
return span.start + span.length;
|
|
}
|
|
function textSpanIsEmpty(span) {
|
|
return span.length === 0;
|
|
}
|
|
function textSpanContainsPosition(span, position) {
|
|
return position >= span.start && position < textSpanEnd(span);
|
|
}
|
|
function textRangeContainsPositionInclusive(span, position) {
|
|
return position >= span.pos && position <= span.end;
|
|
}
|
|
function textSpanContainsTextSpan(span, other) {
|
|
return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span);
|
|
}
|
|
function textSpanOverlapsWith(span, other) {
|
|
return textSpanOverlap(span, other) !== void 0;
|
|
}
|
|
function textSpanOverlap(span1, span2) {
|
|
const overlap = textSpanIntersection(span1, span2);
|
|
return overlap && overlap.length === 0 ? void 0 : overlap;
|
|
}
|
|
function textSpanIntersectsWithTextSpan(span, other) {
|
|
return decodedTextSpanIntersectsWith(span.start, span.length, other.start, other.length);
|
|
}
|
|
function textSpanIntersectsWith(span, start2, length2) {
|
|
return decodedTextSpanIntersectsWith(span.start, span.length, start2, length2);
|
|
}
|
|
function decodedTextSpanIntersectsWith(start1, length1, start2, length2) {
|
|
const end1 = start1 + length1;
|
|
const end2 = start2 + length2;
|
|
return start2 <= end1 && end2 >= start1;
|
|
}
|
|
function textSpanIntersectsWithPosition(span, position) {
|
|
return position <= textSpanEnd(span) && position >= span.start;
|
|
}
|
|
function textSpanIntersection(span1, span2) {
|
|
const start2 = Math.max(span1.start, span2.start);
|
|
const end = Math.min(textSpanEnd(span1), textSpanEnd(span2));
|
|
return start2 <= end ? createTextSpanFromBounds(start2, end) : void 0;
|
|
}
|
|
function createTextSpan(start2, length2) {
|
|
if (start2 < 0) {
|
|
throw new Error("start < 0");
|
|
}
|
|
if (length2 < 0) {
|
|
throw new Error("length < 0");
|
|
}
|
|
return { start: start2, length: length2 };
|
|
}
|
|
function createTextSpanFromBounds(start2, end) {
|
|
return createTextSpan(start2, end - start2);
|
|
}
|
|
function textChangeRangeNewSpan(range) {
|
|
return createTextSpan(range.span.start, range.newLength);
|
|
}
|
|
function textChangeRangeIsUnchanged(range) {
|
|
return textSpanIsEmpty(range.span) && range.newLength === 0;
|
|
}
|
|
function createTextChangeRange(span, newLength) {
|
|
if (newLength < 0) {
|
|
throw new Error("newLength < 0");
|
|
}
|
|
return { span, newLength };
|
|
}
|
|
var unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0);
|
|
function collapseTextChangeRangesAcrossMultipleVersions(changes) {
|
|
if (changes.length === 0) {
|
|
return unchangedTextChangeRange;
|
|
}
|
|
if (changes.length === 1) {
|
|
return changes[0];
|
|
}
|
|
const change0 = changes[0];
|
|
let oldStartN = change0.span.start;
|
|
let oldEndN = textSpanEnd(change0.span);
|
|
let newEndN = oldStartN + change0.newLength;
|
|
for (let i = 1; i < changes.length; i++) {
|
|
const nextChange = changes[i];
|
|
const oldStart1 = oldStartN;
|
|
const oldEnd1 = oldEndN;
|
|
const newEnd1 = newEndN;
|
|
const oldStart2 = nextChange.span.start;
|
|
const oldEnd2 = textSpanEnd(nextChange.span);
|
|
const newEnd2 = oldStart2 + nextChange.newLength;
|
|
oldStartN = Math.min(oldStart1, oldStart2);
|
|
oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
|
|
newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
|
|
}
|
|
return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), newEndN - oldStartN);
|
|
}
|
|
function getTypeParameterOwner(d) {
|
|
if (d && d.kind === 165 /* TypeParameter */) {
|
|
for (let current = d; current; current = current.parent) {
|
|
if (isFunctionLike(current) || isClassLike(current) || current.kind === 261 /* InterfaceDeclaration */) {
|
|
return current;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isParameterPropertyDeclaration(node, parent2) {
|
|
return hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) && parent2.kind === 173 /* Constructor */;
|
|
}
|
|
function isEmptyBindingPattern(node) {
|
|
if (isBindingPattern(node)) {
|
|
return every(node.elements, isEmptyBindingElement);
|
|
}
|
|
return false;
|
|
}
|
|
function isEmptyBindingElement(node) {
|
|
if (isOmittedExpression(node)) {
|
|
return true;
|
|
}
|
|
return isEmptyBindingPattern(node.name);
|
|
}
|
|
function walkUpBindingElementsAndPatterns(binding) {
|
|
let node = binding.parent;
|
|
while (isBindingElement(node.parent)) {
|
|
node = node.parent.parent;
|
|
}
|
|
return node.parent;
|
|
}
|
|
function getCombinedFlags(node, getFlags) {
|
|
if (isBindingElement(node)) {
|
|
node = walkUpBindingElementsAndPatterns(node);
|
|
}
|
|
let flags = getFlags(node);
|
|
if (node.kind === 257 /* VariableDeclaration */) {
|
|
node = node.parent;
|
|
}
|
|
if (node && node.kind === 258 /* VariableDeclarationList */) {
|
|
flags |= getFlags(node);
|
|
node = node.parent;
|
|
}
|
|
if (node && node.kind === 240 /* VariableStatement */) {
|
|
flags |= getFlags(node);
|
|
}
|
|
return flags;
|
|
}
|
|
function getCombinedModifierFlags(node) {
|
|
return getCombinedFlags(node, getEffectiveModifierFlags);
|
|
}
|
|
function getCombinedNodeFlagsAlwaysIncludeJSDoc(node) {
|
|
return getCombinedFlags(node, getEffectiveModifierFlagsAlwaysIncludeJSDoc);
|
|
}
|
|
function getCombinedNodeFlags(node) {
|
|
return getCombinedFlags(node, (n) => n.flags);
|
|
}
|
|
var supportedLocaleDirectories = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"];
|
|
function validateLocaleAndSetLanguage(locale, sys2, errors) {
|
|
const lowerCaseLocale = locale.toLowerCase();
|
|
const matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(lowerCaseLocale);
|
|
if (!matchResult) {
|
|
if (errors) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp"));
|
|
}
|
|
return;
|
|
}
|
|
const language = matchResult[1];
|
|
const territory = matchResult[3];
|
|
if (contains(supportedLocaleDirectories, lowerCaseLocale) && !trySetLanguageAndTerritory(language, territory, errors)) {
|
|
trySetLanguageAndTerritory(language, void 0, errors);
|
|
}
|
|
setUILocale(locale);
|
|
function trySetLanguageAndTerritory(language2, territory2, errors2) {
|
|
const compilerFilePath = normalizePath(sys2.getExecutingFilePath());
|
|
const containingDirectoryPath = getDirectoryPath(compilerFilePath);
|
|
let filePath = combinePaths(containingDirectoryPath, language2);
|
|
if (territory2) {
|
|
filePath = filePath + "-" + territory2;
|
|
}
|
|
filePath = sys2.resolvePath(combinePaths(filePath, "diagnosticMessages.generated.json"));
|
|
if (!sys2.fileExists(filePath)) {
|
|
return false;
|
|
}
|
|
let fileContents = "";
|
|
try {
|
|
fileContents = sys2.readFile(filePath);
|
|
} catch (e) {
|
|
if (errors2) {
|
|
errors2.push(createCompilerDiagnostic(Diagnostics.Unable_to_open_file_0, filePath));
|
|
}
|
|
return false;
|
|
}
|
|
try {
|
|
setLocalizedDiagnosticMessages(JSON.parse(fileContents));
|
|
} catch (e) {
|
|
if (errors2) {
|
|
errors2.push(createCompilerDiagnostic(Diagnostics.Corrupted_locale_file_0, filePath));
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function getOriginalNode(node, nodeTest) {
|
|
if (node) {
|
|
while (node.original !== void 0) {
|
|
node = node.original;
|
|
}
|
|
}
|
|
return !nodeTest || nodeTest(node) ? node : void 0;
|
|
}
|
|
function findAncestor(node, callback) {
|
|
while (node) {
|
|
const result = callback(node);
|
|
if (result === "quit") {
|
|
return void 0;
|
|
} else if (result) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isParseTreeNode(node) {
|
|
return (node.flags & 8 /* Synthesized */) === 0;
|
|
}
|
|
function getParseTreeNode(node, nodeTest) {
|
|
if (node === void 0 || isParseTreeNode(node)) {
|
|
return node;
|
|
}
|
|
node = node.original;
|
|
while (node) {
|
|
if (isParseTreeNode(node)) {
|
|
return !nodeTest || nodeTest(node) ? node : void 0;
|
|
}
|
|
node = node.original;
|
|
}
|
|
}
|
|
function escapeLeadingUnderscores(identifier) {
|
|
return identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* _ */ && identifier.charCodeAt(1) === 95 /* _ */ ? "_" + identifier : identifier;
|
|
}
|
|
function unescapeLeadingUnderscores(identifier) {
|
|
const id = identifier;
|
|
return id.length >= 3 && id.charCodeAt(0) === 95 /* _ */ && id.charCodeAt(1) === 95 /* _ */ && id.charCodeAt(2) === 95 /* _ */ ? id.substr(1) : id;
|
|
}
|
|
function idText(identifierOrPrivateName) {
|
|
return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText);
|
|
}
|
|
function symbolName(symbol) {
|
|
if (symbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) {
|
|
return idText(symbol.valueDeclaration.name);
|
|
}
|
|
return unescapeLeadingUnderscores(symbol.escapedName);
|
|
}
|
|
function nameForNamelessJSDocTypedef(declaration) {
|
|
const hostNode = declaration.parent.parent;
|
|
if (!hostNode) {
|
|
return void 0;
|
|
}
|
|
if (isDeclaration(hostNode)) {
|
|
return getDeclarationIdentifier(hostNode);
|
|
}
|
|
switch (hostNode.kind) {
|
|
case 240 /* VariableStatement */:
|
|
if (hostNode.declarationList && hostNode.declarationList.declarations[0]) {
|
|
return getDeclarationIdentifier(hostNode.declarationList.declarations[0]);
|
|
}
|
|
break;
|
|
case 241 /* ExpressionStatement */:
|
|
let expr = hostNode.expression;
|
|
if (expr.kind === 223 /* BinaryExpression */ && expr.operatorToken.kind === 63 /* EqualsToken */) {
|
|
expr = expr.left;
|
|
}
|
|
switch (expr.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return expr.name;
|
|
case 209 /* ElementAccessExpression */:
|
|
const arg = expr.argumentExpression;
|
|
if (isIdentifier(arg)) {
|
|
return arg;
|
|
}
|
|
}
|
|
break;
|
|
case 214 /* ParenthesizedExpression */: {
|
|
return getDeclarationIdentifier(hostNode.expression);
|
|
}
|
|
case 253 /* LabeledStatement */: {
|
|
if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) {
|
|
return getDeclarationIdentifier(hostNode.statement);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function getDeclarationIdentifier(node) {
|
|
const name = getNameOfDeclaration(node);
|
|
return name && isIdentifier(name) ? name : void 0;
|
|
}
|
|
function nodeHasName(statement, name) {
|
|
if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) {
|
|
return true;
|
|
}
|
|
if (isVariableStatement(statement) && some(statement.declarationList.declarations, (d) => nodeHasName(d, name))) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getNameOfJSDocTypedef(declaration) {
|
|
return declaration.name || nameForNamelessJSDocTypedef(declaration);
|
|
}
|
|
function isNamedDeclaration(node) {
|
|
return !!node.name;
|
|
}
|
|
function getNonAssignedNameOfDeclaration(declaration) {
|
|
switch (declaration.kind) {
|
|
case 79 /* Identifier */:
|
|
return declaration;
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 343 /* JSDocParameterTag */: {
|
|
const { name } = declaration;
|
|
if (name.kind === 163 /* QualifiedName */) {
|
|
return name.right;
|
|
}
|
|
break;
|
|
}
|
|
case 210 /* CallExpression */:
|
|
case 223 /* BinaryExpression */: {
|
|
const expr2 = declaration;
|
|
switch (getAssignmentDeclarationKind(expr2)) {
|
|
case 1 /* ExportsProperty */:
|
|
case 4 /* ThisProperty */:
|
|
case 5 /* Property */:
|
|
case 3 /* PrototypeProperty */:
|
|
return getElementOrPropertyAccessArgumentExpressionOrName(expr2.left);
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return expr2.arguments[1];
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
case 348 /* JSDocTypedefTag */:
|
|
return getNameOfJSDocTypedef(declaration);
|
|
case 342 /* JSDocEnumTag */:
|
|
return nameForNamelessJSDocTypedef(declaration);
|
|
case 274 /* ExportAssignment */: {
|
|
const { expression } = declaration;
|
|
return isIdentifier(expression) ? expression : void 0;
|
|
}
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = declaration;
|
|
if (isBindableStaticElementAccessExpression(expr)) {
|
|
return expr.argumentExpression;
|
|
}
|
|
}
|
|
return declaration.name;
|
|
}
|
|
function getNameOfDeclaration(declaration) {
|
|
if (declaration === void 0)
|
|
return void 0;
|
|
return getNonAssignedNameOfDeclaration(declaration) || (isFunctionExpression(declaration) || isArrowFunction(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : void 0);
|
|
}
|
|
function getAssignedName(node) {
|
|
if (!node.parent) {
|
|
return void 0;
|
|
} else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) {
|
|
return node.parent.name;
|
|
} else if (isBinaryExpression(node.parent) && node === node.parent.right) {
|
|
if (isIdentifier(node.parent.left)) {
|
|
return node.parent.left;
|
|
} else if (isAccessExpression(node.parent.left)) {
|
|
return getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left);
|
|
}
|
|
} else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) {
|
|
return node.parent.name;
|
|
}
|
|
}
|
|
function getDecorators(node) {
|
|
if (hasDecorators(node)) {
|
|
return filter(node.modifiers, isDecorator);
|
|
}
|
|
}
|
|
function getModifiers(node) {
|
|
if (hasSyntacticModifier(node, 126975 /* Modifier */)) {
|
|
return filter(node.modifiers, isModifier);
|
|
}
|
|
}
|
|
function getJSDocParameterTagsWorker(param, noCache) {
|
|
if (param.name) {
|
|
if (isIdentifier(param.name)) {
|
|
const name = param.name.escapedText;
|
|
return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
|
|
} else {
|
|
const i = param.parent.parameters.indexOf(param);
|
|
Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
|
|
const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
|
|
if (i < paramTags.length) {
|
|
return [paramTags[i]];
|
|
}
|
|
}
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getJSDocParameterTags(param) {
|
|
return getJSDocParameterTagsWorker(param, false);
|
|
}
|
|
function getJSDocParameterTagsNoCache(param) {
|
|
return getJSDocParameterTagsWorker(param, true);
|
|
}
|
|
function getJSDocTypeParameterTagsWorker(param, noCache) {
|
|
const name = param.name.escapedText;
|
|
return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocTemplateTag(tag) && tag.typeParameters.some((tp) => tp.name.escapedText === name));
|
|
}
|
|
function getJSDocTypeParameterTags(param) {
|
|
return getJSDocTypeParameterTagsWorker(param, false);
|
|
}
|
|
function getJSDocTypeParameterTagsNoCache(param) {
|
|
return getJSDocTypeParameterTagsWorker(param, true);
|
|
}
|
|
function hasJSDocParameterTags(node) {
|
|
return !!getFirstJSDocTag(node, isJSDocParameterTag);
|
|
}
|
|
function getJSDocAugmentsTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocAugmentsTag);
|
|
}
|
|
function getJSDocImplementsTags(node) {
|
|
return getAllJSDocTags(node, isJSDocImplementsTag);
|
|
}
|
|
function getJSDocClassTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocClassTag);
|
|
}
|
|
function getJSDocPublicTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocPublicTag);
|
|
}
|
|
function getJSDocPublicTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocPublicTag, true);
|
|
}
|
|
function getJSDocPrivateTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocPrivateTag);
|
|
}
|
|
function getJSDocPrivateTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocPrivateTag, true);
|
|
}
|
|
function getJSDocProtectedTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocProtectedTag);
|
|
}
|
|
function getJSDocProtectedTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocProtectedTag, true);
|
|
}
|
|
function getJSDocReadonlyTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocReadonlyTag);
|
|
}
|
|
function getJSDocReadonlyTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocReadonlyTag, true);
|
|
}
|
|
function getJSDocOverrideTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocOverrideTag, true);
|
|
}
|
|
function getJSDocDeprecatedTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocDeprecatedTag);
|
|
}
|
|
function getJSDocDeprecatedTagNoCache(node) {
|
|
return getFirstJSDocTag(node, isJSDocDeprecatedTag, true);
|
|
}
|
|
function getJSDocEnumTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocEnumTag);
|
|
}
|
|
function getJSDocThisTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocThisTag);
|
|
}
|
|
function getJSDocReturnTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocReturnTag);
|
|
}
|
|
function getJSDocTemplateTag(node) {
|
|
return getFirstJSDocTag(node, isJSDocTemplateTag);
|
|
}
|
|
function getJSDocTypeTag(node) {
|
|
const tag = getFirstJSDocTag(node, isJSDocTypeTag);
|
|
if (tag && tag.typeExpression && tag.typeExpression.type) {
|
|
return tag;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getJSDocType(node) {
|
|
let tag = getFirstJSDocTag(node, isJSDocTypeTag);
|
|
if (!tag && isParameter(node)) {
|
|
tag = find(getJSDocParameterTags(node), (tag2) => !!tag2.typeExpression);
|
|
}
|
|
return tag && tag.typeExpression && tag.typeExpression.type;
|
|
}
|
|
function getJSDocReturnType(node) {
|
|
const returnTag = getJSDocReturnTag(node);
|
|
if (returnTag && returnTag.typeExpression) {
|
|
return returnTag.typeExpression.type;
|
|
}
|
|
const typeTag = getJSDocTypeTag(node);
|
|
if (typeTag && typeTag.typeExpression) {
|
|
const type = typeTag.typeExpression.type;
|
|
if (isTypeLiteralNode(type)) {
|
|
const sig = find(type.members, isCallSignatureDeclaration);
|
|
return sig && sig.type;
|
|
}
|
|
if (isFunctionTypeNode(type) || isJSDocFunctionType(type)) {
|
|
return type.type;
|
|
}
|
|
}
|
|
}
|
|
function getJSDocTagsWorker(node, noCache) {
|
|
let tags = node.jsDocCache;
|
|
if (tags === void 0 || noCache) {
|
|
const comments = getJSDocCommentsAndTags(node, noCache);
|
|
Debug.assert(comments.length < 2 || comments[0] !== comments[1]);
|
|
tags = flatMap(comments, (j) => isJSDoc(j) ? j.tags : j);
|
|
if (!noCache) {
|
|
node.jsDocCache = tags;
|
|
}
|
|
}
|
|
return tags;
|
|
}
|
|
function getJSDocTags(node) {
|
|
return getJSDocTagsWorker(node, false);
|
|
}
|
|
function getJSDocTagsNoCache(node) {
|
|
return getJSDocTagsWorker(node, true);
|
|
}
|
|
function getFirstJSDocTag(node, predicate, noCache) {
|
|
return find(getJSDocTagsWorker(node, noCache), predicate);
|
|
}
|
|
function getAllJSDocTags(node, predicate) {
|
|
return getJSDocTags(node).filter(predicate);
|
|
}
|
|
function getAllJSDocTagsOfKind(node, kind) {
|
|
return getJSDocTags(node).filter((doc) => doc.kind === kind);
|
|
}
|
|
function getTextOfJSDocComment(comment) {
|
|
return typeof comment === "string" ? comment : comment == null ? void 0 : comment.map((c) => c.kind === 324 /* JSDocText */ ? c.text : formatJSDocLink(c)).join("");
|
|
}
|
|
function formatJSDocLink(link) {
|
|
const kind = link.kind === 327 /* JSDocLink */ ? "link" : link.kind === 328 /* JSDocLinkCode */ ? "linkcode" : "linkplain";
|
|
const name = link.name ? entityNameToString(link.name) : "";
|
|
const space = link.name && link.text.startsWith("://") ? "" : " ";
|
|
return `{@${kind} ${name}${space}${link.text}}`;
|
|
}
|
|
function getEffectiveTypeParameterDeclarations(node) {
|
|
if (isJSDocSignature(node)) {
|
|
return emptyArray;
|
|
}
|
|
if (isJSDocTypeAlias(node)) {
|
|
Debug.assert(node.parent.kind === 323 /* JSDoc */);
|
|
return flatMap(node.parent.tags, (tag) => isJSDocTemplateTag(tag) ? tag.typeParameters : void 0);
|
|
}
|
|
if (node.typeParameters) {
|
|
return node.typeParameters;
|
|
}
|
|
if (canHaveIllegalTypeParameters(node) && node.typeParameters) {
|
|
return node.typeParameters;
|
|
}
|
|
if (isInJSFile(node)) {
|
|
const decls = getJSDocTypeParameterDeclarations(node);
|
|
if (decls.length) {
|
|
return decls;
|
|
}
|
|
const typeTag = getJSDocType(node);
|
|
if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) {
|
|
return typeTag.typeParameters;
|
|
}
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getEffectiveConstraintOfTypeParameter(node) {
|
|
return node.constraint ? node.constraint : isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint : void 0;
|
|
}
|
|
function isMemberName(node) {
|
|
return node.kind === 79 /* Identifier */ || node.kind === 80 /* PrivateIdentifier */;
|
|
}
|
|
function isGetOrSetAccessorDeclaration(node) {
|
|
return node.kind === 175 /* SetAccessor */ || node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function isPropertyAccessChain(node) {
|
|
return isPropertyAccessExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isElementAccessChain(node) {
|
|
return isElementAccessExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isCallChain(node) {
|
|
return isCallExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isOptionalChain(node) {
|
|
const kind = node.kind;
|
|
return !!(node.flags & 32 /* OptionalChain */) && (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */ || kind === 210 /* CallExpression */ || kind === 232 /* NonNullExpression */);
|
|
}
|
|
function isOptionalChainRoot(node) {
|
|
return isOptionalChain(node) && !isNonNullExpression(node) && !!node.questionDotToken;
|
|
}
|
|
function isExpressionOfOptionalChainRoot(node) {
|
|
return isOptionalChainRoot(node.parent) && node.parent.expression === node;
|
|
}
|
|
function isOutermostOptionalChain(node) {
|
|
return !isOptionalChain(node.parent) || isOptionalChainRoot(node.parent) || node !== node.parent.expression;
|
|
}
|
|
function isNullishCoalesce(node) {
|
|
return node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 60 /* QuestionQuestionToken */;
|
|
}
|
|
function isConstTypeReference(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "const" && !node.typeArguments;
|
|
}
|
|
function skipPartiallyEmittedExpressions(node) {
|
|
return skipOuterExpressions(node, 8 /* PartiallyEmittedExpressions */);
|
|
}
|
|
function isNonNullChain(node) {
|
|
return isNonNullExpression(node) && !!(node.flags & 32 /* OptionalChain */);
|
|
}
|
|
function isBreakOrContinueStatement(node) {
|
|
return node.kind === 249 /* BreakStatement */ || node.kind === 248 /* ContinueStatement */;
|
|
}
|
|
function isNamedExportBindings(node) {
|
|
return node.kind === 277 /* NamespaceExport */ || node.kind === 276 /* NamedExports */;
|
|
}
|
|
function isUnparsedTextLike(node) {
|
|
switch (node.kind) {
|
|
case 305 /* UnparsedText */:
|
|
case 306 /* UnparsedInternalText */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isUnparsedNode(node) {
|
|
return isUnparsedTextLike(node) || node.kind === 303 /* UnparsedPrologue */ || node.kind === 307 /* UnparsedSyntheticReference */;
|
|
}
|
|
function isJSDocPropertyLikeTag(node) {
|
|
return node.kind === 350 /* JSDocPropertyTag */ || node.kind === 343 /* JSDocParameterTag */;
|
|
}
|
|
function isNode(node) {
|
|
return isNodeKind(node.kind);
|
|
}
|
|
function isNodeKind(kind) {
|
|
return kind >= 163 /* FirstNode */;
|
|
}
|
|
function isTokenKind(kind) {
|
|
return kind >= 0 /* FirstToken */ && kind <= 162 /* LastToken */;
|
|
}
|
|
function isToken(n) {
|
|
return isTokenKind(n.kind);
|
|
}
|
|
function isNodeArray(array) {
|
|
return hasProperty(array, "pos") && hasProperty(array, "end");
|
|
}
|
|
function isLiteralKind(kind) {
|
|
return 8 /* FirstLiteralToken */ <= kind && kind <= 14 /* LastLiteralToken */;
|
|
}
|
|
function isLiteralExpression(node) {
|
|
return isLiteralKind(node.kind);
|
|
}
|
|
function isLiteralExpressionOfObject(node) {
|
|
switch (node.kind) {
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTemplateLiteralKind(kind) {
|
|
return 14 /* FirstTemplateToken */ <= kind && kind <= 17 /* LastTemplateToken */;
|
|
}
|
|
function isTemplateLiteralToken(node) {
|
|
return isTemplateLiteralKind(node.kind);
|
|
}
|
|
function isTemplateMiddleOrTemplateTail(node) {
|
|
const kind = node.kind;
|
|
return kind === 16 /* TemplateMiddle */ || kind === 17 /* TemplateTail */;
|
|
}
|
|
function isImportOrExportSpecifier(node) {
|
|
return isImportSpecifier(node) || isExportSpecifier(node);
|
|
}
|
|
function isTypeOnlyImportOrExportDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return node.isTypeOnly || node.parent.parent.isTypeOnly;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.isTypeOnly;
|
|
case 270 /* ImportClause */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.isTypeOnly;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isAssertionKey(node) {
|
|
return isStringLiteral(node) || isIdentifier(node);
|
|
}
|
|
function isStringTextContainingNode(node) {
|
|
return node.kind === 10 /* StringLiteral */ || isTemplateLiteralKind(node.kind);
|
|
}
|
|
function isGeneratedIdentifier(node) {
|
|
return isIdentifier(node) && (node.autoGenerateFlags & 7 /* KindMask */) > 0 /* None */;
|
|
}
|
|
function isGeneratedPrivateIdentifier(node) {
|
|
return isPrivateIdentifier(node) && (node.autoGenerateFlags & 7 /* KindMask */) > 0 /* None */;
|
|
}
|
|
function isPrivateIdentifierClassElementDeclaration(node) {
|
|
return (isPropertyDeclaration(node) || isMethodOrAccessor(node)) && isPrivateIdentifier(node.name);
|
|
}
|
|
function isPrivateIdentifierPropertyAccessExpression(node) {
|
|
return isPropertyAccessExpression(node) && isPrivateIdentifier(node.name);
|
|
}
|
|
function isModifierKind(token) {
|
|
switch (token) {
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 132 /* AsyncKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isParameterPropertyModifier(kind) {
|
|
return !!(modifierToFlag(kind) & 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isClassMemberModifier(idToken) {
|
|
return isParameterPropertyModifier(idToken) || idToken === 124 /* StaticKeyword */ || idToken === 161 /* OverrideKeyword */ || idToken === 127 /* AccessorKeyword */;
|
|
}
|
|
function isModifier(node) {
|
|
return isModifierKind(node.kind);
|
|
}
|
|
function isEntityName(node) {
|
|
const kind = node.kind;
|
|
return kind === 163 /* QualifiedName */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isPropertyName(node) {
|
|
const kind = node.kind;
|
|
return kind === 79 /* Identifier */ || kind === 80 /* PrivateIdentifier */ || kind === 10 /* StringLiteral */ || kind === 8 /* NumericLiteral */ || kind === 164 /* ComputedPropertyName */;
|
|
}
|
|
function isBindingName(node) {
|
|
const kind = node.kind;
|
|
return kind === 79 /* Identifier */ || kind === 203 /* ObjectBindingPattern */ || kind === 204 /* ArrayBindingPattern */;
|
|
}
|
|
function isFunctionLike(node) {
|
|
return !!node && isFunctionLikeKind(node.kind);
|
|
}
|
|
function isFunctionLikeOrClassStaticBlockDeclaration(node) {
|
|
return !!node && (isFunctionLikeKind(node.kind) || isClassStaticBlockDeclaration(node));
|
|
}
|
|
function isFunctionLikeDeclaration(node) {
|
|
return node && isFunctionLikeDeclarationKind(node.kind);
|
|
}
|
|
function isBooleanLiteral(node) {
|
|
return node.kind === 110 /* TrueKeyword */ || node.kind === 95 /* FalseKeyword */;
|
|
}
|
|
function isFunctionLikeDeclarationKind(kind) {
|
|
switch (kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isFunctionLikeKind(kind) {
|
|
switch (kind) {
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return true;
|
|
default:
|
|
return isFunctionLikeDeclarationKind(kind);
|
|
}
|
|
}
|
|
function isFunctionOrModuleBlock(node) {
|
|
return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent);
|
|
}
|
|
function isClassElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 169 /* PropertyDeclaration */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 178 /* IndexSignature */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 237 /* SemicolonClassElement */;
|
|
}
|
|
function isClassLike(node) {
|
|
return node && (node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */);
|
|
}
|
|
function isAccessor(node) {
|
|
return node && (node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */);
|
|
}
|
|
function isAutoAccessorPropertyDeclaration(node) {
|
|
return isPropertyDeclaration(node) && hasAccessorModifier(node);
|
|
}
|
|
function isMethodOrAccessor(node) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isNamedClassElement(node) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isModifierLike(node) {
|
|
return isModifier(node) || isDecorator(node);
|
|
}
|
|
function isTypeElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 177 /* ConstructSignature */ || kind === 176 /* CallSignature */ || kind === 168 /* PropertySignature */ || kind === 170 /* MethodSignature */ || kind === 178 /* IndexSignature */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function isClassOrTypeElement(node) {
|
|
return isTypeElement(node) || isClassElement(node);
|
|
}
|
|
function isObjectLiteralElementLike(node) {
|
|
const kind = node.kind;
|
|
return kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 301 /* SpreadAssignment */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function isTypeNode(node) {
|
|
return isTypeNodeKind(node.kind);
|
|
}
|
|
function isFunctionOrConstructorTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isBindingPattern(node) {
|
|
if (node) {
|
|
const kind = node.kind;
|
|
return kind === 204 /* ArrayBindingPattern */ || kind === 203 /* ObjectBindingPattern */;
|
|
}
|
|
return false;
|
|
}
|
|
function isAssignmentPattern(node) {
|
|
const kind = node.kind;
|
|
return kind === 206 /* ArrayLiteralExpression */ || kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isArrayBindingElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 205 /* BindingElement */ || kind === 229 /* OmittedExpression */;
|
|
}
|
|
function isDeclarationBindingElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isBindingOrAssignmentPattern(node) {
|
|
return isObjectBindingOrAssignmentPattern(node) || isArrayBindingOrAssignmentPattern(node);
|
|
}
|
|
function isObjectBindingOrAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isObjectBindingOrAssignmentElement(node) {
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isArrayBindingOrAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
|
|
const kind = node.kind;
|
|
return kind === 208 /* PropertyAccessExpression */ || kind === 163 /* QualifiedName */ || kind === 202 /* ImportType */;
|
|
}
|
|
function isPropertyAccessOrQualifiedName(node) {
|
|
const kind = node.kind;
|
|
return kind === 208 /* PropertyAccessExpression */ || kind === 163 /* QualifiedName */;
|
|
}
|
|
function isCallLikeExpression(node) {
|
|
switch (node.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 167 /* Decorator */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isCallOrNewExpression(node) {
|
|
return node.kind === 210 /* CallExpression */ || node.kind === 211 /* NewExpression */;
|
|
}
|
|
function isTemplateLiteral(node) {
|
|
const kind = node.kind;
|
|
return kind === 225 /* TemplateExpression */ || kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isLeftHandSideExpression(node) {
|
|
return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isLeftHandSideExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 210 /* CallExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 108 /* ThisKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 232 /* NonNullExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 233 /* MetaProperty */:
|
|
case 100 /* ImportKeyword */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isUnaryExpression(node) {
|
|
return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isUnaryExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
return true;
|
|
default:
|
|
return isLeftHandSideExpressionKind(kind);
|
|
}
|
|
}
|
|
function isUnaryExpressionWithWrite(expr) {
|
|
switch (expr.kind) {
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return true;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return expr.operator === 45 /* PlusPlusToken */ || expr.operator === 46 /* MinusMinusToken */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isExpression(node) {
|
|
return isExpressionKind(skipPartiallyEmittedExpressions(node).kind);
|
|
}
|
|
function isExpressionKind(kind) {
|
|
switch (kind) {
|
|
case 224 /* ConditionalExpression */:
|
|
case 226 /* YieldExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 223 /* BinaryExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 231 /* AsExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 354 /* CommaListExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return true;
|
|
default:
|
|
return isUnaryExpressionKind(kind);
|
|
}
|
|
}
|
|
function isAssertionExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 213 /* TypeAssertionExpression */ || kind === 231 /* AsExpression */;
|
|
}
|
|
function isNotEmittedOrPartiallyEmittedNode(node) {
|
|
return isNotEmittedStatement(node) || isPartiallyEmittedExpression(node);
|
|
}
|
|
function isIterationStatement(node, lookInLabeledStatements) {
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return true;
|
|
case 253 /* LabeledStatement */:
|
|
return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements);
|
|
}
|
|
return false;
|
|
}
|
|
function isScopeMarker(node) {
|
|
return isExportAssignment(node) || isExportDeclaration(node);
|
|
}
|
|
function hasScopeMarker(statements) {
|
|
return some(statements, isScopeMarker);
|
|
}
|
|
function needsScopeMarker(result) {
|
|
return !isAnyImportOrReExport(result) && !isExportAssignment(result) && !hasSyntacticModifier(result, 1 /* Export */) && !isAmbientModule(result);
|
|
}
|
|
function isExternalModuleIndicator(result) {
|
|
return isAnyImportOrReExport(result) || isExportAssignment(result) || hasSyntacticModifier(result, 1 /* Export */);
|
|
}
|
|
function isForInOrOfStatement(node) {
|
|
return node.kind === 246 /* ForInStatement */ || node.kind === 247 /* ForOfStatement */;
|
|
}
|
|
function isConciseBody(node) {
|
|
return isBlock(node) || isExpression(node);
|
|
}
|
|
function isFunctionBody(node) {
|
|
return isBlock(node);
|
|
}
|
|
function isForInitializer(node) {
|
|
return isVariableDeclarationList(node) || isExpression(node);
|
|
}
|
|
function isModuleBody(node) {
|
|
const kind = node.kind;
|
|
return kind === 265 /* ModuleBlock */ || kind === 264 /* ModuleDeclaration */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isNamespaceBody(node) {
|
|
const kind = node.kind;
|
|
return kind === 265 /* ModuleBlock */ || kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isJSDocNamespaceBody(node) {
|
|
const kind = node.kind;
|
|
return kind === 79 /* Identifier */ || kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isNamedImportBindings(node) {
|
|
const kind = node.kind;
|
|
return kind === 272 /* NamedImports */ || kind === 271 /* NamespaceImport */;
|
|
}
|
|
function isModuleOrEnumDeclaration(node) {
|
|
return node.kind === 264 /* ModuleDeclaration */ || node.kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function isDeclarationKind(kind) {
|
|
return kind === 216 /* ArrowFunction */ || kind === 205 /* BindingElement */ || kind === 260 /* ClassDeclaration */ || kind === 228 /* ClassExpression */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 173 /* Constructor */ || kind === 263 /* EnumDeclaration */ || kind === 302 /* EnumMember */ || kind === 278 /* ExportSpecifier */ || kind === 259 /* FunctionDeclaration */ || kind === 215 /* FunctionExpression */ || kind === 174 /* GetAccessor */ || kind === 270 /* ImportClause */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 273 /* ImportSpecifier */ || kind === 261 /* InterfaceDeclaration */ || kind === 288 /* JsxAttribute */ || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 264 /* ModuleDeclaration */ || kind === 267 /* NamespaceExportDeclaration */ || kind === 271 /* NamespaceImport */ || kind === 277 /* NamespaceExport */ || kind === 166 /* Parameter */ || kind === 299 /* PropertyAssignment */ || kind === 169 /* PropertyDeclaration */ || kind === 168 /* PropertySignature */ || kind === 175 /* SetAccessor */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 262 /* TypeAliasDeclaration */ || kind === 165 /* TypeParameter */ || kind === 257 /* VariableDeclaration */ || kind === 348 /* JSDocTypedefTag */ || kind === 341 /* JSDocCallbackTag */ || kind === 350 /* JSDocPropertyTag */;
|
|
}
|
|
function isDeclarationStatementKind(kind) {
|
|
return kind === 259 /* FunctionDeclaration */ || kind === 279 /* MissingDeclaration */ || kind === 260 /* ClassDeclaration */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 275 /* ExportDeclaration */ || kind === 274 /* ExportAssignment */ || kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
function isStatementKindButNotDeclarationKind(kind) {
|
|
return kind === 249 /* BreakStatement */ || kind === 248 /* ContinueStatement */ || kind === 256 /* DebuggerStatement */ || kind === 243 /* DoStatement */ || kind === 241 /* ExpressionStatement */ || kind === 239 /* EmptyStatement */ || kind === 246 /* ForInStatement */ || kind === 247 /* ForOfStatement */ || kind === 245 /* ForStatement */ || kind === 242 /* IfStatement */ || kind === 253 /* LabeledStatement */ || kind === 250 /* ReturnStatement */ || kind === 252 /* SwitchStatement */ || kind === 254 /* ThrowStatement */ || kind === 255 /* TryStatement */ || kind === 240 /* VariableStatement */ || kind === 244 /* WhileStatement */ || kind === 251 /* WithStatement */ || kind === 352 /* NotEmittedStatement */ || kind === 356 /* EndOfDeclarationMarker */ || kind === 355 /* MergeDeclarationMarker */;
|
|
}
|
|
function isDeclaration(node) {
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
return node.parent && node.parent.kind !== 347 /* JSDocTemplateTag */ || isInJSFile(node);
|
|
}
|
|
return isDeclarationKind(node.kind);
|
|
}
|
|
function isDeclarationStatement(node) {
|
|
return isDeclarationStatementKind(node.kind);
|
|
}
|
|
function isStatementButNotDeclaration(node) {
|
|
return isStatementKindButNotDeclarationKind(node.kind);
|
|
}
|
|
function isStatement(node) {
|
|
const kind = node.kind;
|
|
return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || isBlockStatement(node);
|
|
}
|
|
function isBlockStatement(node) {
|
|
if (node.kind !== 238 /* Block */)
|
|
return false;
|
|
if (node.parent !== void 0) {
|
|
if (node.parent.kind === 255 /* TryStatement */ || node.parent.kind === 295 /* CatchClause */) {
|
|
return false;
|
|
}
|
|
}
|
|
return !isFunctionBlock(node);
|
|
}
|
|
function isStatementOrBlock(node) {
|
|
const kind = node.kind;
|
|
return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || kind === 238 /* Block */;
|
|
}
|
|
function isModuleReference(node) {
|
|
const kind = node.kind;
|
|
return kind === 280 /* ExternalModuleReference */ || kind === 163 /* QualifiedName */ || kind === 79 /* Identifier */;
|
|
}
|
|
function isJsxTagNameExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 108 /* ThisKeyword */ || kind === 79 /* Identifier */ || kind === 208 /* PropertyAccessExpression */;
|
|
}
|
|
function isJsxChild(node) {
|
|
const kind = node.kind;
|
|
return kind === 281 /* JsxElement */ || kind === 291 /* JsxExpression */ || kind === 282 /* JsxSelfClosingElement */ || kind === 11 /* JsxText */ || kind === 285 /* JsxFragment */;
|
|
}
|
|
function isJsxAttributeLike(node) {
|
|
const kind = node.kind;
|
|
return kind === 288 /* JsxAttribute */ || kind === 290 /* JsxSpreadAttribute */;
|
|
}
|
|
function isStringLiteralOrJsxExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 10 /* StringLiteral */ || kind === 291 /* JsxExpression */;
|
|
}
|
|
function isJsxOpeningLikeElement(node) {
|
|
const kind = node.kind;
|
|
return kind === 283 /* JsxOpeningElement */ || kind === 282 /* JsxSelfClosingElement */;
|
|
}
|
|
function isCaseOrDefaultClause(node) {
|
|
const kind = node.kind;
|
|
return kind === 292 /* CaseClause */ || kind === 293 /* DefaultClause */;
|
|
}
|
|
function isJSDocNode(node) {
|
|
return node.kind >= 312 /* FirstJSDocNode */ && node.kind <= 350 /* LastJSDocNode */;
|
|
}
|
|
function isJSDocCommentContainingNode(node) {
|
|
return node.kind === 323 /* JSDoc */ || node.kind === 322 /* JSDocNamepathType */ || node.kind === 324 /* JSDocText */ || isJSDocLinkLike(node) || isJSDocTag(node) || isJSDocTypeLiteral(node) || isJSDocSignature(node);
|
|
}
|
|
function isJSDocTag(node) {
|
|
return node.kind >= 330 /* FirstJSDocTagNode */ && node.kind <= 350 /* LastJSDocTagNode */;
|
|
}
|
|
function isSetAccessor(node) {
|
|
return node.kind === 175 /* SetAccessor */;
|
|
}
|
|
function isGetAccessor(node) {
|
|
return node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function hasJSDocNodes(node) {
|
|
const { jsDoc } = node;
|
|
return !!jsDoc && jsDoc.length > 0;
|
|
}
|
|
function hasType(node) {
|
|
return !!node.type;
|
|
}
|
|
function hasInitializer(node) {
|
|
return !!node.initializer;
|
|
}
|
|
function hasOnlyExpressionInitializer(node) {
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 302 /* EnumMember */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isObjectLiteralElement(node) {
|
|
return node.kind === 288 /* JsxAttribute */ || node.kind === 290 /* JsxSpreadAttribute */ || isObjectLiteralElementLike(node);
|
|
}
|
|
function isTypeReferenceType(node) {
|
|
return node.kind === 180 /* TypeReference */ || node.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
var MAX_SMI_X86 = 1073741823;
|
|
function guessIndentation(lines) {
|
|
let indentation = MAX_SMI_X86;
|
|
for (const line of lines) {
|
|
if (!line.length) {
|
|
continue;
|
|
}
|
|
let i = 0;
|
|
for (; i < line.length && i < indentation; i++) {
|
|
if (!isWhiteSpaceLike(line.charCodeAt(i))) {
|
|
break;
|
|
}
|
|
}
|
|
if (i < indentation) {
|
|
indentation = i;
|
|
}
|
|
if (indentation === 0) {
|
|
return 0;
|
|
}
|
|
}
|
|
return indentation === MAX_SMI_X86 ? void 0 : indentation;
|
|
}
|
|
function isStringLiteralLike(node) {
|
|
return node.kind === 10 /* StringLiteral */ || node.kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isJSDocLinkLike(node) {
|
|
return node.kind === 327 /* JSDocLink */ || node.kind === 328 /* JSDocLinkCode */ || node.kind === 329 /* JSDocLinkPlain */;
|
|
}
|
|
function hasRestParameter(s) {
|
|
const last2 = lastOrUndefined(s.parameters);
|
|
return !!last2 && isRestParameter(last2);
|
|
}
|
|
function isRestParameter(node) {
|
|
const type = isJSDocParameterTag(node) ? node.typeExpression && node.typeExpression.type : node.type;
|
|
return node.dotDotDotToken !== void 0 || !!type && type.kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
|
|
// src/compiler/utilities.ts
|
|
var resolvingEmptyArray = [];
|
|
var externalHelpersModuleNameText = "tslib";
|
|
var defaultMaximumTruncationLength = 160;
|
|
var noTruncationMaximumTruncationLength = 1e6;
|
|
function getDeclarationOfKind(symbol, kind) {
|
|
const declarations = symbol.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
if (declaration.kind === kind) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDeclarationsOfKind(symbol, kind) {
|
|
return filter(symbol.declarations || emptyArray, (d) => d.kind === kind);
|
|
}
|
|
function createSymbolTable(symbols) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
if (symbols) {
|
|
for (const symbol of symbols) {
|
|
result.set(symbol.escapedName, symbol);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function isTransientSymbol(symbol) {
|
|
return (symbol.flags & 33554432 /* Transient */) !== 0;
|
|
}
|
|
var stringWriter = createSingleLineStringWriter();
|
|
function createSingleLineStringWriter() {
|
|
let str = "";
|
|
const writeText = (text) => str += text;
|
|
return {
|
|
getText: () => str,
|
|
write: writeText,
|
|
rawWrite: writeText,
|
|
writeKeyword: writeText,
|
|
writeOperator: writeText,
|
|
writePunctuation: writeText,
|
|
writeSpace: writeText,
|
|
writeStringLiteral: writeText,
|
|
writeLiteral: writeText,
|
|
writeParameter: writeText,
|
|
writeProperty: writeText,
|
|
writeSymbol: (s, _) => writeText(s),
|
|
writeTrailingSemicolon: writeText,
|
|
writeComment: writeText,
|
|
getTextPos: () => str.length,
|
|
getLine: () => 0,
|
|
getColumn: () => 0,
|
|
getIndent: () => 0,
|
|
isAtStartOfLine: () => false,
|
|
hasTrailingComment: () => false,
|
|
hasTrailingWhitespace: () => !!str.length && isWhiteSpaceLike(str.charCodeAt(str.length - 1)),
|
|
writeLine: () => str += " ",
|
|
increaseIndent: noop,
|
|
decreaseIndent: noop,
|
|
clear: () => str = "",
|
|
trackSymbol: () => false,
|
|
reportInaccessibleThisError: noop,
|
|
reportInaccessibleUniqueSymbolError: noop,
|
|
reportPrivateInBaseOfClassExpression: noop
|
|
};
|
|
}
|
|
function changesAffectModuleResolution(oldOptions, newOptions) {
|
|
return oldOptions.configFilePath !== newOptions.configFilePath || optionsHaveModuleResolutionChanges(oldOptions, newOptions);
|
|
}
|
|
function optionsHaveModuleResolutionChanges(oldOptions, newOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, moduleResolutionOptionDeclarations);
|
|
}
|
|
function changesAffectingProgramStructure(oldOptions, newOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, optionsAffectingProgramStructure);
|
|
}
|
|
function optionsHaveChanges(oldOptions, newOptions, optionDeclarations2) {
|
|
return oldOptions !== newOptions && optionDeclarations2.some((o) => !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)));
|
|
}
|
|
function forEachAncestor(node, callback) {
|
|
while (true) {
|
|
const res = callback(node);
|
|
if (res === "quit")
|
|
return void 0;
|
|
if (res !== void 0)
|
|
return res;
|
|
if (isSourceFile(node))
|
|
return void 0;
|
|
node = node.parent;
|
|
}
|
|
}
|
|
function forEachEntry(map2, callback) {
|
|
const iterator = map2.entries();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
const [key, value] = iterResult.value;
|
|
const result = callback(value, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function forEachKey(map2, callback) {
|
|
const iterator = map2.keys();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
const result = callback(iterResult.value);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function copyEntries(source, target) {
|
|
source.forEach((value, key) => {
|
|
target.set(key, value);
|
|
});
|
|
}
|
|
function usingSingleLineStringWriter(action) {
|
|
const oldString = stringWriter.getText();
|
|
try {
|
|
action(stringWriter);
|
|
return stringWriter.getText();
|
|
} finally {
|
|
stringWriter.clear();
|
|
stringWriter.writeKeyword(oldString);
|
|
}
|
|
}
|
|
function getFullWidth(node) {
|
|
return node.end - node.pos;
|
|
}
|
|
function getResolvedModule(sourceFile, moduleNameText, mode) {
|
|
return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);
|
|
}
|
|
function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) {
|
|
if (!sourceFile.resolvedModules) {
|
|
sourceFile.resolvedModules = createModeAwareCache();
|
|
}
|
|
sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);
|
|
}
|
|
function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective, mode) {
|
|
if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
|
|
sourceFile.resolvedTypeReferenceDirectiveNames = createModeAwareCache();
|
|
}
|
|
sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, mode, resolvedTypeReferenceDirective);
|
|
}
|
|
function getResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, mode) {
|
|
var _a2;
|
|
return (_a2 = sourceFile == null ? void 0 : sourceFile.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _a2.get(typeReferenceDirectiveName, mode);
|
|
}
|
|
function projectReferenceIsEqualTo(oldRef, newRef) {
|
|
return oldRef.path === newRef.path && !oldRef.prepend === !newRef.prepend && !oldRef.circular === !newRef.circular;
|
|
}
|
|
function moduleResolutionIsEqualTo(oldResolution, newResolution) {
|
|
return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport && oldResolution.extension === newResolution.extension && oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.originalPath === newResolution.originalPath && packageIdIsEqual(oldResolution.packageId, newResolution.packageId);
|
|
}
|
|
function packageIdIsEqual(a, b) {
|
|
return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;
|
|
}
|
|
function packageIdToPackageName({ name, subModuleName }) {
|
|
return subModuleName ? `${name}/${subModuleName}` : name;
|
|
}
|
|
function packageIdToString(packageId) {
|
|
return `${packageIdToPackageName(packageId)}@${packageId.version}`;
|
|
}
|
|
function typeDirectiveIsEqualTo(oldResolution, newResolution) {
|
|
return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary && oldResolution.originalPath === newResolution.originalPath;
|
|
}
|
|
function hasChangesInResolutions(names, newSourceFile, newResolutions, oldResolutions, comparer) {
|
|
Debug.assert(names.length === newResolutions.length);
|
|
for (let i = 0; i < names.length; i++) {
|
|
const newResolution = newResolutions[i];
|
|
const entry = names[i];
|
|
const name = getResolutionName(entry);
|
|
const mode = getResolutionMode(entry, newSourceFile);
|
|
const oldResolution = oldResolutions && oldResolutions.get(name, mode);
|
|
const changed = oldResolution ? !newResolution || !comparer(oldResolution, newResolution) : newResolution;
|
|
if (changed) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function containsParseError(node) {
|
|
aggregateChildData(node);
|
|
return (node.flags & 524288 /* ThisNodeOrAnySubNodesHasError */) !== 0;
|
|
}
|
|
function aggregateChildData(node) {
|
|
if (!(node.flags & 1048576 /* HasAggregatedChildData */)) {
|
|
const thisNodeOrAnySubNodesHasError = (node.flags & 131072 /* ThisNodeHasError */) !== 0 || forEachChild(node, containsParseError);
|
|
if (thisNodeOrAnySubNodesHasError) {
|
|
node.flags |= 524288 /* ThisNodeOrAnySubNodesHasError */;
|
|
}
|
|
node.flags |= 1048576 /* HasAggregatedChildData */;
|
|
}
|
|
}
|
|
function getSourceFileOfNode(node) {
|
|
while (node && node.kind !== 308 /* SourceFile */) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function getSourceFileOfModule(module2) {
|
|
return getSourceFileOfNode(module2.valueDeclaration || getNonAugmentationDeclaration(module2));
|
|
}
|
|
function isPlainJsFile(file, checkJs) {
|
|
return !!file && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */) && !file.checkJsDirective && checkJs === void 0;
|
|
}
|
|
function isStatementWithLocals(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 266 /* CaseBlock */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getStartPositionOfLine(line, sourceFile) {
|
|
Debug.assert(line >= 0);
|
|
return getLineStarts(sourceFile)[line];
|
|
}
|
|
function nodePosToString(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
const loc = getLineAndCharacterOfPosition(file, node.pos);
|
|
return `${file.fileName}(${loc.line + 1},${loc.character + 1})`;
|
|
}
|
|
function getEndLinePosition(line, sourceFile) {
|
|
Debug.assert(line >= 0);
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
const lineIndex = line;
|
|
const sourceText = sourceFile.text;
|
|
if (lineIndex + 1 === lineStarts.length) {
|
|
return sourceText.length - 1;
|
|
} else {
|
|
const start2 = lineStarts[lineIndex];
|
|
let pos = lineStarts[lineIndex + 1] - 1;
|
|
Debug.assert(isLineBreak(sourceText.charCodeAt(pos)));
|
|
while (start2 <= pos && isLineBreak(sourceText.charCodeAt(pos))) {
|
|
pos--;
|
|
}
|
|
return pos;
|
|
}
|
|
}
|
|
function isFileLevelUniqueName(sourceFile, name, hasGlobalName) {
|
|
return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name);
|
|
}
|
|
function nodeIsMissing(node) {
|
|
if (node === void 0) {
|
|
return true;
|
|
}
|
|
return node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* EndOfFileToken */;
|
|
}
|
|
function nodeIsPresent(node) {
|
|
return !nodeIsMissing(node);
|
|
}
|
|
function insertStatementsAfterPrologue(to, from, isPrologueDirective2) {
|
|
if (from === void 0 || from.length === 0)
|
|
return to;
|
|
let statementIndex = 0;
|
|
for (; statementIndex < to.length; ++statementIndex) {
|
|
if (!isPrologueDirective2(to[statementIndex])) {
|
|
break;
|
|
}
|
|
}
|
|
to.splice(statementIndex, 0, ...from);
|
|
return to;
|
|
}
|
|
function insertStatementAfterPrologue(to, statement, isPrologueDirective2) {
|
|
if (statement === void 0)
|
|
return to;
|
|
let statementIndex = 0;
|
|
for (; statementIndex < to.length; ++statementIndex) {
|
|
if (!isPrologueDirective2(to[statementIndex])) {
|
|
break;
|
|
}
|
|
}
|
|
to.splice(statementIndex, 0, statement);
|
|
return to;
|
|
}
|
|
function isAnyPrologueDirective(node) {
|
|
return isPrologueDirective(node) || !!(getEmitFlags(node) & 2097152 /* CustomPrologue */);
|
|
}
|
|
function insertStatementsAfterStandardPrologue(to, from) {
|
|
return insertStatementsAfterPrologue(to, from, isPrologueDirective);
|
|
}
|
|
function insertStatementsAfterCustomPrologue(to, from) {
|
|
return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective);
|
|
}
|
|
function insertStatementAfterStandardPrologue(to, statement) {
|
|
return insertStatementAfterPrologue(to, statement, isPrologueDirective);
|
|
}
|
|
function insertStatementAfterCustomPrologue(to, statement) {
|
|
return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective);
|
|
}
|
|
function isRecognizedTripleSlashComment(text, commentPos, commentEnd) {
|
|
if (text.charCodeAt(commentPos + 1) === 47 /* slash */ && commentPos + 2 < commentEnd && text.charCodeAt(commentPos + 2) === 47 /* slash */) {
|
|
const textSubStr = text.substring(commentPos, commentEnd);
|
|
return fullTripleSlashReferencePathRegEx.test(textSubStr) || fullTripleSlashAMDReferencePathRegEx.test(textSubStr) || fullTripleSlashReferenceTypeReferenceDirectiveRegEx.test(textSubStr) || defaultLibReferenceRegEx.test(textSubStr) ? true : false;
|
|
}
|
|
return false;
|
|
}
|
|
function isPinnedComment(text, start2) {
|
|
return text.charCodeAt(start2 + 1) === 42 /* asterisk */ && text.charCodeAt(start2 + 2) === 33 /* exclamation */;
|
|
}
|
|
function createCommentDirectivesMap(sourceFile, commentDirectives) {
|
|
const directivesByLine = new Map(
|
|
commentDirectives.map((commentDirective) => [
|
|
`${getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line}`,
|
|
commentDirective
|
|
])
|
|
);
|
|
const usedLines = /* @__PURE__ */ new Map();
|
|
return { getUnusedExpectations, markUsed };
|
|
function getUnusedExpectations() {
|
|
return arrayFrom(directivesByLine.entries()).filter(([line, directive]) => directive.type === 0 /* ExpectError */ && !usedLines.get(line)).map(([_, directive]) => directive);
|
|
}
|
|
function markUsed(line) {
|
|
if (!directivesByLine.has(`${line}`)) {
|
|
return false;
|
|
}
|
|
usedLines.set(`${line}`, true);
|
|
return true;
|
|
}
|
|
}
|
|
function getTokenPosOfNode(node, sourceFile, includeJsDoc) {
|
|
if (nodeIsMissing(node)) {
|
|
return node.pos;
|
|
}
|
|
if (isJSDocNode(node) || node.kind === 11 /* JsxText */) {
|
|
return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, false, true);
|
|
}
|
|
if (includeJsDoc && hasJSDocNodes(node)) {
|
|
return getTokenPosOfNode(node.jsDoc[0], sourceFile);
|
|
}
|
|
if (node.kind === 351 /* SyntaxList */ && node._children.length > 0) {
|
|
return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
|
|
}
|
|
return skipTrivia(
|
|
(sourceFile || getSourceFileOfNode(node)).text,
|
|
node.pos,
|
|
false,
|
|
false,
|
|
isInJSDoc(node)
|
|
);
|
|
}
|
|
function getNonDecoratorTokenPosOfNode(node, sourceFile) {
|
|
const lastDecorator = !nodeIsMissing(node) && canHaveModifiers(node) ? findLast(node.modifiers, isDecorator) : void 0;
|
|
if (!lastDecorator) {
|
|
return getTokenPosOfNode(node, sourceFile);
|
|
}
|
|
return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, lastDecorator.end);
|
|
}
|
|
function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia = false) {
|
|
return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia);
|
|
}
|
|
function isJSDocTypeExpressionOrChild(node) {
|
|
return !!findAncestor(node, isJSDocTypeExpression);
|
|
}
|
|
function isExportNamespaceAsDefaultDeclaration(node) {
|
|
return !!(isExportDeclaration(node) && node.exportClause && isNamespaceExport(node.exportClause) && node.exportClause.name.escapedText === "default");
|
|
}
|
|
function getTextOfNodeFromSourceText(sourceText, node, includeTrivia = false) {
|
|
if (nodeIsMissing(node)) {
|
|
return "";
|
|
}
|
|
let text = sourceText.substring(includeTrivia ? node.pos : skipTrivia(sourceText, node.pos), node.end);
|
|
if (isJSDocTypeExpressionOrChild(node)) {
|
|
text = text.split(/\r\n|\n|\r/).map((line) => trimStringStart(line.replace(/^\s*\*/, ""))).join("\n");
|
|
}
|
|
return text;
|
|
}
|
|
function getTextOfNode(node, includeTrivia = false) {
|
|
return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);
|
|
}
|
|
function getPos(range) {
|
|
return range.pos;
|
|
}
|
|
function indexOfNode(nodeArray, node) {
|
|
return binarySearch(nodeArray, node, getPos, compareValues);
|
|
}
|
|
function getEmitFlags(node) {
|
|
const emitNode = node.emitNode;
|
|
return emitNode && emitNode.flags || 0;
|
|
}
|
|
function getScriptTargetFeatures() {
|
|
return {
|
|
es2015: {
|
|
Array: ["find", "findIndex", "fill", "copyWithin", "entries", "keys", "values"],
|
|
RegExp: ["flags", "sticky", "unicode"],
|
|
Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get", " getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"],
|
|
ArrayConstructor: ["from", "of"],
|
|
ObjectConstructor: ["assign", "getOwnPropertySymbols", "keys", "is", "setPrototypeOf"],
|
|
NumberConstructor: ["isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt"],
|
|
Math: ["clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh", "sinh", "tanh", "acosh", "asinh", "atanh", "hypot", "trunc", "fround", "cbrt"],
|
|
Map: ["entries", "keys", "values"],
|
|
Set: ["entries", "keys", "values"],
|
|
Promise: emptyArray,
|
|
PromiseConstructor: ["all", "race", "reject", "resolve"],
|
|
Symbol: ["for", "keyFor"],
|
|
WeakMap: ["entries", "keys", "values"],
|
|
WeakSet: ["entries", "keys", "values"],
|
|
Iterator: emptyArray,
|
|
AsyncIterator: emptyArray,
|
|
String: ["codePointAt", "includes", "endsWith", "normalize", "repeat", "startsWith", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup"],
|
|
StringConstructor: ["fromCodePoint", "raw"]
|
|
},
|
|
es2016: {
|
|
Array: ["includes"]
|
|
},
|
|
es2017: {
|
|
Atomics: emptyArray,
|
|
SharedArrayBuffer: emptyArray,
|
|
String: ["padStart", "padEnd"],
|
|
ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"],
|
|
DateTimeFormat: ["formatToParts"]
|
|
},
|
|
es2018: {
|
|
Promise: ["finally"],
|
|
RegExpMatchArray: ["groups"],
|
|
RegExpExecArray: ["groups"],
|
|
RegExp: ["dotAll"],
|
|
Intl: ["PluralRules"],
|
|
AsyncIterable: emptyArray,
|
|
AsyncIterableIterator: emptyArray,
|
|
AsyncGenerator: emptyArray,
|
|
AsyncGeneratorFunction: emptyArray,
|
|
NumberFormat: ["formatToParts"]
|
|
},
|
|
es2019: {
|
|
Array: ["flat", "flatMap"],
|
|
ObjectConstructor: ["fromEntries"],
|
|
String: ["trimStart", "trimEnd", "trimLeft", "trimRight"],
|
|
Symbol: ["description"]
|
|
},
|
|
es2020: {
|
|
BigInt: emptyArray,
|
|
BigInt64Array: emptyArray,
|
|
BigUint64Array: emptyArray,
|
|
PromiseConstructor: ["allSettled"],
|
|
SymbolConstructor: ["matchAll"],
|
|
String: ["matchAll"],
|
|
DataView: ["setBigInt64", "setBigUint64", "getBigInt64", "getBigUint64"],
|
|
RelativeTimeFormat: ["format", "formatToParts", "resolvedOptions"]
|
|
},
|
|
es2021: {
|
|
PromiseConstructor: ["any"],
|
|
String: ["replaceAll"]
|
|
},
|
|
es2022: {
|
|
Array: ["at"],
|
|
String: ["at"],
|
|
Int8Array: ["at"],
|
|
Uint8Array: ["at"],
|
|
Uint8ClampedArray: ["at"],
|
|
Int16Array: ["at"],
|
|
Uint16Array: ["at"],
|
|
Int32Array: ["at"],
|
|
Uint32Array: ["at"],
|
|
Float32Array: ["at"],
|
|
Float64Array: ["at"],
|
|
BigInt64Array: ["at"],
|
|
BigUint64Array: ["at"],
|
|
ObjectConstructor: ["hasOwn"],
|
|
Error: ["cause"]
|
|
}
|
|
};
|
|
}
|
|
var GetLiteralTextFlags = /* @__PURE__ */ ((GetLiteralTextFlags2) => {
|
|
GetLiteralTextFlags2[GetLiteralTextFlags2["None"] = 0] = "None";
|
|
GetLiteralTextFlags2[GetLiteralTextFlags2["NeverAsciiEscape"] = 1] = "NeverAsciiEscape";
|
|
GetLiteralTextFlags2[GetLiteralTextFlags2["JsxAttributeEscape"] = 2] = "JsxAttributeEscape";
|
|
GetLiteralTextFlags2[GetLiteralTextFlags2["TerminateUnterminatedLiterals"] = 4] = "TerminateUnterminatedLiterals";
|
|
GetLiteralTextFlags2[GetLiteralTextFlags2["AllowNumericSeparator"] = 8] = "AllowNumericSeparator";
|
|
return GetLiteralTextFlags2;
|
|
})(GetLiteralTextFlags || {});
|
|
function getLiteralText(node, sourceFile, flags) {
|
|
var _a2;
|
|
if (sourceFile && canUseOriginalText(node, flags)) {
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node);
|
|
}
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */: {
|
|
const escapeText = flags & 2 /* JsxAttributeEscape */ ? escapeJsxAttributeString : flags & 1 /* NeverAsciiEscape */ || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? escapeString : escapeNonAsciiString;
|
|
if (node.singleQuote) {
|
|
return "'" + escapeText(node.text, 39 /* singleQuote */) + "'";
|
|
} else {
|
|
return '"' + escapeText(node.text, 34 /* doubleQuote */) + '"';
|
|
}
|
|
}
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */: {
|
|
const escapeText = flags & 1 /* NeverAsciiEscape */ || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? escapeString : escapeNonAsciiString;
|
|
const rawText = (_a2 = node.rawText) != null ? _a2 : escapeTemplateSubstitution(escapeText(node.text, 96 /* backtick */));
|
|
switch (node.kind) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return "`" + rawText + "`";
|
|
case 15 /* TemplateHead */:
|
|
return "`" + rawText + "${";
|
|
case 16 /* TemplateMiddle */:
|
|
return "}" + rawText + "${";
|
|
case 17 /* TemplateTail */:
|
|
return "}" + rawText + "`";
|
|
}
|
|
break;
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return node.text;
|
|
case 13 /* RegularExpressionLiteral */:
|
|
if (flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
|
|
return node.text + (node.text.charCodeAt(node.text.length - 1) === 92 /* backslash */ ? " /" : "/");
|
|
}
|
|
return node.text;
|
|
}
|
|
return Debug.fail(`Literal kind '${node.kind}' not accounted for.`);
|
|
}
|
|
function canUseOriginalText(node, flags) {
|
|
if (nodeIsSynthesized(node) || !node.parent || flags & 4 /* TerminateUnterminatedLiterals */ && node.isUnterminated) {
|
|
return false;
|
|
}
|
|
if (isNumericLiteral(node) && node.numericLiteralFlags & 512 /* ContainsSeparator */) {
|
|
return !!(flags & 8 /* AllowNumericSeparator */);
|
|
}
|
|
return !isBigIntLiteral(node);
|
|
}
|
|
function getTextOfConstantValue(value) {
|
|
return isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value;
|
|
}
|
|
function makeIdentifierFromModuleName(moduleName) {
|
|
return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");
|
|
}
|
|
function isBlockOrCatchScoped(declaration) {
|
|
return (getCombinedNodeFlags(declaration) & 3 /* BlockScoped */) !== 0 || isCatchClauseVariableDeclarationOrBindingElement(declaration);
|
|
}
|
|
function isCatchClauseVariableDeclarationOrBindingElement(declaration) {
|
|
const node = getRootDeclaration(declaration);
|
|
return node.kind === 257 /* VariableDeclaration */ && node.parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isAmbientModule(node) {
|
|
return isModuleDeclaration(node) && (node.name.kind === 10 /* StringLiteral */ || isGlobalScopeAugmentation(node));
|
|
}
|
|
function isModuleWithStringLiteralName(node) {
|
|
return isModuleDeclaration(node) && node.name.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isNonGlobalAmbientModule(node) {
|
|
return isModuleDeclaration(node) && isStringLiteral(node.name);
|
|
}
|
|
function isEffectiveModuleDeclaration(node) {
|
|
return isModuleDeclaration(node) || isIdentifier(node);
|
|
}
|
|
function isShorthandAmbientModuleSymbol(moduleSymbol) {
|
|
return isShorthandAmbientModule(moduleSymbol.valueDeclaration);
|
|
}
|
|
function isShorthandAmbientModule(node) {
|
|
return !!node && node.kind === 264 /* ModuleDeclaration */ && !node.body;
|
|
}
|
|
function isBlockScopedContainerTopLevel(node) {
|
|
return node.kind === 308 /* SourceFile */ || node.kind === 264 /* ModuleDeclaration */ || isFunctionLikeOrClassStaticBlockDeclaration(node);
|
|
}
|
|
function isGlobalScopeAugmentation(module2) {
|
|
return !!(module2.flags & 1024 /* GlobalAugmentation */);
|
|
}
|
|
function isExternalModuleAugmentation(node) {
|
|
return isAmbientModule(node) && isModuleAugmentationExternal(node);
|
|
}
|
|
function isModuleAugmentationExternal(node) {
|
|
switch (node.parent.kind) {
|
|
case 308 /* SourceFile */:
|
|
return isExternalModule(node.parent);
|
|
case 265 /* ModuleBlock */:
|
|
return isAmbientModule(node.parent.parent) && isSourceFile(node.parent.parent.parent) && !isExternalModule(node.parent.parent.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function getNonAugmentationDeclaration(symbol) {
|
|
var _a2;
|
|
return (_a2 = symbol.declarations) == null ? void 0 : _a2.find((d) => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));
|
|
}
|
|
function isCommonJSContainingModuleKind(kind) {
|
|
return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
|
|
}
|
|
function isEffectiveExternalModule(node, compilerOptions) {
|
|
return isExternalModule(node) || compilerOptions.isolatedModules || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
|
|
}
|
|
function isEffectiveStrictModeSourceFile(node, compilerOptions) {
|
|
switch (node.scriptKind) {
|
|
case 1 /* JS */:
|
|
case 3 /* TS */:
|
|
case 2 /* JSX */:
|
|
case 4 /* TSX */:
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (node.isDeclarationFile) {
|
|
return false;
|
|
}
|
|
if (getStrictOptionValue(compilerOptions, "alwaysStrict")) {
|
|
return true;
|
|
}
|
|
if (startsWithUseStrict(node.statements)) {
|
|
return true;
|
|
}
|
|
if (isExternalModule(node) || compilerOptions.isolatedModules) {
|
|
if (getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
|
|
return true;
|
|
}
|
|
return !compilerOptions.noImplicitUseStrict;
|
|
}
|
|
return false;
|
|
}
|
|
function isAmbientPropertyDeclaration(node) {
|
|
return !!(node.flags & 16777216 /* Ambient */) || hasSyntacticModifier(node, 2 /* Ambient */);
|
|
}
|
|
function isBlockScope(node, parentNode) {
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 266 /* CaseBlock */:
|
|
case 295 /* CatchClause */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return true;
|
|
case 238 /* Block */:
|
|
return !isFunctionLikeOrClassStaticBlockDeclaration(parentNode);
|
|
}
|
|
return false;
|
|
}
|
|
function isDeclarationWithTypeParameters(node) {
|
|
switch (node.kind) {
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 326 /* JSDocSignature */:
|
|
return true;
|
|
default:
|
|
assertType(node);
|
|
return isDeclarationWithTypeParameterChildren(node);
|
|
}
|
|
}
|
|
function isDeclarationWithTypeParameterChildren(node) {
|
|
switch (node.kind) {
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 347 /* JSDocTemplateTag */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
default:
|
|
assertType(node);
|
|
return false;
|
|
}
|
|
}
|
|
function isAnyImportSyntax(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isAnyImportOrBareOrAccessedRequire(node) {
|
|
return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);
|
|
}
|
|
function isLateVisibilityPaintedStatement(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function hasPossibleExternalModuleReference(node) {
|
|
return isAnyImportOrReExport(node) || isModuleDeclaration(node) || isImportTypeNode(node) || isImportCall(node);
|
|
}
|
|
function isAnyImportOrReExport(node) {
|
|
return isAnyImportSyntax(node) || isExportDeclaration(node);
|
|
}
|
|
function getEnclosingBlockScopeContainer(node) {
|
|
return findAncestor(node.parent, (current) => isBlockScope(current, current.parent));
|
|
}
|
|
function forEachEnclosingBlockScopeContainer(node, cb) {
|
|
let container = getEnclosingBlockScopeContainer(node);
|
|
while (container) {
|
|
cb(container);
|
|
container = getEnclosingBlockScopeContainer(container);
|
|
}
|
|
}
|
|
function declarationNameToString(name) {
|
|
return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
|
|
}
|
|
function getNameFromIndexInfo(info) {
|
|
return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : void 0;
|
|
}
|
|
function isComputedNonLiteralName(name) {
|
|
return name.kind === 164 /* ComputedPropertyName */ && !isStringOrNumericLiteralLike(name.expression);
|
|
}
|
|
function tryGetTextOfPropertyName(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return name.autoGenerateFlags ? void 0 : name.escapedText;
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return escapeLeadingUnderscores(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
if (isStringOrNumericLiteralLike(name.expression))
|
|
return escapeLeadingUnderscores(name.expression.text);
|
|
return void 0;
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function getTextOfPropertyName(name) {
|
|
return Debug.checkDefined(tryGetTextOfPropertyName(name));
|
|
}
|
|
function entityNameToString(name) {
|
|
switch (name.kind) {
|
|
case 108 /* ThisKeyword */:
|
|
return "this";
|
|
case 80 /* PrivateIdentifier */:
|
|
case 79 /* Identifier */:
|
|
return getFullWidth(name) === 0 ? idText(name) : getTextOfNode(name);
|
|
case 163 /* QualifiedName */:
|
|
return entityNameToString(name.left) + "." + entityNameToString(name.right);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (isIdentifier(name.name) || isPrivateIdentifier(name.name)) {
|
|
return entityNameToString(name.expression) + "." + entityNameToString(name.name);
|
|
} else {
|
|
return Debug.assertNever(name.name);
|
|
}
|
|
case 314 /* JSDocMemberName */:
|
|
return entityNameToString(name.left) + entityNameToString(name.right);
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
|
|
const start2 = skipTrivia(sourceFile.text, nodes.pos);
|
|
return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
|
|
const span = getErrorSpanForNode(sourceFile, node);
|
|
return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const span = getErrorSpanForNode(sourceFile, node);
|
|
return createFileDiagnosticFromMessageChain(sourceFile, span.start, span.length, messageChain, relatedInformation);
|
|
}
|
|
function assertDiagnosticLocation(file, start2, length2) {
|
|
Debug.assertGreaterThanOrEqual(start2, 0);
|
|
Debug.assertGreaterThanOrEqual(length2, 0);
|
|
if (file) {
|
|
Debug.assertLessThanOrEqual(start2, file.text.length);
|
|
Debug.assertLessThanOrEqual(start2 + length2, file.text.length);
|
|
}
|
|
}
|
|
function createFileDiagnosticFromMessageChain(file, start2, length2, messageChain, relatedInformation) {
|
|
assertDiagnosticLocation(file, start2, length2);
|
|
return {
|
|
file,
|
|
start: start2,
|
|
length: length2,
|
|
code: messageChain.code,
|
|
category: messageChain.category,
|
|
messageText: messageChain.next ? messageChain : messageChain.messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
function createDiagnosticForFileFromMessageChain(sourceFile, messageChain, relatedInformation) {
|
|
return {
|
|
file: sourceFile,
|
|
start: 0,
|
|
length: 0,
|
|
code: messageChain.code,
|
|
category: messageChain.category,
|
|
messageText: messageChain.next ? messageChain : messageChain.messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
function createDiagnosticMessageChainFromDiagnostic(diagnostic) {
|
|
return typeof diagnostic.messageText === "string" ? {
|
|
code: diagnostic.code,
|
|
category: diagnostic.category,
|
|
messageText: diagnostic.messageText,
|
|
next: diagnostic.next
|
|
} : diagnostic.messageText;
|
|
}
|
|
function createDiagnosticForRange(sourceFile, range, message) {
|
|
return {
|
|
file: sourceFile,
|
|
start: range.pos,
|
|
length: range.end - range.pos,
|
|
code: message.code,
|
|
category: message.category,
|
|
messageText: message.message
|
|
};
|
|
}
|
|
function getSpanOfTokenAtPosition(sourceFile, pos) {
|
|
const scanner2 = createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, void 0, pos);
|
|
scanner2.scan();
|
|
const start2 = scanner2.getTokenPos();
|
|
return createTextSpanFromBounds(start2, scanner2.getTextPos());
|
|
}
|
|
function getErrorSpanForArrowFunction(sourceFile, node) {
|
|
const pos = skipTrivia(sourceFile.text, node.pos);
|
|
if (node.body && node.body.kind === 238 /* Block */) {
|
|
const { line: startLine } = getLineAndCharacterOfPosition(sourceFile, node.body.pos);
|
|
const { line: endLine } = getLineAndCharacterOfPosition(sourceFile, node.body.end);
|
|
if (startLine < endLine) {
|
|
return createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1);
|
|
}
|
|
}
|
|
return createTextSpanFromBounds(pos, node.end);
|
|
}
|
|
function getErrorSpanForNode(sourceFile, node) {
|
|
let errorNode = node;
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
const pos2 = skipTrivia(sourceFile.text, 0, false);
|
|
if (pos2 === sourceFile.text.length) {
|
|
return createTextSpan(0, 0);
|
|
}
|
|
return getSpanOfTokenAtPosition(sourceFile, pos2);
|
|
case 257 /* VariableDeclaration */:
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 271 /* NamespaceImport */:
|
|
errorNode = node.name;
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
return getErrorSpanForArrowFunction(sourceFile, node);
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
const start2 = skipTrivia(sourceFile.text, node.pos);
|
|
const end = node.statements.length > 0 ? node.statements[0].pos : node.end;
|
|
return createTextSpanFromBounds(start2, end);
|
|
}
|
|
if (errorNode === void 0) {
|
|
return getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
}
|
|
Debug.assert(!isJSDoc(errorNode));
|
|
const isMissing = nodeIsMissing(errorNode);
|
|
const pos = isMissing || isJsxText(node) ? errorNode.pos : skipTrivia(sourceFile.text, errorNode.pos);
|
|
if (isMissing) {
|
|
Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
} else {
|
|
Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809");
|
|
}
|
|
return createTextSpanFromBounds(pos, errorNode.end);
|
|
}
|
|
function isExternalOrCommonJsModule(file) {
|
|
return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== void 0;
|
|
}
|
|
function isJsonSourceFile(file) {
|
|
return file.scriptKind === 6 /* JSON */;
|
|
}
|
|
function isEnumConst(node) {
|
|
return !!(getCombinedModifierFlags(node) & 2048 /* Const */);
|
|
}
|
|
function isDeclarationReadonly(declaration) {
|
|
return !!(getCombinedModifierFlags(declaration) & 64 /* Readonly */ && !isParameterPropertyDeclaration(declaration, declaration.parent));
|
|
}
|
|
function isVarConst(node) {
|
|
return !!(getCombinedNodeFlags(node) & 2 /* Const */);
|
|
}
|
|
function isLet(node) {
|
|
return !!(getCombinedNodeFlags(node) & 1 /* Let */);
|
|
}
|
|
function isSuperCall(n) {
|
|
return n.kind === 210 /* CallExpression */ && n.expression.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isImportCall(n) {
|
|
return n.kind === 210 /* CallExpression */ && n.expression.kind === 100 /* ImportKeyword */;
|
|
}
|
|
function isImportMeta(n) {
|
|
return isMetaProperty(n) && n.keywordToken === 100 /* ImportKeyword */ && n.name.escapedText === "meta";
|
|
}
|
|
function isLiteralImportTypeNode(n) {
|
|
return isImportTypeNode(n) && isLiteralTypeNode(n.argument) && isStringLiteral(n.argument.literal);
|
|
}
|
|
function isPrologueDirective(node) {
|
|
return node.kind === 241 /* ExpressionStatement */ && node.expression.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isCustomPrologue(node) {
|
|
return !!(getEmitFlags(node) & 2097152 /* CustomPrologue */);
|
|
}
|
|
function isHoistedFunction(node) {
|
|
return isCustomPrologue(node) && isFunctionDeclaration(node);
|
|
}
|
|
function isHoistedVariable(node) {
|
|
return isIdentifier(node.name) && !node.initializer;
|
|
}
|
|
function isHoistedVariableStatement(node) {
|
|
return isCustomPrologue(node) && isVariableStatement(node) && every(node.declarationList.declarations, isHoistedVariable);
|
|
}
|
|
function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
|
|
return node.kind !== 11 /* JsxText */ ? getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : void 0;
|
|
}
|
|
function getJSDocCommentRanges(node, text) {
|
|
const commentRanges = node.kind === 166 /* Parameter */ || node.kind === 165 /* TypeParameter */ || node.kind === 215 /* FunctionExpression */ || node.kind === 216 /* ArrowFunction */ || node.kind === 214 /* ParenthesizedExpression */ || node.kind === 257 /* VariableDeclaration */ || node.kind === 278 /* ExportSpecifier */ ? concatenate(getTrailingCommentRanges(text, node.pos), getLeadingCommentRanges(text, node.pos)) : getLeadingCommentRanges(text, node.pos);
|
|
return filter(commentRanges, (comment) => text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
|
|
}
|
|
var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
|
|
var defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)(('[^']*')|("[^"]*"))\s*\/>/;
|
|
function isPartOfTypeNode(node) {
|
|
if (179 /* FirstTypeNode */ <= node.kind && node.kind <= 202 /* LastTypeNode */) {
|
|
return true;
|
|
}
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
return true;
|
|
case 114 /* VoidKeyword */:
|
|
return node.parent.kind !== 219 /* VoidExpression */;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
|
|
case 165 /* TypeParameter */:
|
|
return node.parent.kind === 197 /* MappedType */ || node.parent.kind === 192 /* InferType */;
|
|
case 79 /* Identifier */:
|
|
if (node.parent.kind === 163 /* QualifiedName */ && node.parent.right === node) {
|
|
node = node.parent;
|
|
} else if (node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.name === node) {
|
|
node = node.parent;
|
|
}
|
|
Debug.assert(
|
|
node.kind === 79 /* Identifier */ || node.kind === 163 /* QualifiedName */ || node.kind === 208 /* PropertyAccessExpression */,
|
|
"'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."
|
|
);
|
|
case 163 /* QualifiedName */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 108 /* ThisKeyword */: {
|
|
const { parent: parent2 } = node;
|
|
if (parent2.kind === 183 /* TypeQuery */) {
|
|
return false;
|
|
}
|
|
if (parent2.kind === 202 /* ImportType */) {
|
|
return !parent2.isTypeOf;
|
|
}
|
|
if (179 /* FirstTypeNode */ <= parent2.kind && parent2.kind <= 202 /* LastTypeNode */) {
|
|
return true;
|
|
}
|
|
switch (parent2.kind) {
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isHeritageClause(parent2.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent2);
|
|
case 165 /* TypeParameter */:
|
|
return node === parent2.constraint;
|
|
case 347 /* JSDocTemplateTag */:
|
|
return node === parent2.constraint;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 166 /* Parameter */:
|
|
case 257 /* VariableDeclaration */:
|
|
return node === parent2.type;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return node === parent2.type;
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return node === parent2.type;
|
|
case 213 /* TypeAssertionExpression */:
|
|
return node === parent2.type;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return contains(parent2.typeArguments, node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isChildOfNodeWithKind(node, kind) {
|
|
while (node) {
|
|
if (node.kind === kind) {
|
|
return true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function forEachReturnStatement(body, visitor) {
|
|
return traverse(body);
|
|
function traverse(node) {
|
|
switch (node.kind) {
|
|
case 250 /* ReturnStatement */:
|
|
return visitor(node);
|
|
case 266 /* CaseBlock */:
|
|
case 238 /* Block */:
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 253 /* LabeledStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 295 /* CatchClause */:
|
|
return forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
function forEachYieldExpression(body, visitor) {
|
|
return traverse(body);
|
|
function traverse(node) {
|
|
switch (node.kind) {
|
|
case 226 /* YieldExpression */:
|
|
visitor(node);
|
|
const operand = node.expression;
|
|
if (operand) {
|
|
traverse(operand);
|
|
}
|
|
return;
|
|
case 263 /* EnumDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return;
|
|
default:
|
|
if (isFunctionLike(node)) {
|
|
if (node.name && node.name.kind === 164 /* ComputedPropertyName */) {
|
|
traverse(node.name.expression);
|
|
return;
|
|
}
|
|
} else if (!isPartOfTypeNode(node)) {
|
|
forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getRestParameterElementType(node) {
|
|
if (node && node.kind === 185 /* ArrayType */) {
|
|
return node.elementType;
|
|
} else if (node && node.kind === 180 /* TypeReference */) {
|
|
return singleOrUndefined(node.typeArguments);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
function getMembersOfDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 184 /* TypeLiteral */:
|
|
return node.members;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return node.properties;
|
|
}
|
|
}
|
|
function isVariableLike(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 302 /* EnumMember */:
|
|
case 166 /* Parameter */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 257 /* VariableDeclaration */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isVariableLikeOrAccessor(node) {
|
|
return isVariableLike(node) || isAccessor(node);
|
|
}
|
|
function isVariableDeclarationInVariableStatement(node) {
|
|
return node.parent.kind === 258 /* VariableDeclarationList */ && node.parent.parent.kind === 240 /* VariableStatement */;
|
|
}
|
|
function isCommonJsExportedExpression(node) {
|
|
if (!isInJSFile(node))
|
|
return false;
|
|
return isObjectLiteralExpression(node.parent) && isBinaryExpression(node.parent.parent) && getAssignmentDeclarationKind(node.parent.parent) === 2 /* ModuleExports */ || isCommonJsExportPropertyAssignment(node.parent);
|
|
}
|
|
function isCommonJsExportPropertyAssignment(node) {
|
|
if (!isInJSFile(node))
|
|
return false;
|
|
return isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 1 /* ExportsProperty */;
|
|
}
|
|
function isValidESSymbolDeclaration(node) {
|
|
return (isVariableDeclaration(node) ? isVarConst(node) && isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) : isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) : isPropertySignature(node) && hasEffectiveReadonlyModifier(node)) || isCommonJsExportPropertyAssignment(node);
|
|
}
|
|
function introducesArgumentsExoticObject(node) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function unwrapInnermostStatementOfLabel(node, beforeUnwrapLabelCallback) {
|
|
while (true) {
|
|
if (beforeUnwrapLabelCallback) {
|
|
beforeUnwrapLabelCallback(node);
|
|
}
|
|
if (node.statement.kind !== 253 /* LabeledStatement */) {
|
|
return node.statement;
|
|
}
|
|
node = node.statement;
|
|
}
|
|
}
|
|
function isFunctionBlock(node) {
|
|
return node && node.kind === 238 /* Block */ && isFunctionLike(node.parent);
|
|
}
|
|
function isObjectLiteralMethod(node) {
|
|
return node && node.kind === 171 /* MethodDeclaration */ && node.parent.kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
|
|
return (node.kind === 171 /* MethodDeclaration */ || node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */) && (node.parent.kind === 207 /* ObjectLiteralExpression */ || node.parent.kind === 228 /* ClassExpression */);
|
|
}
|
|
function isIdentifierTypePredicate(predicate) {
|
|
return predicate && predicate.kind === 1 /* Identifier */;
|
|
}
|
|
function isThisTypePredicate(predicate) {
|
|
return predicate && predicate.kind === 0 /* This */;
|
|
}
|
|
function getPropertyAssignment(objectLiteral, key, key2) {
|
|
return objectLiteral.properties.filter((property) => {
|
|
if (property.kind === 299 /* PropertyAssignment */) {
|
|
const propName = tryGetTextOfPropertyName(property.name);
|
|
return key === propName || !!key2 && key2 === propName;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
|
|
return firstDefined(getPropertyAssignment(objectLiteral, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
|
|
}
|
|
function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
|
|
if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
|
|
const expression = tsConfigSourceFile.statements[0].expression;
|
|
return tryCast(expression, isObjectLiteralExpression);
|
|
}
|
|
}
|
|
function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
|
|
return firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
|
|
}
|
|
function getTsConfigPropArray(tsConfigSourceFile, propKey) {
|
|
const jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile);
|
|
return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : emptyArray;
|
|
}
|
|
function getContainingFunction(node) {
|
|
return findAncestor(node.parent, isFunctionLike);
|
|
}
|
|
function getContainingFunctionDeclaration(node) {
|
|
return findAncestor(node.parent, isFunctionLikeDeclaration);
|
|
}
|
|
function getContainingClass(node) {
|
|
return findAncestor(node.parent, isClassLike);
|
|
}
|
|
function getContainingClassStaticBlock(node) {
|
|
return findAncestor(node.parent, (n) => {
|
|
if (isClassLike(n) || isFunctionLike(n)) {
|
|
return "quit";
|
|
}
|
|
return isClassStaticBlockDeclaration(n);
|
|
});
|
|
}
|
|
function getContainingFunctionOrClassStaticBlock(node) {
|
|
return findAncestor(node.parent, isFunctionLikeOrClassStaticBlockDeclaration);
|
|
}
|
|
function getThisContainer(node, includeArrowFunctions) {
|
|
Debug.assert(node.kind !== 308 /* SourceFile */);
|
|
while (true) {
|
|
node = node.parent;
|
|
if (!node) {
|
|
return Debug.fail();
|
|
}
|
|
switch (node.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
if (isClassLike(node.parent.parent)) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
break;
|
|
case 167 /* Decorator */:
|
|
if (node.parent.kind === 166 /* Parameter */ && isClassElement(node.parent.parent)) {
|
|
node = node.parent.parent;
|
|
} else if (isClassElement(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
if (!includeArrowFunctions) {
|
|
continue;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 308 /* SourceFile */:
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function isThisContainerOrFunctionBlock(node) {
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
case 238 /* Block */:
|
|
switch (node.parent.kind) {
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInTopLevelContext(node) {
|
|
if (isIdentifier(node) && (isClassDeclaration(node.parent) || isFunctionDeclaration(node.parent)) && node.parent.name === node) {
|
|
node = node.parent;
|
|
}
|
|
const container = getThisContainer(node, true);
|
|
return isSourceFile(container);
|
|
}
|
|
function getNewTargetContainer(node) {
|
|
const container = getThisContainer(node, false);
|
|
if (container) {
|
|
switch (container.kind) {
|
|
case 173 /* Constructor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return container;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSuperContainer(node, stopOnFunctions) {
|
|
while (true) {
|
|
node = node.parent;
|
|
if (!node) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
node = node.parent;
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (!stopOnFunctions) {
|
|
continue;
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return node;
|
|
case 167 /* Decorator */:
|
|
if (node.parent.kind === 166 /* Parameter */ && isClassElement(node.parent.parent)) {
|
|
node = node.parent.parent;
|
|
} else if (isClassElement(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function getImmediatelyInvokedFunctionExpression(func) {
|
|
if (func.kind === 215 /* FunctionExpression */ || func.kind === 216 /* ArrowFunction */) {
|
|
let prev = func;
|
|
let parent2 = func.parent;
|
|
while (parent2.kind === 214 /* ParenthesizedExpression */) {
|
|
prev = parent2;
|
|
parent2 = parent2.parent;
|
|
}
|
|
if (parent2.kind === 210 /* CallExpression */ && parent2.expression === prev) {
|
|
return parent2;
|
|
}
|
|
}
|
|
}
|
|
function isSuperOrSuperProperty(node) {
|
|
return node.kind === 106 /* SuperKeyword */ || isSuperProperty(node);
|
|
}
|
|
function isSuperProperty(node) {
|
|
const kind = node.kind;
|
|
return (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */) && node.expression.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isThisProperty(node) {
|
|
const kind = node.kind;
|
|
return (kind === 208 /* PropertyAccessExpression */ || kind === 209 /* ElementAccessExpression */) && node.expression.kind === 108 /* ThisKeyword */;
|
|
}
|
|
function isThisInitializedDeclaration(node) {
|
|
var _a2;
|
|
return !!node && isVariableDeclaration(node) && ((_a2 = node.initializer) == null ? void 0 : _a2.kind) === 108 /* ThisKeyword */;
|
|
}
|
|
function isThisInitializedObjectBindingExpression(node) {
|
|
return !!node && (isShorthandPropertyAssignment(node) || isPropertyAssignment(node)) && isBinaryExpression(node.parent.parent) && node.parent.parent.operatorToken.kind === 63 /* EqualsToken */ && node.parent.parent.right.kind === 108 /* ThisKeyword */;
|
|
}
|
|
function getEntityNameFromTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isEntityNameExpression(node.expression) ? node.expression : void 0;
|
|
case 79 /* Identifier */:
|
|
case 163 /* QualifiedName */:
|
|
return node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getInvokedExpression(node) {
|
|
switch (node.kind) {
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return node.tag;
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return node.tagName;
|
|
default:
|
|
return node.expression;
|
|
}
|
|
}
|
|
function nodeCanBeDecorated(node, parent2, grandparent) {
|
|
if (isNamedDeclaration(node) && isPrivateIdentifier(node.name)) {
|
|
return false;
|
|
}
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
return true;
|
|
case 169 /* PropertyDeclaration */:
|
|
return parent2.kind === 260 /* ClassDeclaration */;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
return node.body !== void 0 && parent2.kind === 260 /* ClassDeclaration */;
|
|
case 166 /* Parameter */:
|
|
return parent2.body !== void 0 && (parent2.kind === 173 /* Constructor */ || parent2.kind === 171 /* MethodDeclaration */ || parent2.kind === 175 /* SetAccessor */) && grandparent.kind === 260 /* ClassDeclaration */;
|
|
}
|
|
return false;
|
|
}
|
|
function nodeIsDecorated(node, parent2, grandparent) {
|
|
return hasDecorators(node) && nodeCanBeDecorated(node, parent2, grandparent);
|
|
}
|
|
function nodeOrChildIsDecorated(node, parent2, grandparent) {
|
|
return nodeIsDecorated(node, parent2, grandparent) || childIsDecorated(node, parent2);
|
|
}
|
|
function childIsDecorated(node, parent2) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
return some(node.members, (m) => nodeOrChildIsDecorated(m, node, parent2));
|
|
case 171 /* MethodDeclaration */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
return some(node.parameters, (p) => nodeIsDecorated(p, node, parent2));
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function classOrConstructorParameterIsDecorated(node) {
|
|
if (nodeIsDecorated(node))
|
|
return true;
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
return !!constructor && childIsDecorated(constructor, node);
|
|
}
|
|
function isJSXTagName(node) {
|
|
const { parent: parent2 } = node;
|
|
if (parent2.kind === 283 /* JsxOpeningElement */ || parent2.kind === 282 /* JsxSelfClosingElement */ || parent2.kind === 284 /* JsxClosingElement */) {
|
|
return parent2.tagName === node;
|
|
}
|
|
return false;
|
|
}
|
|
function isExpressionNode(node) {
|
|
switch (node.kind) {
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 223 /* BinaryExpression */:
|
|
case 224 /* ConditionalExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 225 /* TemplateExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
case 226 /* YieldExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 233 /* MetaProperty */:
|
|
return true;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return !isHeritageClause(node.parent);
|
|
case 163 /* QualifiedName */:
|
|
while (node.parent.kind === 163 /* QualifiedName */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node);
|
|
case 314 /* JSDocMemberName */:
|
|
while (isJSDocMemberName(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 101 /* InKeyword */;
|
|
case 79 /* Identifier */:
|
|
if (node.parent.kind === 183 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node)) {
|
|
return true;
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 108 /* ThisKeyword */:
|
|
return isInExpressionContext(node);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInExpressionContext(node) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 302 /* EnumMember */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 205 /* BindingElement */:
|
|
return parent2.initializer === node;
|
|
case 241 /* ExpressionStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 250 /* ReturnStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 292 /* CaseClause */:
|
|
case 254 /* ThrowStatement */:
|
|
return parent2.expression === node;
|
|
case 245 /* ForStatement */:
|
|
const forStatement = parent2;
|
|
return forStatement.initializer === node && forStatement.initializer.kind !== 258 /* VariableDeclarationList */ || forStatement.condition === node || forStatement.incrementor === node;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
const forInStatement = parent2;
|
|
return forInStatement.initializer === node && forInStatement.initializer.kind !== 258 /* VariableDeclarationList */ || forInStatement.expression === node;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return node === parent2.expression;
|
|
case 236 /* TemplateSpan */:
|
|
return node === parent2.expression;
|
|
case 164 /* ComputedPropertyName */:
|
|
return node === parent2.expression;
|
|
case 167 /* Decorator */:
|
|
case 291 /* JsxExpression */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
case 301 /* SpreadAssignment */:
|
|
return true;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return parent2.expression === node && !isPartOfTypeNode(parent2);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return parent2.objectAssignmentInitializer === node;
|
|
case 235 /* SatisfiesExpression */:
|
|
return node === parent2.expression;
|
|
default:
|
|
return isExpressionNode(parent2);
|
|
}
|
|
}
|
|
function isPartOfTypeQuery(node) {
|
|
while (node.kind === 163 /* QualifiedName */ || node.kind === 79 /* Identifier */) {
|
|
node = node.parent;
|
|
}
|
|
return node.kind === 183 /* TypeQuery */;
|
|
}
|
|
function isNamespaceReexportDeclaration(node) {
|
|
return isNamespaceExport(node) && !!node.parent.moduleSpecifier;
|
|
}
|
|
function isExternalModuleImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 280 /* ExternalModuleReference */;
|
|
}
|
|
function getExternalModuleImportEqualsDeclarationExpression(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node));
|
|
return node.moduleReference.expression;
|
|
}
|
|
function getExternalModuleRequireArgument(node) {
|
|
return isVariableDeclarationInitializedToBareOrAccessedRequire(node) && getLeftmostAccessExpression(node.initializer).arguments[0];
|
|
}
|
|
function isInternalModuleImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind !== 280 /* ExternalModuleReference */;
|
|
}
|
|
function isSourceFileJS(file) {
|
|
return isInJSFile(file);
|
|
}
|
|
function isSourceFileNotJS(file) {
|
|
return !isInJSFile(file);
|
|
}
|
|
function isInJSFile(node) {
|
|
return !!node && !!(node.flags & 262144 /* JavaScriptFile */);
|
|
}
|
|
function isInJsonFile(node) {
|
|
return !!node && !!(node.flags & 67108864 /* JsonFile */);
|
|
}
|
|
function isSourceFileNotJson(file) {
|
|
return !isJsonSourceFile(file);
|
|
}
|
|
function isInJSDoc(node) {
|
|
return !!node && !!(node.flags & 8388608 /* JSDoc */);
|
|
}
|
|
function isJSDocIndexSignature(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && node.typeArguments && node.typeArguments.length === 2 && (node.typeArguments[0].kind === 152 /* StringKeyword */ || node.typeArguments[0].kind === 148 /* NumberKeyword */);
|
|
}
|
|
function isRequireCall(callExpression, requireStringLiteralLikeArgument) {
|
|
if (callExpression.kind !== 210 /* CallExpression */) {
|
|
return false;
|
|
}
|
|
const { expression, arguments: args } = callExpression;
|
|
if (expression.kind !== 79 /* Identifier */ || expression.escapedText !== "require") {
|
|
return false;
|
|
}
|
|
if (args.length !== 1) {
|
|
return false;
|
|
}
|
|
const arg = args[0];
|
|
return !requireStringLiteralLikeArgument || isStringLiteralLike(arg);
|
|
}
|
|
function isVariableDeclarationInitializedToRequire(node) {
|
|
return isVariableDeclarationInitializedWithRequireHelper(node, false);
|
|
}
|
|
function isVariableDeclarationInitializedToBareOrAccessedRequire(node) {
|
|
return isVariableDeclarationInitializedWithRequireHelper(node, true);
|
|
}
|
|
function isVariableDeclarationInitializedWithRequireHelper(node, allowAccessedRequire) {
|
|
return isVariableDeclaration(node) && !!node.initializer && isRequireCall(allowAccessedRequire ? getLeftmostAccessExpression(node.initializer) : node.initializer, true);
|
|
}
|
|
function isRequireVariableStatement(node) {
|
|
return isVariableStatement(node) && node.declarationList.declarations.length > 0 && every(node.declarationList.declarations, (decl) => isVariableDeclarationInitializedToRequire(decl));
|
|
}
|
|
function isSingleOrDoubleQuote(charCode) {
|
|
return charCode === 39 /* singleQuote */ || charCode === 34 /* doubleQuote */;
|
|
}
|
|
function isStringDoubleQuoted(str, sourceFile) {
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34 /* doubleQuote */;
|
|
}
|
|
function isAssignmentDeclaration(decl) {
|
|
return isBinaryExpression(decl) || isAccessExpression(decl) || isIdentifier(decl) || isCallExpression(decl);
|
|
}
|
|
function getEffectiveInitializer(node) {
|
|
if (isInJSFile(node) && node.initializer && isBinaryExpression(node.initializer) && (node.initializer.operatorToken.kind === 56 /* BarBarToken */ || node.initializer.operatorToken.kind === 60 /* QuestionQuestionToken */) && node.name && isEntityNameExpression(node.name) && isSameEntityName(node.name, node.initializer.left)) {
|
|
return node.initializer.right;
|
|
}
|
|
return node.initializer;
|
|
}
|
|
function getDeclaredExpandoInitializer(node) {
|
|
const init = getEffectiveInitializer(node);
|
|
return init && getExpandoInitializer(init, isPrototypeAccess(node.name));
|
|
}
|
|
function hasExpandoValueProperty(node, isPrototypeAssignment) {
|
|
return forEach(node.properties, (p) => isPropertyAssignment(p) && isIdentifier(p.name) && p.name.escapedText === "value" && p.initializer && getExpandoInitializer(p.initializer, isPrototypeAssignment));
|
|
}
|
|
function getAssignedExpandoInitializer(node) {
|
|
if (node && node.parent && isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const isPrototypeAssignment = isPrototypeAccess(node.parent.left);
|
|
return getExpandoInitializer(node.parent.right, isPrototypeAssignment) || getDefaultedExpandoInitializer(node.parent.left, node.parent.right, isPrototypeAssignment);
|
|
}
|
|
if (node && isCallExpression(node) && isBindableObjectDefinePropertyCall(node)) {
|
|
const result = hasExpandoValueProperty(node.arguments[2], node.arguments[1].text === "prototype");
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function getExpandoInitializer(initializer, isPrototypeAssignment) {
|
|
if (isCallExpression(initializer)) {
|
|
const e = skipParentheses(initializer.expression);
|
|
return e.kind === 215 /* FunctionExpression */ || e.kind === 216 /* ArrowFunction */ ? initializer : void 0;
|
|
}
|
|
if (initializer.kind === 215 /* FunctionExpression */ || initializer.kind === 228 /* ClassExpression */ || initializer.kind === 216 /* ArrowFunction */) {
|
|
return initializer;
|
|
}
|
|
if (isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) {
|
|
return initializer;
|
|
}
|
|
}
|
|
function getDefaultedExpandoInitializer(name, initializer, isPrototypeAssignment) {
|
|
const e = isBinaryExpression(initializer) && (initializer.operatorToken.kind === 56 /* BarBarToken */ || initializer.operatorToken.kind === 60 /* QuestionQuestionToken */) && getExpandoInitializer(initializer.right, isPrototypeAssignment);
|
|
if (e && isSameEntityName(name, initializer.left)) {
|
|
return e;
|
|
}
|
|
}
|
|
function isDefaultedExpandoInitializer(node) {
|
|
const name = isVariableDeclaration(node.parent) ? node.parent.name : isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* EqualsToken */ ? node.parent.left : void 0;
|
|
return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left);
|
|
}
|
|
function getNameOfExpando(node) {
|
|
if (isBinaryExpression(node.parent)) {
|
|
const parent2 = (node.parent.operatorToken.kind === 56 /* BarBarToken */ || node.parent.operatorToken.kind === 60 /* QuestionQuestionToken */) && isBinaryExpression(node.parent.parent) ? node.parent.parent : node.parent;
|
|
if (parent2.operatorToken.kind === 63 /* EqualsToken */ && isIdentifier(parent2.left)) {
|
|
return parent2.left;
|
|
}
|
|
} else if (isVariableDeclaration(node.parent)) {
|
|
return node.parent.name;
|
|
}
|
|
}
|
|
function isSameEntityName(name, initializer) {
|
|
if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) {
|
|
return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(initializer);
|
|
}
|
|
if (isMemberName(name) && isLiteralLikeAccess(initializer) && (initializer.expression.kind === 108 /* ThisKeyword */ || isIdentifier(initializer.expression) && (initializer.expression.escapedText === "window" || initializer.expression.escapedText === "self" || initializer.expression.escapedText === "global"))) {
|
|
return isSameEntityName(name, getNameOrArgument(initializer));
|
|
}
|
|
if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) {
|
|
return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer) && isSameEntityName(name.expression, initializer.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function getRightMostAssignedExpression(node) {
|
|
while (isAssignmentExpression(node, true)) {
|
|
node = node.right;
|
|
}
|
|
return node;
|
|
}
|
|
function isExportsIdentifier(node) {
|
|
return isIdentifier(node) && node.escapedText === "exports";
|
|
}
|
|
function isModuleIdentifier(node) {
|
|
return isIdentifier(node) && node.escapedText === "module";
|
|
}
|
|
function isModuleExportsAccessExpression(node) {
|
|
return (isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node)) && isModuleIdentifier(node.expression) && getElementOrPropertyAccessName(node) === "exports";
|
|
}
|
|
function getAssignmentDeclarationKind(expr) {
|
|
const special = getAssignmentDeclarationKindWorker(expr);
|
|
return special === 5 /* Property */ || isInJSFile(expr) ? special : 0 /* None */;
|
|
}
|
|
function isBindableObjectDefinePropertyCall(expr) {
|
|
return length(expr.arguments) === 3 && isPropertyAccessExpression(expr.expression) && isIdentifier(expr.expression.expression) && idText(expr.expression.expression) === "Object" && idText(expr.expression.name) === "defineProperty" && isStringOrNumericLiteralLike(expr.arguments[1]) && isBindableStaticNameExpression(expr.arguments[0], true);
|
|
}
|
|
function isLiteralLikeAccess(node) {
|
|
return isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node);
|
|
}
|
|
function isLiteralLikeElementAccess(node) {
|
|
return isElementAccessExpression(node) && isStringOrNumericLiteralLike(node.argumentExpression);
|
|
}
|
|
function isBindableStaticAccessExpression(node, excludeThisKeyword) {
|
|
return isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 108 /* ThisKeyword */ || isIdentifier(node.name) && isBindableStaticNameExpression(node.expression, true)) || isBindableStaticElementAccessExpression(node, excludeThisKeyword);
|
|
}
|
|
function isBindableStaticElementAccessExpression(node, excludeThisKeyword) {
|
|
return isLiteralLikeElementAccess(node) && (!excludeThisKeyword && node.expression.kind === 108 /* ThisKeyword */ || isEntityNameExpression(node.expression) || isBindableStaticAccessExpression(node.expression, true));
|
|
}
|
|
function isBindableStaticNameExpression(node, excludeThisKeyword) {
|
|
return isEntityNameExpression(node) || isBindableStaticAccessExpression(node, excludeThisKeyword);
|
|
}
|
|
function getNameOrArgument(expr) {
|
|
if (isPropertyAccessExpression(expr)) {
|
|
return expr.name;
|
|
}
|
|
return expr.argumentExpression;
|
|
}
|
|
function getAssignmentDeclarationKindWorker(expr) {
|
|
if (isCallExpression(expr)) {
|
|
if (!isBindableObjectDefinePropertyCall(expr)) {
|
|
return 0 /* None */;
|
|
}
|
|
const entityName = expr.arguments[0];
|
|
if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) {
|
|
return 8 /* ObjectDefinePropertyExports */;
|
|
}
|
|
if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") {
|
|
return 9 /* ObjectDefinePrototypeProperty */;
|
|
}
|
|
return 7 /* ObjectDefinePropertyValue */;
|
|
}
|
|
if (expr.operatorToken.kind !== 63 /* EqualsToken */ || !isAccessExpression(expr.left) || isVoidZero(getRightMostAssignedExpression(expr))) {
|
|
return 0 /* None */;
|
|
}
|
|
if (isBindableStaticNameExpression(expr.left.expression, true) && getElementOrPropertyAccessName(expr.left) === "prototype" && isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) {
|
|
return 6 /* Prototype */;
|
|
}
|
|
return getAssignmentDeclarationPropertyAccessKind(expr.left);
|
|
}
|
|
function isVoidZero(node) {
|
|
return isVoidExpression(node) && isNumericLiteral(node.expression) && node.expression.text === "0";
|
|
}
|
|
function getElementOrPropertyAccessArgumentExpressionOrName(node) {
|
|
if (isPropertyAccessExpression(node)) {
|
|
return node.name;
|
|
}
|
|
const arg = skipParentheses(node.argumentExpression);
|
|
if (isNumericLiteral(arg) || isStringLiteralLike(arg)) {
|
|
return arg;
|
|
}
|
|
return node;
|
|
}
|
|
function getElementOrPropertyAccessName(node) {
|
|
const name = getElementOrPropertyAccessArgumentExpressionOrName(node);
|
|
if (name) {
|
|
if (isIdentifier(name)) {
|
|
return name.escapedText;
|
|
}
|
|
if (isStringLiteralLike(name) || isNumericLiteral(name)) {
|
|
return escapeLeadingUnderscores(name.text);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAssignmentDeclarationPropertyAccessKind(lhs) {
|
|
if (lhs.expression.kind === 108 /* ThisKeyword */) {
|
|
return 4 /* ThisProperty */;
|
|
} else if (isModuleExportsAccessExpression(lhs)) {
|
|
return 2 /* ModuleExports */;
|
|
} else if (isBindableStaticNameExpression(lhs.expression, true)) {
|
|
if (isPrototypeAccess(lhs.expression)) {
|
|
return 3 /* PrototypeProperty */;
|
|
}
|
|
let nextToLast = lhs;
|
|
while (!isIdentifier(nextToLast.expression)) {
|
|
nextToLast = nextToLast.expression;
|
|
}
|
|
const id = nextToLast.expression;
|
|
if ((id.escapedText === "exports" || id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") && isBindableStaticAccessExpression(lhs)) {
|
|
return 1 /* ExportsProperty */;
|
|
}
|
|
if (isBindableStaticNameExpression(lhs, true) || isElementAccessExpression(lhs) && isDynamicName(lhs)) {
|
|
return 5 /* Property */;
|
|
}
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function getInitializerOfBinaryExpression(expr) {
|
|
while (isBinaryExpression(expr.right)) {
|
|
expr = expr.right;
|
|
}
|
|
return expr.right;
|
|
}
|
|
function isPrototypePropertyAssignment(node) {
|
|
return isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 3 /* PrototypeProperty */;
|
|
}
|
|
function isSpecialPropertyDeclaration(expr) {
|
|
return isInJSFile(expr) && expr.parent && expr.parent.kind === 241 /* ExpressionStatement */ && (!isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) && !!getJSDocTypeTag(expr.parent);
|
|
}
|
|
function setValueDeclaration(symbol, node) {
|
|
const { valueDeclaration } = symbol;
|
|
if (!valueDeclaration || !(node.flags & 16777216 /* Ambient */ && !(valueDeclaration.flags & 16777216 /* Ambient */)) && (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) || valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration)) {
|
|
symbol.valueDeclaration = node;
|
|
}
|
|
}
|
|
function isFunctionSymbol(symbol) {
|
|
if (!symbol || !symbol.valueDeclaration) {
|
|
return false;
|
|
}
|
|
const decl = symbol.valueDeclaration;
|
|
return decl.kind === 259 /* FunctionDeclaration */ || isVariableDeclaration(decl) && decl.initializer && isFunctionLike(decl.initializer);
|
|
}
|
|
function tryGetModuleSpecifierFromDeclaration(node) {
|
|
var _a2, _b;
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return (_a2 = findAncestor(node.initializer, (node2) => isRequireCall(node2, true))) == null ? void 0 : _a2.arguments[0];
|
|
case 269 /* ImportDeclaration */:
|
|
return tryCast(node.moduleSpecifier, isStringLiteralLike);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return tryCast((_b = tryCast(node.moduleReference, isExternalModuleReference)) == null ? void 0 : _b.expression, isStringLiteralLike);
|
|
default:
|
|
Debug.assertNever(node);
|
|
}
|
|
}
|
|
function importFromModuleSpecifier(node) {
|
|
return tryGetImportFromModuleSpecifier(node) || Debug.failBadSyntaxKind(node.parent);
|
|
}
|
|
function tryGetImportFromModuleSpecifier(node) {
|
|
switch (node.parent.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
return node.parent;
|
|
case 280 /* ExternalModuleReference */:
|
|
return node.parent.parent;
|
|
case 210 /* CallExpression */:
|
|
return isImportCall(node.parent) || isRequireCall(node.parent, false) ? node.parent : void 0;
|
|
case 198 /* LiteralType */:
|
|
Debug.assert(isStringLiteral(node));
|
|
return tryCast(node.parent.parent, isImportTypeNode);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getExternalModuleName(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
return node.moduleSpecifier;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.moduleReference.kind === 280 /* ExternalModuleReference */ ? node.moduleReference.expression : void 0;
|
|
case 202 /* ImportType */:
|
|
return isLiteralImportTypeNode(node) ? node.argument.literal : void 0;
|
|
case 210 /* CallExpression */:
|
|
return node.arguments[0];
|
|
case 264 /* ModuleDeclaration */:
|
|
return node.name.kind === 10 /* StringLiteral */ ? node.name : void 0;
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function getNamespaceDeclarationNode(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return node.importClause && tryCast(node.importClause.namedBindings, isNamespaceImport);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node;
|
|
case 275 /* ExportDeclaration */:
|
|
return node.exportClause && tryCast(node.exportClause, isNamespaceExport);
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function isDefaultImport(node) {
|
|
return node.kind === 269 /* ImportDeclaration */ && !!node.importClause && !!node.importClause.name;
|
|
}
|
|
function forEachImportClauseDeclaration(node, action) {
|
|
if (node.name) {
|
|
const result = action(node);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (node.namedBindings) {
|
|
const result = isNamespaceImport(node.namedBindings) ? action(node.namedBindings) : forEach(node.namedBindings.elements, action);
|
|
if (result)
|
|
return result;
|
|
}
|
|
}
|
|
function hasQuestionToken(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 166 /* Parameter */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return node.questionToken !== void 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isJSDocConstructSignature(node) {
|
|
const param = isJSDocFunctionType(node) ? firstOrUndefined(node.parameters) : void 0;
|
|
const name = tryCast(param && param.name, isIdentifier);
|
|
return !!name && name.escapedText === "new";
|
|
}
|
|
function isJSDocTypeAlias(node) {
|
|
return node.kind === 348 /* JSDocTypedefTag */ || node.kind === 341 /* JSDocCallbackTag */ || node.kind === 342 /* JSDocEnumTag */;
|
|
}
|
|
function isTypeAlias(node) {
|
|
return isJSDocTypeAlias(node) || isTypeAliasDeclaration(node);
|
|
}
|
|
function getSourceOfAssignment(node) {
|
|
return isExpressionStatement(node) && isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 63 /* EqualsToken */ ? getRightMostAssignedExpression(node.expression) : void 0;
|
|
}
|
|
function getSourceOfDefaultedAssignment(node) {
|
|
return isExpressionStatement(node) && isBinaryExpression(node.expression) && getAssignmentDeclarationKind(node.expression) !== 0 /* None */ && isBinaryExpression(node.expression.right) && (node.expression.right.operatorToken.kind === 56 /* BarBarToken */ || node.expression.right.operatorToken.kind === 60 /* QuestionQuestionToken */) ? node.expression.right.right : void 0;
|
|
}
|
|
function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
const v = getSingleVariableOfVariableStatement(node);
|
|
return v && v.initializer;
|
|
case 169 /* PropertyDeclaration */:
|
|
return node.initializer;
|
|
case 299 /* PropertyAssignment */:
|
|
return node.initializer;
|
|
}
|
|
}
|
|
function getSingleVariableOfVariableStatement(node) {
|
|
return isVariableStatement(node) ? firstOrUndefined(node.declarationList.declarations) : void 0;
|
|
}
|
|
function getNestedModuleDeclaration(node) {
|
|
return isModuleDeclaration(node) && node.body && node.body.kind === 264 /* ModuleDeclaration */ ? node.body : void 0;
|
|
}
|
|
function getJSDocCommentsAndTags(hostNode, noCache) {
|
|
let result;
|
|
if (isVariableLike(hostNode) && hasInitializer(hostNode) && hasJSDocNodes(hostNode.initializer)) {
|
|
result = addRange(result, filterOwnedJSDocTags(hostNode, last(hostNode.initializer.jsDoc)));
|
|
}
|
|
let node = hostNode;
|
|
while (node && node.parent) {
|
|
if (hasJSDocNodes(node)) {
|
|
result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
|
|
}
|
|
if (node.kind === 166 /* Parameter */) {
|
|
result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
|
|
break;
|
|
}
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
result = addRange(result, (noCache ? getJSDocTypeParameterTagsNoCache : getJSDocTypeParameterTags)(node));
|
|
break;
|
|
}
|
|
node = getNextJSDocCommentLocation(node);
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function filterOwnedJSDocTags(hostNode, jsDoc) {
|
|
if (isJSDoc(jsDoc)) {
|
|
const ownedTags = filter(jsDoc.tags, (tag) => ownsJSDocTag(hostNode, tag));
|
|
return jsDoc.tags === ownedTags ? [jsDoc] : ownedTags;
|
|
}
|
|
return ownsJSDocTag(hostNode, jsDoc) ? [jsDoc] : void 0;
|
|
}
|
|
function ownsJSDocTag(hostNode, tag) {
|
|
return !isJSDocTypeTag(tag) || !tag.parent || !isJSDoc(tag.parent) || !isParenthesizedExpression(tag.parent.parent) || tag.parent.parent === hostNode;
|
|
}
|
|
function getNextJSDocCommentLocation(node) {
|
|
const parent2 = node.parent;
|
|
if (parent2.kind === 299 /* PropertyAssignment */ || parent2.kind === 274 /* ExportAssignment */ || parent2.kind === 169 /* PropertyDeclaration */ || parent2.kind === 241 /* ExpressionStatement */ && node.kind === 208 /* PropertyAccessExpression */ || parent2.kind === 250 /* ReturnStatement */ || getNestedModuleDeclaration(parent2) || isBinaryExpression(node) && node.operatorToken.kind === 63 /* EqualsToken */) {
|
|
return parent2;
|
|
} else if (parent2.parent && (getSingleVariableOfVariableStatement(parent2.parent) === node || isBinaryExpression(parent2) && parent2.operatorToken.kind === 63 /* EqualsToken */)) {
|
|
return parent2.parent;
|
|
} else if (parent2.parent && parent2.parent.parent && (getSingleVariableOfVariableStatement(parent2.parent.parent) || getSingleInitializerOfVariableStatementOrPropertyDeclaration(parent2.parent.parent) === node || getSourceOfDefaultedAssignment(parent2.parent.parent))) {
|
|
return parent2.parent.parent;
|
|
}
|
|
}
|
|
function getParameterSymbolFromJSDoc(node) {
|
|
if (node.symbol) {
|
|
return node.symbol;
|
|
}
|
|
if (!isIdentifier(node.name)) {
|
|
return void 0;
|
|
}
|
|
const name = node.name.escapedText;
|
|
const decl = getHostSignatureFromJSDoc(node);
|
|
if (!decl) {
|
|
return void 0;
|
|
}
|
|
const parameter = find(decl.parameters, (p) => p.name.kind === 79 /* Identifier */ && p.name.escapedText === name);
|
|
return parameter && parameter.symbol;
|
|
}
|
|
function getEffectiveContainerForJSDocTemplateTag(node) {
|
|
if (isJSDoc(node.parent) && node.parent.tags) {
|
|
const typeAlias = find(node.parent.tags, isJSDocTypeAlias);
|
|
if (typeAlias) {
|
|
return typeAlias;
|
|
}
|
|
}
|
|
return getHostSignatureFromJSDoc(node);
|
|
}
|
|
function getHostSignatureFromJSDoc(node) {
|
|
const host = getEffectiveJSDocHost(node);
|
|
if (host) {
|
|
return isPropertySignature(host) && host.type && isFunctionLike(host.type) ? host.type : isFunctionLike(host) ? host : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getEffectiveJSDocHost(node) {
|
|
const host = getJSDocHost(node);
|
|
if (host) {
|
|
return getSourceOfDefaultedAssignment(host) || getSourceOfAssignment(host) || getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) || getSingleVariableOfVariableStatement(host) || getNestedModuleDeclaration(host) || host;
|
|
}
|
|
}
|
|
function getJSDocHost(node) {
|
|
const jsDoc = getJSDocRoot(node);
|
|
if (!jsDoc) {
|
|
return void 0;
|
|
}
|
|
const host = jsDoc.parent;
|
|
if (host && host.jsDoc && jsDoc === lastOrUndefined(host.jsDoc)) {
|
|
return host;
|
|
}
|
|
}
|
|
function getJSDocRoot(node) {
|
|
return findAncestor(node.parent, isJSDoc);
|
|
}
|
|
function getTypeParameterFromJsDoc(node) {
|
|
const name = node.name.escapedText;
|
|
const { typeParameters } = node.parent.parent.parent;
|
|
return typeParameters && find(typeParameters, (p) => p.name.escapedText === name);
|
|
}
|
|
function hasTypeArguments(node) {
|
|
return !!node.typeArguments;
|
|
}
|
|
var AssignmentKind = /* @__PURE__ */ ((AssignmentKind2) => {
|
|
AssignmentKind2[AssignmentKind2["None"] = 0] = "None";
|
|
AssignmentKind2[AssignmentKind2["Definite"] = 1] = "Definite";
|
|
AssignmentKind2[AssignmentKind2["Compound"] = 2] = "Compound";
|
|
return AssignmentKind2;
|
|
})(AssignmentKind || {});
|
|
function getAssignmentTargetKind(node) {
|
|
let parent2 = node.parent;
|
|
while (true) {
|
|
switch (parent2.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
const binaryOperator = parent2.operatorToken.kind;
|
|
return isAssignmentOperator(binaryOperator) && parent2.left === node ? binaryOperator === 63 /* EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 /* Definite */ : 2 /* Compound */ : 0 /* None */;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
const unaryOperator = parent2.operator;
|
|
return unaryOperator === 45 /* PlusPlusToken */ || unaryOperator === 46 /* MinusMinusToken */ ? 2 /* Compound */ : 0 /* None */;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return parent2.initializer === node ? 1 /* Definite */ : 0 /* None */;
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 227 /* SpreadElement */:
|
|
case 232 /* NonNullExpression */:
|
|
node = parent2;
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
node = parent2.parent;
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (parent2.name !== node) {
|
|
return 0 /* None */;
|
|
}
|
|
node = parent2.parent;
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
if (parent2.name === node) {
|
|
return 0 /* None */;
|
|
}
|
|
node = parent2.parent;
|
|
break;
|
|
default:
|
|
return 0 /* None */;
|
|
}
|
|
parent2 = node.parent;
|
|
}
|
|
}
|
|
function isAssignmentTarget(node) {
|
|
return getAssignmentTargetKind(node) !== 0 /* None */;
|
|
}
|
|
function isNodeWithPossibleHoistedDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 240 /* VariableStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 266 /* CaseBlock */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 253 /* LabeledStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 295 /* CatchClause */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isValueSignatureDeclaration(node) {
|
|
return isFunctionExpression(node) || isArrowFunction(node) || isMethodOrAccessor(node) || isFunctionDeclaration(node) || isConstructorDeclaration(node);
|
|
}
|
|
function walkUp(node, kind) {
|
|
while (node && node.kind === kind) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function walkUpParenthesizedTypes(node) {
|
|
return walkUp(node, 193 /* ParenthesizedType */);
|
|
}
|
|
function walkUpParenthesizedExpressions(node) {
|
|
return walkUp(node, 214 /* ParenthesizedExpression */);
|
|
}
|
|
function walkUpParenthesizedTypesAndGetParentAndChild(node) {
|
|
let child;
|
|
while (node && node.kind === 193 /* ParenthesizedType */) {
|
|
child = node;
|
|
node = node.parent;
|
|
}
|
|
return [child, node];
|
|
}
|
|
function skipTypeParentheses(node) {
|
|
while (isParenthesizedTypeNode(node))
|
|
node = node.type;
|
|
return node;
|
|
}
|
|
function skipParentheses(node, excludeJSDocTypeAssertions) {
|
|
const flags = excludeJSDocTypeAssertions ? 1 /* Parentheses */ | 16 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */;
|
|
return skipOuterExpressions(node, flags);
|
|
}
|
|
function isDeleteTarget(node) {
|
|
if (node.kind !== 208 /* PropertyAccessExpression */ && node.kind !== 209 /* ElementAccessExpression */) {
|
|
return false;
|
|
}
|
|
node = walkUpParenthesizedExpressions(node.parent);
|
|
return node && node.kind === 217 /* DeleteExpression */;
|
|
}
|
|
function isNodeDescendantOf(node, ancestor) {
|
|
while (node) {
|
|
if (node === ancestor)
|
|
return true;
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function isDeclarationName(name) {
|
|
return !isSourceFile(name) && !isBindingPattern(name) && isDeclaration(name.parent) && name.parent.name === name;
|
|
}
|
|
function getDeclarationFromName(name) {
|
|
const parent2 = name.parent;
|
|
switch (name.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
if (isComputedPropertyName(parent2))
|
|
return parent2.parent;
|
|
case 79 /* Identifier */:
|
|
if (isDeclaration(parent2)) {
|
|
return parent2.name === name ? parent2 : void 0;
|
|
} else if (isQualifiedName(parent2)) {
|
|
const tag = parent2.parent;
|
|
return isJSDocParameterTag(tag) && tag.name === parent2 ? tag : void 0;
|
|
} else {
|
|
const binExp = parent2.parent;
|
|
return isBinaryExpression(binExp) && getAssignmentDeclarationKind(binExp) !== 0 /* None */ && (binExp.left.symbol || binExp.symbol) && getNameOfDeclaration(binExp) === name ? binExp : void 0;
|
|
}
|
|
case 80 /* PrivateIdentifier */:
|
|
return isDeclaration(parent2) && parent2.name === name ? parent2 : void 0;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function isLiteralComputedPropertyDeclarationName(node) {
|
|
return isStringOrNumericLiteralLike(node) && node.parent.kind === 164 /* ComputedPropertyName */ && isDeclaration(node.parent.parent);
|
|
}
|
|
function isIdentifierName(node) {
|
|
const parent2 = node.parent;
|
|
switch (parent2.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 302 /* EnumMember */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return parent2.name === node;
|
|
case 163 /* QualifiedName */:
|
|
return parent2.right === node;
|
|
case 205 /* BindingElement */:
|
|
case 273 /* ImportSpecifier */:
|
|
return parent2.propertyName === node;
|
|
case 278 /* ExportSpecifier */:
|
|
case 288 /* JsxAttribute */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isAliasSymbolDeclaration(node) {
|
|
if (node.kind === 268 /* ImportEqualsDeclaration */ || node.kind === 267 /* NamespaceExportDeclaration */ || node.kind === 270 /* ImportClause */ && !!node.name || node.kind === 271 /* NamespaceImport */ || node.kind === 277 /* NamespaceExport */ || node.kind === 273 /* ImportSpecifier */ || node.kind === 278 /* ExportSpecifier */ || node.kind === 274 /* ExportAssignment */ && exportAssignmentIsAlias(node)) {
|
|
return true;
|
|
}
|
|
return isInJSFile(node) && (isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) || isPropertyAccessExpression(node) && isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableExpression(node.parent.right));
|
|
}
|
|
function getAliasDeclarationFromName(node) {
|
|
switch (node.parent.kind) {
|
|
case 270 /* ImportClause */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 271 /* NamespaceImport */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 274 /* ExportAssignment */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 277 /* NamespaceExport */:
|
|
return node.parent;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.parent;
|
|
} while (node.parent.kind === 163 /* QualifiedName */);
|
|
return getAliasDeclarationFromName(node);
|
|
}
|
|
}
|
|
function isAliasableExpression(e) {
|
|
return isEntityNameExpression(e) || isClassExpression(e);
|
|
}
|
|
function exportAssignmentIsAlias(node) {
|
|
const e = getExportAssignmentExpression(node);
|
|
return isAliasableExpression(e);
|
|
}
|
|
function getExportAssignmentExpression(node) {
|
|
return isExportAssignment(node) ? node.expression : node.right;
|
|
}
|
|
function getPropertyAssignmentAliasLikeExpression(node) {
|
|
return node.kind === 300 /* ShorthandPropertyAssignment */ ? node.name : node.kind === 299 /* PropertyAssignment */ ? node.initializer : node.parent.right;
|
|
}
|
|
function getEffectiveBaseTypeNode(node) {
|
|
const baseType = getClassExtendsHeritageElement(node);
|
|
if (baseType && isInJSFile(node)) {
|
|
const tag = getJSDocAugmentsTag(node);
|
|
if (tag) {
|
|
return tag.class;
|
|
}
|
|
}
|
|
return baseType;
|
|
}
|
|
function getClassExtendsHeritageElement(node) {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 94 /* ExtendsKeyword */);
|
|
return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : void 0;
|
|
}
|
|
function getEffectiveImplementsTypeNodes(node) {
|
|
if (isInJSFile(node)) {
|
|
return getJSDocImplementsTags(node).map((n) => n.class);
|
|
} else {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 117 /* ImplementsKeyword */);
|
|
return heritageClause == null ? void 0 : heritageClause.types;
|
|
}
|
|
}
|
|
function getAllSuperTypeNodes(node) {
|
|
return isInterfaceDeclaration(node) ? getInterfaceBaseTypeNodes(node) || emptyArray : isClassLike(node) ? concatenate(singleElementArray(getEffectiveBaseTypeNode(node)), getEffectiveImplementsTypeNodes(node)) || emptyArray : emptyArray;
|
|
}
|
|
function getInterfaceBaseTypeNodes(node) {
|
|
const heritageClause = getHeritageClause(node.heritageClauses, 94 /* ExtendsKeyword */);
|
|
return heritageClause ? heritageClause.types : void 0;
|
|
}
|
|
function getHeritageClause(clauses, kind) {
|
|
if (clauses) {
|
|
for (const clause of clauses) {
|
|
if (clause.token === kind) {
|
|
return clause;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAncestor(node, kind) {
|
|
while (node) {
|
|
if (node.kind === kind) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isKeyword(token) {
|
|
return 81 /* FirstKeyword */ <= token && token <= 162 /* LastKeyword */;
|
|
}
|
|
function isContextualKeyword(token) {
|
|
return 126 /* FirstContextualKeyword */ <= token && token <= 162 /* LastContextualKeyword */;
|
|
}
|
|
function isNonContextualKeyword(token) {
|
|
return isKeyword(token) && !isContextualKeyword(token);
|
|
}
|
|
function isFutureReservedKeyword(token) {
|
|
return 117 /* FirstFutureReservedWord */ <= token && token <= 125 /* LastFutureReservedWord */;
|
|
}
|
|
function isStringANonContextualKeyword(name) {
|
|
const token = stringToToken(name);
|
|
return token !== void 0 && isNonContextualKeyword(token);
|
|
}
|
|
function isStringAKeyword(name) {
|
|
const token = stringToToken(name);
|
|
return token !== void 0 && isKeyword(token);
|
|
}
|
|
function isIdentifierANonContextualKeyword({ originalKeywordKind }) {
|
|
return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind);
|
|
}
|
|
function isTrivia(token) {
|
|
return 2 /* FirstTriviaToken */ <= token && token <= 7 /* LastTriviaToken */;
|
|
}
|
|
var FunctionFlags = /* @__PURE__ */ ((FunctionFlags2) => {
|
|
FunctionFlags2[FunctionFlags2["Normal"] = 0] = "Normal";
|
|
FunctionFlags2[FunctionFlags2["Generator"] = 1] = "Generator";
|
|
FunctionFlags2[FunctionFlags2["Async"] = 2] = "Async";
|
|
FunctionFlags2[FunctionFlags2["Invalid"] = 4] = "Invalid";
|
|
FunctionFlags2[FunctionFlags2["AsyncGenerator"] = 3] = "AsyncGenerator";
|
|
return FunctionFlags2;
|
|
})(FunctionFlags || {});
|
|
function getFunctionFlags(node) {
|
|
if (!node) {
|
|
return 4 /* Invalid */;
|
|
}
|
|
let flags = 0 /* Normal */;
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (node.asteriskToken) {
|
|
flags |= 1 /* Generator */;
|
|
}
|
|
case 216 /* ArrowFunction */:
|
|
if (hasSyntacticModifier(node, 512 /* Async */)) {
|
|
flags |= 2 /* Async */;
|
|
}
|
|
break;
|
|
}
|
|
if (!node.body) {
|
|
flags |= 4 /* Invalid */;
|
|
}
|
|
return flags;
|
|
}
|
|
function isAsyncFunction(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
return node.body !== void 0 && node.asteriskToken === void 0 && hasSyntacticModifier(node, 512 /* Async */);
|
|
}
|
|
return false;
|
|
}
|
|
function isStringOrNumericLiteralLike(node) {
|
|
return isStringLiteralLike(node) || isNumericLiteral(node);
|
|
}
|
|
function isSignedNumericLiteral(node) {
|
|
return isPrefixUnaryExpression(node) && (node.operator === 39 /* PlusToken */ || node.operator === 40 /* MinusToken */) && isNumericLiteral(node.operand);
|
|
}
|
|
function hasDynamicName(declaration) {
|
|
const name = getNameOfDeclaration(declaration);
|
|
return !!name && isDynamicName(name);
|
|
}
|
|
function isDynamicName(name) {
|
|
if (!(name.kind === 164 /* ComputedPropertyName */ || name.kind === 209 /* ElementAccessExpression */)) {
|
|
return false;
|
|
}
|
|
const expr = isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression;
|
|
return !isStringOrNumericLiteralLike(expr) && !isSignedNumericLiteral(expr);
|
|
}
|
|
function getPropertyNameForPropertyNameNode(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return name.escapedText;
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
return escapeLeadingUnderscores(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
const nameExpression = name.expression;
|
|
if (isStringOrNumericLiteralLike(nameExpression)) {
|
|
return escapeLeadingUnderscores(nameExpression.text);
|
|
} else if (isSignedNumericLiteral(nameExpression)) {
|
|
if (nameExpression.operator === 40 /* MinusToken */) {
|
|
return tokenToString(nameExpression.operator) + nameExpression.operand.text;
|
|
}
|
|
return nameExpression.operand.text;
|
|
}
|
|
return void 0;
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function isPropertyNameLiteral(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getTextOfIdentifierOrLiteral(node) {
|
|
return isMemberName(node) ? idText(node) : node.text;
|
|
}
|
|
function getEscapedTextOfIdentifierOrLiteral(node) {
|
|
return isMemberName(node) ? node.escapedText : escapeLeadingUnderscores(node.text);
|
|
}
|
|
function getPropertyNameForUniqueESSymbol(symbol) {
|
|
return `__@${getSymbolId(symbol)}@${symbol.escapedName}`;
|
|
}
|
|
function getSymbolNameForPrivateIdentifier(containingClassSymbol, description2) {
|
|
return `__#${getSymbolId(containingClassSymbol)}@${description2}`;
|
|
}
|
|
function isKnownSymbol(symbol) {
|
|
return startsWith(symbol.escapedName, "__@");
|
|
}
|
|
function isPrivateIdentifierSymbol(symbol) {
|
|
return startsWith(symbol.escapedName, "__#");
|
|
}
|
|
function isESSymbolIdentifier(node) {
|
|
return node.kind === 79 /* Identifier */ && node.escapedText === "Symbol";
|
|
}
|
|
function isPushOrUnshiftIdentifier(node) {
|
|
return node.escapedText === "push" || node.escapedText === "unshift";
|
|
}
|
|
function isParameterDeclaration(node) {
|
|
const root = getRootDeclaration(node);
|
|
return root.kind === 166 /* Parameter */;
|
|
}
|
|
function getRootDeclaration(node) {
|
|
while (node.kind === 205 /* BindingElement */) {
|
|
node = node.parent.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function nodeStartsNewLexicalEnvironment(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 215 /* FunctionExpression */ || kind === 259 /* FunctionDeclaration */ || kind === 216 /* ArrowFunction */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 264 /* ModuleDeclaration */ || kind === 308 /* SourceFile */;
|
|
}
|
|
function nodeIsSynthesized(range) {
|
|
return positionIsSynthesized(range.pos) || positionIsSynthesized(range.end);
|
|
}
|
|
function getOriginalSourceFile(sourceFile) {
|
|
return getParseTreeNode(sourceFile, isSourceFile) || sourceFile;
|
|
}
|
|
var Associativity = /* @__PURE__ */ ((Associativity2) => {
|
|
Associativity2[Associativity2["Left"] = 0] = "Left";
|
|
Associativity2[Associativity2["Right"] = 1] = "Right";
|
|
return Associativity2;
|
|
})(Associativity || {});
|
|
function getExpressionAssociativity(expression) {
|
|
const operator = getOperator(expression);
|
|
const hasArguments = expression.kind === 211 /* NewExpression */ && expression.arguments !== void 0;
|
|
return getOperatorAssociativity(expression.kind, operator, hasArguments);
|
|
}
|
|
function getOperatorAssociativity(kind, operator, hasArguments) {
|
|
switch (kind) {
|
|
case 211 /* NewExpression */:
|
|
return hasArguments ? 0 /* Left */ : 1 /* Right */;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 224 /* ConditionalExpression */:
|
|
case 226 /* YieldExpression */:
|
|
return 1 /* Right */;
|
|
case 223 /* BinaryExpression */:
|
|
switch (operator) {
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 1 /* Right */;
|
|
}
|
|
}
|
|
return 0 /* Left */;
|
|
}
|
|
function getExpressionPrecedence(expression) {
|
|
const operator = getOperator(expression);
|
|
const hasArguments = expression.kind === 211 /* NewExpression */ && expression.arguments !== void 0;
|
|
return getOperatorPrecedence(expression.kind, operator, hasArguments);
|
|
}
|
|
function getOperator(expression) {
|
|
if (expression.kind === 223 /* BinaryExpression */) {
|
|
return expression.operatorToken.kind;
|
|
} else if (expression.kind === 221 /* PrefixUnaryExpression */ || expression.kind === 222 /* PostfixUnaryExpression */) {
|
|
return expression.operator;
|
|
} else {
|
|
return expression.kind;
|
|
}
|
|
}
|
|
var OperatorPrecedence = /* @__PURE__ */ ((OperatorPrecedence2) => {
|
|
OperatorPrecedence2[OperatorPrecedence2["Comma"] = 0] = "Comma";
|
|
OperatorPrecedence2[OperatorPrecedence2["Spread"] = 1] = "Spread";
|
|
OperatorPrecedence2[OperatorPrecedence2["Yield"] = 2] = "Yield";
|
|
OperatorPrecedence2[OperatorPrecedence2["Assignment"] = 3] = "Assignment";
|
|
OperatorPrecedence2[OperatorPrecedence2["Conditional"] = 4] = "Conditional";
|
|
OperatorPrecedence2[OperatorPrecedence2["Coalesce"] = 4 /* Conditional */] = "Coalesce";
|
|
OperatorPrecedence2[OperatorPrecedence2["LogicalOR"] = 5] = "LogicalOR";
|
|
OperatorPrecedence2[OperatorPrecedence2["LogicalAND"] = 6] = "LogicalAND";
|
|
OperatorPrecedence2[OperatorPrecedence2["BitwiseOR"] = 7] = "BitwiseOR";
|
|
OperatorPrecedence2[OperatorPrecedence2["BitwiseXOR"] = 8] = "BitwiseXOR";
|
|
OperatorPrecedence2[OperatorPrecedence2["BitwiseAND"] = 9] = "BitwiseAND";
|
|
OperatorPrecedence2[OperatorPrecedence2["Equality"] = 10] = "Equality";
|
|
OperatorPrecedence2[OperatorPrecedence2["Relational"] = 11] = "Relational";
|
|
OperatorPrecedence2[OperatorPrecedence2["Shift"] = 12] = "Shift";
|
|
OperatorPrecedence2[OperatorPrecedence2["Additive"] = 13] = "Additive";
|
|
OperatorPrecedence2[OperatorPrecedence2["Multiplicative"] = 14] = "Multiplicative";
|
|
OperatorPrecedence2[OperatorPrecedence2["Exponentiation"] = 15] = "Exponentiation";
|
|
OperatorPrecedence2[OperatorPrecedence2["Unary"] = 16] = "Unary";
|
|
OperatorPrecedence2[OperatorPrecedence2["Update"] = 17] = "Update";
|
|
OperatorPrecedence2[OperatorPrecedence2["LeftHandSide"] = 18] = "LeftHandSide";
|
|
OperatorPrecedence2[OperatorPrecedence2["Member"] = 19] = "Member";
|
|
OperatorPrecedence2[OperatorPrecedence2["Primary"] = 20] = "Primary";
|
|
OperatorPrecedence2[OperatorPrecedence2["Highest"] = 20 /* Primary */] = "Highest";
|
|
OperatorPrecedence2[OperatorPrecedence2["Lowest"] = 0 /* Comma */] = "Lowest";
|
|
OperatorPrecedence2[OperatorPrecedence2["Invalid"] = -1] = "Invalid";
|
|
return OperatorPrecedence2;
|
|
})(OperatorPrecedence || {});
|
|
function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
|
|
switch (nodeKind) {
|
|
case 354 /* CommaListExpression */:
|
|
return 0 /* Comma */;
|
|
case 227 /* SpreadElement */:
|
|
return 1 /* Spread */;
|
|
case 226 /* YieldExpression */:
|
|
return 2 /* Yield */;
|
|
case 224 /* ConditionalExpression */:
|
|
return 4 /* Conditional */;
|
|
case 223 /* BinaryExpression */:
|
|
switch (operatorKind) {
|
|
case 27 /* CommaToken */:
|
|
return 0 /* Comma */;
|
|
case 63 /* EqualsToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 3 /* Assignment */;
|
|
default:
|
|
return getBinaryOperatorPrecedence(operatorKind);
|
|
}
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
return 16 /* Unary */;
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return 17 /* Update */;
|
|
case 210 /* CallExpression */:
|
|
return 18 /* LeftHandSide */;
|
|
case 211 /* NewExpression */:
|
|
return hasArguments ? 19 /* Member */ : 18 /* LeftHandSide */;
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 233 /* MetaProperty */:
|
|
return 19 /* Member */;
|
|
case 231 /* AsExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return 11 /* Relational */;
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 228 /* ClassExpression */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 229 /* OmittedExpression */:
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
return 20 /* Primary */;
|
|
default:
|
|
return -1 /* Invalid */;
|
|
}
|
|
}
|
|
function getBinaryOperatorPrecedence(kind) {
|
|
switch (kind) {
|
|
case 60 /* QuestionQuestionToken */:
|
|
return 4 /* Coalesce */;
|
|
case 56 /* BarBarToken */:
|
|
return 5 /* LogicalOR */;
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
return 6 /* LogicalAND */;
|
|
case 51 /* BarToken */:
|
|
return 7 /* BitwiseOR */;
|
|
case 52 /* CaretToken */:
|
|
return 8 /* BitwiseXOR */;
|
|
case 50 /* AmpersandToken */:
|
|
return 9 /* BitwiseAND */;
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
return 10 /* Equality */;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
case 102 /* InstanceOfKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 128 /* AsKeyword */:
|
|
case 150 /* SatisfiesKeyword */:
|
|
return 11 /* Relational */;
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
return 12 /* Shift */;
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
return 13 /* Additive */;
|
|
case 41 /* AsteriskToken */:
|
|
case 43 /* SlashToken */:
|
|
case 44 /* PercentToken */:
|
|
return 14 /* Multiplicative */;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return 15 /* Exponentiation */;
|
|
}
|
|
return -1;
|
|
}
|
|
function getSemanticJsxChildren(children) {
|
|
return filter(children, (i) => {
|
|
switch (i.kind) {
|
|
case 291 /* JsxExpression */:
|
|
return !!i.expression;
|
|
case 11 /* JsxText */:
|
|
return !i.containsOnlyTriviaWhiteSpaces;
|
|
default:
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
function createDiagnosticCollection() {
|
|
let nonFileDiagnostics = [];
|
|
const filesWithDiagnostics = [];
|
|
const fileDiagnostics = /* @__PURE__ */ new Map();
|
|
let hasReadNonFileDiagnostics = false;
|
|
return {
|
|
add,
|
|
lookup,
|
|
getGlobalDiagnostics,
|
|
getDiagnostics: getDiagnostics2
|
|
};
|
|
function lookup(diagnostic) {
|
|
let diagnostics;
|
|
if (diagnostic.file) {
|
|
diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
|
|
} else {
|
|
diagnostics = nonFileDiagnostics;
|
|
}
|
|
if (!diagnostics) {
|
|
return void 0;
|
|
}
|
|
const result = binarySearch(diagnostics, diagnostic, identity, compareDiagnosticsSkipRelatedInformation);
|
|
if (result >= 0) {
|
|
return diagnostics[result];
|
|
}
|
|
return void 0;
|
|
}
|
|
function add(diagnostic) {
|
|
let diagnostics;
|
|
if (diagnostic.file) {
|
|
diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
|
|
if (!diagnostics) {
|
|
diagnostics = [];
|
|
fileDiagnostics.set(diagnostic.file.fileName, diagnostics);
|
|
insertSorted(filesWithDiagnostics, diagnostic.file.fileName, compareStringsCaseSensitive);
|
|
}
|
|
} else {
|
|
if (hasReadNonFileDiagnostics) {
|
|
hasReadNonFileDiagnostics = false;
|
|
nonFileDiagnostics = nonFileDiagnostics.slice();
|
|
}
|
|
diagnostics = nonFileDiagnostics;
|
|
}
|
|
insertSorted(diagnostics, diagnostic, compareDiagnosticsSkipRelatedInformation);
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
hasReadNonFileDiagnostics = true;
|
|
return nonFileDiagnostics;
|
|
}
|
|
function getDiagnostics2(fileName) {
|
|
if (fileName) {
|
|
return fileDiagnostics.get(fileName) || [];
|
|
}
|
|
const fileDiags = flatMapToMutable(filesWithDiagnostics, (f) => fileDiagnostics.get(f));
|
|
if (!nonFileDiagnostics.length) {
|
|
return fileDiags;
|
|
}
|
|
fileDiags.unshift(...nonFileDiagnostics);
|
|
return fileDiags;
|
|
}
|
|
}
|
|
var templateSubstitutionRegExp = /\$\{/g;
|
|
function escapeTemplateSubstitution(str) {
|
|
return str.replace(templateSubstitutionRegExp, "\\${");
|
|
}
|
|
function hasInvalidEscape(template) {
|
|
return template && !!(isNoSubstitutionTemplateLiteral(template) ? template.templateFlags : template.head.templateFlags || some(template.templateSpans, (span) => !!span.literal.templateFlags));
|
|
}
|
|
var doubleQuoteEscapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
|
|
var singleQuoteEscapedCharsRegExp = /[\\\'\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g;
|
|
var backtickQuoteEscapedCharsRegExp = /\r\n|[\\\`\u0000-\u001f\t\v\f\b\r\u2028\u2029\u0085]/g;
|
|
var escapedCharsMap = new Map(getEntries({
|
|
" ": "\\t",
|
|
"\v": "\\v",
|
|
"\f": "\\f",
|
|
"\b": "\\b",
|
|
"\r": "\\r",
|
|
"\n": "\\n",
|
|
"\\": "\\\\",
|
|
'"': '\\"',
|
|
"'": "\\'",
|
|
"`": "\\`",
|
|
"\u2028": "\\u2028",
|
|
"\u2029": "\\u2029",
|
|
"\x85": "\\u0085",
|
|
"\r\n": "\\r\\n"
|
|
}));
|
|
function encodeUtf16EscapeSequence(charCode) {
|
|
const hexCharCode = charCode.toString(16).toUpperCase();
|
|
const paddedHexCode = ("0000" + hexCharCode).slice(-4);
|
|
return "\\u" + paddedHexCode;
|
|
}
|
|
function getReplacement(c, offset, input) {
|
|
if (c.charCodeAt(0) === 0 /* nullCharacter */) {
|
|
const lookAhead = input.charCodeAt(offset + c.length);
|
|
if (lookAhead >= 48 /* _0 */ && lookAhead <= 57 /* _9 */) {
|
|
return "\\x00";
|
|
}
|
|
return "\\0";
|
|
}
|
|
return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0));
|
|
}
|
|
function escapeString(s, quoteChar) {
|
|
const escapedCharsRegExp = quoteChar === 96 /* backtick */ ? backtickQuoteEscapedCharsRegExp : quoteChar === 39 /* singleQuote */ ? singleQuoteEscapedCharsRegExp : doubleQuoteEscapedCharsRegExp;
|
|
return s.replace(escapedCharsRegExp, getReplacement);
|
|
}
|
|
var nonAsciiCharacters = /[^\u0000-\u007F]/g;
|
|
function escapeNonAsciiString(s, quoteChar) {
|
|
s = escapeString(s, quoteChar);
|
|
return nonAsciiCharacters.test(s) ? s.replace(nonAsciiCharacters, (c) => encodeUtf16EscapeSequence(c.charCodeAt(0))) : s;
|
|
}
|
|
var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g;
|
|
var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g;
|
|
var jsxEscapedCharsMap = new Map(getEntries({
|
|
'"': """,
|
|
"'": "'"
|
|
}));
|
|
function encodeJsxCharacterEntity(charCode) {
|
|
const hexCharCode = charCode.toString(16).toUpperCase();
|
|
return "&#x" + hexCharCode + ";";
|
|
}
|
|
function getJsxAttributeStringReplacement(c) {
|
|
if (c.charCodeAt(0) === 0 /* nullCharacter */) {
|
|
return "�";
|
|
}
|
|
return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0));
|
|
}
|
|
function escapeJsxAttributeString(s, quoteChar) {
|
|
const escapedCharsRegExp = quoteChar === 39 /* singleQuote */ ? jsxSingleQuoteEscapedCharsRegExp : jsxDoubleQuoteEscapedCharsRegExp;
|
|
return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement);
|
|
}
|
|
function stripQuotes(name) {
|
|
const length2 = name.length;
|
|
if (length2 >= 2 && name.charCodeAt(0) === name.charCodeAt(length2 - 1) && isQuoteOrBacktick(name.charCodeAt(0))) {
|
|
return name.substring(1, length2 - 1);
|
|
}
|
|
return name;
|
|
}
|
|
function isQuoteOrBacktick(charCode) {
|
|
return charCode === 39 /* singleQuote */ || charCode === 34 /* doubleQuote */ || charCode === 96 /* backtick */;
|
|
}
|
|
function isIntrinsicJsxName(name) {
|
|
const ch = name.charCodeAt(0);
|
|
return ch >= 97 /* a */ && ch <= 122 /* z */ || stringContains(name, "-") || stringContains(name, ":");
|
|
}
|
|
var indentStrings = ["", " "];
|
|
function getIndentString(level) {
|
|
const singleLevel = indentStrings[1];
|
|
for (let current = indentStrings.length; current <= level; current++) {
|
|
indentStrings.push(indentStrings[current - 1] + singleLevel);
|
|
}
|
|
return indentStrings[level];
|
|
}
|
|
function getIndentSize() {
|
|
return indentStrings[1].length;
|
|
}
|
|
function isNightly() {
|
|
return stringContains(version, "-dev") || stringContains(version, "-insiders");
|
|
}
|
|
function createTextWriter(newLine) {
|
|
let output;
|
|
let indent3;
|
|
let lineStart;
|
|
let lineCount;
|
|
let linePos;
|
|
let hasTrailingComment = false;
|
|
function updateLineCountAndPosFor(s) {
|
|
const lineStartsOfS = computeLineStarts(s);
|
|
if (lineStartsOfS.length > 1) {
|
|
lineCount = lineCount + lineStartsOfS.length - 1;
|
|
linePos = output.length - s.length + last(lineStartsOfS);
|
|
lineStart = linePos - output.length === 0;
|
|
} else {
|
|
lineStart = false;
|
|
}
|
|
}
|
|
function writeText(s) {
|
|
if (s && s.length) {
|
|
if (lineStart) {
|
|
s = getIndentString(indent3) + s;
|
|
lineStart = false;
|
|
}
|
|
output += s;
|
|
updateLineCountAndPosFor(s);
|
|
}
|
|
}
|
|
function write(s) {
|
|
if (s)
|
|
hasTrailingComment = false;
|
|
writeText(s);
|
|
}
|
|
function writeComment(s) {
|
|
if (s)
|
|
hasTrailingComment = true;
|
|
writeText(s);
|
|
}
|
|
function reset2() {
|
|
output = "";
|
|
indent3 = 0;
|
|
lineStart = true;
|
|
lineCount = 0;
|
|
linePos = 0;
|
|
hasTrailingComment = false;
|
|
}
|
|
function rawWrite(s) {
|
|
if (s !== void 0) {
|
|
output += s;
|
|
updateLineCountAndPosFor(s);
|
|
hasTrailingComment = false;
|
|
}
|
|
}
|
|
function writeLiteral(s) {
|
|
if (s && s.length) {
|
|
write(s);
|
|
}
|
|
}
|
|
function writeLine(force) {
|
|
if (!lineStart || force) {
|
|
output += newLine;
|
|
lineCount++;
|
|
linePos = output.length;
|
|
lineStart = true;
|
|
hasTrailingComment = false;
|
|
}
|
|
}
|
|
function getTextPosWithWriteLine() {
|
|
return lineStart ? output.length : output.length + newLine.length;
|
|
}
|
|
reset2();
|
|
return {
|
|
write,
|
|
rawWrite,
|
|
writeLiteral,
|
|
writeLine,
|
|
increaseIndent: () => {
|
|
indent3++;
|
|
},
|
|
decreaseIndent: () => {
|
|
indent3--;
|
|
},
|
|
getIndent: () => indent3,
|
|
getTextPos: () => output.length,
|
|
getLine: () => lineCount,
|
|
getColumn: () => lineStart ? indent3 * getIndentSize() : output.length - linePos,
|
|
getText: () => output,
|
|
isAtStartOfLine: () => lineStart,
|
|
hasTrailingComment: () => hasTrailingComment,
|
|
hasTrailingWhitespace: () => !!output.length && isWhiteSpaceLike(output.charCodeAt(output.length - 1)),
|
|
clear: reset2,
|
|
reportInaccessibleThisError: noop,
|
|
reportPrivateInBaseOfClassExpression: noop,
|
|
reportInaccessibleUniqueSymbolError: noop,
|
|
trackSymbol: () => false,
|
|
writeKeyword: write,
|
|
writeOperator: write,
|
|
writeParameter: write,
|
|
writeProperty: write,
|
|
writePunctuation: write,
|
|
writeSpace: write,
|
|
writeStringLiteral: write,
|
|
writeSymbol: (s, _) => write(s),
|
|
writeTrailingSemicolon: write,
|
|
writeComment,
|
|
getTextPosWithWriteLine
|
|
};
|
|
}
|
|
function getTrailingSemicolonDeferringWriter(writer) {
|
|
let pendingTrailingSemicolon = false;
|
|
function commitPendingTrailingSemicolon() {
|
|
if (pendingTrailingSemicolon) {
|
|
writer.writeTrailingSemicolon(";");
|
|
pendingTrailingSemicolon = false;
|
|
}
|
|
}
|
|
return {
|
|
...writer,
|
|
writeTrailingSemicolon() {
|
|
pendingTrailingSemicolon = true;
|
|
},
|
|
writeLiteral(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeLiteral(s);
|
|
},
|
|
writeStringLiteral(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeStringLiteral(s);
|
|
},
|
|
writeSymbol(s, sym) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeSymbol(s, sym);
|
|
},
|
|
writePunctuation(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writePunctuation(s);
|
|
},
|
|
writeKeyword(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeKeyword(s);
|
|
},
|
|
writeOperator(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeOperator(s);
|
|
},
|
|
writeParameter(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeParameter(s);
|
|
},
|
|
writeSpace(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeSpace(s);
|
|
},
|
|
writeProperty(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeProperty(s);
|
|
},
|
|
writeComment(s) {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeComment(s);
|
|
},
|
|
writeLine() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.writeLine();
|
|
},
|
|
increaseIndent() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.increaseIndent();
|
|
},
|
|
decreaseIndent() {
|
|
commitPendingTrailingSemicolon();
|
|
writer.decreaseIndent();
|
|
}
|
|
};
|
|
}
|
|
function hostUsesCaseSensitiveFileNames(host) {
|
|
return host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : false;
|
|
}
|
|
function hostGetCanonicalFileName(host) {
|
|
return createGetCanonicalFileName(hostUsesCaseSensitiveFileNames(host));
|
|
}
|
|
function getResolvedExternalModuleName(host, file, referenceFile) {
|
|
return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName);
|
|
}
|
|
function getCanonicalAbsolutePath(host, path) {
|
|
return host.getCanonicalFileName(getNormalizedAbsolutePath(path, host.getCurrentDirectory()));
|
|
}
|
|
function getExternalModuleNameFromDeclaration(host, resolver, declaration) {
|
|
const file = resolver.getExternalModuleFileFromDeclaration(declaration);
|
|
if (!file || file.isDeclarationFile) {
|
|
return void 0;
|
|
}
|
|
const specifier = getExternalModuleName(declaration);
|
|
if (specifier && isStringLiteralLike(specifier) && !pathIsRelative(specifier.text) && getCanonicalAbsolutePath(host, file.path).indexOf(getCanonicalAbsolutePath(host, ensureTrailingDirectorySeparator(host.getCommonSourceDirectory()))) === -1) {
|
|
return void 0;
|
|
}
|
|
return getResolvedExternalModuleName(host, file);
|
|
}
|
|
function getExternalModuleNameFromPath(host, fileName, referencePath) {
|
|
const getCanonicalFileName = (f) => host.getCanonicalFileName(f);
|
|
const dir = toPath(referencePath ? getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName);
|
|
const filePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
|
|
const relativePath = getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, false);
|
|
const extensionless = removeFileExtension(relativePath);
|
|
return referencePath ? ensurePathIsNonModuleName(extensionless) : extensionless;
|
|
}
|
|
function getOwnEmitOutputFilePath(fileName, host, extension) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
let emitOutputFilePathWithoutExtension;
|
|
if (compilerOptions.outDir) {
|
|
emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(fileName, host, compilerOptions.outDir));
|
|
} else {
|
|
emitOutputFilePathWithoutExtension = removeFileExtension(fileName);
|
|
}
|
|
return emitOutputFilePathWithoutExtension + extension;
|
|
}
|
|
function getDeclarationEmitOutputFilePath(fileName, host) {
|
|
return getDeclarationEmitOutputFilePathWorker(fileName, host.getCompilerOptions(), host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f));
|
|
}
|
|
function getDeclarationEmitOutputFilePathWorker(fileName, options, currentDirectory, commonSourceDirectory, getCanonicalFileName) {
|
|
const outputDir = options.declarationDir || options.outDir;
|
|
const path = outputDir ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName) : fileName;
|
|
const declarationExtension = getDeclarationEmitExtensionForPath(path);
|
|
return removeFileExtension(path) + declarationExtension;
|
|
}
|
|
function getDeclarationEmitExtensionForPath(path) {
|
|
return fileExtensionIsOneOf(path, [".mjs" /* Mjs */, ".mts" /* Mts */]) ? ".d.mts" /* Dmts */ : fileExtensionIsOneOf(path, [".cjs" /* Cjs */, ".cts" /* Cts */]) ? ".d.cts" /* Dcts */ : fileExtensionIsOneOf(path, [".json" /* Json */]) ? `.json.d.ts` : ".d.ts" /* Dts */;
|
|
}
|
|
function getPossibleOriginalInputExtensionForExtension(path) {
|
|
return fileExtensionIsOneOf(path, [".d.mts" /* Dmts */, ".mjs" /* Mjs */, ".mts" /* Mts */]) ? [".mts" /* Mts */, ".mjs" /* Mjs */] : fileExtensionIsOneOf(path, [".d.cts" /* Dcts */, ".cjs" /* Cjs */, ".cts" /* Cts */]) ? [".cts" /* Cts */, ".cjs" /* Cjs */] : fileExtensionIsOneOf(path, [`.json.d.ts`]) ? [".json" /* Json */] : [".tsx" /* Tsx */, ".ts" /* Ts */, ".jsx" /* Jsx */, ".js" /* Js */];
|
|
}
|
|
function outFile(options) {
|
|
return options.outFile || options.out;
|
|
}
|
|
function getPathsBasePath(options, host) {
|
|
var _a2, _b;
|
|
if (!options.paths)
|
|
return void 0;
|
|
return (_b = options.baseUrl) != null ? _b : Debug.checkDefined(options.pathsBasePath || ((_a2 = host.getCurrentDirectory) == null ? void 0 : _a2.call(host)), "Encountered 'paths' without a 'baseUrl', config file, or host 'getCurrentDirectory'.");
|
|
}
|
|
function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) {
|
|
const options = host.getCompilerOptions();
|
|
if (outFile(options)) {
|
|
const moduleKind = getEmitModuleKind(options);
|
|
const moduleEmitEnabled = options.emitDeclarationOnly || moduleKind === 2 /* AMD */ || moduleKind === 4 /* System */;
|
|
return filter(
|
|
host.getSourceFiles(),
|
|
(sourceFile) => (moduleEmitEnabled || !isExternalModule(sourceFile)) && sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit)
|
|
);
|
|
} else {
|
|
const sourceFiles = targetSourceFile === void 0 ? host.getSourceFiles() : [targetSourceFile];
|
|
return filter(
|
|
sourceFiles,
|
|
(sourceFile) => sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit)
|
|
);
|
|
}
|
|
}
|
|
function sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit) {
|
|
const options = host.getCompilerOptions();
|
|
return !(options.noEmitForJsFiles && isSourceFileJS(sourceFile)) && !sourceFile.isDeclarationFile && !host.isSourceFileFromExternalLibrary(sourceFile) && (forceDtsEmit || !(isJsonSourceFile(sourceFile) && host.getResolvedProjectReferenceToRedirect(sourceFile.fileName)) && !host.isSourceOfProjectReferenceRedirect(sourceFile.fileName));
|
|
}
|
|
function getSourceFilePathInNewDir(fileName, host, newDirPath) {
|
|
return getSourceFilePathInNewDirWorker(fileName, newDirPath, host.getCurrentDirectory(), host.getCommonSourceDirectory(), (f) => host.getCanonicalFileName(f));
|
|
}
|
|
function getSourceFilePathInNewDirWorker(fileName, newDirPath, currentDirectory, commonSourceDirectory, getCanonicalFileName) {
|
|
let sourceFilePath = getNormalizedAbsolutePath(fileName, currentDirectory);
|
|
const isSourceFileInCommonSourceDirectory = getCanonicalFileName(sourceFilePath).indexOf(getCanonicalFileName(commonSourceDirectory)) === 0;
|
|
sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath;
|
|
return combinePaths(newDirPath, sourceFilePath);
|
|
}
|
|
function writeFile(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) {
|
|
host.writeFile(fileName, text, writeByteOrderMark, (hostErrorMessage) => {
|
|
diagnostics.add(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
|
|
}, sourceFiles, data);
|
|
}
|
|
function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) {
|
|
if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
|
|
const parentDirectory = getDirectoryPath(directoryPath);
|
|
ensureDirectoriesExist(parentDirectory, createDirectory, directoryExists);
|
|
createDirectory(directoryPath);
|
|
}
|
|
}
|
|
function writeFileEnsuringDirectories(path, data, writeByteOrderMark, writeFile2, createDirectory, directoryExists) {
|
|
try {
|
|
writeFile2(path, data, writeByteOrderMark);
|
|
} catch (e) {
|
|
ensureDirectoriesExist(getDirectoryPath(normalizePath(path)), createDirectory, directoryExists);
|
|
writeFile2(path, data, writeByteOrderMark);
|
|
}
|
|
}
|
|
function getLineOfLocalPosition(sourceFile, pos) {
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
return computeLineOfPosition(lineStarts, pos);
|
|
}
|
|
function getLineOfLocalPositionFromLineMap(lineMap, pos) {
|
|
return computeLineOfPosition(lineMap, pos);
|
|
}
|
|
function getFirstConstructorWithBody(node) {
|
|
return find(node.members, (member) => isConstructorDeclaration(member) && nodeIsPresent(member.body));
|
|
}
|
|
function getSetAccessorValueParameter(accessor) {
|
|
if (accessor && accessor.parameters.length > 0) {
|
|
const hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]);
|
|
return accessor.parameters[hasThis ? 1 : 0];
|
|
}
|
|
}
|
|
function getSetAccessorTypeAnnotationNode(accessor) {
|
|
const parameter = getSetAccessorValueParameter(accessor);
|
|
return parameter && parameter.type;
|
|
}
|
|
function getThisParameter(signature) {
|
|
if (signature.parameters.length && !isJSDocSignature(signature)) {
|
|
const thisParameter = signature.parameters[0];
|
|
if (parameterIsThisKeyword(thisParameter)) {
|
|
return thisParameter;
|
|
}
|
|
}
|
|
}
|
|
function parameterIsThisKeyword(parameter) {
|
|
return isThisIdentifier(parameter.name);
|
|
}
|
|
function isThisIdentifier(node) {
|
|
return !!node && node.kind === 79 /* Identifier */ && identifierIsThisKeyword(node);
|
|
}
|
|
function isThisInTypeQuery(node) {
|
|
if (!isThisIdentifier(node)) {
|
|
return false;
|
|
}
|
|
while (isQualifiedName(node.parent) && node.parent.left === node) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 183 /* TypeQuery */;
|
|
}
|
|
function identifierIsThisKeyword(id) {
|
|
return id.originalKeywordKind === 108 /* ThisKeyword */;
|
|
}
|
|
function getAllAccessorDeclarations(declarations, accessor) {
|
|
let firstAccessor;
|
|
let secondAccessor;
|
|
let getAccessor;
|
|
let setAccessor;
|
|
if (hasDynamicName(accessor)) {
|
|
firstAccessor = accessor;
|
|
if (accessor.kind === 174 /* GetAccessor */) {
|
|
getAccessor = accessor;
|
|
} else if (accessor.kind === 175 /* SetAccessor */) {
|
|
setAccessor = accessor;
|
|
} else {
|
|
Debug.fail("Accessor has wrong kind");
|
|
}
|
|
} else {
|
|
forEach(declarations, (member) => {
|
|
if (isAccessor(member) && isStatic(member) === isStatic(accessor)) {
|
|
const memberName = getPropertyNameForPropertyNameNode(member.name);
|
|
const accessorName = getPropertyNameForPropertyNameNode(accessor.name);
|
|
if (memberName === accessorName) {
|
|
if (!firstAccessor) {
|
|
firstAccessor = member;
|
|
} else if (!secondAccessor) {
|
|
secondAccessor = member;
|
|
}
|
|
if (member.kind === 174 /* GetAccessor */ && !getAccessor) {
|
|
getAccessor = member;
|
|
}
|
|
if (member.kind === 175 /* SetAccessor */ && !setAccessor) {
|
|
setAccessor = member;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
firstAccessor,
|
|
secondAccessor,
|
|
getAccessor,
|
|
setAccessor
|
|
};
|
|
}
|
|
function getEffectiveTypeAnnotationNode(node) {
|
|
if (!isInJSFile(node) && isFunctionDeclaration(node))
|
|
return void 0;
|
|
const type = node.type;
|
|
if (type || !isInJSFile(node))
|
|
return type;
|
|
return isJSDocPropertyLikeTag(node) ? node.typeExpression && node.typeExpression.type : getJSDocType(node);
|
|
}
|
|
function getTypeAnnotationNode(node) {
|
|
return node.type;
|
|
}
|
|
function getEffectiveReturnTypeNode(node) {
|
|
return isJSDocSignature(node) ? node.type && node.type.typeExpression && node.type.typeExpression.type : node.type || (isInJSFile(node) ? getJSDocReturnType(node) : void 0);
|
|
}
|
|
function getJSDocTypeParameterDeclarations(node) {
|
|
return flatMap(getJSDocTags(node), (tag) => isNonTypeAliasTemplate(tag) ? tag.typeParameters : void 0);
|
|
}
|
|
function isNonTypeAliasTemplate(tag) {
|
|
return isJSDocTemplateTag(tag) && !(tag.parent.kind === 323 /* JSDoc */ && tag.parent.tags.some(isJSDocTypeAlias));
|
|
}
|
|
function getEffectiveSetAccessorTypeAnnotationNode(node) {
|
|
const parameter = getSetAccessorValueParameter(node);
|
|
return parameter && getEffectiveTypeAnnotationNode(parameter);
|
|
}
|
|
function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) {
|
|
emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments);
|
|
}
|
|
function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) {
|
|
if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos && getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) {
|
|
if (pos !== commentPos && getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) {
|
|
if (comments && comments.length > 0) {
|
|
if (leadingSeparator) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
let emitInterveningSeparator = false;
|
|
for (const comment of comments) {
|
|
if (emitInterveningSeparator) {
|
|
writer.writeSpace(" ");
|
|
emitInterveningSeparator = false;
|
|
}
|
|
writeComment(text, lineMap, writer, comment.pos, comment.end, newLine);
|
|
if (comment.hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
} else {
|
|
emitInterveningSeparator = true;
|
|
}
|
|
}
|
|
if (emitInterveningSeparator && trailingSeparator) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
}
|
|
function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) {
|
|
let leadingComments;
|
|
let currentDetachedCommentInfo;
|
|
if (removeComments) {
|
|
if (node.pos === 0) {
|
|
leadingComments = filter(getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal);
|
|
}
|
|
} else {
|
|
leadingComments = getLeadingCommentRanges(text, node.pos);
|
|
}
|
|
if (leadingComments) {
|
|
const detachedComments = [];
|
|
let lastComment;
|
|
for (const comment of leadingComments) {
|
|
if (lastComment) {
|
|
const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end);
|
|
const commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos);
|
|
if (commentLine >= lastCommentLine + 2) {
|
|
break;
|
|
}
|
|
}
|
|
detachedComments.push(comment);
|
|
lastComment = comment;
|
|
}
|
|
if (detachedComments.length) {
|
|
const lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, last(detachedComments).end);
|
|
const nodeLine = getLineOfLocalPositionFromLineMap(lineMap, skipTrivia(text, node.pos));
|
|
if (nodeLine >= lastCommentLine + 2) {
|
|
emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments);
|
|
emitComments(text, lineMap, writer, detachedComments, false, true, newLine, writeComment);
|
|
currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: last(detachedComments).end };
|
|
}
|
|
}
|
|
}
|
|
return currentDetachedCommentInfo;
|
|
function isPinnedCommentLocal(comment) {
|
|
return isPinnedComment(text, comment.pos);
|
|
}
|
|
}
|
|
function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) {
|
|
if (text.charCodeAt(commentPos + 1) === 42 /* asterisk */) {
|
|
const firstCommentLineAndCharacter = computeLineAndCharacterOfPosition(lineMap, commentPos);
|
|
const lineCount = lineMap.length;
|
|
let firstCommentLineIndent;
|
|
for (let pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) {
|
|
const nextLineStart = currentLine + 1 === lineCount ? text.length + 1 : lineMap[currentLine + 1];
|
|
if (pos !== commentPos) {
|
|
if (firstCommentLineIndent === void 0) {
|
|
firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos);
|
|
}
|
|
const currentWriterIndentSpacing = writer.getIndent() * getIndentSize();
|
|
const spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart);
|
|
if (spacesToEmit > 0) {
|
|
let numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize();
|
|
const indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize());
|
|
writer.rawWrite(indentSizeSpaceString);
|
|
while (numberOfSingleSpacesToEmit) {
|
|
writer.rawWrite(" ");
|
|
numberOfSingleSpacesToEmit--;
|
|
}
|
|
} else {
|
|
writer.rawWrite("");
|
|
}
|
|
}
|
|
writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart);
|
|
pos = nextLineStart;
|
|
}
|
|
} else {
|
|
writer.writeComment(text.substring(commentPos, commentEnd));
|
|
}
|
|
}
|
|
function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) {
|
|
const end = Math.min(commentEnd, nextLineStart - 1);
|
|
const currentLineText = trimString(text.substring(pos, end));
|
|
if (currentLineText) {
|
|
writer.writeComment(currentLineText);
|
|
if (end !== commentEnd) {
|
|
writer.writeLine();
|
|
}
|
|
} else {
|
|
writer.rawWrite(newLine);
|
|
}
|
|
}
|
|
function calculateIndent(text, pos, end) {
|
|
let currentLineIndent = 0;
|
|
for (; pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) {
|
|
if (text.charCodeAt(pos) === 9 /* tab */) {
|
|
currentLineIndent += getIndentSize() - currentLineIndent % getIndentSize();
|
|
} else {
|
|
currentLineIndent++;
|
|
}
|
|
}
|
|
return currentLineIndent;
|
|
}
|
|
function hasEffectiveModifiers(node) {
|
|
return getEffectiveModifierFlags(node) !== 0 /* None */;
|
|
}
|
|
function hasSyntacticModifiers(node) {
|
|
return getSyntacticModifierFlags(node) !== 0 /* None */;
|
|
}
|
|
function hasEffectiveModifier(node, flags) {
|
|
return !!getSelectedEffectiveModifierFlags(node, flags);
|
|
}
|
|
function hasSyntacticModifier(node, flags) {
|
|
return !!getSelectedSyntacticModifierFlags(node, flags);
|
|
}
|
|
function isStatic(node) {
|
|
return isClassElement(node) && hasStaticModifier(node) || isClassStaticBlockDeclaration(node);
|
|
}
|
|
function hasStaticModifier(node) {
|
|
return hasSyntacticModifier(node, 32 /* Static */);
|
|
}
|
|
function hasOverrideModifier(node) {
|
|
return hasEffectiveModifier(node, 16384 /* Override */);
|
|
}
|
|
function hasAbstractModifier(node) {
|
|
return hasSyntacticModifier(node, 256 /* Abstract */);
|
|
}
|
|
function hasAmbientModifier(node) {
|
|
return hasSyntacticModifier(node, 2 /* Ambient */);
|
|
}
|
|
function hasAccessorModifier(node) {
|
|
return hasSyntacticModifier(node, 128 /* Accessor */);
|
|
}
|
|
function hasEffectiveReadonlyModifier(node) {
|
|
return hasEffectiveModifier(node, 64 /* Readonly */);
|
|
}
|
|
function hasDecorators(node) {
|
|
return hasSyntacticModifier(node, 131072 /* Decorator */);
|
|
}
|
|
function getSelectedEffectiveModifierFlags(node, flags) {
|
|
return getEffectiveModifierFlags(node) & flags;
|
|
}
|
|
function getSelectedSyntacticModifierFlags(node, flags) {
|
|
return getSyntacticModifierFlags(node) & flags;
|
|
}
|
|
function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) {
|
|
if (node.kind >= 0 /* FirstToken */ && node.kind <= 162 /* LastToken */) {
|
|
return 0 /* None */;
|
|
}
|
|
if (!(node.modifierFlagsCache & 536870912 /* HasComputedFlags */)) {
|
|
node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912 /* HasComputedFlags */;
|
|
}
|
|
if (includeJSDoc && !(node.modifierFlagsCache & 4096 /* HasComputedJSDocModifiers */) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) {
|
|
node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096 /* HasComputedJSDocModifiers */;
|
|
}
|
|
return node.modifierFlagsCache & ~(536870912 /* HasComputedFlags */ | 4096 /* HasComputedJSDocModifiers */);
|
|
}
|
|
function getEffectiveModifierFlags(node) {
|
|
return getModifierFlagsWorker(node, true);
|
|
}
|
|
function getEffectiveModifierFlagsAlwaysIncludeJSDoc(node) {
|
|
return getModifierFlagsWorker(node, true, true);
|
|
}
|
|
function getSyntacticModifierFlags(node) {
|
|
return getModifierFlagsWorker(node, false);
|
|
}
|
|
function getJSDocModifierFlagsNoCache(node) {
|
|
let flags = 0 /* None */;
|
|
if (!!node.parent && !isParameter(node)) {
|
|
if (isInJSFile(node)) {
|
|
if (getJSDocPublicTagNoCache(node))
|
|
flags |= 4 /* Public */;
|
|
if (getJSDocPrivateTagNoCache(node))
|
|
flags |= 8 /* Private */;
|
|
if (getJSDocProtectedTagNoCache(node))
|
|
flags |= 16 /* Protected */;
|
|
if (getJSDocReadonlyTagNoCache(node))
|
|
flags |= 64 /* Readonly */;
|
|
if (getJSDocOverrideTagNoCache(node))
|
|
flags |= 16384 /* Override */;
|
|
}
|
|
if (getJSDocDeprecatedTagNoCache(node))
|
|
flags |= 8192 /* Deprecated */;
|
|
}
|
|
return flags;
|
|
}
|
|
function getEffectiveModifierFlagsNoCache(node) {
|
|
return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node);
|
|
}
|
|
function getSyntacticModifierFlagsNoCache(node) {
|
|
let flags = canHaveModifiers(node) ? modifiersToFlags(node.modifiers) : 0 /* None */;
|
|
if (node.flags & 4 /* NestedNamespace */ || node.kind === 79 /* Identifier */ && node.isInJSDocNamespace) {
|
|
flags |= 1 /* Export */;
|
|
}
|
|
return flags;
|
|
}
|
|
function modifiersToFlags(modifiers) {
|
|
let flags = 0 /* None */;
|
|
if (modifiers) {
|
|
for (const modifier of modifiers) {
|
|
flags |= modifierToFlag(modifier.kind);
|
|
}
|
|
}
|
|
return flags;
|
|
}
|
|
function modifierToFlag(token) {
|
|
switch (token) {
|
|
case 124 /* StaticKeyword */:
|
|
return 32 /* Static */;
|
|
case 123 /* PublicKeyword */:
|
|
return 4 /* Public */;
|
|
case 122 /* ProtectedKeyword */:
|
|
return 16 /* Protected */;
|
|
case 121 /* PrivateKeyword */:
|
|
return 8 /* Private */;
|
|
case 126 /* AbstractKeyword */:
|
|
return 256 /* Abstract */;
|
|
case 127 /* AccessorKeyword */:
|
|
return 128 /* Accessor */;
|
|
case 93 /* ExportKeyword */:
|
|
return 1 /* Export */;
|
|
case 136 /* DeclareKeyword */:
|
|
return 2 /* Ambient */;
|
|
case 85 /* ConstKeyword */:
|
|
return 2048 /* Const */;
|
|
case 88 /* DefaultKeyword */:
|
|
return 1024 /* Default */;
|
|
case 132 /* AsyncKeyword */:
|
|
return 512 /* Async */;
|
|
case 146 /* ReadonlyKeyword */:
|
|
return 64 /* Readonly */;
|
|
case 161 /* OverrideKeyword */:
|
|
return 16384 /* Override */;
|
|
case 101 /* InKeyword */:
|
|
return 32768 /* In */;
|
|
case 145 /* OutKeyword */:
|
|
return 65536 /* Out */;
|
|
case 167 /* Decorator */:
|
|
return 131072 /* Decorator */;
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function isLogicalOperator(token) {
|
|
return token === 56 /* BarBarToken */ || token === 55 /* AmpersandAmpersandToken */ || token === 53 /* ExclamationToken */;
|
|
}
|
|
function isLogicalOrCoalescingAssignmentOperator(token) {
|
|
return token === 75 /* BarBarEqualsToken */ || token === 76 /* AmpersandAmpersandEqualsToken */ || token === 77 /* QuestionQuestionEqualsToken */;
|
|
}
|
|
function isLogicalOrCoalescingAssignmentExpression(expr) {
|
|
return isLogicalOrCoalescingAssignmentOperator(expr.operatorToken.kind);
|
|
}
|
|
function isAssignmentOperator(token) {
|
|
return token >= 63 /* FirstAssignment */ && token <= 78 /* LastAssignment */;
|
|
}
|
|
function tryGetClassExtendingExpressionWithTypeArguments(node) {
|
|
const cls = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
|
|
return cls && !cls.isImplements ? cls.class : void 0;
|
|
}
|
|
function tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node) {
|
|
return isExpressionWithTypeArguments(node) && isHeritageClause(node.parent) && isClassLike(node.parent.parent) ? { class: node.parent.parent, isImplements: node.parent.token === 117 /* ImplementsKeyword */ } : void 0;
|
|
}
|
|
function isAssignmentExpression(node, excludeCompoundAssignment) {
|
|
return isBinaryExpression(node) && (excludeCompoundAssignment ? node.operatorToken.kind === 63 /* EqualsToken */ : isAssignmentOperator(node.operatorToken.kind)) && isLeftHandSideExpression(node.left);
|
|
}
|
|
function isLeftHandSideOfAssignment(node) {
|
|
return isAssignmentExpression(node.parent) && node.parent.left === node;
|
|
}
|
|
function isDestructuringAssignment(node) {
|
|
if (isAssignmentExpression(node, true)) {
|
|
const kind = node.left.kind;
|
|
return kind === 207 /* ObjectLiteralExpression */ || kind === 206 /* ArrayLiteralExpression */;
|
|
}
|
|
return false;
|
|
}
|
|
function isExpressionWithTypeArgumentsInClassExtendsClause(node) {
|
|
return tryGetClassExtendingExpressionWithTypeArguments(node) !== void 0;
|
|
}
|
|
function isEntityNameExpression(node) {
|
|
return node.kind === 79 /* Identifier */ || isPropertyAccessEntityNameExpression(node);
|
|
}
|
|
function getFirstIdentifier(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.left;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
do {
|
|
node = node.expression;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
}
|
|
}
|
|
function isDottedName(node) {
|
|
return node.kind === 79 /* Identifier */ || node.kind === 108 /* ThisKeyword */ || node.kind === 106 /* SuperKeyword */ || node.kind === 233 /* MetaProperty */ || node.kind === 208 /* PropertyAccessExpression */ && isDottedName(node.expression) || node.kind === 214 /* ParenthesizedExpression */ && isDottedName(node.expression);
|
|
}
|
|
function isPropertyAccessEntityNameExpression(node) {
|
|
return isPropertyAccessExpression(node) && isIdentifier(node.name) && isEntityNameExpression(node.expression);
|
|
}
|
|
function tryGetPropertyAccessOrIdentifierToString(expr) {
|
|
if (isPropertyAccessExpression(expr)) {
|
|
const baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (baseStr !== void 0) {
|
|
return baseStr + "." + entityNameToString(expr.name);
|
|
}
|
|
} else if (isElementAccessExpression(expr)) {
|
|
const baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (baseStr !== void 0 && isPropertyName(expr.argumentExpression)) {
|
|
return baseStr + "." + getPropertyNameForPropertyNameNode(expr.argumentExpression);
|
|
}
|
|
} else if (isIdentifier(expr)) {
|
|
return unescapeLeadingUnderscores(expr.escapedText);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isPrototypeAccess(node) {
|
|
return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype";
|
|
}
|
|
function isRightSideOfQualifiedNameOrPropertyAccess(node) {
|
|
return node.parent.kind === 163 /* QualifiedName */ && node.parent.right === node || node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.name === node;
|
|
}
|
|
function isRightSideOfAccessExpression(node) {
|
|
return isPropertyAccessExpression(node.parent) && node.parent.name === node || isElementAccessExpression(node.parent) && node.parent.argumentExpression === node;
|
|
}
|
|
function isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(node) {
|
|
return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node || isJSDocMemberName(node.parent) && node.parent.right === node;
|
|
}
|
|
function isEmptyObjectLiteral(expression) {
|
|
return expression.kind === 207 /* ObjectLiteralExpression */ && expression.properties.length === 0;
|
|
}
|
|
function isEmptyArrayLiteral(expression) {
|
|
return expression.kind === 206 /* ArrayLiteralExpression */ && expression.elements.length === 0;
|
|
}
|
|
function getLocalSymbolForExportDefault(symbol) {
|
|
if (!isExportDefaultSymbol(symbol) || !symbol.declarations)
|
|
return void 0;
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.localSymbol)
|
|
return decl.localSymbol;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isExportDefaultSymbol(symbol) {
|
|
return symbol && length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 1024 /* Default */);
|
|
}
|
|
function tryExtractTSExtension(fileName) {
|
|
return find(supportedTSExtensionsForExtractExtension, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function getExpandedCharCodes(input) {
|
|
const output = [];
|
|
const length2 = input.length;
|
|
for (let i = 0; i < length2; i++) {
|
|
const charCode = input.charCodeAt(i);
|
|
if (charCode < 128) {
|
|
output.push(charCode);
|
|
} else if (charCode < 2048) {
|
|
output.push(charCode >> 6 | 192);
|
|
output.push(charCode & 63 | 128);
|
|
} else if (charCode < 65536) {
|
|
output.push(charCode >> 12 | 224);
|
|
output.push(charCode >> 6 & 63 | 128);
|
|
output.push(charCode & 63 | 128);
|
|
} else if (charCode < 131072) {
|
|
output.push(charCode >> 18 | 240);
|
|
output.push(charCode >> 12 & 63 | 128);
|
|
output.push(charCode >> 6 & 63 | 128);
|
|
output.push(charCode & 63 | 128);
|
|
} else {
|
|
Debug.assert(false, "Unexpected code point");
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
|
|
function convertToBase64(input) {
|
|
let result = "";
|
|
const charCodes = getExpandedCharCodes(input);
|
|
let i = 0;
|
|
const length2 = charCodes.length;
|
|
let byte1, byte2, byte3, byte4;
|
|
while (i < length2) {
|
|
byte1 = charCodes[i] >> 2;
|
|
byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4;
|
|
byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6;
|
|
byte4 = charCodes[i + 2] & 63;
|
|
if (i + 1 >= length2) {
|
|
byte3 = byte4 = 64;
|
|
} else if (i + 2 >= length2) {
|
|
byte4 = 64;
|
|
}
|
|
result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4);
|
|
i += 3;
|
|
}
|
|
return result;
|
|
}
|
|
function getStringFromExpandedCharCodes(codes) {
|
|
let output = "";
|
|
let i = 0;
|
|
const length2 = codes.length;
|
|
while (i < length2) {
|
|
const charCode = codes[i];
|
|
if (charCode < 128) {
|
|
output += String.fromCharCode(charCode);
|
|
i++;
|
|
} else if ((charCode & 192) === 192) {
|
|
let value = charCode & 63;
|
|
i++;
|
|
let nextCode = codes[i];
|
|
while ((nextCode & 192) === 128) {
|
|
value = value << 6 | nextCode & 63;
|
|
i++;
|
|
nextCode = codes[i];
|
|
}
|
|
output += String.fromCharCode(value);
|
|
} else {
|
|
output += String.fromCharCode(charCode);
|
|
i++;
|
|
}
|
|
}
|
|
return output;
|
|
}
|
|
function base64encode(host, input) {
|
|
if (host && host.base64encode) {
|
|
return host.base64encode(input);
|
|
}
|
|
return convertToBase64(input);
|
|
}
|
|
function base64decode(host, input) {
|
|
if (host && host.base64decode) {
|
|
return host.base64decode(input);
|
|
}
|
|
const length2 = input.length;
|
|
const expandedCharCodes = [];
|
|
let i = 0;
|
|
while (i < length2) {
|
|
if (input.charCodeAt(i) === base64Digits.charCodeAt(64)) {
|
|
break;
|
|
}
|
|
const ch1 = base64Digits.indexOf(input[i]);
|
|
const ch2 = base64Digits.indexOf(input[i + 1]);
|
|
const ch3 = base64Digits.indexOf(input[i + 2]);
|
|
const ch4 = base64Digits.indexOf(input[i + 3]);
|
|
const code1 = (ch1 & 63) << 2 | ch2 >> 4 & 3;
|
|
const code2 = (ch2 & 15) << 4 | ch3 >> 2 & 15;
|
|
const code3 = (ch3 & 3) << 6 | ch4 & 63;
|
|
if (code2 === 0 && ch3 !== 0) {
|
|
expandedCharCodes.push(code1);
|
|
} else if (code3 === 0 && ch4 !== 0) {
|
|
expandedCharCodes.push(code1, code2);
|
|
} else {
|
|
expandedCharCodes.push(code1, code2, code3);
|
|
}
|
|
i += 4;
|
|
}
|
|
return getStringFromExpandedCharCodes(expandedCharCodes);
|
|
}
|
|
function readJsonOrUndefined(path, hostOrText) {
|
|
const jsonText = isString(hostOrText) ? hostOrText : hostOrText.readFile(path);
|
|
if (!jsonText)
|
|
return void 0;
|
|
const result = parseConfigFileTextToJson(path, jsonText);
|
|
return !result.error ? result.config : void 0;
|
|
}
|
|
function readJson(path, host) {
|
|
return readJsonOrUndefined(path, host) || {};
|
|
}
|
|
function directoryProbablyExists(directoryName, host) {
|
|
return !host.directoryExists || host.directoryExists(directoryName);
|
|
}
|
|
var carriageReturnLineFeed = "\r\n";
|
|
var lineFeed = "\n";
|
|
function getNewLineCharacter(options, getNewLine) {
|
|
switch (options.newLine) {
|
|
case 0 /* CarriageReturnLineFeed */:
|
|
return carriageReturnLineFeed;
|
|
case 1 /* LineFeed */:
|
|
return lineFeed;
|
|
}
|
|
return getNewLine ? getNewLine() : sys ? sys.newLine : carriageReturnLineFeed;
|
|
}
|
|
function createRange(pos, end = pos) {
|
|
Debug.assert(end >= pos || end === -1);
|
|
return { pos, end };
|
|
}
|
|
function moveRangeEnd(range, end) {
|
|
return createRange(range.pos, end);
|
|
}
|
|
function moveRangePos(range, pos) {
|
|
return createRange(pos, range.end);
|
|
}
|
|
function moveRangePastDecorators(node) {
|
|
const lastDecorator = canHaveModifiers(node) ? findLast(node.modifiers, isDecorator) : void 0;
|
|
return lastDecorator && !positionIsSynthesized(lastDecorator.end) ? moveRangePos(node, lastDecorator.end) : node;
|
|
}
|
|
function moveRangePastModifiers(node) {
|
|
const lastModifier = canHaveModifiers(node) ? lastOrUndefined(node.modifiers) : void 0;
|
|
return lastModifier && !positionIsSynthesized(lastModifier.end) ? moveRangePos(node, lastModifier.end) : moveRangePastDecorators(node);
|
|
}
|
|
function isCollapsedRange(range) {
|
|
return range.pos === range.end;
|
|
}
|
|
function createTokenRange(pos, token) {
|
|
return createRange(pos, pos + tokenToString(token).length);
|
|
}
|
|
function rangeIsOnSingleLine(range, sourceFile) {
|
|
return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile);
|
|
}
|
|
function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(
|
|
getStartPositionOfRange(range1, sourceFile, false),
|
|
getStartPositionOfRange(range2, sourceFile, false),
|
|
sourceFile
|
|
);
|
|
}
|
|
function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(range1.end, range2.end, sourceFile);
|
|
}
|
|
function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, false), range2.end, sourceFile);
|
|
}
|
|
function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) {
|
|
return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile, false), sourceFile);
|
|
}
|
|
function getLinesBetweenRangeEndAndRangeStart(range1, range2, sourceFile, includeSecondRangeComments) {
|
|
const range2Start = getStartPositionOfRange(range2, sourceFile, includeSecondRangeComments);
|
|
return getLinesBetweenPositions(sourceFile, range1.end, range2Start);
|
|
}
|
|
function getLinesBetweenRangeEndPositions(range1, range2, sourceFile) {
|
|
return getLinesBetweenPositions(sourceFile, range1.end, range2.end);
|
|
}
|
|
function isNodeArrayMultiLine(list, sourceFile) {
|
|
return !positionsAreOnSameLine(list.pos, list.end, sourceFile);
|
|
}
|
|
function positionsAreOnSameLine(pos1, pos2, sourceFile) {
|
|
return getLinesBetweenPositions(sourceFile, pos1, pos2) === 0;
|
|
}
|
|
function getStartPositionOfRange(range, sourceFile, includeComments) {
|
|
return positionIsSynthesized(range.pos) ? -1 : skipTrivia(sourceFile.text, range.pos, false, includeComments);
|
|
}
|
|
function getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
|
|
const startPos = skipTrivia(sourceFile.text, pos, false, includeComments);
|
|
const prevPos = getPreviousNonWhitespacePosition(startPos, stopPos, sourceFile);
|
|
return getLinesBetweenPositions(sourceFile, prevPos != null ? prevPos : stopPos, startPos);
|
|
}
|
|
function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) {
|
|
const nextPos = skipTrivia(sourceFile.text, pos, false, includeComments);
|
|
return getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos));
|
|
}
|
|
function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) {
|
|
while (pos-- > stopPos) {
|
|
if (!isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) {
|
|
return pos;
|
|
}
|
|
}
|
|
}
|
|
function isDeclarationNameOfEnumOrNamespace(node) {
|
|
const parseNode = getParseTreeNode(node);
|
|
if (parseNode) {
|
|
switch (parseNode.parent.kind) {
|
|
case 263 /* EnumDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return parseNode === parseNode.parent.name;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getInitializedVariables(node) {
|
|
return filter(node.declarations, isInitializedVariable);
|
|
}
|
|
function isInitializedVariable(node) {
|
|
return node.initializer !== void 0;
|
|
}
|
|
function isWatchSet(options) {
|
|
return options.watch && hasProperty(options, "watch");
|
|
}
|
|
function closeFileWatcher(watcher) {
|
|
watcher.close();
|
|
}
|
|
function getCheckFlags(symbol) {
|
|
return symbol.flags & 33554432 /* Transient */ ? symbol.checkFlags : 0;
|
|
}
|
|
function getDeclarationModifierFlagsFromSymbol(s, isWrite = false) {
|
|
if (s.valueDeclaration) {
|
|
const declaration = isWrite && s.declarations && find(s.declarations, isSetAccessorDeclaration) || s.flags & 32768 /* GetAccessor */ && find(s.declarations, isGetAccessorDeclaration) || s.valueDeclaration;
|
|
const flags = getCombinedModifierFlags(declaration);
|
|
return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
|
|
}
|
|
if (getCheckFlags(s) & 6 /* Synthetic */) {
|
|
const checkFlags = s.checkFlags;
|
|
const accessModifier = checkFlags & 1024 /* ContainsPrivate */ ? 8 /* Private */ : checkFlags & 256 /* ContainsPublic */ ? 4 /* Public */ : 16 /* Protected */;
|
|
const staticModifier = checkFlags & 2048 /* ContainsStatic */ ? 32 /* Static */ : 0;
|
|
return accessModifier | staticModifier;
|
|
}
|
|
if (s.flags & 4194304 /* Prototype */) {
|
|
return 4 /* Public */ | 32 /* Static */;
|
|
}
|
|
return 0;
|
|
}
|
|
function skipAlias(symbol, checker) {
|
|
return symbol.flags & 2097152 /* Alias */ ? checker.getAliasedSymbol(symbol) : symbol;
|
|
}
|
|
function getCombinedLocalAndExportSymbolFlags(symbol) {
|
|
return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags;
|
|
}
|
|
function isWriteOnlyAccess(node) {
|
|
return accessKind(node) === AccessKind.Write;
|
|
}
|
|
function isWriteAccess(node) {
|
|
return accessKind(node) !== AccessKind.Read;
|
|
}
|
|
var AccessKind = /* @__PURE__ */ ((AccessKind2) => {
|
|
AccessKind2[AccessKind2["Read"] = 0] = "Read";
|
|
AccessKind2[AccessKind2["Write"] = 1] = "Write";
|
|
AccessKind2[AccessKind2["ReadWrite"] = 2] = "ReadWrite";
|
|
return AccessKind2;
|
|
})(AccessKind || {});
|
|
function accessKind(node) {
|
|
const { parent: parent2 } = node;
|
|
if (!parent2)
|
|
return 0 /* Read */;
|
|
switch (parent2.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return accessKind(parent2);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const { operator } = parent2;
|
|
return operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */ ? writeOrReadWrite() : 0 /* Read */;
|
|
case 223 /* BinaryExpression */:
|
|
const { left, operatorToken } = parent2;
|
|
return left === node && isAssignmentOperator(operatorToken.kind) ? operatorToken.kind === 63 /* EqualsToken */ ? 1 /* Write */ : writeOrReadWrite() : 0 /* Read */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return parent2.name !== node ? 0 /* Read */ : accessKind(parent2);
|
|
case 299 /* PropertyAssignment */: {
|
|
const parentAccess = accessKind(parent2.parent);
|
|
return node === parent2.name ? reverseAccessKind(parentAccess) : parentAccess;
|
|
}
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return node === parent2.objectAssignmentInitializer ? 0 /* Read */ : accessKind(parent2.parent);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return accessKind(parent2);
|
|
default:
|
|
return 0 /* Read */;
|
|
}
|
|
function writeOrReadWrite() {
|
|
return parent2.parent && walkUpParenthesizedExpressions(parent2.parent).kind === 241 /* ExpressionStatement */ ? 1 /* Write */ : 2 /* ReadWrite */;
|
|
}
|
|
}
|
|
function reverseAccessKind(a) {
|
|
switch (a) {
|
|
case 0 /* Read */:
|
|
return 1 /* Write */;
|
|
case 1 /* Write */:
|
|
return 0 /* Read */;
|
|
case 2 /* ReadWrite */:
|
|
return 2 /* ReadWrite */;
|
|
default:
|
|
return Debug.assertNever(a);
|
|
}
|
|
}
|
|
function compareDataObjects(dst, src) {
|
|
if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) {
|
|
return false;
|
|
}
|
|
for (const e in dst) {
|
|
if (typeof dst[e] === "object") {
|
|
if (!compareDataObjects(dst[e], src[e])) {
|
|
return false;
|
|
}
|
|
} else if (typeof dst[e] !== "function") {
|
|
if (dst[e] !== src[e]) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function clearMap(map2, onDeleteValue) {
|
|
map2.forEach(onDeleteValue);
|
|
map2.clear();
|
|
}
|
|
function mutateMapSkippingNewValues(map2, newMap, options) {
|
|
const { onDeleteValue, onExistingValue } = options;
|
|
map2.forEach((existingValue, key) => {
|
|
const valueInNewMap = newMap.get(key);
|
|
if (valueInNewMap === void 0) {
|
|
map2.delete(key);
|
|
onDeleteValue(existingValue, key);
|
|
} else if (onExistingValue) {
|
|
onExistingValue(existingValue, valueInNewMap, key);
|
|
}
|
|
});
|
|
}
|
|
function mutateMap(map2, newMap, options) {
|
|
mutateMapSkippingNewValues(map2, newMap, options);
|
|
const { createNewValue } = options;
|
|
newMap.forEach((valueInNewMap, key) => {
|
|
if (!map2.has(key)) {
|
|
map2.set(key, createNewValue(key, valueInNewMap));
|
|
}
|
|
});
|
|
}
|
|
function isAbstractConstructorSymbol(symbol) {
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const declaration = getClassLikeDeclarationOfSymbol(symbol);
|
|
return !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
|
|
}
|
|
return false;
|
|
}
|
|
function getClassLikeDeclarationOfSymbol(symbol) {
|
|
var _a2;
|
|
return (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
|
|
}
|
|
function getObjectFlags(type) {
|
|
return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
|
|
}
|
|
function typeHasCallOrConstructSignatures(type, checker) {
|
|
return checker.getSignaturesOfType(type, 0 /* Call */).length !== 0 || checker.getSignaturesOfType(type, 1 /* Construct */).length !== 0;
|
|
}
|
|
function forSomeAncestorDirectory(directory, callback) {
|
|
return !!forEachAncestorDirectory(directory, (d) => callback(d) ? true : void 0);
|
|
}
|
|
function isUMDExportSymbol(symbol) {
|
|
return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && isNamespaceExportDeclaration(symbol.declarations[0]);
|
|
}
|
|
function showModuleSpecifier({ moduleSpecifier }) {
|
|
return isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : getTextOfNode(moduleSpecifier);
|
|
}
|
|
function getLastChild(node) {
|
|
let lastChild;
|
|
forEachChild(
|
|
node,
|
|
(child) => {
|
|
if (nodeIsPresent(child))
|
|
lastChild = child;
|
|
},
|
|
(children) => {
|
|
for (let i = children.length - 1; i >= 0; i--) {
|
|
if (nodeIsPresent(children[i])) {
|
|
lastChild = children[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
);
|
|
return lastChild;
|
|
}
|
|
function addToSeen(seen, key, value = true) {
|
|
if (seen.has(key)) {
|
|
return false;
|
|
}
|
|
seen.set(key, value);
|
|
return true;
|
|
}
|
|
function isObjectTypeDeclaration(node) {
|
|
return isClassLike(node) || isInterfaceDeclaration(node) || isTypeLiteralNode(node);
|
|
}
|
|
function isTypeNodeKind(kind) {
|
|
return kind >= 179 /* FirstTypeNode */ && kind <= 202 /* LastTypeNode */ || kind === 131 /* AnyKeyword */ || kind === 157 /* UnknownKeyword */ || kind === 148 /* NumberKeyword */ || kind === 160 /* BigIntKeyword */ || kind === 149 /* ObjectKeyword */ || kind === 134 /* BooleanKeyword */ || kind === 152 /* StringKeyword */ || kind === 153 /* SymbolKeyword */ || kind === 114 /* VoidKeyword */ || kind === 155 /* UndefinedKeyword */ || kind === 144 /* NeverKeyword */ || kind === 230 /* ExpressionWithTypeArguments */ || kind === 315 /* JSDocAllType */ || kind === 316 /* JSDocUnknownType */ || kind === 317 /* JSDocNullableType */ || kind === 318 /* JSDocNonNullableType */ || kind === 319 /* JSDocOptionalType */ || kind === 320 /* JSDocFunctionType */ || kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
function isAccessExpression(node) {
|
|
return node.kind === 208 /* PropertyAccessExpression */ || node.kind === 209 /* ElementAccessExpression */;
|
|
}
|
|
function getNameOfAccessExpression(node) {
|
|
if (node.kind === 208 /* PropertyAccessExpression */) {
|
|
return node.name;
|
|
}
|
|
Debug.assert(node.kind === 209 /* ElementAccessExpression */);
|
|
return node.argumentExpression;
|
|
}
|
|
function isBundleFileTextLike(section) {
|
|
switch (section.kind) {
|
|
case "text" /* Text */:
|
|
case "internal" /* Internal */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isNamedImportsOrExports(node) {
|
|
return node.kind === 272 /* NamedImports */ || node.kind === 276 /* NamedExports */;
|
|
}
|
|
function getLeftmostAccessExpression(expr) {
|
|
while (isAccessExpression(expr)) {
|
|
expr = expr.expression;
|
|
}
|
|
return expr;
|
|
}
|
|
function forEachNameInAccessChainWalkingLeft(name, action) {
|
|
if (isAccessExpression(name.parent) && isRightSideOfAccessExpression(name)) {
|
|
return walkAccessExpression(name.parent);
|
|
}
|
|
function walkAccessExpression(access) {
|
|
if (access.kind === 208 /* PropertyAccessExpression */) {
|
|
const res = action(access.name);
|
|
if (res !== void 0) {
|
|
return res;
|
|
}
|
|
} else if (access.kind === 209 /* ElementAccessExpression */) {
|
|
if (isIdentifier(access.argumentExpression) || isStringLiteralLike(access.argumentExpression)) {
|
|
const res = action(access.argumentExpression);
|
|
if (res !== void 0) {
|
|
return res;
|
|
}
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
if (isAccessExpression(access.expression)) {
|
|
return walkAccessExpression(access.expression);
|
|
}
|
|
if (isIdentifier(access.expression)) {
|
|
return action(access.expression);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function getLeftmostExpression(node, stopAtCallExpressions) {
|
|
while (true) {
|
|
switch (node.kind) {
|
|
case 222 /* PostfixUnaryExpression */:
|
|
node = node.operand;
|
|
continue;
|
|
case 223 /* BinaryExpression */:
|
|
node = node.left;
|
|
continue;
|
|
case 224 /* ConditionalExpression */:
|
|
node = node.condition;
|
|
continue;
|
|
case 212 /* TaggedTemplateExpression */:
|
|
node = node.tag;
|
|
continue;
|
|
case 210 /* CallExpression */:
|
|
if (stopAtCallExpressions) {
|
|
return node;
|
|
}
|
|
case 231 /* AsExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
node = node.expression;
|
|
continue;
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function Symbol4(flags, name) {
|
|
this.flags = flags;
|
|
this.escapedName = name;
|
|
this.declarations = void 0;
|
|
this.valueDeclaration = void 0;
|
|
this.id = void 0;
|
|
this.mergeId = void 0;
|
|
this.parent = void 0;
|
|
}
|
|
function Type3(checker, flags) {
|
|
this.flags = flags;
|
|
if (Debug.isDebugging || tracing) {
|
|
this.checker = checker;
|
|
}
|
|
}
|
|
function Signature2(checker, flags) {
|
|
this.flags = flags;
|
|
if (Debug.isDebugging) {
|
|
this.checker = checker;
|
|
}
|
|
}
|
|
function Node4(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.modifierFlagsCache = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
this.original = void 0;
|
|
}
|
|
function Token(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
}
|
|
function Identifier2(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.kind = kind;
|
|
this.id = 0;
|
|
this.flags = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
this.original = void 0;
|
|
this.flowNode = void 0;
|
|
}
|
|
function SourceMapSource(fileName, text, skipTrivia2) {
|
|
this.fileName = fileName;
|
|
this.text = text;
|
|
this.skipTrivia = skipTrivia2 || ((pos) => pos);
|
|
}
|
|
var objectAllocator = {
|
|
getNodeConstructor: () => Node4,
|
|
getTokenConstructor: () => Token,
|
|
getIdentifierConstructor: () => Identifier2,
|
|
getPrivateIdentifierConstructor: () => Node4,
|
|
getSourceFileConstructor: () => Node4,
|
|
getSymbolConstructor: () => Symbol4,
|
|
getTypeConstructor: () => Type3,
|
|
getSignatureConstructor: () => Signature2,
|
|
getSourceMapSourceConstructor: () => SourceMapSource
|
|
};
|
|
function setObjectAllocator(alloc) {
|
|
Object.assign(objectAllocator, alloc);
|
|
}
|
|
function formatStringFromArgs(text, args, baseIndex = 0) {
|
|
return text.replace(/{(\d+)}/g, (_match, index) => "" + Debug.checkDefined(args[+index + baseIndex]));
|
|
}
|
|
var localizedDiagnosticMessages;
|
|
function setLocalizedDiagnosticMessages(messages) {
|
|
localizedDiagnosticMessages = messages;
|
|
}
|
|
function maybeSetLocalizedDiagnosticMessages(getMessages) {
|
|
if (!localizedDiagnosticMessages && getMessages) {
|
|
localizedDiagnosticMessages = getMessages();
|
|
}
|
|
}
|
|
function getLocaleSpecificMessage(message) {
|
|
return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message;
|
|
}
|
|
function createDetachedDiagnostic(fileName, start2, length2, message) {
|
|
assertDiagnosticLocation(void 0, start2, length2);
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 4) {
|
|
text = formatStringFromArgs(text, arguments, 4);
|
|
}
|
|
return {
|
|
file: void 0,
|
|
start: start2,
|
|
length: length2,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
fileName
|
|
};
|
|
}
|
|
function isDiagnosticWithDetachedLocation(diagnostic) {
|
|
return diagnostic.file === void 0 && diagnostic.start !== void 0 && diagnostic.length !== void 0 && typeof diagnostic.fileName === "string";
|
|
}
|
|
function attachFileToDiagnostic(diagnostic, file) {
|
|
const fileName = file.fileName || "";
|
|
const length2 = file.text.length;
|
|
Debug.assertEqual(diagnostic.fileName, fileName);
|
|
Debug.assertLessThanOrEqual(diagnostic.start, length2);
|
|
Debug.assertLessThanOrEqual(diagnostic.start + diagnostic.length, length2);
|
|
const diagnosticWithLocation = {
|
|
file,
|
|
start: diagnostic.start,
|
|
length: diagnostic.length,
|
|
messageText: diagnostic.messageText,
|
|
category: diagnostic.category,
|
|
code: diagnostic.code,
|
|
reportsUnnecessary: diagnostic.reportsUnnecessary
|
|
};
|
|
if (diagnostic.relatedInformation) {
|
|
diagnosticWithLocation.relatedInformation = [];
|
|
for (const related of diagnostic.relatedInformation) {
|
|
if (isDiagnosticWithDetachedLocation(related) && related.fileName === fileName) {
|
|
Debug.assertLessThanOrEqual(related.start, length2);
|
|
Debug.assertLessThanOrEqual(related.start + related.length, length2);
|
|
diagnosticWithLocation.relatedInformation.push(attachFileToDiagnostic(related, file));
|
|
} else {
|
|
diagnosticWithLocation.relatedInformation.push(related);
|
|
}
|
|
}
|
|
}
|
|
return diagnosticWithLocation;
|
|
}
|
|
function attachFileToDiagnostics(diagnostics, file) {
|
|
const diagnosticsWithLocation = [];
|
|
for (const diagnostic of diagnostics) {
|
|
diagnosticsWithLocation.push(attachFileToDiagnostic(diagnostic, file));
|
|
}
|
|
return diagnosticsWithLocation;
|
|
}
|
|
function createFileDiagnostic(file, start2, length2, message) {
|
|
assertDiagnosticLocation(file, start2, length2);
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 4) {
|
|
text = formatStringFromArgs(text, arguments, 4);
|
|
}
|
|
return {
|
|
file,
|
|
start: start2,
|
|
length: length2,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
reportsDeprecated: message.reportsDeprecated
|
|
};
|
|
}
|
|
function formatMessage(_dummy, message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 2) {
|
|
text = formatStringFromArgs(text, arguments, 2);
|
|
}
|
|
return text;
|
|
}
|
|
function createCompilerDiagnostic(message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 1) {
|
|
text = formatStringFromArgs(text, arguments, 1);
|
|
}
|
|
return {
|
|
file: void 0,
|
|
start: void 0,
|
|
length: void 0,
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
reportsUnnecessary: message.reportsUnnecessary,
|
|
reportsDeprecated: message.reportsDeprecated
|
|
};
|
|
}
|
|
function createCompilerDiagnosticFromMessageChain(chain, relatedInformation) {
|
|
return {
|
|
file: void 0,
|
|
start: void 0,
|
|
length: void 0,
|
|
code: chain.code,
|
|
category: chain.category,
|
|
messageText: chain.next ? chain : chain.messageText,
|
|
relatedInformation
|
|
};
|
|
}
|
|
function chainDiagnosticMessages(details, message) {
|
|
let text = getLocaleSpecificMessage(message);
|
|
if (arguments.length > 2) {
|
|
text = formatStringFromArgs(text, arguments, 2);
|
|
}
|
|
return {
|
|
messageText: text,
|
|
category: message.category,
|
|
code: message.code,
|
|
next: details === void 0 || Array.isArray(details) ? details : [details]
|
|
};
|
|
}
|
|
function concatenateDiagnosticMessageChains(headChain, tailChain) {
|
|
let lastChain = headChain;
|
|
while (lastChain.next) {
|
|
lastChain = lastChain.next[0];
|
|
}
|
|
lastChain.next = [tailChain];
|
|
}
|
|
function getDiagnosticFilePath(diagnostic) {
|
|
return diagnostic.file ? diagnostic.file.path : void 0;
|
|
}
|
|
function compareDiagnostics(d1, d2) {
|
|
return compareDiagnosticsSkipRelatedInformation(d1, d2) || compareRelatedInformation(d1, d2) || 0 /* EqualTo */;
|
|
}
|
|
function compareDiagnosticsSkipRelatedInformation(d1, d2) {
|
|
return compareStringsCaseSensitive(getDiagnosticFilePath(d1), getDiagnosticFilePath(d2)) || compareValues(d1.start, d2.start) || compareValues(d1.length, d2.length) || compareValues(d1.code, d2.code) || compareMessageText(d1.messageText, d2.messageText) || 0 /* EqualTo */;
|
|
}
|
|
function compareRelatedInformation(d1, d2) {
|
|
if (!d1.relatedInformation && !d2.relatedInformation) {
|
|
return 0 /* EqualTo */;
|
|
}
|
|
if (d1.relatedInformation && d2.relatedInformation) {
|
|
return compareValues(d1.relatedInformation.length, d2.relatedInformation.length) || forEach(d1.relatedInformation, (d1i, index) => {
|
|
const d2i = d2.relatedInformation[index];
|
|
return compareDiagnostics(d1i, d2i);
|
|
}) || 0 /* EqualTo */;
|
|
}
|
|
return d1.relatedInformation ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
}
|
|
function compareMessageText(t1, t2) {
|
|
if (typeof t1 === "string" && typeof t2 === "string") {
|
|
return compareStringsCaseSensitive(t1, t2);
|
|
} else if (typeof t1 === "string") {
|
|
return -1 /* LessThan */;
|
|
} else if (typeof t2 === "string") {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
let res = compareStringsCaseSensitive(t1.messageText, t2.messageText);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
if (!t1.next && !t2.next) {
|
|
return 0 /* EqualTo */;
|
|
}
|
|
if (!t1.next) {
|
|
return -1 /* LessThan */;
|
|
}
|
|
if (!t2.next) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
const len = Math.min(t1.next.length, t2.next.length);
|
|
for (let i = 0; i < len; i++) {
|
|
res = compareMessageText(t1.next[i], t2.next[i]);
|
|
if (res) {
|
|
return res;
|
|
}
|
|
}
|
|
if (t1.next.length < t2.next.length) {
|
|
return -1 /* LessThan */;
|
|
} else if (t1.next.length > t2.next.length) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
return 0 /* EqualTo */;
|
|
}
|
|
function getLanguageVariant(scriptKind) {
|
|
return scriptKind === 4 /* TSX */ || scriptKind === 2 /* JSX */ || scriptKind === 1 /* JS */ || scriptKind === 6 /* JSON */ ? 1 /* JSX */ : 0 /* Standard */;
|
|
}
|
|
function walkTreeForJSXTags(node) {
|
|
if (!(node.transformFlags & 2 /* ContainsJsx */))
|
|
return void 0;
|
|
return isJsxOpeningLikeElement(node) || isJsxFragment(node) ? node : forEachChild(node, walkTreeForJSXTags);
|
|
}
|
|
function isFileModuleFromUsingJSXTag(file) {
|
|
return !file.isDeclarationFile ? walkTreeForJSXTags(file) : void 0;
|
|
}
|
|
function isFileForcedToBeModuleByFormat(file) {
|
|
return (file.impliedNodeFormat === 99 /* ESNext */ || fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */])) && !file.isDeclarationFile ? true : void 0;
|
|
}
|
|
function getSetExternalModuleIndicator(options) {
|
|
switch (getEmitModuleDetectionKind(options)) {
|
|
case 3 /* Force */:
|
|
return (file) => {
|
|
file.externalModuleIndicator = isFileProbablyExternalModule(file) || !file.isDeclarationFile || void 0;
|
|
};
|
|
case 1 /* Legacy */:
|
|
return (file) => {
|
|
file.externalModuleIndicator = isFileProbablyExternalModule(file);
|
|
};
|
|
case 2 /* Auto */:
|
|
const checks = [isFileProbablyExternalModule];
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
checks.push(isFileModuleFromUsingJSXTag);
|
|
}
|
|
checks.push(isFileForcedToBeModuleByFormat);
|
|
const combined = or(...checks);
|
|
const callback = (file) => void (file.externalModuleIndicator = combined(file));
|
|
return callback;
|
|
}
|
|
}
|
|
function getEmitScriptTarget(compilerOptions) {
|
|
return compilerOptions.target || compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 0 /* ES3 */;
|
|
}
|
|
function getEmitModuleKind(compilerOptions) {
|
|
return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
|
|
}
|
|
function getEmitModuleResolutionKind(compilerOptions) {
|
|
let moduleResolution = compilerOptions.moduleResolution;
|
|
if (moduleResolution === void 0) {
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 1 /* CommonJS */:
|
|
moduleResolution = 2 /* NodeJs */;
|
|
break;
|
|
case 100 /* Node16 */:
|
|
moduleResolution = 3 /* Node16 */;
|
|
break;
|
|
case 199 /* NodeNext */:
|
|
moduleResolution = 99 /* NodeNext */;
|
|
break;
|
|
default:
|
|
moduleResolution = 1 /* Classic */;
|
|
break;
|
|
}
|
|
}
|
|
return moduleResolution;
|
|
}
|
|
function getEmitModuleDetectionKind(options) {
|
|
return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
|
|
}
|
|
function hasJsonModuleEmitEnabled(options) {
|
|
switch (getEmitModuleKind(options)) {
|
|
case 1 /* CommonJS */:
|
|
case 2 /* AMD */:
|
|
case 5 /* ES2015 */:
|
|
case 6 /* ES2020 */:
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function unreachableCodeIsError(options) {
|
|
return options.allowUnreachableCode === false;
|
|
}
|
|
function unusedLabelIsError(options) {
|
|
return options.allowUnusedLabels === false;
|
|
}
|
|
function getAreDeclarationMapsEnabled(options) {
|
|
return !!(getEmitDeclarations(options) && options.declarationMap);
|
|
}
|
|
function getESModuleInterop(compilerOptions) {
|
|
if (compilerOptions.esModuleInterop !== void 0) {
|
|
return compilerOptions.esModuleInterop;
|
|
}
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return true;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAllowSyntheticDefaultImports(compilerOptions) {
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
return compilerOptions.allowSyntheticDefaultImports !== void 0 ? compilerOptions.allowSyntheticDefaultImports : getESModuleInterop(compilerOptions) || moduleKind === 4 /* System */;
|
|
}
|
|
function getEmitDeclarations(compilerOptions) {
|
|
return !!(compilerOptions.declaration || compilerOptions.composite);
|
|
}
|
|
function shouldPreserveConstEnums(compilerOptions) {
|
|
return !!(compilerOptions.preserveConstEnums || compilerOptions.isolatedModules);
|
|
}
|
|
function isIncrementalCompilation(options) {
|
|
return !!(options.incremental || options.composite);
|
|
}
|
|
function getStrictOptionValue(compilerOptions, flag) {
|
|
return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
|
|
}
|
|
function getAllowJSCompilerOption(compilerOptions) {
|
|
return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
|
|
}
|
|
function getUseDefineForClassFields(compilerOptions) {
|
|
return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
|
|
}
|
|
function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, semanticDiagnosticsOptionDeclarations);
|
|
}
|
|
function compilerOptionsAffectEmit(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, affectsEmitOptionDeclarations);
|
|
}
|
|
function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
|
|
return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
|
|
}
|
|
function getCompilerOptionValue(options, option) {
|
|
return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
|
|
}
|
|
function getJSXTransformEnabled(options) {
|
|
const jsx = options.jsx;
|
|
return jsx === 2 /* React */ || jsx === 4 /* ReactJSX */ || jsx === 5 /* ReactJSXDev */;
|
|
}
|
|
function getJSXImplicitImportBase(compilerOptions, file) {
|
|
const jsxImportSourcePragmas = file == null ? void 0 : file.pragmas.get("jsximportsource");
|
|
const jsxImportSourcePragma = isArray(jsxImportSourcePragmas) ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1] : jsxImportSourcePragmas;
|
|
return compilerOptions.jsx === 4 /* ReactJSX */ || compilerOptions.jsx === 5 /* ReactJSXDev */ || compilerOptions.jsxImportSource || jsxImportSourcePragma ? (jsxImportSourcePragma == null ? void 0 : jsxImportSourcePragma.arguments.factory) || compilerOptions.jsxImportSource || "react" : void 0;
|
|
}
|
|
function getJSXRuntimeImport(base, options) {
|
|
return base ? `${base}/${options.jsx === 5 /* ReactJSXDev */ ? "jsx-dev-runtime" : "jsx-runtime"}` : void 0;
|
|
}
|
|
function hasZeroOrOneAsteriskCharacter(str) {
|
|
let seenAsterisk = false;
|
|
for (let i = 0; i < str.length; i++) {
|
|
if (str.charCodeAt(i) === 42 /* asterisk */) {
|
|
if (!seenAsterisk) {
|
|
seenAsterisk = true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createSymlinkCache(cwd, getCanonicalFileName) {
|
|
let symlinkedDirectories;
|
|
let symlinkedDirectoriesByRealpath;
|
|
let symlinkedFiles;
|
|
let hasProcessedResolutions = false;
|
|
return {
|
|
getSymlinkedFiles: () => symlinkedFiles,
|
|
getSymlinkedDirectories: () => symlinkedDirectories,
|
|
getSymlinkedDirectoriesByRealpath: () => symlinkedDirectoriesByRealpath,
|
|
setSymlinkedFile: (path, real) => (symlinkedFiles || (symlinkedFiles = /* @__PURE__ */ new Map())).set(path, real),
|
|
setSymlinkedDirectory: (symlink, real) => {
|
|
let symlinkPath = toPath(symlink, cwd, getCanonicalFileName);
|
|
if (!containsIgnoredPath(symlinkPath)) {
|
|
symlinkPath = ensureTrailingDirectorySeparator(symlinkPath);
|
|
if (real !== false && !(symlinkedDirectories == null ? void 0 : symlinkedDirectories.has(symlinkPath))) {
|
|
(symlinkedDirectoriesByRealpath || (symlinkedDirectoriesByRealpath = createMultiMap())).add(ensureTrailingDirectorySeparator(real.realPath), symlink);
|
|
}
|
|
(symlinkedDirectories || (symlinkedDirectories = /* @__PURE__ */ new Map())).set(symlinkPath, real);
|
|
}
|
|
},
|
|
setSymlinksFromResolutions(files, typeReferenceDirectives) {
|
|
var _a2;
|
|
Debug.assert(!hasProcessedResolutions);
|
|
hasProcessedResolutions = true;
|
|
for (const file of files) {
|
|
(_a2 = file.resolvedModules) == null ? void 0 : _a2.forEach((resolution) => processResolution(this, resolution));
|
|
}
|
|
typeReferenceDirectives == null ? void 0 : typeReferenceDirectives.forEach((resolution) => processResolution(this, resolution));
|
|
},
|
|
hasProcessedResolutions: () => hasProcessedResolutions
|
|
};
|
|
function processResolution(cache, resolution) {
|
|
if (!resolution || !resolution.originalPath || !resolution.resolvedFileName)
|
|
return;
|
|
const { resolvedFileName, originalPath } = resolution;
|
|
cache.setSymlinkedFile(toPath(originalPath, cwd, getCanonicalFileName), resolvedFileName);
|
|
const [commonResolved, commonOriginal] = guessDirectorySymlink(resolvedFileName, originalPath, cwd, getCanonicalFileName) || emptyArray;
|
|
if (commonResolved && commonOriginal) {
|
|
cache.setSymlinkedDirectory(
|
|
commonOriginal,
|
|
{ real: commonResolved, realPath: toPath(commonResolved, cwd, getCanonicalFileName) }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) {
|
|
const aParts = getPathComponents(getNormalizedAbsolutePath(a, cwd));
|
|
const bParts = getPathComponents(getNormalizedAbsolutePath(b, cwd));
|
|
let isDirectory = false;
|
|
while (aParts.length >= 2 && bParts.length >= 2 && !isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) && !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) && getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) {
|
|
aParts.pop();
|
|
bParts.pop();
|
|
isDirectory = true;
|
|
}
|
|
return isDirectory ? [getPathFromPathComponents(aParts), getPathFromPathComponents(bParts)] : void 0;
|
|
}
|
|
function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) {
|
|
return s !== void 0 && (getCanonicalFileName(s) === "node_modules" || startsWith(s, "@"));
|
|
}
|
|
function stripLeadingDirectorySeparator(s) {
|
|
return isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : void 0;
|
|
}
|
|
function tryRemoveDirectoryPrefix(path, dirPath, getCanonicalFileName) {
|
|
const withoutPrefix = tryRemovePrefix(path, dirPath, getCanonicalFileName);
|
|
return withoutPrefix === void 0 ? void 0 : stripLeadingDirectorySeparator(withoutPrefix);
|
|
}
|
|
var reservedCharacterPattern = /[^\w\s\/]/g;
|
|
function regExpEscape(text) {
|
|
return text.replace(reservedCharacterPattern, escapeRegExpCharacter);
|
|
}
|
|
function escapeRegExpCharacter(match) {
|
|
return "\\" + match;
|
|
}
|
|
var wildcardCharCodes = [42 /* asterisk */, 63 /* question */];
|
|
var commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"];
|
|
var implicitExcludePathRegexPattern = `(?!(${commonPackageFolders.join("|")})(/|$))`;
|
|
var filesMatcher = {
|
|
singleAsteriskRegexFragment: "([^./]|(\\.(?!min\\.js$))?)*",
|
|
doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var directoriesMatcher = {
|
|
singleAsteriskRegexFragment: "[^/]*",
|
|
doubleAsteriskRegexFragment: `(/${implicitExcludePathRegexPattern}[^/.][^/]*)*?`,
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var excludeMatcher = {
|
|
singleAsteriskRegexFragment: "[^/]*",
|
|
doubleAsteriskRegexFragment: "(/.+?)?",
|
|
replaceWildcardCharacter: (match) => replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment)
|
|
};
|
|
var wildcardMatchers = {
|
|
files: filesMatcher,
|
|
directories: directoriesMatcher,
|
|
exclude: excludeMatcher
|
|
};
|
|
function getRegularExpressionForWildcard(specs, basePath, usage) {
|
|
const patterns = getRegularExpressionsForWildcards(specs, basePath, usage);
|
|
if (!patterns || !patterns.length) {
|
|
return void 0;
|
|
}
|
|
const pattern = patterns.map((pattern2) => `(${pattern2})`).join("|");
|
|
const terminator = usage === "exclude" ? "($|/)" : "$";
|
|
return `^(${pattern})${terminator}`;
|
|
}
|
|
function getRegularExpressionsForWildcards(specs, basePath, usage) {
|
|
if (specs === void 0 || specs.length === 0) {
|
|
return void 0;
|
|
}
|
|
return flatMap(specs, (spec) => spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]));
|
|
}
|
|
function isImplicitGlob(lastPathComponent) {
|
|
return !/[.*?]/.test(lastPathComponent);
|
|
}
|
|
function getPatternFromSpec(spec, basePath, usage) {
|
|
const pattern = spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]);
|
|
return pattern && `^(${pattern})${usage === "exclude" ? "($|/)" : "$"}`;
|
|
}
|
|
function getSubPatternFromSpec(spec, basePath, usage, { singleAsteriskRegexFragment, doubleAsteriskRegexFragment, replaceWildcardCharacter: replaceWildcardCharacter2 }) {
|
|
let subpattern = "";
|
|
let hasWrittenComponent = false;
|
|
const components = getNormalizedPathComponents(spec, basePath);
|
|
const lastComponent = last(components);
|
|
if (usage !== "exclude" && lastComponent === "**") {
|
|
return void 0;
|
|
}
|
|
components[0] = removeTrailingDirectorySeparator(components[0]);
|
|
if (isImplicitGlob(lastComponent)) {
|
|
components.push("**", "*");
|
|
}
|
|
let optionalCount = 0;
|
|
for (let component of components) {
|
|
if (component === "**") {
|
|
subpattern += doubleAsteriskRegexFragment;
|
|
} else {
|
|
if (usage === "directories") {
|
|
subpattern += "(";
|
|
optionalCount++;
|
|
}
|
|
if (hasWrittenComponent) {
|
|
subpattern += directorySeparator;
|
|
}
|
|
if (usage !== "exclude") {
|
|
let componentPattern = "";
|
|
if (component.charCodeAt(0) === 42 /* asterisk */) {
|
|
componentPattern += "([^./]" + singleAsteriskRegexFragment + ")?";
|
|
component = component.substr(1);
|
|
} else if (component.charCodeAt(0) === 63 /* question */) {
|
|
componentPattern += "[^./]";
|
|
component = component.substr(1);
|
|
}
|
|
componentPattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter2);
|
|
if (componentPattern !== component) {
|
|
subpattern += implicitExcludePathRegexPattern;
|
|
}
|
|
subpattern += componentPattern;
|
|
} else {
|
|
subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter2);
|
|
}
|
|
}
|
|
hasWrittenComponent = true;
|
|
}
|
|
while (optionalCount > 0) {
|
|
subpattern += ")?";
|
|
optionalCount--;
|
|
}
|
|
return subpattern;
|
|
}
|
|
function replaceWildcardCharacter(match, singleAsteriskRegexFragment) {
|
|
return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match;
|
|
}
|
|
function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) {
|
|
path = normalizePath(path);
|
|
currentDirectory = normalizePath(currentDirectory);
|
|
const absolutePath = combinePaths(currentDirectory, path);
|
|
return {
|
|
includeFilePatterns: map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), (pattern) => `^${pattern}$`),
|
|
includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
|
|
includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
|
|
excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
|
|
basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
|
|
};
|
|
}
|
|
function getRegexFromPattern(pattern, useCaseSensitiveFileNames) {
|
|
return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i");
|
|
}
|
|
function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) {
|
|
path = normalizePath(path);
|
|
currentDirectory = normalizePath(currentDirectory);
|
|
const patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory);
|
|
const includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, useCaseSensitiveFileNames));
|
|
const includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames);
|
|
const excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames);
|
|
const results = includeFileRegexes ? includeFileRegexes.map(() => []) : [[]];
|
|
const visited = /* @__PURE__ */ new Map();
|
|
const toCanonical = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
for (const basePath of patterns.basePaths) {
|
|
visitDirectory(basePath, combinePaths(currentDirectory, basePath), depth);
|
|
}
|
|
return flatten(results);
|
|
function visitDirectory(path2, absolutePath, depth2) {
|
|
const canonicalPath = toCanonical(realpath(absolutePath));
|
|
if (visited.has(canonicalPath))
|
|
return;
|
|
visited.set(canonicalPath, true);
|
|
const { files, directories } = getFileSystemEntries(path2);
|
|
for (const current of sort(files, compareStringsCaseSensitive)) {
|
|
const name = combinePaths(path2, current);
|
|
const absoluteName = combinePaths(absolutePath, current);
|
|
if (extensions && !fileExtensionIsOneOf(name, extensions))
|
|
continue;
|
|
if (excludeRegex && excludeRegex.test(absoluteName))
|
|
continue;
|
|
if (!includeFileRegexes) {
|
|
results[0].push(name);
|
|
} else {
|
|
const includeIndex = findIndex(includeFileRegexes, (re) => re.test(absoluteName));
|
|
if (includeIndex !== -1) {
|
|
results[includeIndex].push(name);
|
|
}
|
|
}
|
|
}
|
|
if (depth2 !== void 0) {
|
|
depth2--;
|
|
if (depth2 === 0) {
|
|
return;
|
|
}
|
|
}
|
|
for (const current of sort(directories, compareStringsCaseSensitive)) {
|
|
const name = combinePaths(path2, current);
|
|
const absoluteName = combinePaths(absolutePath, current);
|
|
if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && (!excludeRegex || !excludeRegex.test(absoluteName))) {
|
|
visitDirectory(name, absoluteName, depth2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getBasePaths(path, includes, useCaseSensitiveFileNames) {
|
|
const basePaths = [path];
|
|
if (includes) {
|
|
const includeBasePaths = [];
|
|
for (const include of includes) {
|
|
const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
|
|
includeBasePaths.push(getIncludeBasePath(absolute));
|
|
}
|
|
includeBasePaths.sort(getStringComparer(!useCaseSensitiveFileNames));
|
|
for (const includeBasePath of includeBasePaths) {
|
|
if (every(basePaths, (basePath) => !containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames))) {
|
|
basePaths.push(includeBasePath);
|
|
}
|
|
}
|
|
}
|
|
return basePaths;
|
|
}
|
|
function getIncludeBasePath(absolute) {
|
|
const wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
|
|
if (wildcardOffset < 0) {
|
|
return !hasExtension(absolute) ? absolute : removeTrailingDirectorySeparator(getDirectoryPath(absolute));
|
|
}
|
|
return absolute.substring(0, absolute.lastIndexOf(directorySeparator, wildcardOffset));
|
|
}
|
|
function ensureScriptKind(fileName, scriptKind) {
|
|
return scriptKind || getScriptKindFromFileName(fileName) || 3 /* TS */;
|
|
}
|
|
function getScriptKindFromFileName(fileName) {
|
|
const ext = fileName.substr(fileName.lastIndexOf("."));
|
|
switch (ext.toLowerCase()) {
|
|
case ".js" /* Js */:
|
|
case ".cjs" /* Cjs */:
|
|
case ".mjs" /* Mjs */:
|
|
return 1 /* JS */;
|
|
case ".jsx" /* Jsx */:
|
|
return 2 /* JSX */;
|
|
case ".ts" /* Ts */:
|
|
case ".cts" /* Cts */:
|
|
case ".mts" /* Mts */:
|
|
return 3 /* TS */;
|
|
case ".tsx" /* Tsx */:
|
|
return 4 /* TSX */;
|
|
case ".json" /* Json */:
|
|
return 6 /* JSON */;
|
|
default:
|
|
return 0 /* Unknown */;
|
|
}
|
|
}
|
|
var supportedTSExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */], [".cts" /* Cts */, ".d.cts" /* Dcts */], [".mts" /* Mts */, ".d.mts" /* Dmts */]];
|
|
var supportedTSExtensionsFlat = flatten(supportedTSExtensions);
|
|
var supportedTSExtensionsWithJson = [...supportedTSExtensions, [".json" /* Json */]];
|
|
var supportedTSExtensionsForExtractExtension = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */, ".cts" /* Cts */, ".mts" /* Mts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".cts" /* Cts */, ".mts" /* Mts */];
|
|
var supportedJSExtensions = [[".js" /* Js */, ".jsx" /* Jsx */], [".mjs" /* Mjs */], [".cjs" /* Cjs */]];
|
|
var supportedJSExtensionsFlat = flatten(supportedJSExtensions);
|
|
var allSupportedExtensions = [[".ts" /* Ts */, ".tsx" /* Tsx */, ".d.ts" /* Dts */, ".js" /* Js */, ".jsx" /* Jsx */], [".cts" /* Cts */, ".d.cts" /* Dcts */, ".cjs" /* Cjs */], [".mts" /* Mts */, ".d.mts" /* Dmts */, ".mjs" /* Mjs */]];
|
|
var allSupportedExtensionsWithJson = [...allSupportedExtensions, [".json" /* Json */]];
|
|
var supportedDeclarationExtensions = [".d.ts" /* Dts */, ".d.cts" /* Dcts */, ".d.mts" /* Dmts */];
|
|
var supportedTSImplementationExtensions = [".ts" /* Ts */, ".cts" /* Cts */, ".mts" /* Mts */, ".tsx" /* Tsx */];
|
|
function getSupportedExtensions(options, extraFileExtensions) {
|
|
const needJsExtensions = options && getAllowJSCompilerOption(options);
|
|
if (!extraFileExtensions || extraFileExtensions.length === 0) {
|
|
return needJsExtensions ? allSupportedExtensions : supportedTSExtensions;
|
|
}
|
|
const builtins = needJsExtensions ? allSupportedExtensions : supportedTSExtensions;
|
|
const flatBuiltins = flatten(builtins);
|
|
const extensions = [
|
|
...builtins,
|
|
...mapDefined(extraFileExtensions, (x) => x.scriptKind === 7 /* Deferred */ || needJsExtensions && isJSLike(x.scriptKind) && flatBuiltins.indexOf(x.extension) === -1 ? [x.extension] : void 0)
|
|
];
|
|
return extensions;
|
|
}
|
|
function getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) {
|
|
if (!options || !options.resolveJsonModule)
|
|
return supportedExtensions;
|
|
if (supportedExtensions === allSupportedExtensions)
|
|
return allSupportedExtensionsWithJson;
|
|
if (supportedExtensions === supportedTSExtensions)
|
|
return supportedTSExtensionsWithJson;
|
|
return [...supportedExtensions, [".json" /* Json */]];
|
|
}
|
|
function isJSLike(scriptKind) {
|
|
return scriptKind === 1 /* JS */ || scriptKind === 2 /* JSX */;
|
|
}
|
|
function hasJSFileExtension(fileName) {
|
|
return some(supportedJSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function hasTSFileExtension(fileName) {
|
|
return some(supportedTSExtensionsFlat, (extension) => fileExtensionIs(fileName, extension));
|
|
}
|
|
function isSupportedSourceFileName(fileName, compilerOptions, extraFileExtensions) {
|
|
if (!fileName)
|
|
return false;
|
|
const supportedExtensions = getSupportedExtensions(compilerOptions, extraFileExtensions);
|
|
for (const extension of flatten(getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions))) {
|
|
if (fileExtensionIs(fileName, extension)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function numberOfDirectorySeparators(str) {
|
|
const match = str.match(/\//g);
|
|
return match ? match.length : 0;
|
|
}
|
|
function compareNumberOfDirectorySeparators(path1, path2) {
|
|
return compareValues(
|
|
numberOfDirectorySeparators(path1),
|
|
numberOfDirectorySeparators(path2)
|
|
);
|
|
}
|
|
var extensionsToRemove = [".d.ts" /* Dts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".mts" /* Mts */, ".cjs" /* Cjs */, ".cts" /* Cts */, ".ts" /* Ts */, ".js" /* Js */, ".tsx" /* Tsx */, ".jsx" /* Jsx */, ".json" /* Json */];
|
|
function removeFileExtension(path) {
|
|
for (const ext of extensionsToRemove) {
|
|
const extensionless = tryRemoveExtension(path, ext);
|
|
if (extensionless !== void 0) {
|
|
return extensionless;
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
function tryRemoveExtension(path, extension) {
|
|
return fileExtensionIs(path, extension) ? removeExtension(path, extension) : void 0;
|
|
}
|
|
function removeExtension(path, extension) {
|
|
return path.substring(0, path.length - extension.length);
|
|
}
|
|
function changeExtension(path, newExtension) {
|
|
return changeAnyExtension(path, newExtension, extensionsToRemove, false);
|
|
}
|
|
function tryParsePattern(pattern) {
|
|
const indexOfStar = pattern.indexOf("*");
|
|
if (indexOfStar === -1) {
|
|
return pattern;
|
|
}
|
|
return pattern.indexOf("*", indexOfStar + 1) !== -1 ? void 0 : {
|
|
prefix: pattern.substr(0, indexOfStar),
|
|
suffix: pattern.substr(indexOfStar + 1)
|
|
};
|
|
}
|
|
function tryParsePatterns(paths) {
|
|
return mapDefined(getOwnKeys(paths), (path) => tryParsePattern(path));
|
|
}
|
|
function positionIsSynthesized(pos) {
|
|
return !(pos >= 0);
|
|
}
|
|
function extensionIsTS(ext) {
|
|
return ext === ".ts" /* Ts */ || ext === ".tsx" /* Tsx */ || ext === ".d.ts" /* Dts */ || ext === ".cts" /* Cts */ || ext === ".mts" /* Mts */ || ext === ".d.mts" /* Dmts */ || ext === ".d.cts" /* Dcts */;
|
|
}
|
|
function resolutionExtensionIsTSOrJson(ext) {
|
|
return extensionIsTS(ext) || ext === ".json" /* Json */;
|
|
}
|
|
function extensionFromPath(path) {
|
|
const ext = tryGetExtensionFromPath2(path);
|
|
return ext !== void 0 ? ext : Debug.fail(`File ${path} has unknown extension.`);
|
|
}
|
|
function isAnySupportedFileExtension(path) {
|
|
return tryGetExtensionFromPath2(path) !== void 0;
|
|
}
|
|
function tryGetExtensionFromPath2(path) {
|
|
return find(extensionsToRemove, (e) => fileExtensionIs(path, e));
|
|
}
|
|
function isCheckJsEnabledForFile(sourceFile, compilerOptions) {
|
|
return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
|
|
}
|
|
var emptyFileSystemEntries = {
|
|
files: emptyArray,
|
|
directories: emptyArray
|
|
};
|
|
function matchPatternOrExact(patternOrStrings, candidate) {
|
|
const patterns = [];
|
|
for (const patternOrString of patternOrStrings) {
|
|
if (patternOrString === candidate) {
|
|
return candidate;
|
|
}
|
|
if (!isString(patternOrString)) {
|
|
patterns.push(patternOrString);
|
|
}
|
|
}
|
|
return findBestPatternMatch(patterns, (_) => _, candidate);
|
|
}
|
|
function sliceAfter(arr, value) {
|
|
const index = arr.indexOf(value);
|
|
Debug.assert(index !== -1);
|
|
return arr.slice(index);
|
|
}
|
|
function addRelatedInfo(diagnostic, ...relatedInformation) {
|
|
if (!relatedInformation.length) {
|
|
return diagnostic;
|
|
}
|
|
if (!diagnostic.relatedInformation) {
|
|
diagnostic.relatedInformation = [];
|
|
}
|
|
Debug.assert(diagnostic.relatedInformation !== emptyArray, "Diagnostic had empty array singleton for related info, but is still being constructed!");
|
|
diagnostic.relatedInformation.push(...relatedInformation);
|
|
return diagnostic;
|
|
}
|
|
function minAndMax(arr, getValue) {
|
|
Debug.assert(arr.length !== 0);
|
|
let min2 = getValue(arr[0]);
|
|
let max = min2;
|
|
for (let i = 1; i < arr.length; i++) {
|
|
const value = getValue(arr[i]);
|
|
if (value < min2) {
|
|
min2 = value;
|
|
} else if (value > max) {
|
|
max = value;
|
|
}
|
|
}
|
|
return { min: min2, max };
|
|
}
|
|
function rangeOfNode(node) {
|
|
return { pos: getTokenPosOfNode(node), end: node.end };
|
|
}
|
|
function rangeOfTypeParameters(sourceFile, typeParameters) {
|
|
const pos = typeParameters.pos - 1;
|
|
const end = skipTrivia(sourceFile.text, typeParameters.end) + 1;
|
|
return { pos, end };
|
|
}
|
|
function skipTypeChecking(sourceFile, options, host) {
|
|
return options.skipLibCheck && sourceFile.isDeclarationFile || options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib || host.isSourceOfProjectReferenceRedirect(sourceFile.fileName);
|
|
}
|
|
function isJsonEqual(a, b) {
|
|
return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && equalOwnProperties(a, b, isJsonEqual);
|
|
}
|
|
function parsePseudoBigInt(stringValue) {
|
|
let log2Base;
|
|
switch (stringValue.charCodeAt(1)) {
|
|
case 98 /* b */:
|
|
case 66 /* B */:
|
|
log2Base = 1;
|
|
break;
|
|
case 111 /* o */:
|
|
case 79 /* O */:
|
|
log2Base = 3;
|
|
break;
|
|
case 120 /* x */:
|
|
case 88 /* X */:
|
|
log2Base = 4;
|
|
break;
|
|
default:
|
|
const nIndex = stringValue.length - 1;
|
|
let nonZeroStart = 0;
|
|
while (stringValue.charCodeAt(nonZeroStart) === 48 /* _0 */) {
|
|
nonZeroStart++;
|
|
}
|
|
return stringValue.slice(nonZeroStart, nIndex) || "0";
|
|
}
|
|
const startIndex = 2, endIndex = stringValue.length - 1;
|
|
const bitsNeeded = (endIndex - startIndex) * log2Base;
|
|
const segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0));
|
|
for (let i = endIndex - 1, bitOffset = 0; i >= startIndex; i--, bitOffset += log2Base) {
|
|
const segment = bitOffset >>> 4;
|
|
const digitChar = stringValue.charCodeAt(i);
|
|
const digit = digitChar <= 57 /* _9 */ ? digitChar - 48 /* _0 */ : 10 + digitChar - (digitChar <= 70 /* F */ ? 65 /* A */ : 97 /* a */);
|
|
const shiftedDigit = digit << (bitOffset & 15);
|
|
segments[segment] |= shiftedDigit;
|
|
const residual = shiftedDigit >>> 16;
|
|
if (residual)
|
|
segments[segment + 1] |= residual;
|
|
}
|
|
let base10Value = "";
|
|
let firstNonzeroSegment = segments.length - 1;
|
|
let segmentsRemaining = true;
|
|
while (segmentsRemaining) {
|
|
let mod10 = 0;
|
|
segmentsRemaining = false;
|
|
for (let segment = firstNonzeroSegment; segment >= 0; segment--) {
|
|
const newSegment = mod10 << 16 | segments[segment];
|
|
const segmentValue = newSegment / 10 | 0;
|
|
segments[segment] = segmentValue;
|
|
mod10 = newSegment - segmentValue * 10;
|
|
if (segmentValue && !segmentsRemaining) {
|
|
firstNonzeroSegment = segment;
|
|
segmentsRemaining = true;
|
|
}
|
|
}
|
|
base10Value = mod10 + base10Value;
|
|
}
|
|
return base10Value;
|
|
}
|
|
function pseudoBigIntToString({ negative, base10Value }) {
|
|
return (negative && base10Value !== "0" ? "-" : "") + base10Value;
|
|
}
|
|
function isValidTypeOnlyAliasUseSite(useSite) {
|
|
return !!(useSite.flags & 16777216 /* Ambient */) || isPartOfTypeQuery(useSite) || isIdentifierInNonEmittingHeritageClause(useSite) || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite));
|
|
}
|
|
function isShorthandPropertyNameUseSite(useSite) {
|
|
return isIdentifier(useSite) && isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite;
|
|
}
|
|
function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) {
|
|
while (node.kind === 79 /* Identifier */ || node.kind === 208 /* PropertyAccessExpression */) {
|
|
node = node.parent;
|
|
}
|
|
if (node.kind !== 164 /* ComputedPropertyName */) {
|
|
return false;
|
|
}
|
|
if (hasSyntacticModifier(node.parent, 256 /* Abstract */)) {
|
|
return true;
|
|
}
|
|
const containerKind = node.parent.parent.kind;
|
|
return containerKind === 261 /* InterfaceDeclaration */ || containerKind === 184 /* TypeLiteral */;
|
|
}
|
|
function isIdentifierInNonEmittingHeritageClause(node) {
|
|
if (node.kind !== 79 /* Identifier */)
|
|
return false;
|
|
const heritageClause = findAncestor(node.parent, (parent2) => {
|
|
switch (parent2.kind) {
|
|
case 294 /* HeritageClause */:
|
|
return true;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return false;
|
|
default:
|
|
return "quit";
|
|
}
|
|
});
|
|
return (heritageClause == null ? void 0 : heritageClause.token) === 117 /* ImplementsKeyword */ || (heritageClause == null ? void 0 : heritageClause.parent.kind) === 261 /* InterfaceDeclaration */;
|
|
}
|
|
function isIdentifierTypeReference(node) {
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName);
|
|
}
|
|
function arrayIsHomogeneous(array, comparer = equateValues) {
|
|
if (array.length < 2)
|
|
return true;
|
|
const first2 = array[0];
|
|
for (let i = 1, length2 = array.length; i < length2; i++) {
|
|
const target = array[i];
|
|
if (!comparer(first2, target))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function setTextRangePos(range, pos) {
|
|
range.pos = pos;
|
|
return range;
|
|
}
|
|
function setTextRangeEnd(range, end) {
|
|
range.end = end;
|
|
return range;
|
|
}
|
|
function setTextRangePosEnd(range, pos, end) {
|
|
return setTextRangeEnd(setTextRangePos(range, pos), end);
|
|
}
|
|
function setTextRangePosWidth(range, pos, width) {
|
|
return setTextRangePosEnd(range, pos, pos + width);
|
|
}
|
|
function setNodeFlags(node, newFlags) {
|
|
if (node) {
|
|
node.flags = newFlags;
|
|
}
|
|
return node;
|
|
}
|
|
function setParent(child, parent2) {
|
|
if (child && parent2) {
|
|
child.parent = parent2;
|
|
}
|
|
return child;
|
|
}
|
|
function setEachParent(children, parent2) {
|
|
if (children) {
|
|
for (const child of children) {
|
|
setParent(child, parent2);
|
|
}
|
|
}
|
|
return children;
|
|
}
|
|
function setParentRecursive(rootNode, incremental) {
|
|
if (!rootNode)
|
|
return rootNode;
|
|
forEachChildRecursively(rootNode, isJSDocNode(rootNode) ? bindParentToChildIgnoringJSDoc : bindParentToChild);
|
|
return rootNode;
|
|
function bindParentToChildIgnoringJSDoc(child, parent2) {
|
|
if (incremental && child.parent === parent2) {
|
|
return "skip";
|
|
}
|
|
setParent(child, parent2);
|
|
}
|
|
function bindJSDoc(child) {
|
|
if (hasJSDocNodes(child)) {
|
|
for (const doc of child.jsDoc) {
|
|
bindParentToChildIgnoringJSDoc(doc, child);
|
|
forEachChildRecursively(doc, bindParentToChildIgnoringJSDoc);
|
|
}
|
|
}
|
|
}
|
|
function bindParentToChild(child, parent2) {
|
|
return bindParentToChildIgnoringJSDoc(child, parent2) || bindJSDoc(child);
|
|
}
|
|
}
|
|
function isPackedElement(node) {
|
|
return !isOmittedExpression(node);
|
|
}
|
|
function isPackedArrayLiteral(node) {
|
|
return isArrayLiteralExpression(node) && every(node.elements, isPackedElement);
|
|
}
|
|
function expressionResultIsUnused(node) {
|
|
Debug.assertIsDefined(node.parent);
|
|
while (true) {
|
|
const parent2 = node.parent;
|
|
if (isParenthesizedExpression(parent2)) {
|
|
node = parent2;
|
|
continue;
|
|
}
|
|
if (isExpressionStatement(parent2) || isVoidExpression(parent2) || isForStatement(parent2) && (parent2.initializer === node || parent2.incrementor === node)) {
|
|
return true;
|
|
}
|
|
if (isCommaListExpression(parent2)) {
|
|
if (node !== last(parent2.elements))
|
|
return true;
|
|
node = parent2;
|
|
continue;
|
|
}
|
|
if (isBinaryExpression(parent2) && parent2.operatorToken.kind === 27 /* CommaToken */) {
|
|
if (node === parent2.left)
|
|
return true;
|
|
node = parent2;
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function containsIgnoredPath(path) {
|
|
return some(ignoredPaths, (p) => stringContains(path, p));
|
|
}
|
|
function getContainingNodeArray(node) {
|
|
if (!node.parent)
|
|
return void 0;
|
|
switch (node.kind) {
|
|
case 165 /* TypeParameter */:
|
|
const { parent: parent3 } = node;
|
|
return parent3.kind === 192 /* InferType */ ? void 0 : parent3.typeParameters;
|
|
case 166 /* Parameter */:
|
|
return node.parent.parameters;
|
|
case 201 /* TemplateLiteralTypeSpan */:
|
|
return node.parent.templateSpans;
|
|
case 236 /* TemplateSpan */:
|
|
return node.parent.templateSpans;
|
|
case 167 /* Decorator */: {
|
|
const { parent: parent4 } = node;
|
|
return canHaveDecorators(parent4) ? parent4.modifiers : canHaveIllegalDecorators(parent4) ? parent4.illegalDecorators : void 0;
|
|
}
|
|
case 294 /* HeritageClause */:
|
|
return node.parent.heritageClauses;
|
|
}
|
|
const { parent: parent2 } = node;
|
|
if (isJSDocTag(node)) {
|
|
return isJSDocTypeLiteral(node.parent) ? void 0 : node.parent.tags;
|
|
}
|
|
switch (parent2.kind) {
|
|
case 184 /* TypeLiteral */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
return isTypeElement(node) ? parent2.members : void 0;
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return parent2.types;
|
|
case 186 /* TupleType */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 354 /* CommaListExpression */:
|
|
case 272 /* NamedImports */:
|
|
case 276 /* NamedExports */:
|
|
return parent2.elements;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 289 /* JsxAttributes */:
|
|
return parent2.properties;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return isTypeNode(node) ? parent2.typeArguments : parent2.expression === node ? void 0 : parent2.arguments;
|
|
case 281 /* JsxElement */:
|
|
case 285 /* JsxFragment */:
|
|
return isJsxChild(node) ? parent2.children : void 0;
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return isTypeNode(node) ? parent2.typeArguments : void 0;
|
|
case 238 /* Block */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 265 /* ModuleBlock */:
|
|
return parent2.statements;
|
|
case 266 /* CaseBlock */:
|
|
return parent2.clauses;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return isClassElement(node) ? parent2.members : void 0;
|
|
case 263 /* EnumDeclaration */:
|
|
return isEnumMember(node) ? parent2.members : void 0;
|
|
case 308 /* SourceFile */:
|
|
return parent2.statements;
|
|
}
|
|
}
|
|
function hasContextSensitiveParameters(node) {
|
|
if (!node.typeParameters) {
|
|
if (some(node.parameters, (p) => !getEffectiveTypeAnnotationNode(p))) {
|
|
return true;
|
|
}
|
|
if (node.kind !== 216 /* ArrowFunction */) {
|
|
const parameter = firstOrUndefined(node.parameters);
|
|
if (!(parameter && parameterIsThisKeyword(parameter))) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInfinityOrNaNString(name) {
|
|
return name === "Infinity" || name === "-Infinity" || name === "NaN";
|
|
}
|
|
function isCatchClauseVariableDeclaration(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ && node.parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isParameterOrCatchClauseVariable(symbol) {
|
|
const declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration);
|
|
return !!declaration && (isParameter(declaration) || isCatchClauseVariableDeclaration(declaration));
|
|
}
|
|
function isFunctionExpressionOrArrowFunction(node) {
|
|
return node.kind === 215 /* FunctionExpression */ || node.kind === 216 /* ArrowFunction */;
|
|
}
|
|
function escapeSnippetText(text) {
|
|
return text.replace(/\$/gm, () => "\\$");
|
|
}
|
|
function isNumericLiteralName(name) {
|
|
return (+name).toString() === name;
|
|
}
|
|
function createPropertyNameNodeForIdentifierOrLiteral(name, target, singleQuote, stringNamed) {
|
|
return isIdentifierText(name, target) ? factory.createIdentifier(name) : !stringNamed && isNumericLiteralName(name) && +name >= 0 ? factory.createNumericLiteral(+name) : factory.createStringLiteral(name, !!singleQuote);
|
|
}
|
|
function isThisTypeParameter(type) {
|
|
return !!(type.flags & 262144 /* TypeParameter */ && type.isThisType);
|
|
}
|
|
function getNodeModulePathParts(fullPath) {
|
|
let topLevelNodeModulesIndex = 0;
|
|
let topLevelPackageNameIndex = 0;
|
|
let packageRootIndex = 0;
|
|
let fileNameIndex = 0;
|
|
let States;
|
|
((States2) => {
|
|
States2[States2["BeforeNodeModules"] = 0] = "BeforeNodeModules";
|
|
States2[States2["NodeModules"] = 1] = "NodeModules";
|
|
States2[States2["Scope"] = 2] = "Scope";
|
|
States2[States2["PackageContent"] = 3] = "PackageContent";
|
|
})(States || (States = {}));
|
|
let partStart = 0;
|
|
let partEnd = 0;
|
|
let state = 0 /* BeforeNodeModules */;
|
|
while (partEnd >= 0) {
|
|
partStart = partEnd;
|
|
partEnd = fullPath.indexOf("/", partStart + 1);
|
|
switch (state) {
|
|
case 0 /* BeforeNodeModules */:
|
|
if (fullPath.indexOf(nodeModulesPathPart, partStart) === partStart) {
|
|
topLevelNodeModulesIndex = partStart;
|
|
topLevelPackageNameIndex = partEnd;
|
|
state = 1 /* NodeModules */;
|
|
}
|
|
break;
|
|
case 1 /* NodeModules */:
|
|
case 2 /* Scope */:
|
|
if (state === 1 /* NodeModules */ && fullPath.charAt(partStart + 1) === "@") {
|
|
state = 2 /* Scope */;
|
|
} else {
|
|
packageRootIndex = partEnd;
|
|
state = 3 /* PackageContent */;
|
|
}
|
|
break;
|
|
case 3 /* PackageContent */:
|
|
if (fullPath.indexOf(nodeModulesPathPart, partStart) === partStart) {
|
|
state = 1 /* NodeModules */;
|
|
} else {
|
|
state = 3 /* PackageContent */;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
fileNameIndex = partStart;
|
|
return state > 1 /* NodeModules */ ? { topLevelNodeModulesIndex, topLevelPackageNameIndex, packageRootIndex, fileNameIndex } : void 0;
|
|
}
|
|
function getParameterTypeNode(parameter) {
|
|
var _a2;
|
|
return parameter.kind === 343 /* JSDocParameterTag */ ? (_a2 = parameter.typeExpression) == null ? void 0 : _a2.type : parameter.type;
|
|
}
|
|
function isTypeDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 165 /* TypeParameter */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return true;
|
|
case 270 /* ImportClause */:
|
|
return node.isTypeOnly;
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return node.parent.parent.isTypeOnly;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function canHaveExportModifier(node) {
|
|
return isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isTypeDeclaration(node) || isModuleDeclaration(node) && !isExternalModuleAugmentation(node) && !isGlobalScopeAugmentation(node);
|
|
}
|
|
function isOptionalJSDocPropertyLikeTag(node) {
|
|
if (!isJSDocPropertyLikeTag(node)) {
|
|
return false;
|
|
}
|
|
const { isBracketed, typeExpression } = node;
|
|
return isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* JSDocOptionalType */;
|
|
}
|
|
|
|
// src/compiler/factory/baseNodeFactory.ts
|
|
function createBaseNodeFactory() {
|
|
let NodeConstructor2;
|
|
let TokenConstructor2;
|
|
let IdentifierConstructor2;
|
|
let PrivateIdentifierConstructor2;
|
|
let SourceFileConstructor2;
|
|
return {
|
|
createBaseSourceFileNode,
|
|
createBaseIdentifierNode,
|
|
createBasePrivateIdentifierNode,
|
|
createBaseTokenNode,
|
|
createBaseNode
|
|
};
|
|
function createBaseSourceFileNode(kind) {
|
|
return new (SourceFileConstructor2 || (SourceFileConstructor2 = objectAllocator.getSourceFileConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseIdentifierNode(kind) {
|
|
return new (IdentifierConstructor2 || (IdentifierConstructor2 = objectAllocator.getIdentifierConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBasePrivateIdentifierNode(kind) {
|
|
return new (PrivateIdentifierConstructor2 || (PrivateIdentifierConstructor2 = objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseTokenNode(kind) {
|
|
return new (TokenConstructor2 || (TokenConstructor2 = objectAllocator.getTokenConstructor()))(kind, -1, -1);
|
|
}
|
|
function createBaseNode(kind) {
|
|
return new (NodeConstructor2 || (NodeConstructor2 = objectAllocator.getNodeConstructor()))(kind, -1, -1);
|
|
}
|
|
}
|
|
|
|
// src/compiler/factory/parenthesizerRules.ts
|
|
function createParenthesizerRules(factory2) {
|
|
let binaryLeftOperandParenthesizerCache;
|
|
let binaryRightOperandParenthesizerCache;
|
|
return {
|
|
getParenthesizeLeftSideOfBinaryForOperator,
|
|
getParenthesizeRightSideOfBinaryForOperator,
|
|
parenthesizeLeftSideOfBinary,
|
|
parenthesizeRightSideOfBinary,
|
|
parenthesizeExpressionOfComputedPropertyName,
|
|
parenthesizeConditionOfConditionalExpression,
|
|
parenthesizeBranchOfConditionalExpression,
|
|
parenthesizeExpressionOfExportDefault,
|
|
parenthesizeExpressionOfNew,
|
|
parenthesizeLeftSideOfAccess,
|
|
parenthesizeOperandOfPostfixUnary,
|
|
parenthesizeOperandOfPrefixUnary,
|
|
parenthesizeExpressionsOfCommaDelimitedList,
|
|
parenthesizeExpressionForDisallowedComma,
|
|
parenthesizeExpressionOfExpressionStatement,
|
|
parenthesizeConciseBodyOfArrowFunction,
|
|
parenthesizeCheckTypeOfConditionalType,
|
|
parenthesizeExtendsTypeOfConditionalType,
|
|
parenthesizeConstituentTypesOfUnionType,
|
|
parenthesizeConstituentTypeOfUnionType,
|
|
parenthesizeConstituentTypesOfIntersectionType,
|
|
parenthesizeConstituentTypeOfIntersectionType,
|
|
parenthesizeOperandOfTypeOperator,
|
|
parenthesizeOperandOfReadonlyTypeOperator,
|
|
parenthesizeNonArrayTypeOfPostfixType,
|
|
parenthesizeElementTypesOfTupleType,
|
|
parenthesizeElementTypeOfTupleType,
|
|
parenthesizeTypeOfOptionalType,
|
|
parenthesizeTypeArguments,
|
|
parenthesizeLeadingTypeArgument
|
|
};
|
|
function getParenthesizeLeftSideOfBinaryForOperator(operatorKind) {
|
|
binaryLeftOperandParenthesizerCache || (binaryLeftOperandParenthesizerCache = /* @__PURE__ */ new Map());
|
|
let parenthesizerRule = binaryLeftOperandParenthesizerCache.get(operatorKind);
|
|
if (!parenthesizerRule) {
|
|
parenthesizerRule = (node) => parenthesizeLeftSideOfBinary(operatorKind, node);
|
|
binaryLeftOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
|
|
}
|
|
return parenthesizerRule;
|
|
}
|
|
function getParenthesizeRightSideOfBinaryForOperator(operatorKind) {
|
|
binaryRightOperandParenthesizerCache || (binaryRightOperandParenthesizerCache = /* @__PURE__ */ new Map());
|
|
let parenthesizerRule = binaryRightOperandParenthesizerCache.get(operatorKind);
|
|
if (!parenthesizerRule) {
|
|
parenthesizerRule = (node) => parenthesizeRightSideOfBinary(operatorKind, void 0, node);
|
|
binaryRightOperandParenthesizerCache.set(operatorKind, parenthesizerRule);
|
|
}
|
|
return parenthesizerRule;
|
|
}
|
|
function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
|
|
const binaryOperatorPrecedence = getOperatorPrecedence(223 /* BinaryExpression */, binaryOperator);
|
|
const binaryOperatorAssociativity = getOperatorAssociativity(223 /* BinaryExpression */, binaryOperator);
|
|
const emittedOperand = skipPartiallyEmittedExpressions(operand);
|
|
if (!isLeftSideOfBinary && operand.kind === 216 /* ArrowFunction */ && binaryOperatorPrecedence > 3 /* Assignment */) {
|
|
return true;
|
|
}
|
|
const operandPrecedence = getExpressionPrecedence(emittedOperand);
|
|
switch (compareValues(operandPrecedence, binaryOperatorPrecedence)) {
|
|
case -1 /* LessThan */:
|
|
if (!isLeftSideOfBinary && binaryOperatorAssociativity === 1 /* Right */ && operand.kind === 226 /* YieldExpression */) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case 1 /* GreaterThan */:
|
|
return false;
|
|
case 0 /* EqualTo */:
|
|
if (isLeftSideOfBinary) {
|
|
return binaryOperatorAssociativity === 1 /* Right */;
|
|
} else {
|
|
if (isBinaryExpression(emittedOperand) && emittedOperand.operatorToken.kind === binaryOperator) {
|
|
if (operatorHasAssociativeProperty(binaryOperator)) {
|
|
return false;
|
|
}
|
|
if (binaryOperator === 39 /* PlusToken */) {
|
|
const leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0 /* Unknown */;
|
|
if (isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
const operandAssociativity = getExpressionAssociativity(emittedOperand);
|
|
return operandAssociativity === 0 /* Left */;
|
|
}
|
|
}
|
|
}
|
|
function operatorHasAssociativeProperty(binaryOperator) {
|
|
return binaryOperator === 41 /* AsteriskToken */ || binaryOperator === 51 /* BarToken */ || binaryOperator === 50 /* AmpersandToken */ || binaryOperator === 52 /* CaretToken */ || binaryOperator === 27 /* CommaToken */;
|
|
}
|
|
function getLiteralKindOfBinaryPlusOperand(node) {
|
|
node = skipPartiallyEmittedExpressions(node);
|
|
if (isLiteralKind(node.kind)) {
|
|
return node.kind;
|
|
}
|
|
if (node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 39 /* PlusToken */) {
|
|
if (node.cachedLiteralKind !== void 0) {
|
|
return node.cachedLiteralKind;
|
|
}
|
|
const leftKind = getLiteralKindOfBinaryPlusOperand(node.left);
|
|
const literalKind = isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) ? leftKind : 0 /* Unknown */;
|
|
node.cachedLiteralKind = literalKind;
|
|
return literalKind;
|
|
}
|
|
return 0 /* Unknown */;
|
|
}
|
|
function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) {
|
|
const skipped = skipPartiallyEmittedExpressions(operand);
|
|
if (skipped.kind === 214 /* ParenthesizedExpression */) {
|
|
return operand;
|
|
}
|
|
return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) ? factory2.createParenthesizedExpression(operand) : operand;
|
|
}
|
|
function parenthesizeLeftSideOfBinary(binaryOperator, leftSide) {
|
|
return parenthesizeBinaryOperand(binaryOperator, leftSide, true);
|
|
}
|
|
function parenthesizeRightSideOfBinary(binaryOperator, leftSide, rightSide) {
|
|
return parenthesizeBinaryOperand(binaryOperator, rightSide, false, leftSide);
|
|
}
|
|
function parenthesizeExpressionOfComputedPropertyName(expression) {
|
|
return isCommaSequence(expression) ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
function parenthesizeConditionOfConditionalExpression(condition) {
|
|
const conditionalPrecedence = getOperatorPrecedence(224 /* ConditionalExpression */, 57 /* QuestionToken */);
|
|
const emittedCondition = skipPartiallyEmittedExpressions(condition);
|
|
const conditionPrecedence = getExpressionPrecedence(emittedCondition);
|
|
if (compareValues(conditionPrecedence, conditionalPrecedence) !== 1 /* GreaterThan */) {
|
|
return factory2.createParenthesizedExpression(condition);
|
|
}
|
|
return condition;
|
|
}
|
|
function parenthesizeBranchOfConditionalExpression(branch) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(branch);
|
|
return isCommaSequence(emittedExpression) ? factory2.createParenthesizedExpression(branch) : branch;
|
|
}
|
|
function parenthesizeExpressionOfExportDefault(expression) {
|
|
const check = skipPartiallyEmittedExpressions(expression);
|
|
let needsParens = isCommaSequence(check);
|
|
if (!needsParens) {
|
|
switch (getLeftmostExpression(check, false).kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
needsParens = true;
|
|
}
|
|
}
|
|
return needsParens ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
function parenthesizeExpressionOfNew(expression) {
|
|
const leftmostExpr = getLeftmostExpression(expression, true);
|
|
switch (leftmostExpr.kind) {
|
|
case 210 /* CallExpression */:
|
|
return factory2.createParenthesizedExpression(expression);
|
|
case 211 /* NewExpression */:
|
|
return !leftmostExpr.arguments ? factory2.createParenthesizedExpression(expression) : expression;
|
|
}
|
|
return parenthesizeLeftSideOfAccess(expression);
|
|
}
|
|
function parenthesizeLeftSideOfAccess(expression, optionalChain) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (isLeftHandSideExpression(emittedExpression) && (emittedExpression.kind !== 211 /* NewExpression */ || emittedExpression.arguments) && (optionalChain || !isOptionalChain(emittedExpression))) {
|
|
return expression;
|
|
}
|
|
return setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
function parenthesizeOperandOfPostfixUnary(operand) {
|
|
return isLeftHandSideExpression(operand) ? operand : setTextRange(factory2.createParenthesizedExpression(operand), operand);
|
|
}
|
|
function parenthesizeOperandOfPrefixUnary(operand) {
|
|
return isUnaryExpression(operand) ? operand : setTextRange(factory2.createParenthesizedExpression(operand), operand);
|
|
}
|
|
function parenthesizeExpressionsOfCommaDelimitedList(elements) {
|
|
const result = sameMap(elements, parenthesizeExpressionForDisallowedComma);
|
|
return setTextRange(factory2.createNodeArray(result, elements.hasTrailingComma), elements);
|
|
}
|
|
function parenthesizeExpressionForDisallowedComma(expression) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
const expressionPrecedence = getExpressionPrecedence(emittedExpression);
|
|
const commaPrecedence = getOperatorPrecedence(223 /* BinaryExpression */, 27 /* CommaToken */);
|
|
return expressionPrecedence > commaPrecedence ? expression : setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
function parenthesizeExpressionOfExpressionStatement(expression) {
|
|
const emittedExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (isCallExpression(emittedExpression)) {
|
|
const callee = emittedExpression.expression;
|
|
const kind = skipPartiallyEmittedExpressions(callee).kind;
|
|
if (kind === 215 /* FunctionExpression */ || kind === 216 /* ArrowFunction */) {
|
|
const updated = factory2.updateCallExpression(
|
|
emittedExpression,
|
|
setTextRange(factory2.createParenthesizedExpression(callee), callee),
|
|
emittedExpression.typeArguments,
|
|
emittedExpression.arguments
|
|
);
|
|
return factory2.restoreOuterExpressions(expression, updated, 8 /* PartiallyEmittedExpressions */);
|
|
}
|
|
}
|
|
const leftmostExpressionKind = getLeftmostExpression(emittedExpression, false).kind;
|
|
if (leftmostExpressionKind === 207 /* ObjectLiteralExpression */ || leftmostExpressionKind === 215 /* FunctionExpression */) {
|
|
return setTextRange(factory2.createParenthesizedExpression(expression), expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function parenthesizeConciseBodyOfArrowFunction(body) {
|
|
if (!isBlock(body) && (isCommaSequence(body) || getLeftmostExpression(body, false).kind === 207 /* ObjectLiteralExpression */)) {
|
|
return setTextRange(factory2.createParenthesizedExpression(body), body);
|
|
}
|
|
return body;
|
|
}
|
|
function parenthesizeCheckTypeOfConditionalType(checkType) {
|
|
switch (checkType.kind) {
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 191 /* ConditionalType */:
|
|
return factory2.createParenthesizedType(checkType);
|
|
}
|
|
return checkType;
|
|
}
|
|
function parenthesizeExtendsTypeOfConditionalType(extendsType) {
|
|
switch (extendsType.kind) {
|
|
case 191 /* ConditionalType */:
|
|
return factory2.createParenthesizedType(extendsType);
|
|
}
|
|
return extendsType;
|
|
}
|
|
function parenthesizeConstituentTypeOfUnionType(type) {
|
|
switch (type.kind) {
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeCheckTypeOfConditionalType(type);
|
|
}
|
|
function parenthesizeConstituentTypesOfUnionType(members) {
|
|
return factory2.createNodeArray(sameMap(members, parenthesizeConstituentTypeOfUnionType));
|
|
}
|
|
function parenthesizeConstituentTypeOfIntersectionType(type) {
|
|
switch (type.kind) {
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeConstituentTypeOfUnionType(type);
|
|
}
|
|
function parenthesizeConstituentTypesOfIntersectionType(members) {
|
|
return factory2.createNodeArray(sameMap(members, parenthesizeConstituentTypeOfIntersectionType));
|
|
}
|
|
function parenthesizeOperandOfTypeOperator(type) {
|
|
switch (type.kind) {
|
|
case 190 /* IntersectionType */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeConstituentTypeOfIntersectionType(type);
|
|
}
|
|
function parenthesizeOperandOfReadonlyTypeOperator(type) {
|
|
switch (type.kind) {
|
|
case 195 /* TypeOperator */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeOperandOfTypeOperator(type);
|
|
}
|
|
function parenthesizeNonArrayTypeOfPostfixType(type) {
|
|
switch (type.kind) {
|
|
case 192 /* InferType */:
|
|
case 195 /* TypeOperator */:
|
|
case 183 /* TypeQuery */:
|
|
return factory2.createParenthesizedType(type);
|
|
}
|
|
return parenthesizeOperandOfTypeOperator(type);
|
|
}
|
|
function parenthesizeElementTypesOfTupleType(types) {
|
|
return factory2.createNodeArray(sameMap(types, parenthesizeElementTypeOfTupleType));
|
|
}
|
|
function parenthesizeElementTypeOfTupleType(type) {
|
|
if (hasJSDocPostfixQuestion(type))
|
|
return factory2.createParenthesizedType(type);
|
|
return type;
|
|
}
|
|
function hasJSDocPostfixQuestion(type) {
|
|
if (isJSDocNullableType(type))
|
|
return type.postfix;
|
|
if (isNamedTupleMember(type))
|
|
return hasJSDocPostfixQuestion(type.type);
|
|
if (isFunctionTypeNode(type) || isConstructorTypeNode(type) || isTypeOperatorNode(type))
|
|
return hasJSDocPostfixQuestion(type.type);
|
|
if (isConditionalTypeNode(type))
|
|
return hasJSDocPostfixQuestion(type.falseType);
|
|
if (isUnionTypeNode(type))
|
|
return hasJSDocPostfixQuestion(last(type.types));
|
|
if (isIntersectionTypeNode(type))
|
|
return hasJSDocPostfixQuestion(last(type.types));
|
|
if (isInferTypeNode(type))
|
|
return !!type.typeParameter.constraint && hasJSDocPostfixQuestion(type.typeParameter.constraint);
|
|
return false;
|
|
}
|
|
function parenthesizeTypeOfOptionalType(type) {
|
|
if (hasJSDocPostfixQuestion(type))
|
|
return factory2.createParenthesizedType(type);
|
|
return parenthesizeNonArrayTypeOfPostfixType(type);
|
|
}
|
|
function parenthesizeLeadingTypeArgument(node) {
|
|
return isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory2.createParenthesizedType(node) : node;
|
|
}
|
|
function parenthesizeOrdinalTypeArgument(node, i) {
|
|
return i === 0 ? parenthesizeLeadingTypeArgument(node) : node;
|
|
}
|
|
function parenthesizeTypeArguments(typeArguments) {
|
|
if (some(typeArguments)) {
|
|
return factory2.createNodeArray(sameMap(typeArguments, parenthesizeOrdinalTypeArgument));
|
|
}
|
|
}
|
|
}
|
|
var nullParenthesizerRules = {
|
|
getParenthesizeLeftSideOfBinaryForOperator: (_) => identity,
|
|
getParenthesizeRightSideOfBinaryForOperator: (_) => identity,
|
|
parenthesizeLeftSideOfBinary: (_binaryOperator, leftSide) => leftSide,
|
|
parenthesizeRightSideOfBinary: (_binaryOperator, _leftSide, rightSide) => rightSide,
|
|
parenthesizeExpressionOfComputedPropertyName: identity,
|
|
parenthesizeConditionOfConditionalExpression: identity,
|
|
parenthesizeBranchOfConditionalExpression: identity,
|
|
parenthesizeExpressionOfExportDefault: identity,
|
|
parenthesizeExpressionOfNew: (expression) => cast(expression, isLeftHandSideExpression),
|
|
parenthesizeLeftSideOfAccess: (expression) => cast(expression, isLeftHandSideExpression),
|
|
parenthesizeOperandOfPostfixUnary: (operand) => cast(operand, isLeftHandSideExpression),
|
|
parenthesizeOperandOfPrefixUnary: (operand) => cast(operand, isUnaryExpression),
|
|
parenthesizeExpressionsOfCommaDelimitedList: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeExpressionForDisallowedComma: identity,
|
|
parenthesizeExpressionOfExpressionStatement: identity,
|
|
parenthesizeConciseBodyOfArrowFunction: identity,
|
|
parenthesizeCheckTypeOfConditionalType: identity,
|
|
parenthesizeExtendsTypeOfConditionalType: identity,
|
|
parenthesizeConstituentTypesOfUnionType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeConstituentTypeOfUnionType: identity,
|
|
parenthesizeConstituentTypesOfIntersectionType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeConstituentTypeOfIntersectionType: identity,
|
|
parenthesizeOperandOfTypeOperator: identity,
|
|
parenthesizeOperandOfReadonlyTypeOperator: identity,
|
|
parenthesizeNonArrayTypeOfPostfixType: identity,
|
|
parenthesizeElementTypesOfTupleType: (nodes) => cast(nodes, isNodeArray),
|
|
parenthesizeElementTypeOfTupleType: identity,
|
|
parenthesizeTypeOfOptionalType: identity,
|
|
parenthesizeTypeArguments: (nodes) => nodes && cast(nodes, isNodeArray),
|
|
parenthesizeLeadingTypeArgument: identity
|
|
};
|
|
|
|
// src/compiler/factory/nodeConverters.ts
|
|
function createNodeConverters(factory2) {
|
|
return {
|
|
convertToFunctionBlock,
|
|
convertToFunctionExpression,
|
|
convertToArrayAssignmentElement,
|
|
convertToObjectAssignmentElement,
|
|
convertToAssignmentPattern,
|
|
convertToObjectAssignmentPattern,
|
|
convertToArrayAssignmentPattern,
|
|
convertToAssignmentElementTarget
|
|
};
|
|
function convertToFunctionBlock(node, multiLine) {
|
|
if (isBlock(node))
|
|
return node;
|
|
const returnStatement = factory2.createReturnStatement(node);
|
|
setTextRange(returnStatement, node);
|
|
const body = factory2.createBlock([returnStatement], multiLine);
|
|
setTextRange(body, node);
|
|
return body;
|
|
}
|
|
function convertToFunctionExpression(node) {
|
|
if (!node.body)
|
|
return Debug.fail(`Cannot convert a FunctionDeclaration without a body`);
|
|
const updated = factory2.createFunctionExpression(
|
|
node.modifiers,
|
|
node.asteriskToken,
|
|
node.name,
|
|
node.typeParameters,
|
|
node.parameters,
|
|
node.type,
|
|
node.body
|
|
);
|
|
setOriginalNode(updated, node);
|
|
setTextRange(updated, node);
|
|
if (getStartsOnNewLine(node)) {
|
|
setStartsOnNewLine(updated, true);
|
|
}
|
|
return updated;
|
|
}
|
|
function convertToArrayAssignmentElement(element) {
|
|
if (isBindingElement(element)) {
|
|
if (element.dotDotDotToken) {
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createSpreadElement(element.name), element), element);
|
|
}
|
|
const expression = convertToAssignmentElementTarget(element.name);
|
|
return element.initializer ? setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(expression, element.initializer),
|
|
element
|
|
),
|
|
element
|
|
) : expression;
|
|
}
|
|
return cast(element, isExpression);
|
|
}
|
|
function convertToObjectAssignmentElement(element) {
|
|
if (isBindingElement(element)) {
|
|
if (element.dotDotDotToken) {
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createSpreadAssignment(element.name), element), element);
|
|
}
|
|
if (element.propertyName) {
|
|
const expression = convertToAssignmentElementTarget(element.name);
|
|
return setOriginalNode(setTextRange(factory2.createPropertyAssignment(element.propertyName, element.initializer ? factory2.createAssignment(expression, element.initializer) : expression), element), element);
|
|
}
|
|
Debug.assertNode(element.name, isIdentifier);
|
|
return setOriginalNode(setTextRange(factory2.createShorthandPropertyAssignment(element.name, element.initializer), element), element);
|
|
}
|
|
return cast(element, isObjectLiteralElementLike);
|
|
}
|
|
function convertToAssignmentPattern(node) {
|
|
switch (node.kind) {
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return convertToArrayAssignmentPattern(node);
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return convertToObjectAssignmentPattern(node);
|
|
}
|
|
}
|
|
function convertToObjectAssignmentPattern(node) {
|
|
if (isObjectBindingPattern(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createObjectLiteralExpression(map(node.elements, convertToObjectAssignmentElement)),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return cast(node, isObjectLiteralExpression);
|
|
}
|
|
function convertToArrayAssignmentPattern(node) {
|
|
if (isArrayBindingPattern(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createArrayLiteralExpression(map(node.elements, convertToArrayAssignmentElement)),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return cast(node, isArrayLiteralExpression);
|
|
}
|
|
function convertToAssignmentElementTarget(node) {
|
|
if (isBindingPattern(node)) {
|
|
return convertToAssignmentPattern(node);
|
|
}
|
|
return cast(node, isExpression);
|
|
}
|
|
}
|
|
var nullNodeConverters = {
|
|
convertToFunctionBlock: notImplemented,
|
|
convertToFunctionExpression: notImplemented,
|
|
convertToArrayAssignmentElement: notImplemented,
|
|
convertToObjectAssignmentElement: notImplemented,
|
|
convertToAssignmentPattern: notImplemented,
|
|
convertToObjectAssignmentPattern: notImplemented,
|
|
convertToArrayAssignmentPattern: notImplemented,
|
|
convertToAssignmentElementTarget: notImplemented
|
|
};
|
|
|
|
// src/compiler/factory/nodeFactory.ts
|
|
var nextAutoGenerateId = 0;
|
|
var NodeFactoryFlags = /* @__PURE__ */ ((NodeFactoryFlags2) => {
|
|
NodeFactoryFlags2[NodeFactoryFlags2["None"] = 0] = "None";
|
|
NodeFactoryFlags2[NodeFactoryFlags2["NoParenthesizerRules"] = 1] = "NoParenthesizerRules";
|
|
NodeFactoryFlags2[NodeFactoryFlags2["NoNodeConverters"] = 2] = "NoNodeConverters";
|
|
NodeFactoryFlags2[NodeFactoryFlags2["NoIndentationOnFreshPropertyAccess"] = 4] = "NoIndentationOnFreshPropertyAccess";
|
|
NodeFactoryFlags2[NodeFactoryFlags2["NoOriginalNode"] = 8] = "NoOriginalNode";
|
|
return NodeFactoryFlags2;
|
|
})(NodeFactoryFlags || {});
|
|
var nodeFactoryPatchers = [];
|
|
function addNodeFactoryPatcher(fn) {
|
|
nodeFactoryPatchers.push(fn);
|
|
}
|
|
function createNodeFactory(flags, baseFactory2) {
|
|
const update = flags & 8 /* NoOriginalNode */ ? updateWithoutOriginal : updateWithOriginal;
|
|
const parenthesizerRules = memoize(() => flags & 1 /* NoParenthesizerRules */ ? nullParenthesizerRules : createParenthesizerRules(factory2));
|
|
const converters = memoize(() => flags & 2 /* NoNodeConverters */ ? nullNodeConverters : createNodeConverters(factory2));
|
|
const getBinaryCreateFunction = memoizeOne((operator) => (left, right) => createBinaryExpression(left, operator, right));
|
|
const getPrefixUnaryCreateFunction = memoizeOne((operator) => (operand) => createPrefixUnaryExpression(operator, operand));
|
|
const getPostfixUnaryCreateFunction = memoizeOne((operator) => (operand) => createPostfixUnaryExpression(operand, operator));
|
|
const getJSDocPrimaryTypeCreateFunction = memoizeOne((kind) => () => createJSDocPrimaryTypeWorker(kind));
|
|
const getJSDocUnaryTypeCreateFunction = memoizeOne((kind) => (type) => createJSDocUnaryTypeWorker(kind, type));
|
|
const getJSDocUnaryTypeUpdateFunction = memoizeOne((kind) => (node, type) => updateJSDocUnaryTypeWorker(kind, node, type));
|
|
const getJSDocPrePostfixUnaryTypeCreateFunction = memoizeOne((kind) => (type, postfix) => createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix));
|
|
const getJSDocPrePostfixUnaryTypeUpdateFunction = memoizeOne((kind) => (node, type) => updateJSDocPrePostfixUnaryTypeWorker(kind, node, type));
|
|
const getJSDocSimpleTagCreateFunction = memoizeOne((kind) => (tagName, comment) => createJSDocSimpleTagWorker(kind, tagName, comment));
|
|
const getJSDocSimpleTagUpdateFunction = memoizeOne((kind) => (node, tagName, comment) => updateJSDocSimpleTagWorker(kind, node, tagName, comment));
|
|
const getJSDocTypeLikeTagCreateFunction = memoizeOne((kind) => (tagName, typeExpression, comment) => createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment));
|
|
const getJSDocTypeLikeTagUpdateFunction = memoizeOne((kind) => (node, tagName, typeExpression, comment) => updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment));
|
|
const factory2 = {
|
|
get parenthesizer() {
|
|
return parenthesizerRules();
|
|
},
|
|
get converters() {
|
|
return converters();
|
|
},
|
|
baseFactory: baseFactory2,
|
|
flags,
|
|
createNodeArray: createNodeArray2,
|
|
createNumericLiteral: createNumericLiteral2,
|
|
createBigIntLiteral: createBigIntLiteral2,
|
|
createStringLiteral: createStringLiteral2,
|
|
createStringLiteralFromNode: createStringLiteralFromNode2,
|
|
createRegularExpressionLiteral: createRegularExpressionLiteral2,
|
|
createLiteralLikeNode,
|
|
createIdentifier: createIdentifier3,
|
|
updateIdentifier,
|
|
createTempVariable: createTempVariable3,
|
|
createLoopVariable: createLoopVariable2,
|
|
createUniqueName: createUniqueName2,
|
|
getGeneratedNameForNode: getGeneratedNameForNode3,
|
|
createPrivateIdentifier: createPrivateIdentifier2,
|
|
createUniquePrivateName,
|
|
getGeneratedPrivateNameForNode,
|
|
createToken: createToken3,
|
|
createSuper: createSuper2,
|
|
createThis: createThis2,
|
|
createNull: createNull2,
|
|
createTrue: createTrue2,
|
|
createFalse: createFalse2,
|
|
createModifier: createModifier2,
|
|
createModifiersFromModifierFlags: createModifiersFromModifierFlags2,
|
|
createQualifiedName: createQualifiedName2,
|
|
updateQualifiedName: updateQualifiedName2,
|
|
createComputedPropertyName: createComputedPropertyName2,
|
|
updateComputedPropertyName: updateComputedPropertyName2,
|
|
createTypeParameterDeclaration: createTypeParameterDeclaration2,
|
|
updateTypeParameterDeclaration: updateTypeParameterDeclaration2,
|
|
createParameterDeclaration,
|
|
updateParameterDeclaration,
|
|
createDecorator: createDecorator2,
|
|
updateDecorator: updateDecorator2,
|
|
createPropertySignature: createPropertySignature3,
|
|
updatePropertySignature: updatePropertySignature3,
|
|
createPropertyDeclaration,
|
|
updatePropertyDeclaration: updatePropertyDeclaration2,
|
|
createMethodSignature: createMethodSignature3,
|
|
updateMethodSignature: updateMethodSignature3,
|
|
createMethodDeclaration,
|
|
updateMethodDeclaration,
|
|
createConstructorDeclaration,
|
|
updateConstructorDeclaration,
|
|
createGetAccessorDeclaration,
|
|
updateGetAccessorDeclaration,
|
|
createSetAccessorDeclaration,
|
|
updateSetAccessorDeclaration,
|
|
createCallSignature: createCallSignature2,
|
|
updateCallSignature: updateCallSignature2,
|
|
createConstructSignature: createConstructSignature2,
|
|
updateConstructSignature: updateConstructSignature2,
|
|
createIndexSignature: createIndexSignature3,
|
|
updateIndexSignature: updateIndexSignature2,
|
|
createClassStaticBlockDeclaration,
|
|
updateClassStaticBlockDeclaration,
|
|
createTemplateLiteralTypeSpan,
|
|
updateTemplateLiteralTypeSpan,
|
|
createKeywordTypeNode: createKeywordTypeNode2,
|
|
createTypePredicateNode: createTypePredicateNode3,
|
|
updateTypePredicateNode: updateTypePredicateNode3,
|
|
createTypeReferenceNode: createTypeReferenceNode2,
|
|
updateTypeReferenceNode: updateTypeReferenceNode2,
|
|
createFunctionTypeNode: createFunctionTypeNode2,
|
|
updateFunctionTypeNode: updateFunctionTypeNode2,
|
|
createConstructorTypeNode: createConstructorTypeNode2,
|
|
updateConstructorTypeNode: updateConstructorTypeNode2,
|
|
createTypeQueryNode: createTypeQueryNode2,
|
|
updateTypeQueryNode: updateTypeQueryNode2,
|
|
createTypeLiteralNode: createTypeLiteralNode2,
|
|
updateTypeLiteralNode: updateTypeLiteralNode2,
|
|
createArrayTypeNode: createArrayTypeNode2,
|
|
updateArrayTypeNode: updateArrayTypeNode2,
|
|
createTupleTypeNode: createTupleTypeNode2,
|
|
updateTupleTypeNode: updateTupleTypeNode2,
|
|
createNamedTupleMember,
|
|
updateNamedTupleMember,
|
|
createOptionalTypeNode: createOptionalTypeNode2,
|
|
updateOptionalTypeNode: updateOptionalTypeNode2,
|
|
createRestTypeNode: createRestTypeNode2,
|
|
updateRestTypeNode: updateRestTypeNode2,
|
|
createUnionTypeNode: createUnionTypeNode2,
|
|
updateUnionTypeNode: updateUnionTypeNode2,
|
|
createIntersectionTypeNode: createIntersectionTypeNode2,
|
|
updateIntersectionTypeNode: updateIntersectionTypeNode2,
|
|
createConditionalTypeNode: createConditionalTypeNode2,
|
|
updateConditionalTypeNode: updateConditionalTypeNode2,
|
|
createInferTypeNode: createInferTypeNode2,
|
|
updateInferTypeNode: updateInferTypeNode2,
|
|
createImportTypeNode: createImportTypeNode2,
|
|
updateImportTypeNode: updateImportTypeNode2,
|
|
createParenthesizedType: createParenthesizedType2,
|
|
updateParenthesizedType: updateParenthesizedType2,
|
|
createThisTypeNode: createThisTypeNode2,
|
|
createTypeOperatorNode: createTypeOperatorNode3,
|
|
updateTypeOperatorNode: updateTypeOperatorNode2,
|
|
createIndexedAccessTypeNode: createIndexedAccessTypeNode2,
|
|
updateIndexedAccessTypeNode: updateIndexedAccessTypeNode2,
|
|
createMappedTypeNode: createMappedTypeNode2,
|
|
updateMappedTypeNode: updateMappedTypeNode2,
|
|
createLiteralTypeNode: createLiteralTypeNode2,
|
|
updateLiteralTypeNode: updateLiteralTypeNode2,
|
|
createTemplateLiteralType,
|
|
updateTemplateLiteralType,
|
|
createObjectBindingPattern: createObjectBindingPattern2,
|
|
updateObjectBindingPattern: updateObjectBindingPattern2,
|
|
createArrayBindingPattern: createArrayBindingPattern2,
|
|
updateArrayBindingPattern: updateArrayBindingPattern2,
|
|
createBindingElement: createBindingElement2,
|
|
updateBindingElement: updateBindingElement2,
|
|
createArrayLiteralExpression,
|
|
updateArrayLiteralExpression,
|
|
createObjectLiteralExpression,
|
|
updateObjectLiteralExpression,
|
|
createPropertyAccessExpression: flags & 4 /* NoIndentationOnFreshPropertyAccess */ ? (expression, name) => setEmitFlags(createPropertyAccessExpression(expression, name), 262144 /* NoIndentation */) : createPropertyAccessExpression,
|
|
updatePropertyAccessExpression,
|
|
createPropertyAccessChain: flags & 4 /* NoIndentationOnFreshPropertyAccess */ ? (expression, questionDotToken, name) => setEmitFlags(createPropertyAccessChain2(expression, questionDotToken, name), 262144 /* NoIndentation */) : createPropertyAccessChain2,
|
|
updatePropertyAccessChain: updatePropertyAccessChain2,
|
|
createElementAccessExpression,
|
|
updateElementAccessExpression,
|
|
createElementAccessChain: createElementAccessChain2,
|
|
updateElementAccessChain: updateElementAccessChain2,
|
|
createCallExpression,
|
|
updateCallExpression,
|
|
createCallChain: createCallChain2,
|
|
updateCallChain: updateCallChain2,
|
|
createNewExpression,
|
|
updateNewExpression,
|
|
createTaggedTemplateExpression,
|
|
updateTaggedTemplateExpression,
|
|
createTypeAssertion: createTypeAssertion2,
|
|
updateTypeAssertion: updateTypeAssertion2,
|
|
createParenthesizedExpression,
|
|
updateParenthesizedExpression,
|
|
createFunctionExpression: createFunctionExpression2,
|
|
updateFunctionExpression: updateFunctionExpression2,
|
|
createArrowFunction: createArrowFunction3,
|
|
updateArrowFunction: updateArrowFunction3,
|
|
createDeleteExpression,
|
|
updateDeleteExpression,
|
|
createTypeOfExpression,
|
|
updateTypeOfExpression,
|
|
createVoidExpression,
|
|
updateVoidExpression,
|
|
createAwaitExpression,
|
|
updateAwaitExpression,
|
|
createPrefixUnaryExpression,
|
|
updatePrefixUnaryExpression,
|
|
createPostfixUnaryExpression,
|
|
updatePostfixUnaryExpression,
|
|
createBinaryExpression,
|
|
updateBinaryExpression,
|
|
createConditionalExpression,
|
|
updateConditionalExpression,
|
|
createTemplateExpression: createTemplateExpression2,
|
|
updateTemplateExpression: updateTemplateExpression2,
|
|
createTemplateHead: createTemplateHead2,
|
|
createTemplateMiddle: createTemplateMiddle2,
|
|
createTemplateTail: createTemplateTail2,
|
|
createNoSubstitutionTemplateLiteral: createNoSubstitutionTemplateLiteral2,
|
|
createTemplateLiteralLikeNode,
|
|
createYieldExpression,
|
|
updateYieldExpression,
|
|
createSpreadElement,
|
|
updateSpreadElement,
|
|
createClassExpression: createClassExpression3,
|
|
updateClassExpression: updateClassExpression3,
|
|
createOmittedExpression: createOmittedExpression2,
|
|
createExpressionWithTypeArguments: createExpressionWithTypeArguments3,
|
|
updateExpressionWithTypeArguments: updateExpressionWithTypeArguments3,
|
|
createAsExpression: createAsExpression2,
|
|
updateAsExpression: updateAsExpression2,
|
|
createNonNullExpression: createNonNullExpression2,
|
|
updateNonNullExpression: updateNonNullExpression2,
|
|
createSatisfiesExpression,
|
|
updateSatisfiesExpression,
|
|
createNonNullChain: createNonNullChain2,
|
|
updateNonNullChain: updateNonNullChain2,
|
|
createMetaProperty: createMetaProperty2,
|
|
updateMetaProperty: updateMetaProperty2,
|
|
createTemplateSpan: createTemplateSpan2,
|
|
updateTemplateSpan: updateTemplateSpan2,
|
|
createSemicolonClassElement: createSemicolonClassElement2,
|
|
createBlock: createBlock2,
|
|
updateBlock: updateBlock2,
|
|
createVariableStatement: createVariableStatement2,
|
|
updateVariableStatement: updateVariableStatement2,
|
|
createEmptyStatement: createEmptyStatement2,
|
|
createExpressionStatement: createExpressionStatement2,
|
|
updateExpressionStatement: updateExpressionStatement2,
|
|
createIfStatement,
|
|
updateIfStatement,
|
|
createDoStatement,
|
|
updateDoStatement,
|
|
createWhileStatement,
|
|
updateWhileStatement,
|
|
createForStatement,
|
|
updateForStatement,
|
|
createForInStatement,
|
|
updateForInStatement,
|
|
createForOfStatement,
|
|
updateForOfStatement,
|
|
createContinueStatement,
|
|
updateContinueStatement,
|
|
createBreakStatement,
|
|
updateBreakStatement,
|
|
createReturnStatement,
|
|
updateReturnStatement,
|
|
createWithStatement,
|
|
updateWithStatement,
|
|
createSwitchStatement,
|
|
updateSwitchStatement,
|
|
createLabeledStatement,
|
|
updateLabeledStatement,
|
|
createThrowStatement,
|
|
updateThrowStatement,
|
|
createTryStatement,
|
|
updateTryStatement,
|
|
createDebuggerStatement: createDebuggerStatement2,
|
|
createVariableDeclaration: createVariableDeclaration3,
|
|
updateVariableDeclaration: updateVariableDeclaration3,
|
|
createVariableDeclarationList: createVariableDeclarationList2,
|
|
updateVariableDeclarationList: updateVariableDeclarationList2,
|
|
createFunctionDeclaration: createFunctionDeclaration2,
|
|
updateFunctionDeclaration: updateFunctionDeclaration2,
|
|
createClassDeclaration: createClassDeclaration2,
|
|
updateClassDeclaration: updateClassDeclaration2,
|
|
createInterfaceDeclaration: createInterfaceDeclaration2,
|
|
updateInterfaceDeclaration: updateInterfaceDeclaration2,
|
|
createTypeAliasDeclaration: createTypeAliasDeclaration2,
|
|
updateTypeAliasDeclaration: updateTypeAliasDeclaration2,
|
|
createEnumDeclaration: createEnumDeclaration2,
|
|
updateEnumDeclaration: updateEnumDeclaration2,
|
|
createModuleDeclaration: createModuleDeclaration2,
|
|
updateModuleDeclaration: updateModuleDeclaration2,
|
|
createModuleBlock: createModuleBlock2,
|
|
updateModuleBlock: updateModuleBlock2,
|
|
createCaseBlock: createCaseBlock2,
|
|
updateCaseBlock: updateCaseBlock2,
|
|
createNamespaceExportDeclaration: createNamespaceExportDeclaration2,
|
|
updateNamespaceExportDeclaration: updateNamespaceExportDeclaration2,
|
|
createImportEqualsDeclaration: createImportEqualsDeclaration2,
|
|
updateImportEqualsDeclaration: updateImportEqualsDeclaration2,
|
|
createImportDeclaration: createImportDeclaration2,
|
|
updateImportDeclaration: updateImportDeclaration2,
|
|
createImportClause: createImportClause3,
|
|
updateImportClause: updateImportClause3,
|
|
createAssertClause,
|
|
updateAssertClause,
|
|
createAssertEntry,
|
|
updateAssertEntry,
|
|
createImportTypeAssertionContainer,
|
|
updateImportTypeAssertionContainer,
|
|
createNamespaceImport: createNamespaceImport2,
|
|
updateNamespaceImport: updateNamespaceImport2,
|
|
createNamespaceExport: createNamespaceExport2,
|
|
updateNamespaceExport: updateNamespaceExport2,
|
|
createNamedImports: createNamedImports2,
|
|
updateNamedImports: updateNamedImports2,
|
|
createImportSpecifier: createImportSpecifier2,
|
|
updateImportSpecifier: updateImportSpecifier2,
|
|
createExportAssignment: createExportAssignment3,
|
|
updateExportAssignment: updateExportAssignment2,
|
|
createExportDeclaration: createExportDeclaration3,
|
|
updateExportDeclaration: updateExportDeclaration3,
|
|
createNamedExports: createNamedExports2,
|
|
updateNamedExports: updateNamedExports2,
|
|
createExportSpecifier: createExportSpecifier2,
|
|
updateExportSpecifier: updateExportSpecifier2,
|
|
createMissingDeclaration,
|
|
createExternalModuleReference: createExternalModuleReference2,
|
|
updateExternalModuleReference: updateExternalModuleReference2,
|
|
get createJSDocAllType() {
|
|
return getJSDocPrimaryTypeCreateFunction(315 /* JSDocAllType */);
|
|
},
|
|
get createJSDocUnknownType() {
|
|
return getJSDocPrimaryTypeCreateFunction(316 /* JSDocUnknownType */);
|
|
},
|
|
get createJSDocNonNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeCreateFunction(318 /* JSDocNonNullableType */);
|
|
},
|
|
get updateJSDocNonNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeUpdateFunction(318 /* JSDocNonNullableType */);
|
|
},
|
|
get createJSDocNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeCreateFunction(317 /* JSDocNullableType */);
|
|
},
|
|
get updateJSDocNullableType() {
|
|
return getJSDocPrePostfixUnaryTypeUpdateFunction(317 /* JSDocNullableType */);
|
|
},
|
|
get createJSDocOptionalType() {
|
|
return getJSDocUnaryTypeCreateFunction(319 /* JSDocOptionalType */);
|
|
},
|
|
get updateJSDocOptionalType() {
|
|
return getJSDocUnaryTypeUpdateFunction(319 /* JSDocOptionalType */);
|
|
},
|
|
get createJSDocVariadicType() {
|
|
return getJSDocUnaryTypeCreateFunction(321 /* JSDocVariadicType */);
|
|
},
|
|
get updateJSDocVariadicType() {
|
|
return getJSDocUnaryTypeUpdateFunction(321 /* JSDocVariadicType */);
|
|
},
|
|
get createJSDocNamepathType() {
|
|
return getJSDocUnaryTypeCreateFunction(322 /* JSDocNamepathType */);
|
|
},
|
|
get updateJSDocNamepathType() {
|
|
return getJSDocUnaryTypeUpdateFunction(322 /* JSDocNamepathType */);
|
|
},
|
|
createJSDocFunctionType,
|
|
updateJSDocFunctionType,
|
|
createJSDocTypeLiteral: createJSDocTypeLiteral2,
|
|
updateJSDocTypeLiteral,
|
|
createJSDocTypeExpression: createJSDocTypeExpression2,
|
|
updateJSDocTypeExpression,
|
|
createJSDocSignature: createJSDocSignature2,
|
|
updateJSDocSignature,
|
|
createJSDocTemplateTag: createJSDocTemplateTag2,
|
|
updateJSDocTemplateTag,
|
|
createJSDocTypedefTag: createJSDocTypedefTag2,
|
|
updateJSDocTypedefTag,
|
|
createJSDocParameterTag: createJSDocParameterTag2,
|
|
updateJSDocParameterTag,
|
|
createJSDocPropertyTag: createJSDocPropertyTag2,
|
|
updateJSDocPropertyTag,
|
|
createJSDocCallbackTag: createJSDocCallbackTag2,
|
|
updateJSDocCallbackTag,
|
|
createJSDocAugmentsTag: createJSDocAugmentsTag2,
|
|
updateJSDocAugmentsTag,
|
|
createJSDocImplementsTag: createJSDocImplementsTag2,
|
|
updateJSDocImplementsTag,
|
|
createJSDocSeeTag,
|
|
updateJSDocSeeTag,
|
|
createJSDocNameReference,
|
|
updateJSDocNameReference,
|
|
createJSDocMemberName,
|
|
updateJSDocMemberName,
|
|
createJSDocLink,
|
|
updateJSDocLink,
|
|
createJSDocLinkCode,
|
|
updateJSDocLinkCode,
|
|
createJSDocLinkPlain,
|
|
updateJSDocLinkPlain,
|
|
get createJSDocTypeTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(346 /* JSDocTypeTag */);
|
|
},
|
|
get updateJSDocTypeTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(346 /* JSDocTypeTag */);
|
|
},
|
|
get createJSDocReturnTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(344 /* JSDocReturnTag */);
|
|
},
|
|
get updateJSDocReturnTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(344 /* JSDocReturnTag */);
|
|
},
|
|
get createJSDocThisTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(345 /* JSDocThisTag */);
|
|
},
|
|
get updateJSDocThisTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(345 /* JSDocThisTag */);
|
|
},
|
|
get createJSDocEnumTag() {
|
|
return getJSDocTypeLikeTagCreateFunction(342 /* JSDocEnumTag */);
|
|
},
|
|
get updateJSDocEnumTag() {
|
|
return getJSDocTypeLikeTagUpdateFunction(342 /* JSDocEnumTag */);
|
|
},
|
|
get createJSDocAuthorTag() {
|
|
return getJSDocSimpleTagCreateFunction(333 /* JSDocAuthorTag */);
|
|
},
|
|
get updateJSDocAuthorTag() {
|
|
return getJSDocSimpleTagUpdateFunction(333 /* JSDocAuthorTag */);
|
|
},
|
|
get createJSDocClassTag() {
|
|
return getJSDocSimpleTagCreateFunction(335 /* JSDocClassTag */);
|
|
},
|
|
get updateJSDocClassTag() {
|
|
return getJSDocSimpleTagUpdateFunction(335 /* JSDocClassTag */);
|
|
},
|
|
get createJSDocPublicTag() {
|
|
return getJSDocSimpleTagCreateFunction(336 /* JSDocPublicTag */);
|
|
},
|
|
get updateJSDocPublicTag() {
|
|
return getJSDocSimpleTagUpdateFunction(336 /* JSDocPublicTag */);
|
|
},
|
|
get createJSDocPrivateTag() {
|
|
return getJSDocSimpleTagCreateFunction(337 /* JSDocPrivateTag */);
|
|
},
|
|
get updateJSDocPrivateTag() {
|
|
return getJSDocSimpleTagUpdateFunction(337 /* JSDocPrivateTag */);
|
|
},
|
|
get createJSDocProtectedTag() {
|
|
return getJSDocSimpleTagCreateFunction(338 /* JSDocProtectedTag */);
|
|
},
|
|
get updateJSDocProtectedTag() {
|
|
return getJSDocSimpleTagUpdateFunction(338 /* JSDocProtectedTag */);
|
|
},
|
|
get createJSDocReadonlyTag() {
|
|
return getJSDocSimpleTagCreateFunction(339 /* JSDocReadonlyTag */);
|
|
},
|
|
get updateJSDocReadonlyTag() {
|
|
return getJSDocSimpleTagUpdateFunction(339 /* JSDocReadonlyTag */);
|
|
},
|
|
get createJSDocOverrideTag() {
|
|
return getJSDocSimpleTagCreateFunction(340 /* JSDocOverrideTag */);
|
|
},
|
|
get updateJSDocOverrideTag() {
|
|
return getJSDocSimpleTagUpdateFunction(340 /* JSDocOverrideTag */);
|
|
},
|
|
get createJSDocDeprecatedTag() {
|
|
return getJSDocSimpleTagCreateFunction(334 /* JSDocDeprecatedTag */);
|
|
},
|
|
get updateJSDocDeprecatedTag() {
|
|
return getJSDocSimpleTagUpdateFunction(334 /* JSDocDeprecatedTag */);
|
|
},
|
|
createJSDocUnknownTag,
|
|
updateJSDocUnknownTag,
|
|
createJSDocText,
|
|
updateJSDocText,
|
|
createJSDocComment: createJSDocComment2,
|
|
updateJSDocComment,
|
|
createJsxElement: createJsxElement2,
|
|
updateJsxElement: updateJsxElement2,
|
|
createJsxSelfClosingElement: createJsxSelfClosingElement2,
|
|
updateJsxSelfClosingElement: updateJsxSelfClosingElement2,
|
|
createJsxOpeningElement: createJsxOpeningElement2,
|
|
updateJsxOpeningElement: updateJsxOpeningElement2,
|
|
createJsxClosingElement: createJsxClosingElement2,
|
|
updateJsxClosingElement: updateJsxClosingElement2,
|
|
createJsxFragment: createJsxFragment2,
|
|
createJsxText: createJsxText2,
|
|
updateJsxText: updateJsxText2,
|
|
createJsxOpeningFragment: createJsxOpeningFragment2,
|
|
createJsxJsxClosingFragment: createJsxJsxClosingFragment2,
|
|
updateJsxFragment: updateJsxFragment2,
|
|
createJsxAttribute: createJsxAttribute2,
|
|
updateJsxAttribute: updateJsxAttribute2,
|
|
createJsxAttributes: createJsxAttributes2,
|
|
updateJsxAttributes: updateJsxAttributes2,
|
|
createJsxSpreadAttribute: createJsxSpreadAttribute2,
|
|
updateJsxSpreadAttribute: updateJsxSpreadAttribute2,
|
|
createJsxExpression: createJsxExpression2,
|
|
updateJsxExpression: updateJsxExpression2,
|
|
createCaseClause: createCaseClause2,
|
|
updateCaseClause: updateCaseClause2,
|
|
createDefaultClause: createDefaultClause2,
|
|
updateDefaultClause: updateDefaultClause2,
|
|
createHeritageClause: createHeritageClause2,
|
|
updateHeritageClause: updateHeritageClause2,
|
|
createCatchClause: createCatchClause2,
|
|
updateCatchClause: updateCatchClause2,
|
|
createPropertyAssignment: createPropertyAssignment2,
|
|
updatePropertyAssignment: updatePropertyAssignment2,
|
|
createShorthandPropertyAssignment: createShorthandPropertyAssignment2,
|
|
updateShorthandPropertyAssignment: updateShorthandPropertyAssignment2,
|
|
createSpreadAssignment: createSpreadAssignment2,
|
|
updateSpreadAssignment: updateSpreadAssignment2,
|
|
createEnumMember: createEnumMember2,
|
|
updateEnumMember: updateEnumMember2,
|
|
createSourceFile: createSourceFile2,
|
|
updateSourceFile: updateSourceFile2,
|
|
createBundle: createBundle2,
|
|
updateBundle: updateBundle2,
|
|
createUnparsedSource,
|
|
createUnparsedPrologue,
|
|
createUnparsedPrepend,
|
|
createUnparsedTextLike,
|
|
createUnparsedSyntheticReference,
|
|
createInputFiles: createInputFiles2,
|
|
createSyntheticExpression,
|
|
createSyntaxList: createSyntaxList3,
|
|
createNotEmittedStatement: createNotEmittedStatement2,
|
|
createPartiallyEmittedExpression: createPartiallyEmittedExpression2,
|
|
updatePartiallyEmittedExpression: updatePartiallyEmittedExpression2,
|
|
createCommaListExpression,
|
|
updateCommaListExpression,
|
|
createEndOfDeclarationMarker,
|
|
createMergeDeclarationMarker,
|
|
createSyntheticReferenceExpression,
|
|
updateSyntheticReferenceExpression,
|
|
cloneNode,
|
|
get createComma() {
|
|
return getBinaryCreateFunction(27 /* CommaToken */);
|
|
},
|
|
get createAssignment() {
|
|
return getBinaryCreateFunction(63 /* EqualsToken */);
|
|
},
|
|
get createLogicalOr() {
|
|
return getBinaryCreateFunction(56 /* BarBarToken */);
|
|
},
|
|
get createLogicalAnd() {
|
|
return getBinaryCreateFunction(55 /* AmpersandAmpersandToken */);
|
|
},
|
|
get createBitwiseOr() {
|
|
return getBinaryCreateFunction(51 /* BarToken */);
|
|
},
|
|
get createBitwiseXor() {
|
|
return getBinaryCreateFunction(52 /* CaretToken */);
|
|
},
|
|
get createBitwiseAnd() {
|
|
return getBinaryCreateFunction(50 /* AmpersandToken */);
|
|
},
|
|
get createStrictEquality() {
|
|
return getBinaryCreateFunction(36 /* EqualsEqualsEqualsToken */);
|
|
},
|
|
get createStrictInequality() {
|
|
return getBinaryCreateFunction(37 /* ExclamationEqualsEqualsToken */);
|
|
},
|
|
get createEquality() {
|
|
return getBinaryCreateFunction(34 /* EqualsEqualsToken */);
|
|
},
|
|
get createInequality() {
|
|
return getBinaryCreateFunction(35 /* ExclamationEqualsToken */);
|
|
},
|
|
get createLessThan() {
|
|
return getBinaryCreateFunction(29 /* LessThanToken */);
|
|
},
|
|
get createLessThanEquals() {
|
|
return getBinaryCreateFunction(32 /* LessThanEqualsToken */);
|
|
},
|
|
get createGreaterThan() {
|
|
return getBinaryCreateFunction(31 /* GreaterThanToken */);
|
|
},
|
|
get createGreaterThanEquals() {
|
|
return getBinaryCreateFunction(33 /* GreaterThanEqualsToken */);
|
|
},
|
|
get createLeftShift() {
|
|
return getBinaryCreateFunction(47 /* LessThanLessThanToken */);
|
|
},
|
|
get createRightShift() {
|
|
return getBinaryCreateFunction(48 /* GreaterThanGreaterThanToken */);
|
|
},
|
|
get createUnsignedRightShift() {
|
|
return getBinaryCreateFunction(49 /* GreaterThanGreaterThanGreaterThanToken */);
|
|
},
|
|
get createAdd() {
|
|
return getBinaryCreateFunction(39 /* PlusToken */);
|
|
},
|
|
get createSubtract() {
|
|
return getBinaryCreateFunction(40 /* MinusToken */);
|
|
},
|
|
get createMultiply() {
|
|
return getBinaryCreateFunction(41 /* AsteriskToken */);
|
|
},
|
|
get createDivide() {
|
|
return getBinaryCreateFunction(43 /* SlashToken */);
|
|
},
|
|
get createModulo() {
|
|
return getBinaryCreateFunction(44 /* PercentToken */);
|
|
},
|
|
get createExponent() {
|
|
return getBinaryCreateFunction(42 /* AsteriskAsteriskToken */);
|
|
},
|
|
get createPrefixPlus() {
|
|
return getPrefixUnaryCreateFunction(39 /* PlusToken */);
|
|
},
|
|
get createPrefixMinus() {
|
|
return getPrefixUnaryCreateFunction(40 /* MinusToken */);
|
|
},
|
|
get createPrefixIncrement() {
|
|
return getPrefixUnaryCreateFunction(45 /* PlusPlusToken */);
|
|
},
|
|
get createPrefixDecrement() {
|
|
return getPrefixUnaryCreateFunction(46 /* MinusMinusToken */);
|
|
},
|
|
get createBitwiseNot() {
|
|
return getPrefixUnaryCreateFunction(54 /* TildeToken */);
|
|
},
|
|
get createLogicalNot() {
|
|
return getPrefixUnaryCreateFunction(53 /* ExclamationToken */);
|
|
},
|
|
get createPostfixIncrement() {
|
|
return getPostfixUnaryCreateFunction(45 /* PlusPlusToken */);
|
|
},
|
|
get createPostfixDecrement() {
|
|
return getPostfixUnaryCreateFunction(46 /* MinusMinusToken */);
|
|
},
|
|
createImmediatelyInvokedFunctionExpression: createImmediatelyInvokedFunctionExpression2,
|
|
createImmediatelyInvokedArrowFunction: createImmediatelyInvokedArrowFunction2,
|
|
createVoidZero: createVoidZero2,
|
|
createExportDefault: createExportDefault2,
|
|
createExternalModuleExport: createExternalModuleExport2,
|
|
createTypeCheck,
|
|
createMethodCall,
|
|
createGlobalMethodCall,
|
|
createFunctionBindCall,
|
|
createFunctionCallCall,
|
|
createFunctionApplyCall,
|
|
createArraySliceCall,
|
|
createArrayConcatCall,
|
|
createObjectDefinePropertyCall,
|
|
createReflectGetCall,
|
|
createReflectSetCall,
|
|
createPropertyDescriptor,
|
|
createCallBinding,
|
|
createAssignmentTargetWrapper,
|
|
inlineExpressions,
|
|
getInternalName,
|
|
getLocalName,
|
|
getExportName,
|
|
getDeclarationName,
|
|
getNamespaceMemberName,
|
|
getExternalModuleOrNamespaceExportName,
|
|
restoreOuterExpressions,
|
|
restoreEnclosingLabel,
|
|
createUseStrictPrologue,
|
|
copyPrologue,
|
|
copyStandardPrologue,
|
|
copyCustomPrologue,
|
|
ensureUseStrict,
|
|
liftToBlock,
|
|
mergeLexicalEnvironment,
|
|
updateModifiers
|
|
};
|
|
forEach(nodeFactoryPatchers, (fn) => fn(factory2));
|
|
return factory2;
|
|
function createNodeArray2(elements, hasTrailingComma) {
|
|
if (elements === void 0 || elements === emptyArray) {
|
|
elements = [];
|
|
} else if (isNodeArray(elements)) {
|
|
if (hasTrailingComma === void 0 || elements.hasTrailingComma === hasTrailingComma) {
|
|
if (elements.transformFlags === void 0) {
|
|
aggregateChildrenFlags(elements);
|
|
}
|
|
Debug.attachNodeArrayDebugInfo(elements);
|
|
return elements;
|
|
}
|
|
const array2 = elements.slice();
|
|
array2.pos = elements.pos;
|
|
array2.end = elements.end;
|
|
array2.hasTrailingComma = hasTrailingComma;
|
|
array2.transformFlags = elements.transformFlags;
|
|
Debug.attachNodeArrayDebugInfo(array2);
|
|
return array2;
|
|
}
|
|
const length2 = elements.length;
|
|
const array = length2 >= 1 && length2 <= 4 ? elements.slice() : elements;
|
|
setTextRangePosEnd(array, -1, -1);
|
|
array.hasTrailingComma = !!hasTrailingComma;
|
|
aggregateChildrenFlags(array);
|
|
Debug.attachNodeArrayDebugInfo(array);
|
|
return array;
|
|
}
|
|
function createBaseNode(kind) {
|
|
return baseFactory2.createBaseNode(kind);
|
|
}
|
|
function createBaseDeclaration(kind) {
|
|
const node = createBaseNode(kind);
|
|
node.symbol = void 0;
|
|
node.localSymbol = void 0;
|
|
node.locals = void 0;
|
|
node.nextContainer = void 0;
|
|
return node;
|
|
}
|
|
function createBaseNamedDeclaration(kind, modifiers, name) {
|
|
const node = createBaseDeclaration(kind);
|
|
name = asName(name);
|
|
node.name = name;
|
|
if (canHaveModifiers(node)) {
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers);
|
|
}
|
|
if (name) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
if (isIdentifier(name)) {
|
|
node.transformFlags |= propagateIdentifierNameFlags(name);
|
|
break;
|
|
}
|
|
default:
|
|
node.transformFlags |= propagateChildFlags(name);
|
|
break;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function createBaseGenericNamedDeclaration(kind, modifiers, name, typeParameters) {
|
|
const node = createBaseNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.typeParameters = asNodeArray(typeParameters);
|
|
node.transformFlags |= propagateChildrenFlags(node.typeParameters);
|
|
if (typeParameters)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseSignatureDeclaration(kind, modifiers, name, typeParameters, parameters, type) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters
|
|
);
|
|
node.parameters = createNodeArray2(parameters);
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildrenFlags(node.parameters) | propagateChildFlags(node.type);
|
|
if (type)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
node.typeArguments = void 0;
|
|
return node;
|
|
}
|
|
function finishUpdateBaseSignatureDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.typeArguments = original.typeArguments;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createBaseFunctionLikeDeclaration(kind, modifiers, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseSignatureDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.body = body;
|
|
node.transformFlags |= propagateChildFlags(node.body) & ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
if (!body)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseInterfaceOrClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters
|
|
);
|
|
node.heritageClauses = asNodeArray(heritageClauses);
|
|
node.transformFlags |= propagateChildrenFlags(node.heritageClauses);
|
|
return node;
|
|
}
|
|
function createBaseClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseInterfaceOrClassLikeDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses
|
|
);
|
|
node.members = createNodeArray2(members);
|
|
node.transformFlags |= propagateChildrenFlags(node.members);
|
|
return node;
|
|
}
|
|
function createBaseBindingLikeDeclaration(kind, modifiers, name, initializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.initializer = initializer;
|
|
node.transformFlags |= propagateChildFlags(node.initializer);
|
|
return node;
|
|
}
|
|
function createBaseVariableLikeDeclaration(kind, modifiers, name, type, initializer) {
|
|
const node = createBaseBindingLikeDeclaration(
|
|
kind,
|
|
modifiers,
|
|
name,
|
|
initializer
|
|
);
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(type);
|
|
if (type)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createBaseLiteral(kind, text) {
|
|
const node = createBaseToken(kind);
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function createNumericLiteral2(value, numericLiteralFlags = 0 /* None */) {
|
|
const node = createBaseLiteral(8 /* NumericLiteral */, typeof value === "number" ? value + "" : value);
|
|
node.numericLiteralFlags = numericLiteralFlags;
|
|
if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createBigIntLiteral2(value) {
|
|
const node = createBaseLiteral(9 /* BigIntLiteral */, typeof value === "string" ? value : pseudoBigIntToString(value) + "n");
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function createBaseStringLiteral(text, isSingleQuote) {
|
|
const node = createBaseLiteral(10 /* StringLiteral */, text);
|
|
node.singleQuote = isSingleQuote;
|
|
return node;
|
|
}
|
|
function createStringLiteral2(text, isSingleQuote, hasExtendedUnicodeEscape) {
|
|
const node = createBaseStringLiteral(text, isSingleQuote);
|
|
node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
|
|
if (hasExtendedUnicodeEscape)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createStringLiteralFromNode2(sourceNode) {
|
|
const node = createBaseStringLiteral(getTextOfIdentifierOrLiteral(sourceNode), void 0);
|
|
node.textSourceNode = sourceNode;
|
|
return node;
|
|
}
|
|
function createRegularExpressionLiteral2(text) {
|
|
const node = createBaseLiteral(13 /* RegularExpressionLiteral */, text);
|
|
return node;
|
|
}
|
|
function createLiteralLikeNode(kind, text) {
|
|
switch (kind) {
|
|
case 8 /* NumericLiteral */:
|
|
return createNumericLiteral2(text, 0);
|
|
case 9 /* BigIntLiteral */:
|
|
return createBigIntLiteral2(text);
|
|
case 10 /* StringLiteral */:
|
|
return createStringLiteral2(text, void 0);
|
|
case 11 /* JsxText */:
|
|
return createJsxText2(text, false);
|
|
case 12 /* JsxTextAllWhiteSpaces */:
|
|
return createJsxText2(text, true);
|
|
case 13 /* RegularExpressionLiteral */:
|
|
return createRegularExpressionLiteral2(text);
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return createTemplateLiteralLikeNode(kind, text, void 0, 0);
|
|
}
|
|
}
|
|
function createBaseIdentifier(text, originalKeywordKind) {
|
|
if (originalKeywordKind === void 0 && text) {
|
|
originalKeywordKind = stringToToken(text);
|
|
}
|
|
if (originalKeywordKind === 79 /* Identifier */) {
|
|
originalKeywordKind = void 0;
|
|
}
|
|
const node = baseFactory2.createBaseIdentifierNode(79 /* Identifier */);
|
|
node.originalKeywordKind = originalKeywordKind;
|
|
node.escapedText = escapeLeadingUnderscores(text);
|
|
return node;
|
|
}
|
|
function createBaseGeneratedIdentifier(text, autoGenerateFlags, prefix, suffix) {
|
|
const node = createBaseIdentifier(text, void 0);
|
|
node.autoGenerateFlags = autoGenerateFlags;
|
|
node.autoGenerateId = nextAutoGenerateId;
|
|
node.autoGeneratePrefix = prefix;
|
|
node.autoGenerateSuffix = suffix;
|
|
nextAutoGenerateId++;
|
|
return node;
|
|
}
|
|
function createIdentifier3(text, typeArguments, originalKeywordKind, hasExtendedUnicodeEscape) {
|
|
const node = createBaseIdentifier(text, originalKeywordKind);
|
|
if (typeArguments) {
|
|
node.typeArguments = createNodeArray2(typeArguments);
|
|
}
|
|
if (node.originalKeywordKind === 133 /* AwaitKeyword */) {
|
|
node.transformFlags |= 67108864 /* ContainsPossibleTopLevelAwait */;
|
|
}
|
|
if (hasExtendedUnicodeEscape) {
|
|
node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape;
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateIdentifier(node, typeArguments) {
|
|
return node.typeArguments !== typeArguments ? update(createIdentifier3(idText(node), typeArguments), node) : node;
|
|
}
|
|
function createTempVariable3(recordTempVariable, reservedInNestedScopes, prefix, suffix) {
|
|
let flags2 = 1 /* Auto */;
|
|
if (reservedInNestedScopes)
|
|
flags2 |= 8 /* ReservedInNestedScopes */;
|
|
const name = createBaseGeneratedIdentifier("", flags2, prefix, suffix);
|
|
if (recordTempVariable) {
|
|
recordTempVariable(name);
|
|
}
|
|
return name;
|
|
}
|
|
function createLoopVariable2(reservedInNestedScopes) {
|
|
let flags2 = 2 /* Loop */;
|
|
if (reservedInNestedScopes)
|
|
flags2 |= 8 /* ReservedInNestedScopes */;
|
|
return createBaseGeneratedIdentifier("", flags2, void 0, void 0);
|
|
}
|
|
function createUniqueName2(text, flags2 = 0 /* None */, prefix, suffix) {
|
|
Debug.assert(!(flags2 & 7 /* KindMask */), "Argument out of range: flags");
|
|
Debug.assert((flags2 & (16 /* Optimistic */ | 32 /* FileLevel */)) !== 32 /* FileLevel */, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic");
|
|
return createBaseGeneratedIdentifier(text, 3 /* Unique */ | flags2, prefix, suffix);
|
|
}
|
|
function getGeneratedNameForNode3(node, flags2 = 0, prefix, suffix) {
|
|
Debug.assert(!(flags2 & 7 /* KindMask */), "Argument out of range: flags");
|
|
const text = !node ? "" : isMemberName(node) ? formatGeneratedName(false, prefix, node, suffix, idText) : `generated@${getNodeId(node)}`;
|
|
if (prefix || suffix)
|
|
flags2 |= 16 /* Optimistic */;
|
|
const name = createBaseGeneratedIdentifier(text, 4 /* Node */ | flags2, prefix, suffix);
|
|
name.original = node;
|
|
return name;
|
|
}
|
|
function createBasePrivateIdentifier(text) {
|
|
const node = baseFactory2.createBasePrivateIdentifierNode(80 /* PrivateIdentifier */);
|
|
node.escapedText = escapeLeadingUnderscores(text);
|
|
node.transformFlags |= 16777216 /* ContainsClassFields */;
|
|
return node;
|
|
}
|
|
function createPrivateIdentifier2(text) {
|
|
if (!startsWith(text, "#"))
|
|
Debug.fail("First character of private identifier must be #: " + text);
|
|
return createBasePrivateIdentifier(text);
|
|
}
|
|
function createBaseGeneratedPrivateIdentifier(text, autoGenerateFlags, prefix, suffix) {
|
|
const node = createBasePrivateIdentifier(text);
|
|
node.autoGenerateFlags = autoGenerateFlags;
|
|
node.autoGenerateId = nextAutoGenerateId;
|
|
node.autoGeneratePrefix = prefix;
|
|
node.autoGenerateSuffix = suffix;
|
|
nextAutoGenerateId++;
|
|
return node;
|
|
}
|
|
function createUniquePrivateName(text, prefix, suffix) {
|
|
if (text && !startsWith(text, "#"))
|
|
Debug.fail("First character of private identifier must be #: " + text);
|
|
const autoGenerateFlags = 8 /* ReservedInNestedScopes */ | (text ? 3 /* Unique */ : 1 /* Auto */);
|
|
return createBaseGeneratedPrivateIdentifier(text != null ? text : "", autoGenerateFlags, prefix, suffix);
|
|
}
|
|
function getGeneratedPrivateNameForNode(node, prefix, suffix) {
|
|
const text = isMemberName(node) ? formatGeneratedName(true, prefix, node, suffix, idText) : `#generated@${getNodeId(node)}`;
|
|
const flags2 = prefix || suffix ? 16 /* Optimistic */ : 0 /* None */;
|
|
const name = createBaseGeneratedPrivateIdentifier(text, 4 /* Node */ | flags2, prefix, suffix);
|
|
name.original = node;
|
|
return name;
|
|
}
|
|
function createBaseToken(kind) {
|
|
return baseFactory2.createBaseTokenNode(kind);
|
|
}
|
|
function createToken3(token) {
|
|
Debug.assert(token >= 0 /* FirstToken */ && token <= 162 /* LastToken */, "Invalid token");
|
|
Debug.assert(token <= 14 /* FirstTemplateToken */ || token >= 17 /* LastTemplateToken */, "Invalid token. Use 'createTemplateLiteralLikeNode' to create template literals.");
|
|
Debug.assert(token <= 8 /* FirstLiteralToken */ || token >= 14 /* LastLiteralToken */, "Invalid token. Use 'createLiteralLikeNode' to create literals.");
|
|
Debug.assert(token !== 79 /* Identifier */, "Invalid token. Use 'createIdentifier' to create identifiers");
|
|
const node = createBaseToken(token);
|
|
let transformFlags = 0 /* None */;
|
|
switch (token) {
|
|
case 132 /* AsyncKeyword */:
|
|
transformFlags = 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
break;
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 131 /* AnyKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
transformFlags = 1 /* ContainsTypeScript */;
|
|
break;
|
|
case 106 /* SuperKeyword */:
|
|
transformFlags = 1024 /* ContainsES2015 */ | 134217728 /* ContainsLexicalSuper */;
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
transformFlags = 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 127 /* AccessorKeyword */:
|
|
transformFlags = 16777216 /* ContainsClassFields */;
|
|
break;
|
|
case 108 /* ThisKeyword */:
|
|
transformFlags = 16384 /* ContainsLexicalThis */;
|
|
break;
|
|
}
|
|
if (transformFlags) {
|
|
node.transformFlags |= transformFlags;
|
|
}
|
|
return node;
|
|
}
|
|
function createSuper2() {
|
|
return createToken3(106 /* SuperKeyword */);
|
|
}
|
|
function createThis2() {
|
|
return createToken3(108 /* ThisKeyword */);
|
|
}
|
|
function createNull2() {
|
|
return createToken3(104 /* NullKeyword */);
|
|
}
|
|
function createTrue2() {
|
|
return createToken3(110 /* TrueKeyword */);
|
|
}
|
|
function createFalse2() {
|
|
return createToken3(95 /* FalseKeyword */);
|
|
}
|
|
function createModifier2(kind) {
|
|
return createToken3(kind);
|
|
}
|
|
function createModifiersFromModifierFlags2(flags2) {
|
|
const result = [];
|
|
if (flags2 & 1 /* Export */)
|
|
result.push(createModifier2(93 /* ExportKeyword */));
|
|
if (flags2 & 2 /* Ambient */)
|
|
result.push(createModifier2(136 /* DeclareKeyword */));
|
|
if (flags2 & 1024 /* Default */)
|
|
result.push(createModifier2(88 /* DefaultKeyword */));
|
|
if (flags2 & 2048 /* Const */)
|
|
result.push(createModifier2(85 /* ConstKeyword */));
|
|
if (flags2 & 4 /* Public */)
|
|
result.push(createModifier2(123 /* PublicKeyword */));
|
|
if (flags2 & 8 /* Private */)
|
|
result.push(createModifier2(121 /* PrivateKeyword */));
|
|
if (flags2 & 16 /* Protected */)
|
|
result.push(createModifier2(122 /* ProtectedKeyword */));
|
|
if (flags2 & 256 /* Abstract */)
|
|
result.push(createModifier2(126 /* AbstractKeyword */));
|
|
if (flags2 & 32 /* Static */)
|
|
result.push(createModifier2(124 /* StaticKeyword */));
|
|
if (flags2 & 16384 /* Override */)
|
|
result.push(createModifier2(161 /* OverrideKeyword */));
|
|
if (flags2 & 64 /* Readonly */)
|
|
result.push(createModifier2(146 /* ReadonlyKeyword */));
|
|
if (flags2 & 128 /* Accessor */)
|
|
result.push(createModifier2(127 /* AccessorKeyword */));
|
|
if (flags2 & 512 /* Async */)
|
|
result.push(createModifier2(132 /* AsyncKeyword */));
|
|
if (flags2 & 32768 /* In */)
|
|
result.push(createModifier2(101 /* InKeyword */));
|
|
if (flags2 & 65536 /* Out */)
|
|
result.push(createModifier2(145 /* OutKeyword */));
|
|
return result.length ? result : void 0;
|
|
}
|
|
function createQualifiedName2(left, right) {
|
|
const node = createBaseNode(163 /* QualifiedName */);
|
|
node.left = left;
|
|
node.right = asName(right);
|
|
node.transformFlags |= propagateChildFlags(node.left) | propagateIdentifierNameFlags(node.right);
|
|
return node;
|
|
}
|
|
function updateQualifiedName2(node, left, right) {
|
|
return node.left !== left || node.right !== right ? update(createQualifiedName2(left, right), node) : node;
|
|
}
|
|
function createComputedPropertyName2(expression) {
|
|
const node = createBaseNode(164 /* ComputedPropertyName */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfComputedPropertyName(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1024 /* ContainsES2015 */ | 131072 /* ContainsComputedPropertyName */;
|
|
return node;
|
|
}
|
|
function updateComputedPropertyName2(node, expression) {
|
|
return node.expression !== expression ? update(createComputedPropertyName2(expression), node) : node;
|
|
}
|
|
function createTypeParameterDeclaration2(modifiers, name, constraint, defaultType) {
|
|
const node = createBaseNamedDeclaration(
|
|
165 /* TypeParameter */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.constraint = constraint;
|
|
node.default = defaultType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeParameterDeclaration2(node, modifiers, name, constraint, defaultType) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.constraint !== constraint || node.default !== defaultType ? update(createTypeParameterDeclaration2(modifiers, name, constraint, defaultType), node) : node;
|
|
}
|
|
function createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
166 /* Parameter */,
|
|
modifiers,
|
|
name,
|
|
type,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.questionToken = questionToken;
|
|
if (isThisIdentifier(node.name)) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | propagateChildFlags(node.questionToken);
|
|
if (questionToken)
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
if (modifiersToFlags(node.modifiers) & 16476 /* ParameterPropertyModifier */)
|
|
node.transformFlags |= 8192 /* ContainsTypeScriptClassSyntax */;
|
|
if (initializer || dotDotDotToken)
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateParameterDeclaration(node, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
return node.modifiers !== modifiers || node.dotDotDotToken !== dotDotDotToken || node.name !== name || node.questionToken !== questionToken || node.type !== type || node.initializer !== initializer ? update(createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer), node) : node;
|
|
}
|
|
function createDecorator2(expression) {
|
|
const node = createBaseNode(167 /* Decorator */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */ | 8192 /* ContainsTypeScriptClassSyntax */ | 33554432 /* ContainsDecorators */;
|
|
return node;
|
|
}
|
|
function updateDecorator2(node, expression) {
|
|
return node.expression !== expression ? update(createDecorator2(expression), node) : node;
|
|
}
|
|
function createPropertySignature3(modifiers, name, questionToken, type) {
|
|
const node = createBaseNamedDeclaration(
|
|
168 /* PropertySignature */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.type = type;
|
|
node.questionToken = questionToken;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.initializer = void 0;
|
|
return node;
|
|
}
|
|
function updatePropertySignature3(node, modifiers, name, questionToken, type) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.questionToken !== questionToken || node.type !== type ? finishUpdatePropertySignature(createPropertySignature3(modifiers, name, questionToken, type), node) : node;
|
|
}
|
|
function finishUpdatePropertySignature(updated, original) {
|
|
if (updated !== original) {
|
|
updated.initializer = original.initializer;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
169 /* PropertyDeclaration */,
|
|
modifiers,
|
|
name,
|
|
type,
|
|
initializer
|
|
);
|
|
node.questionToken = questionOrExclamationToken && isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
|
|
node.exclamationToken = questionOrExclamationToken && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0;
|
|
node.transformFlags |= propagateChildFlags(node.questionToken) | propagateChildFlags(node.exclamationToken) | 16777216 /* ContainsClassFields */;
|
|
if (isComputedPropertyName(node.name) || hasStaticModifier(node) && node.initializer) {
|
|
node.transformFlags |= 8192 /* ContainsTypeScriptClassSyntax */;
|
|
}
|
|
if (questionOrExclamationToken || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePropertyDeclaration2(node, modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.questionToken !== (questionOrExclamationToken !== void 0 && isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0) || node.exclamationToken !== (questionOrExclamationToken !== void 0 && isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : void 0) || node.type !== type || node.initializer !== initializer ? update(createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer), node) : node;
|
|
}
|
|
function createMethodSignature3(modifiers, name, questionToken, typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
170 /* MethodSignature */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.questionToken = questionToken;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateMethodSignature3(node, modifiers, name, questionToken, typeParameters, parameters, type) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.questionToken !== questionToken || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateBaseSignatureDeclaration(createMethodSignature3(modifiers, name, questionToken, typeParameters, parameters, type), node) : node;
|
|
}
|
|
function createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
171 /* MethodDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
node.questionToken = questionToken;
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken) | propagateChildFlags(node.questionToken) | 1024 /* ContainsES2015 */;
|
|
if (questionToken) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
function updateMethodDeclaration(node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
return node.modifiers !== modifiers || node.asteriskToken !== asteriskToken || node.name !== name || node.questionToken !== questionToken || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body ? finishUpdateMethodDeclaration(createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node) : node;
|
|
}
|
|
function finishUpdateMethodDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.exclamationToken = original.exclamationToken;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createClassStaticBlockDeclaration(body) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
172 /* ClassStaticBlockDeclaration */,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
node.body = body;
|
|
node.transformFlags = propagateChildFlags(body) | 16777216 /* ContainsClassFields */;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
function updateClassStaticBlockDeclaration(node, body) {
|
|
return node.body !== body ? finishUpdateClassStaticBlockDeclaration(createClassStaticBlockDeclaration(body), node) : node;
|
|
}
|
|
function finishUpdateClassStaticBlockDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createConstructorDeclaration(modifiers, parameters, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
173 /* Constructor */,
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
node.illegalDecorators = void 0;
|
|
node.typeParameters = void 0;
|
|
node.type = void 0;
|
|
return node;
|
|
}
|
|
function updateConstructorDeclaration(node, modifiers, parameters, body) {
|
|
return node.modifiers !== modifiers || node.parameters !== parameters || node.body !== body ? finishUpdateConstructorDeclaration(createConstructorDeclaration(modifiers, parameters, body), node) : node;
|
|
}
|
|
function finishUpdateConstructorDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.typeParameters = original.typeParameters;
|
|
updated.type = original.type;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createGetAccessorDeclaration(modifiers, name, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
174 /* GetAccessor */,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.typeParameters = void 0;
|
|
return node;
|
|
}
|
|
function updateGetAccessorDeclaration(node, modifiers, name, parameters, type, body) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.parameters !== parameters || node.type !== type || node.body !== body ? finishUpdateGetAccessorDeclaration(createGetAccessorDeclaration(modifiers, name, parameters, type, body), node) : node;
|
|
}
|
|
function finishUpdateGetAccessorDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.typeParameters = original.typeParameters;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createSetAccessorDeclaration(modifiers, name, parameters, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
175 /* SetAccessor */,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
node.typeParameters = void 0;
|
|
node.type = void 0;
|
|
return node;
|
|
}
|
|
function updateSetAccessorDeclaration(node, modifiers, name, parameters, body) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.parameters !== parameters || node.body !== body ? finishUpdateSetAccessorDeclaration(createSetAccessorDeclaration(modifiers, name, parameters, body), node) : node;
|
|
}
|
|
function finishUpdateSetAccessorDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.typeParameters = original.typeParameters;
|
|
updated.type = original.type;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createCallSignature2(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
176 /* CallSignature */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateCallSignature2(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateBaseSignatureDeclaration(createCallSignature2(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function createConstructSignature2(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
177 /* ConstructSignature */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateConstructSignature2(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateBaseSignatureDeclaration(createConstructSignature2(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function createIndexSignature3(modifiers, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
178 /* IndexSignature */,
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateIndexSignature2(node, modifiers, parameters, type) {
|
|
return node.parameters !== parameters || node.type !== type || node.modifiers !== modifiers ? finishUpdateBaseSignatureDeclaration(createIndexSignature3(modifiers, parameters, type), node) : node;
|
|
}
|
|
function createTemplateLiteralTypeSpan(type, literal) {
|
|
const node = createBaseNode(201 /* TemplateLiteralTypeSpan */);
|
|
node.type = type;
|
|
node.literal = literal;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTemplateLiteralTypeSpan(node, type, literal) {
|
|
return node.type !== type || node.literal !== literal ? update(createTemplateLiteralTypeSpan(type, literal), node) : node;
|
|
}
|
|
function createKeywordTypeNode2(kind) {
|
|
return createToken3(kind);
|
|
}
|
|
function createTypePredicateNode3(assertsModifier, parameterName, type) {
|
|
const node = createBaseNode(179 /* TypePredicate */);
|
|
node.assertsModifier = assertsModifier;
|
|
node.parameterName = asName(parameterName);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypePredicateNode3(node, assertsModifier, parameterName, type) {
|
|
return node.assertsModifier !== assertsModifier || node.parameterName !== parameterName || node.type !== type ? update(createTypePredicateNode3(assertsModifier, parameterName, type), node) : node;
|
|
}
|
|
function createTypeReferenceNode2(typeName, typeArguments) {
|
|
const node = createBaseNode(180 /* TypeReference */);
|
|
node.typeName = asName(typeName);
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(createNodeArray2(typeArguments));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeReferenceNode2(node, typeName, typeArguments) {
|
|
return node.typeName !== typeName || node.typeArguments !== typeArguments ? update(createTypeReferenceNode2(typeName, typeArguments), node) : node;
|
|
}
|
|
function createFunctionTypeNode2(typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
181 /* FunctionType */,
|
|
void 0,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
function updateFunctionTypeNode2(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? finishUpdateFunctionTypeNode(createFunctionTypeNode2(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function finishUpdateFunctionTypeNode(updated, original) {
|
|
if (updated !== original) {
|
|
updated.modifiers = original.modifiers;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createConstructorTypeNode2(...args) {
|
|
return args.length === 4 ? createConstructorTypeNode1(...args) : args.length === 3 ? createConstructorTypeNode22(...args) : Debug.fail("Incorrect number of arguments specified.");
|
|
}
|
|
function createConstructorTypeNode1(modifiers, typeParameters, parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
182 /* ConstructorType */,
|
|
modifiers,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createConstructorTypeNode22(typeParameters, parameters, type) {
|
|
return createConstructorTypeNode1(void 0, typeParameters, parameters, type);
|
|
}
|
|
function updateConstructorTypeNode2(...args) {
|
|
return args.length === 5 ? updateConstructorTypeNode1(...args) : args.length === 4 ? updateConstructorTypeNode22(...args) : 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 ? finishUpdateBaseSignatureDeclaration(createConstructorTypeNode2(modifiers, typeParameters, parameters, type), node) : node;
|
|
}
|
|
function updateConstructorTypeNode22(node, typeParameters, parameters, type) {
|
|
return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type);
|
|
}
|
|
function createTypeQueryNode2(exprName, typeArguments) {
|
|
const node = createBaseNode(183 /* TypeQuery */);
|
|
node.exprName = exprName;
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeQueryNode2(node, exprName, typeArguments) {
|
|
return node.exprName !== exprName || node.typeArguments !== typeArguments ? update(createTypeQueryNode2(exprName, typeArguments), node) : node;
|
|
}
|
|
function createTypeLiteralNode2(members) {
|
|
const node = createBaseNode(184 /* TypeLiteral */);
|
|
node.members = createNodeArray2(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeLiteralNode2(node, members) {
|
|
return node.members !== members ? update(createTypeLiteralNode2(members), node) : node;
|
|
}
|
|
function createArrayTypeNode2(elementType) {
|
|
const node = createBaseNode(185 /* ArrayType */);
|
|
node.elementType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(elementType);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateArrayTypeNode2(node, elementType) {
|
|
return node.elementType !== elementType ? update(createArrayTypeNode2(elementType), node) : node;
|
|
}
|
|
function createTupleTypeNode2(elements) {
|
|
const node = createBaseNode(186 /* TupleType */);
|
|
node.elements = createNodeArray2(parenthesizerRules().parenthesizeElementTypesOfTupleType(elements));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTupleTypeNode2(node, elements) {
|
|
return node.elements !== elements ? update(createTupleTypeNode2(elements), node) : node;
|
|
}
|
|
function createNamedTupleMember(dotDotDotToken, name, questionToken, type) {
|
|
const node = createBaseNode(199 /* NamedTupleMember */);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.name = name;
|
|
node.questionToken = questionToken;
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateNamedTupleMember(node, dotDotDotToken, name, questionToken, type) {
|
|
return node.dotDotDotToken !== dotDotDotToken || node.name !== name || node.questionToken !== questionToken || node.type !== type ? update(createNamedTupleMember(dotDotDotToken, name, questionToken, type), node) : node;
|
|
}
|
|
function createOptionalTypeNode2(type) {
|
|
const node = createBaseNode(187 /* OptionalType */);
|
|
node.type = parenthesizerRules().parenthesizeTypeOfOptionalType(type);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateOptionalTypeNode2(node, type) {
|
|
return node.type !== type ? update(createOptionalTypeNode2(type), node) : node;
|
|
}
|
|
function createRestTypeNode2(type) {
|
|
const node = createBaseNode(188 /* RestType */);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateRestTypeNode2(node, type) {
|
|
return node.type !== type ? update(createRestTypeNode2(type), node) : node;
|
|
}
|
|
function createUnionOrIntersectionTypeNode(kind, types, parenthesize) {
|
|
const node = createBaseNode(kind);
|
|
node.types = factory2.createNodeArray(parenthesize(types));
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateUnionOrIntersectionTypeNode(node, types, parenthesize) {
|
|
return node.types !== types ? update(createUnionOrIntersectionTypeNode(node.kind, types, parenthesize), node) : node;
|
|
}
|
|
function createUnionTypeNode2(types) {
|
|
return createUnionOrIntersectionTypeNode(189 /* UnionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
|
|
}
|
|
function updateUnionTypeNode2(node, types) {
|
|
return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType);
|
|
}
|
|
function createIntersectionTypeNode2(types) {
|
|
return createUnionOrIntersectionTypeNode(190 /* IntersectionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
|
|
}
|
|
function updateIntersectionTypeNode2(node, types) {
|
|
return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType);
|
|
}
|
|
function createConditionalTypeNode2(checkType, extendsType, trueType, falseType) {
|
|
const node = createBaseNode(191 /* ConditionalType */);
|
|
node.checkType = parenthesizerRules().parenthesizeCheckTypeOfConditionalType(checkType);
|
|
node.extendsType = parenthesizerRules().parenthesizeExtendsTypeOfConditionalType(extendsType);
|
|
node.trueType = trueType;
|
|
node.falseType = falseType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateConditionalTypeNode2(node, checkType, extendsType, trueType, falseType) {
|
|
return node.checkType !== checkType || node.extendsType !== extendsType || node.trueType !== trueType || node.falseType !== falseType ? update(createConditionalTypeNode2(checkType, extendsType, trueType, falseType), node) : node;
|
|
}
|
|
function createInferTypeNode2(typeParameter) {
|
|
const node = createBaseNode(192 /* InferType */);
|
|
node.typeParameter = typeParameter;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateInferTypeNode2(node, typeParameter) {
|
|
return node.typeParameter !== typeParameter ? update(createInferTypeNode2(typeParameter), node) : node;
|
|
}
|
|
function createTemplateLiteralType(head, templateSpans) {
|
|
const node = createBaseNode(200 /* TemplateLiteralType */);
|
|
node.head = head;
|
|
node.templateSpans = createNodeArray2(templateSpans);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTemplateLiteralType(node, head, templateSpans) {
|
|
return node.head !== head || node.templateSpans !== templateSpans ? update(createTemplateLiteralType(head, templateSpans), node) : node;
|
|
}
|
|
function createImportTypeNode2(argument, assertions, qualifier, typeArguments, isTypeOf = false) {
|
|
const node = createBaseNode(202 /* ImportType */);
|
|
node.argument = argument;
|
|
node.assertions = assertions;
|
|
node.qualifier = qualifier;
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.isTypeOf = isTypeOf;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateImportTypeNode2(node, argument, assertions, qualifier, typeArguments, isTypeOf = node.isTypeOf) {
|
|
return node.argument !== argument || node.assertions !== assertions || node.qualifier !== qualifier || node.typeArguments !== typeArguments || node.isTypeOf !== isTypeOf ? update(createImportTypeNode2(argument, assertions, qualifier, typeArguments, isTypeOf), node) : node;
|
|
}
|
|
function createParenthesizedType2(type) {
|
|
const node = createBaseNode(193 /* ParenthesizedType */);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateParenthesizedType2(node, type) {
|
|
return node.type !== type ? update(createParenthesizedType2(type), node) : node;
|
|
}
|
|
function createThisTypeNode2() {
|
|
const node = createBaseNode(194 /* ThisType */);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function createTypeOperatorNode3(operator, type) {
|
|
const node = createBaseNode(195 /* TypeOperator */);
|
|
node.operator = operator;
|
|
node.type = operator === 146 /* ReadonlyKeyword */ ? parenthesizerRules().parenthesizeOperandOfReadonlyTypeOperator(type) : parenthesizerRules().parenthesizeOperandOfTypeOperator(type);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeOperatorNode2(node, type) {
|
|
return node.type !== type ? update(createTypeOperatorNode3(node.operator, type), node) : node;
|
|
}
|
|
function createIndexedAccessTypeNode2(objectType, indexType) {
|
|
const node = createBaseNode(196 /* IndexedAccessType */);
|
|
node.objectType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(objectType);
|
|
node.indexType = indexType;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateIndexedAccessTypeNode2(node, objectType, indexType) {
|
|
return node.objectType !== objectType || node.indexType !== indexType ? update(createIndexedAccessTypeNode2(objectType, indexType), node) : node;
|
|
}
|
|
function createMappedTypeNode2(readonlyToken, typeParameter, nameType, questionToken, type, members) {
|
|
const node = createBaseNode(197 /* MappedType */);
|
|
node.readonlyToken = readonlyToken;
|
|
node.typeParameter = typeParameter;
|
|
node.nameType = nameType;
|
|
node.questionToken = questionToken;
|
|
node.type = type;
|
|
node.members = members && createNodeArray2(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateMappedTypeNode2(node, readonlyToken, typeParameter, nameType, questionToken, type, members) {
|
|
return node.readonlyToken !== readonlyToken || node.typeParameter !== typeParameter || node.nameType !== nameType || node.questionToken !== questionToken || node.type !== type || node.members !== members ? update(createMappedTypeNode2(readonlyToken, typeParameter, nameType, questionToken, type, members), node) : node;
|
|
}
|
|
function createLiteralTypeNode2(literal) {
|
|
const node = createBaseNode(198 /* LiteralType */);
|
|
node.literal = literal;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateLiteralTypeNode2(node, literal) {
|
|
return node.literal !== literal ? update(createLiteralTypeNode2(literal), node) : node;
|
|
}
|
|
function createObjectBindingPattern2(elements) {
|
|
const node = createBaseNode(203 /* ObjectBindingPattern */);
|
|
node.elements = createNodeArray2(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements) | 1024 /* ContainsES2015 */ | 524288 /* ContainsBindingPattern */;
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */ | 65536 /* ContainsObjectRestOrSpread */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateObjectBindingPattern2(node, elements) {
|
|
return node.elements !== elements ? update(createObjectBindingPattern2(elements), node) : node;
|
|
}
|
|
function createArrayBindingPattern2(elements) {
|
|
const node = createBaseNode(204 /* ArrayBindingPattern */);
|
|
node.elements = createNodeArray2(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements) | 1024 /* ContainsES2015 */ | 524288 /* ContainsBindingPattern */;
|
|
return node;
|
|
}
|
|
function updateArrayBindingPattern2(node, elements) {
|
|
return node.elements !== elements ? update(createArrayBindingPattern2(elements), node) : node;
|
|
}
|
|
function createBindingElement2(dotDotDotToken, propertyName, name, initializer) {
|
|
const node = createBaseBindingLikeDeclaration(
|
|
205 /* BindingElement */,
|
|
void 0,
|
|
name,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.propertyName = asName(propertyName);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | 1024 /* ContainsES2015 */;
|
|
if (node.propertyName) {
|
|
node.transformFlags |= isIdentifier(node.propertyName) ? propagateIdentifierNameFlags(node.propertyName) : propagateChildFlags(node.propertyName);
|
|
}
|
|
if (dotDotDotToken)
|
|
node.transformFlags |= 32768 /* ContainsRestOrSpread */;
|
|
return node;
|
|
}
|
|
function updateBindingElement2(node, dotDotDotToken, propertyName, name, initializer) {
|
|
return node.propertyName !== propertyName || node.dotDotDotToken !== dotDotDotToken || node.name !== name || node.initializer !== initializer ? update(createBindingElement2(dotDotDotToken, propertyName, name, initializer), node) : node;
|
|
}
|
|
function createBaseExpression(kind) {
|
|
const node = createBaseNode(kind);
|
|
return node;
|
|
}
|
|
function createArrayLiteralExpression(elements, multiLine) {
|
|
const node = createBaseExpression(206 /* ArrayLiteralExpression */);
|
|
const lastElement = elements && lastOrUndefined(elements);
|
|
const elementsArray = createNodeArray2(elements, lastElement && isOmittedExpression(lastElement) ? true : void 0);
|
|
node.elements = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(elementsArray);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
return node;
|
|
}
|
|
function updateArrayLiteralExpression(node, elements) {
|
|
return node.elements !== elements ? update(createArrayLiteralExpression(elements, node.multiLine), node) : node;
|
|
}
|
|
function createObjectLiteralExpression(properties, multiLine) {
|
|
const node = createBaseExpression(207 /* ObjectLiteralExpression */);
|
|
node.properties = createNodeArray2(properties);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.properties);
|
|
return node;
|
|
}
|
|
function updateObjectLiteralExpression(node, properties) {
|
|
return node.properties !== properties ? update(createObjectLiteralExpression(properties, node.multiLine), node) : node;
|
|
}
|
|
function createPropertyAccessExpression(expression, name) {
|
|
const node = createBaseExpression(208 /* PropertyAccessExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.name = asName(name);
|
|
node.transformFlags = propagateChildFlags(node.expression) | (isIdentifier(node.name) ? propagateIdentifierNameFlags(node.name) : propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
if (isSuperKeyword(expression)) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePropertyAccessExpression(node, expression, name) {
|
|
if (isPropertyAccessChain(node)) {
|
|
return updatePropertyAccessChain2(node, expression, node.questionDotToken, cast(name, isIdentifier));
|
|
}
|
|
return node.expression !== expression || node.name !== name ? update(createPropertyAccessExpression(expression, name), node) : node;
|
|
}
|
|
function createPropertyAccessChain2(expression, questionDotToken, name) {
|
|
const node = createBaseExpression(208 /* PropertyAccessExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.questionDotToken = questionDotToken;
|
|
node.name = asName(name);
|
|
node.transformFlags |= 32 /* ContainsES2020 */ | propagateChildFlags(node.expression) | propagateChildFlags(node.questionDotToken) | (isIdentifier(node.name) ? propagateIdentifierNameFlags(node.name) : propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
return node;
|
|
}
|
|
function updatePropertyAccessChain2(node, expression, questionDotToken, name) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead.");
|
|
return node.expression !== expression || node.questionDotToken !== questionDotToken || node.name !== name ? update(createPropertyAccessChain2(expression, questionDotToken, name), node) : node;
|
|
}
|
|
function createElementAccessExpression(expression, index) {
|
|
const node = createBaseExpression(209 /* ElementAccessExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.argumentExpression = asExpression(index);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.argumentExpression);
|
|
if (isSuperKeyword(expression)) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateElementAccessExpression(node, expression, argumentExpression) {
|
|
if (isElementAccessChain(node)) {
|
|
return updateElementAccessChain2(node, expression, node.questionDotToken, argumentExpression);
|
|
}
|
|
return node.expression !== expression || node.argumentExpression !== argumentExpression ? update(createElementAccessExpression(expression, argumentExpression), node) : node;
|
|
}
|
|
function createElementAccessChain2(expression, questionDotToken, index) {
|
|
const node = createBaseExpression(209 /* ElementAccessExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.questionDotToken = questionDotToken;
|
|
node.argumentExpression = asExpression(index);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.questionDotToken) | propagateChildFlags(node.argumentExpression) | 32 /* ContainsES2020 */;
|
|
return node;
|
|
}
|
|
function updateElementAccessChain2(node, expression, questionDotToken, argumentExpression) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead.");
|
|
return node.expression !== expression || node.questionDotToken !== questionDotToken || node.argumentExpression !== argumentExpression ? update(createElementAccessChain2(expression, questionDotToken, argumentExpression), node) : node;
|
|
}
|
|
function createCallExpression(expression, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(210 /* CallExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray2(argumentsArray));
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.typeArguments) | propagateChildrenFlags(node.arguments);
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (isImportKeyword(node.expression)) {
|
|
node.transformFlags |= 8388608 /* ContainsDynamicImport */;
|
|
} else if (isSuperProperty(node.expression)) {
|
|
node.transformFlags |= 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateCallExpression(node, expression, typeArguments, argumentsArray) {
|
|
if (isCallChain(node)) {
|
|
return updateCallChain2(node, expression, node.questionDotToken, typeArguments, argumentsArray);
|
|
}
|
|
return node.expression !== expression || node.typeArguments !== typeArguments || node.arguments !== argumentsArray ? update(createCallExpression(expression, typeArguments, argumentsArray), node) : node;
|
|
}
|
|
function createCallChain2(expression, questionDotToken, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(210 /* CallExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.questionDotToken = questionDotToken;
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray2(argumentsArray));
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.questionDotToken) | propagateChildrenFlags(node.typeArguments) | propagateChildrenFlags(node.arguments) | 32 /* ContainsES2020 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (isSuperProperty(node.expression)) {
|
|
node.transformFlags |= 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateCallChain2(node, expression, questionDotToken, typeArguments, argumentsArray) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a CallExpression using updateCallChain. Use updateCall instead.");
|
|
return node.expression !== expression || node.questionDotToken !== questionDotToken || node.typeArguments !== typeArguments || node.arguments !== argumentsArray ? update(createCallChain2(expression, questionDotToken, typeArguments, argumentsArray), node) : node;
|
|
}
|
|
function createNewExpression(expression, typeArguments, argumentsArray) {
|
|
const node = createBaseExpression(211 /* NewExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfNew(expression);
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.arguments = argumentsArray ? parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(argumentsArray) : void 0;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.typeArguments) | propagateChildrenFlags(node.arguments) | 32 /* ContainsES2020 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateNewExpression(node, expression, typeArguments, argumentsArray) {
|
|
return node.expression !== expression || node.typeArguments !== typeArguments || node.arguments !== argumentsArray ? update(createNewExpression(expression, typeArguments, argumentsArray), node) : node;
|
|
}
|
|
function createTaggedTemplateExpression(tag, typeArguments, template) {
|
|
const node = createBaseExpression(212 /* TaggedTemplateExpression */);
|
|
node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag, false);
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.template = template;
|
|
node.transformFlags |= propagateChildFlags(node.tag) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.template) | 1024 /* ContainsES2015 */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (hasInvalidEscape(node.template)) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateTaggedTemplateExpression(node, tag, typeArguments, template) {
|
|
return node.tag !== tag || node.typeArguments !== typeArguments || node.template !== template ? update(createTaggedTemplateExpression(tag, typeArguments, template), node) : node;
|
|
}
|
|
function createTypeAssertion2(type, expression) {
|
|
const node = createBaseExpression(213 /* TypeAssertionExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateTypeAssertion2(node, type, expression) {
|
|
return node.type !== type || node.expression !== expression ? update(createTypeAssertion2(type, expression), node) : node;
|
|
}
|
|
function createParenthesizedExpression(expression) {
|
|
const node = createBaseExpression(214 /* ParenthesizedExpression */);
|
|
node.expression = expression;
|
|
node.transformFlags = propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateParenthesizedExpression(node, expression) {
|
|
return node.expression !== expression ? update(createParenthesizedExpression(expression), node) : node;
|
|
}
|
|
function createFunctionExpression2(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
215 /* FunctionExpression */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken);
|
|
if (node.typeParameters) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (node.asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (node.asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateFunctionExpression2(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return node.name !== name || node.modifiers !== modifiers || node.asteriskToken !== asteriskToken || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body ? finishUpdateBaseSignatureDeclaration(createFunctionExpression2(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) : node;
|
|
}
|
|
function createArrowFunction3(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
216 /* ArrowFunction */,
|
|
modifiers,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body)
|
|
);
|
|
node.equalsGreaterThanToken = equalsGreaterThanToken != null ? equalsGreaterThanToken : createToken3(38 /* EqualsGreaterThanToken */);
|
|
node.transformFlags |= propagateChildFlags(node.equalsGreaterThanToken) | 1024 /* ContainsES2015 */;
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
node.transformFlags |= 256 /* ContainsES2017 */ | 16384 /* ContainsLexicalThis */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateArrowFunction3(node, modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) {
|
|
return node.modifiers !== modifiers || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.equalsGreaterThanToken !== equalsGreaterThanToken || node.body !== body ? finishUpdateBaseSignatureDeclaration(createArrowFunction3(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node) : node;
|
|
}
|
|
function createDeleteExpression(expression) {
|
|
const node = createBaseExpression(217 /* DeleteExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateDeleteExpression(node, expression) {
|
|
return node.expression !== expression ? update(createDeleteExpression(expression), node) : node;
|
|
}
|
|
function createTypeOfExpression(expression) {
|
|
const node = createBaseExpression(218 /* TypeOfExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateTypeOfExpression(node, expression) {
|
|
return node.expression !== expression ? update(createTypeOfExpression(expression), node) : node;
|
|
}
|
|
function createVoidExpression(expression) {
|
|
const node = createBaseExpression(219 /* VoidExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateVoidExpression(node, expression) {
|
|
return node.expression !== expression ? update(createVoidExpression(expression), node) : node;
|
|
}
|
|
function createAwaitExpression(expression) {
|
|
const node = createBaseExpression(220 /* AwaitExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 256 /* ContainsES2017 */ | 128 /* ContainsES2018 */ | 2097152 /* ContainsAwait */;
|
|
return node;
|
|
}
|
|
function updateAwaitExpression(node, expression) {
|
|
return node.expression !== expression ? update(createAwaitExpression(expression), node) : node;
|
|
}
|
|
function createPrefixUnaryExpression(operator, operand) {
|
|
const node = createBaseExpression(221 /* PrefixUnaryExpression */);
|
|
node.operator = operator;
|
|
node.operand = parenthesizerRules().parenthesizeOperandOfPrefixUnary(operand);
|
|
node.transformFlags |= propagateChildFlags(node.operand);
|
|
if ((operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand)) {
|
|
node.transformFlags |= 268435456 /* ContainsUpdateExpressionForIdentifier */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePrefixUnaryExpression(node, operand) {
|
|
return node.operand !== operand ? update(createPrefixUnaryExpression(node.operator, operand), node) : node;
|
|
}
|
|
function createPostfixUnaryExpression(operand, operator) {
|
|
const node = createBaseExpression(222 /* PostfixUnaryExpression */);
|
|
node.operator = operator;
|
|
node.operand = parenthesizerRules().parenthesizeOperandOfPostfixUnary(operand);
|
|
node.transformFlags |= propagateChildFlags(node.operand);
|
|
if (isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand)) {
|
|
node.transformFlags |= 268435456 /* ContainsUpdateExpressionForIdentifier */;
|
|
}
|
|
return node;
|
|
}
|
|
function updatePostfixUnaryExpression(node, operand) {
|
|
return node.operand !== operand ? update(createPostfixUnaryExpression(operand, node.operator), node) : node;
|
|
}
|
|
function createBinaryExpression(left, operator, right) {
|
|
const node = createBaseExpression(223 /* BinaryExpression */);
|
|
const operatorToken = asToken(operator);
|
|
const operatorKind = operatorToken.kind;
|
|
node.left = parenthesizerRules().parenthesizeLeftSideOfBinary(operatorKind, left);
|
|
node.operatorToken = operatorToken;
|
|
node.right = parenthesizerRules().parenthesizeRightSideOfBinary(operatorKind, node.left, right);
|
|
node.transformFlags |= propagateChildFlags(node.left) | propagateChildFlags(node.operatorToken) | propagateChildFlags(node.right);
|
|
if (operatorKind === 60 /* QuestionQuestionToken */) {
|
|
node.transformFlags |= 32 /* ContainsES2020 */;
|
|
} else if (operatorKind === 63 /* EqualsToken */) {
|
|
if (isObjectLiteralExpression(node.left)) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 128 /* ContainsES2018 */ | 4096 /* ContainsDestructuringAssignment */ | propagateAssignmentPatternFlags(node.left);
|
|
} else if (isArrayLiteralExpression(node.left)) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 4096 /* ContainsDestructuringAssignment */ | propagateAssignmentPatternFlags(node.left);
|
|
}
|
|
} else if (operatorKind === 42 /* AsteriskAsteriskToken */ || operatorKind === 67 /* AsteriskAsteriskEqualsToken */) {
|
|
node.transformFlags |= 512 /* ContainsES2016 */;
|
|
} else if (isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
|
|
node.transformFlags |= 16 /* ContainsES2021 */;
|
|
}
|
|
if (operatorKind === 101 /* InKeyword */ && isPrivateIdentifier(node.left)) {
|
|
node.transformFlags |= 536870912 /* ContainsPrivateIdentifierInExpression */;
|
|
}
|
|
return node;
|
|
}
|
|
function propagateAssignmentPatternFlags(node) {
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */)
|
|
return 65536 /* ContainsObjectRestOrSpread */;
|
|
if (node.transformFlags & 128 /* ContainsES2018 */) {
|
|
for (const element of getElementsOfBindingOrAssignmentPattern(node)) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (target && isAssignmentPattern(target)) {
|
|
if (target.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return 65536 /* ContainsObjectRestOrSpread */;
|
|
}
|
|
if (target.transformFlags & 128 /* ContainsES2018 */) {
|
|
const flags2 = propagateAssignmentPatternFlags(target);
|
|
if (flags2)
|
|
return flags2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function updateBinaryExpression(node, left, operator, right) {
|
|
return node.left !== left || node.operatorToken !== operator || node.right !== right ? update(createBinaryExpression(left, operator, right), node) : node;
|
|
}
|
|
function createConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse) {
|
|
const node = createBaseExpression(224 /* ConditionalExpression */);
|
|
node.condition = parenthesizerRules().parenthesizeConditionOfConditionalExpression(condition);
|
|
node.questionToken = questionToken != null ? questionToken : createToken3(57 /* QuestionToken */);
|
|
node.whenTrue = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenTrue);
|
|
node.colonToken = colonToken != null ? colonToken : createToken3(58 /* ColonToken */);
|
|
node.whenFalse = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenFalse);
|
|
node.transformFlags |= propagateChildFlags(node.condition) | propagateChildFlags(node.questionToken) | propagateChildFlags(node.whenTrue) | propagateChildFlags(node.colonToken) | propagateChildFlags(node.whenFalse);
|
|
return node;
|
|
}
|
|
function updateConditionalExpression(node, condition, questionToken, whenTrue, colonToken, whenFalse) {
|
|
return node.condition !== condition || node.questionToken !== questionToken || node.whenTrue !== whenTrue || node.colonToken !== colonToken || node.whenFalse !== whenFalse ? update(createConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse), node) : node;
|
|
}
|
|
function createTemplateExpression2(head, templateSpans) {
|
|
const node = createBaseExpression(225 /* TemplateExpression */);
|
|
node.head = head;
|
|
node.templateSpans = createNodeArray2(templateSpans);
|
|
node.transformFlags |= propagateChildFlags(node.head) | propagateChildrenFlags(node.templateSpans) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateTemplateExpression2(node, head, templateSpans) {
|
|
return node.head !== head || node.templateSpans !== templateSpans ? update(createTemplateExpression2(head, templateSpans), node) : node;
|
|
}
|
|
function createTemplateLiteralLikeNodeChecked(kind, text, rawText, templateFlags = 0 /* None */) {
|
|
Debug.assert(!(templateFlags & ~2048 /* TemplateLiteralLikeFlags */), "Unsupported template flags.");
|
|
let cooked = void 0;
|
|
if (rawText !== void 0 && rawText !== text) {
|
|
cooked = getCookedText(kind, rawText);
|
|
if (typeof cooked === "object") {
|
|
return Debug.fail("Invalid raw text");
|
|
}
|
|
}
|
|
if (text === void 0) {
|
|
if (cooked === void 0) {
|
|
return Debug.fail("Arguments 'text' and 'rawText' may not both be undefined.");
|
|
}
|
|
text = cooked;
|
|
} else if (cooked !== void 0) {
|
|
Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'.");
|
|
}
|
|
return createTemplateLiteralLikeNode(kind, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateLiteralLikeNode(kind, text, rawText, templateFlags) {
|
|
const node = createBaseToken(kind);
|
|
node.text = text;
|
|
node.rawText = rawText;
|
|
node.templateFlags = templateFlags & 2048 /* TemplateLiteralLikeFlags */;
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
if (node.templateFlags) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
}
|
|
return node;
|
|
}
|
|
function createTemplateHead2(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(15 /* TemplateHead */, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateMiddle2(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(16 /* TemplateMiddle */, text, rawText, templateFlags);
|
|
}
|
|
function createTemplateTail2(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(17 /* TemplateTail */, text, rawText, templateFlags);
|
|
}
|
|
function createNoSubstitutionTemplateLiteral2(text, rawText, templateFlags) {
|
|
return createTemplateLiteralLikeNodeChecked(14 /* NoSubstitutionTemplateLiteral */, text, rawText, templateFlags);
|
|
}
|
|
function createYieldExpression(asteriskToken, expression) {
|
|
Debug.assert(!asteriskToken || !!expression, "A `YieldExpression` with an asteriskToken must have an expression.");
|
|
const node = createBaseExpression(226 /* YieldExpression */);
|
|
node.expression = expression && parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.asteriskToken = asteriskToken;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.asteriskToken) | 1024 /* ContainsES2015 */ | 128 /* ContainsES2018 */ | 1048576 /* ContainsYield */;
|
|
return node;
|
|
}
|
|
function updateYieldExpression(node, asteriskToken, expression) {
|
|
return node.expression !== expression || node.asteriskToken !== asteriskToken ? update(createYieldExpression(asteriskToken, expression), node) : node;
|
|
}
|
|
function createSpreadElement(expression) {
|
|
const node = createBaseExpression(227 /* SpreadElement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1024 /* ContainsES2015 */ | 32768 /* ContainsRestOrSpread */;
|
|
return node;
|
|
}
|
|
function updateSpreadElement(node, expression) {
|
|
return node.expression !== expression ? update(createSpreadElement(expression), node) : node;
|
|
}
|
|
function createClassExpression3(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseClassLikeDeclaration(
|
|
228 /* ClassExpression */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateClassExpression3(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.typeParameters !== typeParameters || node.heritageClauses !== heritageClauses || node.members !== members ? update(createClassExpression3(modifiers, name, typeParameters, heritageClauses, members), node) : node;
|
|
}
|
|
function createOmittedExpression2() {
|
|
return createBaseExpression(229 /* OmittedExpression */);
|
|
}
|
|
function createExpressionWithTypeArguments3(expression, typeArguments) {
|
|
const node = createBaseNode(230 /* ExpressionWithTypeArguments */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.typeArguments) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateExpressionWithTypeArguments3(node, expression, typeArguments) {
|
|
return node.expression !== expression || node.typeArguments !== typeArguments ? update(createExpressionWithTypeArguments3(expression, typeArguments), node) : node;
|
|
}
|
|
function createAsExpression2(expression, type) {
|
|
const node = createBaseExpression(231 /* AsExpression */);
|
|
node.expression = expression;
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateAsExpression2(node, expression, type) {
|
|
return node.expression !== expression || node.type !== type ? update(createAsExpression2(expression, type), node) : node;
|
|
}
|
|
function createNonNullExpression2(expression) {
|
|
const node = createBaseExpression(232 /* NonNullExpression */);
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateNonNullExpression2(node, expression) {
|
|
if (isNonNullChain(node)) {
|
|
return updateNonNullChain2(node, expression);
|
|
}
|
|
return node.expression !== expression ? update(createNonNullExpression2(expression), node) : node;
|
|
}
|
|
function createSatisfiesExpression(expression, type) {
|
|
const node = createBaseExpression(235 /* SatisfiesExpression */);
|
|
node.expression = expression;
|
|
node.type = type;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.type) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateSatisfiesExpression(node, expression, type) {
|
|
return node.expression !== expression || node.type !== type ? update(createSatisfiesExpression(expression, type), node) : node;
|
|
}
|
|
function createNonNullChain2(expression) {
|
|
const node = createBaseExpression(232 /* NonNullExpression */);
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, true);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateNonNullChain2(node, expression) {
|
|
Debug.assert(!!(node.flags & 32 /* OptionalChain */), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead.");
|
|
return node.expression !== expression ? update(createNonNullChain2(expression), node) : node;
|
|
}
|
|
function createMetaProperty2(keywordToken, name) {
|
|
const node = createBaseExpression(233 /* MetaProperty */);
|
|
node.keywordToken = keywordToken;
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name);
|
|
switch (keywordToken) {
|
|
case 103 /* NewKeyword */:
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 100 /* ImportKeyword */:
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
break;
|
|
default:
|
|
return Debug.assertNever(keywordToken);
|
|
}
|
|
return node;
|
|
}
|
|
function updateMetaProperty2(node, name) {
|
|
return node.name !== name ? update(createMetaProperty2(node.keywordToken, name), node) : node;
|
|
}
|
|
function createTemplateSpan2(expression, literal) {
|
|
const node = createBaseNode(236 /* TemplateSpan */);
|
|
node.expression = expression;
|
|
node.literal = literal;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.literal) | 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function updateTemplateSpan2(node, expression, literal) {
|
|
return node.expression !== expression || node.literal !== literal ? update(createTemplateSpan2(expression, literal), node) : node;
|
|
}
|
|
function createSemicolonClassElement2() {
|
|
const node = createBaseNode(237 /* SemicolonClassElement */);
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
return node;
|
|
}
|
|
function createBlock2(statements, multiLine) {
|
|
const node = createBaseNode(238 /* Block */);
|
|
node.statements = createNodeArray2(statements);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateBlock2(node, statements) {
|
|
return node.statements !== statements ? update(createBlock2(statements, node.multiLine), node) : node;
|
|
}
|
|
function createVariableStatement2(modifiers, declarationList) {
|
|
const node = createBaseDeclaration(240 /* VariableStatement */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.declarationList = isArray(declarationList) ? createVariableDeclarationList2(declarationList) : declarationList;
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.declarationList);
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateVariableStatement2(node, modifiers, declarationList) {
|
|
return node.modifiers !== modifiers || node.declarationList !== declarationList ? update(createVariableStatement2(modifiers, declarationList), node) : node;
|
|
}
|
|
function createEmptyStatement2() {
|
|
return createBaseNode(239 /* EmptyStatement */);
|
|
}
|
|
function createExpressionStatement2(expression) {
|
|
const node = createBaseNode(241 /* ExpressionStatement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionOfExpressionStatement(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateExpressionStatement2(node, expression) {
|
|
return node.expression !== expression ? update(createExpressionStatement2(expression), node) : node;
|
|
}
|
|
function createIfStatement(expression, thenStatement, elseStatement) {
|
|
const node = createBaseNode(242 /* IfStatement */);
|
|
node.expression = expression;
|
|
node.thenStatement = asEmbeddedStatement(thenStatement);
|
|
node.elseStatement = asEmbeddedStatement(elseStatement);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thenStatement) | propagateChildFlags(node.elseStatement);
|
|
return node;
|
|
}
|
|
function updateIfStatement(node, expression, thenStatement, elseStatement) {
|
|
return node.expression !== expression || node.thenStatement !== thenStatement || node.elseStatement !== elseStatement ? update(createIfStatement(expression, thenStatement, elseStatement), node) : node;
|
|
}
|
|
function createDoStatement(statement, expression) {
|
|
const node = createBaseNode(243 /* DoStatement */);
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.statement) | propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateDoStatement(node, statement, expression) {
|
|
return node.statement !== statement || node.expression !== expression ? update(createDoStatement(statement, expression), node) : node;
|
|
}
|
|
function createWhileStatement(expression, statement) {
|
|
const node = createBaseNode(244 /* WhileStatement */);
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateWhileStatement(node, expression, statement) {
|
|
return node.expression !== expression || node.statement !== statement ? update(createWhileStatement(expression, statement), node) : node;
|
|
}
|
|
function createForStatement(initializer, condition, incrementor, statement) {
|
|
const node = createBaseNode(245 /* ForStatement */);
|
|
node.initializer = initializer;
|
|
node.condition = condition;
|
|
node.incrementor = incrementor;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.initializer) | propagateChildFlags(node.condition) | propagateChildFlags(node.incrementor) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateForStatement(node, initializer, condition, incrementor, statement) {
|
|
return node.initializer !== initializer || node.condition !== condition || node.incrementor !== incrementor || node.statement !== statement ? update(createForStatement(initializer, condition, incrementor, statement), node) : node;
|
|
}
|
|
function createForInStatement(initializer, expression, statement) {
|
|
const node = createBaseNode(246 /* ForInStatement */);
|
|
node.initializer = initializer;
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.initializer) | propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateForInStatement(node, initializer, expression, statement) {
|
|
return node.initializer !== initializer || node.expression !== expression || node.statement !== statement ? update(createForInStatement(initializer, expression, statement), node) : node;
|
|
}
|
|
function createForOfStatement(awaitModifier, initializer, expression, statement) {
|
|
const node = createBaseNode(247 /* ForOfStatement */);
|
|
node.awaitModifier = awaitModifier;
|
|
node.initializer = initializer;
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.awaitModifier) | propagateChildFlags(node.initializer) | propagateChildFlags(node.expression) | propagateChildFlags(node.statement) | 1024 /* ContainsES2015 */;
|
|
if (awaitModifier)
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
return node;
|
|
}
|
|
function updateForOfStatement(node, awaitModifier, initializer, expression, statement) {
|
|
return node.awaitModifier !== awaitModifier || node.initializer !== initializer || node.expression !== expression || node.statement !== statement ? update(createForOfStatement(awaitModifier, initializer, expression, statement), node) : node;
|
|
}
|
|
function createContinueStatement(label) {
|
|
const node = createBaseNode(248 /* ContinueStatement */);
|
|
node.label = asName(label);
|
|
node.transformFlags |= propagateChildFlags(node.label) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateContinueStatement(node, label) {
|
|
return node.label !== label ? update(createContinueStatement(label), node) : node;
|
|
}
|
|
function createBreakStatement(label) {
|
|
const node = createBaseNode(249 /* BreakStatement */);
|
|
node.label = asName(label);
|
|
node.transformFlags |= propagateChildFlags(node.label) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateBreakStatement(node, label) {
|
|
return node.label !== label ? update(createBreakStatement(label), node) : node;
|
|
}
|
|
function createReturnStatement(expression) {
|
|
const node = createBaseNode(250 /* ReturnStatement */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 128 /* ContainsES2018 */ | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
return node;
|
|
}
|
|
function updateReturnStatement(node, expression) {
|
|
return node.expression !== expression ? update(createReturnStatement(expression), node) : node;
|
|
}
|
|
function createWithStatement(expression, statement) {
|
|
const node = createBaseNode(251 /* WithStatement */);
|
|
node.expression = expression;
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateWithStatement(node, expression, statement) {
|
|
return node.expression !== expression || node.statement !== statement ? update(createWithStatement(expression, statement), node) : node;
|
|
}
|
|
function createSwitchStatement(expression, caseBlock) {
|
|
const node = createBaseNode(252 /* SwitchStatement */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.caseBlock = caseBlock;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.caseBlock);
|
|
return node;
|
|
}
|
|
function updateSwitchStatement(node, expression, caseBlock) {
|
|
return node.expression !== expression || node.caseBlock !== caseBlock ? update(createSwitchStatement(expression, caseBlock), node) : node;
|
|
}
|
|
function createLabeledStatement(label, statement) {
|
|
const node = createBaseNode(253 /* LabeledStatement */);
|
|
node.label = asName(label);
|
|
node.statement = asEmbeddedStatement(statement);
|
|
node.transformFlags |= propagateChildFlags(node.label) | propagateChildFlags(node.statement);
|
|
return node;
|
|
}
|
|
function updateLabeledStatement(node, label, statement) {
|
|
return node.label !== label || node.statement !== statement ? update(createLabeledStatement(label, statement), node) : node;
|
|
}
|
|
function createThrowStatement(expression) {
|
|
const node = createBaseNode(254 /* ThrowStatement */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
return node;
|
|
}
|
|
function updateThrowStatement(node, expression) {
|
|
return node.expression !== expression ? update(createThrowStatement(expression), node) : node;
|
|
}
|
|
function createTryStatement(tryBlock, catchClause, finallyBlock) {
|
|
const node = createBaseNode(255 /* TryStatement */);
|
|
node.tryBlock = tryBlock;
|
|
node.catchClause = catchClause;
|
|
node.finallyBlock = finallyBlock;
|
|
node.transformFlags |= propagateChildFlags(node.tryBlock) | propagateChildFlags(node.catchClause) | propagateChildFlags(node.finallyBlock);
|
|
return node;
|
|
}
|
|
function updateTryStatement(node, tryBlock, catchClause, finallyBlock) {
|
|
return node.tryBlock !== tryBlock || node.catchClause !== catchClause || node.finallyBlock !== finallyBlock ? update(createTryStatement(tryBlock, catchClause, finallyBlock), node) : node;
|
|
}
|
|
function createDebuggerStatement2() {
|
|
return createBaseNode(256 /* DebuggerStatement */);
|
|
}
|
|
function createVariableDeclaration3(name, exclamationToken, type, initializer) {
|
|
const node = createBaseVariableLikeDeclaration(
|
|
257 /* VariableDeclaration */,
|
|
void 0,
|
|
name,
|
|
type,
|
|
initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)
|
|
);
|
|
node.exclamationToken = exclamationToken;
|
|
node.transformFlags |= propagateChildFlags(node.exclamationToken);
|
|
if (exclamationToken) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateVariableDeclaration3(node, name, exclamationToken, type, initializer) {
|
|
return node.name !== name || node.type !== type || node.exclamationToken !== exclamationToken || node.initializer !== initializer ? update(createVariableDeclaration3(name, exclamationToken, type, initializer), node) : node;
|
|
}
|
|
function createVariableDeclarationList2(declarations, flags2 = 0 /* None */) {
|
|
const node = createBaseNode(258 /* VariableDeclarationList */);
|
|
node.flags |= flags2 & 3 /* BlockScoped */;
|
|
node.declarations = createNodeArray2(declarations);
|
|
node.transformFlags |= propagateChildrenFlags(node.declarations) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
if (flags2 & 3 /* BlockScoped */) {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */ | 262144 /* ContainsBlockScopedBinding */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateVariableDeclarationList2(node, declarations) {
|
|
return node.declarations !== declarations ? update(createVariableDeclarationList2(declarations, node.flags), node) : node;
|
|
}
|
|
function createFunctionDeclaration2(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
const node = createBaseFunctionLikeDeclaration(
|
|
259 /* FunctionDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.asteriskToken = asteriskToken;
|
|
if (!node.body || modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildFlags(node.asteriskToken) | 4194304 /* ContainsHoistedDeclarationOrCompletion */;
|
|
if (modifiersToFlags(node.modifiers) & 512 /* Async */) {
|
|
if (node.asteriskToken) {
|
|
node.transformFlags |= 128 /* ContainsES2018 */;
|
|
} else {
|
|
node.transformFlags |= 256 /* ContainsES2017 */;
|
|
}
|
|
} else if (node.asteriskToken) {
|
|
node.transformFlags |= 2048 /* ContainsGenerator */;
|
|
}
|
|
}
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateFunctionDeclaration2(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return node.modifiers !== modifiers || node.asteriskToken !== asteriskToken || node.name !== name || node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type || node.body !== body ? finishUpdateFunctionDeclaration(createFunctionDeclaration2(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) : node;
|
|
}
|
|
function finishUpdateFunctionDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return finishUpdateBaseSignatureDeclaration(updated, original);
|
|
}
|
|
function createClassDeclaration2(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseClassLikeDeclaration(
|
|
260 /* ClassDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
if (node.transformFlags & 8192 /* ContainsTypeScriptClassSyntax */) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function updateClassDeclaration2(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.typeParameters !== typeParameters || node.heritageClauses !== heritageClauses || node.members !== members ? update(createClassDeclaration2(modifiers, name, typeParameters, heritageClauses, members), node) : node;
|
|
}
|
|
function createInterfaceDeclaration2(modifiers, name, typeParameters, heritageClauses, members) {
|
|
const node = createBaseInterfaceOrClassLikeDeclaration(
|
|
261 /* InterfaceDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters,
|
|
heritageClauses
|
|
);
|
|
node.members = createNodeArray2(members);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateInterfaceDeclaration2(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.typeParameters !== typeParameters || node.heritageClauses !== heritageClauses || node.members !== members ? finishUpdateInterfaceDeclaration(createInterfaceDeclaration2(modifiers, name, typeParameters, heritageClauses, members), node) : node;
|
|
}
|
|
function finishUpdateInterfaceDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createTypeAliasDeclaration2(modifiers, name, typeParameters, type) {
|
|
const node = createBaseGenericNamedDeclaration(
|
|
262 /* TypeAliasDeclaration */,
|
|
modifiers,
|
|
name,
|
|
typeParameters
|
|
);
|
|
node.type = type;
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateTypeAliasDeclaration2(node, modifiers, name, typeParameters, type) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.typeParameters !== typeParameters || node.type !== type ? finishUpdateTypeAliasDeclaration(createTypeAliasDeclaration2(modifiers, name, typeParameters, type), node) : node;
|
|
}
|
|
function finishUpdateTypeAliasDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createEnumDeclaration2(modifiers, name, members) {
|
|
const node = createBaseNamedDeclaration(
|
|
263 /* EnumDeclaration */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.members = createNodeArray2(members);
|
|
node.transformFlags |= propagateChildrenFlags(node.members) | 1 /* ContainsTypeScript */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateEnumDeclaration2(node, modifiers, name, members) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.members !== members ? finishUpdateEnumDeclaration(createEnumDeclaration2(modifiers, name, members), node) : node;
|
|
}
|
|
function finishUpdateEnumDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createModuleDeclaration2(modifiers, name, body, flags2 = 0 /* None */) {
|
|
const node = createBaseDeclaration(264 /* ModuleDeclaration */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.flags |= flags2 & (16 /* Namespace */ | 4 /* NestedNamespace */ | 1024 /* GlobalAugmentation */);
|
|
node.name = name;
|
|
node.body = body;
|
|
if (modifiersToFlags(node.modifiers) & 2 /* Ambient */) {
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
} else {
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.name) | propagateChildFlags(node.body) | 1 /* ContainsTypeScript */;
|
|
}
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateModuleDeclaration2(node, modifiers, name, body) {
|
|
return node.modifiers !== modifiers || node.name !== name || node.body !== body ? finishUpdateModuleDeclaration(createModuleDeclaration2(modifiers, name, body, node.flags), node) : node;
|
|
}
|
|
function finishUpdateModuleDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createModuleBlock2(statements) {
|
|
const node = createBaseNode(265 /* ModuleBlock */);
|
|
node.statements = createNodeArray2(statements);
|
|
node.transformFlags |= propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateModuleBlock2(node, statements) {
|
|
return node.statements !== statements ? update(createModuleBlock2(statements), node) : node;
|
|
}
|
|
function createCaseBlock2(clauses) {
|
|
const node = createBaseNode(266 /* CaseBlock */);
|
|
node.clauses = createNodeArray2(clauses);
|
|
node.transformFlags |= propagateChildrenFlags(node.clauses);
|
|
return node;
|
|
}
|
|
function updateCaseBlock2(node, clauses) {
|
|
return node.clauses !== clauses ? update(createCaseBlock2(clauses), node) : node;
|
|
}
|
|
function createNamespaceExportDeclaration2(name) {
|
|
const node = createBaseNamedDeclaration(
|
|
267 /* NamespaceExportDeclaration */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.transformFlags = 1 /* ContainsTypeScript */;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
return node;
|
|
}
|
|
function updateNamespaceExportDeclaration2(node, name) {
|
|
return node.name !== name ? finishUpdateNamespaceExportDeclaration(createNamespaceExportDeclaration2(name), node) : node;
|
|
}
|
|
function finishUpdateNamespaceExportDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createImportEqualsDeclaration2(modifiers, isTypeOnly, name, moduleReference) {
|
|
const node = createBaseNamedDeclaration(
|
|
268 /* ImportEqualsDeclaration */,
|
|
modifiers,
|
|
name
|
|
);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.moduleReference = moduleReference;
|
|
node.transformFlags |= propagateChildFlags(node.moduleReference);
|
|
if (!isExternalModuleReference(node.moduleReference))
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateImportEqualsDeclaration2(node, modifiers, isTypeOnly, name, moduleReference) {
|
|
return node.modifiers !== modifiers || node.isTypeOnly !== isTypeOnly || node.name !== name || node.moduleReference !== moduleReference ? finishUpdateImportEqualsDeclaration(createImportEqualsDeclaration2(modifiers, isTypeOnly, name, moduleReference), node) : node;
|
|
}
|
|
function finishUpdateImportEqualsDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createImportDeclaration2(modifiers, importClause, moduleSpecifier, assertClause) {
|
|
const node = createBaseDeclaration(269 /* ImportDeclaration */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.importClause = importClause;
|
|
node.moduleSpecifier = moduleSpecifier;
|
|
node.assertClause = assertClause;
|
|
node.transformFlags |= propagateChildFlags(node.importClause) | propagateChildFlags(node.moduleSpecifier);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateImportDeclaration2(node, modifiers, importClause, moduleSpecifier, assertClause) {
|
|
return node.modifiers !== modifiers || node.importClause !== importClause || node.moduleSpecifier !== moduleSpecifier || node.assertClause !== assertClause ? finishUpdateImportDeclaration(createImportDeclaration2(modifiers, importClause, moduleSpecifier, assertClause), node) : node;
|
|
}
|
|
function finishUpdateImportDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createImportClause3(isTypeOnly, name, namedBindings) {
|
|
const node = createBaseNode(270 /* ImportClause */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.name = name;
|
|
node.namedBindings = namedBindings;
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.namedBindings);
|
|
if (isTypeOnly) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateImportClause3(node, isTypeOnly, name, namedBindings) {
|
|
return node.isTypeOnly !== isTypeOnly || node.name !== name || node.namedBindings !== namedBindings ? update(createImportClause3(isTypeOnly, name, namedBindings), node) : node;
|
|
}
|
|
function createAssertClause(elements, multiLine) {
|
|
const node = createBaseNode(296 /* AssertClause */);
|
|
node.elements = createNodeArray2(elements);
|
|
node.multiLine = multiLine;
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function updateAssertClause(node, elements, multiLine) {
|
|
return node.elements !== elements || node.multiLine !== multiLine ? update(createAssertClause(elements, multiLine), node) : node;
|
|
}
|
|
function createAssertEntry(name, value) {
|
|
const node = createBaseNode(297 /* AssertEntry */);
|
|
node.name = name;
|
|
node.value = value;
|
|
node.transformFlags |= 4 /* ContainsESNext */;
|
|
return node;
|
|
}
|
|
function updateAssertEntry(node, name, value) {
|
|
return node.name !== name || node.value !== value ? update(createAssertEntry(name, value), node) : node;
|
|
}
|
|
function createImportTypeAssertionContainer(clause, multiLine) {
|
|
const node = createBaseNode(298 /* ImportTypeAssertionContainer */);
|
|
node.assertClause = clause;
|
|
node.multiLine = multiLine;
|
|
return node;
|
|
}
|
|
function updateImportTypeAssertionContainer(node, clause, multiLine) {
|
|
return node.assertClause !== clause || node.multiLine !== multiLine ? update(createImportTypeAssertionContainer(clause, multiLine), node) : node;
|
|
}
|
|
function createNamespaceImport2(name) {
|
|
const node = createBaseNode(271 /* NamespaceImport */);
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamespaceImport2(node, name) {
|
|
return node.name !== name ? update(createNamespaceImport2(name), node) : node;
|
|
}
|
|
function createNamespaceExport2(name) {
|
|
const node = createBaseNode(277 /* NamespaceExport */);
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.name) | 4 /* ContainsESNext */;
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamespaceExport2(node, name) {
|
|
return node.name !== name ? update(createNamespaceExport2(name), node) : node;
|
|
}
|
|
function createNamedImports2(elements) {
|
|
const node = createBaseNode(272 /* NamedImports */);
|
|
node.elements = createNodeArray2(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamedImports2(node, elements) {
|
|
return node.elements !== elements ? update(createNamedImports2(elements), node) : node;
|
|
}
|
|
function createImportSpecifier2(isTypeOnly, propertyName, name) {
|
|
const node = createBaseNode(273 /* ImportSpecifier */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.propertyName = propertyName;
|
|
node.name = name;
|
|
node.transformFlags |= propagateChildFlags(node.propertyName) | propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateImportSpecifier2(node, isTypeOnly, propertyName, name) {
|
|
return node.isTypeOnly !== isTypeOnly || node.propertyName !== propertyName || node.name !== name ? update(createImportSpecifier2(isTypeOnly, propertyName, name), node) : node;
|
|
}
|
|
function createExportAssignment3(modifiers, isExportEquals, expression) {
|
|
const node = createBaseDeclaration(274 /* ExportAssignment */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.isExportEquals = isExportEquals;
|
|
node.expression = isExportEquals ? parenthesizerRules().parenthesizeRightSideOfBinary(63 /* EqualsToken */, void 0, expression) : parenthesizerRules().parenthesizeExpressionOfExportDefault(expression);
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.expression);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateExportAssignment2(node, modifiers, expression) {
|
|
return node.modifiers !== modifiers || node.expression !== expression ? finishUpdateExportAssignment(createExportAssignment3(modifiers, node.isExportEquals, expression), node) : node;
|
|
}
|
|
function finishUpdateExportAssignment(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createExportDeclaration3(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
const node = createBaseDeclaration(275 /* ExportDeclaration */);
|
|
node.modifiers = asNodeArray(modifiers);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.exportClause = exportClause;
|
|
node.moduleSpecifier = moduleSpecifier;
|
|
node.assertClause = assertClause;
|
|
node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.exportClause) | propagateChildFlags(node.moduleSpecifier);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
node.illegalDecorators = void 0;
|
|
return node;
|
|
}
|
|
function updateExportDeclaration3(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
return node.modifiers !== modifiers || node.isTypeOnly !== isTypeOnly || node.exportClause !== exportClause || node.moduleSpecifier !== moduleSpecifier || node.assertClause !== assertClause ? finishUpdateExportDeclaration(createExportDeclaration3(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause), node) : node;
|
|
}
|
|
function finishUpdateExportDeclaration(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createNamedExports2(elements) {
|
|
const node = createBaseNode(276 /* NamedExports */);
|
|
node.elements = createNodeArray2(elements);
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateNamedExports2(node, elements) {
|
|
return node.elements !== elements ? update(createNamedExports2(elements), node) : node;
|
|
}
|
|
function createExportSpecifier2(isTypeOnly, propertyName, name) {
|
|
const node = createBaseNode(278 /* ExportSpecifier */);
|
|
node.isTypeOnly = isTypeOnly;
|
|
node.propertyName = asName(propertyName);
|
|
node.name = asName(name);
|
|
node.transformFlags |= propagateChildFlags(node.propertyName) | propagateChildFlags(node.name);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateExportSpecifier2(node, isTypeOnly, propertyName, name) {
|
|
return node.isTypeOnly !== isTypeOnly || node.propertyName !== propertyName || node.name !== name ? update(createExportSpecifier2(isTypeOnly, propertyName, name), node) : node;
|
|
}
|
|
function createMissingDeclaration() {
|
|
const node = createBaseDeclaration(279 /* MissingDeclaration */);
|
|
return node;
|
|
}
|
|
function createExternalModuleReference2(expression) {
|
|
const node = createBaseNode(280 /* ExternalModuleReference */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression);
|
|
node.transformFlags &= ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
return node;
|
|
}
|
|
function updateExternalModuleReference2(node, expression) {
|
|
return node.expression !== expression ? update(createExternalModuleReference2(expression), node) : node;
|
|
}
|
|
function createJSDocPrimaryTypeWorker(kind) {
|
|
return createBaseNode(kind);
|
|
}
|
|
function createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix = false) {
|
|
const node = createJSDocUnaryTypeWorker(
|
|
kind,
|
|
postfix ? type && parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(type) : type
|
|
);
|
|
node.postfix = postfix;
|
|
return node;
|
|
}
|
|
function createJSDocUnaryTypeWorker(kind, type) {
|
|
const node = createBaseNode(kind);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
function updateJSDocPrePostfixUnaryTypeWorker(kind, node, type) {
|
|
return node.type !== type ? update(createJSDocPrePostfixUnaryTypeWorker(kind, type, node.postfix), node) : node;
|
|
}
|
|
function updateJSDocUnaryTypeWorker(kind, node, type) {
|
|
return node.type !== type ? update(createJSDocUnaryTypeWorker(kind, type), node) : node;
|
|
}
|
|
function createJSDocFunctionType(parameters, type) {
|
|
const node = createBaseSignatureDeclaration(
|
|
320 /* JSDocFunctionType */,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
type
|
|
);
|
|
return node;
|
|
}
|
|
function updateJSDocFunctionType(node, parameters, type) {
|
|
return node.parameters !== parameters || node.type !== type ? update(createJSDocFunctionType(parameters, type), node) : node;
|
|
}
|
|
function createJSDocTypeLiteral2(propertyTags, isArrayType = false) {
|
|
const node = createBaseNode(325 /* JSDocTypeLiteral */);
|
|
node.jsDocPropertyTags = asNodeArray(propertyTags);
|
|
node.isArrayType = isArrayType;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeLiteral(node, propertyTags, isArrayType) {
|
|
return node.jsDocPropertyTags !== propertyTags || node.isArrayType !== isArrayType ? update(createJSDocTypeLiteral2(propertyTags, isArrayType), node) : node;
|
|
}
|
|
function createJSDocTypeExpression2(type) {
|
|
const node = createBaseNode(312 /* JSDocTypeExpression */);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeExpression(node, type) {
|
|
return node.type !== type ? update(createJSDocTypeExpression2(type), node) : node;
|
|
}
|
|
function createJSDocSignature2(typeParameters, parameters, type) {
|
|
const node = createBaseNode(326 /* JSDocSignature */);
|
|
node.typeParameters = asNodeArray(typeParameters);
|
|
node.parameters = createNodeArray2(parameters);
|
|
node.type = type;
|
|
return node;
|
|
}
|
|
function updateJSDocSignature(node, typeParameters, parameters, type) {
|
|
return node.typeParameters !== typeParameters || node.parameters !== parameters || node.type !== type ? update(createJSDocSignature2(typeParameters, parameters, type), node) : node;
|
|
}
|
|
function getDefaultTagName(node) {
|
|
const defaultTagName = getDefaultTagNameForKind(node.kind);
|
|
return node.tagName.escapedText === escapeLeadingUnderscores(defaultTagName) ? node.tagName : createIdentifier3(defaultTagName);
|
|
}
|
|
function createBaseJSDocTag(kind, tagName, comment) {
|
|
const node = createBaseNode(kind);
|
|
node.tagName = tagName;
|
|
node.comment = comment;
|
|
return node;
|
|
}
|
|
function createJSDocTemplateTag2(tagName, constraint, typeParameters, comment) {
|
|
const node = createBaseJSDocTag(347 /* JSDocTemplateTag */, tagName != null ? tagName : createIdentifier3("template"), comment);
|
|
node.constraint = constraint;
|
|
node.typeParameters = createNodeArray2(typeParameters);
|
|
return node;
|
|
}
|
|
function updateJSDocTemplateTag(node, tagName = getDefaultTagName(node), constraint, typeParameters, comment) {
|
|
return node.tagName !== tagName || node.constraint !== constraint || node.typeParameters !== typeParameters || node.comment !== comment ? update(createJSDocTemplateTag2(tagName, constraint, typeParameters, comment), node) : node;
|
|
}
|
|
function createJSDocTypedefTag2(tagName, typeExpression, fullName, comment) {
|
|
const node = createBaseJSDocTag(348 /* JSDocTypedefTag */, tagName != null ? tagName : createIdentifier3("typedef"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.fullName = fullName;
|
|
node.name = getJSDocTypeAliasName(fullName);
|
|
return node;
|
|
}
|
|
function updateJSDocTypedefTag(node, tagName = getDefaultTagName(node), typeExpression, fullName, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.fullName !== fullName || node.comment !== comment ? update(createJSDocTypedefTag2(tagName, typeExpression, fullName, comment), node) : node;
|
|
}
|
|
function createJSDocParameterTag2(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
const node = createBaseJSDocTag(343 /* JSDocParameterTag */, tagName != null ? tagName : createIdentifier3("param"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.name = name;
|
|
node.isNameFirst = !!isNameFirst;
|
|
node.isBracketed = isBracketed;
|
|
return node;
|
|
}
|
|
function updateJSDocParameterTag(node, tagName = getDefaultTagName(node), name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
return node.tagName !== tagName || node.name !== name || node.isBracketed !== isBracketed || node.typeExpression !== typeExpression || node.isNameFirst !== isNameFirst || node.comment !== comment ? update(createJSDocParameterTag2(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node) : node;
|
|
}
|
|
function createJSDocPropertyTag2(tagName, name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
const node = createBaseJSDocTag(350 /* JSDocPropertyTag */, tagName != null ? tagName : createIdentifier3("prop"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.name = name;
|
|
node.isNameFirst = !!isNameFirst;
|
|
node.isBracketed = isBracketed;
|
|
return node;
|
|
}
|
|
function updateJSDocPropertyTag(node, tagName = getDefaultTagName(node), name, isBracketed, typeExpression, isNameFirst, comment) {
|
|
return node.tagName !== tagName || node.name !== name || node.isBracketed !== isBracketed || node.typeExpression !== typeExpression || node.isNameFirst !== isNameFirst || node.comment !== comment ? update(createJSDocPropertyTag2(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node) : node;
|
|
}
|
|
function createJSDocCallbackTag2(tagName, typeExpression, fullName, comment) {
|
|
const node = createBaseJSDocTag(341 /* JSDocCallbackTag */, tagName != null ? tagName : createIdentifier3("callback"), comment);
|
|
node.typeExpression = typeExpression;
|
|
node.fullName = fullName;
|
|
node.name = getJSDocTypeAliasName(fullName);
|
|
return node;
|
|
}
|
|
function updateJSDocCallbackTag(node, tagName = getDefaultTagName(node), typeExpression, fullName, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.fullName !== fullName || node.comment !== comment ? update(createJSDocCallbackTag2(tagName, typeExpression, fullName, comment), node) : node;
|
|
}
|
|
function createJSDocAugmentsTag2(tagName, className, comment) {
|
|
const node = createBaseJSDocTag(331 /* JSDocAugmentsTag */, tagName != null ? tagName : createIdentifier3("augments"), comment);
|
|
node.class = className;
|
|
return node;
|
|
}
|
|
function updateJSDocAugmentsTag(node, tagName = getDefaultTagName(node), className, comment) {
|
|
return node.tagName !== tagName || node.class !== className || node.comment !== comment ? update(createJSDocAugmentsTag2(tagName, className, comment), node) : node;
|
|
}
|
|
function createJSDocImplementsTag2(tagName, className, comment) {
|
|
const node = createBaseJSDocTag(332 /* JSDocImplementsTag */, tagName != null ? tagName : createIdentifier3("implements"), comment);
|
|
node.class = className;
|
|
return node;
|
|
}
|
|
function createJSDocSeeTag(tagName, name, comment) {
|
|
const node = createBaseJSDocTag(349 /* JSDocSeeTag */, tagName != null ? tagName : createIdentifier3("see"), comment);
|
|
node.name = name;
|
|
return node;
|
|
}
|
|
function updateJSDocSeeTag(node, tagName, name, comment) {
|
|
return node.tagName !== tagName || node.name !== name || node.comment !== comment ? update(createJSDocSeeTag(tagName, name, comment), node) : node;
|
|
}
|
|
function createJSDocNameReference(name) {
|
|
const node = createBaseNode(313 /* JSDocNameReference */);
|
|
node.name = name;
|
|
return node;
|
|
}
|
|
function updateJSDocNameReference(node, name) {
|
|
return node.name !== name ? update(createJSDocNameReference(name), node) : node;
|
|
}
|
|
function createJSDocMemberName(left, right) {
|
|
const node = createBaseNode(314 /* JSDocMemberName */);
|
|
node.left = left;
|
|
node.right = right;
|
|
node.transformFlags |= propagateChildFlags(node.left) | propagateChildFlags(node.right);
|
|
return node;
|
|
}
|
|
function updateJSDocMemberName(node, left, right) {
|
|
return node.left !== left || node.right !== right ? update(createJSDocMemberName(left, right), node) : node;
|
|
}
|
|
function createJSDocLink(name, text) {
|
|
const node = createBaseNode(327 /* JSDocLink */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLink(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLink(name, text), node) : node;
|
|
}
|
|
function createJSDocLinkCode(name, text) {
|
|
const node = createBaseNode(328 /* JSDocLinkCode */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLinkCode(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLinkCode(name, text), node) : node;
|
|
}
|
|
function createJSDocLinkPlain(name, text) {
|
|
const node = createBaseNode(329 /* JSDocLinkPlain */);
|
|
node.name = name;
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocLinkPlain(node, name, text) {
|
|
return node.name !== name ? update(createJSDocLinkPlain(name, text), node) : node;
|
|
}
|
|
function updateJSDocImplementsTag(node, tagName = getDefaultTagName(node), className, comment) {
|
|
return node.tagName !== tagName || node.class !== className || node.comment !== comment ? update(createJSDocImplementsTag2(tagName, className, comment), node) : node;
|
|
}
|
|
function createJSDocSimpleTagWorker(kind, tagName, comment) {
|
|
const node = createBaseJSDocTag(kind, tagName != null ? tagName : createIdentifier3(getDefaultTagNameForKind(kind)), comment);
|
|
return node;
|
|
}
|
|
function updateJSDocSimpleTagWorker(kind, node, tagName = getDefaultTagName(node), comment) {
|
|
return node.tagName !== tagName || node.comment !== comment ? update(createJSDocSimpleTagWorker(kind, tagName, comment), node) : node;
|
|
}
|
|
function createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment) {
|
|
const node = createBaseJSDocTag(kind, tagName != null ? tagName : createIdentifier3(getDefaultTagNameForKind(kind)), comment);
|
|
node.typeExpression = typeExpression;
|
|
return node;
|
|
}
|
|
function updateJSDocTypeLikeTagWorker(kind, node, tagName = getDefaultTagName(node), typeExpression, comment) {
|
|
return node.tagName !== tagName || node.typeExpression !== typeExpression || node.comment !== comment ? update(createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment), node) : node;
|
|
}
|
|
function createJSDocUnknownTag(tagName, comment) {
|
|
const node = createBaseJSDocTag(330 /* JSDocTag */, tagName, comment);
|
|
return node;
|
|
}
|
|
function updateJSDocUnknownTag(node, tagName, comment) {
|
|
return node.tagName !== tagName || node.comment !== comment ? update(createJSDocUnknownTag(tagName, comment), node) : node;
|
|
}
|
|
function createJSDocText(text) {
|
|
const node = createBaseNode(324 /* JSDocText */);
|
|
node.text = text;
|
|
return node;
|
|
}
|
|
function updateJSDocText(node, text) {
|
|
return node.text !== text ? update(createJSDocText(text), node) : node;
|
|
}
|
|
function createJSDocComment2(comment, tags) {
|
|
const node = createBaseNode(323 /* JSDoc */);
|
|
node.comment = comment;
|
|
node.tags = asNodeArray(tags);
|
|
return node;
|
|
}
|
|
function updateJSDocComment(node, comment, tags) {
|
|
return node.comment !== comment || node.tags !== tags ? update(createJSDocComment2(comment, tags), node) : node;
|
|
}
|
|
function createJsxElement2(openingElement, children, closingElement) {
|
|
const node = createBaseNode(281 /* JsxElement */);
|
|
node.openingElement = openingElement;
|
|
node.children = createNodeArray2(children);
|
|
node.closingElement = closingElement;
|
|
node.transformFlags |= propagateChildFlags(node.openingElement) | propagateChildrenFlags(node.children) | propagateChildFlags(node.closingElement) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxElement2(node, openingElement, children, closingElement) {
|
|
return node.openingElement !== openingElement || node.children !== children || node.closingElement !== closingElement ? update(createJsxElement2(openingElement, children, closingElement), node) : node;
|
|
}
|
|
function createJsxSelfClosingElement2(tagName, typeArguments, attributes) {
|
|
const node = createBaseNode(282 /* JsxSelfClosingElement */);
|
|
node.tagName = tagName;
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.attributes = attributes;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.attributes) | 2 /* ContainsJsx */;
|
|
if (node.typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateJsxSelfClosingElement2(node, tagName, typeArguments, attributes) {
|
|
return node.tagName !== tagName || node.typeArguments !== typeArguments || node.attributes !== attributes ? update(createJsxSelfClosingElement2(tagName, typeArguments, attributes), node) : node;
|
|
}
|
|
function createJsxOpeningElement2(tagName, typeArguments, attributes) {
|
|
const node = createBaseNode(283 /* JsxOpeningElement */);
|
|
node.tagName = tagName;
|
|
node.typeArguments = asNodeArray(typeArguments);
|
|
node.attributes = attributes;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | propagateChildrenFlags(node.typeArguments) | propagateChildFlags(node.attributes) | 2 /* ContainsJsx */;
|
|
if (typeArguments) {
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
}
|
|
return node;
|
|
}
|
|
function updateJsxOpeningElement2(node, tagName, typeArguments, attributes) {
|
|
return node.tagName !== tagName || node.typeArguments !== typeArguments || node.attributes !== attributes ? update(createJsxOpeningElement2(tagName, typeArguments, attributes), node) : node;
|
|
}
|
|
function createJsxClosingElement2(tagName) {
|
|
const node = createBaseNode(284 /* JsxClosingElement */);
|
|
node.tagName = tagName;
|
|
node.transformFlags |= propagateChildFlags(node.tagName) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxClosingElement2(node, tagName) {
|
|
return node.tagName !== tagName ? update(createJsxClosingElement2(tagName), node) : node;
|
|
}
|
|
function createJsxFragment2(openingFragment, children, closingFragment) {
|
|
const node = createBaseNode(285 /* JsxFragment */);
|
|
node.openingFragment = openingFragment;
|
|
node.children = createNodeArray2(children);
|
|
node.closingFragment = closingFragment;
|
|
node.transformFlags |= propagateChildFlags(node.openingFragment) | propagateChildrenFlags(node.children) | propagateChildFlags(node.closingFragment) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxFragment2(node, openingFragment, children, closingFragment) {
|
|
return node.openingFragment !== openingFragment || node.children !== children || node.closingFragment !== closingFragment ? update(createJsxFragment2(openingFragment, children, closingFragment), node) : node;
|
|
}
|
|
function createJsxText2(text, containsOnlyTriviaWhiteSpaces) {
|
|
const node = createBaseNode(11 /* JsxText */);
|
|
node.text = text;
|
|
node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces;
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxText2(node, text, containsOnlyTriviaWhiteSpaces) {
|
|
return node.text !== text || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces ? update(createJsxText2(text, containsOnlyTriviaWhiteSpaces), node) : node;
|
|
}
|
|
function createJsxOpeningFragment2() {
|
|
const node = createBaseNode(286 /* JsxOpeningFragment */);
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function createJsxJsxClosingFragment2() {
|
|
const node = createBaseNode(287 /* JsxClosingFragment */);
|
|
node.transformFlags |= 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function createJsxAttribute2(name, initializer) {
|
|
const node = createBaseNode(288 /* JsxAttribute */);
|
|
node.name = name;
|
|
node.initializer = initializer;
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxAttribute2(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? update(createJsxAttribute2(name, initializer), node) : node;
|
|
}
|
|
function createJsxAttributes2(properties) {
|
|
const node = createBaseNode(289 /* JsxAttributes */);
|
|
node.properties = createNodeArray2(properties);
|
|
node.transformFlags |= propagateChildrenFlags(node.properties) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxAttributes2(node, properties) {
|
|
return node.properties !== properties ? update(createJsxAttributes2(properties), node) : node;
|
|
}
|
|
function createJsxSpreadAttribute2(expression) {
|
|
const node = createBaseNode(290 /* JsxSpreadAttribute */);
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxSpreadAttribute2(node, expression) {
|
|
return node.expression !== expression ? update(createJsxSpreadAttribute2(expression), node) : node;
|
|
}
|
|
function createJsxExpression2(dotDotDotToken, expression) {
|
|
const node = createBaseNode(291 /* JsxExpression */);
|
|
node.dotDotDotToken = dotDotDotToken;
|
|
node.expression = expression;
|
|
node.transformFlags |= propagateChildFlags(node.dotDotDotToken) | propagateChildFlags(node.expression) | 2 /* ContainsJsx */;
|
|
return node;
|
|
}
|
|
function updateJsxExpression2(node, expression) {
|
|
return node.expression !== expression ? update(createJsxExpression2(node.dotDotDotToken, expression), node) : node;
|
|
}
|
|
function createCaseClause2(expression, statements) {
|
|
const node = createBaseNode(292 /* CaseClause */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.statements = createNodeArray2(statements);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateCaseClause2(node, expression, statements) {
|
|
return node.expression !== expression || node.statements !== statements ? update(createCaseClause2(expression, statements), node) : node;
|
|
}
|
|
function createDefaultClause2(statements) {
|
|
const node = createBaseNode(293 /* DefaultClause */);
|
|
node.statements = createNodeArray2(statements);
|
|
node.transformFlags = propagateChildrenFlags(node.statements);
|
|
return node;
|
|
}
|
|
function updateDefaultClause2(node, statements) {
|
|
return node.statements !== statements ? update(createDefaultClause2(statements), node) : node;
|
|
}
|
|
function createHeritageClause2(token, types) {
|
|
const node = createBaseNode(294 /* HeritageClause */);
|
|
node.token = token;
|
|
node.types = createNodeArray2(types);
|
|
node.transformFlags |= propagateChildrenFlags(node.types);
|
|
switch (token) {
|
|
case 94 /* ExtendsKeyword */:
|
|
node.transformFlags |= 1024 /* ContainsES2015 */;
|
|
break;
|
|
case 117 /* ImplementsKeyword */:
|
|
node.transformFlags |= 1 /* ContainsTypeScript */;
|
|
break;
|
|
default:
|
|
return Debug.assertNever(token);
|
|
}
|
|
return node;
|
|
}
|
|
function updateHeritageClause2(node, types) {
|
|
return node.types !== types ? update(createHeritageClause2(node.token, types), node) : node;
|
|
}
|
|
function createCatchClause2(variableDeclaration, block) {
|
|
const node = createBaseNode(295 /* CatchClause */);
|
|
if (typeof variableDeclaration === "string" || variableDeclaration && !isVariableDeclaration(variableDeclaration)) {
|
|
variableDeclaration = createVariableDeclaration3(
|
|
variableDeclaration,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
node.variableDeclaration = variableDeclaration;
|
|
node.block = block;
|
|
node.transformFlags |= propagateChildFlags(node.variableDeclaration) | propagateChildFlags(node.block);
|
|
if (!variableDeclaration)
|
|
node.transformFlags |= 64 /* ContainsES2019 */;
|
|
return node;
|
|
}
|
|
function updateCatchClause2(node, variableDeclaration, block) {
|
|
return node.variableDeclaration !== variableDeclaration || node.block !== block ? update(createCatchClause2(variableDeclaration, block), node) : node;
|
|
}
|
|
function createPropertyAssignment2(name, initializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
299 /* PropertyAssignment */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.initializer = parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer);
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
node.questionToken = void 0;
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
function updatePropertyAssignment2(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? finishUpdatePropertyAssignment(createPropertyAssignment2(name, initializer), node) : node;
|
|
}
|
|
function finishUpdatePropertyAssignment(updated, original) {
|
|
if (updated !== original) {
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
updated.questionToken = original.questionToken;
|
|
updated.exclamationToken = original.exclamationToken;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createShorthandPropertyAssignment2(name, objectAssignmentInitializer) {
|
|
const node = createBaseNamedDeclaration(
|
|
300 /* ShorthandPropertyAssignment */,
|
|
void 0,
|
|
name
|
|
);
|
|
node.objectAssignmentInitializer = objectAssignmentInitializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer);
|
|
node.transformFlags |= propagateChildFlags(node.objectAssignmentInitializer) | 1024 /* ContainsES2015 */;
|
|
node.equalsToken = void 0;
|
|
node.illegalDecorators = void 0;
|
|
node.modifiers = void 0;
|
|
node.questionToken = void 0;
|
|
node.exclamationToken = void 0;
|
|
return node;
|
|
}
|
|
function updateShorthandPropertyAssignment2(node, name, objectAssignmentInitializer) {
|
|
return node.name !== name || node.objectAssignmentInitializer !== objectAssignmentInitializer ? finishUpdateShorthandPropertyAssignment(createShorthandPropertyAssignment2(name, objectAssignmentInitializer), node) : node;
|
|
}
|
|
function finishUpdateShorthandPropertyAssignment(updated, original) {
|
|
if (updated !== original) {
|
|
updated.equalsToken = original.equalsToken;
|
|
updated.illegalDecorators = original.illegalDecorators;
|
|
updated.modifiers = original.modifiers;
|
|
updated.questionToken = original.questionToken;
|
|
updated.exclamationToken = original.exclamationToken;
|
|
}
|
|
return update(updated, original);
|
|
}
|
|
function createSpreadAssignment2(expression) {
|
|
const node = createBaseNode(301 /* SpreadAssignment */);
|
|
node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression);
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 128 /* ContainsES2018 */ | 65536 /* ContainsObjectRestOrSpread */;
|
|
return node;
|
|
}
|
|
function updateSpreadAssignment2(node, expression) {
|
|
return node.expression !== expression ? update(createSpreadAssignment2(expression), node) : node;
|
|
}
|
|
function createEnumMember2(name, initializer) {
|
|
const node = createBaseNode(302 /* EnumMember */);
|
|
node.name = asName(name);
|
|
node.initializer = initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer);
|
|
node.transformFlags |= propagateChildFlags(node.name) | propagateChildFlags(node.initializer) | 1 /* ContainsTypeScript */;
|
|
return node;
|
|
}
|
|
function updateEnumMember2(node, name, initializer) {
|
|
return node.name !== name || node.initializer !== initializer ? update(createEnumMember2(name, initializer), node) : node;
|
|
}
|
|
function createSourceFile2(statements, endOfFileToken, flags2) {
|
|
const node = baseFactory2.createBaseSourceFileNode(308 /* SourceFile */);
|
|
node.statements = createNodeArray2(statements);
|
|
node.endOfFileToken = endOfFileToken;
|
|
node.flags |= flags2;
|
|
node.fileName = "";
|
|
node.text = "";
|
|
node.languageVersion = 0;
|
|
node.languageVariant = 0;
|
|
node.scriptKind = 0;
|
|
node.isDeclarationFile = false;
|
|
node.hasNoDefaultLib = false;
|
|
node.transformFlags |= propagateChildrenFlags(node.statements) | propagateChildFlags(node.endOfFileToken);
|
|
return node;
|
|
}
|
|
function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) {
|
|
const node = source.redirectInfo ? Object.create(source.redirectInfo.redirectTarget) : baseFactory2.createBaseSourceFileNode(308 /* SourceFile */);
|
|
for (const p in source) {
|
|
if (p === "emitNode" || hasProperty(node, p) || !hasProperty(source, p))
|
|
continue;
|
|
node[p] = source[p];
|
|
}
|
|
node.flags |= source.flags;
|
|
node.statements = createNodeArray2(statements);
|
|
node.endOfFileToken = source.endOfFileToken;
|
|
node.isDeclarationFile = isDeclarationFile;
|
|
node.referencedFiles = referencedFiles;
|
|
node.typeReferenceDirectives = typeReferences;
|
|
node.hasNoDefaultLib = hasNoDefaultLib;
|
|
node.libReferenceDirectives = libReferences;
|
|
node.transformFlags = propagateChildrenFlags(node.statements) | propagateChildFlags(node.endOfFileToken);
|
|
node.impliedNodeFormat = source.impliedNodeFormat;
|
|
return node;
|
|
}
|
|
function updateSourceFile2(node, statements, isDeclarationFile = node.isDeclarationFile, referencedFiles = node.referencedFiles, typeReferenceDirectives = node.typeReferenceDirectives, hasNoDefaultLib = node.hasNoDefaultLib, libReferenceDirectives = node.libReferenceDirectives) {
|
|
return node.statements !== statements || node.isDeclarationFile !== isDeclarationFile || node.referencedFiles !== referencedFiles || node.typeReferenceDirectives !== typeReferenceDirectives || node.hasNoDefaultLib !== hasNoDefaultLib || node.libReferenceDirectives !== libReferenceDirectives ? update(cloneSourceFileWithChanges(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives), node) : node;
|
|
}
|
|
function createBundle2(sourceFiles, prepends = emptyArray) {
|
|
const node = createBaseNode(309 /* Bundle */);
|
|
node.prepends = prepends;
|
|
node.sourceFiles = sourceFiles;
|
|
return node;
|
|
}
|
|
function updateBundle2(node, sourceFiles, prepends = emptyArray) {
|
|
return node.sourceFiles !== sourceFiles || node.prepends !== prepends ? update(createBundle2(sourceFiles, prepends), node) : node;
|
|
}
|
|
function createUnparsedSource(prologues, syntheticReferences, texts) {
|
|
const node = createBaseNode(310 /* UnparsedSource */);
|
|
node.prologues = prologues;
|
|
node.syntheticReferences = syntheticReferences;
|
|
node.texts = texts;
|
|
node.fileName = "";
|
|
node.text = "";
|
|
node.referencedFiles = emptyArray;
|
|
node.libReferenceDirectives = emptyArray;
|
|
node.getLineAndCharacterOfPosition = (pos) => getLineAndCharacterOfPosition(node, pos);
|
|
return node;
|
|
}
|
|
function createBaseUnparsedNode(kind, data) {
|
|
const node = createBaseNode(kind);
|
|
node.data = data;
|
|
return node;
|
|
}
|
|
function createUnparsedPrologue(data) {
|
|
return createBaseUnparsedNode(303 /* UnparsedPrologue */, data);
|
|
}
|
|
function createUnparsedPrepend(data, texts) {
|
|
const node = createBaseUnparsedNode(304 /* UnparsedPrepend */, data);
|
|
node.texts = texts;
|
|
return node;
|
|
}
|
|
function createUnparsedTextLike(data, internal) {
|
|
return createBaseUnparsedNode(internal ? 306 /* UnparsedInternalText */ : 305 /* UnparsedText */, data);
|
|
}
|
|
function createUnparsedSyntheticReference(section) {
|
|
const node = createBaseNode(307 /* UnparsedSyntheticReference */);
|
|
node.data = section.data;
|
|
node.section = section;
|
|
return node;
|
|
}
|
|
function createInputFiles2() {
|
|
const node = createBaseNode(311 /* InputFiles */);
|
|
node.javascriptText = "";
|
|
node.declarationText = "";
|
|
return node;
|
|
}
|
|
function createSyntheticExpression(type, isSpread = false, tupleNameSource) {
|
|
const node = createBaseNode(234 /* SyntheticExpression */);
|
|
node.type = type;
|
|
node.isSpread = isSpread;
|
|
node.tupleNameSource = tupleNameSource;
|
|
return node;
|
|
}
|
|
function createSyntaxList3(children) {
|
|
const node = createBaseNode(351 /* SyntaxList */);
|
|
node._children = children;
|
|
return node;
|
|
}
|
|
function createNotEmittedStatement2(original) {
|
|
const node = createBaseNode(352 /* NotEmittedStatement */);
|
|
node.original = original;
|
|
setTextRange(node, original);
|
|
return node;
|
|
}
|
|
function createPartiallyEmittedExpression2(expression, original) {
|
|
const node = createBaseNode(353 /* PartiallyEmittedExpression */);
|
|
node.expression = expression;
|
|
node.original = original;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
|
|
setTextRange(node, original);
|
|
return node;
|
|
}
|
|
function updatePartiallyEmittedExpression2(node, expression) {
|
|
return node.expression !== expression ? update(createPartiallyEmittedExpression2(expression, node.original), node) : node;
|
|
}
|
|
function flattenCommaElements(node) {
|
|
if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
|
|
if (isCommaListExpression(node)) {
|
|
return node.elements;
|
|
}
|
|
if (isBinaryExpression(node) && isCommaToken(node.operatorToken)) {
|
|
return [node.left, node.right];
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function createCommaListExpression(elements) {
|
|
const node = createBaseNode(354 /* CommaListExpression */);
|
|
node.elements = createNodeArray2(sameFlatMap(elements, flattenCommaElements));
|
|
node.transformFlags |= propagateChildrenFlags(node.elements);
|
|
return node;
|
|
}
|
|
function updateCommaListExpression(node, elements) {
|
|
return node.elements !== elements ? update(createCommaListExpression(elements), node) : node;
|
|
}
|
|
function createEndOfDeclarationMarker(original) {
|
|
const node = createBaseNode(356 /* EndOfDeclarationMarker */);
|
|
node.emitNode = {};
|
|
node.original = original;
|
|
return node;
|
|
}
|
|
function createMergeDeclarationMarker(original) {
|
|
const node = createBaseNode(355 /* MergeDeclarationMarker */);
|
|
node.emitNode = {};
|
|
node.original = original;
|
|
return node;
|
|
}
|
|
function createSyntheticReferenceExpression(expression, thisArg) {
|
|
const node = createBaseNode(357 /* SyntheticReferenceExpression */);
|
|
node.expression = expression;
|
|
node.thisArg = thisArg;
|
|
node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg);
|
|
return node;
|
|
}
|
|
function updateSyntheticReferenceExpression(node, expression, thisArg) {
|
|
return node.expression !== expression || node.thisArg !== thisArg ? update(createSyntheticReferenceExpression(expression, thisArg), node) : node;
|
|
}
|
|
function cloneNode(node) {
|
|
if (node === void 0) {
|
|
return node;
|
|
}
|
|
const clone2 = isSourceFile(node) ? baseFactory2.createBaseSourceFileNode(308 /* SourceFile */) : isIdentifier(node) ? baseFactory2.createBaseIdentifierNode(79 /* Identifier */) : isPrivateIdentifier(node) ? baseFactory2.createBasePrivateIdentifierNode(80 /* PrivateIdentifier */) : !isNodeKind(node.kind) ? baseFactory2.createBaseTokenNode(node.kind) : baseFactory2.createBaseNode(node.kind);
|
|
clone2.flags |= node.flags & ~8 /* Synthesized */;
|
|
clone2.transformFlags = node.transformFlags;
|
|
setOriginalNode(clone2, node);
|
|
for (const key in node) {
|
|
if (hasProperty(clone2, key) || !hasProperty(node, key)) {
|
|
continue;
|
|
}
|
|
clone2[key] = node[key];
|
|
}
|
|
return clone2;
|
|
}
|
|
function createImmediatelyInvokedFunctionExpression2(statements, param, paramValue) {
|
|
return createCallExpression(
|
|
createFunctionExpression2(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
param ? [param] : [],
|
|
void 0,
|
|
createBlock2(statements, true)
|
|
),
|
|
void 0,
|
|
paramValue ? [paramValue] : []
|
|
);
|
|
}
|
|
function createImmediatelyInvokedArrowFunction2(statements, param, paramValue) {
|
|
return createCallExpression(
|
|
createArrowFunction3(
|
|
void 0,
|
|
void 0,
|
|
param ? [param] : [],
|
|
void 0,
|
|
void 0,
|
|
createBlock2(statements, true)
|
|
),
|
|
void 0,
|
|
paramValue ? [paramValue] : []
|
|
);
|
|
}
|
|
function createVoidZero2() {
|
|
return createVoidExpression(createNumericLiteral2("0"));
|
|
}
|
|
function createExportDefault2(expression) {
|
|
return createExportAssignment3(
|
|
void 0,
|
|
false,
|
|
expression
|
|
);
|
|
}
|
|
function createExternalModuleExport2(exportName) {
|
|
return createExportDeclaration3(
|
|
void 0,
|
|
false,
|
|
createNamedExports2([
|
|
createExportSpecifier2(false, void 0, exportName)
|
|
])
|
|
);
|
|
}
|
|
function createTypeCheck(value, tag) {
|
|
return tag === "undefined" ? factory2.createStrictEquality(value, createVoidZero2()) : factory2.createStrictEquality(createTypeOfExpression(value), createStringLiteral2(tag));
|
|
}
|
|
function createMethodCall(object, methodName, argumentsList) {
|
|
if (isCallChain(object)) {
|
|
return createCallChain2(
|
|
createPropertyAccessChain2(object, void 0, methodName),
|
|
void 0,
|
|
void 0,
|
|
argumentsList
|
|
);
|
|
}
|
|
return createCallExpression(
|
|
createPropertyAccessExpression(object, methodName),
|
|
void 0,
|
|
argumentsList
|
|
);
|
|
}
|
|
function createFunctionBindCall(target, thisArg, argumentsList) {
|
|
return createMethodCall(target, "bind", [thisArg, ...argumentsList]);
|
|
}
|
|
function createFunctionCallCall(target, thisArg, argumentsList) {
|
|
return createMethodCall(target, "call", [thisArg, ...argumentsList]);
|
|
}
|
|
function createFunctionApplyCall(target, thisArg, argumentsExpression) {
|
|
return createMethodCall(target, "apply", [thisArg, argumentsExpression]);
|
|
}
|
|
function createGlobalMethodCall(globalObjectName, methodName, argumentsList) {
|
|
return createMethodCall(createIdentifier3(globalObjectName), methodName, argumentsList);
|
|
}
|
|
function createArraySliceCall(array, start2) {
|
|
return createMethodCall(array, "slice", start2 === void 0 ? [] : [asExpression(start2)]);
|
|
}
|
|
function createArrayConcatCall(array, argumentsList) {
|
|
return createMethodCall(array, "concat", argumentsList);
|
|
}
|
|
function createObjectDefinePropertyCall(target, propertyName, attributes) {
|
|
return createGlobalMethodCall("Object", "defineProperty", [target, asExpression(propertyName), attributes]);
|
|
}
|
|
function createReflectGetCall(target, propertyKey, receiver) {
|
|
return createGlobalMethodCall("Reflect", "get", receiver ? [target, propertyKey, receiver] : [target, propertyKey]);
|
|
}
|
|
function createReflectSetCall(target, propertyKey, value, receiver) {
|
|
return createGlobalMethodCall("Reflect", "set", receiver ? [target, propertyKey, value, receiver] : [target, propertyKey, value]);
|
|
}
|
|
function tryAddPropertyAssignment(properties, propertyName, expression) {
|
|
if (expression) {
|
|
properties.push(createPropertyAssignment2(propertyName, expression));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function createPropertyDescriptor(attributes, singleLine) {
|
|
const properties = [];
|
|
tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable));
|
|
tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable));
|
|
let isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable));
|
|
isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData;
|
|
let isAccessor2 = tryAddPropertyAssignment(properties, "get", attributes.get);
|
|
isAccessor2 = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor2;
|
|
Debug.assert(!(isData && isAccessor2), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor.");
|
|
return createObjectLiteralExpression(properties, !singleLine);
|
|
}
|
|
function updateOuterExpression(outerExpression, expression) {
|
|
switch (outerExpression.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return updateParenthesizedExpression(outerExpression, expression);
|
|
case 213 /* TypeAssertionExpression */:
|
|
return updateTypeAssertion2(outerExpression, outerExpression.type, expression);
|
|
case 231 /* AsExpression */:
|
|
return updateAsExpression2(outerExpression, expression, outerExpression.type);
|
|
case 235 /* SatisfiesExpression */:
|
|
return updateSatisfiesExpression(outerExpression, expression, outerExpression.type);
|
|
case 232 /* NonNullExpression */:
|
|
return updateNonNullExpression2(outerExpression, expression);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return updatePartiallyEmittedExpression2(outerExpression, expression);
|
|
}
|
|
}
|
|
function isIgnorableParen(node) {
|
|
return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
|
|
}
|
|
function restoreOuterExpressions(outerExpression, innerExpression, kinds = 15 /* All */) {
|
|
if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
|
|
return updateOuterExpression(
|
|
outerExpression,
|
|
restoreOuterExpressions(outerExpression.expression, innerExpression)
|
|
);
|
|
}
|
|
return innerExpression;
|
|
}
|
|
function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) {
|
|
if (!outermostLabeledStatement) {
|
|
return node;
|
|
}
|
|
const updated = updateLabeledStatement(
|
|
outermostLabeledStatement,
|
|
outermostLabeledStatement.label,
|
|
isLabeledStatement(outermostLabeledStatement.statement) ? restoreEnclosingLabel(node, outermostLabeledStatement.statement) : node
|
|
);
|
|
if (afterRestoreLabelCallback) {
|
|
afterRestoreLabelCallback(outermostLabeledStatement);
|
|
}
|
|
return updated;
|
|
}
|
|
function shouldBeCapturedInTempVariable(node, cacheIdentifiers) {
|
|
const target = skipParentheses(node);
|
|
switch (target.kind) {
|
|
case 79 /* Identifier */:
|
|
return cacheIdentifiers;
|
|
case 108 /* ThisKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return false;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
const elements = target.elements;
|
|
if (elements.length === 0) {
|
|
return false;
|
|
}
|
|
return true;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return target.properties.length > 0;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
|
|
const callee = skipOuterExpressions(expression, 15 /* All */);
|
|
let thisArg;
|
|
let target;
|
|
if (isSuperProperty(callee)) {
|
|
thisArg = createThis2();
|
|
target = callee;
|
|
} else if (isSuperKeyword(callee)) {
|
|
thisArg = createThis2();
|
|
target = languageVersion !== void 0 && languageVersion < 2 /* ES2015 */ ? setTextRange(createIdentifier3("_super"), callee) : callee;
|
|
} else if (getEmitFlags(callee) & 8192 /* HelperName */) {
|
|
thisArg = createVoidZero2();
|
|
target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee, false);
|
|
} else if (isPropertyAccessExpression(callee)) {
|
|
if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
|
|
thisArg = createTempVariable3(recordTempVariable);
|
|
target = createPropertyAccessExpression(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
thisArg,
|
|
callee.expression
|
|
),
|
|
callee.expression
|
|
),
|
|
callee.name
|
|
);
|
|
setTextRange(target, callee);
|
|
} else {
|
|
thisArg = callee.expression;
|
|
target = callee;
|
|
}
|
|
} else if (isElementAccessExpression(callee)) {
|
|
if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) {
|
|
thisArg = createTempVariable3(recordTempVariable);
|
|
target = createElementAccessExpression(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
thisArg,
|
|
callee.expression
|
|
),
|
|
callee.expression
|
|
),
|
|
callee.argumentExpression
|
|
);
|
|
setTextRange(target, callee);
|
|
} else {
|
|
thisArg = callee.expression;
|
|
target = callee;
|
|
}
|
|
} else {
|
|
thisArg = createVoidZero2();
|
|
target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, false);
|
|
}
|
|
return { target, thisArg };
|
|
}
|
|
function createAssignmentTargetWrapper(paramName, expression) {
|
|
return createPropertyAccessExpression(
|
|
createParenthesizedExpression(
|
|
createObjectLiteralExpression([
|
|
createSetAccessorDeclaration(
|
|
void 0,
|
|
"value",
|
|
[createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
paramName,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)],
|
|
createBlock2([
|
|
createExpressionStatement2(expression)
|
|
])
|
|
)
|
|
])
|
|
),
|
|
"value"
|
|
);
|
|
}
|
|
function inlineExpressions(expressions) {
|
|
return expressions.length > 10 ? createCommaListExpression(expressions) : reduceLeft(expressions, factory2.createComma);
|
|
}
|
|
function getName(node, allowComments, allowSourceMaps, emitFlags = 0) {
|
|
const nodeName = getNameOfDeclaration(node);
|
|
if (nodeName && isIdentifier(nodeName) && !isGeneratedIdentifier(nodeName)) {
|
|
const name = setParent(setTextRange(cloneNode(nodeName), nodeName), nodeName.parent);
|
|
emitFlags |= getEmitFlags(nodeName);
|
|
if (!allowSourceMaps)
|
|
emitFlags |= 96 /* NoSourceMap */;
|
|
if (!allowComments)
|
|
emitFlags |= 3072 /* NoComments */;
|
|
if (emitFlags)
|
|
setEmitFlags(name, emitFlags);
|
|
return name;
|
|
}
|
|
return getGeneratedNameForNode3(node);
|
|
}
|
|
function getInternalName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 32768 /* LocalName */ | 65536 /* InternalName */);
|
|
}
|
|
function getLocalName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 32768 /* LocalName */);
|
|
}
|
|
function getExportName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps, 16384 /* ExportName */);
|
|
}
|
|
function getDeclarationName(node, allowComments, allowSourceMaps) {
|
|
return getName(node, allowComments, allowSourceMaps);
|
|
}
|
|
function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) {
|
|
const qualifiedName = createPropertyAccessExpression(ns, nodeIsSynthesized(name) ? name : cloneNode(name));
|
|
setTextRange(qualifiedName, name);
|
|
let emitFlags = 0;
|
|
if (!allowSourceMaps)
|
|
emitFlags |= 96 /* NoSourceMap */;
|
|
if (!allowComments)
|
|
emitFlags |= 3072 /* NoComments */;
|
|
if (emitFlags)
|
|
setEmitFlags(qualifiedName, emitFlags);
|
|
return qualifiedName;
|
|
}
|
|
function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) {
|
|
if (ns && hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps);
|
|
}
|
|
return getExportName(node, allowComments, allowSourceMaps);
|
|
}
|
|
function copyPrologue(source, target, ensureUseStrict2, visitor) {
|
|
const offset = copyStandardPrologue(source, target, 0, ensureUseStrict2);
|
|
return copyCustomPrologue(source, target, offset, visitor);
|
|
}
|
|
function isUseStrictPrologue2(node) {
|
|
return isStringLiteral(node.expression) && node.expression.text === "use strict";
|
|
}
|
|
function createUseStrictPrologue() {
|
|
return startOnNewLine(createExpressionStatement2(createStringLiteral2("use strict")));
|
|
}
|
|
function copyStandardPrologue(source, target, statementOffset = 0, ensureUseStrict2) {
|
|
Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array");
|
|
let foundUseStrict = false;
|
|
const numStatements = source.length;
|
|
while (statementOffset < numStatements) {
|
|
const statement = source[statementOffset];
|
|
if (isPrologueDirective(statement)) {
|
|
if (isUseStrictPrologue2(statement)) {
|
|
foundUseStrict = true;
|
|
}
|
|
target.push(statement);
|
|
} else {
|
|
break;
|
|
}
|
|
statementOffset++;
|
|
}
|
|
if (ensureUseStrict2 && !foundUseStrict) {
|
|
target.push(createUseStrictPrologue());
|
|
}
|
|
return statementOffset;
|
|
}
|
|
function copyCustomPrologue(source, target, statementOffset, visitor, filter2 = returnTrue) {
|
|
const numStatements = source.length;
|
|
while (statementOffset !== void 0 && statementOffset < numStatements) {
|
|
const statement = source[statementOffset];
|
|
if (getEmitFlags(statement) & 2097152 /* CustomPrologue */ && filter2(statement)) {
|
|
append(target, visitor ? visitNode(statement, visitor, isStatement) : statement);
|
|
} else {
|
|
break;
|
|
}
|
|
statementOffset++;
|
|
}
|
|
return statementOffset;
|
|
}
|
|
function ensureUseStrict(statements) {
|
|
const foundUseStrict = findUseStrictPrologue(statements);
|
|
if (!foundUseStrict) {
|
|
return setTextRange(createNodeArray2([createUseStrictPrologue(), ...statements]), statements);
|
|
}
|
|
return statements;
|
|
}
|
|
function liftToBlock(nodes) {
|
|
Debug.assert(every(nodes, isStatementOrBlock), "Cannot lift nodes to a Block.");
|
|
return singleOrUndefined(nodes) || createBlock2(nodes);
|
|
}
|
|
function findSpanEnd(array, test, start2) {
|
|
let i = start2;
|
|
while (i < array.length && test(array[i])) {
|
|
i++;
|
|
}
|
|
return i;
|
|
}
|
|
function mergeLexicalEnvironment(statements, declarations) {
|
|
if (!some(declarations)) {
|
|
return statements;
|
|
}
|
|
const leftStandardPrologueEnd = findSpanEnd(statements, isPrologueDirective, 0);
|
|
const leftHoistedFunctionsEnd = findSpanEnd(statements, isHoistedFunction, leftStandardPrologueEnd);
|
|
const leftHoistedVariablesEnd = findSpanEnd(statements, isHoistedVariableStatement, leftHoistedFunctionsEnd);
|
|
const rightStandardPrologueEnd = findSpanEnd(declarations, isPrologueDirective, 0);
|
|
const rightHoistedFunctionsEnd = findSpanEnd(declarations, isHoistedFunction, rightStandardPrologueEnd);
|
|
const rightHoistedVariablesEnd = findSpanEnd(declarations, isHoistedVariableStatement, rightHoistedFunctionsEnd);
|
|
const rightCustomPrologueEnd = findSpanEnd(declarations, isCustomPrologue, rightHoistedVariablesEnd);
|
|
Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues");
|
|
const left = isNodeArray(statements) ? statements.slice() : statements;
|
|
if (rightCustomPrologueEnd > rightHoistedVariablesEnd) {
|
|
left.splice(leftHoistedVariablesEnd, 0, ...declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd));
|
|
}
|
|
if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) {
|
|
left.splice(leftHoistedFunctionsEnd, 0, ...declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd));
|
|
}
|
|
if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) {
|
|
left.splice(leftStandardPrologueEnd, 0, ...declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd));
|
|
}
|
|
if (rightStandardPrologueEnd > 0) {
|
|
if (leftStandardPrologueEnd === 0) {
|
|
left.splice(0, 0, ...declarations.slice(0, rightStandardPrologueEnd));
|
|
} else {
|
|
const leftPrologues = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < leftStandardPrologueEnd; i++) {
|
|
const leftPrologue = statements[i];
|
|
leftPrologues.set(leftPrologue.expression.text, true);
|
|
}
|
|
for (let i = rightStandardPrologueEnd - 1; i >= 0; i--) {
|
|
const rightPrologue = declarations[i];
|
|
if (!leftPrologues.has(rightPrologue.expression.text)) {
|
|
left.unshift(rightPrologue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isNodeArray(statements)) {
|
|
return setTextRange(createNodeArray2(left, statements.hasTrailingComma), statements);
|
|
}
|
|
return statements;
|
|
}
|
|
function updateModifiers(node, modifiers) {
|
|
var _a2;
|
|
let modifierArray;
|
|
if (typeof modifiers === "number") {
|
|
modifierArray = createModifiersFromModifierFlags2(modifiers);
|
|
} else {
|
|
modifierArray = modifiers;
|
|
}
|
|
return isTypeParameterDeclaration(node) ? updateTypeParameterDeclaration2(node, modifierArray, node.name, node.constraint, node.default) : isParameter(node) ? updateParameterDeclaration(node, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) : isConstructorTypeNode(node) ? updateConstructorTypeNode1(node, modifierArray, node.typeParameters, node.parameters, node.type) : isPropertySignature(node) ? updatePropertySignature3(node, modifierArray, node.name, node.questionToken, node.type) : isPropertyDeclaration(node) ? updatePropertyDeclaration2(node, modifierArray, node.name, (_a2 = node.questionToken) != null ? _a2 : node.exclamationToken, node.type, node.initializer) : isMethodSignature(node) ? updateMethodSignature3(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) : isMethodDeclaration(node) ? updateMethodDeclaration(node, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) : isConstructorDeclaration(node) ? updateConstructorDeclaration(node, modifierArray, node.parameters, node.body) : isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.type, node.body) : isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.body) : isIndexSignatureDeclaration(node) ? updateIndexSignature2(node, modifierArray, node.parameters, node.type) : isFunctionExpression(node) ? updateFunctionExpression2(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isArrowFunction(node) ? updateArrowFunction3(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) : isClassExpression(node) ? updateClassExpression3(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isVariableStatement(node) ? updateVariableStatement2(node, modifierArray, node.declarationList) : isFunctionDeclaration(node) ? updateFunctionDeclaration2(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : isClassDeclaration(node) ? updateClassDeclaration2(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isInterfaceDeclaration(node) ? updateInterfaceDeclaration2(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration2(node, modifierArray, node.name, node.typeParameters, node.type) : isEnumDeclaration(node) ? updateEnumDeclaration2(node, modifierArray, node.name, node.members) : isModuleDeclaration(node) ? updateModuleDeclaration2(node, modifierArray, node.name, node.body) : isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration2(node, modifierArray, node.isTypeOnly, node.name, node.moduleReference) : isImportDeclaration(node) ? updateImportDeclaration2(node, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause) : isExportAssignment(node) ? updateExportAssignment2(node, modifierArray, node.expression) : isExportDeclaration(node) ? updateExportDeclaration3(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) : Debug.assertNever(node);
|
|
}
|
|
function asNodeArray(array) {
|
|
return array ? createNodeArray2(array) : void 0;
|
|
}
|
|
function asName(name) {
|
|
return typeof name === "string" ? createIdentifier3(name) : name;
|
|
}
|
|
function asExpression(value) {
|
|
return typeof value === "string" ? createStringLiteral2(value) : typeof value === "number" ? createNumericLiteral2(value) : typeof value === "boolean" ? value ? createTrue2() : createFalse2() : value;
|
|
}
|
|
function asToken(value) {
|
|
return typeof value === "number" ? createToken3(value) : value;
|
|
}
|
|
function asEmbeddedStatement(statement) {
|
|
return statement && isNotEmittedStatement(statement) ? setTextRange(setOriginalNode(createEmptyStatement2(), statement), statement) : statement;
|
|
}
|
|
}
|
|
function updateWithoutOriginal(updated, original) {
|
|
if (updated !== original) {
|
|
setTextRange(updated, original);
|
|
}
|
|
return updated;
|
|
}
|
|
function updateWithOriginal(updated, original) {
|
|
if (updated !== original) {
|
|
setOriginalNode(updated, original);
|
|
setTextRange(updated, original);
|
|
}
|
|
return updated;
|
|
}
|
|
function getDefaultTagNameForKind(kind) {
|
|
switch (kind) {
|
|
case 346 /* JSDocTypeTag */:
|
|
return "type";
|
|
case 344 /* JSDocReturnTag */:
|
|
return "returns";
|
|
case 345 /* JSDocThisTag */:
|
|
return "this";
|
|
case 342 /* JSDocEnumTag */:
|
|
return "enum";
|
|
case 333 /* JSDocAuthorTag */:
|
|
return "author";
|
|
case 335 /* JSDocClassTag */:
|
|
return "class";
|
|
case 336 /* JSDocPublicTag */:
|
|
return "public";
|
|
case 337 /* JSDocPrivateTag */:
|
|
return "private";
|
|
case 338 /* JSDocProtectedTag */:
|
|
return "protected";
|
|
case 339 /* JSDocReadonlyTag */:
|
|
return "readonly";
|
|
case 340 /* JSDocOverrideTag */:
|
|
return "override";
|
|
case 347 /* JSDocTemplateTag */:
|
|
return "template";
|
|
case 348 /* JSDocTypedefTag */:
|
|
return "typedef";
|
|
case 343 /* JSDocParameterTag */:
|
|
return "param";
|
|
case 350 /* JSDocPropertyTag */:
|
|
return "prop";
|
|
case 341 /* JSDocCallbackTag */:
|
|
return "callback";
|
|
case 331 /* JSDocAugmentsTag */:
|
|
return "augments";
|
|
case 332 /* JSDocImplementsTag */:
|
|
return "implements";
|
|
default:
|
|
return Debug.fail(`Unsupported kind: ${Debug.formatSyntaxKind(kind)}`);
|
|
}
|
|
}
|
|
var rawTextScanner;
|
|
var invalidValueSentinel = {};
|
|
function getCookedText(kind, rawText) {
|
|
if (!rawTextScanner) {
|
|
rawTextScanner = createScanner(99 /* Latest */, false, 0 /* Standard */);
|
|
}
|
|
switch (kind) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
rawTextScanner.setText("`" + rawText + "`");
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
rawTextScanner.setText("`" + rawText + "${");
|
|
break;
|
|
case 16 /* TemplateMiddle */:
|
|
rawTextScanner.setText("}" + rawText + "${");
|
|
break;
|
|
case 17 /* TemplateTail */:
|
|
rawTextScanner.setText("}" + rawText + "`");
|
|
break;
|
|
}
|
|
let token = rawTextScanner.scan();
|
|
if (token === 19 /* CloseBraceToken */) {
|
|
token = rawTextScanner.reScanTemplateToken(false);
|
|
}
|
|
if (rawTextScanner.isUnterminated()) {
|
|
rawTextScanner.setText(void 0);
|
|
return invalidValueSentinel;
|
|
}
|
|
let tokenValue;
|
|
switch (token) {
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
tokenValue = rawTextScanner.getTokenValue();
|
|
break;
|
|
}
|
|
if (tokenValue === void 0 || rawTextScanner.scan() !== 1 /* EndOfFileToken */) {
|
|
rawTextScanner.setText(void 0);
|
|
return invalidValueSentinel;
|
|
}
|
|
rawTextScanner.setText(void 0);
|
|
return tokenValue;
|
|
}
|
|
function propagateIdentifierNameFlags(node) {
|
|
return propagateChildFlags(node) & ~67108864 /* ContainsPossibleTopLevelAwait */;
|
|
}
|
|
function propagatePropertyNameFlagsOfChild(node, transformFlags) {
|
|
return transformFlags | node.transformFlags & 134234112 /* PropertyNamePropagatingFlags */;
|
|
}
|
|
function propagateChildFlags(child) {
|
|
if (!child)
|
|
return 0 /* None */;
|
|
const childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind);
|
|
return isNamedDeclaration(child) && isPropertyName(child.name) ? propagatePropertyNameFlagsOfChild(child.name, childFlags) : childFlags;
|
|
}
|
|
function propagateChildrenFlags(children) {
|
|
return children ? children.transformFlags : 0 /* None */;
|
|
}
|
|
function aggregateChildrenFlags(children) {
|
|
let subtreeFlags = 0 /* None */;
|
|
for (const child of children) {
|
|
subtreeFlags |= propagateChildFlags(child);
|
|
}
|
|
children.transformFlags = subtreeFlags;
|
|
}
|
|
function getTransformFlagsSubtreeExclusions(kind) {
|
|
if (kind >= 179 /* FirstTypeNode */ && kind <= 202 /* LastTypeNode */) {
|
|
return -2 /* TypeExcludes */;
|
|
}
|
|
switch (kind) {
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return -2147450880 /* ArrayLiteralOrCallOrNewExcludes */;
|
|
case 264 /* ModuleDeclaration */:
|
|
return -1941676032 /* ModuleExcludes */;
|
|
case 166 /* Parameter */:
|
|
return -2147483648 /* ParameterExcludes */;
|
|
case 216 /* ArrowFunction */:
|
|
return -2072174592 /* ArrowFunctionExcludes */;
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return -1937940480 /* FunctionExcludes */;
|
|
case 258 /* VariableDeclarationList */:
|
|
return -2146893824 /* VariableDeclarationListExcludes */;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return -2147344384 /* ClassExcludes */;
|
|
case 173 /* Constructor */:
|
|
return -1937948672 /* ConstructorExcludes */;
|
|
case 169 /* PropertyDeclaration */:
|
|
return -2013249536 /* PropertyExcludes */;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return -2005057536 /* MethodOrAccessorExcludes */;
|
|
case 131 /* AnyKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 165 /* TypeParameter */:
|
|
case 168 /* PropertySignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return -2 /* TypeExcludes */;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return -2147278848 /* ObjectLiteralExcludes */;
|
|
case 295 /* CatchClause */:
|
|
return -2147418112 /* CatchClauseExcludes */;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
return -2147450880 /* BindingPatternExcludes */;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 106 /* SuperKeyword */:
|
|
return -2147483648 /* OuterExpressionExcludes */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return -2147483648 /* PropertyAccessExcludes */;
|
|
default:
|
|
return -2147483648 /* NodeExcludes */;
|
|
}
|
|
}
|
|
var baseFactory = createBaseNodeFactory();
|
|
function makeSynthetic(node) {
|
|
node.flags |= 8 /* Synthesized */;
|
|
return node;
|
|
}
|
|
var syntheticFactory = {
|
|
createBaseSourceFileNode: (kind) => makeSynthetic(baseFactory.createBaseSourceFileNode(kind)),
|
|
createBaseIdentifierNode: (kind) => makeSynthetic(baseFactory.createBaseIdentifierNode(kind)),
|
|
createBasePrivateIdentifierNode: (kind) => makeSynthetic(baseFactory.createBasePrivateIdentifierNode(kind)),
|
|
createBaseTokenNode: (kind) => makeSynthetic(baseFactory.createBaseTokenNode(kind)),
|
|
createBaseNode: (kind) => makeSynthetic(baseFactory.createBaseNode(kind))
|
|
};
|
|
var factory = createNodeFactory(4 /* NoIndentationOnFreshPropertyAccess */, syntheticFactory);
|
|
function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) {
|
|
let stripInternal;
|
|
let bundleFileInfo;
|
|
let fileName;
|
|
let text;
|
|
let length2;
|
|
let sourceMapPath;
|
|
let sourceMapText;
|
|
let getText;
|
|
let getSourceMapText;
|
|
let oldFileOfCurrentEmit;
|
|
if (!isString(textOrInputFiles)) {
|
|
Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts");
|
|
fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || "";
|
|
sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath;
|
|
getText = () => mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText;
|
|
getSourceMapText = () => mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText;
|
|
length2 = () => getText().length;
|
|
if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) {
|
|
Debug.assert(mapTextOrStripInternal === void 0 || typeof mapTextOrStripInternal === "boolean");
|
|
stripInternal = mapTextOrStripInternal;
|
|
bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts;
|
|
oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit;
|
|
}
|
|
} else {
|
|
fileName = "";
|
|
text = textOrInputFiles;
|
|
length2 = textOrInputFiles.length;
|
|
sourceMapPath = mapPathOrType;
|
|
sourceMapText = mapTextOrStripInternal;
|
|
}
|
|
const node = oldFileOfCurrentEmit ? parseOldFileOfCurrentEmit(Debug.checkDefined(bundleFileInfo)) : parseUnparsedSourceFile(bundleFileInfo, stripInternal, length2);
|
|
node.fileName = fileName;
|
|
node.sourceMapPath = sourceMapPath;
|
|
node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
|
|
if (getText && getSourceMapText) {
|
|
Object.defineProperty(node, "text", { get: getText });
|
|
Object.defineProperty(node, "sourceMapText", { get: getSourceMapText });
|
|
} else {
|
|
Debug.assert(!oldFileOfCurrentEmit);
|
|
node.text = text != null ? text : "";
|
|
node.sourceMapText = sourceMapText;
|
|
}
|
|
return node;
|
|
}
|
|
function parseUnparsedSourceFile(bundleFileInfo, stripInternal, length2) {
|
|
let prologues;
|
|
let helpers;
|
|
let referencedFiles;
|
|
let typeReferenceDirectives;
|
|
let libReferenceDirectives;
|
|
let prependChildren;
|
|
let texts;
|
|
let hasNoDefaultLib;
|
|
for (const section of bundleFileInfo ? bundleFileInfo.sections : emptyArray) {
|
|
switch (section.kind) {
|
|
case "prologue" /* Prologue */:
|
|
prologues = append(prologues, setTextRange(factory.createUnparsedPrologue(section.data), section));
|
|
break;
|
|
case "emitHelpers" /* EmitHelpers */:
|
|
helpers = append(helpers, getAllUnscopedEmitHelpers().get(section.data));
|
|
break;
|
|
case "no-default-lib" /* NoDefaultLib */:
|
|
hasNoDefaultLib = true;
|
|
break;
|
|
case "reference" /* Reference */:
|
|
referencedFiles = append(referencedFiles, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "type" /* Type */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "type-import" /* TypeResolutionModeImport */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: 99 /* ESNext */ });
|
|
break;
|
|
case "type-require" /* TypeResolutionModeRequire */:
|
|
typeReferenceDirectives = append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: 1 /* CommonJS */ });
|
|
break;
|
|
case "lib" /* Lib */:
|
|
libReferenceDirectives = append(libReferenceDirectives, { pos: -1, end: -1, fileName: section.data });
|
|
break;
|
|
case "prepend" /* Prepend */:
|
|
let prependTexts;
|
|
for (const text of section.texts) {
|
|
if (!stripInternal || text.kind !== "internal" /* Internal */) {
|
|
prependTexts = append(prependTexts, setTextRange(factory.createUnparsedTextLike(text.data, text.kind === "internal" /* Internal */), text));
|
|
}
|
|
}
|
|
prependChildren = addRange(prependChildren, prependTexts);
|
|
texts = append(texts, factory.createUnparsedPrepend(section.data, prependTexts != null ? prependTexts : emptyArray));
|
|
break;
|
|
case "internal" /* Internal */:
|
|
if (stripInternal) {
|
|
if (!texts)
|
|
texts = [];
|
|
break;
|
|
}
|
|
case "text" /* Text */:
|
|
texts = append(texts, setTextRange(factory.createUnparsedTextLike(section.data, section.kind === "internal" /* Internal */), section));
|
|
break;
|
|
default:
|
|
Debug.assertNever(section);
|
|
}
|
|
}
|
|
if (!texts) {
|
|
const textNode = factory.createUnparsedTextLike(void 0, false);
|
|
setTextRangePosWidth(textNode, 0, typeof length2 === "function" ? length2() : length2);
|
|
texts = [textNode];
|
|
}
|
|
const node = parseNodeFactory.createUnparsedSource(prologues != null ? prologues : emptyArray, void 0, texts);
|
|
setEachParent(prologues, node);
|
|
setEachParent(texts, node);
|
|
setEachParent(prependChildren, node);
|
|
node.hasNoDefaultLib = hasNoDefaultLib;
|
|
node.helpers = helpers;
|
|
node.referencedFiles = referencedFiles || emptyArray;
|
|
node.typeReferenceDirectives = typeReferenceDirectives;
|
|
node.libReferenceDirectives = libReferenceDirectives || emptyArray;
|
|
return node;
|
|
}
|
|
function parseOldFileOfCurrentEmit(bundleFileInfo) {
|
|
let texts;
|
|
let syntheticReferences;
|
|
for (const section of bundleFileInfo.sections) {
|
|
switch (section.kind) {
|
|
case "internal" /* Internal */:
|
|
case "text" /* Text */:
|
|
texts = append(texts, setTextRange(factory.createUnparsedTextLike(section.data, section.kind === "internal" /* Internal */), section));
|
|
break;
|
|
case "no-default-lib" /* NoDefaultLib */:
|
|
case "reference" /* Reference */:
|
|
case "type" /* Type */:
|
|
case "type-import" /* TypeResolutionModeImport */:
|
|
case "type-require" /* TypeResolutionModeRequire */:
|
|
case "lib" /* Lib */:
|
|
syntheticReferences = append(syntheticReferences, setTextRange(factory.createUnparsedSyntheticReference(section), section));
|
|
break;
|
|
case "prologue" /* Prologue */:
|
|
case "emitHelpers" /* EmitHelpers */:
|
|
case "prepend" /* Prepend */:
|
|
break;
|
|
default:
|
|
Debug.assertNever(section);
|
|
}
|
|
}
|
|
const node = factory.createUnparsedSource(emptyArray, syntheticReferences, texts != null ? texts : emptyArray);
|
|
setEachParent(syntheticReferences, node);
|
|
setEachParent(texts, node);
|
|
node.helpers = map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, (name) => getAllUnscopedEmitHelpers().get(name));
|
|
return node;
|
|
}
|
|
function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath) {
|
|
return !isString(javascriptTextOrReadFileText) ? createInputFilesWithFilePaths(
|
|
javascriptTextOrReadFileText,
|
|
declarationTextOrJavascriptPath,
|
|
javascriptMapPath,
|
|
javascriptMapTextOrDeclarationPath,
|
|
declarationMapPath,
|
|
declarationMapTextOrBuildInfoPath
|
|
) : createInputFilesWithFileTexts(
|
|
void 0,
|
|
javascriptTextOrReadFileText,
|
|
javascriptMapPath,
|
|
javascriptMapTextOrDeclarationPath,
|
|
void 0,
|
|
declarationTextOrJavascriptPath,
|
|
declarationMapPath,
|
|
declarationMapTextOrBuildInfoPath
|
|
);
|
|
}
|
|
function createInputFilesWithFilePaths(readFileText, javascriptPath, javascriptMapPath, declarationPath, declarationMapPath, buildInfoPath, host, options) {
|
|
const node = parseNodeFactory.createInputFiles();
|
|
node.javascriptPath = javascriptPath;
|
|
node.javascriptMapPath = javascriptMapPath;
|
|
node.declarationPath = declarationPath;
|
|
node.declarationMapPath = declarationMapPath;
|
|
node.buildInfoPath = buildInfoPath;
|
|
const cache = /* @__PURE__ */ new Map();
|
|
const textGetter = (path) => {
|
|
if (path === void 0)
|
|
return void 0;
|
|
let value = cache.get(path);
|
|
if (value === void 0) {
|
|
value = readFileText(path);
|
|
cache.set(path, value !== void 0 ? value : false);
|
|
}
|
|
return value !== false ? value : void 0;
|
|
};
|
|
const definedTextGetter = (path) => {
|
|
const result = textGetter(path);
|
|
return result !== void 0 ? result : `/* Input file ${path} was missing */\r
|
|
`;
|
|
};
|
|
let buildInfo;
|
|
const getAndCacheBuildInfo = () => {
|
|
var _a2, _b;
|
|
if (buildInfo === void 0 && buildInfoPath) {
|
|
if (host == null ? void 0 : host.getBuildInfo) {
|
|
buildInfo = (_a2 = host.getBuildInfo(buildInfoPath, options.configFilePath)) != null ? _a2 : false;
|
|
} else {
|
|
const result = textGetter(buildInfoPath);
|
|
buildInfo = result !== void 0 ? (_b = getBuildInfo(buildInfoPath, result)) != null ? _b : false : false;
|
|
}
|
|
}
|
|
return buildInfo || void 0;
|
|
};
|
|
Object.defineProperties(node, {
|
|
javascriptText: { get: () => definedTextGetter(javascriptPath) },
|
|
javascriptMapText: { get: () => textGetter(javascriptMapPath) },
|
|
declarationText: { get: () => definedTextGetter(Debug.checkDefined(declarationPath)) },
|
|
declarationMapText: { get: () => textGetter(declarationMapPath) },
|
|
buildInfo: { get: getAndCacheBuildInfo }
|
|
});
|
|
return node;
|
|
}
|
|
function createInputFilesWithFileTexts(javascriptPath, javascriptText, javascriptMapPath, javascriptMapText, declarationPath, declarationText, declarationMapPath, declarationMapText, buildInfoPath, buildInfo, oldFileOfCurrentEmit) {
|
|
const node = parseNodeFactory.createInputFiles();
|
|
node.javascriptPath = javascriptPath;
|
|
node.javascriptText = javascriptText;
|
|
node.javascriptMapPath = javascriptMapPath;
|
|
node.javascriptMapText = javascriptMapText;
|
|
node.declarationPath = declarationPath;
|
|
node.declarationText = declarationText;
|
|
node.declarationMapPath = declarationMapPath;
|
|
node.declarationMapText = declarationMapText;
|
|
node.buildInfoPath = buildInfoPath;
|
|
node.buildInfo = buildInfo;
|
|
node.oldFileOfCurrentEmit = oldFileOfCurrentEmit;
|
|
return node;
|
|
}
|
|
var SourceMapSource2;
|
|
function createSourceMapSource(fileName, text, skipTrivia2) {
|
|
return new (SourceMapSource2 || (SourceMapSource2 = objectAllocator.getSourceMapSourceConstructor()))(fileName, text, skipTrivia2);
|
|
}
|
|
function setOriginalNode(node, original) {
|
|
node.original = original;
|
|
if (original) {
|
|
const emitNode = original.emitNode;
|
|
if (emitNode)
|
|
node.emitNode = mergeEmitNode(emitNode, node.emitNode);
|
|
}
|
|
return node;
|
|
}
|
|
function mergeEmitNode(sourceEmitNode, destEmitNode) {
|
|
const {
|
|
flags,
|
|
leadingComments,
|
|
trailingComments,
|
|
commentRange,
|
|
sourceMapRange,
|
|
tokenSourceMapRanges,
|
|
constantValue,
|
|
helpers,
|
|
startsOnNewLine,
|
|
snippetElement
|
|
} = sourceEmitNode;
|
|
if (!destEmitNode)
|
|
destEmitNode = {};
|
|
if (leadingComments)
|
|
destEmitNode.leadingComments = addRange(leadingComments.slice(), destEmitNode.leadingComments);
|
|
if (trailingComments)
|
|
destEmitNode.trailingComments = addRange(trailingComments.slice(), destEmitNode.trailingComments);
|
|
if (flags)
|
|
destEmitNode.flags = flags & ~536870912 /* Immutable */;
|
|
if (commentRange)
|
|
destEmitNode.commentRange = commentRange;
|
|
if (sourceMapRange)
|
|
destEmitNode.sourceMapRange = sourceMapRange;
|
|
if (tokenSourceMapRanges)
|
|
destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges);
|
|
if (constantValue !== void 0)
|
|
destEmitNode.constantValue = constantValue;
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
destEmitNode.helpers = appendIfUnique(destEmitNode.helpers, helper);
|
|
}
|
|
}
|
|
if (startsOnNewLine !== void 0)
|
|
destEmitNode.startsOnNewLine = startsOnNewLine;
|
|
if (snippetElement !== void 0)
|
|
destEmitNode.snippetElement = snippetElement;
|
|
return destEmitNode;
|
|
}
|
|
function mergeTokenSourceMapRanges(sourceRanges, destRanges) {
|
|
if (!destRanges)
|
|
destRanges = [];
|
|
for (const key in sourceRanges) {
|
|
destRanges[key] = sourceRanges[key];
|
|
}
|
|
return destRanges;
|
|
}
|
|
|
|
// src/compiler/factory/emitNode.ts
|
|
function getOrCreateEmitNode(node) {
|
|
var _a2;
|
|
if (!node.emitNode) {
|
|
if (isParseTreeNode(node)) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return node.emitNode = { annotatedNodes: [node] };
|
|
}
|
|
const sourceFile = (_a2 = getSourceFileOfNode(getParseTreeNode(getSourceFileOfNode(node)))) != null ? _a2 : Debug.fail("Could not determine parsed source file.");
|
|
getOrCreateEmitNode(sourceFile).annotatedNodes.push(node);
|
|
}
|
|
node.emitNode = {};
|
|
} else {
|
|
Debug.assert(!(node.emitNode.flags & 536870912 /* Immutable */), "Invalid attempt to mutate an immutable node.");
|
|
}
|
|
return node.emitNode;
|
|
}
|
|
function disposeEmitNodes(sourceFile) {
|
|
var _a2, _b;
|
|
const annotatedNodes = (_b = (_a2 = getSourceFileOfNode(getParseTreeNode(sourceFile))) == null ? void 0 : _a2.emitNode) == null ? void 0 : _b.annotatedNodes;
|
|
if (annotatedNodes) {
|
|
for (const node of annotatedNodes) {
|
|
node.emitNode = void 0;
|
|
}
|
|
}
|
|
}
|
|
function removeAllComments(node) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.flags |= 3072 /* NoComments */;
|
|
emitNode.leadingComments = void 0;
|
|
emitNode.trailingComments = void 0;
|
|
return node;
|
|
}
|
|
function setEmitFlags(node, emitFlags) {
|
|
getOrCreateEmitNode(node).flags = emitFlags;
|
|
return node;
|
|
}
|
|
function addEmitFlags(node, emitFlags) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.flags = emitNode.flags | emitFlags;
|
|
return node;
|
|
}
|
|
function getSourceMapRange(node) {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.sourceMapRange) != null ? _b : node;
|
|
}
|
|
function setSourceMapRange(node, range) {
|
|
getOrCreateEmitNode(node).sourceMapRange = range;
|
|
return node;
|
|
}
|
|
function getTokenSourceMapRange(node, token) {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.tokenSourceMapRanges) == null ? void 0 : _b[token];
|
|
}
|
|
function setTokenSourceMapRange(node, token, range) {
|
|
var _a2;
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
const tokenSourceMapRanges = (_a2 = emitNode.tokenSourceMapRanges) != null ? _a2 : emitNode.tokenSourceMapRanges = [];
|
|
tokenSourceMapRanges[token] = range;
|
|
return node;
|
|
}
|
|
function getStartsOnNewLine(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.startsOnNewLine;
|
|
}
|
|
function setStartsOnNewLine(node, newLine) {
|
|
getOrCreateEmitNode(node).startsOnNewLine = newLine;
|
|
return node;
|
|
}
|
|
function getCommentRange(node) {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.commentRange) != null ? _b : node;
|
|
}
|
|
function setCommentRange(node, range) {
|
|
getOrCreateEmitNode(node).commentRange = range;
|
|
return node;
|
|
}
|
|
function getSyntheticLeadingComments(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.leadingComments;
|
|
}
|
|
function setSyntheticLeadingComments(node, comments) {
|
|
getOrCreateEmitNode(node).leadingComments = comments;
|
|
return node;
|
|
}
|
|
function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) {
|
|
return setSyntheticLeadingComments(node, append(getSyntheticLeadingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
|
|
}
|
|
function getSyntheticTrailingComments(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.trailingComments;
|
|
}
|
|
function setSyntheticTrailingComments(node, comments) {
|
|
getOrCreateEmitNode(node).trailingComments = comments;
|
|
return node;
|
|
}
|
|
function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) {
|
|
return setSyntheticTrailingComments(node, append(getSyntheticTrailingComments(node), { kind, pos: -1, end: -1, hasTrailingNewLine, text }));
|
|
}
|
|
function moveSyntheticComments(node, original) {
|
|
setSyntheticLeadingComments(node, getSyntheticLeadingComments(original));
|
|
setSyntheticTrailingComments(node, getSyntheticTrailingComments(original));
|
|
const emit = getOrCreateEmitNode(original);
|
|
emit.leadingComments = void 0;
|
|
emit.trailingComments = void 0;
|
|
return node;
|
|
}
|
|
function getConstantValue(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.constantValue;
|
|
}
|
|
function setConstantValue(node, value) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.constantValue = value;
|
|
return node;
|
|
}
|
|
function addEmitHelper(node, helper) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.helpers = append(emitNode.helpers, helper);
|
|
return node;
|
|
}
|
|
function addEmitHelpers(node, helpers) {
|
|
if (some(helpers)) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
for (const helper of helpers) {
|
|
emitNode.helpers = appendIfUnique(emitNode.helpers, helper);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function removeEmitHelper(node, helper) {
|
|
var _a2;
|
|
const helpers = (_a2 = node.emitNode) == null ? void 0 : _a2.helpers;
|
|
if (helpers) {
|
|
return orderedRemoveItem(helpers, helper);
|
|
}
|
|
return false;
|
|
}
|
|
function getEmitHelpers(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.helpers;
|
|
}
|
|
function moveEmitHelpers(source, target, predicate) {
|
|
const sourceEmitNode = source.emitNode;
|
|
const sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers;
|
|
if (!some(sourceEmitHelpers))
|
|
return;
|
|
const targetEmitNode = getOrCreateEmitNode(target);
|
|
let helpersRemoved = 0;
|
|
for (let i = 0; i < sourceEmitHelpers.length; i++) {
|
|
const helper = sourceEmitHelpers[i];
|
|
if (predicate(helper)) {
|
|
helpersRemoved++;
|
|
targetEmitNode.helpers = appendIfUnique(targetEmitNode.helpers, helper);
|
|
} else if (helpersRemoved > 0) {
|
|
sourceEmitHelpers[i - helpersRemoved] = helper;
|
|
}
|
|
}
|
|
if (helpersRemoved > 0) {
|
|
sourceEmitHelpers.length -= helpersRemoved;
|
|
}
|
|
}
|
|
function getSnippetElement(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.snippetElement;
|
|
}
|
|
function setSnippetElement(node, snippet) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.snippetElement = snippet;
|
|
return node;
|
|
}
|
|
function ignoreSourceNewlines(node) {
|
|
getOrCreateEmitNode(node).flags |= 268435456 /* IgnoreSourceNewlines */;
|
|
return node;
|
|
}
|
|
function setTypeNode(node, type) {
|
|
const emitNode = getOrCreateEmitNode(node);
|
|
emitNode.typeNode = type;
|
|
return node;
|
|
}
|
|
function getTypeNode(node) {
|
|
var _a2;
|
|
return (_a2 = node.emitNode) == null ? void 0 : _a2.typeNode;
|
|
}
|
|
|
|
// src/compiler/factory/emitHelpers.ts
|
|
function createEmitHelperFactory(context) {
|
|
const factory2 = context.factory;
|
|
const immutableTrue = memoize(() => setEmitFlags(factory2.createTrue(), 536870912 /* Immutable */));
|
|
const immutableFalse = memoize(() => setEmitFlags(factory2.createFalse(), 536870912 /* Immutable */));
|
|
return {
|
|
getUnscopedHelperName,
|
|
createDecorateHelper,
|
|
createMetadataHelper,
|
|
createParamHelper,
|
|
createAssignHelper,
|
|
createAwaitHelper,
|
|
createAsyncGeneratorHelper,
|
|
createAsyncDelegatorHelper,
|
|
createAsyncValuesHelper,
|
|
createRestHelper,
|
|
createAwaiterHelper,
|
|
createExtendsHelper,
|
|
createTemplateObjectHelper,
|
|
createSpreadArrayHelper,
|
|
createValuesHelper,
|
|
createReadHelper,
|
|
createGeneratorHelper,
|
|
createCreateBindingHelper,
|
|
createImportStarHelper,
|
|
createImportStarCallbackHelper,
|
|
createImportDefaultHelper,
|
|
createExportStarHelper,
|
|
createClassPrivateFieldGetHelper,
|
|
createClassPrivateFieldSetHelper,
|
|
createClassPrivateFieldInHelper
|
|
};
|
|
function getUnscopedHelperName(name) {
|
|
return setEmitFlags(factory2.createIdentifier(name), 8192 /* HelperName */ | 4 /* AdviseOnEmitNode */);
|
|
}
|
|
function createDecorateHelper(decoratorExpressions, target, memberName, descriptor) {
|
|
context.requestEmitHelper(decorateHelper);
|
|
const argumentsArray = [];
|
|
argumentsArray.push(factory2.createArrayLiteralExpression(decoratorExpressions, true));
|
|
argumentsArray.push(target);
|
|
if (memberName) {
|
|
argumentsArray.push(memberName);
|
|
if (descriptor) {
|
|
argumentsArray.push(descriptor);
|
|
}
|
|
}
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__decorate"),
|
|
void 0,
|
|
argumentsArray
|
|
);
|
|
}
|
|
function createMetadataHelper(metadataKey, metadataValue) {
|
|
context.requestEmitHelper(metadataHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__metadata"),
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(metadataKey),
|
|
metadataValue
|
|
]
|
|
);
|
|
}
|
|
function createParamHelper(expression, parameterOffset, location2) {
|
|
context.requestEmitHelper(paramHelper);
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
getUnscopedHelperName("__param"),
|
|
void 0,
|
|
[
|
|
factory2.createNumericLiteral(parameterOffset + ""),
|
|
expression
|
|
]
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createAssignHelper(attributesSegments) {
|
|
if (getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ES2015 */) {
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "assign"),
|
|
void 0,
|
|
attributesSegments
|
|
);
|
|
}
|
|
context.requestEmitHelper(assignHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__assign"),
|
|
void 0,
|
|
attributesSegments
|
|
);
|
|
}
|
|
function createAwaitHelper(expression) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
return factory2.createCallExpression(getUnscopedHelperName("__await"), void 0, [expression]);
|
|
}
|
|
function createAsyncGeneratorHelper(generatorFunc, hasLexicalThis) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
context.requestEmitHelper(asyncGeneratorHelper);
|
|
(generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 524288 /* AsyncFunctionBody */ | 1048576 /* ReuseTempVariableScope */;
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncGenerator"),
|
|
void 0,
|
|
[
|
|
hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
|
|
factory2.createIdentifier("arguments"),
|
|
generatorFunc
|
|
]
|
|
);
|
|
}
|
|
function createAsyncDelegatorHelper(expression) {
|
|
context.requestEmitHelper(awaitHelper);
|
|
context.requestEmitHelper(asyncDelegator);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncDelegator"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createAsyncValuesHelper(expression) {
|
|
context.requestEmitHelper(asyncValues);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__asyncValues"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createRestHelper(value, elements, computedTempVariables, location2) {
|
|
context.requestEmitHelper(restHelper);
|
|
const propertyNames = [];
|
|
let computedTempVariableOffset = 0;
|
|
for (let i = 0; i < elements.length - 1; i++) {
|
|
const propertyName = getPropertyNameOfBindingOrAssignmentElement(elements[i]);
|
|
if (propertyName) {
|
|
if (isComputedPropertyName(propertyName)) {
|
|
Debug.assertIsDefined(computedTempVariables, "Encountered computed property name but 'computedTempVariables' argument was not provided.");
|
|
const temp = computedTempVariables[computedTempVariableOffset];
|
|
computedTempVariableOffset++;
|
|
propertyNames.push(
|
|
factory2.createConditionalExpression(
|
|
factory2.createTypeCheck(temp, "symbol"),
|
|
void 0,
|
|
temp,
|
|
void 0,
|
|
factory2.createAdd(temp, factory2.createStringLiteral(""))
|
|
)
|
|
);
|
|
} else {
|
|
propertyNames.push(factory2.createStringLiteralFromNode(propertyName));
|
|
}
|
|
}
|
|
}
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__rest"),
|
|
void 0,
|
|
[
|
|
value,
|
|
setTextRange(
|
|
factory2.createArrayLiteralExpression(propertyNames),
|
|
location2
|
|
)
|
|
]
|
|
);
|
|
}
|
|
function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) {
|
|
context.requestEmitHelper(awaiterHelper);
|
|
const generatorFunc = factory2.createFunctionExpression(
|
|
void 0,
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
body
|
|
);
|
|
(generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 524288 /* AsyncFunctionBody */ | 1048576 /* ReuseTempVariableScope */;
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__awaiter"),
|
|
void 0,
|
|
[
|
|
hasLexicalThis ? factory2.createThis() : factory2.createVoidZero(),
|
|
hasLexicalArguments ? factory2.createIdentifier("arguments") : factory2.createVoidZero(),
|
|
promiseConstructor ? createExpressionFromEntityName(factory2, promiseConstructor) : factory2.createVoidZero(),
|
|
generatorFunc
|
|
]
|
|
);
|
|
}
|
|
function createExtendsHelper(name) {
|
|
context.requestEmitHelper(extendsHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__extends"),
|
|
void 0,
|
|
[name, factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */)]
|
|
);
|
|
}
|
|
function createTemplateObjectHelper(cooked, raw) {
|
|
context.requestEmitHelper(templateObjectHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__makeTemplateObject"),
|
|
void 0,
|
|
[cooked, raw]
|
|
);
|
|
}
|
|
function createSpreadArrayHelper(to, from, packFrom) {
|
|
context.requestEmitHelper(spreadArrayHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__spreadArray"),
|
|
void 0,
|
|
[to, from, packFrom ? immutableTrue() : immutableFalse()]
|
|
);
|
|
}
|
|
function createValuesHelper(expression) {
|
|
context.requestEmitHelper(valuesHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__values"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createReadHelper(iteratorRecord, count) {
|
|
context.requestEmitHelper(readHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__read"),
|
|
void 0,
|
|
count !== void 0 ? [iteratorRecord, factory2.createNumericLiteral(count + "")] : [iteratorRecord]
|
|
);
|
|
}
|
|
function createGeneratorHelper(body) {
|
|
context.requestEmitHelper(generatorHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__generator"),
|
|
void 0,
|
|
[factory2.createThis(), body]
|
|
);
|
|
}
|
|
function createCreateBindingHelper(module2, inputName, outputName) {
|
|
context.requestEmitHelper(createBindingHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__createBinding"),
|
|
void 0,
|
|
[factory2.createIdentifier("exports"), module2, inputName, ...outputName ? [outputName] : []]
|
|
);
|
|
}
|
|
function createImportStarHelper(expression) {
|
|
context.requestEmitHelper(importStarHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__importStar"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createImportStarCallbackHelper() {
|
|
context.requestEmitHelper(importStarHelper);
|
|
return getUnscopedHelperName("__importStar");
|
|
}
|
|
function createImportDefaultHelper(expression) {
|
|
context.requestEmitHelper(importDefaultHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__importDefault"),
|
|
void 0,
|
|
[expression]
|
|
);
|
|
}
|
|
function createExportStarHelper(moduleExpression, exportsExpression = factory2.createIdentifier("exports")) {
|
|
context.requestEmitHelper(exportStarHelper);
|
|
context.requestEmitHelper(createBindingHelper);
|
|
return factory2.createCallExpression(
|
|
getUnscopedHelperName("__exportStar"),
|
|
void 0,
|
|
[moduleExpression, exportsExpression]
|
|
);
|
|
}
|
|
function createClassPrivateFieldGetHelper(receiver, state, kind, f) {
|
|
context.requestEmitHelper(classPrivateFieldGetHelper);
|
|
let args;
|
|
if (!f) {
|
|
args = [receiver, state, factory2.createStringLiteral(kind)];
|
|
} else {
|
|
args = [receiver, state, factory2.createStringLiteral(kind), f];
|
|
}
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), void 0, args);
|
|
}
|
|
function createClassPrivateFieldSetHelper(receiver, state, value, kind, f) {
|
|
context.requestEmitHelper(classPrivateFieldSetHelper);
|
|
let args;
|
|
if (!f) {
|
|
args = [receiver, state, value, factory2.createStringLiteral(kind)];
|
|
} else {
|
|
args = [receiver, state, value, factory2.createStringLiteral(kind), f];
|
|
}
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), void 0, args);
|
|
}
|
|
function createClassPrivateFieldInHelper(state, receiver) {
|
|
context.requestEmitHelper(classPrivateFieldInHelper);
|
|
return factory2.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), void 0, [state, receiver]);
|
|
}
|
|
}
|
|
function compareEmitHelpers(x, y) {
|
|
if (x === y)
|
|
return 0 /* EqualTo */;
|
|
if (x.priority === y.priority)
|
|
return 0 /* EqualTo */;
|
|
if (x.priority === void 0)
|
|
return 1 /* GreaterThan */;
|
|
if (y.priority === void 0)
|
|
return -1 /* LessThan */;
|
|
return compareValues(x.priority, y.priority);
|
|
}
|
|
function helperString(input, ...args) {
|
|
return (uniqueName) => {
|
|
let result = "";
|
|
for (let i = 0; i < args.length; i++) {
|
|
result += input[i];
|
|
result += uniqueName(args[i]);
|
|
}
|
|
result += input[input.length - 1];
|
|
return result;
|
|
};
|
|
}
|
|
var decorateHelper = {
|
|
name: "typescript:decorate",
|
|
importName: "__decorate",
|
|
scoped: false,
|
|
priority: 2,
|
|
text: `
|
|
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
|
|
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
|
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
|
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
|
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
|
};`
|
|
};
|
|
var metadataHelper = {
|
|
name: "typescript:metadata",
|
|
importName: "__metadata",
|
|
scoped: false,
|
|
priority: 3,
|
|
text: `
|
|
var __metadata = (this && this.__metadata) || function (k, v) {
|
|
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
|
|
};`
|
|
};
|
|
var paramHelper = {
|
|
name: "typescript:param",
|
|
importName: "__param",
|
|
scoped: false,
|
|
priority: 4,
|
|
text: `
|
|
var __param = (this && this.__param) || function (paramIndex, decorator) {
|
|
return function (target, key) { decorator(target, key, paramIndex); }
|
|
};`
|
|
};
|
|
var assignHelper = {
|
|
name: "typescript:assign",
|
|
importName: "__assign",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
var __assign = (this && this.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};`
|
|
};
|
|
var awaitHelper = {
|
|
name: "typescript:await",
|
|
importName: "__await",
|
|
scoped: false,
|
|
text: `
|
|
var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }`
|
|
};
|
|
var asyncGeneratorHelper = {
|
|
name: "typescript:asyncGenerator",
|
|
importName: "__asyncGenerator",
|
|
scoped: false,
|
|
dependencies: [awaitHelper],
|
|
text: `
|
|
var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
|
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
|
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
|
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
|
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
|
function fulfill(value) { resume("next", value); }
|
|
function reject(value) { resume("throw", value); }
|
|
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
|
};`
|
|
};
|
|
var asyncDelegator = {
|
|
name: "typescript:asyncDelegator",
|
|
importName: "__asyncDelegator",
|
|
scoped: false,
|
|
dependencies: [awaitHelper],
|
|
text: `
|
|
var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
|
|
var i, p;
|
|
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
|
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
|
|
};`
|
|
};
|
|
var asyncValues = {
|
|
name: "typescript:asyncValues",
|
|
importName: "__asyncValues",
|
|
scoped: false,
|
|
text: `
|
|
var __asyncValues = (this && this.__asyncValues) || function (o) {
|
|
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
|
var m = o[Symbol.asyncIterator], i;
|
|
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
|
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
|
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
|
};`
|
|
};
|
|
var restHelper = {
|
|
name: "typescript:rest",
|
|
importName: "__rest",
|
|
scoped: false,
|
|
text: `
|
|
var __rest = (this && this.__rest) || function (s, e) {
|
|
var t = {};
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
|
t[p] = s[p];
|
|
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
|
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
|
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
|
t[p[i]] = s[p[i]];
|
|
}
|
|
return t;
|
|
};`
|
|
};
|
|
var awaiterHelper = {
|
|
name: "typescript:awaiter",
|
|
importName: "__awaiter",
|
|
scoped: false,
|
|
priority: 5,
|
|
text: `
|
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
|
return new (P || (P = Promise))(function (resolve, reject) {
|
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
|
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
|
});
|
|
};`
|
|
};
|
|
var extendsHelper = {
|
|
name: "typescript:extends",
|
|
importName: "__extends",
|
|
scoped: false,
|
|
priority: 0,
|
|
text: `
|
|
var __extends = (this && this.__extends) || (function () {
|
|
var extendStatics = function (d, b) {
|
|
extendStatics = Object.setPrototypeOf ||
|
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
|
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
|
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 __());
|
|
};
|
|
})();`
|
|
};
|
|
var templateObjectHelper = {
|
|
name: "typescript:makeTemplateObject",
|
|
importName: "__makeTemplateObject",
|
|
scoped: false,
|
|
priority: 0,
|
|
text: `
|
|
var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {
|
|
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
|
return cooked;
|
|
};`
|
|
};
|
|
var readHelper = {
|
|
name: "typescript:read",
|
|
importName: "__read",
|
|
scoped: false,
|
|
text: `
|
|
var __read = (this && this.__read) || function (o, n) {
|
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
if (!m) return o;
|
|
var i = m.call(o), r, ar = [], e;
|
|
try {
|
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
}
|
|
catch (error) { e = { error: error }; }
|
|
finally {
|
|
try {
|
|
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
}
|
|
finally { if (e) throw e.error; }
|
|
}
|
|
return ar;
|
|
};`
|
|
};
|
|
var spreadArrayHelper = {
|
|
name: "typescript:spreadArray",
|
|
importName: "__spreadArray",
|
|
scoped: false,
|
|
text: `
|
|
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
if (ar || !(i in from)) {
|
|
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
ar[i] = from[i];
|
|
}
|
|
}
|
|
return to.concat(ar || Array.prototype.slice.call(from));
|
|
};`
|
|
};
|
|
var valuesHelper = {
|
|
name: "typescript:values",
|
|
importName: "__values",
|
|
scoped: false,
|
|
text: `
|
|
var __values = (this && this.__values) || function(o) {
|
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
if (m) return m.call(o);
|
|
if (o && typeof o.length === "number") return {
|
|
next: function () {
|
|
if (o && i >= o.length) o = void 0;
|
|
return { value: o && o[i++], done: !o };
|
|
}
|
|
};
|
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
};`
|
|
};
|
|
var generatorHelper = {
|
|
name: "typescript:generator",
|
|
importName: "__generator",
|
|
scoped: false,
|
|
priority: 6,
|
|
text: `
|
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
|
function step(op) {
|
|
if (f) throw new TypeError("Generator is already executing.");
|
|
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
|
switch (op[0]) {
|
|
case 0: case 1: t = op; break;
|
|
case 4: _.label++; return { value: op[1], done: false };
|
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
|
default:
|
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
|
if (t[2]) _.ops.pop();
|
|
_.trys.pop(); continue;
|
|
}
|
|
op = body.call(thisArg, _);
|
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
|
}
|
|
};`
|
|
};
|
|
var createBindingHelper = {
|
|
name: "typescript:commonjscreatebinding",
|
|
importName: "__createBinding",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
var desc = Object.getOwnPropertyDescriptor(m, k);
|
|
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
|
desc = { enumerable: true, get: function() { return m[k]; } };
|
|
}
|
|
Object.defineProperty(o, k2, desc);
|
|
}) : (function(o, m, k, k2) {
|
|
if (k2 === undefined) k2 = k;
|
|
o[k2] = m[k];
|
|
}));`
|
|
};
|
|
var setModuleDefaultHelper = {
|
|
name: "typescript:commonjscreatevalue",
|
|
importName: "__setModuleDefault",
|
|
scoped: false,
|
|
priority: 1,
|
|
text: `
|
|
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
|
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
|
}) : function(o, v) {
|
|
o["default"] = v;
|
|
});`
|
|
};
|
|
var importStarHelper = {
|
|
name: "typescript:commonjsimportstar",
|
|
importName: "__importStar",
|
|
scoped: false,
|
|
dependencies: [createBindingHelper, setModuleDefaultHelper],
|
|
priority: 2,
|
|
text: `
|
|
var __importStar = (this && this.__importStar) || function (mod) {
|
|
if (mod && mod.__esModule) return mod;
|
|
var result = {};
|
|
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
|
__setModuleDefault(result, mod);
|
|
return result;
|
|
};`
|
|
};
|
|
var importDefaultHelper = {
|
|
name: "typescript:commonjsimportdefault",
|
|
importName: "__importDefault",
|
|
scoped: false,
|
|
text: `
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};`
|
|
};
|
|
var exportStarHelper = {
|
|
name: "typescript:export-star",
|
|
importName: "__exportStar",
|
|
scoped: false,
|
|
dependencies: [createBindingHelper],
|
|
priority: 2,
|
|
text: `
|
|
var __exportStar = (this && this.__exportStar) || function(m, exports) {
|
|
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
|
|
};`
|
|
};
|
|
var classPrivateFieldGetHelper = {
|
|
name: "typescript:classPrivateFieldGet",
|
|
importName: "__classPrivateFieldGet",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
|
|
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
|
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
|
};`
|
|
};
|
|
var classPrivateFieldSetHelper = {
|
|
name: "typescript:classPrivateFieldSet",
|
|
importName: "__classPrivateFieldSet",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
|
|
if (kind === "m") throw new TypeError("Private method is not writable");
|
|
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
|
|
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
|
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
|
|
};`
|
|
};
|
|
var classPrivateFieldInHelper = {
|
|
name: "typescript:classPrivateFieldIn",
|
|
importName: "__classPrivateFieldIn",
|
|
scoped: false,
|
|
text: `
|
|
var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
|
|
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
|
|
return typeof state === "function" ? receiver === state : state.has(receiver);
|
|
};`
|
|
};
|
|
var allUnscopedEmitHelpers;
|
|
function getAllUnscopedEmitHelpers() {
|
|
return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = arrayToMap([
|
|
decorateHelper,
|
|
metadataHelper,
|
|
paramHelper,
|
|
assignHelper,
|
|
awaitHelper,
|
|
asyncGeneratorHelper,
|
|
asyncDelegator,
|
|
asyncValues,
|
|
restHelper,
|
|
awaiterHelper,
|
|
extendsHelper,
|
|
templateObjectHelper,
|
|
spreadArrayHelper,
|
|
valuesHelper,
|
|
readHelper,
|
|
generatorHelper,
|
|
importStarHelper,
|
|
importDefaultHelper,
|
|
exportStarHelper,
|
|
classPrivateFieldGetHelper,
|
|
classPrivateFieldSetHelper,
|
|
classPrivateFieldInHelper,
|
|
createBindingHelper,
|
|
setModuleDefaultHelper
|
|
], (helper) => helper.name));
|
|
}
|
|
var asyncSuperHelper = {
|
|
name: "typescript:async-super",
|
|
scoped: true,
|
|
text: helperString`
|
|
const ${"_superIndex"} = name => super[name];`
|
|
};
|
|
var advancedAsyncSuperHelper = {
|
|
name: "typescript:advanced-async-super",
|
|
scoped: true,
|
|
text: helperString`
|
|
const ${"_superIndex"} = (function (geti, seti) {
|
|
const cache = Object.create(null);
|
|
return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });
|
|
})(name => super[name], (name, value) => super[name] = value);`
|
|
};
|
|
function isCallToHelper(firstSegment, helperName) {
|
|
return isCallExpression(firstSegment) && isIdentifier(firstSegment.expression) && (getEmitFlags(firstSegment.expression) & 8192 /* HelperName */) !== 0 && firstSegment.expression.escapedText === helperName;
|
|
}
|
|
|
|
// src/compiler/factory/nodeTests.ts
|
|
function isNumericLiteral(node) {
|
|
return node.kind === 8 /* NumericLiteral */;
|
|
}
|
|
function isBigIntLiteral(node) {
|
|
return node.kind === 9 /* BigIntLiteral */;
|
|
}
|
|
function isStringLiteral(node) {
|
|
return node.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isJsxText(node) {
|
|
return node.kind === 11 /* JsxText */;
|
|
}
|
|
function isRegularExpressionLiteral(node) {
|
|
return node.kind === 13 /* RegularExpressionLiteral */;
|
|
}
|
|
function isNoSubstitutionTemplateLiteral(node) {
|
|
return node.kind === 14 /* NoSubstitutionTemplateLiteral */;
|
|
}
|
|
function isTemplateHead(node) {
|
|
return node.kind === 15 /* TemplateHead */;
|
|
}
|
|
function isTemplateMiddle(node) {
|
|
return node.kind === 16 /* TemplateMiddle */;
|
|
}
|
|
function isTemplateTail(node) {
|
|
return node.kind === 17 /* TemplateTail */;
|
|
}
|
|
function isDotDotDotToken(node) {
|
|
return node.kind === 25 /* DotDotDotToken */;
|
|
}
|
|
function isCommaToken(node) {
|
|
return node.kind === 27 /* CommaToken */;
|
|
}
|
|
function isPlusToken(node) {
|
|
return node.kind === 39 /* PlusToken */;
|
|
}
|
|
function isMinusToken(node) {
|
|
return node.kind === 40 /* MinusToken */;
|
|
}
|
|
function isAsteriskToken(node) {
|
|
return node.kind === 41 /* AsteriskToken */;
|
|
}
|
|
function isExclamationToken(node) {
|
|
return node.kind === 53 /* ExclamationToken */;
|
|
}
|
|
function isQuestionToken(node) {
|
|
return node.kind === 57 /* QuestionToken */;
|
|
}
|
|
function isColonToken(node) {
|
|
return node.kind === 58 /* ColonToken */;
|
|
}
|
|
function isQuestionDotToken(node) {
|
|
return node.kind === 28 /* QuestionDotToken */;
|
|
}
|
|
function isEqualsGreaterThanToken(node) {
|
|
return node.kind === 38 /* EqualsGreaterThanToken */;
|
|
}
|
|
function isIdentifier(node) {
|
|
return node.kind === 79 /* Identifier */;
|
|
}
|
|
function isPrivateIdentifier(node) {
|
|
return node.kind === 80 /* PrivateIdentifier */;
|
|
}
|
|
function isExportModifier(node) {
|
|
return node.kind === 93 /* ExportKeyword */;
|
|
}
|
|
function isAsyncModifier(node) {
|
|
return node.kind === 132 /* AsyncKeyword */;
|
|
}
|
|
function isAssertsKeyword(node) {
|
|
return node.kind === 129 /* AssertsKeyword */;
|
|
}
|
|
function isAwaitKeyword(node) {
|
|
return node.kind === 133 /* AwaitKeyword */;
|
|
}
|
|
function isReadonlyKeyword(node) {
|
|
return node.kind === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function isStaticModifier(node) {
|
|
return node.kind === 124 /* StaticKeyword */;
|
|
}
|
|
function isAbstractModifier(node) {
|
|
return node.kind === 126 /* AbstractKeyword */;
|
|
}
|
|
function isOverrideModifier(node) {
|
|
return node.kind === 161 /* OverrideKeyword */;
|
|
}
|
|
function isAccessorModifier(node) {
|
|
return node.kind === 127 /* AccessorKeyword */;
|
|
}
|
|
function isSuperKeyword(node) {
|
|
return node.kind === 106 /* SuperKeyword */;
|
|
}
|
|
function isImportKeyword(node) {
|
|
return node.kind === 100 /* ImportKeyword */;
|
|
}
|
|
function isQualifiedName(node) {
|
|
return node.kind === 163 /* QualifiedName */;
|
|
}
|
|
function isComputedPropertyName(node) {
|
|
return node.kind === 164 /* ComputedPropertyName */;
|
|
}
|
|
function isTypeParameterDeclaration(node) {
|
|
return node.kind === 165 /* TypeParameter */;
|
|
}
|
|
function isParameter(node) {
|
|
return node.kind === 166 /* Parameter */;
|
|
}
|
|
function isDecorator(node) {
|
|
return node.kind === 167 /* Decorator */;
|
|
}
|
|
function isPropertySignature(node) {
|
|
return node.kind === 168 /* PropertySignature */;
|
|
}
|
|
function isPropertyDeclaration(node) {
|
|
return node.kind === 169 /* PropertyDeclaration */;
|
|
}
|
|
function isMethodSignature(node) {
|
|
return node.kind === 170 /* MethodSignature */;
|
|
}
|
|
function isMethodDeclaration(node) {
|
|
return node.kind === 171 /* MethodDeclaration */;
|
|
}
|
|
function isClassStaticBlockDeclaration(node) {
|
|
return node.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
}
|
|
function isConstructorDeclaration(node) {
|
|
return node.kind === 173 /* Constructor */;
|
|
}
|
|
function isGetAccessorDeclaration(node) {
|
|
return node.kind === 174 /* GetAccessor */;
|
|
}
|
|
function isSetAccessorDeclaration(node) {
|
|
return node.kind === 175 /* SetAccessor */;
|
|
}
|
|
function isCallSignatureDeclaration(node) {
|
|
return node.kind === 176 /* CallSignature */;
|
|
}
|
|
function isConstructSignatureDeclaration(node) {
|
|
return node.kind === 177 /* ConstructSignature */;
|
|
}
|
|
function isIndexSignatureDeclaration(node) {
|
|
return node.kind === 178 /* IndexSignature */;
|
|
}
|
|
function isTypePredicateNode(node) {
|
|
return node.kind === 179 /* TypePredicate */;
|
|
}
|
|
function isTypeReferenceNode(node) {
|
|
return node.kind === 180 /* TypeReference */;
|
|
}
|
|
function isFunctionTypeNode(node) {
|
|
return node.kind === 181 /* FunctionType */;
|
|
}
|
|
function isConstructorTypeNode(node) {
|
|
return node.kind === 182 /* ConstructorType */;
|
|
}
|
|
function isTypeQueryNode(node) {
|
|
return node.kind === 183 /* TypeQuery */;
|
|
}
|
|
function isTypeLiteralNode(node) {
|
|
return node.kind === 184 /* TypeLiteral */;
|
|
}
|
|
function isArrayTypeNode(node) {
|
|
return node.kind === 185 /* ArrayType */;
|
|
}
|
|
function isTupleTypeNode(node) {
|
|
return node.kind === 186 /* TupleType */;
|
|
}
|
|
function isNamedTupleMember(node) {
|
|
return node.kind === 199 /* NamedTupleMember */;
|
|
}
|
|
function isOptionalTypeNode(node) {
|
|
return node.kind === 187 /* OptionalType */;
|
|
}
|
|
function isRestTypeNode(node) {
|
|
return node.kind === 188 /* RestType */;
|
|
}
|
|
function isUnionTypeNode(node) {
|
|
return node.kind === 189 /* UnionType */;
|
|
}
|
|
function isIntersectionTypeNode(node) {
|
|
return node.kind === 190 /* IntersectionType */;
|
|
}
|
|
function isConditionalTypeNode(node) {
|
|
return node.kind === 191 /* ConditionalType */;
|
|
}
|
|
function isInferTypeNode(node) {
|
|
return node.kind === 192 /* InferType */;
|
|
}
|
|
function isParenthesizedTypeNode(node) {
|
|
return node.kind === 193 /* ParenthesizedType */;
|
|
}
|
|
function isThisTypeNode(node) {
|
|
return node.kind === 194 /* ThisType */;
|
|
}
|
|
function isTypeOperatorNode(node) {
|
|
return node.kind === 195 /* TypeOperator */;
|
|
}
|
|
function isIndexedAccessTypeNode(node) {
|
|
return node.kind === 196 /* IndexedAccessType */;
|
|
}
|
|
function isMappedTypeNode(node) {
|
|
return node.kind === 197 /* MappedType */;
|
|
}
|
|
function isLiteralTypeNode(node) {
|
|
return node.kind === 198 /* LiteralType */;
|
|
}
|
|
function isImportTypeNode(node) {
|
|
return node.kind === 202 /* ImportType */;
|
|
}
|
|
function isTemplateLiteralTypeSpan(node) {
|
|
return node.kind === 201 /* TemplateLiteralTypeSpan */;
|
|
}
|
|
function isTemplateLiteralTypeNode(node) {
|
|
return node.kind === 200 /* TemplateLiteralType */;
|
|
}
|
|
function isObjectBindingPattern(node) {
|
|
return node.kind === 203 /* ObjectBindingPattern */;
|
|
}
|
|
function isArrayBindingPattern(node) {
|
|
return node.kind === 204 /* ArrayBindingPattern */;
|
|
}
|
|
function isBindingElement(node) {
|
|
return node.kind === 205 /* BindingElement */;
|
|
}
|
|
function isArrayLiteralExpression(node) {
|
|
return node.kind === 206 /* ArrayLiteralExpression */;
|
|
}
|
|
function isObjectLiteralExpression(node) {
|
|
return node.kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isPropertyAccessExpression(node) {
|
|
return node.kind === 208 /* PropertyAccessExpression */;
|
|
}
|
|
function isElementAccessExpression(node) {
|
|
return node.kind === 209 /* ElementAccessExpression */;
|
|
}
|
|
function isCallExpression(node) {
|
|
return node.kind === 210 /* CallExpression */;
|
|
}
|
|
function isNewExpression(node) {
|
|
return node.kind === 211 /* NewExpression */;
|
|
}
|
|
function isTaggedTemplateExpression(node) {
|
|
return node.kind === 212 /* TaggedTemplateExpression */;
|
|
}
|
|
function isTypeAssertionExpression(node) {
|
|
return node.kind === 213 /* TypeAssertionExpression */;
|
|
}
|
|
function isParenthesizedExpression(node) {
|
|
return node.kind === 214 /* ParenthesizedExpression */;
|
|
}
|
|
function isFunctionExpression(node) {
|
|
return node.kind === 215 /* FunctionExpression */;
|
|
}
|
|
function isArrowFunction(node) {
|
|
return node.kind === 216 /* ArrowFunction */;
|
|
}
|
|
function isDeleteExpression(node) {
|
|
return node.kind === 217 /* DeleteExpression */;
|
|
}
|
|
function isTypeOfExpression(node) {
|
|
return node.kind === 218 /* TypeOfExpression */;
|
|
}
|
|
function isVoidExpression(node) {
|
|
return node.kind === 219 /* VoidExpression */;
|
|
}
|
|
function isAwaitExpression(node) {
|
|
return node.kind === 220 /* AwaitExpression */;
|
|
}
|
|
function isPrefixUnaryExpression(node) {
|
|
return node.kind === 221 /* PrefixUnaryExpression */;
|
|
}
|
|
function isPostfixUnaryExpression(node) {
|
|
return node.kind === 222 /* PostfixUnaryExpression */;
|
|
}
|
|
function isBinaryExpression(node) {
|
|
return node.kind === 223 /* BinaryExpression */;
|
|
}
|
|
function isConditionalExpression(node) {
|
|
return node.kind === 224 /* ConditionalExpression */;
|
|
}
|
|
function isTemplateExpression(node) {
|
|
return node.kind === 225 /* TemplateExpression */;
|
|
}
|
|
function isYieldExpression(node) {
|
|
return node.kind === 226 /* YieldExpression */;
|
|
}
|
|
function isSpreadElement(node) {
|
|
return node.kind === 227 /* SpreadElement */;
|
|
}
|
|
function isClassExpression(node) {
|
|
return node.kind === 228 /* ClassExpression */;
|
|
}
|
|
function isOmittedExpression(node) {
|
|
return node.kind === 229 /* OmittedExpression */;
|
|
}
|
|
function isExpressionWithTypeArguments(node) {
|
|
return node.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
function isAsExpression(node) {
|
|
return node.kind === 231 /* AsExpression */;
|
|
}
|
|
function isSatisfiesExpression(node) {
|
|
return node.kind === 235 /* SatisfiesExpression */;
|
|
}
|
|
function isNonNullExpression(node) {
|
|
return node.kind === 232 /* NonNullExpression */;
|
|
}
|
|
function isMetaProperty(node) {
|
|
return node.kind === 233 /* MetaProperty */;
|
|
}
|
|
function isSyntheticExpression(node) {
|
|
return node.kind === 234 /* SyntheticExpression */;
|
|
}
|
|
function isPartiallyEmittedExpression(node) {
|
|
return node.kind === 353 /* PartiallyEmittedExpression */;
|
|
}
|
|
function isCommaListExpression(node) {
|
|
return node.kind === 354 /* CommaListExpression */;
|
|
}
|
|
function isTemplateSpan(node) {
|
|
return node.kind === 236 /* TemplateSpan */;
|
|
}
|
|
function isSemicolonClassElement(node) {
|
|
return node.kind === 237 /* SemicolonClassElement */;
|
|
}
|
|
function isBlock(node) {
|
|
return node.kind === 238 /* Block */;
|
|
}
|
|
function isVariableStatement(node) {
|
|
return node.kind === 240 /* VariableStatement */;
|
|
}
|
|
function isEmptyStatement(node) {
|
|
return node.kind === 239 /* EmptyStatement */;
|
|
}
|
|
function isExpressionStatement(node) {
|
|
return node.kind === 241 /* ExpressionStatement */;
|
|
}
|
|
function isIfStatement(node) {
|
|
return node.kind === 242 /* IfStatement */;
|
|
}
|
|
function isDoStatement(node) {
|
|
return node.kind === 243 /* DoStatement */;
|
|
}
|
|
function isWhileStatement(node) {
|
|
return node.kind === 244 /* WhileStatement */;
|
|
}
|
|
function isForStatement(node) {
|
|
return node.kind === 245 /* ForStatement */;
|
|
}
|
|
function isForInStatement(node) {
|
|
return node.kind === 246 /* ForInStatement */;
|
|
}
|
|
function isForOfStatement(node) {
|
|
return node.kind === 247 /* ForOfStatement */;
|
|
}
|
|
function isContinueStatement(node) {
|
|
return node.kind === 248 /* ContinueStatement */;
|
|
}
|
|
function isBreakStatement(node) {
|
|
return node.kind === 249 /* BreakStatement */;
|
|
}
|
|
function isReturnStatement(node) {
|
|
return node.kind === 250 /* ReturnStatement */;
|
|
}
|
|
function isWithStatement(node) {
|
|
return node.kind === 251 /* WithStatement */;
|
|
}
|
|
function isSwitchStatement(node) {
|
|
return node.kind === 252 /* SwitchStatement */;
|
|
}
|
|
function isLabeledStatement(node) {
|
|
return node.kind === 253 /* LabeledStatement */;
|
|
}
|
|
function isThrowStatement(node) {
|
|
return node.kind === 254 /* ThrowStatement */;
|
|
}
|
|
function isTryStatement(node) {
|
|
return node.kind === 255 /* TryStatement */;
|
|
}
|
|
function isDebuggerStatement(node) {
|
|
return node.kind === 256 /* DebuggerStatement */;
|
|
}
|
|
function isVariableDeclaration(node) {
|
|
return node.kind === 257 /* VariableDeclaration */;
|
|
}
|
|
function isVariableDeclarationList(node) {
|
|
return node.kind === 258 /* VariableDeclarationList */;
|
|
}
|
|
function isFunctionDeclaration(node) {
|
|
return node.kind === 259 /* FunctionDeclaration */;
|
|
}
|
|
function isClassDeclaration(node) {
|
|
return node.kind === 260 /* ClassDeclaration */;
|
|
}
|
|
function isInterfaceDeclaration(node) {
|
|
return node.kind === 261 /* InterfaceDeclaration */;
|
|
}
|
|
function isTypeAliasDeclaration(node) {
|
|
return node.kind === 262 /* TypeAliasDeclaration */;
|
|
}
|
|
function isEnumDeclaration(node) {
|
|
return node.kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function isModuleDeclaration(node) {
|
|
return node.kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isModuleBlock(node) {
|
|
return node.kind === 265 /* ModuleBlock */;
|
|
}
|
|
function isCaseBlock(node) {
|
|
return node.kind === 266 /* CaseBlock */;
|
|
}
|
|
function isNamespaceExportDeclaration(node) {
|
|
return node.kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
function isImportEqualsDeclaration(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */;
|
|
}
|
|
function isImportDeclaration(node) {
|
|
return node.kind === 269 /* ImportDeclaration */;
|
|
}
|
|
function isImportClause(node) {
|
|
return node.kind === 270 /* ImportClause */;
|
|
}
|
|
function isImportTypeAssertionContainer(node) {
|
|
return node.kind === 298 /* ImportTypeAssertionContainer */;
|
|
}
|
|
function isAssertClause(node) {
|
|
return node.kind === 296 /* AssertClause */;
|
|
}
|
|
function isAssertEntry(node) {
|
|
return node.kind === 297 /* AssertEntry */;
|
|
}
|
|
function isNamespaceImport(node) {
|
|
return node.kind === 271 /* NamespaceImport */;
|
|
}
|
|
function isNamespaceExport(node) {
|
|
return node.kind === 277 /* NamespaceExport */;
|
|
}
|
|
function isNamedImports(node) {
|
|
return node.kind === 272 /* NamedImports */;
|
|
}
|
|
function isImportSpecifier(node) {
|
|
return node.kind === 273 /* ImportSpecifier */;
|
|
}
|
|
function isExportAssignment(node) {
|
|
return node.kind === 274 /* ExportAssignment */;
|
|
}
|
|
function isExportDeclaration(node) {
|
|
return node.kind === 275 /* ExportDeclaration */;
|
|
}
|
|
function isNamedExports(node) {
|
|
return node.kind === 276 /* NamedExports */;
|
|
}
|
|
function isExportSpecifier(node) {
|
|
return node.kind === 278 /* ExportSpecifier */;
|
|
}
|
|
function isMissingDeclaration(node) {
|
|
return node.kind === 279 /* MissingDeclaration */;
|
|
}
|
|
function isNotEmittedStatement(node) {
|
|
return node.kind === 352 /* NotEmittedStatement */;
|
|
}
|
|
function isSyntheticReference(node) {
|
|
return node.kind === 357 /* SyntheticReferenceExpression */;
|
|
}
|
|
function isMergeDeclarationMarker(node) {
|
|
return node.kind === 355 /* MergeDeclarationMarker */;
|
|
}
|
|
function isEndOfDeclarationMarker(node) {
|
|
return node.kind === 356 /* EndOfDeclarationMarker */;
|
|
}
|
|
function isExternalModuleReference(node) {
|
|
return node.kind === 280 /* ExternalModuleReference */;
|
|
}
|
|
function isJsxElement(node) {
|
|
return node.kind === 281 /* JsxElement */;
|
|
}
|
|
function isJsxSelfClosingElement(node) {
|
|
return node.kind === 282 /* JsxSelfClosingElement */;
|
|
}
|
|
function isJsxOpeningElement(node) {
|
|
return node.kind === 283 /* JsxOpeningElement */;
|
|
}
|
|
function isJsxClosingElement(node) {
|
|
return node.kind === 284 /* JsxClosingElement */;
|
|
}
|
|
function isJsxFragment(node) {
|
|
return node.kind === 285 /* JsxFragment */;
|
|
}
|
|
function isJsxOpeningFragment(node) {
|
|
return node.kind === 286 /* JsxOpeningFragment */;
|
|
}
|
|
function isJsxClosingFragment(node) {
|
|
return node.kind === 287 /* JsxClosingFragment */;
|
|
}
|
|
function isJsxAttribute(node) {
|
|
return node.kind === 288 /* JsxAttribute */;
|
|
}
|
|
function isJsxAttributes(node) {
|
|
return node.kind === 289 /* JsxAttributes */;
|
|
}
|
|
function isJsxSpreadAttribute(node) {
|
|
return node.kind === 290 /* JsxSpreadAttribute */;
|
|
}
|
|
function isJsxExpression(node) {
|
|
return node.kind === 291 /* JsxExpression */;
|
|
}
|
|
function isCaseClause(node) {
|
|
return node.kind === 292 /* CaseClause */;
|
|
}
|
|
function isDefaultClause(node) {
|
|
return node.kind === 293 /* DefaultClause */;
|
|
}
|
|
function isHeritageClause(node) {
|
|
return node.kind === 294 /* HeritageClause */;
|
|
}
|
|
function isCatchClause(node) {
|
|
return node.kind === 295 /* CatchClause */;
|
|
}
|
|
function isPropertyAssignment(node) {
|
|
return node.kind === 299 /* PropertyAssignment */;
|
|
}
|
|
function isShorthandPropertyAssignment(node) {
|
|
return node.kind === 300 /* ShorthandPropertyAssignment */;
|
|
}
|
|
function isSpreadAssignment(node) {
|
|
return node.kind === 301 /* SpreadAssignment */;
|
|
}
|
|
function isEnumMember(node) {
|
|
return node.kind === 302 /* EnumMember */;
|
|
}
|
|
function isUnparsedPrepend(node) {
|
|
return node.kind === 304 /* UnparsedPrepend */;
|
|
}
|
|
function isSourceFile(node) {
|
|
return node.kind === 308 /* SourceFile */;
|
|
}
|
|
function isBundle(node) {
|
|
return node.kind === 309 /* Bundle */;
|
|
}
|
|
function isUnparsedSource(node) {
|
|
return node.kind === 310 /* UnparsedSource */;
|
|
}
|
|
function isJSDocTypeExpression(node) {
|
|
return node.kind === 312 /* JSDocTypeExpression */;
|
|
}
|
|
function isJSDocNameReference(node) {
|
|
return node.kind === 313 /* JSDocNameReference */;
|
|
}
|
|
function isJSDocMemberName(node) {
|
|
return node.kind === 314 /* JSDocMemberName */;
|
|
}
|
|
function isJSDocLink(node) {
|
|
return node.kind === 327 /* JSDocLink */;
|
|
}
|
|
function isJSDocLinkCode(node) {
|
|
return node.kind === 328 /* JSDocLinkCode */;
|
|
}
|
|
function isJSDocLinkPlain(node) {
|
|
return node.kind === 329 /* JSDocLinkPlain */;
|
|
}
|
|
function isJSDocAllType(node) {
|
|
return node.kind === 315 /* JSDocAllType */;
|
|
}
|
|
function isJSDocUnknownType(node) {
|
|
return node.kind === 316 /* JSDocUnknownType */;
|
|
}
|
|
function isJSDocNullableType(node) {
|
|
return node.kind === 317 /* JSDocNullableType */;
|
|
}
|
|
function isJSDocNonNullableType(node) {
|
|
return node.kind === 318 /* JSDocNonNullableType */;
|
|
}
|
|
function isJSDocOptionalType(node) {
|
|
return node.kind === 319 /* JSDocOptionalType */;
|
|
}
|
|
function isJSDocFunctionType(node) {
|
|
return node.kind === 320 /* JSDocFunctionType */;
|
|
}
|
|
function isJSDocVariadicType(node) {
|
|
return node.kind === 321 /* JSDocVariadicType */;
|
|
}
|
|
function isJSDocNamepathType(node) {
|
|
return node.kind === 322 /* JSDocNamepathType */;
|
|
}
|
|
function isJSDoc(node) {
|
|
return node.kind === 323 /* JSDoc */;
|
|
}
|
|
function isJSDocTypeLiteral(node) {
|
|
return node.kind === 325 /* JSDocTypeLiteral */;
|
|
}
|
|
function isJSDocSignature(node) {
|
|
return node.kind === 326 /* JSDocSignature */;
|
|
}
|
|
function isJSDocAugmentsTag(node) {
|
|
return node.kind === 331 /* JSDocAugmentsTag */;
|
|
}
|
|
function isJSDocAuthorTag(node) {
|
|
return node.kind === 333 /* JSDocAuthorTag */;
|
|
}
|
|
function isJSDocClassTag(node) {
|
|
return node.kind === 335 /* JSDocClassTag */;
|
|
}
|
|
function isJSDocCallbackTag(node) {
|
|
return node.kind === 341 /* JSDocCallbackTag */;
|
|
}
|
|
function isJSDocPublicTag(node) {
|
|
return node.kind === 336 /* JSDocPublicTag */;
|
|
}
|
|
function isJSDocPrivateTag(node) {
|
|
return node.kind === 337 /* JSDocPrivateTag */;
|
|
}
|
|
function isJSDocProtectedTag(node) {
|
|
return node.kind === 338 /* JSDocProtectedTag */;
|
|
}
|
|
function isJSDocReadonlyTag(node) {
|
|
return node.kind === 339 /* JSDocReadonlyTag */;
|
|
}
|
|
function isJSDocOverrideTag(node) {
|
|
return node.kind === 340 /* JSDocOverrideTag */;
|
|
}
|
|
function isJSDocDeprecatedTag(node) {
|
|
return node.kind === 334 /* JSDocDeprecatedTag */;
|
|
}
|
|
function isJSDocSeeTag(node) {
|
|
return node.kind === 349 /* JSDocSeeTag */;
|
|
}
|
|
function isJSDocEnumTag(node) {
|
|
return node.kind === 342 /* JSDocEnumTag */;
|
|
}
|
|
function isJSDocParameterTag(node) {
|
|
return node.kind === 343 /* JSDocParameterTag */;
|
|
}
|
|
function isJSDocReturnTag(node) {
|
|
return node.kind === 344 /* JSDocReturnTag */;
|
|
}
|
|
function isJSDocThisTag(node) {
|
|
return node.kind === 345 /* JSDocThisTag */;
|
|
}
|
|
function isJSDocTypeTag(node) {
|
|
return node.kind === 346 /* JSDocTypeTag */;
|
|
}
|
|
function isJSDocTemplateTag(node) {
|
|
return node.kind === 347 /* JSDocTemplateTag */;
|
|
}
|
|
function isJSDocTypedefTag(node) {
|
|
return node.kind === 348 /* JSDocTypedefTag */;
|
|
}
|
|
function isJSDocUnknownTag(node) {
|
|
return node.kind === 330 /* JSDocTag */;
|
|
}
|
|
function isJSDocPropertyTag(node) {
|
|
return node.kind === 350 /* JSDocPropertyTag */;
|
|
}
|
|
function isJSDocImplementsTag(node) {
|
|
return node.kind === 332 /* JSDocImplementsTag */;
|
|
}
|
|
function isSyntaxList(n) {
|
|
return n.kind === 351 /* SyntaxList */;
|
|
}
|
|
|
|
// src/compiler/factory/utilities.ts
|
|
function createEmptyExports(factory2) {
|
|
return factory2.createExportDeclaration(void 0, false, factory2.createNamedExports([]), void 0);
|
|
}
|
|
function createMemberAccessForPropertyName(factory2, target, memberName, location2) {
|
|
if (isComputedPropertyName(memberName)) {
|
|
return setTextRange(factory2.createElementAccessExpression(target, memberName.expression), location2);
|
|
} else {
|
|
const expression = setTextRange(
|
|
isMemberName(memberName) ? factory2.createPropertyAccessExpression(target, memberName) : factory2.createElementAccessExpression(target, memberName),
|
|
memberName
|
|
);
|
|
getOrCreateEmitNode(expression).flags |= 128 /* NoNestedSourceMaps */;
|
|
return expression;
|
|
}
|
|
}
|
|
function createReactNamespace(reactNamespace, parent2) {
|
|
const react = parseNodeFactory.createIdentifier(reactNamespace || "React");
|
|
setParent(react, getParseTreeNode(parent2));
|
|
return react;
|
|
}
|
|
function createJsxFactoryExpressionFromEntityName(factory2, jsxFactory, parent2) {
|
|
if (isQualifiedName(jsxFactory)) {
|
|
const left = createJsxFactoryExpressionFromEntityName(factory2, jsxFactory.left, parent2);
|
|
const right = factory2.createIdentifier(idText(jsxFactory.right));
|
|
right.escapedText = jsxFactory.right.escapedText;
|
|
return factory2.createPropertyAccessExpression(left, right);
|
|
} else {
|
|
return createReactNamespace(idText(jsxFactory), parent2);
|
|
}
|
|
}
|
|
function createJsxFactoryExpression(factory2, jsxFactoryEntity, reactNamespace, parent2) {
|
|
return jsxFactoryEntity ? createJsxFactoryExpressionFromEntityName(factory2, jsxFactoryEntity, parent2) : factory2.createPropertyAccessExpression(
|
|
createReactNamespace(reactNamespace, parent2),
|
|
"createElement"
|
|
);
|
|
}
|
|
function createJsxFragmentFactoryExpression(factory2, jsxFragmentFactoryEntity, reactNamespace, parent2) {
|
|
return jsxFragmentFactoryEntity ? createJsxFactoryExpressionFromEntityName(factory2, jsxFragmentFactoryEntity, parent2) : factory2.createPropertyAccessExpression(
|
|
createReactNamespace(reactNamespace, parent2),
|
|
"Fragment"
|
|
);
|
|
}
|
|
function createExpressionForJsxElement(factory2, callee, tagName, props, children, location2) {
|
|
const argumentsList = [tagName];
|
|
if (props) {
|
|
argumentsList.push(props);
|
|
}
|
|
if (children && children.length > 0) {
|
|
if (!props) {
|
|
argumentsList.push(factory2.createNull());
|
|
}
|
|
if (children.length > 1) {
|
|
for (const child of children) {
|
|
startOnNewLine(child);
|
|
argumentsList.push(child);
|
|
}
|
|
} else {
|
|
argumentsList.push(children[0]);
|
|
}
|
|
}
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
callee,
|
|
void 0,
|
|
argumentsList
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createExpressionForJsxFragment(factory2, jsxFactoryEntity, jsxFragmentFactoryEntity, reactNamespace, children, parentElement, location2) {
|
|
const tagName = createJsxFragmentFactoryExpression(factory2, jsxFragmentFactoryEntity, reactNamespace, parentElement);
|
|
const argumentsList = [tagName, factory2.createNull()];
|
|
if (children && children.length > 0) {
|
|
if (children.length > 1) {
|
|
for (const child of children) {
|
|
startOnNewLine(child);
|
|
argumentsList.push(child);
|
|
}
|
|
} else {
|
|
argumentsList.push(children[0]);
|
|
}
|
|
}
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
createJsxFactoryExpression(factory2, jsxFactoryEntity, reactNamespace, parentElement),
|
|
void 0,
|
|
argumentsList
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createForOfBindingStatement(factory2, node, boundValue) {
|
|
if (isVariableDeclarationList(node)) {
|
|
const firstDeclaration = first(node.declarations);
|
|
const updatedDeclaration = factory2.updateVariableDeclaration(
|
|
firstDeclaration,
|
|
firstDeclaration.name,
|
|
void 0,
|
|
void 0,
|
|
boundValue
|
|
);
|
|
return setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.updateVariableDeclarationList(node, [updatedDeclaration])
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const updatedExpression = setTextRange(factory2.createAssignment(node, boundValue), node);
|
|
return setTextRange(factory2.createExpressionStatement(updatedExpression), node);
|
|
}
|
|
}
|
|
function insertLeadingStatement(factory2, dest, source) {
|
|
if (isBlock(dest)) {
|
|
return factory2.updateBlock(dest, setTextRange(factory2.createNodeArray([source, ...dest.statements]), dest.statements));
|
|
} else {
|
|
return factory2.createBlock(factory2.createNodeArray([dest, source]), true);
|
|
}
|
|
}
|
|
function createExpressionFromEntityName(factory2, node) {
|
|
if (isQualifiedName(node)) {
|
|
const left = createExpressionFromEntityName(factory2, node.left);
|
|
const right = setParent(setTextRange(factory2.cloneNode(node.right), node.right), node.right.parent);
|
|
return setTextRange(factory2.createPropertyAccessExpression(left, right), node);
|
|
} else {
|
|
return setParent(setTextRange(factory2.cloneNode(node), node), node.parent);
|
|
}
|
|
}
|
|
function createExpressionForPropertyName(factory2, memberName) {
|
|
if (isIdentifier(memberName)) {
|
|
return factory2.createStringLiteralFromNode(memberName);
|
|
} else if (isComputedPropertyName(memberName)) {
|
|
return setParent(setTextRange(factory2.cloneNode(memberName.expression), memberName.expression), memberName.expression.parent);
|
|
} else {
|
|
return setParent(setTextRange(factory2.cloneNode(memberName), memberName), memberName.parent);
|
|
}
|
|
}
|
|
function createExpressionForAccessorDeclaration(factory2, properties, property, receiver, multiLine) {
|
|
const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property);
|
|
if (property === firstAccessor) {
|
|
return setTextRange(
|
|
factory2.createObjectDefinePropertyCall(
|
|
receiver,
|
|
createExpressionForPropertyName(factory2, property.name),
|
|
factory2.createPropertyDescriptor({
|
|
enumerable: factory2.createFalse(),
|
|
configurable: true,
|
|
get: getAccessor && setTextRange(
|
|
setOriginalNode(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(getAccessor),
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
getAccessor.parameters,
|
|
void 0,
|
|
getAccessor.body
|
|
),
|
|
getAccessor
|
|
),
|
|
getAccessor
|
|
),
|
|
set: setAccessor && setTextRange(
|
|
setOriginalNode(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(setAccessor),
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
setAccessor.parameters,
|
|
void 0,
|
|
setAccessor.body
|
|
),
|
|
setAccessor
|
|
),
|
|
setAccessor
|
|
)
|
|
}, !multiLine)
|
|
),
|
|
firstAccessor
|
|
);
|
|
}
|
|
return void 0;
|
|
}
|
|
function createExpressionForPropertyAssignment(factory2, property, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, property.name, property.name),
|
|
property.initializer
|
|
),
|
|
property
|
|
),
|
|
property
|
|
);
|
|
}
|
|
function createExpressionForShorthandPropertyAssignment(factory2, property, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, property.name, property.name),
|
|
factory2.cloneNode(property.name)
|
|
),
|
|
property
|
|
),
|
|
property
|
|
);
|
|
}
|
|
function createExpressionForMethodDeclaration(factory2, method, receiver) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
createMemberAccessForPropertyName(factory2, receiver, method.name, method.name),
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
getModifiers(method),
|
|
method.asteriskToken,
|
|
void 0,
|
|
void 0,
|
|
method.parameters,
|
|
void 0,
|
|
method.body
|
|
),
|
|
method
|
|
),
|
|
method
|
|
)
|
|
),
|
|
method
|
|
),
|
|
method
|
|
);
|
|
}
|
|
function createExpressionForObjectLiteralElementLike(factory2, node, property, receiver) {
|
|
if (property.name && isPrivateIdentifier(property.name)) {
|
|
Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals.");
|
|
}
|
|
switch (property.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return createExpressionForAccessorDeclaration(factory2, node.properties, property, receiver, !!node.multiLine);
|
|
case 299 /* PropertyAssignment */:
|
|
return createExpressionForPropertyAssignment(factory2, property, receiver);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return createExpressionForShorthandPropertyAssignment(factory2, property, receiver);
|
|
case 171 /* MethodDeclaration */:
|
|
return createExpressionForMethodDeclaration(factory2, property, receiver);
|
|
}
|
|
}
|
|
function expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, recordTempVariable, resultVariable) {
|
|
const operator = node.operator;
|
|
Debug.assert(operator === 45 /* PlusPlusToken */ || operator === 46 /* MinusMinusToken */, "Expected 'node' to be a pre- or post-increment or pre- or post-decrement expression");
|
|
const temp = factory2.createTempVariable(recordTempVariable);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node.operand);
|
|
let operation = isPrefixUnaryExpression(node) ? factory2.createPrefixUnaryExpression(operator, temp) : factory2.createPostfixUnaryExpression(temp, operator);
|
|
setTextRange(operation, node);
|
|
if (resultVariable) {
|
|
operation = factory2.createAssignment(resultVariable, operation);
|
|
setTextRange(operation, node);
|
|
}
|
|
expression = factory2.createComma(expression, operation);
|
|
setTextRange(expression, node);
|
|
if (isPostfixUnaryExpression(node)) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
function isInternalName(node) {
|
|
return (getEmitFlags(node) & 65536 /* InternalName */) !== 0;
|
|
}
|
|
function isLocalName(node) {
|
|
return (getEmitFlags(node) & 32768 /* LocalName */) !== 0;
|
|
}
|
|
function isExportName(node) {
|
|
return (getEmitFlags(node) & 16384 /* ExportName */) !== 0;
|
|
}
|
|
function isUseStrictPrologue(node) {
|
|
return isStringLiteral(node.expression) && node.expression.text === "use strict";
|
|
}
|
|
function findUseStrictPrologue(statements) {
|
|
for (const statement of statements) {
|
|
if (isPrologueDirective(statement)) {
|
|
if (isUseStrictPrologue(statement)) {
|
|
return statement;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function startsWithUseStrict(statements) {
|
|
const firstStatement = firstOrUndefined(statements);
|
|
return firstStatement !== void 0 && isPrologueDirective(firstStatement) && isUseStrictPrologue(firstStatement);
|
|
}
|
|
function isCommaSequence(node) {
|
|
return node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 27 /* CommaToken */ || node.kind === 354 /* CommaListExpression */;
|
|
}
|
|
function isJSDocTypeAssertion(node) {
|
|
return isParenthesizedExpression(node) && isInJSFile(node) && !!getJSDocTypeTag(node);
|
|
}
|
|
function getJSDocTypeAssertionType(node) {
|
|
const type = getJSDocType(node);
|
|
Debug.assertIsDefined(type);
|
|
return type;
|
|
}
|
|
function isOuterExpression(node, kinds = 15 /* All */) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
if (kinds & 16 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
|
|
return false;
|
|
}
|
|
return (kinds & 1 /* Parentheses */) !== 0;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return (kinds & 2 /* TypeAssertions */) !== 0;
|
|
case 232 /* NonNullExpression */:
|
|
return (kinds & 4 /* NonNullAssertions */) !== 0;
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0;
|
|
}
|
|
return false;
|
|
}
|
|
function skipOuterExpressions(node, kinds = 15 /* All */) {
|
|
while (isOuterExpression(node, kinds)) {
|
|
node = node.expression;
|
|
}
|
|
return node;
|
|
}
|
|
function skipAssertions(node) {
|
|
return skipOuterExpressions(node, 6 /* Assertions */);
|
|
}
|
|
function startOnNewLine(node) {
|
|
return setStartsOnNewLine(node, true);
|
|
}
|
|
function getExternalHelpersModuleName(node) {
|
|
const parseNode = getOriginalNode(node, isSourceFile);
|
|
const emitNode = parseNode && parseNode.emitNode;
|
|
return emitNode && emitNode.externalHelpersModuleName;
|
|
}
|
|
function hasRecordedExternalHelpers(sourceFile) {
|
|
const parseNode = getOriginalNode(sourceFile, isSourceFile);
|
|
const emitNode = parseNode && parseNode.emitNode;
|
|
return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers);
|
|
}
|
|
function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) {
|
|
if (compilerOptions.importHelpers && isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
let namedBindings;
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
if (moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */ || sourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
const helpers = getEmitHelpers(sourceFile);
|
|
if (helpers) {
|
|
const helperNames = [];
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
const importName = helper.importName;
|
|
if (importName) {
|
|
pushIfUnique(helperNames, importName);
|
|
}
|
|
}
|
|
}
|
|
if (some(helperNames)) {
|
|
helperNames.sort(compareStringsCaseSensitive);
|
|
namedBindings = nodeFactory.createNamedImports(
|
|
map(
|
|
helperNames,
|
|
(name) => isFileLevelUniqueName(sourceFile, name) ? nodeFactory.createImportSpecifier(false, void 0, nodeFactory.createIdentifier(name)) : nodeFactory.createImportSpecifier(false, nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name))
|
|
)
|
|
);
|
|
const parseNode = getOriginalNode(sourceFile, isSourceFile);
|
|
const emitNode = getOrCreateEmitNode(parseNode);
|
|
emitNode.externalHelpers = true;
|
|
}
|
|
}
|
|
} else {
|
|
const externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault);
|
|
if (externalHelpersModuleName) {
|
|
namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName);
|
|
}
|
|
}
|
|
if (namedBindings) {
|
|
const externalHelpersImportDeclaration = nodeFactory.createImportDeclaration(
|
|
void 0,
|
|
nodeFactory.createImportClause(false, void 0, namedBindings),
|
|
nodeFactory.createStringLiteral(externalHelpersModuleNameText),
|
|
void 0
|
|
);
|
|
addEmitFlags(externalHelpersImportDeclaration, 134217728 /* NeverApplyImportHelper */);
|
|
return externalHelpersImportDeclaration;
|
|
}
|
|
}
|
|
}
|
|
function getOrCreateExternalHelpersModuleNameIfNeeded(factory2, node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) {
|
|
if (compilerOptions.importHelpers && isEffectiveExternalModule(node, compilerOptions)) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(node);
|
|
if (externalHelpersModuleName) {
|
|
return externalHelpersModuleName;
|
|
}
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
let create = (hasExportStarsToExportValues || getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || node.impliedNodeFormat === 1 /* CommonJS */);
|
|
if (!create) {
|
|
const helpers = getEmitHelpers(node);
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
create = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (create) {
|
|
const parseNode = getOriginalNode(node, isSourceFile);
|
|
const emitNode = getOrCreateEmitNode(parseNode);
|
|
return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory2.createUniqueName(externalHelpersModuleNameText));
|
|
}
|
|
}
|
|
}
|
|
function getLocalNameForExternalImport(factory2, node, sourceFile) {
|
|
const namespaceDeclaration = getNamespaceDeclarationNode(node);
|
|
if (namespaceDeclaration && !isDefaultImport(node) && !isExportNamespaceAsDefaultDeclaration(node)) {
|
|
const name = namespaceDeclaration.name;
|
|
return isGeneratedIdentifier(name) ? name : factory2.createIdentifier(getSourceTextOfNodeFromSourceFile(sourceFile, name) || idText(name));
|
|
}
|
|
if (node.kind === 269 /* ImportDeclaration */ && node.importClause) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
if (node.kind === 275 /* ExportDeclaration */ && node.moduleSpecifier) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExternalModuleNameLiteral(factory2, importNode, sourceFile, host, resolver, compilerOptions) {
|
|
const moduleName = getExternalModuleName(importNode);
|
|
if (moduleName && isStringLiteral(moduleName)) {
|
|
return tryGetModuleNameFromDeclaration(importNode, host, factory2, resolver, compilerOptions) || tryRenameExternalModule(factory2, moduleName, sourceFile) || factory2.cloneNode(moduleName);
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryRenameExternalModule(factory2, moduleName, sourceFile) {
|
|
const rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text);
|
|
return rename ? factory2.createStringLiteral(rename) : void 0;
|
|
}
|
|
function tryGetModuleNameFromFile(factory2, file, host, options) {
|
|
if (!file) {
|
|
return void 0;
|
|
}
|
|
if (file.moduleName) {
|
|
return factory2.createStringLiteral(file.moduleName);
|
|
}
|
|
if (!file.isDeclarationFile && outFile(options)) {
|
|
return factory2.createStringLiteral(getExternalModuleNameFromPath(host, file.fileName));
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetModuleNameFromDeclaration(declaration, host, factory2, resolver, compilerOptions) {
|
|
return tryGetModuleNameFromFile(factory2, resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
|
|
}
|
|
function getInitializerOfBindingOrAssignmentElement(bindingElement) {
|
|
if (isDeclarationBindingElement(bindingElement)) {
|
|
return bindingElement.initializer;
|
|
}
|
|
if (isPropertyAssignment(bindingElement)) {
|
|
const initializer = bindingElement.initializer;
|
|
return isAssignmentExpression(initializer, true) ? initializer.right : void 0;
|
|
}
|
|
if (isShorthandPropertyAssignment(bindingElement)) {
|
|
return bindingElement.objectAssignmentInitializer;
|
|
}
|
|
if (isAssignmentExpression(bindingElement, true)) {
|
|
return bindingElement.right;
|
|
}
|
|
if (isSpreadElement(bindingElement)) {
|
|
return getInitializerOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
}
|
|
function getTargetOfBindingOrAssignmentElement(bindingElement) {
|
|
if (isDeclarationBindingElement(bindingElement)) {
|
|
return bindingElement.name;
|
|
}
|
|
if (isObjectLiteralElementLike(bindingElement)) {
|
|
switch (bindingElement.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.initializer);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return bindingElement.name;
|
|
case 301 /* SpreadAssignment */:
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (isAssignmentExpression(bindingElement, true)) {
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.left);
|
|
}
|
|
if (isSpreadElement(bindingElement)) {
|
|
return getTargetOfBindingOrAssignmentElement(bindingElement.expression);
|
|
}
|
|
return bindingElement;
|
|
}
|
|
function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
return bindingElement.dotDotDotToken;
|
|
case 227 /* SpreadElement */:
|
|
case 301 /* SpreadAssignment */:
|
|
return bindingElement;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPropertyNameOfBindingOrAssignmentElement(bindingElement) {
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement);
|
|
Debug.assert(!!propertyName || isSpreadAssignment(bindingElement), "Invalid property name for binding element.");
|
|
return propertyName;
|
|
}
|
|
function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) {
|
|
switch (bindingElement.kind) {
|
|
case 205 /* BindingElement */:
|
|
if (bindingElement.propertyName) {
|
|
const propertyName = bindingElement.propertyName;
|
|
if (isPrivateIdentifier(propertyName)) {
|
|
return Debug.failBadSyntaxKind(propertyName);
|
|
}
|
|
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) ? propertyName.expression : propertyName;
|
|
}
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
if (bindingElement.name) {
|
|
const propertyName = bindingElement.name;
|
|
if (isPrivateIdentifier(propertyName)) {
|
|
return Debug.failBadSyntaxKind(propertyName);
|
|
}
|
|
return isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) ? propertyName.expression : propertyName;
|
|
}
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
if (bindingElement.name && isPrivateIdentifier(bindingElement.name)) {
|
|
return Debug.failBadSyntaxKind(bindingElement.name);
|
|
}
|
|
return bindingElement.name;
|
|
}
|
|
const target = getTargetOfBindingOrAssignmentElement(bindingElement);
|
|
if (target && isPropertyName(target)) {
|
|
return target;
|
|
}
|
|
}
|
|
function isStringOrNumericLiteral(node) {
|
|
const kind = node.kind;
|
|
return kind === 10 /* StringLiteral */ || kind === 8 /* NumericLiteral */;
|
|
}
|
|
function getElementsOfBindingOrAssignmentPattern(name) {
|
|
switch (name.kind) {
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return name.elements;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return name.properties;
|
|
}
|
|
}
|
|
function getJSDocTypeAliasName(fullName) {
|
|
if (fullName) {
|
|
let rightNode = fullName;
|
|
while (true) {
|
|
if (isIdentifier(rightNode) || !rightNode.body) {
|
|
return isIdentifier(rightNode) ? rightNode : rightNode.name;
|
|
}
|
|
rightNode = rightNode.body;
|
|
}
|
|
}
|
|
}
|
|
function canHaveIllegalType(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function canHaveIllegalTypeParameters(node) {
|
|
const kind = node.kind;
|
|
return kind === 173 /* Constructor */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function canHaveIllegalDecorators(node) {
|
|
const kind = node.kind;
|
|
return kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 259 /* FunctionDeclaration */ || kind === 173 /* Constructor */ || kind === 178 /* IndexSignature */ || kind === 172 /* ClassStaticBlockDeclaration */ || kind === 279 /* MissingDeclaration */ || kind === 240 /* VariableStatement */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 267 /* NamespaceExportDeclaration */ || kind === 275 /* ExportDeclaration */ || kind === 274 /* ExportAssignment */;
|
|
}
|
|
function canHaveIllegalModifiers(node) {
|
|
const kind = node.kind;
|
|
return kind === 172 /* ClassStaticBlockDeclaration */ || kind === 299 /* PropertyAssignment */ || kind === 300 /* ShorthandPropertyAssignment */ || kind === 181 /* FunctionType */ || kind === 279 /* MissingDeclaration */ || kind === 267 /* NamespaceExportDeclaration */;
|
|
}
|
|
var isTypeNodeOrTypeParameterDeclaration = or(isTypeNode, isTypeParameterDeclaration);
|
|
var isQuestionOrExclamationToken = or(isQuestionToken, isExclamationToken);
|
|
var isIdentifierOrThisTypeNode = or(isIdentifier, isThisTypeNode);
|
|
var isReadonlyKeywordOrPlusOrMinusToken = or(isReadonlyKeyword, isPlusToken, isMinusToken);
|
|
var isQuestionOrPlusOrMinusToken = or(isQuestionToken, isPlusToken, isMinusToken);
|
|
var isModuleName = or(isIdentifier, isStringLiteral);
|
|
function isLiteralTypeLikeExpression(node) {
|
|
const kind = node.kind;
|
|
return kind === 104 /* NullKeyword */ || kind === 110 /* TrueKeyword */ || kind === 95 /* FalseKeyword */ || isLiteralExpression(node) || isPrefixUnaryExpression(node);
|
|
}
|
|
function isExponentiationOperator(kind) {
|
|
return kind === 42 /* AsteriskAsteriskToken */;
|
|
}
|
|
function isMultiplicativeOperator(kind) {
|
|
return kind === 41 /* AsteriskToken */ || kind === 43 /* SlashToken */ || kind === 44 /* PercentToken */;
|
|
}
|
|
function isMultiplicativeOperatorOrHigher(kind) {
|
|
return isExponentiationOperator(kind) || isMultiplicativeOperator(kind);
|
|
}
|
|
function isAdditiveOperator(kind) {
|
|
return kind === 39 /* PlusToken */ || kind === 40 /* MinusToken */;
|
|
}
|
|
function isAdditiveOperatorOrHigher(kind) {
|
|
return isAdditiveOperator(kind) || isMultiplicativeOperatorOrHigher(kind);
|
|
}
|
|
function isShiftOperator(kind) {
|
|
return kind === 47 /* LessThanLessThanToken */ || kind === 48 /* GreaterThanGreaterThanToken */ || kind === 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
}
|
|
function isShiftOperatorOrHigher(kind) {
|
|
return isShiftOperator(kind) || isAdditiveOperatorOrHigher(kind);
|
|
}
|
|
function isRelationalOperator(kind) {
|
|
return kind === 29 /* LessThanToken */ || kind === 32 /* LessThanEqualsToken */ || kind === 31 /* GreaterThanToken */ || kind === 33 /* GreaterThanEqualsToken */ || kind === 102 /* InstanceOfKeyword */ || kind === 101 /* InKeyword */;
|
|
}
|
|
function isRelationalOperatorOrHigher(kind) {
|
|
return isRelationalOperator(kind) || isShiftOperatorOrHigher(kind);
|
|
}
|
|
function isEqualityOperator(kind) {
|
|
return kind === 34 /* EqualsEqualsToken */ || kind === 36 /* EqualsEqualsEqualsToken */ || kind === 35 /* ExclamationEqualsToken */ || kind === 37 /* ExclamationEqualsEqualsToken */;
|
|
}
|
|
function isEqualityOperatorOrHigher(kind) {
|
|
return isEqualityOperator(kind) || isRelationalOperatorOrHigher(kind);
|
|
}
|
|
function isBitwiseOperator(kind) {
|
|
return kind === 50 /* AmpersandToken */ || kind === 51 /* BarToken */ || kind === 52 /* CaretToken */;
|
|
}
|
|
function isBitwiseOperatorOrHigher(kind) {
|
|
return isBitwiseOperator(kind) || isEqualityOperatorOrHigher(kind);
|
|
}
|
|
function isLogicalOperator2(kind) {
|
|
return kind === 55 /* AmpersandAmpersandToken */ || kind === 56 /* BarBarToken */;
|
|
}
|
|
function isLogicalOperatorOrHigher(kind) {
|
|
return isLogicalOperator2(kind) || isBitwiseOperatorOrHigher(kind);
|
|
}
|
|
function isAssignmentOperatorOrHigher(kind) {
|
|
return kind === 60 /* QuestionQuestionToken */ || isLogicalOperatorOrHigher(kind) || isAssignmentOperator(kind);
|
|
}
|
|
function isBinaryOperator(kind) {
|
|
return isAssignmentOperatorOrHigher(kind) || kind === 27 /* CommaToken */;
|
|
}
|
|
function isBinaryOperatorToken(node) {
|
|
return isBinaryOperator(node.kind);
|
|
}
|
|
var BinaryExpressionState;
|
|
((BinaryExpressionState2) => {
|
|
function enter(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, outerState) {
|
|
const prevUserState = stackIndex > 0 ? userStateStack[stackIndex - 1] : void 0;
|
|
Debug.assertEqual(stateStack[stackIndex], enter);
|
|
userStateStack[stackIndex] = machine.onEnter(nodeStack[stackIndex], prevUserState, outerState);
|
|
stateStack[stackIndex] = nextState(machine, enter);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.enter = enter;
|
|
function left(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], left);
|
|
Debug.assertIsDefined(machine.onLeft);
|
|
stateStack[stackIndex] = nextState(machine, left);
|
|
const nextNode = machine.onLeft(nodeStack[stackIndex].left, userStateStack[stackIndex], nodeStack[stackIndex]);
|
|
if (nextNode) {
|
|
checkCircularity(stackIndex, nodeStack, nextNode);
|
|
return pushStack(stackIndex, stateStack, nodeStack, userStateStack, nextNode);
|
|
}
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.left = left;
|
|
function operator(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], operator);
|
|
Debug.assertIsDefined(machine.onOperator);
|
|
stateStack[stackIndex] = nextState(machine, operator);
|
|
machine.onOperator(nodeStack[stackIndex].operatorToken, userStateStack[stackIndex], nodeStack[stackIndex]);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.operator = operator;
|
|
function right(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], right);
|
|
Debug.assertIsDefined(machine.onRight);
|
|
stateStack[stackIndex] = nextState(machine, right);
|
|
const nextNode = machine.onRight(nodeStack[stackIndex].right, userStateStack[stackIndex], nodeStack[stackIndex]);
|
|
if (nextNode) {
|
|
checkCircularity(stackIndex, nodeStack, nextNode);
|
|
return pushStack(stackIndex, stateStack, nodeStack, userStateStack, nextNode);
|
|
}
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.right = right;
|
|
function exit(machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], exit);
|
|
stateStack[stackIndex] = nextState(machine, exit);
|
|
const result = machine.onExit(nodeStack[stackIndex], userStateStack[stackIndex]);
|
|
if (stackIndex > 0) {
|
|
stackIndex--;
|
|
if (machine.foldState) {
|
|
const side = stateStack[stackIndex] === exit ? "right" : "left";
|
|
userStateStack[stackIndex] = machine.foldState(userStateStack[stackIndex], result, side);
|
|
}
|
|
} else {
|
|
resultHolder.value = result;
|
|
}
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.exit = exit;
|
|
function done(_machine, stackIndex, stateStack, _nodeStack, _userStateStack, _resultHolder, _outerState) {
|
|
Debug.assertEqual(stateStack[stackIndex], done);
|
|
return stackIndex;
|
|
}
|
|
BinaryExpressionState2.done = done;
|
|
function nextState(machine, currentState) {
|
|
switch (currentState) {
|
|
case enter:
|
|
if (machine.onLeft)
|
|
return left;
|
|
case left:
|
|
if (machine.onOperator)
|
|
return operator;
|
|
case operator:
|
|
if (machine.onRight)
|
|
return right;
|
|
case right:
|
|
return exit;
|
|
case exit:
|
|
return done;
|
|
case done:
|
|
return done;
|
|
default:
|
|
Debug.fail("Invalid state");
|
|
}
|
|
}
|
|
BinaryExpressionState2.nextState = nextState;
|
|
function pushStack(stackIndex, stateStack, nodeStack, userStateStack, node) {
|
|
stackIndex++;
|
|
stateStack[stackIndex] = enter;
|
|
nodeStack[stackIndex] = node;
|
|
userStateStack[stackIndex] = void 0;
|
|
return stackIndex;
|
|
}
|
|
function checkCircularity(stackIndex, nodeStack, node) {
|
|
if (Debug.shouldAssert(2 /* Aggressive */)) {
|
|
while (stackIndex >= 0) {
|
|
Debug.assert(nodeStack[stackIndex] !== node, "Circular traversal detected.");
|
|
stackIndex--;
|
|
}
|
|
}
|
|
}
|
|
})(BinaryExpressionState || (BinaryExpressionState = {}));
|
|
var BinaryExpressionStateMachine = class {
|
|
constructor(onEnter, onLeft, onOperator, onRight, onExit, foldState) {
|
|
this.onEnter = onEnter;
|
|
this.onLeft = onLeft;
|
|
this.onOperator = onOperator;
|
|
this.onRight = onRight;
|
|
this.onExit = onExit;
|
|
this.foldState = foldState;
|
|
}
|
|
};
|
|
function createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState) {
|
|
const machine = new BinaryExpressionStateMachine(onEnter, onLeft, onOperator, onRight, onExit, foldState);
|
|
return trampoline;
|
|
function trampoline(node, outerState) {
|
|
const resultHolder = { value: void 0 };
|
|
const stateStack = [BinaryExpressionState.enter];
|
|
const nodeStack = [node];
|
|
const userStateStack = [void 0];
|
|
let stackIndex = 0;
|
|
while (stateStack[stackIndex] !== BinaryExpressionState.done) {
|
|
stackIndex = stateStack[stackIndex](machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, outerState);
|
|
}
|
|
Debug.assertEqual(stackIndex, 0);
|
|
return resultHolder.value;
|
|
}
|
|
}
|
|
function elideNodes(factory2, nodes) {
|
|
if (nodes === void 0)
|
|
return void 0;
|
|
if (nodes.length === 0)
|
|
return nodes;
|
|
return setTextRange(factory2.createNodeArray([], nodes.hasTrailingComma), nodes);
|
|
}
|
|
function getNodeForGeneratedName(name) {
|
|
if (name.autoGenerateFlags & 4 /* Node */) {
|
|
const autoGenerateId = name.autoGenerateId;
|
|
let node = name;
|
|
let original = node.original;
|
|
while (original) {
|
|
node = original;
|
|
if (isMemberName(node) && !!(node.autoGenerateFlags & 4 /* Node */) && node.autoGenerateId !== autoGenerateId) {
|
|
break;
|
|
}
|
|
original = node.original;
|
|
}
|
|
return node;
|
|
}
|
|
return name;
|
|
}
|
|
function formatGeneratedNamePart(part, generateName) {
|
|
return typeof part === "object" ? formatGeneratedName(false, part.prefix, part.node, part.suffix, generateName) : typeof part === "string" ? part.length > 0 && part.charCodeAt(0) === 35 /* hash */ ? part.slice(1) : part : "";
|
|
}
|
|
function formatIdentifier(name, generateName) {
|
|
return typeof name === "string" ? name : formatIdentifierWorker(name, Debug.checkDefined(generateName));
|
|
}
|
|
function formatIdentifierWorker(node, generateName) {
|
|
return isGeneratedPrivateIdentifier(node) ? generateName(node).slice(1) : isGeneratedIdentifier(node) ? generateName(node) : isPrivateIdentifier(node) ? node.escapedText.slice(1) : idText(node);
|
|
}
|
|
function formatGeneratedName(privateName, prefix, baseName, suffix, generateName) {
|
|
prefix = formatGeneratedNamePart(prefix, generateName);
|
|
suffix = formatGeneratedNamePart(suffix, generateName);
|
|
baseName = formatIdentifier(baseName, generateName);
|
|
return `${privateName ? "#" : ""}${prefix}${baseName}${suffix}`;
|
|
}
|
|
function createAccessorPropertyBackingField(factory2, node, modifiers, initializer) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
modifiers,
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage"),
|
|
void 0,
|
|
void 0,
|
|
initializer
|
|
);
|
|
}
|
|
function createAccessorPropertyGetRedirector(factory2, node, modifiers, name) {
|
|
return factory2.createGetAccessorDeclaration(
|
|
modifiers,
|
|
name,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock([
|
|
factory2.createReturnStatement(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage")
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function createAccessorPropertySetRedirector(factory2, node, modifiers, name) {
|
|
return factory2.createSetAccessorDeclaration(
|
|
modifiers,
|
|
name,
|
|
[factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"value"
|
|
)],
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
factory2.getGeneratedPrivateNameForNode(node.name, void 0, "_accessor_storage")
|
|
),
|
|
factory2.createIdentifier("value")
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
|
|
// src/compiler/factory/utilitiesPublic.ts
|
|
function setTextRange(range, location2) {
|
|
return location2 ? setTextRangePosEnd(range, location2.pos, location2.end) : range;
|
|
}
|
|
function canHaveModifiers(node) {
|
|
const kind = node.kind;
|
|
return kind === 165 /* TypeParameter */ || kind === 166 /* Parameter */ || kind === 168 /* PropertySignature */ || kind === 169 /* PropertyDeclaration */ || kind === 170 /* MethodSignature */ || kind === 171 /* MethodDeclaration */ || kind === 173 /* Constructor */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 178 /* IndexSignature */ || kind === 182 /* ConstructorType */ || kind === 215 /* FunctionExpression */ || kind === 216 /* ArrowFunction */ || kind === 228 /* ClassExpression */ || kind === 240 /* VariableStatement */ || kind === 259 /* FunctionDeclaration */ || kind === 260 /* ClassDeclaration */ || kind === 261 /* InterfaceDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 263 /* EnumDeclaration */ || kind === 264 /* ModuleDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 274 /* ExportAssignment */ || kind === 275 /* ExportDeclaration */;
|
|
}
|
|
function canHaveDecorators(node) {
|
|
const kind = node.kind;
|
|
return kind === 166 /* Parameter */ || kind === 169 /* PropertyDeclaration */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 228 /* ClassExpression */ || kind === 260 /* ClassDeclaration */;
|
|
}
|
|
|
|
// src/compiler/parser.ts
|
|
var NodeConstructor;
|
|
var TokenConstructor;
|
|
var IdentifierConstructor;
|
|
var PrivateIdentifierConstructor;
|
|
var SourceFileConstructor;
|
|
var parseBaseNodeFactory = {
|
|
createBaseSourceFileNode: (kind) => new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, -1, -1),
|
|
createBaseIdentifierNode: (kind) => new (IdentifierConstructor || (IdentifierConstructor = objectAllocator.getIdentifierConstructor()))(kind, -1, -1),
|
|
createBasePrivateIdentifierNode: (kind) => new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1),
|
|
createBaseTokenNode: (kind) => new (TokenConstructor || (TokenConstructor = objectAllocator.getTokenConstructor()))(kind, -1, -1),
|
|
createBaseNode: (kind) => new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, -1, -1)
|
|
};
|
|
var parseNodeFactory = createNodeFactory(1 /* NoParenthesizerRules */, parseBaseNodeFactory);
|
|
function visitNode2(cbNode, node) {
|
|
return node && cbNode(node);
|
|
}
|
|
function visitNodes(cbNode, cbNodes, nodes) {
|
|
if (nodes) {
|
|
if (cbNodes) {
|
|
return cbNodes(nodes);
|
|
}
|
|
for (const node of nodes) {
|
|
const result = cbNode(node);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isJSDocLikeText(text, start2) {
|
|
return text.charCodeAt(start2 + 1) === 42 /* asterisk */ && text.charCodeAt(start2 + 2) === 42 /* asterisk */ && text.charCodeAt(start2 + 3) !== 47 /* slash */;
|
|
}
|
|
function isFileProbablyExternalModule(sourceFile) {
|
|
return forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) || getImportMetaIfNecessary(sourceFile);
|
|
}
|
|
function isAnExternalModuleIndicatorNode(node) {
|
|
return canHaveModifiers(node) && hasModifierOfKind(node, 93 /* ExportKeyword */) || isImportEqualsDeclaration(node) && isExternalModuleReference(node.moduleReference) || isImportDeclaration(node) || isExportAssignment(node) || isExportDeclaration(node) ? node : void 0;
|
|
}
|
|
function getImportMetaIfNecessary(sourceFile) {
|
|
return sourceFile.flags & 4194304 /* PossiblyContainsImportMeta */ ? walkTreeForImportMeta(sourceFile) : void 0;
|
|
}
|
|
function walkTreeForImportMeta(node) {
|
|
return isImportMeta2(node) ? node : forEachChild(node, walkTreeForImportMeta);
|
|
}
|
|
function hasModifierOfKind(node, kind) {
|
|
return some(node.modifiers, (m) => m.kind === kind);
|
|
}
|
|
function isImportMeta2(node) {
|
|
return isMetaProperty(node) && node.keywordToken === 100 /* ImportKeyword */ && node.name.escapedText === "meta";
|
|
}
|
|
var forEachChildTable = {
|
|
[163 /* QualifiedName */]: function forEachChildInQualifiedName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.right);
|
|
},
|
|
[165 /* TypeParameter */]: function forEachChildInTypeParameter(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.constraint) || visitNode2(cbNode, node.default) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[300 /* ShorthandPropertyAssignment */]: function forEachChildInShorthandPropertyAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.equalsToken) || visitNode2(cbNode, node.objectAssignmentInitializer);
|
|
},
|
|
[301 /* SpreadAssignment */]: function forEachChildInSpreadAssignment(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[166 /* Parameter */]: function forEachChildInParameter(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[169 /* PropertyDeclaration */]: function forEachChildInPropertyDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[168 /* PropertySignature */]: function forEachChildInPropertySignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[299 /* PropertyAssignment */]: function forEachChildInPropertyAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[257 /* VariableDeclaration */]: function forEachChildInVariableDeclaration(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.exclamationToken) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[205 /* BindingElement */]: function forEachChildInBindingElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.propertyName) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[178 /* IndexSignature */]: function forEachChildInIndexSignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[182 /* ConstructorType */]: function forEachChildInConstructorType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[181 /* FunctionType */]: function forEachChildInFunctionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[176 /* CallSignature */]: forEachChildInCallOrConstructSignature,
|
|
[177 /* ConstructSignature */]: forEachChildInCallOrConstructSignature,
|
|
[171 /* MethodDeclaration */]: function forEachChildInMethodDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.exclamationToken) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[170 /* MethodSignature */]: function forEachChildInMethodSignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[173 /* Constructor */]: function forEachChildInConstructor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[174 /* GetAccessor */]: function forEachChildInGetAccessor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[175 /* SetAccessor */]: function forEachChildInSetAccessor(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[259 /* FunctionDeclaration */]: function forEachChildInFunctionDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[215 /* FunctionExpression */]: function forEachChildInFunctionExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.body);
|
|
},
|
|
[216 /* ArrowFunction */]: function forEachChildInArrowFunction(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type) || visitNode2(cbNode, node.equalsGreaterThanToken) || visitNode2(cbNode, node.body);
|
|
},
|
|
[172 /* ClassStaticBlockDeclaration */]: function forEachChildInClassStaticBlockDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.body);
|
|
},
|
|
[180 /* TypeReference */]: function forEachChildInTypeReference(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.typeName) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[179 /* TypePredicate */]: function forEachChildInTypePredicate(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.assertsModifier) || visitNode2(cbNode, node.parameterName) || visitNode2(cbNode, node.type);
|
|
},
|
|
[183 /* TypeQuery */]: function forEachChildInTypeQuery(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.exprName) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[184 /* TypeLiteral */]: function forEachChildInTypeLiteral(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[185 /* ArrayType */]: function forEachChildInArrayType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.elementType);
|
|
},
|
|
[186 /* TupleType */]: function forEachChildInTupleType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[189 /* UnionType */]: forEachChildInUnionOrIntersectionType,
|
|
[190 /* IntersectionType */]: forEachChildInUnionOrIntersectionType,
|
|
[191 /* ConditionalType */]: function forEachChildInConditionalType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.checkType) || visitNode2(cbNode, node.extendsType) || visitNode2(cbNode, node.trueType) || visitNode2(cbNode, node.falseType);
|
|
},
|
|
[192 /* InferType */]: function forEachChildInInferType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.typeParameter);
|
|
},
|
|
[202 /* ImportType */]: function forEachChildInImportType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.argument) || visitNode2(cbNode, node.assertions) || visitNode2(cbNode, node.qualifier) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[298 /* ImportTypeAssertionContainer */]: function forEachChildInImportTypeAssertionContainer(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[193 /* ParenthesizedType */]: forEachChildInParenthesizedTypeOrTypeOperator,
|
|
[195 /* TypeOperator */]: forEachChildInParenthesizedTypeOrTypeOperator,
|
|
[196 /* IndexedAccessType */]: function forEachChildInIndexedAccessType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.objectType) || visitNode2(cbNode, node.indexType);
|
|
},
|
|
[197 /* MappedType */]: function forEachChildInMappedType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.readonlyToken) || visitNode2(cbNode, node.typeParameter) || visitNode2(cbNode, node.nameType) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[198 /* LiteralType */]: function forEachChildInLiteralType(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.literal);
|
|
},
|
|
[199 /* NamedTupleMember */]: function forEachChildInNamedTupleMember(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.type);
|
|
},
|
|
[203 /* ObjectBindingPattern */]: forEachChildInObjectOrArrayBindingPattern,
|
|
[204 /* ArrayBindingPattern */]: forEachChildInObjectOrArrayBindingPattern,
|
|
[206 /* ArrayLiteralExpression */]: function forEachChildInArrayLiteralExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[207 /* ObjectLiteralExpression */]: function forEachChildInObjectLiteralExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.properties);
|
|
},
|
|
[208 /* PropertyAccessExpression */]: function forEachChildInPropertyAccessExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.questionDotToken) || visitNode2(cbNode, node.name);
|
|
},
|
|
[209 /* ElementAccessExpression */]: function forEachChildInElementAccessExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.questionDotToken) || visitNode2(cbNode, node.argumentExpression);
|
|
},
|
|
[210 /* CallExpression */]: forEachChildInCallOrNewExpression,
|
|
[211 /* NewExpression */]: forEachChildInCallOrNewExpression,
|
|
[212 /* TaggedTemplateExpression */]: function forEachChildInTaggedTemplateExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tag) || visitNode2(cbNode, node.questionDotToken) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode2(cbNode, node.template);
|
|
},
|
|
[213 /* TypeAssertionExpression */]: function forEachChildInTypeAssertionExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[214 /* ParenthesizedExpression */]: function forEachChildInParenthesizedExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[217 /* DeleteExpression */]: function forEachChildInDeleteExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[218 /* TypeOfExpression */]: function forEachChildInTypeOfExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[219 /* VoidExpression */]: function forEachChildInVoidExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[221 /* PrefixUnaryExpression */]: function forEachChildInPrefixUnaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.operand);
|
|
},
|
|
[226 /* YieldExpression */]: function forEachChildInYieldExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.asteriskToken) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[220 /* AwaitExpression */]: function forEachChildInAwaitExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[222 /* PostfixUnaryExpression */]: function forEachChildInPostfixUnaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.operand);
|
|
},
|
|
[223 /* BinaryExpression */]: function forEachChildInBinaryExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.operatorToken) || visitNode2(cbNode, node.right);
|
|
},
|
|
[231 /* AsExpression */]: function forEachChildInAsExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.type);
|
|
},
|
|
[232 /* NonNullExpression */]: function forEachChildInNonNullExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[235 /* SatisfiesExpression */]: function forEachChildInSatisfiesExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.type);
|
|
},
|
|
[233 /* MetaProperty */]: function forEachChildInMetaProperty(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[224 /* ConditionalExpression */]: function forEachChildInConditionalExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.condition) || visitNode2(cbNode, node.questionToken) || visitNode2(cbNode, node.whenTrue) || visitNode2(cbNode, node.colonToken) || visitNode2(cbNode, node.whenFalse);
|
|
},
|
|
[227 /* SpreadElement */]: function forEachChildInSpreadElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[238 /* Block */]: forEachChildInBlock,
|
|
[265 /* ModuleBlock */]: forEachChildInBlock,
|
|
[308 /* SourceFile */]: function forEachChildInSourceFile(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.statements) || visitNode2(cbNode, node.endOfFileToken);
|
|
},
|
|
[240 /* VariableStatement */]: function forEachChildInVariableStatement(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.declarationList);
|
|
},
|
|
[258 /* VariableDeclarationList */]: function forEachChildInVariableDeclarationList(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.declarations);
|
|
},
|
|
[241 /* ExpressionStatement */]: function forEachChildInExpressionStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[242 /* IfStatement */]: function forEachChildInIfStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.thenStatement) || visitNode2(cbNode, node.elseStatement);
|
|
},
|
|
[243 /* DoStatement */]: function forEachChildInDoStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.statement) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[244 /* WhileStatement */]: function forEachChildInWhileStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[245 /* ForStatement */]: function forEachChildInForStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.condition) || visitNode2(cbNode, node.incrementor) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[246 /* ForInStatement */]: function forEachChildInForInStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[247 /* ForOfStatement */]: function forEachChildInForOfStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.awaitModifier) || visitNode2(cbNode, node.initializer) || visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[248 /* ContinueStatement */]: forEachChildInContinueOrBreakStatement,
|
|
[249 /* BreakStatement */]: forEachChildInContinueOrBreakStatement,
|
|
[250 /* ReturnStatement */]: function forEachChildInReturnStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[251 /* WithStatement */]: function forEachChildInWithStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[252 /* SwitchStatement */]: function forEachChildInSwitchStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.caseBlock);
|
|
},
|
|
[266 /* CaseBlock */]: function forEachChildInCaseBlock(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.clauses);
|
|
},
|
|
[292 /* CaseClause */]: function forEachChildInCaseClause(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.statements);
|
|
},
|
|
[293 /* DefaultClause */]: function forEachChildInDefaultClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.statements);
|
|
},
|
|
[253 /* LabeledStatement */]: function forEachChildInLabeledStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.label) || visitNode2(cbNode, node.statement);
|
|
},
|
|
[254 /* ThrowStatement */]: function forEachChildInThrowStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[255 /* TryStatement */]: function forEachChildInTryStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.tryBlock) || visitNode2(cbNode, node.catchClause) || visitNode2(cbNode, node.finallyBlock);
|
|
},
|
|
[295 /* CatchClause */]: function forEachChildInCatchClause(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.variableDeclaration) || visitNode2(cbNode, node.block);
|
|
},
|
|
[167 /* Decorator */]: function forEachChildInDecorator(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[260 /* ClassDeclaration */]: forEachChildInClassDeclarationOrExpression,
|
|
[228 /* ClassExpression */]: forEachChildInClassDeclarationOrExpression,
|
|
[261 /* InterfaceDeclaration */]: function forEachChildInInterfaceDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.heritageClauses) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[262 /* TypeAliasDeclaration */]: function forEachChildInTypeAliasDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[263 /* EnumDeclaration */]: function forEachChildInEnumDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.members);
|
|
},
|
|
[302 /* EnumMember */]: function forEachChildInEnumMember(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[264 /* ModuleDeclaration */]: function forEachChildInModuleDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.body);
|
|
},
|
|
[268 /* ImportEqualsDeclaration */]: function forEachChildInImportEqualsDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNode2(cbNode, node.moduleReference);
|
|
},
|
|
[269 /* ImportDeclaration */]: function forEachChildInImportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.importClause) || visitNode2(cbNode, node.moduleSpecifier) || visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[270 /* ImportClause */]: function forEachChildInImportClause(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.namedBindings);
|
|
},
|
|
[296 /* AssertClause */]: function forEachChildInAssertClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[297 /* AssertEntry */]: function forEachChildInAssertEntry(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.value);
|
|
},
|
|
[267 /* NamespaceExportDeclaration */]: function forEachChildInNamespaceExportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNode2(cbNode, node.name);
|
|
},
|
|
[271 /* NamespaceImport */]: function forEachChildInNamespaceImport(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[277 /* NamespaceExport */]: function forEachChildInNamespaceExport(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[272 /* NamedImports */]: forEachChildInNamedImportsOrExports,
|
|
[276 /* NamedExports */]: forEachChildInNamedImportsOrExports,
|
|
[275 /* ExportDeclaration */]: function forEachChildInExportDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.exportClause) || visitNode2(cbNode, node.moduleSpecifier) || visitNode2(cbNode, node.assertClause);
|
|
},
|
|
[273 /* ImportSpecifier */]: forEachChildInImportOrExportSpecifier,
|
|
[278 /* ExportSpecifier */]: forEachChildInImportOrExportSpecifier,
|
|
[274 /* ExportAssignment */]: function forEachChildInExportAssignment(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[225 /* TemplateExpression */]: function forEachChildInTemplateExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
|
|
},
|
|
[236 /* TemplateSpan */]: function forEachChildInTemplateSpan(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.literal);
|
|
},
|
|
[200 /* TemplateLiteralType */]: function forEachChildInTemplateLiteralType(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.head) || visitNodes(cbNode, cbNodes, node.templateSpans);
|
|
},
|
|
[201 /* TemplateLiteralTypeSpan */]: function forEachChildInTemplateLiteralTypeSpan(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type) || visitNode2(cbNode, node.literal);
|
|
},
|
|
[164 /* ComputedPropertyName */]: function forEachChildInComputedPropertyName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[294 /* HeritageClause */]: function forEachChildInHeritageClause(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.types);
|
|
},
|
|
[230 /* ExpressionWithTypeArguments */]: function forEachChildInExpressionWithTypeArguments(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNodes(cbNode, cbNodes, node.typeArguments);
|
|
},
|
|
[280 /* ExternalModuleReference */]: function forEachChildInExternalModuleReference(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[279 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.illegalDecorators) || visitNodes(cbNode, cbNodes, node.modifiers);
|
|
},
|
|
[354 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
},
|
|
[281 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.openingElement) || visitNodes(cbNode, cbNodes, node.children) || visitNode2(cbNode, node.closingElement);
|
|
},
|
|
[285 /* JsxFragment */]: function forEachChildInJsxFragment(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.openingFragment) || visitNodes(cbNode, cbNodes, node.children) || visitNode2(cbNode, node.closingFragment);
|
|
},
|
|
[282 /* JsxSelfClosingElement */]: forEachChildInJsxOpeningOrSelfClosingElement,
|
|
[283 /* JsxOpeningElement */]: forEachChildInJsxOpeningOrSelfClosingElement,
|
|
[289 /* JsxAttributes */]: function forEachChildInJsxAttributes(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.properties);
|
|
},
|
|
[288 /* JsxAttribute */]: function forEachChildInJsxAttribute(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name) || visitNode2(cbNode, node.initializer);
|
|
},
|
|
[290 /* JsxSpreadAttribute */]: function forEachChildInJsxSpreadAttribute(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
},
|
|
[291 /* JsxExpression */]: function forEachChildInJsxExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.dotDotDotToken) || visitNode2(cbNode, node.expression);
|
|
},
|
|
[284 /* JsxClosingElement */]: function forEachChildInJsxClosingElement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.tagName);
|
|
},
|
|
[187 /* OptionalType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[188 /* RestType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[312 /* JSDocTypeExpression */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[318 /* JSDocNonNullableType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[317 /* JSDocNullableType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[319 /* JSDocOptionalType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[321 /* JSDocVariadicType */]: forEachChildInOptionalRestOrJSDocParameterModifier,
|
|
[320 /* JSDocFunctionType */]: function forEachChildInJSDocFunctionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
},
|
|
[323 /* JSDoc */]: function forEachChildInJSDoc(node, cbNode, cbNodes) {
|
|
return (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)) || visitNodes(cbNode, cbNodes, node.tags);
|
|
},
|
|
[349 /* JSDocSeeTag */]: function forEachChildInJSDocSeeTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.name) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[313 /* JSDocNameReference */]: function forEachChildInJSDocNameReference(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
},
|
|
[314 /* JSDocMemberName */]: function forEachChildInJSDocMemberName(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.left) || visitNode2(cbNode, node.right);
|
|
},
|
|
[343 /* JSDocParameterTag */]: forEachChildInJSDocParameterOrPropertyTag,
|
|
[350 /* JSDocPropertyTag */]: forEachChildInJSDocParameterOrPropertyTag,
|
|
[333 /* JSDocAuthorTag */]: function forEachChildInJSDocAuthorTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[332 /* JSDocImplementsTag */]: function forEachChildInJSDocImplementsTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.class) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[331 /* JSDocAugmentsTag */]: function forEachChildInJSDocAugmentsTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.class) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[347 /* JSDocTemplateTag */]: function forEachChildInJSDocTemplateTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.constraint) || visitNodes(cbNode, cbNodes, node.typeParameters) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[348 /* JSDocTypedefTag */]: function forEachChildInJSDocTypedefTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (node.typeExpression && node.typeExpression.kind === 312 /* JSDocTypeExpression */ ? visitNode2(cbNode, node.typeExpression) || visitNode2(cbNode, node.fullName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)) : visitNode2(cbNode, node.fullName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment)));
|
|
},
|
|
[341 /* JSDocCallbackTag */]: function forEachChildInJSDocCallbackTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.fullName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
},
|
|
[344 /* JSDocReturnTag */]: forEachChildInJSDocReturnTag,
|
|
[346 /* JSDocTypeTag */]: forEachChildInJSDocReturnTag,
|
|
[345 /* JSDocThisTag */]: forEachChildInJSDocReturnTag,
|
|
[342 /* JSDocEnumTag */]: forEachChildInJSDocReturnTag,
|
|
[326 /* JSDocSignature */]: function forEachChildInJSDocSignature(node, cbNode, _cbNodes) {
|
|
return forEach(node.typeParameters, cbNode) || forEach(node.parameters, cbNode) || visitNode2(cbNode, node.type);
|
|
},
|
|
[327 /* JSDocLink */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[328 /* JSDocLinkCode */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[329 /* JSDocLinkPlain */]: forEachChildInJSDocLinkCodeOrPlain,
|
|
[325 /* JSDocTypeLiteral */]: function forEachChildInJSDocTypeLiteral(node, cbNode, _cbNodes) {
|
|
return forEach(node.jsDocPropertyTags, cbNode);
|
|
},
|
|
[330 /* JSDocTag */]: forEachChildInJSDocTag,
|
|
[335 /* JSDocClassTag */]: forEachChildInJSDocTag,
|
|
[336 /* JSDocPublicTag */]: forEachChildInJSDocTag,
|
|
[337 /* JSDocPrivateTag */]: forEachChildInJSDocTag,
|
|
[338 /* JSDocProtectedTag */]: forEachChildInJSDocTag,
|
|
[339 /* JSDocReadonlyTag */]: forEachChildInJSDocTag,
|
|
[334 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag,
|
|
[340 /* JSDocOverrideTag */]: forEachChildInJSDocTag,
|
|
[353 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
|
|
};
|
|
function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.types);
|
|
}
|
|
function forEachChildInParenthesizedTypeOrTypeOperator(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInObjectOrArrayBindingPattern(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
}
|
|
function forEachChildInCallOrNewExpression(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.expression) || visitNode2(cbNode, node.questionDotToken) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNodes(cbNode, cbNodes, node.arguments);
|
|
}
|
|
function forEachChildInBlock(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.statements);
|
|
}
|
|
function forEachChildInContinueOrBreakStatement(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.label);
|
|
}
|
|
function forEachChildInClassDeclarationOrExpression(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.modifiers) || visitNode2(cbNode, node.name) || visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.heritageClauses) || visitNodes(cbNode, cbNodes, node.members);
|
|
}
|
|
function forEachChildInNamedImportsOrExports(node, cbNode, cbNodes) {
|
|
return visitNodes(cbNode, cbNodes, node.elements);
|
|
}
|
|
function forEachChildInImportOrExportSpecifier(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.propertyName) || visitNode2(cbNode, node.name);
|
|
}
|
|
function forEachChildInJsxOpeningOrSelfClosingElement(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNodes(cbNode, cbNodes, node.typeArguments) || visitNode2(cbNode, node.attributes);
|
|
}
|
|
function forEachChildInOptionalRestOrJSDocParameterModifier(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.type);
|
|
}
|
|
function forEachChildInJSDocParameterOrPropertyTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (node.isNameFirst ? visitNode2(cbNode, node.name) || visitNode2(cbNode, node.typeExpression) : visitNode2(cbNode, node.typeExpression) || visitNode2(cbNode, node.name)) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInJSDocReturnTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || visitNode2(cbNode, node.typeExpression) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInJSDocLinkCodeOrPlain(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.name);
|
|
}
|
|
function forEachChildInJSDocTag(node, cbNode, cbNodes) {
|
|
return visitNode2(cbNode, node.tagName) || (typeof node.comment === "string" ? void 0 : visitNodes(cbNode, cbNodes, node.comment));
|
|
}
|
|
function forEachChildInPartiallyEmittedExpression(node, cbNode, _cbNodes) {
|
|
return visitNode2(cbNode, node.expression);
|
|
}
|
|
function forEachChild(node, cbNode, cbNodes) {
|
|
if (node === void 0 || node.kind <= 162 /* LastToken */) {
|
|
return;
|
|
}
|
|
const fn = forEachChildTable[node.kind];
|
|
return fn === void 0 ? void 0 : fn(node, cbNode, cbNodes);
|
|
}
|
|
function forEachChildRecursively(rootNode, cbNode, cbNodes) {
|
|
const queue = gatherPossibleChildren(rootNode);
|
|
const parents = [];
|
|
while (parents.length < queue.length) {
|
|
parents.push(rootNode);
|
|
}
|
|
while (queue.length !== 0) {
|
|
const current = queue.pop();
|
|
const parent2 = parents.pop();
|
|
if (isArray(current)) {
|
|
if (cbNodes) {
|
|
const res = cbNodes(current, parent2);
|
|
if (res) {
|
|
if (res === "skip")
|
|
continue;
|
|
return res;
|
|
}
|
|
}
|
|
for (let i = current.length - 1; i >= 0; --i) {
|
|
queue.push(current[i]);
|
|
parents.push(parent2);
|
|
}
|
|
} else {
|
|
const res = cbNode(current, parent2);
|
|
if (res) {
|
|
if (res === "skip")
|
|
continue;
|
|
return res;
|
|
}
|
|
if (current.kind >= 163 /* FirstNode */) {
|
|
for (const child of gatherPossibleChildren(current)) {
|
|
queue.push(child);
|
|
parents.push(current);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function gatherPossibleChildren(node) {
|
|
const children = [];
|
|
forEachChild(node, addWorkItem, addWorkItem);
|
|
return children;
|
|
function addWorkItem(n) {
|
|
children.unshift(n);
|
|
}
|
|
}
|
|
function setExternalModuleIndicator(sourceFile) {
|
|
sourceFile.externalModuleIndicator = isFileProbablyExternalModule(sourceFile);
|
|
}
|
|
function createSourceFile(fileName, sourceText, languageVersionOrOptions, setParentNodes = false, scriptKind) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Parse, "createSourceFile", { path: fileName }, true);
|
|
mark("beforeParse");
|
|
let result;
|
|
perfLogger.logStartParseSourceFile(fileName);
|
|
const {
|
|
languageVersion,
|
|
setExternalModuleIndicator: overrideSetExternalModuleIndicator,
|
|
impliedNodeFormat: format
|
|
} = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions };
|
|
if (languageVersion === 100 /* JSON */) {
|
|
result = Parser.parseSourceFile(fileName, sourceText, languageVersion, void 0, setParentNodes, 6 /* JSON */, noop);
|
|
} else {
|
|
const setIndicator = format === void 0 ? overrideSetExternalModuleIndicator : (file) => {
|
|
file.impliedNodeFormat = format;
|
|
return (overrideSetExternalModuleIndicator || setExternalModuleIndicator)(file);
|
|
};
|
|
result = Parser.parseSourceFile(fileName, sourceText, languageVersion, void 0, setParentNodes, scriptKind, setIndicator);
|
|
}
|
|
perfLogger.logStopParseSourceFile();
|
|
mark("afterParse");
|
|
measure("Parse", "beforeParse", "afterParse");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function parseIsolatedEntityName(text, languageVersion) {
|
|
return Parser.parseIsolatedEntityName(text, languageVersion);
|
|
}
|
|
function parseJsonText(fileName, sourceText) {
|
|
return Parser.parseJsonText(fileName, sourceText);
|
|
}
|
|
function isExternalModule(file) {
|
|
return file.externalModuleIndicator !== void 0;
|
|
}
|
|
function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks = false) {
|
|
const newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
|
|
newSourceFile.flags |= sourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */;
|
|
return newSourceFile;
|
|
}
|
|
function parseIsolatedJSDocComment(content, start2, length2) {
|
|
const result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start2, length2);
|
|
if (result && result.jsDoc) {
|
|
Parser.fixupParentReferences(result.jsDoc);
|
|
}
|
|
return result;
|
|
}
|
|
function parseJSDocTypeExpressionForTests(content, start2, length2) {
|
|
return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start2, length2);
|
|
}
|
|
var Parser;
|
|
((Parser2) => {
|
|
const scanner2 = createScanner(99 /* Latest */, true);
|
|
const disallowInAndDecoratorContext = 4096 /* DisallowInContext */ | 16384 /* DecoratorContext */;
|
|
let NodeConstructor2;
|
|
let TokenConstructor2;
|
|
let IdentifierConstructor2;
|
|
let PrivateIdentifierConstructor2;
|
|
let SourceFileConstructor2;
|
|
function countNode(node) {
|
|
nodeCount++;
|
|
return node;
|
|
}
|
|
const baseNodeFactory = {
|
|
createBaseSourceFileNode: (kind) => countNode(new SourceFileConstructor2(kind, 0, 0)),
|
|
createBaseIdentifierNode: (kind) => countNode(new IdentifierConstructor2(kind, 0, 0)),
|
|
createBasePrivateIdentifierNode: (kind) => countNode(new PrivateIdentifierConstructor2(kind, 0, 0)),
|
|
createBaseTokenNode: (kind) => countNode(new TokenConstructor2(kind, 0, 0)),
|
|
createBaseNode: (kind) => countNode(new NodeConstructor2(kind, 0, 0))
|
|
};
|
|
const factory2 = createNodeFactory(1 /* NoParenthesizerRules */ | 2 /* NoNodeConverters */ | 8 /* NoOriginalNode */, baseNodeFactory);
|
|
let fileName;
|
|
let sourceFlags;
|
|
let sourceText;
|
|
let languageVersion;
|
|
let scriptKind;
|
|
let languageVariant;
|
|
let parseDiagnostics;
|
|
let jsDocDiagnostics;
|
|
let syntaxCursor;
|
|
let currentToken;
|
|
let nodeCount;
|
|
let identifiers;
|
|
let privateIdentifiers;
|
|
let identifierCount;
|
|
let parsingContext;
|
|
let notParenthesizedArrow;
|
|
let contextFlags;
|
|
let topLevel = true;
|
|
let parseErrorBeforeNextFinishedNode = false;
|
|
function parseSourceFile(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes = false, scriptKind2, setExternalModuleIndicatorOverride) {
|
|
var _a2;
|
|
scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
|
|
if (scriptKind2 === 6 /* JSON */) {
|
|
const result2 = parseJsonText2(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes);
|
|
convertToObjectWorker(result2, (_a2 = result2.statements[0]) == null ? void 0 : _a2.expression, result2.parseDiagnostics, false, void 0, void 0);
|
|
result2.referencedFiles = emptyArray;
|
|
result2.typeReferenceDirectives = emptyArray;
|
|
result2.libReferenceDirectives = emptyArray;
|
|
result2.amdDependencies = emptyArray;
|
|
result2.hasNoDefaultLib = false;
|
|
result2.pragmas = emptyMap;
|
|
return result2;
|
|
}
|
|
initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, scriptKind2);
|
|
const result = parseSourceFileWorker(languageVersion2, setParentNodes, scriptKind2, setExternalModuleIndicatorOverride || setExternalModuleIndicator);
|
|
clearState();
|
|
return result;
|
|
}
|
|
Parser2.parseSourceFile = parseSourceFile;
|
|
function parseIsolatedEntityName2(content, languageVersion2) {
|
|
initializeState("", content, languageVersion2, void 0, 1 /* JS */);
|
|
nextToken();
|
|
const entityName = parseEntityName(true);
|
|
const isInvalid = token() === 1 /* EndOfFileToken */ && !parseDiagnostics.length;
|
|
clearState();
|
|
return isInvalid ? entityName : void 0;
|
|
}
|
|
Parser2.parseIsolatedEntityName = parseIsolatedEntityName2;
|
|
function parseJsonText2(fileName2, sourceText2, languageVersion2 = 2 /* ES2015 */, syntaxCursor2, setParentNodes = false) {
|
|
initializeState(fileName2, sourceText2, languageVersion2, syntaxCursor2, 6 /* JSON */);
|
|
sourceFlags = contextFlags;
|
|
nextToken();
|
|
const pos = getNodePos();
|
|
let statements, endOfFileToken;
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
statements = createNodeArray2([], pos, pos);
|
|
endOfFileToken = parseTokenNode();
|
|
} else {
|
|
let expressions;
|
|
while (token() !== 1 /* EndOfFileToken */) {
|
|
let expression2;
|
|
switch (token()) {
|
|
case 22 /* OpenBracketToken */:
|
|
expression2 = parseArrayLiteralExpression();
|
|
break;
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
expression2 = parseTokenNode();
|
|
break;
|
|
case 40 /* MinusToken */:
|
|
if (lookAhead(() => nextToken() === 8 /* NumericLiteral */ && nextToken() !== 58 /* ColonToken */)) {
|
|
expression2 = parsePrefixUnaryExpression();
|
|
} else {
|
|
expression2 = parseObjectLiteralExpression();
|
|
}
|
|
break;
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
if (lookAhead(() => nextToken() !== 58 /* ColonToken */)) {
|
|
expression2 = parseLiteralNode();
|
|
break;
|
|
}
|
|
default:
|
|
expression2 = parseObjectLiteralExpression();
|
|
break;
|
|
}
|
|
if (expressions && isArray(expressions)) {
|
|
expressions.push(expression2);
|
|
} else if (expressions) {
|
|
expressions = [expressions, expression2];
|
|
} else {
|
|
expressions = expression2;
|
|
if (token() !== 1 /* EndOfFileToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Unexpected_token);
|
|
}
|
|
}
|
|
}
|
|
const expression = isArray(expressions) ? finishNode(factory2.createArrayLiteralExpression(expressions), pos) : Debug.checkDefined(expressions);
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
finishNode(statement, pos);
|
|
statements = createNodeArray2([statement], pos);
|
|
endOfFileToken = parseExpectedToken(1 /* EndOfFileToken */, Diagnostics.Unexpected_token);
|
|
}
|
|
const sourceFile = createSourceFile2(fileName2, 2 /* ES2015 */, 6 /* JSON */, false, statements, endOfFileToken, sourceFlags, noop);
|
|
if (setParentNodes) {
|
|
fixupParentReferences(sourceFile);
|
|
}
|
|
sourceFile.nodeCount = nodeCount;
|
|
sourceFile.identifierCount = identifierCount;
|
|
sourceFile.identifiers = identifiers;
|
|
sourceFile.parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
const result = sourceFile;
|
|
clearState();
|
|
return result;
|
|
}
|
|
Parser2.parseJsonText = parseJsonText2;
|
|
function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) {
|
|
NodeConstructor2 = objectAllocator.getNodeConstructor();
|
|
TokenConstructor2 = objectAllocator.getTokenConstructor();
|
|
IdentifierConstructor2 = objectAllocator.getIdentifierConstructor();
|
|
PrivateIdentifierConstructor2 = objectAllocator.getPrivateIdentifierConstructor();
|
|
SourceFileConstructor2 = objectAllocator.getSourceFileConstructor();
|
|
fileName = normalizePath(_fileName);
|
|
sourceText = _sourceText;
|
|
languageVersion = _languageVersion;
|
|
syntaxCursor = _syntaxCursor;
|
|
scriptKind = _scriptKind;
|
|
languageVariant = getLanguageVariant(_scriptKind);
|
|
parseDiagnostics = [];
|
|
parsingContext = 0;
|
|
identifiers = /* @__PURE__ */ new Map();
|
|
privateIdentifiers = /* @__PURE__ */ new Map();
|
|
identifierCount = 0;
|
|
nodeCount = 0;
|
|
sourceFlags = 0;
|
|
topLevel = true;
|
|
switch (scriptKind) {
|
|
case 1 /* JS */:
|
|
case 2 /* JSX */:
|
|
contextFlags = 262144 /* JavaScriptFile */;
|
|
break;
|
|
case 6 /* JSON */:
|
|
contextFlags = 262144 /* JavaScriptFile */ | 67108864 /* JsonFile */;
|
|
break;
|
|
default:
|
|
contextFlags = 0 /* None */;
|
|
break;
|
|
}
|
|
parseErrorBeforeNextFinishedNode = false;
|
|
scanner2.setText(sourceText);
|
|
scanner2.setOnError(scanError);
|
|
scanner2.setScriptTarget(languageVersion);
|
|
scanner2.setLanguageVariant(languageVariant);
|
|
}
|
|
function clearState() {
|
|
scanner2.clearCommentDirectives();
|
|
scanner2.setText("");
|
|
scanner2.setOnError(void 0);
|
|
sourceText = void 0;
|
|
languageVersion = void 0;
|
|
syntaxCursor = void 0;
|
|
scriptKind = void 0;
|
|
languageVariant = void 0;
|
|
sourceFlags = 0;
|
|
parseDiagnostics = void 0;
|
|
jsDocDiagnostics = void 0;
|
|
parsingContext = 0;
|
|
identifiers = void 0;
|
|
notParenthesizedArrow = void 0;
|
|
topLevel = true;
|
|
}
|
|
function parseSourceFileWorker(languageVersion2, setParentNodes, scriptKind2, setExternalModuleIndicator2) {
|
|
const isDeclarationFile = isDeclarationFileName(fileName);
|
|
if (isDeclarationFile) {
|
|
contextFlags |= 16777216 /* Ambient */;
|
|
}
|
|
sourceFlags = contextFlags;
|
|
nextToken();
|
|
const statements = parseList(ParsingContext.SourceElements, parseStatement);
|
|
Debug.assert(token() === 1 /* EndOfFileToken */);
|
|
const endOfFileToken = addJSDocComment(parseTokenNode());
|
|
const sourceFile = createSourceFile2(fileName, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator2);
|
|
processCommentPragmas(sourceFile, sourceText);
|
|
processPragmasIntoFields(sourceFile, reportPragmaDiagnostic);
|
|
sourceFile.commentDirectives = scanner2.getCommentDirectives();
|
|
sourceFile.nodeCount = nodeCount;
|
|
sourceFile.identifierCount = identifierCount;
|
|
sourceFile.identifiers = identifiers;
|
|
sourceFile.parseDiagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
if (setParentNodes) {
|
|
fixupParentReferences(sourceFile);
|
|
}
|
|
return sourceFile;
|
|
function reportPragmaDiagnostic(pos, end, diagnostic) {
|
|
parseDiagnostics.push(createDetachedDiagnostic(fileName, pos, end, diagnostic));
|
|
}
|
|
}
|
|
function withJSDoc(node, hasJSDoc) {
|
|
return hasJSDoc ? addJSDocComment(node) : node;
|
|
}
|
|
let hasDeprecatedTag = false;
|
|
function addJSDocComment(node) {
|
|
Debug.assert(!node.jsDoc);
|
|
const jsDoc = mapDefined(getJSDocCommentRanges(node, sourceText), (comment) => JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos));
|
|
if (jsDoc.length)
|
|
node.jsDoc = jsDoc;
|
|
if (hasDeprecatedTag) {
|
|
hasDeprecatedTag = false;
|
|
node.flags |= 268435456 /* Deprecated */;
|
|
}
|
|
return node;
|
|
}
|
|
function reparseTopLevelAwait(sourceFile) {
|
|
const savedSyntaxCursor = syntaxCursor;
|
|
const baseSyntaxCursor = IncrementalParser.createSyntaxCursor(sourceFile);
|
|
syntaxCursor = { currentNode: currentNode2 };
|
|
const statements = [];
|
|
const savedParseDiagnostics = parseDiagnostics;
|
|
parseDiagnostics = [];
|
|
let pos = 0;
|
|
let start2 = findNextStatementWithAwait(sourceFile.statements, 0);
|
|
while (start2 !== -1) {
|
|
const prevStatement = sourceFile.statements[pos];
|
|
const nextStatement = sourceFile.statements[start2];
|
|
addRange(statements, sourceFile.statements, pos, start2);
|
|
pos = findNextStatementWithoutAwait(sourceFile.statements, start2);
|
|
const diagnosticStart = findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= prevStatement.pos);
|
|
const diagnosticEnd = diagnosticStart >= 0 ? findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= nextStatement.pos, diagnosticStart) : -1;
|
|
if (diagnosticStart >= 0) {
|
|
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart, diagnosticEnd >= 0 ? diagnosticEnd : void 0);
|
|
}
|
|
speculationHelper(() => {
|
|
const savedContextFlags = contextFlags;
|
|
contextFlags |= 32768 /* AwaitContext */;
|
|
scanner2.setTextPos(nextStatement.pos);
|
|
nextToken();
|
|
while (token() !== 1 /* EndOfFileToken */) {
|
|
const startPos = scanner2.getStartPos();
|
|
const statement = parseListElement(ParsingContext.SourceElements, parseStatement);
|
|
statements.push(statement);
|
|
if (startPos === scanner2.getStartPos()) {
|
|
nextToken();
|
|
}
|
|
if (pos >= 0) {
|
|
const nonAwaitStatement = sourceFile.statements[pos];
|
|
if (statement.end === nonAwaitStatement.pos) {
|
|
break;
|
|
}
|
|
if (statement.end > nonAwaitStatement.pos) {
|
|
pos = findNextStatementWithoutAwait(sourceFile.statements, pos + 1);
|
|
}
|
|
}
|
|
}
|
|
contextFlags = savedContextFlags;
|
|
}, 2 /* Reparse */);
|
|
start2 = pos >= 0 ? findNextStatementWithAwait(sourceFile.statements, pos) : -1;
|
|
}
|
|
if (pos >= 0) {
|
|
const prevStatement = sourceFile.statements[pos];
|
|
addRange(statements, sourceFile.statements, pos);
|
|
const diagnosticStart = findIndex(savedParseDiagnostics, (diagnostic) => diagnostic.start >= prevStatement.pos);
|
|
if (diagnosticStart >= 0) {
|
|
addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart);
|
|
}
|
|
}
|
|
syntaxCursor = savedSyntaxCursor;
|
|
return factory2.updateSourceFile(sourceFile, setTextRange(factory2.createNodeArray(statements), sourceFile.statements));
|
|
function containsPossibleTopLevelAwait(node) {
|
|
return !(node.flags & 32768 /* AwaitContext */) && !!(node.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */);
|
|
}
|
|
function findNextStatementWithAwait(statements2, start3) {
|
|
for (let i = start3; i < statements2.length; i++) {
|
|
if (containsPossibleTopLevelAwait(statements2[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function findNextStatementWithoutAwait(statements2, start3) {
|
|
for (let i = start3; i < statements2.length; i++) {
|
|
if (!containsPossibleTopLevelAwait(statements2[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function currentNode2(position) {
|
|
const node = baseSyntaxCursor.currentNode(position);
|
|
if (topLevel && node && containsPossibleTopLevelAwait(node)) {
|
|
node.intersectsChange = true;
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function fixupParentReferences(rootNode) {
|
|
setParentRecursive(rootNode, true);
|
|
}
|
|
Parser2.fixupParentReferences = fixupParentReferences;
|
|
function createSourceFile2(fileName2, languageVersion2, scriptKind2, isDeclarationFile, statements, endOfFileToken, flags, setExternalModuleIndicator2) {
|
|
let sourceFile = factory2.createSourceFile(statements, endOfFileToken, flags);
|
|
setTextRangePosWidth(sourceFile, 0, sourceText.length);
|
|
setFields(sourceFile);
|
|
if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 67108864 /* ContainsPossibleTopLevelAwait */) {
|
|
sourceFile = reparseTopLevelAwait(sourceFile);
|
|
setFields(sourceFile);
|
|
}
|
|
return sourceFile;
|
|
function setFields(sourceFile2) {
|
|
sourceFile2.text = sourceText;
|
|
sourceFile2.bindDiagnostics = [];
|
|
sourceFile2.bindSuggestionDiagnostics = void 0;
|
|
sourceFile2.languageVersion = languageVersion2;
|
|
sourceFile2.fileName = fileName2;
|
|
sourceFile2.languageVariant = getLanguageVariant(scriptKind2);
|
|
sourceFile2.isDeclarationFile = isDeclarationFile;
|
|
sourceFile2.scriptKind = scriptKind2;
|
|
setExternalModuleIndicator2(sourceFile2);
|
|
sourceFile2.setExternalModuleIndicator = setExternalModuleIndicator2;
|
|
}
|
|
}
|
|
function setContextFlag(val, flag) {
|
|
if (val) {
|
|
contextFlags |= flag;
|
|
} else {
|
|
contextFlags &= ~flag;
|
|
}
|
|
}
|
|
function setDisallowInContext(val) {
|
|
setContextFlag(val, 4096 /* DisallowInContext */);
|
|
}
|
|
function setYieldContext(val) {
|
|
setContextFlag(val, 8192 /* YieldContext */);
|
|
}
|
|
function setDecoratorContext(val) {
|
|
setContextFlag(val, 16384 /* DecoratorContext */);
|
|
}
|
|
function setAwaitContext(val) {
|
|
setContextFlag(val, 32768 /* AwaitContext */);
|
|
}
|
|
function doOutsideOfContext(context, func) {
|
|
const contextFlagsToClear = context & contextFlags;
|
|
if (contextFlagsToClear) {
|
|
setContextFlag(false, contextFlagsToClear);
|
|
const result = func();
|
|
setContextFlag(true, contextFlagsToClear);
|
|
return result;
|
|
}
|
|
return func();
|
|
}
|
|
function doInsideOfContext(context, func) {
|
|
const contextFlagsToSet = context & ~contextFlags;
|
|
if (contextFlagsToSet) {
|
|
setContextFlag(true, contextFlagsToSet);
|
|
const result = func();
|
|
setContextFlag(false, contextFlagsToSet);
|
|
return result;
|
|
}
|
|
return func();
|
|
}
|
|
function allowInAnd(func) {
|
|
return doOutsideOfContext(4096 /* DisallowInContext */, func);
|
|
}
|
|
function disallowInAnd(func) {
|
|
return doInsideOfContext(4096 /* DisallowInContext */, func);
|
|
}
|
|
function allowConditionalTypesAnd(func) {
|
|
return doOutsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
|
|
}
|
|
function disallowConditionalTypesAnd(func) {
|
|
return doInsideOfContext(65536 /* DisallowConditionalTypesContext */, func);
|
|
}
|
|
function doInYieldContext(func) {
|
|
return doInsideOfContext(8192 /* YieldContext */, func);
|
|
}
|
|
function doInDecoratorContext(func) {
|
|
return doInsideOfContext(16384 /* DecoratorContext */, func);
|
|
}
|
|
function doInAwaitContext(func) {
|
|
return doInsideOfContext(32768 /* AwaitContext */, func);
|
|
}
|
|
function doOutsideOfAwaitContext(func) {
|
|
return doOutsideOfContext(32768 /* AwaitContext */, func);
|
|
}
|
|
function doInYieldAndAwaitContext(func) {
|
|
return doInsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */, func);
|
|
}
|
|
function doOutsideOfYieldAndAwaitContext(func) {
|
|
return doOutsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */, func);
|
|
}
|
|
function inContext(flags) {
|
|
return (contextFlags & flags) !== 0;
|
|
}
|
|
function inYieldContext() {
|
|
return inContext(8192 /* YieldContext */);
|
|
}
|
|
function inDisallowInContext() {
|
|
return inContext(4096 /* DisallowInContext */);
|
|
}
|
|
function inDisallowConditionalTypesContext() {
|
|
return inContext(65536 /* DisallowConditionalTypesContext */);
|
|
}
|
|
function inDecoratorContext() {
|
|
return inContext(16384 /* DecoratorContext */);
|
|
}
|
|
function inAwaitContext() {
|
|
return inContext(32768 /* AwaitContext */);
|
|
}
|
|
function parseErrorAtCurrentToken(message, arg0) {
|
|
return parseErrorAt(scanner2.getTokenPos(), scanner2.getTextPos(), message, arg0);
|
|
}
|
|
function parseErrorAtPosition(start2, length2, message, arg0) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
let result;
|
|
if (!lastError || start2 !== lastError.start) {
|
|
result = createDetachedDiagnostic(fileName, start2, length2, message, arg0);
|
|
parseDiagnostics.push(result);
|
|
}
|
|
parseErrorBeforeNextFinishedNode = true;
|
|
return result;
|
|
}
|
|
function parseErrorAt(start2, end, message, arg0) {
|
|
return parseErrorAtPosition(start2, end - start2, message, arg0);
|
|
}
|
|
function parseErrorAtRange(range, message, arg0) {
|
|
parseErrorAt(range.pos, range.end, message, arg0);
|
|
}
|
|
function scanError(message, length2) {
|
|
parseErrorAtPosition(scanner2.getTextPos(), length2, message);
|
|
}
|
|
function getNodePos() {
|
|
return scanner2.getStartPos();
|
|
}
|
|
function hasPrecedingJSDocComment() {
|
|
return scanner2.hasPrecedingJSDocComment();
|
|
}
|
|
function token() {
|
|
return currentToken;
|
|
}
|
|
function nextTokenWithoutCheck() {
|
|
return currentToken = scanner2.scan();
|
|
}
|
|
function nextTokenAnd(func) {
|
|
nextToken();
|
|
return func();
|
|
}
|
|
function nextToken() {
|
|
if (isKeyword(currentToken) && (scanner2.hasUnicodeEscape() || scanner2.hasExtendedUnicodeEscape())) {
|
|
parseErrorAt(scanner2.getTokenPos(), scanner2.getTextPos(), Diagnostics.Keywords_cannot_contain_escape_characters);
|
|
}
|
|
return nextTokenWithoutCheck();
|
|
}
|
|
function nextTokenJSDoc() {
|
|
return currentToken = scanner2.scanJsDocToken();
|
|
}
|
|
function reScanGreaterToken() {
|
|
return currentToken = scanner2.reScanGreaterToken();
|
|
}
|
|
function reScanSlashToken() {
|
|
return currentToken = scanner2.reScanSlashToken();
|
|
}
|
|
function reScanTemplateToken(isTaggedTemplate) {
|
|
return currentToken = scanner2.reScanTemplateToken(isTaggedTemplate);
|
|
}
|
|
function reScanTemplateHeadOrNoSubstitutionTemplate() {
|
|
return currentToken = scanner2.reScanTemplateHeadOrNoSubstitutionTemplate();
|
|
}
|
|
function reScanLessThanToken() {
|
|
return currentToken = scanner2.reScanLessThanToken();
|
|
}
|
|
function reScanHashToken() {
|
|
return currentToken = scanner2.reScanHashToken();
|
|
}
|
|
function scanJsxIdentifier() {
|
|
return currentToken = scanner2.scanJsxIdentifier();
|
|
}
|
|
function scanJsxText() {
|
|
return currentToken = scanner2.scanJsxToken();
|
|
}
|
|
function scanJsxAttributeValue() {
|
|
return currentToken = scanner2.scanJsxAttributeValue();
|
|
}
|
|
function speculationHelper(callback, speculationKind) {
|
|
const saveToken = currentToken;
|
|
const saveParseDiagnosticsLength = parseDiagnostics.length;
|
|
const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
|
|
const saveContextFlags = contextFlags;
|
|
const result = speculationKind !== 0 /* TryParse */ ? scanner2.lookAhead(callback) : scanner2.tryScan(callback);
|
|
Debug.assert(saveContextFlags === contextFlags);
|
|
if (!result || speculationKind !== 0 /* TryParse */) {
|
|
currentToken = saveToken;
|
|
if (speculationKind !== 2 /* Reparse */) {
|
|
parseDiagnostics.length = saveParseDiagnosticsLength;
|
|
}
|
|
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
|
|
}
|
|
return result;
|
|
}
|
|
function lookAhead(callback) {
|
|
return speculationHelper(callback, 1 /* Lookahead */);
|
|
}
|
|
function tryParse(callback) {
|
|
return speculationHelper(callback, 0 /* TryParse */);
|
|
}
|
|
function isBindingIdentifier() {
|
|
if (token() === 79 /* Identifier */) {
|
|
return true;
|
|
}
|
|
return token() > 116 /* LastReservedWord */;
|
|
}
|
|
function isIdentifier2() {
|
|
if (token() === 79 /* Identifier */) {
|
|
return true;
|
|
}
|
|
if (token() === 125 /* YieldKeyword */ && inYieldContext()) {
|
|
return false;
|
|
}
|
|
if (token() === 133 /* AwaitKeyword */ && inAwaitContext()) {
|
|
return false;
|
|
}
|
|
return token() > 116 /* LastReservedWord */;
|
|
}
|
|
function parseExpected(kind, diagnosticMessage, shouldAdvance = true) {
|
|
if (token() === kind) {
|
|
if (shouldAdvance) {
|
|
nextToken();
|
|
}
|
|
return true;
|
|
}
|
|
if (diagnosticMessage) {
|
|
parseErrorAtCurrentToken(diagnosticMessage);
|
|
} else {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
|
|
}
|
|
return false;
|
|
}
|
|
const viableKeywordSuggestions = Object.keys(textToKeywordObj).filter((keyword) => keyword.length > 2);
|
|
function parseErrorForMissingSemicolonAfter(node) {
|
|
var _a2;
|
|
if (isTaggedTemplateExpression(node)) {
|
|
parseErrorAt(skipTrivia(sourceText, node.template.pos), node.template.end, Diagnostics.Module_declaration_names_may_only_use_or_quoted_strings);
|
|
return;
|
|
}
|
|
const expressionText = isIdentifier(node) ? idText(node) : void 0;
|
|
if (!expressionText || !isIdentifierText(expressionText, languageVersion)) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
return;
|
|
}
|
|
const pos = skipTrivia(sourceText, node.pos);
|
|
switch (expressionText) {
|
|
case "const":
|
|
case "let":
|
|
case "var":
|
|
parseErrorAt(pos, node.end, Diagnostics.Variable_declaration_not_allowed_at_this_location);
|
|
return;
|
|
case "declare":
|
|
return;
|
|
case "interface":
|
|
parseErrorForInvalidName(Diagnostics.Interface_name_cannot_be_0, Diagnostics.Interface_must_be_given_a_name, 18 /* OpenBraceToken */);
|
|
return;
|
|
case "is":
|
|
parseErrorAt(pos, scanner2.getTextPos(), Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
|
|
return;
|
|
case "module":
|
|
case "namespace":
|
|
parseErrorForInvalidName(Diagnostics.Namespace_name_cannot_be_0, Diagnostics.Namespace_must_be_given_a_name, 18 /* OpenBraceToken */);
|
|
return;
|
|
case "type":
|
|
parseErrorForInvalidName(Diagnostics.Type_alias_name_cannot_be_0, Diagnostics.Type_alias_must_be_given_a_name, 63 /* EqualsToken */);
|
|
return;
|
|
}
|
|
const suggestion = (_a2 = getSpellingSuggestion(expressionText, viableKeywordSuggestions, (n) => n)) != null ? _a2 : getSpaceSuggestion(expressionText);
|
|
if (suggestion) {
|
|
parseErrorAt(pos, node.end, Diagnostics.Unknown_keyword_or_identifier_Did_you_mean_0, suggestion);
|
|
return;
|
|
}
|
|
if (token() === 0 /* Unknown */) {
|
|
return;
|
|
}
|
|
parseErrorAt(pos, node.end, Diagnostics.Unexpected_keyword_or_identifier);
|
|
}
|
|
function parseErrorForInvalidName(nameDiagnostic, blankDiagnostic, tokenIfBlankName) {
|
|
if (token() === tokenIfBlankName) {
|
|
parseErrorAtCurrentToken(blankDiagnostic);
|
|
} else {
|
|
parseErrorAtCurrentToken(nameDiagnostic, scanner2.getTokenValue());
|
|
}
|
|
}
|
|
function getSpaceSuggestion(expressionText) {
|
|
for (const keyword of viableKeywordSuggestions) {
|
|
if (expressionText.length > keyword.length + 2 && startsWith(expressionText, keyword)) {
|
|
return `${keyword} ${expressionText.slice(keyword.length)}`;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseSemicolonAfterPropertyName(name, type, initializer) {
|
|
if (token() === 59 /* AtToken */ && !scanner2.hasPrecedingLineBreak()) {
|
|
parseErrorAtCurrentToken(Diagnostics.Decorators_must_precede_the_name_and_all_keywords_of_property_declarations);
|
|
return;
|
|
}
|
|
if (token() === 20 /* OpenParenToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Cannot_start_a_function_call_in_a_type_annotation);
|
|
nextToken();
|
|
return;
|
|
}
|
|
if (type && !canParseSemicolon()) {
|
|
if (initializer) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
} else {
|
|
parseErrorAtCurrentToken(Diagnostics.Expected_for_property_initializer);
|
|
}
|
|
return;
|
|
}
|
|
if (tryParseSemicolon()) {
|
|
return;
|
|
}
|
|
if (initializer) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(26 /* SemicolonToken */));
|
|
return;
|
|
}
|
|
parseErrorForMissingSemicolonAfter(name);
|
|
}
|
|
function parseExpectedJSDoc(kind) {
|
|
if (token() === kind) {
|
|
nextTokenJSDoc();
|
|
return true;
|
|
}
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
|
|
return false;
|
|
}
|
|
function parseExpectedMatchingBrackets(openKind, closeKind, openParsed, openPosition) {
|
|
if (token() === closeKind) {
|
|
nextToken();
|
|
return;
|
|
}
|
|
const lastError = parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(closeKind));
|
|
if (!openParsed) {
|
|
return;
|
|
}
|
|
if (lastError) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openPosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, tokenToString(openKind), tokenToString(closeKind))
|
|
);
|
|
}
|
|
}
|
|
function parseOptional(t) {
|
|
if (token() === t) {
|
|
nextToken();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseOptionalToken(t) {
|
|
if (token() === t) {
|
|
return parseTokenNode();
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseOptionalTokenJSDoc(t) {
|
|
if (token() === t) {
|
|
return parseTokenNodeJSDoc();
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseExpectedToken(t, diagnosticMessage, arg0) {
|
|
return parseOptionalToken(t) || createMissingNode(t, false, diagnosticMessage || Diagnostics._0_expected, arg0 || tokenToString(t));
|
|
}
|
|
function parseExpectedTokenJSDoc(t) {
|
|
return parseOptionalTokenJSDoc(t) || createMissingNode(t, false, Diagnostics._0_expected, tokenToString(t));
|
|
}
|
|
function parseTokenNode() {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
nextToken();
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function parseTokenNodeJSDoc() {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
nextTokenJSDoc();
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function canParseSemicolon() {
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
return true;
|
|
}
|
|
return token() === 19 /* CloseBraceToken */ || token() === 1 /* EndOfFileToken */ || scanner2.hasPrecedingLineBreak();
|
|
}
|
|
function tryParseSemicolon() {
|
|
if (!canParseSemicolon()) {
|
|
return false;
|
|
}
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
nextToken();
|
|
}
|
|
return true;
|
|
}
|
|
function parseSemicolon() {
|
|
return tryParseSemicolon() || parseExpected(26 /* SemicolonToken */);
|
|
}
|
|
function createNodeArray2(elements, pos, end, hasTrailingComma) {
|
|
const array = factory2.createNodeArray(elements, hasTrailingComma);
|
|
setTextRangePosEnd(array, pos, end != null ? end : scanner2.getStartPos());
|
|
return array;
|
|
}
|
|
function finishNode(node, pos, end) {
|
|
setTextRangePosEnd(node, pos, end != null ? end : scanner2.getStartPos());
|
|
if (contextFlags) {
|
|
node.flags |= contextFlags;
|
|
}
|
|
if (parseErrorBeforeNextFinishedNode) {
|
|
parseErrorBeforeNextFinishedNode = false;
|
|
node.flags |= 131072 /* ThisNodeHasError */;
|
|
}
|
|
return node;
|
|
}
|
|
function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
|
|
if (reportAtCurrentPosition) {
|
|
parseErrorAtPosition(scanner2.getStartPos(), 0, diagnosticMessage, arg0);
|
|
} else if (diagnosticMessage) {
|
|
parseErrorAtCurrentToken(diagnosticMessage, arg0);
|
|
}
|
|
const pos = getNodePos();
|
|
const result = kind === 79 /* Identifier */ ? factory2.createIdentifier("", void 0, void 0) : isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, "", "", void 0) : kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral("", void 0) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral("", void 0) : kind === 279 /* MissingDeclaration */ ? factory2.createMissingDeclaration() : factory2.createToken(kind);
|
|
return finishNode(result, pos);
|
|
}
|
|
function internIdentifier(text) {
|
|
let identifier = identifiers.get(text);
|
|
if (identifier === void 0) {
|
|
identifiers.set(text, identifier = text);
|
|
}
|
|
return identifier;
|
|
}
|
|
function createIdentifier3(isIdentifier3, diagnosticMessage, privateIdentifierDiagnosticMessage) {
|
|
if (isIdentifier3) {
|
|
identifierCount++;
|
|
const pos = getNodePos();
|
|
const originalKeywordKind = token();
|
|
const text = internIdentifier(scanner2.getTokenValue());
|
|
const hasExtendedUnicodeEscape = scanner2.hasExtendedUnicodeEscape();
|
|
nextTokenWithoutCheck();
|
|
return finishNode(factory2.createIdentifier(text, void 0, originalKeywordKind, hasExtendedUnicodeEscape), pos);
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
return createIdentifier3(true);
|
|
}
|
|
if (token() === 0 /* Unknown */ && scanner2.tryScan(() => scanner2.reScanInvalidIdentifier() === 79 /* Identifier */)) {
|
|
return createIdentifier3(true);
|
|
}
|
|
identifierCount++;
|
|
const reportAtCurrentPosition = token() === 1 /* EndOfFileToken */;
|
|
const isReservedWord = scanner2.isReservedWord();
|
|
const msgArg = scanner2.getTokenText();
|
|
const defaultMessage = isReservedWord ? Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here : Diagnostics.Identifier_expected;
|
|
return createMissingNode(79 /* Identifier */, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg);
|
|
}
|
|
function parseBindingIdentifier(privateIdentifierDiagnosticMessage) {
|
|
return createIdentifier3(isBindingIdentifier(), void 0, privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) {
|
|
return createIdentifier3(isIdentifier2(), diagnosticMessage, privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseIdentifierName(diagnosticMessage) {
|
|
return createIdentifier3(tokenIsIdentifierOrKeyword(token()), diagnosticMessage);
|
|
}
|
|
function isLiteralPropertyName() {
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */;
|
|
}
|
|
function isAssertionKey2() {
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */;
|
|
}
|
|
function parsePropertyNameWorker(allowComputedPropertyNames) {
|
|
if (token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */) {
|
|
const node = parseLiteralNode();
|
|
node.text = internIdentifier(node.text);
|
|
return node;
|
|
}
|
|
if (allowComputedPropertyNames && token() === 22 /* OpenBracketToken */) {
|
|
return parseComputedPropertyName();
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
return parsePrivateIdentifier();
|
|
}
|
|
return parseIdentifierName();
|
|
}
|
|
function parsePropertyName() {
|
|
return parsePropertyNameWorker(true);
|
|
}
|
|
function parseComputedPropertyName() {
|
|
const pos = getNodePos();
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
return finishNode(factory2.createComputedPropertyName(expression), pos);
|
|
}
|
|
function internPrivateIdentifier(text) {
|
|
let privateIdentifier = privateIdentifiers.get(text);
|
|
if (privateIdentifier === void 0) {
|
|
privateIdentifiers.set(text, privateIdentifier = text);
|
|
}
|
|
return privateIdentifier;
|
|
}
|
|
function parsePrivateIdentifier() {
|
|
const pos = getNodePos();
|
|
const node = factory2.createPrivateIdentifier(internPrivateIdentifier(scanner2.getTokenValue()));
|
|
nextToken();
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseContextualModifier(t) {
|
|
return token() === t && tryParse(nextTokenCanFollowModifier);
|
|
}
|
|
function nextTokenIsOnSameLineAndCanFollowModifier() {
|
|
nextToken();
|
|
if (scanner2.hasPrecedingLineBreak()) {
|
|
return false;
|
|
}
|
|
return canFollowModifier();
|
|
}
|
|
function nextTokenCanFollowModifier() {
|
|
switch (token()) {
|
|
case 85 /* ConstKeyword */:
|
|
return nextToken() === 92 /* EnumKeyword */;
|
|
case 93 /* ExportKeyword */:
|
|
nextToken();
|
|
if (token() === 88 /* DefaultKeyword */) {
|
|
return lookAhead(nextTokenCanFollowDefaultKeyword);
|
|
}
|
|
if (token() === 154 /* TypeKeyword */) {
|
|
return lookAhead(nextTokenCanFollowExportModifier);
|
|
}
|
|
return canFollowExportModifier();
|
|
case 88 /* DefaultKeyword */:
|
|
return nextTokenCanFollowDefaultKeyword();
|
|
case 127 /* AccessorKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
nextToken();
|
|
return canFollowModifier();
|
|
default:
|
|
return nextTokenIsOnSameLineAndCanFollowModifier();
|
|
}
|
|
}
|
|
function canFollowExportModifier() {
|
|
return token() !== 41 /* AsteriskToken */ && token() !== 128 /* AsKeyword */ && token() !== 18 /* OpenBraceToken */ && canFollowModifier();
|
|
}
|
|
function nextTokenCanFollowExportModifier() {
|
|
nextToken();
|
|
return canFollowExportModifier();
|
|
}
|
|
function parseAnyContextualModifier() {
|
|
return isModifierKind(token()) && tryParse(nextTokenCanFollowModifier);
|
|
}
|
|
function canFollowModifier() {
|
|
return token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */ || token() === 41 /* AsteriskToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
|
|
}
|
|
function nextTokenCanFollowDefaultKeyword() {
|
|
nextToken();
|
|
return token() === 84 /* ClassKeyword */ || token() === 98 /* FunctionKeyword */ || token() === 118 /* InterfaceKeyword */ || token() === 126 /* AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine) || token() === 132 /* AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine);
|
|
}
|
|
function isListElement2(parsingContext2, inErrorRecovery) {
|
|
const node = currentNode(parsingContext2);
|
|
if (node) {
|
|
return true;
|
|
}
|
|
switch (parsingContext2) {
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return !(token() === 26 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
|
|
case ParsingContext.SwitchClauses:
|
|
return token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
|
|
case ParsingContext.TypeMembers:
|
|
return lookAhead(isTypeMemberStart);
|
|
case ParsingContext.ClassMembers:
|
|
return lookAhead(isClassMemberStart) || token() === 26 /* SemicolonToken */ && !inErrorRecovery;
|
|
case ParsingContext.EnumMembers:
|
|
return token() === 22 /* OpenBracketToken */ || isLiteralPropertyName();
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
switch (token()) {
|
|
case 22 /* OpenBracketToken */:
|
|
case 41 /* AsteriskToken */:
|
|
case 25 /* DotDotDotToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
default:
|
|
return isLiteralPropertyName();
|
|
}
|
|
case ParsingContext.RestProperties:
|
|
return isLiteralPropertyName();
|
|
case ParsingContext.ObjectBindingElements:
|
|
return token() === 22 /* OpenBracketToken */ || token() === 25 /* DotDotDotToken */ || isLiteralPropertyName();
|
|
case ParsingContext.AssertEntries:
|
|
return isAssertionKey2();
|
|
case ParsingContext.HeritageClauseElement:
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return lookAhead(isValidHeritageClauseObjectLiteral);
|
|
}
|
|
if (!inErrorRecovery) {
|
|
return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
|
|
} else {
|
|
return isIdentifier2() && !isHeritageClauseExtendsOrImplementsKeyword();
|
|
}
|
|
case ParsingContext.VariableDeclarations:
|
|
return isBindingIdentifierOrPrivateIdentifierOrPattern();
|
|
case ParsingContext.ArrayBindingElements:
|
|
return token() === 27 /* CommaToken */ || token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern();
|
|
case ParsingContext.TypeParameters:
|
|
return token() === 101 /* InKeyword */ || isIdentifier2();
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
switch (token()) {
|
|
case 27 /* CommaToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
}
|
|
case ParsingContext.ArgumentExpressions:
|
|
return token() === 25 /* DotDotDotToken */ || isStartOfExpression();
|
|
case ParsingContext.Parameters:
|
|
return isStartOfParameter(false);
|
|
case ParsingContext.JSDocParameters:
|
|
return isStartOfParameter(true);
|
|
case ParsingContext.TypeArguments:
|
|
case ParsingContext.TupleElementTypes:
|
|
return token() === 27 /* CommaToken */ || isStartOfType();
|
|
case ParsingContext.HeritageClauses:
|
|
return isHeritageClause2();
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
return tokenIsIdentifierOrKeyword(token());
|
|
case ParsingContext.JsxAttributes:
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
|
|
case ParsingContext.JsxChildren:
|
|
return true;
|
|
}
|
|
return Debug.fail("Non-exhaustive case in 'isListElement'.");
|
|
}
|
|
function isValidHeritageClauseObjectLiteral() {
|
|
Debug.assert(token() === 18 /* OpenBraceToken */);
|
|
if (nextToken() === 19 /* CloseBraceToken */) {
|
|
const next = nextToken();
|
|
return next === 27 /* CommaToken */ || next === 18 /* OpenBraceToken */ || next === 94 /* ExtendsKeyword */ || next === 117 /* ImplementsKeyword */;
|
|
}
|
|
return true;
|
|
}
|
|
function nextTokenIsIdentifier() {
|
|
nextToken();
|
|
return isIdentifier2();
|
|
}
|
|
function nextTokenIsIdentifierOrKeyword() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token());
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrGreaterThan() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeywordOrGreaterThan(token());
|
|
}
|
|
function isHeritageClauseExtendsOrImplementsKeyword() {
|
|
if (token() === 117 /* ImplementsKeyword */ || token() === 94 /* ExtendsKeyword */) {
|
|
return lookAhead(nextTokenIsStartOfExpression);
|
|
}
|
|
return false;
|
|
}
|
|
function nextTokenIsStartOfExpression() {
|
|
nextToken();
|
|
return isStartOfExpression();
|
|
}
|
|
function nextTokenIsStartOfType() {
|
|
nextToken();
|
|
return isStartOfType();
|
|
}
|
|
function isListTerminator(kind) {
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
return true;
|
|
}
|
|
switch (kind) {
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauses:
|
|
case ParsingContext.TypeMembers:
|
|
case ParsingContext.ClassMembers:
|
|
case ParsingContext.EnumMembers:
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
case ParsingContext.ObjectBindingElements:
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
case ParsingContext.AssertEntries:
|
|
return token() === 19 /* CloseBraceToken */;
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return token() === 19 /* CloseBraceToken */ || token() === 82 /* CaseKeyword */ || token() === 88 /* DefaultKeyword */;
|
|
case ParsingContext.HeritageClauseElement:
|
|
return token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
case ParsingContext.VariableDeclarations:
|
|
return isVariableDeclaratorListTerminator();
|
|
case ParsingContext.TypeParameters:
|
|
return token() === 31 /* GreaterThanToken */ || token() === 20 /* OpenParenToken */ || token() === 18 /* OpenBraceToken */ || token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
case ParsingContext.ArgumentExpressions:
|
|
return token() === 21 /* CloseParenToken */ || token() === 26 /* SemicolonToken */;
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
case ParsingContext.TupleElementTypes:
|
|
case ParsingContext.ArrayBindingElements:
|
|
return token() === 23 /* CloseBracketToken */;
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
case ParsingContext.RestProperties:
|
|
return token() === 21 /* CloseParenToken */ || token() === 23 /* CloseBracketToken */;
|
|
case ParsingContext.TypeArguments:
|
|
return token() !== 27 /* CommaToken */;
|
|
case ParsingContext.HeritageClauses:
|
|
return token() === 18 /* OpenBraceToken */ || token() === 19 /* CloseBraceToken */;
|
|
case ParsingContext.JsxAttributes:
|
|
return token() === 31 /* GreaterThanToken */ || token() === 43 /* SlashToken */;
|
|
case ParsingContext.JsxChildren:
|
|
return token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsSlash);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isVariableDeclaratorListTerminator() {
|
|
if (canParseSemicolon()) {
|
|
return true;
|
|
}
|
|
if (isInOrOfKeyword(token())) {
|
|
return true;
|
|
}
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isInSomeParsingContext() {
|
|
for (let kind = 0; kind < ParsingContext.Count; kind++) {
|
|
if (parsingContext & 1 << kind) {
|
|
if (isListElement2(kind, true) || isListTerminator(kind)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseList(kind, parseElement) {
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << kind;
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
while (!isListTerminator(kind)) {
|
|
if (isListElement2(kind, false)) {
|
|
list.push(parseListElement(kind, parseElement));
|
|
continue;
|
|
}
|
|
if (abortParsingListOrMoveToNextToken(kind)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray2(list, listPos);
|
|
}
|
|
function parseListElement(parsingContext2, parseElement) {
|
|
const node = currentNode(parsingContext2);
|
|
if (node) {
|
|
return consumeNode(node);
|
|
}
|
|
return parseElement();
|
|
}
|
|
function currentNode(parsingContext2, pos) {
|
|
if (!syntaxCursor || !isReusableParsingContext(parsingContext2) || parseErrorBeforeNextFinishedNode) {
|
|
return void 0;
|
|
}
|
|
const node = syntaxCursor.currentNode(pos != null ? pos : scanner2.getStartPos());
|
|
if (nodeIsMissing(node) || node.intersectsChange || containsParseError(node)) {
|
|
return void 0;
|
|
}
|
|
const nodeContextFlags = node.flags & 50720768 /* ContextFlags */;
|
|
if (nodeContextFlags !== contextFlags) {
|
|
return void 0;
|
|
}
|
|
if (!canReuseNode(node, parsingContext2)) {
|
|
return void 0;
|
|
}
|
|
if (node.jsDocCache) {
|
|
node.jsDocCache = void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function consumeNode(node) {
|
|
scanner2.setTextPos(node.end);
|
|
nextToken();
|
|
return node;
|
|
}
|
|
function isReusableParsingContext(parsingContext2) {
|
|
switch (parsingContext2) {
|
|
case ParsingContext.ClassMembers:
|
|
case ParsingContext.SwitchClauses:
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
case ParsingContext.EnumMembers:
|
|
case ParsingContext.TypeMembers:
|
|
case ParsingContext.VariableDeclarations:
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function canReuseNode(node, parsingContext2) {
|
|
switch (parsingContext2) {
|
|
case ParsingContext.ClassMembers:
|
|
return isReusableClassMember(node);
|
|
case ParsingContext.SwitchClauses:
|
|
return isReusableSwitchClause(node);
|
|
case ParsingContext.SourceElements:
|
|
case ParsingContext.BlockStatements:
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return isReusableStatement(node);
|
|
case ParsingContext.EnumMembers:
|
|
return isReusableEnumMember(node);
|
|
case ParsingContext.TypeMembers:
|
|
return isReusableTypeMember(node);
|
|
case ParsingContext.VariableDeclarations:
|
|
return isReusableVariableDeclaration(node);
|
|
case ParsingContext.JSDocParameters:
|
|
case ParsingContext.Parameters:
|
|
return isReusableParameter(node);
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableClassMember(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 178 /* IndexSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 237 /* SemicolonClassElement */:
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
const methodDeclaration = node;
|
|
const nameIsConstructor = methodDeclaration.name.kind === 79 /* Identifier */ && methodDeclaration.name.originalKeywordKind === 135 /* ConstructorKeyword */;
|
|
return !nameIsConstructor;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableSwitchClause(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableStatement(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 238 /* Block */:
|
|
case 242 /* IfStatement */:
|
|
case 241 /* ExpressionStatement */:
|
|
case 254 /* ThrowStatement */:
|
|
case 250 /* ReturnStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 239 /* EmptyStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 253 /* LabeledStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 256 /* DebuggerStatement */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableEnumMember(node) {
|
|
return node.kind === 302 /* EnumMember */;
|
|
}
|
|
function isReusableTypeMember(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 168 /* PropertySignature */:
|
|
case 176 /* CallSignature */:
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isReusableVariableDeclaration(node) {
|
|
if (node.kind !== 257 /* VariableDeclaration */) {
|
|
return false;
|
|
}
|
|
const variableDeclarator = node;
|
|
return variableDeclarator.initializer === void 0;
|
|
}
|
|
function isReusableParameter(node) {
|
|
if (node.kind !== 166 /* Parameter */) {
|
|
return false;
|
|
}
|
|
const parameter = node;
|
|
return parameter.initializer === void 0;
|
|
}
|
|
function abortParsingListOrMoveToNextToken(kind) {
|
|
parsingContextErrors(kind);
|
|
if (isInSomeParsingContext()) {
|
|
return true;
|
|
}
|
|
nextToken();
|
|
return false;
|
|
}
|
|
function parsingContextErrors(context) {
|
|
switch (context) {
|
|
case ParsingContext.SourceElements:
|
|
return token() === 88 /* DefaultKeyword */ ? parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(93 /* ExportKeyword */)) : parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
|
|
case ParsingContext.BlockStatements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected);
|
|
case ParsingContext.SwitchClauses:
|
|
return parseErrorAtCurrentToken(Diagnostics.case_or_default_expected);
|
|
case ParsingContext.SwitchClauseStatements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
|
|
case ParsingContext.RestProperties:
|
|
case ParsingContext.TypeMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
|
|
case ParsingContext.ClassMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_A_constructor_method_accessor_or_property_was_expected);
|
|
case ParsingContext.EnumMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Enum_member_expected);
|
|
case ParsingContext.HeritageClauseElement:
|
|
return parseErrorAtCurrentToken(Diagnostics.Expression_expected);
|
|
case ParsingContext.VariableDeclarations:
|
|
return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_variable_declaration_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Variable_declaration_expected);
|
|
case ParsingContext.ObjectBindingElements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_destructuring_pattern_expected);
|
|
case ParsingContext.ArrayBindingElements:
|
|
return parseErrorAtCurrentToken(Diagnostics.Array_element_destructuring_pattern_expected);
|
|
case ParsingContext.ArgumentExpressions:
|
|
return parseErrorAtCurrentToken(Diagnostics.Argument_expression_expected);
|
|
case ParsingContext.ObjectLiteralMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Property_assignment_expected);
|
|
case ParsingContext.ArrayLiteralMembers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Expression_or_comma_expected);
|
|
case ParsingContext.JSDocParameters:
|
|
return parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
|
|
case ParsingContext.Parameters:
|
|
return isKeyword(token()) ? parseErrorAtCurrentToken(Diagnostics._0_is_not_allowed_as_a_parameter_name, tokenToString(token())) : parseErrorAtCurrentToken(Diagnostics.Parameter_declaration_expected);
|
|
case ParsingContext.TypeParameters:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_parameter_declaration_expected);
|
|
case ParsingContext.TypeArguments:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_argument_expected);
|
|
case ParsingContext.TupleElementTypes:
|
|
return parseErrorAtCurrentToken(Diagnostics.Type_expected);
|
|
case ParsingContext.HeritageClauses:
|
|
return parseErrorAtCurrentToken(Diagnostics.Unexpected_token_expected);
|
|
case ParsingContext.ImportOrExportSpecifiers:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.JsxAttributes:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.JsxChildren:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
|
|
case ParsingContext.AssertEntries:
|
|
return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
|
|
case ParsingContext.Count:
|
|
return Debug.fail("ParsingContext.Count used as a context");
|
|
default:
|
|
Debug.assertNever(context);
|
|
}
|
|
}
|
|
function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << kind;
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
let commaStart = -1;
|
|
while (true) {
|
|
if (isListElement2(kind, false)) {
|
|
const startPos = scanner2.getStartPos();
|
|
const result = parseListElement(kind, parseElement);
|
|
if (!result) {
|
|
parsingContext = saveParsingContext;
|
|
return void 0;
|
|
}
|
|
list.push(result);
|
|
commaStart = scanner2.getTokenPos();
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
continue;
|
|
}
|
|
commaStart = -1;
|
|
if (isListTerminator(kind)) {
|
|
break;
|
|
}
|
|
parseExpected(27 /* CommaToken */, getExpectedCommaDiagnostic(kind));
|
|
if (considerSemicolonAsDelimiter && token() === 26 /* SemicolonToken */ && !scanner2.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
}
|
|
if (startPos === scanner2.getStartPos()) {
|
|
nextToken();
|
|
}
|
|
continue;
|
|
}
|
|
if (isListTerminator(kind)) {
|
|
break;
|
|
}
|
|
if (abortParsingListOrMoveToNextToken(kind)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray2(list, listPos, void 0, commaStart >= 0);
|
|
}
|
|
function getExpectedCommaDiagnostic(kind) {
|
|
return kind === ParsingContext.EnumMembers ? Diagnostics.An_enum_member_name_must_be_followed_by_a_or : void 0;
|
|
}
|
|
function createMissingList() {
|
|
const list = createNodeArray2([], getNodePos());
|
|
list.isMissingList = true;
|
|
return list;
|
|
}
|
|
function isMissingList(arr) {
|
|
return !!arr.isMissingList;
|
|
}
|
|
function parseBracketedList(kind, parseElement, open, close2) {
|
|
if (parseExpected(open)) {
|
|
const result = parseDelimitedList(kind, parseElement);
|
|
parseExpected(close2);
|
|
return result;
|
|
}
|
|
return createMissingList();
|
|
}
|
|
function parseEntityName(allowReservedWords, diagnosticMessage) {
|
|
const pos = getNodePos();
|
|
let entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage);
|
|
let dotPos = getNodePos();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
entity.jsdocDotPos = dotPos;
|
|
break;
|
|
}
|
|
dotPos = getNodePos();
|
|
entity = finishNode(
|
|
factory2.createQualifiedName(
|
|
entity,
|
|
parseRightSideOfDot(allowReservedWords, false)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
return entity;
|
|
}
|
|
function createQualifiedName2(entity, name) {
|
|
return finishNode(factory2.createQualifiedName(entity, name), entity.pos);
|
|
}
|
|
function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) {
|
|
if (scanner2.hasPrecedingLineBreak() && tokenIsIdentifierOrKeyword(token())) {
|
|
const matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
|
|
if (matchesPattern) {
|
|
return createMissingNode(79 /* Identifier */, true, Diagnostics.Identifier_expected);
|
|
}
|
|
}
|
|
if (token() === 80 /* PrivateIdentifier */) {
|
|
const node = parsePrivateIdentifier();
|
|
return allowPrivateIdentifiers ? node : createMissingNode(79 /* Identifier */, true, Diagnostics.Identifier_expected);
|
|
}
|
|
return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
|
|
}
|
|
function parseTemplateSpans(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
const list = [];
|
|
let node;
|
|
do {
|
|
node = parseTemplateSpan(isTaggedTemplate);
|
|
list.push(node);
|
|
} while (node.literal.kind === 16 /* TemplateMiddle */);
|
|
return createNodeArray2(list, pos);
|
|
}
|
|
function parseTemplateExpression(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateExpression(
|
|
parseTemplateHead(isTaggedTemplate),
|
|
parseTemplateSpans(isTaggedTemplate)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseTemplateType() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateLiteralType(
|
|
parseTemplateHead(false),
|
|
parseTemplateTypeSpans()
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseTemplateTypeSpans() {
|
|
const pos = getNodePos();
|
|
const list = [];
|
|
let node;
|
|
do {
|
|
node = parseTemplateTypeSpan();
|
|
list.push(node);
|
|
} while (node.literal.kind === 16 /* TemplateMiddle */);
|
|
return createNodeArray2(list, pos);
|
|
}
|
|
function parseTemplateTypeSpan() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateLiteralTypeSpan(
|
|
parseType(),
|
|
parseLiteralOfTemplateSpan(false)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseLiteralOfTemplateSpan(isTaggedTemplate) {
|
|
if (token() === 19 /* CloseBraceToken */) {
|
|
reScanTemplateToken(isTaggedTemplate);
|
|
return parseTemplateMiddleOrTemplateTail();
|
|
} else {
|
|
return parseExpectedToken(17 /* TemplateTail */, Diagnostics._0_expected, tokenToString(19 /* CloseBraceToken */));
|
|
}
|
|
}
|
|
function parseTemplateSpan(isTaggedTemplate) {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTemplateSpan(
|
|
allowInAnd(parseExpression),
|
|
parseLiteralOfTemplateSpan(isTaggedTemplate)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseLiteralNode() {
|
|
return parseLiteralLikeNode(token());
|
|
}
|
|
function parseTemplateHead(isTaggedTemplate) {
|
|
if (isTaggedTemplate) {
|
|
reScanTemplateHeadOrNoSubstitutionTemplate();
|
|
}
|
|
const fragment = parseLiteralLikeNode(token());
|
|
Debug.assert(fragment.kind === 15 /* TemplateHead */, "Template head has wrong token kind");
|
|
return fragment;
|
|
}
|
|
function parseTemplateMiddleOrTemplateTail() {
|
|
const fragment = parseLiteralLikeNode(token());
|
|
Debug.assert(fragment.kind === 16 /* TemplateMiddle */ || fragment.kind === 17 /* TemplateTail */, "Template fragment has wrong token kind");
|
|
return fragment;
|
|
}
|
|
function getTemplateLiteralRawText(kind) {
|
|
const isLast = kind === 14 /* NoSubstitutionTemplateLiteral */ || kind === 17 /* TemplateTail */;
|
|
const tokenText = scanner2.getTokenText();
|
|
return tokenText.substring(1, tokenText.length - (scanner2.isUnterminated() ? 0 : isLast ? 1 : 2));
|
|
}
|
|
function parseLiteralLikeNode(kind) {
|
|
const pos = getNodePos();
|
|
const node = isTemplateLiteralKind(kind) ? factory2.createTemplateLiteralLikeNode(kind, scanner2.getTokenValue(), getTemplateLiteralRawText(kind), scanner2.getTokenFlags() & 2048 /* TemplateLiteralLikeFlags */) : kind === 8 /* NumericLiteral */ ? factory2.createNumericLiteral(scanner2.getTokenValue(), scanner2.getNumericLiteralFlags()) : kind === 10 /* StringLiteral */ ? factory2.createStringLiteral(scanner2.getTokenValue(), void 0, scanner2.hasExtendedUnicodeEscape()) : isLiteralKind(kind) ? factory2.createLiteralLikeNode(kind, scanner2.getTokenValue()) : Debug.fail();
|
|
if (scanner2.hasExtendedUnicodeEscape()) {
|
|
node.hasExtendedUnicodeEscape = true;
|
|
}
|
|
if (scanner2.isUnterminated()) {
|
|
node.isUnterminated = true;
|
|
}
|
|
nextToken();
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseEntityNameOfTypeReference() {
|
|
return parseEntityName(true, Diagnostics.Type_expected);
|
|
}
|
|
function parseTypeArgumentsOfTypeReference() {
|
|
if (!scanner2.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* LessThanToken */) {
|
|
return parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
|
|
}
|
|
}
|
|
function parseTypeReference() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTypeReferenceNode(
|
|
parseEntityNameOfTypeReference(),
|
|
parseTypeArgumentsOfTypeReference()
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function typeHasArrowFunctionBlockingParseError(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return nodeIsMissing(node.typeName);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */: {
|
|
const { parameters, type } = node;
|
|
return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type);
|
|
}
|
|
case 193 /* ParenthesizedType */:
|
|
return typeHasArrowFunctionBlockingParseError(node.type);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function parseThisTypePredicate(lhs) {
|
|
nextToken();
|
|
return finishNode(factory2.createTypePredicateNode(void 0, lhs, parseType()), lhs.pos);
|
|
}
|
|
function parseThisTypeNode() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createThisTypeNode(), pos);
|
|
}
|
|
function parseJSDocAllType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocAllType(), pos);
|
|
}
|
|
function parseJSDocNonNullableType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocNonNullableType(parseNonArrayType(), false), pos);
|
|
}
|
|
function parseJSDocUnknownOrNullableType() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
if (token() === 27 /* CommaToken */ || token() === 19 /* CloseBraceToken */ || token() === 21 /* CloseParenToken */ || token() === 31 /* GreaterThanToken */ || token() === 63 /* EqualsToken */ || token() === 51 /* BarToken */) {
|
|
return finishNode(factory2.createJSDocUnknownType(), pos);
|
|
} else {
|
|
return finishNode(factory2.createJSDocNullableType(parseType(), false), pos);
|
|
}
|
|
}
|
|
function parseJSDocFunctionType() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (lookAhead(nextTokenIsOpenParen)) {
|
|
nextToken();
|
|
const parameters = parseParameters(4 /* Type */ | 32 /* JSDoc */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
return withJSDoc(finishNode(factory2.createJSDocFunctionType(parameters, type), pos), hasJSDoc);
|
|
}
|
|
return finishNode(factory2.createTypeReferenceNode(parseIdentifierName(), void 0), pos);
|
|
}
|
|
function parseJSDocParameter() {
|
|
const pos = getNodePos();
|
|
let name;
|
|
if (token() === 108 /* ThisKeyword */ || token() === 103 /* NewKeyword */) {
|
|
name = parseIdentifierName();
|
|
parseExpected(58 /* ColonToken */);
|
|
}
|
|
return finishNode(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
parseJSDocType(),
|
|
void 0
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseJSDocType() {
|
|
scanner2.setInJSDocType(true);
|
|
const pos = getNodePos();
|
|
if (parseOptional(142 /* ModuleKeyword */)) {
|
|
const moduleTag = factory2.createJSDocNamepathType(void 0);
|
|
terminate:
|
|
while (true) {
|
|
switch (token()) {
|
|
case 19 /* CloseBraceToken */:
|
|
case 1 /* EndOfFileToken */:
|
|
case 27 /* CommaToken */:
|
|
case 5 /* WhitespaceTrivia */:
|
|
break terminate;
|
|
default:
|
|
nextTokenJSDoc();
|
|
}
|
|
}
|
|
scanner2.setInJSDocType(false);
|
|
return finishNode(moduleTag, pos);
|
|
}
|
|
const hasDotDotDot = parseOptional(25 /* DotDotDotToken */);
|
|
let type = parseTypeOrTypePredicate();
|
|
scanner2.setInJSDocType(false);
|
|
if (hasDotDotDot) {
|
|
type = finishNode(factory2.createJSDocVariadicType(type), pos);
|
|
}
|
|
if (token() === 63 /* EqualsToken */) {
|
|
nextToken();
|
|
return finishNode(factory2.createJSDocOptionalType(type), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeQuery() {
|
|
const pos = getNodePos();
|
|
parseExpected(112 /* TypeOfKeyword */);
|
|
const entityName = parseEntityName(true);
|
|
const typeArguments = !scanner2.hasPrecedingLineBreak() ? tryParseTypeArguments() : void 0;
|
|
return finishNode(factory2.createTypeQueryNode(entityName, typeArguments), pos);
|
|
}
|
|
function parseTypeParameter() {
|
|
const pos = getNodePos();
|
|
const modifiers = parseModifiers();
|
|
const name = parseIdentifier();
|
|
let constraint;
|
|
let expression;
|
|
if (parseOptional(94 /* ExtendsKeyword */)) {
|
|
if (isStartOfType() || !isStartOfExpression()) {
|
|
constraint = parseType();
|
|
} else {
|
|
expression = parseUnaryExpressionOrHigher();
|
|
}
|
|
}
|
|
const defaultType = parseOptional(63 /* EqualsToken */) ? parseType() : void 0;
|
|
const node = factory2.createTypeParameterDeclaration(modifiers, name, constraint, defaultType);
|
|
node.expression = expression;
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseTypeParameters() {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return parseBracketedList(ParsingContext.TypeParameters, parseTypeParameter, 29 /* LessThanToken */, 31 /* GreaterThanToken */);
|
|
}
|
|
}
|
|
function isStartOfParameter(isJSDocParameter) {
|
|
return token() === 25 /* DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern() || isModifierKind(token()) || token() === 59 /* AtToken */ || isStartOfType(!isJSDocParameter);
|
|
}
|
|
function parseNameOfParameter(modifiers) {
|
|
const name = parseIdentifierOrPattern(Diagnostics.Private_identifiers_cannot_be_used_as_parameters);
|
|
if (getFullWidth(name) === 0 && !some(modifiers) && isModifierKind(token())) {
|
|
nextToken();
|
|
}
|
|
return name;
|
|
}
|
|
function isParameterNameStart() {
|
|
return isBindingIdentifier() || token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */;
|
|
}
|
|
function parseParameter(inOuterAwaitContext) {
|
|
return parseParameterWorker(inOuterAwaitContext);
|
|
}
|
|
function parseParameterForSpeculation(inOuterAwaitContext) {
|
|
return parseParameterWorker(inOuterAwaitContext, false);
|
|
}
|
|
function parseParameterWorker(inOuterAwaitContext, allowAmbiguity = true) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators);
|
|
if (token() === 108 /* ThisKeyword */) {
|
|
const node2 = factory2.createParameterDeclaration(
|
|
decorators,
|
|
void 0,
|
|
createIdentifier3(true),
|
|
void 0,
|
|
parseTypeAnnotation(),
|
|
void 0
|
|
);
|
|
if (decorators) {
|
|
parseErrorAtRange(decorators[0], Diagnostics.Decorators_may_not_be_applied_to_this_parameters);
|
|
}
|
|
return withJSDoc(finishNode(node2, pos), hasJSDoc);
|
|
}
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const modifiers = combineDecoratorsAndModifiers(decorators, parseModifiers());
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
if (!allowAmbiguity && !isParameterNameStart()) {
|
|
return void 0;
|
|
}
|
|
const node = withJSDoc(
|
|
finishNode(
|
|
factory2.createParameterDeclaration(
|
|
modifiers,
|
|
dotDotDotToken,
|
|
parseNameOfParameter(modifiers),
|
|
parseOptionalToken(57 /* QuestionToken */),
|
|
parseTypeAnnotation(),
|
|
parseInitializer()
|
|
),
|
|
pos
|
|
),
|
|
hasJSDoc
|
|
);
|
|
topLevel = savedTopLevel;
|
|
return node;
|
|
}
|
|
function parseReturnType(returnToken, isType) {
|
|
if (shouldParseReturnType(returnToken, isType)) {
|
|
return allowConditionalTypesAnd(parseTypeOrTypePredicate);
|
|
}
|
|
}
|
|
function shouldParseReturnType(returnToken, isType) {
|
|
if (returnToken === 38 /* EqualsGreaterThanToken */) {
|
|
parseExpected(returnToken);
|
|
return true;
|
|
} else if (parseOptional(58 /* ColonToken */)) {
|
|
return true;
|
|
} else if (isType && token() === 38 /* EqualsGreaterThanToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(58 /* ColonToken */));
|
|
nextToken();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseParametersWorker(flags, allowAmbiguity) {
|
|
const savedYieldContext = inYieldContext();
|
|
const savedAwaitContext = inAwaitContext();
|
|
setYieldContext(!!(flags & 1 /* Yield */));
|
|
setAwaitContext(!!(flags & 2 /* Await */));
|
|
const parameters = flags & 32 /* JSDoc */ ? parseDelimitedList(ParsingContext.JSDocParameters, parseJSDocParameter) : parseDelimitedList(ParsingContext.Parameters, () => allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext));
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return parameters;
|
|
}
|
|
function parseParameters(flags) {
|
|
if (!parseExpected(20 /* OpenParenToken */)) {
|
|
return createMissingList();
|
|
}
|
|
const parameters = parseParametersWorker(flags, true);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return parameters;
|
|
}
|
|
function parseTypeMemberSemicolon() {
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
return;
|
|
}
|
|
parseSemicolon();
|
|
}
|
|
function parseSignatureMember(kind) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (kind === 177 /* ConstructSignature */) {
|
|
parseExpected(103 /* NewKeyword */);
|
|
}
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(58 /* ColonToken */, true);
|
|
parseTypeMemberSemicolon();
|
|
const node = kind === 176 /* CallSignature */ ? factory2.createCallSignature(typeParameters, parameters, type) : factory2.createConstructSignature(typeParameters, parameters, type);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isIndexSignature() {
|
|
return token() === 22 /* OpenBracketToken */ && lookAhead(isUnambiguouslyIndexSignature);
|
|
}
|
|
function isUnambiguouslyIndexSignature() {
|
|
nextToken();
|
|
if (token() === 25 /* DotDotDotToken */ || token() === 23 /* CloseBracketToken */) {
|
|
return true;
|
|
}
|
|
if (isModifierKind(token())) {
|
|
nextToken();
|
|
if (isIdentifier2()) {
|
|
return true;
|
|
}
|
|
} else if (!isIdentifier2()) {
|
|
return false;
|
|
} else {
|
|
nextToken();
|
|
}
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */) {
|
|
return true;
|
|
}
|
|
if (token() !== 57 /* QuestionToken */) {
|
|
return false;
|
|
}
|
|
nextToken();
|
|
return token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 23 /* CloseBracketToken */;
|
|
}
|
|
function parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const parameters = parseBracketedList(ParsingContext.Parameters, () => parseParameter(false), 22 /* OpenBracketToken */, 23 /* CloseBracketToken */);
|
|
const type = parseTypeAnnotation();
|
|
parseTypeMemberSemicolon();
|
|
const node = factory2.createIndexSignature(modifiers, parameters, type);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers) {
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
let node;
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(58 /* ColonToken */, true);
|
|
node = factory2.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type);
|
|
} else {
|
|
const type = parseTypeAnnotation();
|
|
node = factory2.createPropertySignature(modifiers, name, questionToken, type);
|
|
if (token() === 63 /* EqualsToken */)
|
|
node.initializer = parseInitializer();
|
|
}
|
|
parseTypeMemberSemicolon();
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isTypeMemberStart() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 137 /* GetKeyword */ || token() === 151 /* SetKeyword */) {
|
|
return true;
|
|
}
|
|
let idToken = false;
|
|
while (isModifierKind(token())) {
|
|
idToken = true;
|
|
nextToken();
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return true;
|
|
}
|
|
if (isLiteralPropertyName()) {
|
|
idToken = true;
|
|
nextToken();
|
|
}
|
|
if (idToken) {
|
|
return token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 57 /* QuestionToken */ || token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || canParseSemicolon();
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeMember() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseSignatureMember(176 /* CallSignature */);
|
|
}
|
|
if (token() === 103 /* NewKeyword */ && lookAhead(nextTokenIsOpenParenOrLessThan)) {
|
|
return parseSignatureMember(177 /* ConstructSignature */);
|
|
}
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiers();
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, void 0, modifiers, 174 /* GetAccessor */, 4 /* Type */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, void 0, modifiers, 175 /* SetAccessor */, 4 /* Type */);
|
|
}
|
|
if (isIndexSignature()) {
|
|
return parseIndexSignatureDeclaration(pos, hasJSDoc, void 0, modifiers);
|
|
}
|
|
return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers);
|
|
}
|
|
function nextTokenIsOpenParenOrLessThan() {
|
|
nextToken();
|
|
return token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */;
|
|
}
|
|
function nextTokenIsDot() {
|
|
return nextToken() === 24 /* DotToken */;
|
|
}
|
|
function nextTokenIsOpenParenOrLessThanOrDot() {
|
|
switch (nextToken()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 24 /* DotToken */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeLiteral() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createTypeLiteralNode(parseObjectTypeMembers()), pos);
|
|
}
|
|
function parseObjectTypeMembers() {
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = parseList(ParsingContext.TypeMembers, parseTypeMember);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
return members;
|
|
}
|
|
function isStartOfMappedType() {
|
|
nextToken();
|
|
if (token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
return nextToken() === 146 /* ReadonlyKeyword */;
|
|
}
|
|
if (token() === 146 /* ReadonlyKeyword */) {
|
|
nextToken();
|
|
}
|
|
return token() === 22 /* OpenBracketToken */ && nextTokenIsIdentifier() && nextToken() === 101 /* InKeyword */;
|
|
}
|
|
function parseMappedTypeParameter() {
|
|
const pos = getNodePos();
|
|
const name = parseIdentifierName();
|
|
parseExpected(101 /* InKeyword */);
|
|
const type = parseType();
|
|
return finishNode(factory2.createTypeParameterDeclaration(void 0, name, type, void 0), pos);
|
|
}
|
|
function parseMappedType() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
let readonlyToken;
|
|
if (token() === 146 /* ReadonlyKeyword */ || token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
readonlyToken = parseTokenNode();
|
|
if (readonlyToken.kind !== 146 /* ReadonlyKeyword */) {
|
|
parseExpected(146 /* ReadonlyKeyword */);
|
|
}
|
|
}
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const typeParameter = parseMappedTypeParameter();
|
|
const nameType = parseOptional(128 /* AsKeyword */) ? parseType() : void 0;
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
let questionToken;
|
|
if (token() === 57 /* QuestionToken */ || token() === 39 /* PlusToken */ || token() === 40 /* MinusToken */) {
|
|
questionToken = parseTokenNode();
|
|
if (questionToken.kind !== 57 /* QuestionToken */) {
|
|
parseExpected(57 /* QuestionToken */);
|
|
}
|
|
}
|
|
const type = parseTypeAnnotation();
|
|
parseSemicolon();
|
|
const members = parseList(ParsingContext.TypeMembers, parseTypeMember);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos);
|
|
}
|
|
function parseTupleElementType() {
|
|
const pos = getNodePos();
|
|
if (parseOptional(25 /* DotDotDotToken */)) {
|
|
return finishNode(factory2.createRestTypeNode(parseType()), pos);
|
|
}
|
|
const type = parseType();
|
|
if (isJSDocNullableType(type) && type.pos === type.type.pos) {
|
|
const node = factory2.createOptionalTypeNode(type.type);
|
|
setTextRange(node, type);
|
|
node.flags = type.flags;
|
|
return node;
|
|
}
|
|
return type;
|
|
}
|
|
function isNextTokenColonOrQuestionColon() {
|
|
return nextToken() === 58 /* ColonToken */ || token() === 57 /* QuestionToken */ && nextToken() === 58 /* ColonToken */;
|
|
}
|
|
function isTupleElementName() {
|
|
if (token() === 25 /* DotDotDotToken */) {
|
|
return tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon();
|
|
}
|
|
return tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon();
|
|
}
|
|
function parseTupleElementNameOrTupleElementType() {
|
|
if (lookAhead(isTupleElementName)) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const name = parseIdentifierName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const type = parseTupleElementType();
|
|
const node = factory2.createNamedTupleMember(dotDotDotToken, name, questionToken, type);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
return parseTupleElementType();
|
|
}
|
|
function parseTupleType() {
|
|
const pos = getNodePos();
|
|
return finishNode(
|
|
factory2.createTupleTypeNode(
|
|
parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementNameOrTupleElementType, 22 /* OpenBracketToken */, 23 /* CloseBracketToken */)
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseParenthesizedType() {
|
|
const pos = getNodePos();
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const type = parseType();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return finishNode(factory2.createParenthesizedType(type), pos);
|
|
}
|
|
function parseModifiersForConstructorType() {
|
|
let modifiers;
|
|
if (token() === 126 /* AbstractKeyword */) {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
const modifier = finishNode(factory2.createToken(126 /* AbstractKeyword */), pos);
|
|
modifiers = createNodeArray2([modifier], pos);
|
|
}
|
|
return modifiers;
|
|
}
|
|
function parseFunctionOrConstructorType() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiersForConstructorType();
|
|
const isConstructorType = parseOptional(103 /* NewKeyword */);
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(4 /* Type */);
|
|
const type = parseReturnType(38 /* EqualsGreaterThanToken */, false);
|
|
const node = isConstructorType ? factory2.createConstructorTypeNode(modifiers, typeParameters, parameters, type) : factory2.createFunctionTypeNode(typeParameters, parameters, type);
|
|
if (!isConstructorType)
|
|
node.modifiers = modifiers;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseKeywordAndNoDot() {
|
|
const node = parseTokenNode();
|
|
return token() === 24 /* DotToken */ ? void 0 : node;
|
|
}
|
|
function parseLiteralTypeNode(negative) {
|
|
const pos = getNodePos();
|
|
if (negative) {
|
|
nextToken();
|
|
}
|
|
let expression = token() === 110 /* TrueKeyword */ || token() === 95 /* FalseKeyword */ || token() === 104 /* NullKeyword */ ? parseTokenNode() : parseLiteralLikeNode(token());
|
|
if (negative) {
|
|
expression = finishNode(factory2.createPrefixUnaryExpression(40 /* MinusToken */, expression), pos);
|
|
}
|
|
return finishNode(factory2.createLiteralTypeNode(expression), pos);
|
|
}
|
|
function isStartOfTypeOfImportType() {
|
|
nextToken();
|
|
return token() === 100 /* ImportKeyword */;
|
|
}
|
|
function parseImportTypeAssertions() {
|
|
const pos = getNodePos();
|
|
const openBracePosition = scanner2.getTokenPos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const multiLine = scanner2.hasPrecedingLineBreak();
|
|
parseExpected(130 /* AssertKeyword */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const clause = parseAssertClause(true);
|
|
if (!parseExpected(19 /* CloseBraceToken */)) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
if (lastError && lastError.code === Diagnostics._0_expected.code) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")
|
|
);
|
|
}
|
|
}
|
|
return finishNode(factory2.createImportTypeAssertionContainer(clause, multiLine), pos);
|
|
}
|
|
function parseImportType() {
|
|
sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
|
|
const pos = getNodePos();
|
|
const isTypeOf = parseOptional(112 /* TypeOfKeyword */);
|
|
parseExpected(100 /* ImportKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const type = parseType();
|
|
let assertions;
|
|
if (parseOptional(27 /* CommaToken */)) {
|
|
assertions = parseImportTypeAssertions();
|
|
}
|
|
parseExpected(21 /* CloseParenToken */);
|
|
const qualifier = parseOptional(24 /* DotToken */) ? parseEntityNameOfTypeReference() : void 0;
|
|
const typeArguments = parseTypeArgumentsOfTypeReference();
|
|
return finishNode(factory2.createImportTypeNode(type, assertions, qualifier, typeArguments, isTypeOf), pos);
|
|
}
|
|
function nextTokenIsNumericOrBigIntLiteral() {
|
|
nextToken();
|
|
return token() === 8 /* NumericLiteral */ || token() === 9 /* BigIntLiteral */;
|
|
}
|
|
function parseNonArrayType() {
|
|
switch (token()) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
return tryParse(parseKeywordAndNoDot) || parseTypeReference();
|
|
case 66 /* AsteriskEqualsToken */:
|
|
scanner2.reScanAsteriskEqualsToken();
|
|
case 41 /* AsteriskToken */:
|
|
return parseJSDocAllType();
|
|
case 60 /* QuestionQuestionToken */:
|
|
scanner2.reScanQuestionToken();
|
|
case 57 /* QuestionToken */:
|
|
return parseJSDocUnknownOrNullableType();
|
|
case 98 /* FunctionKeyword */:
|
|
return parseJSDocFunctionType();
|
|
case 53 /* ExclamationToken */:
|
|
return parseJSDocNonNullableType();
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
return parseLiteralTypeNode();
|
|
case 40 /* MinusToken */:
|
|
return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(true) : parseTypeReference();
|
|
case 114 /* VoidKeyword */:
|
|
return parseTokenNode();
|
|
case 108 /* ThisKeyword */: {
|
|
const thisKeyword = parseThisTypeNode();
|
|
if (token() === 140 /* IsKeyword */ && !scanner2.hasPrecedingLineBreak()) {
|
|
return parseThisTypePredicate(thisKeyword);
|
|
} else {
|
|
return thisKeyword;
|
|
}
|
|
}
|
|
case 112 /* TypeOfKeyword */:
|
|
return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery();
|
|
case 18 /* OpenBraceToken */:
|
|
return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral();
|
|
case 22 /* OpenBracketToken */:
|
|
return parseTupleType();
|
|
case 20 /* OpenParenToken */:
|
|
return parseParenthesizedType();
|
|
case 100 /* ImportKeyword */:
|
|
return parseImportType();
|
|
case 129 /* AssertsKeyword */:
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference();
|
|
case 15 /* TemplateHead */:
|
|
return parseTemplateType();
|
|
default:
|
|
return parseTypeReference();
|
|
}
|
|
}
|
|
function isStartOfType(inStartOfParameter) {
|
|
switch (token()) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 156 /* UniqueKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 108 /* ThisKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 22 /* OpenBracketToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 51 /* BarToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 103 /* NewKeyword */:
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 41 /* AsteriskToken */:
|
|
case 57 /* QuestionToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 25 /* DotDotDotToken */:
|
|
case 138 /* InferKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
case 129 /* AssertsKeyword */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
return true;
|
|
case 98 /* FunctionKeyword */:
|
|
return !inStartOfParameter;
|
|
case 40 /* MinusToken */:
|
|
return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral);
|
|
case 20 /* OpenParenToken */:
|
|
return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType);
|
|
default:
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfParenthesizedOrFunctionType() {
|
|
nextToken();
|
|
return token() === 21 /* CloseParenToken */ || isStartOfParameter(false) || isStartOfType();
|
|
}
|
|
function parsePostfixTypeOrHigher() {
|
|
const pos = getNodePos();
|
|
let type = parseNonArrayType();
|
|
while (!scanner2.hasPrecedingLineBreak()) {
|
|
switch (token()) {
|
|
case 53 /* ExclamationToken */:
|
|
nextToken();
|
|
type = finishNode(factory2.createJSDocNonNullableType(type, true), pos);
|
|
break;
|
|
case 57 /* QuestionToken */:
|
|
if (lookAhead(nextTokenIsStartOfType)) {
|
|
return type;
|
|
}
|
|
nextToken();
|
|
type = finishNode(factory2.createJSDocNullableType(type, true), pos);
|
|
break;
|
|
case 22 /* OpenBracketToken */:
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
if (isStartOfType()) {
|
|
const indexType = parseType();
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
type = finishNode(factory2.createIndexedAccessTypeNode(type, indexType), pos);
|
|
} else {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
type = finishNode(factory2.createArrayTypeNode(type), pos);
|
|
}
|
|
break;
|
|
default:
|
|
return type;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeOperator(operator) {
|
|
const pos = getNodePos();
|
|
parseExpected(operator);
|
|
return finishNode(factory2.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos);
|
|
}
|
|
function tryParseConstraintOfInferType() {
|
|
if (parseOptional(94 /* ExtendsKeyword */)) {
|
|
const constraint = disallowConditionalTypesAnd(parseType);
|
|
if (inDisallowConditionalTypesContext() || token() !== 57 /* QuestionToken */) {
|
|
return constraint;
|
|
}
|
|
}
|
|
}
|
|
function parseTypeParameterOfInferType() {
|
|
const pos = getNodePos();
|
|
const name = parseIdentifier();
|
|
const constraint = tryParse(tryParseConstraintOfInferType);
|
|
const node = factory2.createTypeParameterDeclaration(void 0, name, constraint);
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseInferType() {
|
|
const pos = getNodePos();
|
|
parseExpected(138 /* InferKeyword */);
|
|
return finishNode(factory2.createInferTypeNode(parseTypeParameterOfInferType()), pos);
|
|
}
|
|
function parseTypeOperatorOrHigher() {
|
|
const operator = token();
|
|
switch (operator) {
|
|
case 141 /* KeyOfKeyword */:
|
|
case 156 /* UniqueKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
return parseTypeOperator(operator);
|
|
case 138 /* InferKeyword */:
|
|
return parseInferType();
|
|
}
|
|
return allowConditionalTypesAnd(parsePostfixTypeOrHigher);
|
|
}
|
|
function parseFunctionOrConstructorTypeToError(isInUnionType) {
|
|
if (isStartOfFunctionTypeOrConstructorType()) {
|
|
const type = parseFunctionOrConstructorType();
|
|
let diagnostic;
|
|
if (isFunctionTypeNode(type)) {
|
|
diagnostic = isInUnionType ? Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type : Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
|
|
} else {
|
|
diagnostic = isInUnionType ? Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type : Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type;
|
|
}
|
|
parseErrorAtRange(type, diagnostic);
|
|
return type;
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseUnionOrIntersectionType(operator, parseConstituentType, createTypeNode) {
|
|
const pos = getNodePos();
|
|
const isUnionType = operator === 51 /* BarToken */;
|
|
const hasLeadingOperator = parseOptional(operator);
|
|
let type = hasLeadingOperator && parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType();
|
|
if (token() === operator || hasLeadingOperator) {
|
|
const types = [type];
|
|
while (parseOptional(operator)) {
|
|
types.push(parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType());
|
|
}
|
|
type = finishNode(createTypeNode(createNodeArray2(types, pos)), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseIntersectionTypeOrHigher() {
|
|
return parseUnionOrIntersectionType(50 /* AmpersandToken */, parseTypeOperatorOrHigher, factory2.createIntersectionTypeNode);
|
|
}
|
|
function parseUnionTypeOrHigher() {
|
|
return parseUnionOrIntersectionType(51 /* BarToken */, parseIntersectionTypeOrHigher, factory2.createUnionTypeNode);
|
|
}
|
|
function nextTokenIsNewKeyword() {
|
|
nextToken();
|
|
return token() === 103 /* NewKeyword */;
|
|
}
|
|
function isStartOfFunctionTypeOrConstructorType() {
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return true;
|
|
}
|
|
if (token() === 20 /* OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType)) {
|
|
return true;
|
|
}
|
|
return token() === 103 /* NewKeyword */ || token() === 126 /* AbstractKeyword */ && lookAhead(nextTokenIsNewKeyword);
|
|
}
|
|
function skipParameterStart() {
|
|
if (isModifierKind(token())) {
|
|
parseModifiers();
|
|
}
|
|
if (isIdentifier2() || token() === 108 /* ThisKeyword */) {
|
|
nextToken();
|
|
return true;
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */ || token() === 18 /* OpenBraceToken */) {
|
|
const previousErrorCount = parseDiagnostics.length;
|
|
parseIdentifierOrPattern();
|
|
return previousErrorCount === parseDiagnostics.length;
|
|
}
|
|
return false;
|
|
}
|
|
function isUnambiguouslyStartOfFunctionType() {
|
|
nextToken();
|
|
if (token() === 21 /* CloseParenToken */ || token() === 25 /* DotDotDotToken */) {
|
|
return true;
|
|
}
|
|
if (skipParameterStart()) {
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 57 /* QuestionToken */ || token() === 63 /* EqualsToken */) {
|
|
return true;
|
|
}
|
|
if (token() === 21 /* CloseParenToken */) {
|
|
nextToken();
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseTypeOrTypePredicate() {
|
|
const pos = getNodePos();
|
|
const typePredicateVariable = isIdentifier2() && tryParse(parseTypePredicatePrefix);
|
|
const type = parseType();
|
|
if (typePredicateVariable) {
|
|
return finishNode(factory2.createTypePredicateNode(void 0, typePredicateVariable, type), pos);
|
|
} else {
|
|
return type;
|
|
}
|
|
}
|
|
function parseTypePredicatePrefix() {
|
|
const id = parseIdentifier();
|
|
if (token() === 140 /* IsKeyword */ && !scanner2.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
return id;
|
|
}
|
|
}
|
|
function parseAssertsTypePredicate() {
|
|
const pos = getNodePos();
|
|
const assertsModifier = parseExpectedToken(129 /* AssertsKeyword */);
|
|
const parameterName = token() === 108 /* ThisKeyword */ ? parseThisTypeNode() : parseIdentifier();
|
|
const type = parseOptional(140 /* IsKeyword */) ? parseType() : void 0;
|
|
return finishNode(factory2.createTypePredicateNode(assertsModifier, parameterName, type), pos);
|
|
}
|
|
function parseType() {
|
|
if (contextFlags & 40960 /* TypeExcludesFlags */) {
|
|
return doOutsideOfContext(40960 /* TypeExcludesFlags */, parseType);
|
|
}
|
|
if (isStartOfFunctionTypeOrConstructorType()) {
|
|
return parseFunctionOrConstructorType();
|
|
}
|
|
const pos = getNodePos();
|
|
const type = parseUnionTypeOrHigher();
|
|
if (!inDisallowConditionalTypesContext() && !scanner2.hasPrecedingLineBreak() && parseOptional(94 /* ExtendsKeyword */)) {
|
|
const extendsType = disallowConditionalTypesAnd(parseType);
|
|
parseExpected(57 /* QuestionToken */);
|
|
const trueType = allowConditionalTypesAnd(parseType);
|
|
parseExpected(58 /* ColonToken */);
|
|
const falseType = allowConditionalTypesAnd(parseType);
|
|
return finishNode(factory2.createConditionalTypeNode(type, extendsType, trueType, falseType), pos);
|
|
}
|
|
return type;
|
|
}
|
|
function parseTypeAnnotation() {
|
|
return parseOptional(58 /* ColonToken */) ? parseType() : void 0;
|
|
}
|
|
function isStartOfLeftHandSideExpression() {
|
|
switch (token()) {
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 20 /* OpenParenToken */:
|
|
case 22 /* OpenBracketToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 103 /* NewKeyword */:
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 79 /* Identifier */:
|
|
return true;
|
|
case 100 /* ImportKeyword */:
|
|
return lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
|
|
default:
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfExpression() {
|
|
if (isStartOfLeftHandSideExpression()) {
|
|
return true;
|
|
}
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 89 /* DeleteKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 133 /* AwaitKeyword */:
|
|
case 125 /* YieldKeyword */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return true;
|
|
default:
|
|
if (isBinaryOperator2()) {
|
|
return true;
|
|
}
|
|
return isIdentifier2();
|
|
}
|
|
}
|
|
function isStartOfExpressionStatement() {
|
|
return token() !== 18 /* OpenBraceToken */ && token() !== 98 /* FunctionKeyword */ && token() !== 84 /* ClassKeyword */ && token() !== 59 /* AtToken */ && isStartOfExpression();
|
|
}
|
|
function parseExpression() {
|
|
const saveDecoratorContext = inDecoratorContext();
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(false);
|
|
}
|
|
const pos = getNodePos();
|
|
let expr = parseAssignmentExpressionOrHigher(true);
|
|
let operatorToken;
|
|
while (operatorToken = parseOptionalToken(27 /* CommaToken */)) {
|
|
expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(true), pos);
|
|
}
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(true);
|
|
}
|
|
return expr;
|
|
}
|
|
function parseInitializer() {
|
|
return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(true) : void 0;
|
|
}
|
|
function parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) {
|
|
if (isYieldExpression2()) {
|
|
return parseYieldExpression();
|
|
}
|
|
const arrowExpression = tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction);
|
|
if (arrowExpression) {
|
|
return arrowExpression;
|
|
}
|
|
const pos = getNodePos();
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
|
|
return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, void 0);
|
|
}
|
|
if (isLeftHandSideExpression(expr) && isAssignmentOperator(reScanGreaterToken())) {
|
|
return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction), pos);
|
|
}
|
|
return parseConditionalExpressionRest(expr, pos, allowReturnTypeInArrowFunction);
|
|
}
|
|
function isYieldExpression2() {
|
|
if (token() === 125 /* YieldKeyword */) {
|
|
if (inYieldContext()) {
|
|
return true;
|
|
}
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
|
|
}
|
|
return false;
|
|
}
|
|
function nextTokenIsIdentifierOnSameLine() {
|
|
nextToken();
|
|
return !scanner2.hasPrecedingLineBreak() && isIdentifier2();
|
|
}
|
|
function parseYieldExpression() {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
if (!scanner2.hasPrecedingLineBreak() && (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
|
|
return finishNode(
|
|
factory2.createYieldExpression(
|
|
parseOptionalToken(41 /* AsteriskToken */),
|
|
parseAssignmentExpressionOrHigher(true)
|
|
),
|
|
pos
|
|
);
|
|
} else {
|
|
return finishNode(factory2.createYieldExpression(void 0, void 0), pos);
|
|
}
|
|
}
|
|
function parseSimpleArrowFunctionExpression(pos, identifier, allowReturnTypeInArrowFunction, asyncModifier) {
|
|
Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
|
|
const parameter = factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
identifier,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
finishNode(parameter, identifier.pos);
|
|
const parameters = createNodeArray2([parameter], parameter.pos, parameter.end);
|
|
const equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
|
|
const body = parseArrowFunctionExpressionBody(!!asyncModifier, allowReturnTypeInArrowFunction);
|
|
const node = factory2.createArrowFunction(asyncModifier, void 0, parameters, void 0, equalsGreaterThanToken, body);
|
|
return addJSDocComment(finishNode(node, pos));
|
|
}
|
|
function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
const triState = isParenthesizedArrowFunctionExpression();
|
|
if (triState === Tristate.False) {
|
|
return void 0;
|
|
}
|
|
return triState === Tristate.True ? parseParenthesizedArrowFunctionExpression(true, true) : tryParse(() => parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction));
|
|
}
|
|
function isParenthesizedArrowFunctionExpression() {
|
|
if (token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */ || token() === 132 /* AsyncKeyword */) {
|
|
return lookAhead(isParenthesizedArrowFunctionExpressionWorker);
|
|
}
|
|
if (token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
function isParenthesizedArrowFunctionExpressionWorker() {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
nextToken();
|
|
if (scanner2.hasPrecedingLineBreak()) {
|
|
return Tristate.False;
|
|
}
|
|
if (token() !== 20 /* OpenParenToken */ && token() !== 29 /* LessThanToken */) {
|
|
return Tristate.False;
|
|
}
|
|
}
|
|
const first2 = token();
|
|
const second = nextToken();
|
|
if (first2 === 20 /* OpenParenToken */) {
|
|
if (second === 21 /* CloseParenToken */) {
|
|
const third = nextToken();
|
|
switch (third) {
|
|
case 38 /* EqualsGreaterThanToken */:
|
|
case 58 /* ColonToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
return Tristate.True;
|
|
default:
|
|
return Tristate.False;
|
|
}
|
|
}
|
|
if (second === 22 /* OpenBracketToken */ || second === 18 /* OpenBraceToken */) {
|
|
return Tristate.Unknown;
|
|
}
|
|
if (second === 25 /* DotDotDotToken */) {
|
|
return Tristate.True;
|
|
}
|
|
if (isModifierKind(second) && second !== 132 /* AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) {
|
|
if (nextToken() === 128 /* AsKeyword */) {
|
|
return Tristate.False;
|
|
}
|
|
return Tristate.True;
|
|
}
|
|
if (!isIdentifier2() && second !== 108 /* ThisKeyword */) {
|
|
return Tristate.False;
|
|
}
|
|
switch (nextToken()) {
|
|
case 58 /* ColonToken */:
|
|
return Tristate.True;
|
|
case 57 /* QuestionToken */:
|
|
nextToken();
|
|
if (token() === 58 /* ColonToken */ || token() === 27 /* CommaToken */ || token() === 63 /* EqualsToken */ || token() === 21 /* CloseParenToken */) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
case 27 /* CommaToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 21 /* CloseParenToken */:
|
|
return Tristate.Unknown;
|
|
}
|
|
return Tristate.False;
|
|
} else {
|
|
Debug.assert(first2 === 29 /* LessThanToken */);
|
|
if (!isIdentifier2()) {
|
|
return Tristate.False;
|
|
}
|
|
if (languageVariant === 1 /* JSX */) {
|
|
const isArrowFunctionInJsx = lookAhead(() => {
|
|
const third = nextToken();
|
|
if (third === 94 /* ExtendsKeyword */) {
|
|
const fourth = nextToken();
|
|
switch (fourth) {
|
|
case 63 /* EqualsToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
} else if (third === 27 /* CommaToken */ || third === 63 /* EqualsToken */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
if (isArrowFunctionInJsx) {
|
|
return Tristate.True;
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
return Tristate.Unknown;
|
|
}
|
|
}
|
|
function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
const tokenPos = scanner2.getTokenPos();
|
|
if (notParenthesizedArrow == null ? void 0 : notParenthesizedArrow.has(tokenPos)) {
|
|
return void 0;
|
|
}
|
|
const result = parseParenthesizedArrowFunctionExpression(false, allowReturnTypeInArrowFunction);
|
|
if (!result) {
|
|
(notParenthesizedArrow || (notParenthesizedArrow = /* @__PURE__ */ new Set())).add(tokenPos);
|
|
}
|
|
return result;
|
|
}
|
|
function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === Tristate.True) {
|
|
const pos = getNodePos();
|
|
const asyncModifier = parseModifiersForArrowFunction();
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, asyncModifier);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isUnParenthesizedAsyncArrowFunctionWorker() {
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
nextToken();
|
|
if (scanner2.hasPrecedingLineBreak() || token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.False;
|
|
}
|
|
const expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
|
|
if (!scanner2.hasPrecedingLineBreak() && expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
|
|
return Tristate.True;
|
|
}
|
|
}
|
|
return Tristate.False;
|
|
}
|
|
function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiersForArrowFunction();
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
let parameters;
|
|
if (!parseExpected(20 /* OpenParenToken */)) {
|
|
if (!allowAmbiguity) {
|
|
return void 0;
|
|
}
|
|
parameters = createMissingList();
|
|
} else {
|
|
if (!allowAmbiguity) {
|
|
const maybeParameters = parseParametersWorker(isAsync, allowAmbiguity);
|
|
if (!maybeParameters) {
|
|
return void 0;
|
|
}
|
|
parameters = maybeParameters;
|
|
} else {
|
|
parameters = parseParametersWorker(isAsync, allowAmbiguity);
|
|
}
|
|
if (!parseExpected(21 /* CloseParenToken */) && !allowAmbiguity) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const hasReturnColon = token() === 58 /* ColonToken */;
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
|
|
return void 0;
|
|
}
|
|
let unwrappedType = type;
|
|
while ((unwrappedType == null ? void 0 : unwrappedType.kind) === 193 /* ParenthesizedType */) {
|
|
unwrappedType = unwrappedType.type;
|
|
}
|
|
const hasJSDocFunctionType = unwrappedType && isJSDocFunctionType(unwrappedType);
|
|
if (!allowAmbiguity && token() !== 38 /* EqualsGreaterThanToken */ && (hasJSDocFunctionType || token() !== 18 /* OpenBraceToken */)) {
|
|
return void 0;
|
|
}
|
|
const lastToken = token();
|
|
const equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
|
|
const body = lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */ ? parseArrowFunctionExpressionBody(some(modifiers, isAsyncModifier), allowReturnTypeInArrowFunction) : parseIdentifier();
|
|
if (!allowReturnTypeInArrowFunction && hasReturnColon) {
|
|
if (token() !== 58 /* ColonToken */) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const node = factory2.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseArrowFunctionExpressionBody(isAsync, allowReturnTypeInArrowFunction) {
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
|
|
}
|
|
if (token() !== 26 /* SemicolonToken */ && token() !== 98 /* FunctionKeyword */ && token() !== 84 /* ClassKeyword */ && isStartOfStatement() && !isStartOfExpressionStatement()) {
|
|
return parseFunctionBlock(16 /* IgnoreMissingOpenBrace */ | (isAsync ? 2 /* Await */ : 0 /* None */));
|
|
}
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const node = isAsync ? doInAwaitContext(() => parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction)) : doOutsideOfAwaitContext(() => parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction));
|
|
topLevel = savedTopLevel;
|
|
return node;
|
|
}
|
|
function parseConditionalExpressionRest(leftOperand, pos, allowReturnTypeInArrowFunction) {
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
if (!questionToken) {
|
|
return leftOperand;
|
|
}
|
|
let colonToken;
|
|
return finishNode(
|
|
factory2.createConditionalExpression(
|
|
leftOperand,
|
|
questionToken,
|
|
doOutsideOfContext(disallowInAndDecoratorContext, () => parseAssignmentExpressionOrHigher(false)),
|
|
colonToken = parseExpectedToken(58 /* ColonToken */),
|
|
nodeIsPresent(colonToken) ? parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) : createMissingNode(79 /* Identifier */, false, Diagnostics._0_expected, tokenToString(58 /* ColonToken */))
|
|
),
|
|
pos
|
|
);
|
|
}
|
|
function parseBinaryExpressionOrHigher(precedence) {
|
|
const pos = getNodePos();
|
|
const leftOperand = parseUnaryExpressionOrHigher();
|
|
return parseBinaryExpressionRest(precedence, leftOperand, pos);
|
|
}
|
|
function isInOrOfKeyword(t) {
|
|
return t === 101 /* InKeyword */ || t === 162 /* OfKeyword */;
|
|
}
|
|
function parseBinaryExpressionRest(precedence, leftOperand, pos) {
|
|
while (true) {
|
|
reScanGreaterToken();
|
|
const newPrecedence = getBinaryOperatorPrecedence(token());
|
|
const consumeCurrentOperator = token() === 42 /* AsteriskAsteriskToken */ ? newPrecedence >= precedence : newPrecedence > precedence;
|
|
if (!consumeCurrentOperator) {
|
|
break;
|
|
}
|
|
if (token() === 101 /* InKeyword */ && inDisallowInContext()) {
|
|
break;
|
|
}
|
|
if (token() === 128 /* AsKeyword */ || token() === 150 /* SatisfiesKeyword */) {
|
|
if (scanner2.hasPrecedingLineBreak()) {
|
|
break;
|
|
} else {
|
|
const keywordKind = token();
|
|
nextToken();
|
|
leftOperand = keywordKind === 150 /* SatisfiesKeyword */ ? makeSatisfiesExpression(leftOperand, parseType()) : makeAsExpression(leftOperand, parseType());
|
|
}
|
|
} else {
|
|
leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence), pos);
|
|
}
|
|
}
|
|
return leftOperand;
|
|
}
|
|
function isBinaryOperator2() {
|
|
if (inDisallowInContext() && token() === 101 /* InKeyword */) {
|
|
return false;
|
|
}
|
|
return getBinaryOperatorPrecedence(token()) > 0;
|
|
}
|
|
function makeSatisfiesExpression(left, right) {
|
|
return finishNode(factory2.createSatisfiesExpression(left, right), left.pos);
|
|
}
|
|
function makeBinaryExpression(left, operatorToken, right, pos) {
|
|
return finishNode(factory2.createBinaryExpression(left, operatorToken, right), pos);
|
|
}
|
|
function makeAsExpression(left, right) {
|
|
return finishNode(factory2.createAsExpression(left, right), left.pos);
|
|
}
|
|
function parsePrefixUnaryExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createPrefixUnaryExpression(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseDeleteExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseTypeOfExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createTypeOfExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseVoidExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createVoidExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function isAwaitExpression2() {
|
|
if (token() === 133 /* AwaitKeyword */) {
|
|
if (inAwaitContext()) {
|
|
return true;
|
|
}
|
|
return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine);
|
|
}
|
|
return false;
|
|
}
|
|
function parseAwaitExpression() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createAwaitExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos);
|
|
}
|
|
function parseUnaryExpressionOrHigher() {
|
|
if (isUpdateExpression()) {
|
|
const pos = getNodePos();
|
|
const updateExpression = parseUpdateExpression();
|
|
return token() === 42 /* AsteriskAsteriskToken */ ? parseBinaryExpressionRest(getBinaryOperatorPrecedence(token()), updateExpression, pos) : updateExpression;
|
|
}
|
|
const unaryOperator = token();
|
|
const simpleUnaryExpression = parseSimpleUnaryExpression();
|
|
if (token() === 42 /* AsteriskAsteriskToken */) {
|
|
const pos = skipTrivia(sourceText, simpleUnaryExpression.pos);
|
|
const { end } = simpleUnaryExpression;
|
|
if (simpleUnaryExpression.kind === 213 /* TypeAssertionExpression */) {
|
|
parseErrorAt(pos, end, Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
|
|
} else {
|
|
parseErrorAt(pos, end, Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, tokenToString(unaryOperator));
|
|
}
|
|
}
|
|
return simpleUnaryExpression;
|
|
}
|
|
function parseSimpleUnaryExpression() {
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
return parsePrefixUnaryExpression();
|
|
case 89 /* DeleteKeyword */:
|
|
return parseDeleteExpression();
|
|
case 112 /* TypeOfKeyword */:
|
|
return parseTypeOfExpression();
|
|
case 114 /* VoidKeyword */:
|
|
return parseVoidExpression();
|
|
case 29 /* LessThanToken */:
|
|
return parseTypeAssertion();
|
|
case 133 /* AwaitKeyword */:
|
|
if (isAwaitExpression2()) {
|
|
return parseAwaitExpression();
|
|
}
|
|
default:
|
|
return parseUpdateExpression();
|
|
}
|
|
}
|
|
function isUpdateExpression() {
|
|
switch (token()) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 89 /* DeleteKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 133 /* AwaitKeyword */:
|
|
return false;
|
|
case 29 /* LessThanToken */:
|
|
if (languageVariant !== 1 /* JSX */) {
|
|
return false;
|
|
}
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function parseUpdateExpression() {
|
|
if (token() === 45 /* PlusPlusToken */ || token() === 46 /* MinusMinusToken */) {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createPrefixUnaryExpression(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos);
|
|
} else if (languageVariant === 1 /* JSX */ && token() === 29 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) {
|
|
return parseJsxElementOrSelfClosingElementOrFragment(true);
|
|
}
|
|
const expression = parseLeftHandSideExpressionOrHigher();
|
|
Debug.assert(isLeftHandSideExpression(expression));
|
|
if ((token() === 45 /* PlusPlusToken */ || token() === 46 /* MinusMinusToken */) && !scanner2.hasPrecedingLineBreak()) {
|
|
const operator = token();
|
|
nextToken();
|
|
return finishNode(factory2.createPostfixUnaryExpression(expression, operator), expression.pos);
|
|
}
|
|
return expression;
|
|
}
|
|
function parseLeftHandSideExpressionOrHigher() {
|
|
const pos = getNodePos();
|
|
let expression;
|
|
if (token() === 100 /* ImportKeyword */) {
|
|
if (lookAhead(nextTokenIsOpenParenOrLessThan)) {
|
|
sourceFlags |= 2097152 /* PossiblyContainsDynamicImport */;
|
|
expression = parseTokenNode();
|
|
} else if (lookAhead(nextTokenIsDot)) {
|
|
nextToken();
|
|
nextToken();
|
|
expression = finishNode(factory2.createMetaProperty(100 /* ImportKeyword */, parseIdentifierName()), pos);
|
|
sourceFlags |= 4194304 /* PossiblyContainsImportMeta */;
|
|
} else {
|
|
expression = parseMemberExpressionOrHigher();
|
|
}
|
|
} else {
|
|
expression = token() === 106 /* SuperKeyword */ ? parseSuperExpression() : parseMemberExpressionOrHigher();
|
|
}
|
|
return parseCallExpressionRest(pos, expression);
|
|
}
|
|
function parseMemberExpressionOrHigher() {
|
|
const pos = getNodePos();
|
|
const expression = parsePrimaryExpression();
|
|
return parseMemberExpressionRest(pos, expression, true);
|
|
}
|
|
function parseSuperExpression() {
|
|
const pos = getNodePos();
|
|
let expression = parseTokenNode();
|
|
if (token() === 29 /* LessThanToken */) {
|
|
const startPos = getNodePos();
|
|
const typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (typeArguments !== void 0) {
|
|
parseErrorAt(startPos, getNodePos(), Diagnostics.super_may_not_use_type_arguments);
|
|
if (!isTemplateStartOfTaggedTemplate()) {
|
|
expression = factory2.createExpressionWithTypeArguments(expression, typeArguments);
|
|
}
|
|
}
|
|
}
|
|
if (token() === 20 /* OpenParenToken */ || token() === 24 /* DotToken */ || token() === 22 /* OpenBracketToken */) {
|
|
return expression;
|
|
}
|
|
parseExpectedToken(24 /* DotToken */, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
|
|
return finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(true, true)), pos);
|
|
}
|
|
function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition, openingTag) {
|
|
const pos = getNodePos();
|
|
const opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext);
|
|
let result;
|
|
if (opening.kind === 283 /* JsxOpeningElement */) {
|
|
let children = parseJsxChildren(opening);
|
|
let closingElement;
|
|
const lastChild = children[children.length - 1];
|
|
if ((lastChild == null ? void 0 : lastChild.kind) === 281 /* JsxElement */ && !tagNamesAreEquivalent(lastChild.openingElement.tagName, lastChild.closingElement.tagName) && tagNamesAreEquivalent(opening.tagName, lastChild.closingElement.tagName)) {
|
|
const end = lastChild.children.end;
|
|
const newLast = finishNode(
|
|
factory2.createJsxElement(
|
|
lastChild.openingElement,
|
|
lastChild.children,
|
|
finishNode(factory2.createJsxClosingElement(finishNode(factory2.createIdentifier(""), end, end)), end, end)
|
|
),
|
|
lastChild.openingElement.pos,
|
|
end
|
|
);
|
|
children = createNodeArray2([...children.slice(0, children.length - 1), newLast], children.pos, end);
|
|
closingElement = lastChild.closingElement;
|
|
} else {
|
|
closingElement = parseJsxClosingElement(opening, inExpressionContext);
|
|
if (!tagNamesAreEquivalent(opening.tagName, closingElement.tagName)) {
|
|
if (openingTag && isJsxOpeningElement(openingTag) && tagNamesAreEquivalent(closingElement.tagName, openingTag.tagName)) {
|
|
parseErrorAtRange(opening.tagName, Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, getTextOfNodeFromSourceText(sourceText, opening.tagName));
|
|
} else {
|
|
parseErrorAtRange(closingElement.tagName, Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, getTextOfNodeFromSourceText(sourceText, opening.tagName));
|
|
}
|
|
}
|
|
}
|
|
result = finishNode(factory2.createJsxElement(opening, children, closingElement), pos);
|
|
} else if (opening.kind === 286 /* JsxOpeningFragment */) {
|
|
result = finishNode(factory2.createJsxFragment(opening, parseJsxChildren(opening), parseJsxClosingFragment(inExpressionContext)), pos);
|
|
} else {
|
|
Debug.assert(opening.kind === 282 /* JsxSelfClosingElement */);
|
|
result = opening;
|
|
}
|
|
if (inExpressionContext && token() === 29 /* LessThanToken */) {
|
|
const topBadPos = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition;
|
|
const invalidElement = tryParse(() => parseJsxElementOrSelfClosingElementOrFragment(true, topBadPos));
|
|
if (invalidElement) {
|
|
const operatorToken = createMissingNode(27 /* CommaToken */, false);
|
|
setTextRangePosWidth(operatorToken, invalidElement.pos, 0);
|
|
parseErrorAt(skipTrivia(sourceText, topBadPos), invalidElement.end, Diagnostics.JSX_expressions_must_have_one_parent_element);
|
|
return finishNode(factory2.createBinaryExpression(result, operatorToken, invalidElement), pos);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function parseJsxText() {
|
|
const pos = getNodePos();
|
|
const node = factory2.createJsxText(scanner2.getTokenValue(), currentToken === 12 /* JsxTextAllWhiteSpaces */);
|
|
currentToken = scanner2.scanJsxToken();
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseJsxChild(openingTag, token2) {
|
|
switch (token2) {
|
|
case 1 /* EndOfFileToken */:
|
|
if (isJsxOpeningFragment(openingTag)) {
|
|
parseErrorAtRange(openingTag, Diagnostics.JSX_fragment_has_no_corresponding_closing_tag);
|
|
} else {
|
|
const tag = openingTag.tagName;
|
|
const start2 = skipTrivia(sourceText, tag.pos);
|
|
parseErrorAt(start2, tag.end, Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, getTextOfNodeFromSourceText(sourceText, openingTag.tagName));
|
|
}
|
|
return void 0;
|
|
case 30 /* LessThanSlashToken */:
|
|
case 7 /* ConflictMarkerTrivia */:
|
|
return void 0;
|
|
case 11 /* JsxText */:
|
|
case 12 /* JsxTextAllWhiteSpaces */:
|
|
return parseJsxText();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseJsxExpression(false);
|
|
case 29 /* LessThanToken */:
|
|
return parseJsxElementOrSelfClosingElementOrFragment(false, void 0, openingTag);
|
|
default:
|
|
return Debug.assertNever(token2);
|
|
}
|
|
}
|
|
function parseJsxChildren(openingTag) {
|
|
const list = [];
|
|
const listPos = getNodePos();
|
|
const saveParsingContext = parsingContext;
|
|
parsingContext |= 1 << ParsingContext.JsxChildren;
|
|
while (true) {
|
|
const child = parseJsxChild(openingTag, currentToken = scanner2.reScanJsxToken());
|
|
if (!child)
|
|
break;
|
|
list.push(child);
|
|
if (isJsxOpeningElement(openingTag) && (child == null ? void 0 : child.kind) === 281 /* JsxElement */ && !tagNamesAreEquivalent(child.openingElement.tagName, child.closingElement.tagName) && tagNamesAreEquivalent(openingTag.tagName, child.closingElement.tagName)) {
|
|
break;
|
|
}
|
|
}
|
|
parsingContext = saveParsingContext;
|
|
return createNodeArray2(list, listPos);
|
|
}
|
|
function parseJsxAttributes() {
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createJsxAttributes(parseList(ParsingContext.JsxAttributes, parseJsxAttribute)), pos);
|
|
}
|
|
function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(29 /* LessThanToken */);
|
|
if (token() === 31 /* GreaterThanToken */) {
|
|
scanJsxText();
|
|
return finishNode(factory2.createJsxOpeningFragment(), pos);
|
|
}
|
|
const tagName = parseJsxElementName();
|
|
const typeArguments = (contextFlags & 262144 /* JavaScriptFile */) === 0 ? tryParseTypeArguments() : void 0;
|
|
const attributes = parseJsxAttributes();
|
|
let node;
|
|
if (token() === 31 /* GreaterThanToken */) {
|
|
scanJsxText();
|
|
node = factory2.createJsxOpeningElement(tagName, typeArguments, attributes);
|
|
} else {
|
|
parseExpected(43 /* SlashToken */);
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
node = factory2.createJsxSelfClosingElement(tagName, typeArguments, attributes);
|
|
}
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseJsxElementName() {
|
|
const pos = getNodePos();
|
|
scanJsxIdentifier();
|
|
let expression = token() === 108 /* ThisKeyword */ ? parseTokenNode() : parseIdentifierName();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
expression = finishNode(factory2.createPropertyAccessExpression(expression, parseRightSideOfDot(true, false)), pos);
|
|
}
|
|
return expression;
|
|
}
|
|
function parseJsxExpression(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
if (!parseExpected(18 /* OpenBraceToken */)) {
|
|
return void 0;
|
|
}
|
|
let dotDotDotToken;
|
|
let expression;
|
|
if (token() !== 19 /* CloseBraceToken */) {
|
|
dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
expression = parseExpression();
|
|
}
|
|
if (inExpressionContext) {
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
if (parseExpected(19 /* CloseBraceToken */, void 0, false)) {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxExpression(dotDotDotToken, expression), pos);
|
|
}
|
|
function parseJsxAttribute() {
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseJsxSpreadAttribute();
|
|
}
|
|
scanJsxIdentifier();
|
|
const pos = getNodePos();
|
|
return finishNode(factory2.createJsxAttribute(parseIdentifierName(), parseJsxAttributeValue()), pos);
|
|
}
|
|
function parseJsxAttributeValue() {
|
|
if (token() === 63 /* EqualsToken */) {
|
|
if (scanJsxAttributeValue() === 10 /* StringLiteral */) {
|
|
return parseLiteralNode();
|
|
}
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseJsxExpression(true);
|
|
}
|
|
if (token() === 29 /* LessThanToken */) {
|
|
return parseJsxElementOrSelfClosingElementOrFragment(true);
|
|
}
|
|
parseErrorAtCurrentToken(Diagnostics.or_JSX_element_expected);
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseJsxSpreadAttribute() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
parseExpected(25 /* DotDotDotToken */);
|
|
const expression = parseExpression();
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createJsxSpreadAttribute(expression), pos);
|
|
}
|
|
function parseJsxClosingElement(open, inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(30 /* LessThanSlashToken */);
|
|
const tagName = parseJsxElementName();
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext || !tagNamesAreEquivalent(open.tagName, tagName)) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxClosingElement(tagName), pos);
|
|
}
|
|
function parseJsxClosingFragment(inExpressionContext) {
|
|
const pos = getNodePos();
|
|
parseExpected(30 /* LessThanSlashToken */);
|
|
if (tokenIsIdentifierOrKeyword(token())) {
|
|
parseErrorAtRange(parseJsxElementName(), Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment);
|
|
}
|
|
if (parseExpected(31 /* GreaterThanToken */, void 0, false)) {
|
|
if (inExpressionContext) {
|
|
nextToken();
|
|
} else {
|
|
scanJsxText();
|
|
}
|
|
}
|
|
return finishNode(factory2.createJsxJsxClosingFragment(), pos);
|
|
}
|
|
function parseTypeAssertion() {
|
|
const pos = getNodePos();
|
|
parseExpected(29 /* LessThanToken */);
|
|
const type = parseType();
|
|
parseExpected(31 /* GreaterThanToken */);
|
|
const expression = parseSimpleUnaryExpression();
|
|
return finishNode(factory2.createTypeAssertion(type, expression), pos);
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token()) || token() === 22 /* OpenBracketToken */ || isTemplateStartOfTaggedTemplate();
|
|
}
|
|
function isStartOfOptionalPropertyOrElementAccessChain() {
|
|
return token() === 28 /* QuestionDotToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate);
|
|
}
|
|
function tryReparseOptionalChain(node) {
|
|
if (node.flags & 32 /* OptionalChain */) {
|
|
return true;
|
|
}
|
|
if (isNonNullExpression(node)) {
|
|
let expr = node.expression;
|
|
while (isNonNullExpression(expr) && !(expr.flags & 32 /* OptionalChain */)) {
|
|
expr = expr.expression;
|
|
}
|
|
if (expr.flags & 32 /* OptionalChain */) {
|
|
while (isNonNullExpression(node)) {
|
|
node.flags |= 32 /* OptionalChain */;
|
|
node = node.expression;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parsePropertyAccessExpressionRest(pos, expression, questionDotToken) {
|
|
const name = parseRightSideOfDot(true, true);
|
|
const isOptionalChain2 = questionDotToken || tryReparseOptionalChain(expression);
|
|
const propertyAccess = isOptionalChain2 ? factory2.createPropertyAccessChain(expression, questionDotToken, name) : factory2.createPropertyAccessExpression(expression, name);
|
|
if (isOptionalChain2 && isPrivateIdentifier(propertyAccess.name)) {
|
|
parseErrorAtRange(propertyAccess.name, Diagnostics.An_optional_chain_cannot_contain_private_identifiers);
|
|
}
|
|
if (isExpressionWithTypeArguments(expression) && expression.typeArguments) {
|
|
const pos2 = expression.typeArguments.pos - 1;
|
|
const end = skipTrivia(sourceText, expression.typeArguments.end) + 1;
|
|
parseErrorAt(pos2, end, Diagnostics.An_instantiation_expression_cannot_be_followed_by_a_property_access);
|
|
}
|
|
return finishNode(propertyAccess, pos);
|
|
}
|
|
function parseElementAccessExpressionRest(pos, expression, questionDotToken) {
|
|
let argumentExpression;
|
|
if (token() === 23 /* CloseBracketToken */) {
|
|
argumentExpression = createMissingNode(79 /* Identifier */, true, Diagnostics.An_element_access_expression_should_take_an_argument);
|
|
} else {
|
|
const argument = allowInAnd(parseExpression);
|
|
if (isStringOrNumericLiteralLike(argument)) {
|
|
argument.text = internIdentifier(argument.text);
|
|
}
|
|
argumentExpression = argument;
|
|
}
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
const indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createElementAccessChain(expression, questionDotToken, argumentExpression) : factory2.createElementAccessExpression(expression, argumentExpression);
|
|
return finishNode(indexedAccess, pos);
|
|
}
|
|
function parseMemberExpressionRest(pos, expression, allowOptionalChain) {
|
|
while (true) {
|
|
let questionDotToken;
|
|
let isPropertyAccess = false;
|
|
if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) {
|
|
questionDotToken = parseExpectedToken(28 /* QuestionDotToken */);
|
|
isPropertyAccess = tokenIsIdentifierOrKeyword(token());
|
|
} else {
|
|
isPropertyAccess = parseOptional(24 /* DotToken */);
|
|
}
|
|
if (isPropertyAccess) {
|
|
expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
|
|
continue;
|
|
}
|
|
if ((questionDotToken || !inDecoratorContext()) && parseOptional(22 /* OpenBracketToken */)) {
|
|
expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
|
|
continue;
|
|
}
|
|
if (isTemplateStartOfTaggedTemplate()) {
|
|
expression = !questionDotToken && expression.kind === 230 /* ExpressionWithTypeArguments */ ? parseTaggedTemplateRest(pos, expression.expression, questionDotToken, expression.typeArguments) : parseTaggedTemplateRest(pos, expression, questionDotToken, void 0);
|
|
continue;
|
|
}
|
|
if (!questionDotToken) {
|
|
if (token() === 53 /* ExclamationToken */ && !scanner2.hasPrecedingLineBreak()) {
|
|
nextToken();
|
|
expression = finishNode(factory2.createNonNullExpression(expression), pos);
|
|
continue;
|
|
}
|
|
const typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (typeArguments) {
|
|
expression = finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
|
|
continue;
|
|
}
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
function isTemplateStartOfTaggedTemplate() {
|
|
return token() === 14 /* NoSubstitutionTemplateLiteral */ || token() === 15 /* TemplateHead */;
|
|
}
|
|
function parseTaggedTemplateRest(pos, tag, questionDotToken, typeArguments) {
|
|
const tagExpression = factory2.createTaggedTemplateExpression(
|
|
tag,
|
|
typeArguments,
|
|
token() === 14 /* NoSubstitutionTemplateLiteral */ ? (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : parseTemplateExpression(true)
|
|
);
|
|
if (questionDotToken || tag.flags & 32 /* OptionalChain */) {
|
|
tagExpression.flags |= 32 /* OptionalChain */;
|
|
}
|
|
tagExpression.questionDotToken = questionDotToken;
|
|
return finishNode(tagExpression, pos);
|
|
}
|
|
function parseCallExpressionRest(pos, expression) {
|
|
while (true) {
|
|
expression = parseMemberExpressionRest(pos, expression, true);
|
|
let typeArguments;
|
|
const questionDotToken = parseOptionalToken(28 /* QuestionDotToken */);
|
|
if (questionDotToken) {
|
|
typeArguments = tryParse(parseTypeArgumentsInExpression);
|
|
if (isTemplateStartOfTaggedTemplate()) {
|
|
expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
|
|
continue;
|
|
}
|
|
}
|
|
if (typeArguments || token() === 20 /* OpenParenToken */) {
|
|
if (!questionDotToken && expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
typeArguments = expression.typeArguments;
|
|
expression = expression.expression;
|
|
}
|
|
const argumentList = parseArgumentList();
|
|
const callExpr = questionDotToken || tryReparseOptionalChain(expression) ? factory2.createCallChain(expression, questionDotToken, typeArguments, argumentList) : factory2.createCallExpression(expression, typeArguments, argumentList);
|
|
expression = finishNode(callExpr, pos);
|
|
continue;
|
|
}
|
|
if (questionDotToken) {
|
|
const name = createMissingNode(79 /* Identifier */, false, Diagnostics.Identifier_expected);
|
|
expression = finishNode(factory2.createPropertyAccessChain(expression, questionDotToken, name), pos);
|
|
}
|
|
break;
|
|
}
|
|
return expression;
|
|
}
|
|
function parseArgumentList() {
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return result;
|
|
}
|
|
function parseTypeArgumentsInExpression() {
|
|
if ((contextFlags & 262144 /* JavaScriptFile */) !== 0) {
|
|
return void 0;
|
|
}
|
|
if (reScanLessThanToken() !== 29 /* LessThanToken */) {
|
|
return void 0;
|
|
}
|
|
nextToken();
|
|
const typeArguments = parseDelimitedList(ParsingContext.TypeArguments, parseType);
|
|
if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
|
|
return void 0;
|
|
}
|
|
nextToken();
|
|
return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : void 0;
|
|
}
|
|
function canFollowTypeArgumentsInExpression() {
|
|
switch (token()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
return true;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
return false;
|
|
}
|
|
return scanner2.hasPrecedingLineBreak() || isBinaryOperator2() || !isStartOfExpression();
|
|
}
|
|
function parsePrimaryExpression() {
|
|
switch (token()) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return parseLiteralNode();
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
return parseTokenNode();
|
|
case 20 /* OpenParenToken */:
|
|
return parseParenthesizedExpression();
|
|
case 22 /* OpenBracketToken */:
|
|
return parseArrayLiteralExpression();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseObjectLiteralExpression();
|
|
case 132 /* AsyncKeyword */:
|
|
if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) {
|
|
break;
|
|
}
|
|
return parseFunctionExpression();
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassExpression();
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionExpression();
|
|
case 103 /* NewKeyword */:
|
|
return parseNewExpressionOrNewDotTarget();
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
if (reScanSlashToken() === 13 /* RegularExpressionLiteral */) {
|
|
return parseLiteralNode();
|
|
}
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
return parseTemplateExpression(false);
|
|
case 80 /* PrivateIdentifier */:
|
|
return parsePrivateIdentifier();
|
|
}
|
|
return parseIdentifier(Diagnostics.Expression_expected);
|
|
}
|
|
function parseParenthesizedExpression() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return withJSDoc(finishNode(factory2.createParenthesizedExpression(expression), pos), hasJSDoc);
|
|
}
|
|
function parseSpreadElement() {
|
|
const pos = getNodePos();
|
|
parseExpected(25 /* DotDotDotToken */);
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
return finishNode(factory2.createSpreadElement(expression), pos);
|
|
}
|
|
function parseArgumentOrArrayLiteralElement() {
|
|
return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() : token() === 27 /* CommaToken */ ? finishNode(factory2.createOmittedExpression(), getNodePos()) : parseAssignmentExpressionOrHigher(true);
|
|
}
|
|
function parseArgumentExpression() {
|
|
return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
|
|
}
|
|
function parseArrayLiteralExpression() {
|
|
const pos = getNodePos();
|
|
const openBracketPosition = scanner2.getTokenPos();
|
|
const openBracketParsed = parseExpected(22 /* OpenBracketToken */);
|
|
const multiLine = scanner2.hasPrecedingLineBreak();
|
|
const elements = parseDelimitedList(ParsingContext.ArrayLiteralMembers, parseArgumentOrArrayLiteralElement);
|
|
parseExpectedMatchingBrackets(22 /* OpenBracketToken */, 23 /* CloseBracketToken */, openBracketParsed, openBracketPosition);
|
|
return finishNode(factory2.createArrayLiteralExpression(elements, multiLine), pos);
|
|
}
|
|
function parseObjectLiteralElement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
if (parseOptionalToken(25 /* DotDotDotToken */)) {
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
return withJSDoc(finishNode(factory2.createSpreadAssignment(expression), pos), hasJSDoc);
|
|
}
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers();
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* GetAccessor */, 0 /* None */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SetAccessor */, 0 /* None */);
|
|
}
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const tokenIsIdentifier = isIdentifier2();
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
const exclamationToken = parseOptionalToken(53 /* ExclamationToken */);
|
|
if (asteriskToken || token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken);
|
|
}
|
|
let node;
|
|
const isShorthandPropertyAssignment2 = tokenIsIdentifier && token() !== 58 /* ColonToken */;
|
|
if (isShorthandPropertyAssignment2) {
|
|
const equalsToken = parseOptionalToken(63 /* EqualsToken */);
|
|
const objectAssignmentInitializer = equalsToken ? allowInAnd(() => parseAssignmentExpressionOrHigher(true)) : void 0;
|
|
node = factory2.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
|
|
node.equalsToken = equalsToken;
|
|
} else {
|
|
parseExpected(58 /* ColonToken */);
|
|
const initializer = allowInAnd(() => parseAssignmentExpressionOrHigher(true));
|
|
node = factory2.createPropertyAssignment(name, initializer);
|
|
}
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
node.questionToken = questionToken;
|
|
node.exclamationToken = exclamationToken;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseObjectLiteralExpression() {
|
|
const pos = getNodePos();
|
|
const openBracePosition = scanner2.getTokenPos();
|
|
const openBraceParsed = parseExpected(18 /* OpenBraceToken */);
|
|
const multiLine = scanner2.hasPrecedingLineBreak();
|
|
const properties = parseDelimitedList(ParsingContext.ObjectLiteralMembers, parseObjectLiteralElement, true);
|
|
parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
|
|
return finishNode(factory2.createObjectLiteralExpression(properties, multiLine), pos);
|
|
}
|
|
function parseFunctionExpression() {
|
|
const savedDecoratorContext = inDecoratorContext();
|
|
setDecoratorContext(false);
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const modifiers = parseModifiers();
|
|
parseExpected(98 /* FunctionKeyword */);
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalBindingIdentifier) : isGenerator ? doInYieldContext(parseOptionalBindingIdentifier) : isAsync ? doInAwaitContext(parseOptionalBindingIdentifier) : parseOptionalBindingIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlock(isGenerator | isAsync);
|
|
setDecoratorContext(savedDecoratorContext);
|
|
const node = factory2.createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseOptionalBindingIdentifier() {
|
|
return isBindingIdentifier() ? parseBindingIdentifier() : void 0;
|
|
}
|
|
function parseNewExpressionOrNewDotTarget() {
|
|
const pos = getNodePos();
|
|
parseExpected(103 /* NewKeyword */);
|
|
if (parseOptional(24 /* DotToken */)) {
|
|
const name = parseIdentifierName();
|
|
return finishNode(factory2.createMetaProperty(103 /* NewKeyword */, name), pos);
|
|
}
|
|
const expressionPos = getNodePos();
|
|
let expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), false);
|
|
let typeArguments;
|
|
if (expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
typeArguments = expression.typeArguments;
|
|
expression = expression.expression;
|
|
}
|
|
if (token() === 28 /* QuestionDotToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0, getTextOfNodeFromSourceText(sourceText, expression));
|
|
}
|
|
const argumentList = token() === 20 /* OpenParenToken */ ? parseArgumentList() : void 0;
|
|
return finishNode(factory2.createNewExpression(expression, typeArguments, argumentList), pos);
|
|
}
|
|
function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const openBracePosition = scanner2.getTokenPos();
|
|
const openBraceParsed = parseExpected(18 /* OpenBraceToken */, diagnosticMessage);
|
|
if (openBraceParsed || ignoreMissingOpenBrace) {
|
|
const multiLine = scanner2.hasPrecedingLineBreak();
|
|
const statements = parseList(ParsingContext.BlockStatements, parseStatement);
|
|
parseExpectedMatchingBrackets(18 /* OpenBraceToken */, 19 /* CloseBraceToken */, openBraceParsed, openBracePosition);
|
|
const result = withJSDoc(finishNode(factory2.createBlock(statements, multiLine), pos), hasJSDoc);
|
|
if (token() === 63 /* EqualsToken */) {
|
|
parseErrorAtCurrentToken(Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses);
|
|
nextToken();
|
|
}
|
|
return result;
|
|
} else {
|
|
const statements = createMissingList();
|
|
return withJSDoc(finishNode(factory2.createBlock(statements, void 0), pos), hasJSDoc);
|
|
}
|
|
}
|
|
function parseFunctionBlock(flags, diagnosticMessage) {
|
|
const savedYieldContext = inYieldContext();
|
|
setYieldContext(!!(flags & 1 /* Yield */));
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(!!(flags & 2 /* Await */));
|
|
const savedTopLevel = topLevel;
|
|
topLevel = false;
|
|
const saveDecoratorContext = inDecoratorContext();
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(false);
|
|
}
|
|
const block = parseBlock(!!(flags & 16 /* IgnoreMissingOpenBrace */), diagnosticMessage);
|
|
if (saveDecoratorContext) {
|
|
setDecoratorContext(true);
|
|
}
|
|
topLevel = savedTopLevel;
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return block;
|
|
}
|
|
function parseEmptyStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(26 /* SemicolonToken */);
|
|
return withJSDoc(finishNode(factory2.createEmptyStatement(), pos), hasJSDoc);
|
|
}
|
|
function parseIfStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(99 /* IfKeyword */);
|
|
const openParenPosition = scanner2.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const thenStatement = parseStatement();
|
|
const elseStatement = parseOptional(91 /* ElseKeyword */) ? parseStatement() : void 0;
|
|
return withJSDoc(finishNode(factory2.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc);
|
|
}
|
|
function parseDoStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(90 /* DoKeyword */);
|
|
const statement = parseStatement();
|
|
parseExpected(115 /* WhileKeyword */);
|
|
const openParenPosition = scanner2.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
parseOptional(26 /* SemicolonToken */);
|
|
return withJSDoc(finishNode(factory2.createDoStatement(statement, expression), pos), hasJSDoc);
|
|
}
|
|
function parseWhileStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(115 /* WhileKeyword */);
|
|
const openParenPosition = scanner2.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const statement = parseStatement();
|
|
return withJSDoc(finishNode(factory2.createWhileStatement(expression, statement), pos), hasJSDoc);
|
|
}
|
|
function parseForOrForInOrForOfStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(97 /* ForKeyword */);
|
|
const awaitToken = parseOptionalToken(133 /* AwaitKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
let initializer;
|
|
if (token() !== 26 /* SemicolonToken */) {
|
|
if (token() === 113 /* VarKeyword */ || token() === 119 /* LetKeyword */ || token() === 85 /* ConstKeyword */) {
|
|
initializer = parseVariableDeclarationList(true);
|
|
} else {
|
|
initializer = disallowInAnd(parseExpression);
|
|
}
|
|
}
|
|
let node;
|
|
if (awaitToken ? parseExpected(162 /* OfKeyword */) : parseOptional(162 /* OfKeyword */)) {
|
|
const expression = allowInAnd(() => parseAssignmentExpressionOrHigher(true));
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForOfStatement(awaitToken, initializer, expression, parseStatement());
|
|
} else if (parseOptional(101 /* InKeyword */)) {
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForInStatement(initializer, expression, parseStatement());
|
|
} else {
|
|
parseExpected(26 /* SemicolonToken */);
|
|
const condition = token() !== 26 /* SemicolonToken */ && token() !== 21 /* CloseParenToken */ ? allowInAnd(parseExpression) : void 0;
|
|
parseExpected(26 /* SemicolonToken */);
|
|
const incrementor = token() !== 21 /* CloseParenToken */ ? allowInAnd(parseExpression) : void 0;
|
|
parseExpected(21 /* CloseParenToken */);
|
|
node = factory2.createForStatement(initializer, condition, incrementor, parseStatement());
|
|
}
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseBreakOrContinueStatement(kind) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(kind === 249 /* BreakStatement */ ? 81 /* BreakKeyword */ : 86 /* ContinueKeyword */);
|
|
const label = canParseSemicolon() ? void 0 : parseIdentifier();
|
|
parseSemicolon();
|
|
const node = kind === 249 /* BreakStatement */ ? factory2.createBreakStatement(label) : factory2.createContinueStatement(label);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseReturnStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(105 /* ReturnKeyword */);
|
|
const expression = canParseSemicolon() ? void 0 : allowInAnd(parseExpression);
|
|
parseSemicolon();
|
|
return withJSDoc(finishNode(factory2.createReturnStatement(expression), pos), hasJSDoc);
|
|
}
|
|
function parseWithStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(116 /* WithKeyword */);
|
|
const openParenPosition = scanner2.getTokenPos();
|
|
const openParenParsed = parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpectedMatchingBrackets(20 /* OpenParenToken */, 21 /* CloseParenToken */, openParenParsed, openParenPosition);
|
|
const statement = doInsideOfContext(33554432 /* InWithStatement */, parseStatement);
|
|
return withJSDoc(finishNode(factory2.createWithStatement(expression, statement), pos), hasJSDoc);
|
|
}
|
|
function parseCaseClause() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(82 /* CaseKeyword */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(58 /* ColonToken */);
|
|
const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
|
|
return withJSDoc(finishNode(factory2.createCaseClause(expression, statements), pos), hasJSDoc);
|
|
}
|
|
function parseDefaultClause() {
|
|
const pos = getNodePos();
|
|
parseExpected(88 /* DefaultKeyword */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const statements = parseList(ParsingContext.SwitchClauseStatements, parseStatement);
|
|
return finishNode(factory2.createDefaultClause(statements), pos);
|
|
}
|
|
function parseCaseOrDefaultClause() {
|
|
return token() === 82 /* CaseKeyword */ ? parseCaseClause() : parseDefaultClause();
|
|
}
|
|
function parseCaseBlock() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const clauses = parseList(ParsingContext.SwitchClauses, parseCaseOrDefaultClause);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createCaseBlock(clauses), pos);
|
|
}
|
|
function parseSwitchStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(107 /* SwitchKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = allowInAnd(parseExpression);
|
|
parseExpected(21 /* CloseParenToken */);
|
|
const caseBlock = parseCaseBlock();
|
|
return withJSDoc(finishNode(factory2.createSwitchStatement(expression, caseBlock), pos), hasJSDoc);
|
|
}
|
|
function parseThrowStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(109 /* ThrowKeyword */);
|
|
let expression = scanner2.hasPrecedingLineBreak() ? void 0 : allowInAnd(parseExpression);
|
|
if (expression === void 0) {
|
|
identifierCount++;
|
|
expression = finishNode(factory2.createIdentifier(""), getNodePos());
|
|
}
|
|
if (!tryParseSemicolon()) {
|
|
parseErrorForMissingSemicolonAfter(expression);
|
|
}
|
|
return withJSDoc(finishNode(factory2.createThrowStatement(expression), pos), hasJSDoc);
|
|
}
|
|
function parseTryStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(111 /* TryKeyword */);
|
|
const tryBlock = parseBlock(false);
|
|
const catchClause = token() === 83 /* CatchKeyword */ ? parseCatchClause() : void 0;
|
|
let finallyBlock;
|
|
if (!catchClause || token() === 96 /* FinallyKeyword */) {
|
|
parseExpected(96 /* FinallyKeyword */, Diagnostics.catch_or_finally_expected);
|
|
finallyBlock = parseBlock(false);
|
|
}
|
|
return withJSDoc(finishNode(factory2.createTryStatement(tryBlock, catchClause, finallyBlock), pos), hasJSDoc);
|
|
}
|
|
function parseCatchClause() {
|
|
const pos = getNodePos();
|
|
parseExpected(83 /* CatchKeyword */);
|
|
let variableDeclaration;
|
|
if (parseOptional(20 /* OpenParenToken */)) {
|
|
variableDeclaration = parseVariableDeclaration();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
} else {
|
|
variableDeclaration = void 0;
|
|
}
|
|
const block = parseBlock(false);
|
|
return finishNode(factory2.createCatchClause(variableDeclaration, block), pos);
|
|
}
|
|
function parseDebuggerStatement() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
parseExpected(87 /* DebuggerKeyword */);
|
|
parseSemicolon();
|
|
return withJSDoc(finishNode(factory2.createDebuggerStatement(), pos), hasJSDoc);
|
|
}
|
|
function parseExpressionOrLabeledStatement() {
|
|
const pos = getNodePos();
|
|
let hasJSDoc = hasPrecedingJSDocComment();
|
|
let node;
|
|
const hasParen = token() === 20 /* OpenParenToken */;
|
|
const expression = allowInAnd(parseExpression);
|
|
if (isIdentifier(expression) && parseOptional(58 /* ColonToken */)) {
|
|
node = factory2.createLabeledStatement(expression, parseStatement());
|
|
} else {
|
|
if (!tryParseSemicolon()) {
|
|
parseErrorForMissingSemicolonAfter(expression);
|
|
}
|
|
node = factory2.createExpressionStatement(expression);
|
|
if (hasParen) {
|
|
hasJSDoc = false;
|
|
}
|
|
}
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOnSameLine() {
|
|
nextToken();
|
|
return tokenIsIdentifierOrKeyword(token()) && !scanner2.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsClassKeywordOnSameLine() {
|
|
nextToken();
|
|
return token() === 84 /* ClassKeyword */ && !scanner2.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsFunctionKeywordOnSameLine() {
|
|
nextToken();
|
|
return token() === 98 /* FunctionKeyword */ && !scanner2.hasPrecedingLineBreak();
|
|
}
|
|
function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() {
|
|
nextToken();
|
|
return (tokenIsIdentifierOrKeyword(token()) || token() === 8 /* NumericLiteral */ || token() === 9 /* BigIntLiteral */ || token() === 10 /* StringLiteral */) && !scanner2.hasPrecedingLineBreak();
|
|
}
|
|
function isDeclaration2() {
|
|
while (true) {
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
return true;
|
|
case 118 /* InterfaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
return nextTokenIsIdentifierOnSameLine();
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
return nextTokenIsIdentifierOrStringLiteralOnSameLine();
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 132 /* AsyncKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
nextToken();
|
|
if (scanner2.hasPrecedingLineBreak()) {
|
|
return false;
|
|
}
|
|
continue;
|
|
case 159 /* GlobalKeyword */:
|
|
nextToken();
|
|
return token() === 18 /* OpenBraceToken */ || token() === 79 /* Identifier */ || token() === 93 /* ExportKeyword */;
|
|
case 100 /* ImportKeyword */:
|
|
nextToken();
|
|
return token() === 10 /* StringLiteral */ || token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */ || tokenIsIdentifierOrKeyword(token());
|
|
case 93 /* ExportKeyword */:
|
|
let currentToken2 = nextToken();
|
|
if (currentToken2 === 154 /* TypeKeyword */) {
|
|
currentToken2 = lookAhead(nextToken);
|
|
}
|
|
if (currentToken2 === 63 /* EqualsToken */ || currentToken2 === 41 /* AsteriskToken */ || currentToken2 === 18 /* OpenBraceToken */ || currentToken2 === 88 /* DefaultKeyword */ || currentToken2 === 128 /* AsKeyword */) {
|
|
return true;
|
|
}
|
|
continue;
|
|
case 124 /* StaticKeyword */:
|
|
nextToken();
|
|
continue;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function isStartOfDeclaration() {
|
|
return lookAhead(isDeclaration2);
|
|
}
|
|
function isStartOfStatement() {
|
|
switch (token()) {
|
|
case 59 /* AtToken */:
|
|
case 26 /* SemicolonToken */:
|
|
case 18 /* OpenBraceToken */:
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 99 /* IfKeyword */:
|
|
case 90 /* DoKeyword */:
|
|
case 115 /* WhileKeyword */:
|
|
case 97 /* ForKeyword */:
|
|
case 86 /* ContinueKeyword */:
|
|
case 81 /* BreakKeyword */:
|
|
case 105 /* ReturnKeyword */:
|
|
case 116 /* WithKeyword */:
|
|
case 107 /* SwitchKeyword */:
|
|
case 109 /* ThrowKeyword */:
|
|
case 111 /* TryKeyword */:
|
|
case 87 /* DebuggerKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
return true;
|
|
case 100 /* ImportKeyword */:
|
|
return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot);
|
|
case 85 /* ConstKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
return isStartOfDeclaration();
|
|
case 132 /* AsyncKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
case 159 /* GlobalKeyword */:
|
|
return true;
|
|
case 127 /* AccessorKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine);
|
|
default:
|
|
return isStartOfExpression();
|
|
}
|
|
}
|
|
function nextTokenIsBindingIdentifierOrStartOfDestructuring() {
|
|
nextToken();
|
|
return isBindingIdentifier() || token() === 18 /* OpenBraceToken */ || token() === 22 /* OpenBracketToken */;
|
|
}
|
|
function isLetDeclaration() {
|
|
return lookAhead(nextTokenIsBindingIdentifierOrStartOfDestructuring);
|
|
}
|
|
function parseStatement() {
|
|
switch (token()) {
|
|
case 26 /* SemicolonToken */:
|
|
return parseEmptyStatement();
|
|
case 18 /* OpenBraceToken */:
|
|
return parseBlock(false);
|
|
case 113 /* VarKeyword */:
|
|
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 119 /* LetKeyword */:
|
|
if (isLetDeclaration()) {
|
|
return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
}
|
|
break;
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionDeclaration(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassDeclaration(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0);
|
|
case 99 /* IfKeyword */:
|
|
return parseIfStatement();
|
|
case 90 /* DoKeyword */:
|
|
return parseDoStatement();
|
|
case 115 /* WhileKeyword */:
|
|
return parseWhileStatement();
|
|
case 97 /* ForKeyword */:
|
|
return parseForOrForInOrForOfStatement();
|
|
case 86 /* ContinueKeyword */:
|
|
return parseBreakOrContinueStatement(248 /* ContinueStatement */);
|
|
case 81 /* BreakKeyword */:
|
|
return parseBreakOrContinueStatement(249 /* BreakStatement */);
|
|
case 105 /* ReturnKeyword */:
|
|
return parseReturnStatement();
|
|
case 116 /* WithKeyword */:
|
|
return parseWithStatement();
|
|
case 107 /* SwitchKeyword */:
|
|
return parseSwitchStatement();
|
|
case 109 /* ThrowKeyword */:
|
|
return parseThrowStatement();
|
|
case 111 /* TryKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
return parseTryStatement();
|
|
case 87 /* DebuggerKeyword */:
|
|
return parseDebuggerStatement();
|
|
case 59 /* AtToken */:
|
|
return parseDeclaration();
|
|
case 132 /* AsyncKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 159 /* GlobalKeyword */:
|
|
if (isStartOfDeclaration()) {
|
|
return parseDeclaration();
|
|
}
|
|
break;
|
|
}
|
|
return parseExpressionOrLabeledStatement();
|
|
}
|
|
function isDeclareModifier(modifier) {
|
|
return modifier.kind === 136 /* DeclareKeyword */;
|
|
}
|
|
function parseDeclaration() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers();
|
|
const isAmbient = some(modifiers, isDeclareModifier);
|
|
if (isAmbient) {
|
|
const node = tryReuseAmbientDeclaration(pos);
|
|
if (node) {
|
|
return node;
|
|
}
|
|
for (const m of modifiers) {
|
|
m.flags |= 16777216 /* Ambient */;
|
|
}
|
|
return doInsideOfContext(16777216 /* Ambient */, () => parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers));
|
|
} else {
|
|
return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
function tryReuseAmbientDeclaration(pos) {
|
|
return doInsideOfContext(16777216 /* Ambient */, () => {
|
|
const node = currentNode(parsingContext, pos);
|
|
if (node) {
|
|
return consumeNode(node);
|
|
}
|
|
});
|
|
}
|
|
function parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers) {
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
return parseVariableStatement(pos, hasJSDoc, decorators, modifiers);
|
|
case 98 /* FunctionKeyword */:
|
|
return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 84 /* ClassKeyword */:
|
|
return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 118 /* InterfaceKeyword */:
|
|
return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 154 /* TypeKeyword */:
|
|
return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 92 /* EnumKeyword */:
|
|
return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 159 /* GlobalKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 100 /* ImportKeyword */:
|
|
return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
case 93 /* ExportKeyword */:
|
|
nextToken();
|
|
switch (token()) {
|
|
case 88 /* DefaultKeyword */:
|
|
case 63 /* EqualsToken */:
|
|
return parseExportAssignment(pos, hasJSDoc, decorators, modifiers);
|
|
case 128 /* AsKeyword */:
|
|
return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
default:
|
|
return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
default:
|
|
if (decorators || modifiers) {
|
|
const missing = createMissingNode(279 /* MissingDeclaration */, true, Diagnostics.Declaration_expected);
|
|
setTextRangePos(missing, pos);
|
|
missing.illegalDecorators = decorators;
|
|
missing.modifiers = modifiers;
|
|
return missing;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function nextTokenIsIdentifierOrStringLiteralOnSameLine() {
|
|
nextToken();
|
|
return !scanner2.hasPrecedingLineBreak() && (isIdentifier2() || token() === 10 /* StringLiteral */);
|
|
}
|
|
function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
|
|
if (token() !== 18 /* OpenBraceToken */) {
|
|
if (flags & 4 /* Type */) {
|
|
parseTypeMemberSemicolon();
|
|
return;
|
|
}
|
|
if (canParseSemicolon()) {
|
|
parseSemicolon();
|
|
return;
|
|
}
|
|
}
|
|
return parseFunctionBlock(flags, diagnosticMessage);
|
|
}
|
|
function parseArrayBindingElement() {
|
|
const pos = getNodePos();
|
|
if (token() === 27 /* CommaToken */) {
|
|
return finishNode(factory2.createOmittedExpression(), pos);
|
|
}
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const name = parseIdentifierOrPattern();
|
|
const initializer = parseInitializer();
|
|
return finishNode(factory2.createBindingElement(dotDotDotToken, void 0, name, initializer), pos);
|
|
}
|
|
function parseObjectBindingElement() {
|
|
const pos = getNodePos();
|
|
const dotDotDotToken = parseOptionalToken(25 /* DotDotDotToken */);
|
|
const tokenIsIdentifier = isBindingIdentifier();
|
|
let propertyName = parsePropertyName();
|
|
let name;
|
|
if (tokenIsIdentifier && token() !== 58 /* ColonToken */) {
|
|
name = propertyName;
|
|
propertyName = void 0;
|
|
} else {
|
|
parseExpected(58 /* ColonToken */);
|
|
name = parseIdentifierOrPattern();
|
|
}
|
|
const initializer = parseInitializer();
|
|
return finishNode(factory2.createBindingElement(dotDotDotToken, propertyName, name, initializer), pos);
|
|
}
|
|
function parseObjectBindingPattern() {
|
|
const pos = getNodePos();
|
|
parseExpected(18 /* OpenBraceToken */);
|
|
const elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
return finishNode(factory2.createObjectBindingPattern(elements), pos);
|
|
}
|
|
function parseArrayBindingPattern() {
|
|
const pos = getNodePos();
|
|
parseExpected(22 /* OpenBracketToken */);
|
|
const elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
return finishNode(factory2.createArrayBindingPattern(elements), pos);
|
|
}
|
|
function isBindingIdentifierOrPrivateIdentifierOrPattern() {
|
|
return token() === 18 /* OpenBraceToken */ || token() === 22 /* OpenBracketToken */ || token() === 80 /* PrivateIdentifier */ || isBindingIdentifier();
|
|
}
|
|
function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) {
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return parseArrayBindingPattern();
|
|
}
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
return parseObjectBindingPattern();
|
|
}
|
|
return parseBindingIdentifier(privateIdentifierDiagnosticMessage);
|
|
}
|
|
function parseVariableDeclarationAllowExclamation() {
|
|
return parseVariableDeclaration(true);
|
|
}
|
|
function parseVariableDeclaration(allowExclamation) {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const name = parseIdentifierOrPattern(Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations);
|
|
let exclamationToken;
|
|
if (allowExclamation && name.kind === 79 /* Identifier */ && token() === 53 /* ExclamationToken */ && !scanner2.hasPrecedingLineBreak()) {
|
|
exclamationToken = parseTokenNode();
|
|
}
|
|
const type = parseTypeAnnotation();
|
|
const initializer = isInOrOfKeyword(token()) ? void 0 : parseInitializer();
|
|
const node = factory2.createVariableDeclaration(name, exclamationToken, type, initializer);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseVariableDeclarationList(inForStatementInitializer) {
|
|
const pos = getNodePos();
|
|
let flags = 0;
|
|
switch (token()) {
|
|
case 113 /* VarKeyword */:
|
|
break;
|
|
case 119 /* LetKeyword */:
|
|
flags |= 1 /* Let */;
|
|
break;
|
|
case 85 /* ConstKeyword */:
|
|
flags |= 2 /* Const */;
|
|
break;
|
|
default:
|
|
Debug.fail();
|
|
}
|
|
nextToken();
|
|
let declarations;
|
|
if (token() === 162 /* OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) {
|
|
declarations = createMissingList();
|
|
} else {
|
|
const savedDisallowIn = inDisallowInContext();
|
|
setDisallowInContext(inForStatementInitializer);
|
|
declarations = parseDelimitedList(
|
|
ParsingContext.VariableDeclarations,
|
|
inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation
|
|
);
|
|
setDisallowInContext(savedDisallowIn);
|
|
}
|
|
return finishNode(factory2.createVariableDeclarationList(declarations, flags), pos);
|
|
}
|
|
function canFollowContextualOfKeyword() {
|
|
return nextTokenIsIdentifier() && nextToken() === 21 /* CloseParenToken */;
|
|
}
|
|
function parseVariableStatement(pos, hasJSDoc, decorators, modifiers) {
|
|
const declarationList = parseVariableDeclarationList(false);
|
|
parseSemicolon();
|
|
const node = factory2.createVariableStatement(modifiers, declarationList);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
const modifierFlags = modifiersToFlags(modifiers);
|
|
parseExpected(98 /* FunctionKeyword */);
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const name = modifierFlags & 1024 /* Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier();
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = modifierFlags & 512 /* Async */ ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
if (modifierFlags & 1 /* Export */)
|
|
setAwaitContext(true);
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, Diagnostics.or_expected);
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseConstructorName() {
|
|
if (token() === 135 /* ConstructorKeyword */) {
|
|
return parseExpected(135 /* ConstructorKeyword */);
|
|
}
|
|
if (token() === 10 /* StringLiteral */ && lookAhead(nextToken) === 20 /* OpenParenToken */) {
|
|
return tryParse(() => {
|
|
const literalNode = parseLiteralNode();
|
|
return literalNode.text === "constructor" ? literalNode : void 0;
|
|
});
|
|
}
|
|
}
|
|
function tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
return tryParse(() => {
|
|
if (parseConstructorName()) {
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(0 /* None */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(0 /* None */, Diagnostics.or_expected);
|
|
const node = factory2.createConstructorDeclaration(modifiers, parameters, body);
|
|
node.illegalDecorators = decorators;
|
|
node.typeParameters = typeParameters;
|
|
node.type = type;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
});
|
|
}
|
|
function parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken, diagnosticMessage) {
|
|
const isGenerator = asteriskToken ? 1 /* Yield */ : 0 /* None */;
|
|
const isAsync = some(modifiers, isAsyncModifier) ? 2 /* Await */ : 0 /* None */;
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(isGenerator | isAsync);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);
|
|
const node = factory2.createMethodDeclaration(
|
|
combineDecoratorsAndModifiers(decorators, modifiers),
|
|
asteriskToken,
|
|
name,
|
|
questionToken,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
body
|
|
);
|
|
node.exclamationToken = exclamationToken;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken) {
|
|
const exclamationToken = !questionToken && !scanner2.hasPrecedingLineBreak() ? parseOptionalToken(53 /* ExclamationToken */) : void 0;
|
|
const type = parseTypeAnnotation();
|
|
const initializer = doOutsideOfContext(8192 /* YieldContext */ | 32768 /* AwaitContext */ | 4096 /* DisallowInContext */, parseInitializer);
|
|
parseSemicolonAfterPropertyName(name, type, initializer);
|
|
const node = factory2.createPropertyDeclaration(
|
|
combineDecoratorsAndModifiers(decorators, modifiers),
|
|
name,
|
|
questionToken || exclamationToken,
|
|
type,
|
|
initializer
|
|
);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
|
|
const name = parsePropertyName();
|
|
const questionToken = parseOptionalToken(57 /* QuestionToken */);
|
|
if (asteriskToken || token() === 20 /* OpenParenToken */ || token() === 29 /* LessThanToken */) {
|
|
return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, void 0, Diagnostics.or_expected);
|
|
}
|
|
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
|
|
}
|
|
function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) {
|
|
const name = parsePropertyName();
|
|
const typeParameters = parseTypeParameters();
|
|
const parameters = parseParameters(0 /* None */);
|
|
const type = parseReturnType(58 /* ColonToken */, false);
|
|
const body = parseFunctionBlockOrSemicolon(flags);
|
|
const node = kind === 174 /* GetAccessor */ ? factory2.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body) : factory2.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body);
|
|
node.typeParameters = typeParameters;
|
|
if (isSetAccessorDeclaration(node))
|
|
node.type = type;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function isClassMemberStart() {
|
|
let idToken;
|
|
if (token() === 59 /* AtToken */) {
|
|
return true;
|
|
}
|
|
while (isModifierKind(token())) {
|
|
idToken = token();
|
|
if (isClassMemberModifier(idToken)) {
|
|
return true;
|
|
}
|
|
nextToken();
|
|
}
|
|
if (token() === 41 /* AsteriskToken */) {
|
|
return true;
|
|
}
|
|
if (isLiteralPropertyName()) {
|
|
idToken = token();
|
|
nextToken();
|
|
}
|
|
if (token() === 22 /* OpenBracketToken */) {
|
|
return true;
|
|
}
|
|
if (idToken !== void 0) {
|
|
if (!isKeyword(idToken) || idToken === 151 /* SetKeyword */ || idToken === 137 /* GetKeyword */) {
|
|
return true;
|
|
}
|
|
switch (token()) {
|
|
case 20 /* OpenParenToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 58 /* ColonToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 57 /* QuestionToken */:
|
|
return true;
|
|
default:
|
|
return canParseSemicolon();
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpectedToken(124 /* StaticKeyword */);
|
|
const body = parseClassStaticBlockBody();
|
|
const node = withJSDoc(finishNode(factory2.createClassStaticBlockDeclaration(body), pos), hasJSDoc);
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
return node;
|
|
}
|
|
function parseClassStaticBlockBody() {
|
|
const savedYieldContext = inYieldContext();
|
|
const savedAwaitContext = inAwaitContext();
|
|
setYieldContext(false);
|
|
setAwaitContext(true);
|
|
const body = parseBlock(false);
|
|
setYieldContext(savedYieldContext);
|
|
setAwaitContext(savedAwaitContext);
|
|
return body;
|
|
}
|
|
function parseDecoratorExpression() {
|
|
if (inAwaitContext() && token() === 133 /* AwaitKeyword */) {
|
|
const pos = getNodePos();
|
|
const awaitExpression = parseIdentifier(Diagnostics.Expression_expected);
|
|
nextToken();
|
|
const memberExpression = parseMemberExpressionRest(pos, awaitExpression, true);
|
|
return parseCallExpressionRest(pos, memberExpression);
|
|
}
|
|
return parseLeftHandSideExpressionOrHigher();
|
|
}
|
|
function tryParseDecorator() {
|
|
const pos = getNodePos();
|
|
if (!parseOptional(59 /* AtToken */)) {
|
|
return void 0;
|
|
}
|
|
const expression = doInDecoratorContext(parseDecoratorExpression);
|
|
return finishNode(factory2.createDecorator(expression), pos);
|
|
}
|
|
function parseDecorators() {
|
|
const pos = getNodePos();
|
|
let list, decorator;
|
|
while (decorator = tryParseDecorator()) {
|
|
list = append(list, decorator);
|
|
}
|
|
return list && createNodeArray2(list, pos);
|
|
}
|
|
function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) {
|
|
const pos = getNodePos();
|
|
const kind = token();
|
|
if (token() === 85 /* ConstKeyword */ && permitInvalidConstAsModifier) {
|
|
if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
|
|
return void 0;
|
|
}
|
|
} else if (stopOnStartOfClassStaticBlock && token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
|
|
return void 0;
|
|
} else if (hasSeenStaticModifier && token() === 124 /* StaticKeyword */) {
|
|
return void 0;
|
|
} else {
|
|
if (!parseAnyContextualModifier()) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return finishNode(factory2.createToken(kind), pos);
|
|
}
|
|
function combineDecoratorsAndModifiers(decorators, modifiers) {
|
|
if (!decorators)
|
|
return modifiers;
|
|
if (!modifiers)
|
|
return decorators;
|
|
const decoratorsAndModifiers = factory2.createNodeArray(concatenate(decorators, modifiers));
|
|
setTextRangePosEnd(decoratorsAndModifiers, decorators.pos, modifiers.end);
|
|
return decoratorsAndModifiers;
|
|
}
|
|
function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) {
|
|
const pos = getNodePos();
|
|
let list, modifier, hasSeenStatic = false;
|
|
while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) {
|
|
if (modifier.kind === 124 /* StaticKeyword */)
|
|
hasSeenStatic = true;
|
|
list = append(list, modifier);
|
|
}
|
|
return list && createNodeArray2(list, pos);
|
|
}
|
|
function parseModifiersForArrowFunction() {
|
|
let modifiers;
|
|
if (token() === 132 /* AsyncKeyword */) {
|
|
const pos = getNodePos();
|
|
nextToken();
|
|
const modifier = finishNode(factory2.createToken(132 /* AsyncKeyword */), pos);
|
|
modifiers = createNodeArray2([modifier], pos);
|
|
}
|
|
return modifiers;
|
|
}
|
|
function parseClassElement() {
|
|
const pos = getNodePos();
|
|
if (token() === 26 /* SemicolonToken */) {
|
|
nextToken();
|
|
return finishNode(factory2.createSemicolonClassElement(), pos);
|
|
}
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const decorators = parseDecorators();
|
|
const modifiers = parseModifiers(true, true);
|
|
if (token() === 124 /* StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) {
|
|
return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
if (parseContextualModifier(137 /* GetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* GetAccessor */, 0 /* None */);
|
|
}
|
|
if (parseContextualModifier(151 /* SetKeyword */)) {
|
|
return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SetAccessor */, 0 /* None */);
|
|
}
|
|
if (token() === 135 /* ConstructorKeyword */ || token() === 10 /* StringLiteral */) {
|
|
const constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
if (constructorDeclaration) {
|
|
return constructorDeclaration;
|
|
}
|
|
}
|
|
if (isIndexSignature()) {
|
|
return parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
if (tokenIsIdentifierOrKeyword(token()) || token() === 10 /* StringLiteral */ || token() === 8 /* NumericLiteral */ || token() === 41 /* AsteriskToken */ || token() === 22 /* OpenBracketToken */) {
|
|
const isAmbient = some(modifiers, isDeclareModifier);
|
|
if (isAmbient) {
|
|
for (const m of modifiers) {
|
|
m.flags |= 16777216 /* Ambient */;
|
|
}
|
|
return doInsideOfContext(16777216 /* Ambient */, () => parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers));
|
|
} else {
|
|
return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
if (decorators || modifiers) {
|
|
const name = createMissingNode(79 /* Identifier */, true, Diagnostics.Declaration_expected);
|
|
return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, void 0);
|
|
}
|
|
return Debug.fail("Should not have attempted to parse class member declaration.");
|
|
}
|
|
function parseClassExpression() {
|
|
return parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), void 0, void 0, 228 /* ClassExpression */);
|
|
}
|
|
function parseClassDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, 260 /* ClassDeclaration */);
|
|
}
|
|
function parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, kind) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
parseExpected(84 /* ClassKeyword */);
|
|
const name = parseNameOfClassDeclarationOrExpression();
|
|
const typeParameters = parseTypeParameters();
|
|
if (some(modifiers, isExportModifier))
|
|
setAwaitContext(true);
|
|
const heritageClauses = parseHeritageClauses();
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = parseClassMembers();
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = kind === 260 /* ClassDeclaration */ ? factory2.createClassDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members) : factory2.createClassExpression(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseNameOfClassDeclarationOrExpression() {
|
|
return isBindingIdentifier() && !isImplementsClause() ? createIdentifier3(isBindingIdentifier()) : void 0;
|
|
}
|
|
function isImplementsClause() {
|
|
return token() === 117 /* ImplementsKeyword */ && lookAhead(nextTokenIsIdentifierOrKeyword);
|
|
}
|
|
function parseHeritageClauses() {
|
|
if (isHeritageClause2()) {
|
|
return parseList(ParsingContext.HeritageClauses, parseHeritageClause);
|
|
}
|
|
return void 0;
|
|
}
|
|
function parseHeritageClause() {
|
|
const pos = getNodePos();
|
|
const tok = token();
|
|
Debug.assert(tok === 94 /* ExtendsKeyword */ || tok === 117 /* ImplementsKeyword */);
|
|
nextToken();
|
|
const types = parseDelimitedList(ParsingContext.HeritageClauseElement, parseExpressionWithTypeArguments);
|
|
return finishNode(factory2.createHeritageClause(tok, types), pos);
|
|
}
|
|
function parseExpressionWithTypeArguments() {
|
|
const pos = getNodePos();
|
|
const expression = parseLeftHandSideExpressionOrHigher();
|
|
if (expression.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
return expression;
|
|
}
|
|
const typeArguments = tryParseTypeArguments();
|
|
return finishNode(factory2.createExpressionWithTypeArguments(expression, typeArguments), pos);
|
|
}
|
|
function tryParseTypeArguments() {
|
|
return token() === 29 /* LessThanToken */ ? parseBracketedList(ParsingContext.TypeArguments, parseType, 29 /* LessThanToken */, 31 /* GreaterThanToken */) : void 0;
|
|
}
|
|
function isHeritageClause2() {
|
|
return token() === 94 /* ExtendsKeyword */ || token() === 117 /* ImplementsKeyword */;
|
|
}
|
|
function parseClassMembers() {
|
|
return parseList(ParsingContext.ClassMembers, parseClassElement);
|
|
}
|
|
function parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(118 /* InterfaceKeyword */);
|
|
const name = parseIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
const heritageClauses = parseHeritageClauses();
|
|
const members = parseObjectTypeMembers();
|
|
const node = factory2.createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(154 /* TypeKeyword */);
|
|
const name = parseIdentifier();
|
|
const typeParameters = parseTypeParameters();
|
|
parseExpected(63 /* EqualsToken */);
|
|
const type = token() === 139 /* IntrinsicKeyword */ && tryParse(parseKeywordAndNoDot) || parseType();
|
|
parseSemicolon();
|
|
const node = factory2.createTypeAliasDeclaration(modifiers, name, typeParameters, type);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseEnumMember() {
|
|
const pos = getNodePos();
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
const name = parsePropertyName();
|
|
const initializer = allowInAnd(parseInitializer);
|
|
return withJSDoc(finishNode(factory2.createEnumMember(name, initializer), pos), hasJSDoc);
|
|
}
|
|
function parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(92 /* EnumKeyword */);
|
|
const name = parseIdentifier();
|
|
let members;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
members = doOutsideOfYieldAndAwaitContext(() => parseDelimitedList(ParsingContext.EnumMembers, parseEnumMember));
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
members = createMissingList();
|
|
}
|
|
const node = factory2.createEnumDeclaration(modifiers, name, members);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseModuleBlock() {
|
|
const pos = getNodePos();
|
|
let statements;
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
statements = parseList(ParsingContext.BlockStatements, parseStatement);
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
} else {
|
|
statements = createMissingList();
|
|
}
|
|
return finishNode(factory2.createModuleBlock(statements), pos);
|
|
}
|
|
function parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags) {
|
|
const namespaceFlag = flags & 16 /* Namespace */;
|
|
const name = parseIdentifier();
|
|
const body = parseOptional(24 /* DotToken */) ? parseModuleOrNamespaceDeclaration(getNodePos(), false, void 0, void 0, 4 /* NestedNamespace */ | namespaceFlag) : parseModuleBlock();
|
|
const node = factory2.createModuleDeclaration(modifiers, name, body, flags);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
let flags = 0;
|
|
let name;
|
|
if (token() === 159 /* GlobalKeyword */) {
|
|
name = parseIdentifier();
|
|
flags |= 1024 /* GlobalAugmentation */;
|
|
} else {
|
|
name = parseLiteralNode();
|
|
name.text = internIdentifier(name.text);
|
|
}
|
|
let body;
|
|
if (token() === 18 /* OpenBraceToken */) {
|
|
body = parseModuleBlock();
|
|
} else {
|
|
parseSemicolon();
|
|
}
|
|
const node = factory2.createModuleDeclaration(modifiers, name, body, flags);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
let flags = 0;
|
|
if (token() === 159 /* GlobalKeyword */) {
|
|
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
} else if (parseOptional(143 /* NamespaceKeyword */)) {
|
|
flags |= 16 /* Namespace */;
|
|
} else {
|
|
parseExpected(142 /* ModuleKeyword */);
|
|
if (token() === 10 /* StringLiteral */) {
|
|
return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers);
|
|
}
|
|
}
|
|
return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags);
|
|
}
|
|
function isExternalModuleReference2() {
|
|
return token() === 147 /* RequireKeyword */ && lookAhead(nextTokenIsOpenParen);
|
|
}
|
|
function nextTokenIsOpenParen() {
|
|
return nextToken() === 20 /* OpenParenToken */;
|
|
}
|
|
function nextTokenIsOpenBrace() {
|
|
return nextToken() === 18 /* OpenBraceToken */;
|
|
}
|
|
function nextTokenIsSlash() {
|
|
return nextToken() === 43 /* SlashToken */;
|
|
}
|
|
function parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(128 /* AsKeyword */);
|
|
parseExpected(143 /* NamespaceKeyword */);
|
|
const name = parseIdentifier();
|
|
parseSemicolon();
|
|
const node = factory2.createNamespaceExportDeclaration(name);
|
|
node.illegalDecorators = decorators;
|
|
node.modifiers = modifiers;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
parseExpected(100 /* ImportKeyword */);
|
|
const afterImportPos = scanner2.getStartPos();
|
|
let identifier;
|
|
if (isIdentifier2()) {
|
|
identifier = parseIdentifier();
|
|
}
|
|
let isTypeOnly = false;
|
|
if (token() !== 158 /* FromKeyword */ && (identifier == null ? void 0 : identifier.escapedText) === "type" && (isIdentifier2() || tokenAfterImportDefinitelyProducesImportDeclaration())) {
|
|
isTypeOnly = true;
|
|
identifier = isIdentifier2() ? parseIdentifier() : void 0;
|
|
}
|
|
if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) {
|
|
return parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly);
|
|
}
|
|
let importClause;
|
|
if (identifier || token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */) {
|
|
importClause = parseImportClause(identifier, afterImportPos, isTypeOnly);
|
|
parseExpected(158 /* FromKeyword */);
|
|
}
|
|
const moduleSpecifier = parseModuleSpecifier();
|
|
let assertClause;
|
|
if (token() === 130 /* AssertKeyword */ && !scanner2.hasPrecedingLineBreak()) {
|
|
assertClause = parseAssertClause();
|
|
}
|
|
parseSemicolon();
|
|
const node = factory2.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseAssertEntry() {
|
|
const pos = getNodePos();
|
|
const name = tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
|
|
parseExpected(58 /* ColonToken */);
|
|
const value = parseAssignmentExpressionOrHigher(true);
|
|
return finishNode(factory2.createAssertEntry(name, value), pos);
|
|
}
|
|
function parseAssertClause(skipAssertKeyword) {
|
|
const pos = getNodePos();
|
|
if (!skipAssertKeyword) {
|
|
parseExpected(130 /* AssertKeyword */);
|
|
}
|
|
const openBracePosition = scanner2.getTokenPos();
|
|
if (parseExpected(18 /* OpenBraceToken */)) {
|
|
const multiLine = scanner2.hasPrecedingLineBreak();
|
|
const elements = parseDelimitedList(ParsingContext.AssertEntries, parseAssertEntry, true);
|
|
if (!parseExpected(19 /* CloseBraceToken */)) {
|
|
const lastError = lastOrUndefined(parseDiagnostics);
|
|
if (lastError && lastError.code === Diagnostics._0_expected.code) {
|
|
addRelatedInfo(
|
|
lastError,
|
|
createDetachedDiagnostic(fileName, openBracePosition, 1, Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")
|
|
);
|
|
}
|
|
}
|
|
return finishNode(factory2.createAssertClause(elements, multiLine), pos);
|
|
} else {
|
|
const elements = createNodeArray2([], getNodePos(), void 0, false);
|
|
return finishNode(factory2.createAssertClause(elements, false), pos);
|
|
}
|
|
}
|
|
function tokenAfterImportDefinitelyProducesImportDeclaration() {
|
|
return token() === 41 /* AsteriskToken */ || token() === 18 /* OpenBraceToken */;
|
|
}
|
|
function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() {
|
|
return token() === 27 /* CommaToken */ || token() === 158 /* FromKeyword */;
|
|
}
|
|
function parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly) {
|
|
parseExpected(63 /* EqualsToken */);
|
|
const moduleReference = parseModuleReference();
|
|
parseSemicolon();
|
|
const node = factory2.createImportEqualsDeclaration(modifiers, isTypeOnly, identifier, moduleReference);
|
|
node.illegalDecorators = decorators;
|
|
const finished = withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
return finished;
|
|
}
|
|
function parseImportClause(identifier, pos, isTypeOnly) {
|
|
let namedBindings;
|
|
if (!identifier || parseOptional(27 /* CommaToken */)) {
|
|
namedBindings = token() === 41 /* AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(272 /* NamedImports */);
|
|
}
|
|
return finishNode(factory2.createImportClause(isTypeOnly, identifier, namedBindings), pos);
|
|
}
|
|
function parseModuleReference() {
|
|
return isExternalModuleReference2() ? parseExternalModuleReference() : parseEntityName(false);
|
|
}
|
|
function parseExternalModuleReference() {
|
|
const pos = getNodePos();
|
|
parseExpected(147 /* RequireKeyword */);
|
|
parseExpected(20 /* OpenParenToken */);
|
|
const expression = parseModuleSpecifier();
|
|
parseExpected(21 /* CloseParenToken */);
|
|
return finishNode(factory2.createExternalModuleReference(expression), pos);
|
|
}
|
|
function parseModuleSpecifier() {
|
|
if (token() === 10 /* StringLiteral */) {
|
|
const result = parseLiteralNode();
|
|
result.text = internIdentifier(result.text);
|
|
return result;
|
|
} else {
|
|
return parseExpression();
|
|
}
|
|
}
|
|
function parseNamespaceImport() {
|
|
const pos = getNodePos();
|
|
parseExpected(41 /* AsteriskToken */);
|
|
parseExpected(128 /* AsKeyword */);
|
|
const name = parseIdentifier();
|
|
return finishNode(factory2.createNamespaceImport(name), pos);
|
|
}
|
|
function parseNamedImportsOrExports(kind) {
|
|
const pos = getNodePos();
|
|
const node = kind === 272 /* NamedImports */ ? factory2.createNamedImports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseImportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */)) : factory2.createNamedExports(parseBracketedList(ParsingContext.ImportOrExportSpecifiers, parseExportSpecifier, 18 /* OpenBraceToken */, 19 /* CloseBraceToken */));
|
|
return finishNode(node, pos);
|
|
}
|
|
function parseExportSpecifier() {
|
|
const hasJSDoc = hasPrecedingJSDocComment();
|
|
return withJSDoc(parseImportOrExportSpecifier(278 /* ExportSpecifier */), hasJSDoc);
|
|
}
|
|
function parseImportSpecifier() {
|
|
return parseImportOrExportSpecifier(273 /* ImportSpecifier */);
|
|
}
|
|
function parseImportOrExportSpecifier(kind) {
|
|
const pos = getNodePos();
|
|
let checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier2();
|
|
let checkIdentifierStart = scanner2.getTokenPos();
|
|
let checkIdentifierEnd = scanner2.getTextPos();
|
|
let isTypeOnly = false;
|
|
let propertyName;
|
|
let canParseAsKeyword = true;
|
|
let name = parseIdentifierName();
|
|
if (name.escapedText === "type") {
|
|
if (token() === 128 /* AsKeyword */) {
|
|
const firstAs = parseIdentifierName();
|
|
if (token() === 128 /* AsKeyword */) {
|
|
const secondAs = parseIdentifierName();
|
|
if (tokenIsIdentifierOrKeyword(token())) {
|
|
isTypeOnly = true;
|
|
propertyName = firstAs;
|
|
name = parseNameWithKeywordCheck();
|
|
canParseAsKeyword = false;
|
|
} else {
|
|
propertyName = name;
|
|
name = secondAs;
|
|
canParseAsKeyword = false;
|
|
}
|
|
} else if (tokenIsIdentifierOrKeyword(token())) {
|
|
propertyName = name;
|
|
canParseAsKeyword = false;
|
|
name = parseNameWithKeywordCheck();
|
|
} else {
|
|
isTypeOnly = true;
|
|
name = firstAs;
|
|
}
|
|
} else if (tokenIsIdentifierOrKeyword(token())) {
|
|
isTypeOnly = true;
|
|
name = parseNameWithKeywordCheck();
|
|
}
|
|
}
|
|
if (canParseAsKeyword && token() === 128 /* AsKeyword */) {
|
|
propertyName = name;
|
|
parseExpected(128 /* AsKeyword */);
|
|
name = parseNameWithKeywordCheck();
|
|
}
|
|
if (kind === 273 /* ImportSpecifier */ && checkIdentifierIsKeyword) {
|
|
parseErrorAt(checkIdentifierStart, checkIdentifierEnd, Diagnostics.Identifier_expected);
|
|
}
|
|
const node = kind === 273 /* ImportSpecifier */ ? factory2.createImportSpecifier(isTypeOnly, propertyName, name) : factory2.createExportSpecifier(isTypeOnly, propertyName, name);
|
|
return finishNode(node, pos);
|
|
function parseNameWithKeywordCheck() {
|
|
checkIdentifierIsKeyword = isKeyword(token()) && !isIdentifier2();
|
|
checkIdentifierStart = scanner2.getTokenPos();
|
|
checkIdentifierEnd = scanner2.getTextPos();
|
|
return parseIdentifierName();
|
|
}
|
|
}
|
|
function parseNamespaceExport(pos) {
|
|
return finishNode(factory2.createNamespaceExport(parseIdentifierName()), pos);
|
|
}
|
|
function parseExportDeclaration(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(true);
|
|
let exportClause;
|
|
let moduleSpecifier;
|
|
let assertClause;
|
|
const isTypeOnly = parseOptional(154 /* TypeKeyword */);
|
|
const namespaceExportPos = getNodePos();
|
|
if (parseOptional(41 /* AsteriskToken */)) {
|
|
if (parseOptional(128 /* AsKeyword */)) {
|
|
exportClause = parseNamespaceExport(namespaceExportPos);
|
|
}
|
|
parseExpected(158 /* FromKeyword */);
|
|
moduleSpecifier = parseModuleSpecifier();
|
|
} else {
|
|
exportClause = parseNamedImportsOrExports(276 /* NamedExports */);
|
|
if (token() === 158 /* FromKeyword */ || token() === 10 /* StringLiteral */ && !scanner2.hasPrecedingLineBreak()) {
|
|
parseExpected(158 /* FromKeyword */);
|
|
moduleSpecifier = parseModuleSpecifier();
|
|
}
|
|
}
|
|
if (moduleSpecifier && token() === 130 /* AssertKeyword */ && !scanner2.hasPrecedingLineBreak()) {
|
|
assertClause = parseAssertClause();
|
|
}
|
|
parseSemicolon();
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
function parseExportAssignment(pos, hasJSDoc, decorators, modifiers) {
|
|
const savedAwaitContext = inAwaitContext();
|
|
setAwaitContext(true);
|
|
let isExportEquals;
|
|
if (parseOptional(63 /* EqualsToken */)) {
|
|
isExportEquals = true;
|
|
} else {
|
|
parseExpected(88 /* DefaultKeyword */);
|
|
}
|
|
const expression = parseAssignmentExpressionOrHigher(true);
|
|
parseSemicolon();
|
|
setAwaitContext(savedAwaitContext);
|
|
const node = factory2.createExportAssignment(modifiers, isExportEquals, expression);
|
|
node.illegalDecorators = decorators;
|
|
return withJSDoc(finishNode(node, pos), hasJSDoc);
|
|
}
|
|
let ParsingContext;
|
|
((ParsingContext2) => {
|
|
ParsingContext2[ParsingContext2["SourceElements"] = 0] = "SourceElements";
|
|
ParsingContext2[ParsingContext2["BlockStatements"] = 1] = "BlockStatements";
|
|
ParsingContext2[ParsingContext2["SwitchClauses"] = 2] = "SwitchClauses";
|
|
ParsingContext2[ParsingContext2["SwitchClauseStatements"] = 3] = "SwitchClauseStatements";
|
|
ParsingContext2[ParsingContext2["TypeMembers"] = 4] = "TypeMembers";
|
|
ParsingContext2[ParsingContext2["ClassMembers"] = 5] = "ClassMembers";
|
|
ParsingContext2[ParsingContext2["EnumMembers"] = 6] = "EnumMembers";
|
|
ParsingContext2[ParsingContext2["HeritageClauseElement"] = 7] = "HeritageClauseElement";
|
|
ParsingContext2[ParsingContext2["VariableDeclarations"] = 8] = "VariableDeclarations";
|
|
ParsingContext2[ParsingContext2["ObjectBindingElements"] = 9] = "ObjectBindingElements";
|
|
ParsingContext2[ParsingContext2["ArrayBindingElements"] = 10] = "ArrayBindingElements";
|
|
ParsingContext2[ParsingContext2["ArgumentExpressions"] = 11] = "ArgumentExpressions";
|
|
ParsingContext2[ParsingContext2["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers";
|
|
ParsingContext2[ParsingContext2["JsxAttributes"] = 13] = "JsxAttributes";
|
|
ParsingContext2[ParsingContext2["JsxChildren"] = 14] = "JsxChildren";
|
|
ParsingContext2[ParsingContext2["ArrayLiteralMembers"] = 15] = "ArrayLiteralMembers";
|
|
ParsingContext2[ParsingContext2["Parameters"] = 16] = "Parameters";
|
|
ParsingContext2[ParsingContext2["JSDocParameters"] = 17] = "JSDocParameters";
|
|
ParsingContext2[ParsingContext2["RestProperties"] = 18] = "RestProperties";
|
|
ParsingContext2[ParsingContext2["TypeParameters"] = 19] = "TypeParameters";
|
|
ParsingContext2[ParsingContext2["TypeArguments"] = 20] = "TypeArguments";
|
|
ParsingContext2[ParsingContext2["TupleElementTypes"] = 21] = "TupleElementTypes";
|
|
ParsingContext2[ParsingContext2["HeritageClauses"] = 22] = "HeritageClauses";
|
|
ParsingContext2[ParsingContext2["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers";
|
|
ParsingContext2[ParsingContext2["AssertEntries"] = 24] = "AssertEntries";
|
|
ParsingContext2[ParsingContext2["Count"] = 25] = "Count";
|
|
})(ParsingContext || (ParsingContext = {}));
|
|
let Tristate;
|
|
((Tristate2) => {
|
|
Tristate2[Tristate2["False"] = 0] = "False";
|
|
Tristate2[Tristate2["True"] = 1] = "True";
|
|
Tristate2[Tristate2["Unknown"] = 2] = "Unknown";
|
|
})(Tristate || (Tristate = {}));
|
|
let JSDocParser;
|
|
((JSDocParser2) => {
|
|
function parseJSDocTypeExpressionForTests2(content, start2, length2) {
|
|
initializeState("file.js", content, 99 /* Latest */, void 0, 1 /* JS */);
|
|
scanner2.setText(content, start2, length2);
|
|
currentToken = scanner2.scan();
|
|
const jsDocTypeExpression = parseJSDocTypeExpression();
|
|
const sourceFile = createSourceFile2("file.js", 99 /* Latest */, 1 /* JS */, false, [], factory2.createToken(1 /* EndOfFileToken */), 0 /* None */, noop);
|
|
const diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
if (jsDocDiagnostics) {
|
|
sourceFile.jsDocDiagnostics = attachFileToDiagnostics(jsDocDiagnostics, sourceFile);
|
|
}
|
|
clearState();
|
|
return jsDocTypeExpression ? { jsDocTypeExpression, diagnostics } : void 0;
|
|
}
|
|
JSDocParser2.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests2;
|
|
function parseJSDocTypeExpression(mayOmitBraces) {
|
|
const pos = getNodePos();
|
|
const hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18 /* OpenBraceToken */);
|
|
const type = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
|
|
if (!mayOmitBraces || hasBrace) {
|
|
parseExpectedJSDoc(19 /* CloseBraceToken */);
|
|
}
|
|
const result = factory2.createJSDocTypeExpression(type);
|
|
fixupParentReferences(result);
|
|
return finishNode(result, pos);
|
|
}
|
|
JSDocParser2.parseJSDocTypeExpression = parseJSDocTypeExpression;
|
|
function parseJSDocNameReference() {
|
|
const pos = getNodePos();
|
|
const hasBrace = parseOptional(18 /* OpenBraceToken */);
|
|
const p2 = getNodePos();
|
|
let entityName = parseEntityName(false);
|
|
while (token() === 80 /* PrivateIdentifier */) {
|
|
reScanHashToken();
|
|
nextTokenJSDoc();
|
|
entityName = finishNode(factory2.createJSDocMemberName(entityName, parseIdentifier()), p2);
|
|
}
|
|
if (hasBrace) {
|
|
parseExpectedJSDoc(19 /* CloseBraceToken */);
|
|
}
|
|
const result = factory2.createJSDocNameReference(entityName);
|
|
fixupParentReferences(result);
|
|
return finishNode(result, pos);
|
|
}
|
|
JSDocParser2.parseJSDocNameReference = parseJSDocNameReference;
|
|
function parseIsolatedJSDocComment2(content, start2, length2) {
|
|
initializeState("", content, 99 /* Latest */, void 0, 1 /* JS */);
|
|
const jsDoc = doInsideOfContext(8388608 /* JSDoc */, () => parseJSDocCommentWorker(start2, length2));
|
|
const sourceFile = { languageVariant: 0 /* Standard */, text: content };
|
|
const diagnostics = attachFileToDiagnostics(parseDiagnostics, sourceFile);
|
|
clearState();
|
|
return jsDoc ? { jsDoc, diagnostics } : void 0;
|
|
}
|
|
JSDocParser2.parseIsolatedJSDocComment = parseIsolatedJSDocComment2;
|
|
function parseJSDocComment(parent2, start2, length2) {
|
|
const saveToken = currentToken;
|
|
const saveParseDiagnosticsLength = parseDiagnostics.length;
|
|
const saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode;
|
|
const comment = doInsideOfContext(8388608 /* JSDoc */, () => parseJSDocCommentWorker(start2, length2));
|
|
setParent(comment, parent2);
|
|
if (contextFlags & 262144 /* JavaScriptFile */) {
|
|
if (!jsDocDiagnostics) {
|
|
jsDocDiagnostics = [];
|
|
}
|
|
jsDocDiagnostics.push(...parseDiagnostics);
|
|
}
|
|
currentToken = saveToken;
|
|
parseDiagnostics.length = saveParseDiagnosticsLength;
|
|
parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode;
|
|
return comment;
|
|
}
|
|
JSDocParser2.parseJSDocComment = parseJSDocComment;
|
|
let JSDocState;
|
|
((JSDocState2) => {
|
|
JSDocState2[JSDocState2["BeginningOfLine"] = 0] = "BeginningOfLine";
|
|
JSDocState2[JSDocState2["SawAsterisk"] = 1] = "SawAsterisk";
|
|
JSDocState2[JSDocState2["SavingComments"] = 2] = "SavingComments";
|
|
JSDocState2[JSDocState2["SavingBackticks"] = 3] = "SavingBackticks";
|
|
})(JSDocState || (JSDocState = {}));
|
|
let PropertyLikeParse;
|
|
((PropertyLikeParse2) => {
|
|
PropertyLikeParse2[PropertyLikeParse2["Property"] = 1] = "Property";
|
|
PropertyLikeParse2[PropertyLikeParse2["Parameter"] = 2] = "Parameter";
|
|
PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
|
|
})(PropertyLikeParse || (PropertyLikeParse = {}));
|
|
function parseJSDocCommentWorker(start2 = 0, length2) {
|
|
const content = sourceText;
|
|
const end = length2 === void 0 ? content.length : start2 + length2;
|
|
length2 = end - start2;
|
|
Debug.assert(start2 >= 0);
|
|
Debug.assert(start2 <= end);
|
|
Debug.assert(end <= content.length);
|
|
if (!isJSDocLikeText(content, start2)) {
|
|
return void 0;
|
|
}
|
|
let tags;
|
|
let tagsPos;
|
|
let tagsEnd;
|
|
let linkEnd;
|
|
let commentsPos;
|
|
let comments = [];
|
|
const parts = [];
|
|
return scanner2.scanRange(start2 + 3, length2 - 5, () => {
|
|
let state = 1 /* SawAsterisk */;
|
|
let margin;
|
|
let indent3 = start2 - (content.lastIndexOf("\n", start2) + 1) + 4;
|
|
function pushComment(text) {
|
|
if (!margin) {
|
|
margin = indent3;
|
|
}
|
|
comments.push(text);
|
|
indent3 += text.length;
|
|
}
|
|
nextTokenJSDoc();
|
|
while (parseOptionalJsdoc(5 /* WhitespaceTrivia */))
|
|
;
|
|
if (parseOptionalJsdoc(4 /* NewLineTrivia */)) {
|
|
state = 0 /* BeginningOfLine */;
|
|
indent3 = 0;
|
|
}
|
|
loop:
|
|
while (true) {
|
|
switch (token()) {
|
|
case 59 /* AtToken */:
|
|
if (state === 0 /* BeginningOfLine */ || state === 1 /* SawAsterisk */) {
|
|
removeTrailingWhitespace(comments);
|
|
if (!commentsPos)
|
|
commentsPos = getNodePos();
|
|
addTag(parseTag(indent3));
|
|
state = 0 /* BeginningOfLine */;
|
|
margin = void 0;
|
|
} else {
|
|
pushComment(scanner2.getTokenText());
|
|
}
|
|
break;
|
|
case 4 /* NewLineTrivia */:
|
|
comments.push(scanner2.getTokenText());
|
|
state = 0 /* BeginningOfLine */;
|
|
indent3 = 0;
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
const asterisk = scanner2.getTokenText();
|
|
if (state === 1 /* SawAsterisk */ || state === 2 /* SavingComments */) {
|
|
state = 2 /* SavingComments */;
|
|
pushComment(asterisk);
|
|
} else {
|
|
state = 1 /* SawAsterisk */;
|
|
indent3 += asterisk.length;
|
|
}
|
|
break;
|
|
case 5 /* WhitespaceTrivia */:
|
|
const whitespace = scanner2.getTokenText();
|
|
if (state === 2 /* SavingComments */) {
|
|
comments.push(whitespace);
|
|
} else if (margin !== void 0 && indent3 + whitespace.length > margin) {
|
|
comments.push(whitespace.slice(margin - indent3));
|
|
}
|
|
indent3 += whitespace.length;
|
|
break;
|
|
case 1 /* EndOfFileToken */:
|
|
break loop;
|
|
case 18 /* OpenBraceToken */:
|
|
state = 2 /* SavingComments */;
|
|
const commentEnd = scanner2.getStartPos();
|
|
const linkStart = scanner2.getTextPos() - 1;
|
|
const link = parseJSDocLink(linkStart);
|
|
if (link) {
|
|
if (!linkEnd) {
|
|
removeLeadingNewlines(comments);
|
|
}
|
|
parts.push(finishNode(factory2.createJSDocText(comments.join("")), linkEnd != null ? linkEnd : start2, commentEnd));
|
|
parts.push(link);
|
|
comments = [];
|
|
linkEnd = scanner2.getTextPos();
|
|
break;
|
|
}
|
|
default:
|
|
state = 2 /* SavingComments */;
|
|
pushComment(scanner2.getTokenText());
|
|
break;
|
|
}
|
|
nextTokenJSDoc();
|
|
}
|
|
removeTrailingWhitespace(comments);
|
|
if (parts.length && comments.length) {
|
|
parts.push(finishNode(factory2.createJSDocText(comments.join("")), linkEnd != null ? linkEnd : start2, commentsPos));
|
|
}
|
|
if (parts.length && tags)
|
|
Debug.assertIsDefined(commentsPos, "having parsed tags implies that the end of the comment span should be set");
|
|
const tagsArray = tags && createNodeArray2(tags, tagsPos, tagsEnd);
|
|
return finishNode(factory2.createJSDocComment(parts.length ? createNodeArray2(parts, start2, commentsPos) : comments.length ? comments.join("") : void 0, tagsArray), start2, end);
|
|
});
|
|
function removeLeadingNewlines(comments2) {
|
|
while (comments2.length && (comments2[0] === "\n" || comments2[0] === "\r")) {
|
|
comments2.shift();
|
|
}
|
|
}
|
|
function removeTrailingWhitespace(comments2) {
|
|
while (comments2.length && comments2[comments2.length - 1].trim() === "") {
|
|
comments2.pop();
|
|
}
|
|
}
|
|
function isNextNonwhitespaceTokenEndOfFile() {
|
|
while (true) {
|
|
nextTokenJSDoc();
|
|
if (token() === 1 /* EndOfFileToken */) {
|
|
return true;
|
|
}
|
|
if (!(token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function skipWhitespace() {
|
|
if (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
|
|
return;
|
|
}
|
|
}
|
|
while (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
nextTokenJSDoc();
|
|
}
|
|
}
|
|
function skipWhitespaceOrAsterisk() {
|
|
if (token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) {
|
|
return "";
|
|
}
|
|
}
|
|
let precedingLineBreak = scanner2.hasPrecedingLineBreak();
|
|
let seenLineBreak = false;
|
|
let indentText = "";
|
|
while (precedingLineBreak && token() === 41 /* AsteriskToken */ || token() === 5 /* WhitespaceTrivia */ || token() === 4 /* NewLineTrivia */) {
|
|
indentText += scanner2.getTokenText();
|
|
if (token() === 4 /* NewLineTrivia */) {
|
|
precedingLineBreak = true;
|
|
seenLineBreak = true;
|
|
indentText = "";
|
|
} else if (token() === 41 /* AsteriskToken */) {
|
|
precedingLineBreak = false;
|
|
}
|
|
nextTokenJSDoc();
|
|
}
|
|
return seenLineBreak ? indentText : "";
|
|
}
|
|
function parseTag(margin) {
|
|
Debug.assert(token() === 59 /* AtToken */);
|
|
const start3 = scanner2.getTokenPos();
|
|
nextTokenJSDoc();
|
|
const tagName = parseJSDocIdentifierName(void 0);
|
|
const indentText = skipWhitespaceOrAsterisk();
|
|
let tag;
|
|
switch (tagName.escapedText) {
|
|
case "author":
|
|
tag = parseAuthorTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "implements":
|
|
tag = parseImplementsTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "augments":
|
|
case "extends":
|
|
tag = parseAugmentsTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "class":
|
|
case "constructor":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocClassTag, tagName, margin, indentText);
|
|
break;
|
|
case "public":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocPublicTag, tagName, margin, indentText);
|
|
break;
|
|
case "private":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocPrivateTag, tagName, margin, indentText);
|
|
break;
|
|
case "protected":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocProtectedTag, tagName, margin, indentText);
|
|
break;
|
|
case "readonly":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocReadonlyTag, tagName, margin, indentText);
|
|
break;
|
|
case "override":
|
|
tag = parseSimpleTag(start3, factory2.createJSDocOverrideTag, tagName, margin, indentText);
|
|
break;
|
|
case "deprecated":
|
|
hasDeprecatedTag = true;
|
|
tag = parseSimpleTag(start3, factory2.createJSDocDeprecatedTag, tagName, margin, indentText);
|
|
break;
|
|
case "this":
|
|
tag = parseThisTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "enum":
|
|
tag = parseEnumTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "arg":
|
|
case "argument":
|
|
case "param":
|
|
return parseParameterOrPropertyTag(start3, tagName, 2 /* Parameter */, margin);
|
|
case "return":
|
|
case "returns":
|
|
tag = parseReturnTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "template":
|
|
tag = parseTemplateTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "type":
|
|
tag = parseTypeTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "typedef":
|
|
tag = parseTypedefTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "callback":
|
|
tag = parseCallbackTag(start3, tagName, margin, indentText);
|
|
break;
|
|
case "see":
|
|
tag = parseSeeTag(start3, tagName, margin, indentText);
|
|
break;
|
|
default:
|
|
tag = parseUnknownTag(start3, tagName, margin, indentText);
|
|
break;
|
|
}
|
|
return tag;
|
|
}
|
|
function parseTrailingTagComments(pos, end2, margin, indentText) {
|
|
if (!indentText) {
|
|
margin += end2 - pos;
|
|
}
|
|
return parseTagComments(margin, indentText.slice(margin));
|
|
}
|
|
function parseTagComments(indent3, initialMargin) {
|
|
const commentsPos2 = getNodePos();
|
|
let comments2 = [];
|
|
const parts2 = [];
|
|
let linkEnd2;
|
|
let state = 0 /* BeginningOfLine */;
|
|
let previousWhitespace = true;
|
|
let margin;
|
|
function pushComment(text) {
|
|
if (!margin) {
|
|
margin = indent3;
|
|
}
|
|
comments2.push(text);
|
|
indent3 += text.length;
|
|
}
|
|
if (initialMargin !== void 0) {
|
|
if (initialMargin !== "") {
|
|
pushComment(initialMargin);
|
|
}
|
|
state = 1 /* SawAsterisk */;
|
|
}
|
|
let tok = token();
|
|
loop:
|
|
while (true) {
|
|
switch (tok) {
|
|
case 4 /* NewLineTrivia */:
|
|
state = 0 /* BeginningOfLine */;
|
|
comments2.push(scanner2.getTokenText());
|
|
indent3 = 0;
|
|
break;
|
|
case 59 /* AtToken */:
|
|
if (state === 3 /* SavingBackticks */ || state === 2 /* SavingComments */ && (!previousWhitespace || lookAhead(isNextJSDocTokenWhitespace))) {
|
|
comments2.push(scanner2.getTokenText());
|
|
break;
|
|
}
|
|
scanner2.setTextPos(scanner2.getTextPos() - 1);
|
|
case 1 /* EndOfFileToken */:
|
|
break loop;
|
|
case 5 /* WhitespaceTrivia */:
|
|
if (state === 2 /* SavingComments */ || state === 3 /* SavingBackticks */) {
|
|
pushComment(scanner2.getTokenText());
|
|
} else {
|
|
const whitespace = scanner2.getTokenText();
|
|
if (margin !== void 0 && indent3 + whitespace.length > margin) {
|
|
comments2.push(whitespace.slice(margin - indent3));
|
|
}
|
|
indent3 += whitespace.length;
|
|
}
|
|
break;
|
|
case 18 /* OpenBraceToken */:
|
|
state = 2 /* SavingComments */;
|
|
const commentEnd = scanner2.getStartPos();
|
|
const linkStart = scanner2.getTextPos() - 1;
|
|
const link = parseJSDocLink(linkStart);
|
|
if (link) {
|
|
parts2.push(finishNode(factory2.createJSDocText(comments2.join("")), linkEnd2 != null ? linkEnd2 : commentsPos2, commentEnd));
|
|
parts2.push(link);
|
|
comments2 = [];
|
|
linkEnd2 = scanner2.getTextPos();
|
|
} else {
|
|
pushComment(scanner2.getTokenText());
|
|
}
|
|
break;
|
|
case 61 /* BacktickToken */:
|
|
if (state === 3 /* SavingBackticks */) {
|
|
state = 2 /* SavingComments */;
|
|
} else {
|
|
state = 3 /* SavingBackticks */;
|
|
}
|
|
pushComment(scanner2.getTokenText());
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
if (state === 0 /* BeginningOfLine */) {
|
|
state = 1 /* SawAsterisk */;
|
|
indent3 += 1;
|
|
break;
|
|
}
|
|
default:
|
|
if (state !== 3 /* SavingBackticks */) {
|
|
state = 2 /* SavingComments */;
|
|
}
|
|
pushComment(scanner2.getTokenText());
|
|
break;
|
|
}
|
|
previousWhitespace = token() === 5 /* WhitespaceTrivia */;
|
|
tok = nextTokenJSDoc();
|
|
}
|
|
removeLeadingNewlines(comments2);
|
|
removeTrailingWhitespace(comments2);
|
|
if (parts2.length) {
|
|
if (comments2.length) {
|
|
parts2.push(finishNode(factory2.createJSDocText(comments2.join("")), linkEnd2 != null ? linkEnd2 : commentsPos2));
|
|
}
|
|
return createNodeArray2(parts2, commentsPos2, scanner2.getTextPos());
|
|
} else if (comments2.length) {
|
|
return comments2.join("");
|
|
}
|
|
}
|
|
function isNextJSDocTokenWhitespace() {
|
|
const next = nextTokenJSDoc();
|
|
return next === 5 /* WhitespaceTrivia */ || next === 4 /* NewLineTrivia */;
|
|
}
|
|
function parseJSDocLink(start3) {
|
|
const linkType = tryParse(parseJSDocLinkPrefix);
|
|
if (!linkType) {
|
|
return void 0;
|
|
}
|
|
nextTokenJSDoc();
|
|
skipWhitespace();
|
|
const p2 = getNodePos();
|
|
let name = tokenIsIdentifierOrKeyword(token()) ? parseEntityName(true) : void 0;
|
|
if (name) {
|
|
while (token() === 80 /* PrivateIdentifier */) {
|
|
reScanHashToken();
|
|
nextTokenJSDoc();
|
|
name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), p2);
|
|
}
|
|
}
|
|
const text = [];
|
|
while (token() !== 19 /* CloseBraceToken */ && token() !== 4 /* NewLineTrivia */ && token() !== 1 /* EndOfFileToken */) {
|
|
text.push(scanner2.getTokenText());
|
|
nextTokenJSDoc();
|
|
}
|
|
const create = linkType === "link" ? factory2.createJSDocLink : linkType === "linkcode" ? factory2.createJSDocLinkCode : factory2.createJSDocLinkPlain;
|
|
return finishNode(create(name, text.join("")), start3, scanner2.getTextPos());
|
|
}
|
|
function parseJSDocLinkPrefix() {
|
|
skipWhitespaceOrAsterisk();
|
|
if (token() === 18 /* OpenBraceToken */ && nextTokenJSDoc() === 59 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
|
|
const kind = scanner2.getTokenValue();
|
|
if (isJSDocLinkTag(kind))
|
|
return kind;
|
|
}
|
|
}
|
|
function isJSDocLinkTag(kind) {
|
|
return kind === "link" || kind === "linkcode" || kind === "linkplain";
|
|
}
|
|
function parseUnknownTag(start3, tagName, indent3, indentText) {
|
|
return finishNode(factory2.createJSDocUnknownTag(tagName, parseTrailingTagComments(start3, getNodePos(), indent3, indentText)), start3);
|
|
}
|
|
function addTag(tag) {
|
|
if (!tag) {
|
|
return;
|
|
}
|
|
if (!tags) {
|
|
tags = [tag];
|
|
tagsPos = tag.pos;
|
|
} else {
|
|
tags.push(tag);
|
|
}
|
|
tagsEnd = tag.end;
|
|
}
|
|
function tryParseTypeExpression() {
|
|
skipWhitespaceOrAsterisk();
|
|
return token() === 18 /* OpenBraceToken */ ? parseJSDocTypeExpression() : void 0;
|
|
}
|
|
function parseBracketNameInPropertyAndParamTag() {
|
|
const isBracketed = parseOptionalJsdoc(22 /* OpenBracketToken */);
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
}
|
|
const isBackquoted = parseOptionalJsdoc(61 /* BacktickToken */);
|
|
const name = parseJSDocEntityName();
|
|
if (isBackquoted) {
|
|
parseExpectedTokenJSDoc(61 /* BacktickToken */);
|
|
}
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
if (parseOptionalToken(63 /* EqualsToken */)) {
|
|
parseExpression();
|
|
}
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
return { name, isBracketed };
|
|
}
|
|
function isObjectOrObjectArrayTypeReference(node) {
|
|
switch (node.kind) {
|
|
case 149 /* ObjectKeyword */:
|
|
return true;
|
|
case 185 /* ArrayType */:
|
|
return isObjectOrObjectArrayTypeReference(node.elementType);
|
|
default:
|
|
return isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments;
|
|
}
|
|
}
|
|
function parseParameterOrPropertyTag(start3, tagName, target, indent3) {
|
|
let typeExpression = tryParseTypeExpression();
|
|
let isNameFirst = !typeExpression;
|
|
skipWhitespaceOrAsterisk();
|
|
const { name, isBracketed } = parseBracketNameInPropertyAndParamTag();
|
|
const indentText = skipWhitespaceOrAsterisk();
|
|
if (isNameFirst && !lookAhead(parseJSDocLinkPrefix)) {
|
|
typeExpression = tryParseTypeExpression();
|
|
}
|
|
const comment = parseTrailingTagComments(start3, getNodePos(), indent3, indentText);
|
|
const nestedTypeLiteral = target !== 4 /* CallbackParameter */ && parseNestedTypeLiteral(typeExpression, name, target, indent3);
|
|
if (nestedTypeLiteral) {
|
|
typeExpression = nestedTypeLiteral;
|
|
isNameFirst = true;
|
|
}
|
|
const result = target === 1 /* Property */ ? factory2.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) : factory2.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment);
|
|
return finishNode(result, start3);
|
|
}
|
|
function parseNestedTypeLiteral(typeExpression, name, target, indent3) {
|
|
if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) {
|
|
const pos = getNodePos();
|
|
let child;
|
|
let children;
|
|
while (child = tryParse(() => parseChildParameterOrPropertyTag(target, indent3, name))) {
|
|
if (child.kind === 343 /* JSDocParameterTag */ || child.kind === 350 /* JSDocPropertyTag */) {
|
|
children = append(children, child);
|
|
}
|
|
}
|
|
if (children) {
|
|
const literal = finishNode(factory2.createJSDocTypeLiteral(children, typeExpression.type.kind === 185 /* ArrayType */), pos);
|
|
return finishNode(factory2.createJSDocTypeExpression(literal), pos);
|
|
}
|
|
}
|
|
}
|
|
function parseReturnTag(start3, tagName, indent3, indentText) {
|
|
if (some(tags, isJSDocReturnTag)) {
|
|
parseErrorAt(tagName.pos, scanner2.getTokenPos(), Diagnostics._0_tag_already_specified, tagName.escapedText);
|
|
}
|
|
const typeExpression = tryParseTypeExpression();
|
|
return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start3, getNodePos(), indent3, indentText)), start3);
|
|
}
|
|
function parseTypeTag(start3, tagName, indent3, indentText) {
|
|
if (some(tags, isJSDocTypeTag)) {
|
|
parseErrorAt(tagName.pos, scanner2.getTokenPos(), Diagnostics._0_tag_already_specified, tagName.escapedText);
|
|
}
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
const comments2 = indent3 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start3, getNodePos(), indent3, indentText) : void 0;
|
|
return finishNode(factory2.createJSDocTypeTag(tagName, typeExpression, comments2), start3);
|
|
}
|
|
function parseSeeTag(start3, tagName, indent3, indentText) {
|
|
const isMarkdownOrJSDocLink = token() === 22 /* OpenBracketToken */ || lookAhead(() => nextTokenJSDoc() === 59 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && isJSDocLinkTag(scanner2.getTokenValue()));
|
|
const nameExpression = isMarkdownOrJSDocLink ? void 0 : parseJSDocNameReference();
|
|
const comments2 = indent3 !== void 0 && indentText !== void 0 ? parseTrailingTagComments(start3, getNodePos(), indent3, indentText) : void 0;
|
|
return finishNode(factory2.createJSDocSeeTag(tagName, nameExpression, comments2), start3);
|
|
}
|
|
function parseAuthorTag(start3, tagName, indent3, indentText) {
|
|
const commentStart = getNodePos();
|
|
const textOnly = parseAuthorNameAndEmail();
|
|
let commentEnd = scanner2.getStartPos();
|
|
const comments2 = parseTrailingTagComments(start3, commentEnd, indent3, indentText);
|
|
if (!comments2) {
|
|
commentEnd = scanner2.getStartPos();
|
|
}
|
|
const allParts = typeof comments2 !== "string" ? createNodeArray2(concatenate([finishNode(textOnly, commentStart, commentEnd)], comments2), commentStart) : textOnly.text + comments2;
|
|
return finishNode(factory2.createJSDocAuthorTag(tagName, allParts), start3);
|
|
}
|
|
function parseAuthorNameAndEmail() {
|
|
const comments2 = [];
|
|
let inEmail = false;
|
|
let token2 = scanner2.getToken();
|
|
while (token2 !== 1 /* EndOfFileToken */ && token2 !== 4 /* NewLineTrivia */) {
|
|
if (token2 === 29 /* LessThanToken */) {
|
|
inEmail = true;
|
|
} else if (token2 === 59 /* AtToken */ && !inEmail) {
|
|
break;
|
|
} else if (token2 === 31 /* GreaterThanToken */ && inEmail) {
|
|
comments2.push(scanner2.getTokenText());
|
|
scanner2.setTextPos(scanner2.getTokenPos() + 1);
|
|
break;
|
|
}
|
|
comments2.push(scanner2.getTokenText());
|
|
token2 = nextTokenJSDoc();
|
|
}
|
|
return factory2.createJSDocText(comments2.join(""));
|
|
}
|
|
function parseImplementsTag(start3, tagName, margin, indentText) {
|
|
const className = parseExpressionWithTypeArgumentsForAugments();
|
|
return finishNode(factory2.createJSDocImplementsTag(tagName, className, parseTrailingTagComments(start3, getNodePos(), margin, indentText)), start3);
|
|
}
|
|
function parseAugmentsTag(start3, tagName, margin, indentText) {
|
|
const className = parseExpressionWithTypeArgumentsForAugments();
|
|
return finishNode(factory2.createJSDocAugmentsTag(tagName, className, parseTrailingTagComments(start3, getNodePos(), margin, indentText)), start3);
|
|
}
|
|
function parseExpressionWithTypeArgumentsForAugments() {
|
|
const usedBrace = parseOptional(18 /* OpenBraceToken */);
|
|
const pos = getNodePos();
|
|
const expression = parsePropertyAccessEntityNameExpression();
|
|
const typeArguments = tryParseTypeArguments();
|
|
const node = factory2.createExpressionWithTypeArguments(expression, typeArguments);
|
|
const res = finishNode(node, pos);
|
|
if (usedBrace) {
|
|
parseExpected(19 /* CloseBraceToken */);
|
|
}
|
|
return res;
|
|
}
|
|
function parsePropertyAccessEntityNameExpression() {
|
|
const pos = getNodePos();
|
|
let node = parseJSDocIdentifierName();
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
const name = parseJSDocIdentifierName();
|
|
node = finishNode(factory2.createPropertyAccessExpression(node, name), pos);
|
|
}
|
|
return node;
|
|
}
|
|
function parseSimpleTag(start3, createTag, tagName, margin, indentText) {
|
|
return finishNode(createTag(tagName, parseTrailingTagComments(start3, getNodePos(), margin, indentText)), start3);
|
|
}
|
|
function parseThisTag(start3, tagName, margin, indentText) {
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
skipWhitespace();
|
|
return finishNode(factory2.createJSDocThisTag(tagName, typeExpression, parseTrailingTagComments(start3, getNodePos(), margin, indentText)), start3);
|
|
}
|
|
function parseEnumTag(start3, tagName, margin, indentText) {
|
|
const typeExpression = parseJSDocTypeExpression(true);
|
|
skipWhitespace();
|
|
return finishNode(factory2.createJSDocEnumTag(tagName, typeExpression, parseTrailingTagComments(start3, getNodePos(), margin, indentText)), start3);
|
|
}
|
|
function parseTypedefTag(start3, tagName, indent3, indentText) {
|
|
var _a2;
|
|
let typeExpression = tryParseTypeExpression();
|
|
skipWhitespaceOrAsterisk();
|
|
const fullName = parseJSDocTypeNameWithNamespace();
|
|
skipWhitespace();
|
|
let comment = parseTagComments(indent3);
|
|
let end2;
|
|
if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) {
|
|
let child;
|
|
let childTypeTag;
|
|
let jsDocPropertyTags;
|
|
let hasChildren = false;
|
|
while (child = tryParse(() => parseChildPropertyTag(indent3))) {
|
|
hasChildren = true;
|
|
if (child.kind === 346 /* JSDocTypeTag */) {
|
|
if (childTypeTag) {
|
|
const lastError = parseErrorAtCurrentToken(Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags);
|
|
if (lastError) {
|
|
addRelatedInfo(lastError, createDetachedDiagnostic(fileName, 0, 0, Diagnostics.The_tag_was_first_specified_here));
|
|
}
|
|
break;
|
|
} else {
|
|
childTypeTag = child;
|
|
}
|
|
} else {
|
|
jsDocPropertyTags = append(jsDocPropertyTags, child);
|
|
}
|
|
}
|
|
if (hasChildren) {
|
|
const isArrayType = typeExpression && typeExpression.type.kind === 185 /* ArrayType */;
|
|
const jsdocTypeLiteral = factory2.createJSDocTypeLiteral(jsDocPropertyTags, isArrayType);
|
|
typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ? childTypeTag.typeExpression : finishNode(jsdocTypeLiteral, start3);
|
|
end2 = typeExpression.end;
|
|
}
|
|
}
|
|
end2 = end2 || comment !== void 0 ? getNodePos() : ((_a2 = fullName != null ? fullName : typeExpression) != null ? _a2 : tagName).end;
|
|
if (!comment) {
|
|
comment = parseTrailingTagComments(start3, end2, indent3, indentText);
|
|
}
|
|
const typedefTag = factory2.createJSDocTypedefTag(tagName, typeExpression, fullName, comment);
|
|
return finishNode(typedefTag, start3, end2);
|
|
}
|
|
function parseJSDocTypeNameWithNamespace(nested) {
|
|
const pos = scanner2.getTokenPos();
|
|
if (!tokenIsIdentifierOrKeyword(token())) {
|
|
return void 0;
|
|
}
|
|
const typeNameOrNamespaceName = parseJSDocIdentifierName();
|
|
if (parseOptional(24 /* DotToken */)) {
|
|
const body = parseJSDocTypeNameWithNamespace(true);
|
|
const jsDocNamespaceNode = factory2.createModuleDeclaration(
|
|
void 0,
|
|
typeNameOrNamespaceName,
|
|
body,
|
|
nested ? 4 /* NestedNamespace */ : void 0
|
|
);
|
|
return finishNode(jsDocNamespaceNode, pos);
|
|
}
|
|
if (nested) {
|
|
typeNameOrNamespaceName.isInJSDocNamespace = true;
|
|
}
|
|
return typeNameOrNamespaceName;
|
|
}
|
|
function parseCallbackTagParameters(indent3) {
|
|
const pos = getNodePos();
|
|
let child;
|
|
let parameters;
|
|
while (child = tryParse(() => parseChildParameterOrPropertyTag(4 /* CallbackParameter */, indent3))) {
|
|
parameters = append(parameters, child);
|
|
}
|
|
return createNodeArray2(parameters || [], pos);
|
|
}
|
|
function parseCallbackTag(start3, tagName, indent3, indentText) {
|
|
const fullName = parseJSDocTypeNameWithNamespace();
|
|
skipWhitespace();
|
|
let comment = parseTagComments(indent3);
|
|
const parameters = parseCallbackTagParameters(indent3);
|
|
const returnTag = tryParse(() => {
|
|
if (parseOptionalJsdoc(59 /* AtToken */)) {
|
|
const tag = parseTag(indent3);
|
|
if (tag && tag.kind === 344 /* JSDocReturnTag */) {
|
|
return tag;
|
|
}
|
|
}
|
|
});
|
|
const typeExpression = finishNode(factory2.createJSDocSignature(void 0, parameters, returnTag), start3);
|
|
if (!comment) {
|
|
comment = parseTrailingTagComments(start3, getNodePos(), indent3, indentText);
|
|
}
|
|
const end2 = comment !== void 0 ? getNodePos() : typeExpression.end;
|
|
return finishNode(factory2.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start3, end2);
|
|
}
|
|
function escapedTextsEqual(a, b) {
|
|
while (!isIdentifier(a) || !isIdentifier(b)) {
|
|
if (!isIdentifier(a) && !isIdentifier(b) && a.right.escapedText === b.right.escapedText) {
|
|
a = a.left;
|
|
b = b.left;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return a.escapedText === b.escapedText;
|
|
}
|
|
function parseChildPropertyTag(indent3) {
|
|
return parseChildParameterOrPropertyTag(1 /* Property */, indent3);
|
|
}
|
|
function parseChildParameterOrPropertyTag(target, indent3, name) {
|
|
let canParseTag = true;
|
|
let seenAsterisk = false;
|
|
while (true) {
|
|
switch (nextTokenJSDoc()) {
|
|
case 59 /* AtToken */:
|
|
if (canParseTag) {
|
|
const child = tryParseChildTag(target, indent3);
|
|
if (child && (child.kind === 343 /* JSDocParameterTag */ || child.kind === 350 /* JSDocPropertyTag */) && target !== 4 /* CallbackParameter */ && name && (isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) {
|
|
return false;
|
|
}
|
|
return child;
|
|
}
|
|
seenAsterisk = false;
|
|
break;
|
|
case 4 /* NewLineTrivia */:
|
|
canParseTag = true;
|
|
seenAsterisk = false;
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
if (seenAsterisk) {
|
|
canParseTag = false;
|
|
}
|
|
seenAsterisk = true;
|
|
break;
|
|
case 79 /* Identifier */:
|
|
canParseTag = false;
|
|
break;
|
|
case 1 /* EndOfFileToken */:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function tryParseChildTag(target, indent3) {
|
|
Debug.assert(token() === 59 /* AtToken */);
|
|
const start3 = scanner2.getStartPos();
|
|
nextTokenJSDoc();
|
|
const tagName = parseJSDocIdentifierName();
|
|
skipWhitespace();
|
|
let t;
|
|
switch (tagName.escapedText) {
|
|
case "type":
|
|
return target === 1 /* Property */ && parseTypeTag(start3, tagName);
|
|
case "prop":
|
|
case "property":
|
|
t = 1 /* Property */;
|
|
break;
|
|
case "arg":
|
|
case "argument":
|
|
case "param":
|
|
t = 2 /* Parameter */ | 4 /* CallbackParameter */;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (!(target & t)) {
|
|
return false;
|
|
}
|
|
return parseParameterOrPropertyTag(start3, tagName, target, indent3);
|
|
}
|
|
function parseTemplateTagTypeParameter() {
|
|
const typeParameterPos = getNodePos();
|
|
const isBracketed = parseOptionalJsdoc(22 /* OpenBracketToken */);
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
}
|
|
const name = parseJSDocIdentifierName(Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces);
|
|
let defaultType;
|
|
if (isBracketed) {
|
|
skipWhitespace();
|
|
parseExpected(63 /* EqualsToken */);
|
|
defaultType = doInsideOfContext(8388608 /* JSDoc */, parseJSDocType);
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
return finishNode(factory2.createTypeParameterDeclaration(void 0, name, void 0, defaultType), typeParameterPos);
|
|
}
|
|
function parseTemplateTagTypeParameters() {
|
|
const pos = getNodePos();
|
|
const typeParameters = [];
|
|
do {
|
|
skipWhitespace();
|
|
const node = parseTemplateTagTypeParameter();
|
|
if (node !== void 0) {
|
|
typeParameters.push(node);
|
|
}
|
|
skipWhitespaceOrAsterisk();
|
|
} while (parseOptionalJsdoc(27 /* CommaToken */));
|
|
return createNodeArray2(typeParameters, pos);
|
|
}
|
|
function parseTemplateTag(start3, tagName, indent3, indentText) {
|
|
const constraint = token() === 18 /* OpenBraceToken */ ? parseJSDocTypeExpression() : void 0;
|
|
const typeParameters = parseTemplateTagTypeParameters();
|
|
return finishNode(factory2.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start3, getNodePos(), indent3, indentText)), start3);
|
|
}
|
|
function parseOptionalJsdoc(t) {
|
|
if (token() === t) {
|
|
nextTokenJSDoc();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function parseJSDocEntityName() {
|
|
let entity = parseJSDocIdentifierName();
|
|
if (parseOptional(22 /* OpenBracketToken */)) {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
while (parseOptional(24 /* DotToken */)) {
|
|
const name = parseJSDocIdentifierName();
|
|
if (parseOptional(22 /* OpenBracketToken */)) {
|
|
parseExpected(23 /* CloseBracketToken */);
|
|
}
|
|
entity = createQualifiedName2(entity, name);
|
|
}
|
|
return entity;
|
|
}
|
|
function parseJSDocIdentifierName(message) {
|
|
if (!tokenIsIdentifierOrKeyword(token())) {
|
|
return createMissingNode(79 /* Identifier */, !message, message || Diagnostics.Identifier_expected);
|
|
}
|
|
identifierCount++;
|
|
const pos = scanner2.getTokenPos();
|
|
const end2 = scanner2.getTextPos();
|
|
const originalKeywordKind = token();
|
|
const text = internIdentifier(scanner2.getTokenValue());
|
|
const result = finishNode(factory2.createIdentifier(text, void 0, originalKeywordKind), pos, end2);
|
|
nextTokenJSDoc();
|
|
return result;
|
|
}
|
|
}
|
|
})(JSDocParser = Parser2.JSDocParser || (Parser2.JSDocParser = {}));
|
|
})(Parser || (Parser = {}));
|
|
var IncrementalParser;
|
|
((IncrementalParser2) => {
|
|
function updateSourceFile2(sourceFile, newText, textChangeRange, aggressiveChecks) {
|
|
aggressiveChecks = aggressiveChecks || Debug.shouldAssert(2 /* Aggressive */);
|
|
checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks);
|
|
if (textChangeRangeIsUnchanged(textChangeRange)) {
|
|
return sourceFile;
|
|
}
|
|
if (sourceFile.statements.length === 0) {
|
|
return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, void 0, true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
|
|
}
|
|
const incrementalSourceFile = sourceFile;
|
|
Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed);
|
|
incrementalSourceFile.hasBeenIncrementallyParsed = true;
|
|
Parser.fixupParentReferences(incrementalSourceFile);
|
|
const oldText = sourceFile.text;
|
|
const syntaxCursor = createSyntaxCursor(sourceFile);
|
|
const changeRange = extendToAffectedRange(sourceFile, textChangeRange);
|
|
checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks);
|
|
Debug.assert(changeRange.span.start <= textChangeRange.span.start);
|
|
Debug.assert(textSpanEnd(changeRange.span) === textSpanEnd(textChangeRange.span));
|
|
Debug.assert(textSpanEnd(textChangeRangeNewSpan(changeRange)) === textSpanEnd(textChangeRangeNewSpan(textChangeRange)));
|
|
const delta = textChangeRangeNewSpan(changeRange).length - changeRange.span.length;
|
|
updateTokenPositionsAndMarkElements(
|
|
incrementalSourceFile,
|
|
changeRange.span.start,
|
|
textSpanEnd(changeRange.span),
|
|
textSpanEnd(textChangeRangeNewSpan(changeRange)),
|
|
delta,
|
|
oldText,
|
|
newText,
|
|
aggressiveChecks
|
|
);
|
|
const result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator);
|
|
result.commentDirectives = getNewCommentDirectives(
|
|
sourceFile.commentDirectives,
|
|
result.commentDirectives,
|
|
changeRange.span.start,
|
|
textSpanEnd(changeRange.span),
|
|
delta,
|
|
oldText,
|
|
newText,
|
|
aggressiveChecks
|
|
);
|
|
result.impliedNodeFormat = sourceFile.impliedNodeFormat;
|
|
return result;
|
|
}
|
|
IncrementalParser2.updateSourceFile = updateSourceFile2;
|
|
function getNewCommentDirectives(oldDirectives, newDirectives, changeStart, changeRangeOldEnd, delta, oldText, newText, aggressiveChecks) {
|
|
if (!oldDirectives)
|
|
return newDirectives;
|
|
let commentDirectives;
|
|
let addedNewlyScannedDirectives = false;
|
|
for (const directive of oldDirectives) {
|
|
const { range, type } = directive;
|
|
if (range.end < changeStart) {
|
|
commentDirectives = append(commentDirectives, directive);
|
|
} else if (range.pos > changeRangeOldEnd) {
|
|
addNewlyScannedDirectives();
|
|
const updatedDirective = {
|
|
range: { pos: range.pos + delta, end: range.end + delta },
|
|
type
|
|
};
|
|
commentDirectives = append(commentDirectives, updatedDirective);
|
|
if (aggressiveChecks) {
|
|
Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
|
|
}
|
|
}
|
|
}
|
|
addNewlyScannedDirectives();
|
|
return commentDirectives;
|
|
function addNewlyScannedDirectives() {
|
|
if (addedNewlyScannedDirectives)
|
|
return;
|
|
addedNewlyScannedDirectives = true;
|
|
if (!commentDirectives) {
|
|
commentDirectives = newDirectives;
|
|
} else if (newDirectives) {
|
|
commentDirectives.push(...newDirectives);
|
|
}
|
|
}
|
|
}
|
|
function moveElementEntirelyPastChangeRange(element, isArray2, delta, oldText, newText, aggressiveChecks) {
|
|
if (isArray2) {
|
|
visitArray2(element);
|
|
} else {
|
|
visitNode3(element);
|
|
}
|
|
return;
|
|
function visitNode3(node) {
|
|
let text = "";
|
|
if (aggressiveChecks && shouldCheckNode(node)) {
|
|
text = oldText.substring(node.pos, node.end);
|
|
}
|
|
if (node._children) {
|
|
node._children = void 0;
|
|
}
|
|
setTextRangePosEnd(node, node.pos + delta, node.end + delta);
|
|
if (aggressiveChecks && shouldCheckNode(node)) {
|
|
Debug.assert(text === newText.substring(node.pos, node.end));
|
|
}
|
|
forEachChild(node, visitNode3, visitArray2);
|
|
if (hasJSDocNodes(node)) {
|
|
for (const jsDocComment of node.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
checkNodePositions(node, aggressiveChecks);
|
|
}
|
|
function visitArray2(array) {
|
|
array._children = void 0;
|
|
setTextRangePosEnd(array, array.pos + delta, array.end + delta);
|
|
for (const node of array) {
|
|
visitNode3(node);
|
|
}
|
|
}
|
|
}
|
|
function shouldCheckNode(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 79 /* Identifier */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) {
|
|
Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range");
|
|
Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range");
|
|
Debug.assert(element.pos <= element.end);
|
|
const pos = Math.min(element.pos, changeRangeNewEnd);
|
|
const end = element.end >= changeRangeOldEnd ? element.end + delta : Math.min(element.end, changeRangeNewEnd);
|
|
Debug.assert(pos <= end);
|
|
if (element.parent) {
|
|
Debug.assertGreaterThanOrEqual(pos, element.parent.pos);
|
|
Debug.assertLessThanOrEqual(end, element.parent.end);
|
|
}
|
|
setTextRangePosEnd(element, pos, end);
|
|
}
|
|
function checkNodePositions(node, aggressiveChecks) {
|
|
if (aggressiveChecks) {
|
|
let pos = node.pos;
|
|
const visitNode3 = (child) => {
|
|
Debug.assert(child.pos >= pos);
|
|
pos = child.end;
|
|
};
|
|
if (hasJSDocNodes(node)) {
|
|
for (const jsDocComment of node.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
forEachChild(node, visitNode3);
|
|
Debug.assert(pos <= node.end);
|
|
}
|
|
}
|
|
function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) {
|
|
visitNode3(sourceFile);
|
|
return;
|
|
function visitNode3(child) {
|
|
Debug.assert(child.pos <= child.end);
|
|
if (child.pos > changeRangeOldEnd) {
|
|
moveElementEntirelyPastChangeRange(child, false, delta, oldText, newText, aggressiveChecks);
|
|
return;
|
|
}
|
|
const fullEnd = child.end;
|
|
if (fullEnd >= changeStart) {
|
|
child.intersectsChange = true;
|
|
child._children = void 0;
|
|
adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
|
|
forEachChild(child, visitNode3, visitArray2);
|
|
if (hasJSDocNodes(child)) {
|
|
for (const jsDocComment of child.jsDoc) {
|
|
visitNode3(jsDocComment);
|
|
}
|
|
}
|
|
checkNodePositions(child, aggressiveChecks);
|
|
return;
|
|
}
|
|
Debug.assert(fullEnd < changeStart);
|
|
}
|
|
function visitArray2(array) {
|
|
Debug.assert(array.pos <= array.end);
|
|
if (array.pos > changeRangeOldEnd) {
|
|
moveElementEntirelyPastChangeRange(array, true, delta, oldText, newText, aggressiveChecks);
|
|
return;
|
|
}
|
|
const fullEnd = array.end;
|
|
if (fullEnd >= changeStart) {
|
|
array.intersectsChange = true;
|
|
array._children = void 0;
|
|
adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
|
|
for (const node of array) {
|
|
visitNode3(node);
|
|
}
|
|
return;
|
|
}
|
|
Debug.assert(fullEnd < changeStart);
|
|
}
|
|
}
|
|
function extendToAffectedRange(sourceFile, changeRange) {
|
|
const maxLookahead = 1;
|
|
let start2 = changeRange.span.start;
|
|
for (let i = 0; start2 > 0 && i <= maxLookahead; i++) {
|
|
const nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start2);
|
|
Debug.assert(nearestNode.pos <= start2);
|
|
const position = nearestNode.pos;
|
|
start2 = Math.max(0, position - 1);
|
|
}
|
|
const finalSpan = createTextSpanFromBounds(start2, textSpanEnd(changeRange.span));
|
|
const finalLength = changeRange.newLength + (changeRange.span.start - start2);
|
|
return createTextChangeRange(finalSpan, finalLength);
|
|
}
|
|
function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) {
|
|
let bestResult = sourceFile;
|
|
let lastNodeEntirelyBeforePosition;
|
|
forEachChild(sourceFile, visit);
|
|
if (lastNodeEntirelyBeforePosition) {
|
|
const lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition);
|
|
if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) {
|
|
bestResult = lastChildOfLastEntireNodeBeforePosition;
|
|
}
|
|
}
|
|
return bestResult;
|
|
function getLastDescendant(node) {
|
|
while (true) {
|
|
const lastChild = getLastChild(node);
|
|
if (lastChild) {
|
|
node = lastChild;
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function visit(child) {
|
|
if (nodeIsMissing(child)) {
|
|
return;
|
|
}
|
|
if (child.pos <= position) {
|
|
if (child.pos >= bestResult.pos) {
|
|
bestResult = child;
|
|
}
|
|
if (position < child.end) {
|
|
forEachChild(child, visit);
|
|
return true;
|
|
} else {
|
|
Debug.assert(child.end <= position);
|
|
lastNodeEntirelyBeforePosition = child;
|
|
}
|
|
} else {
|
|
Debug.assert(child.pos > position);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) {
|
|
const oldText = sourceFile.text;
|
|
if (textChangeRange) {
|
|
Debug.assert(oldText.length - textChangeRange.span.length + textChangeRange.newLength === newText.length);
|
|
if (aggressiveChecks || Debug.shouldAssert(3 /* VeryAggressive */)) {
|
|
const oldTextPrefix = oldText.substr(0, textChangeRange.span.start);
|
|
const newTextPrefix = newText.substr(0, textChangeRange.span.start);
|
|
Debug.assert(oldTextPrefix === newTextPrefix);
|
|
const oldTextSuffix = oldText.substring(textSpanEnd(textChangeRange.span), oldText.length);
|
|
const newTextSuffix = newText.substring(textSpanEnd(textChangeRangeNewSpan(textChangeRange)), newText.length);
|
|
Debug.assert(oldTextSuffix === newTextSuffix);
|
|
}
|
|
}
|
|
}
|
|
function createSyntaxCursor(sourceFile) {
|
|
let currentArray = sourceFile.statements;
|
|
let currentArrayIndex = 0;
|
|
Debug.assert(currentArrayIndex < currentArray.length);
|
|
let current = currentArray[currentArrayIndex];
|
|
let lastQueriedPosition = InvalidPosition.Value;
|
|
return {
|
|
currentNode(position) {
|
|
if (position !== lastQueriedPosition) {
|
|
if (current && current.end === position && currentArrayIndex < currentArray.length - 1) {
|
|
currentArrayIndex++;
|
|
current = currentArray[currentArrayIndex];
|
|
}
|
|
if (!current || current.pos !== position) {
|
|
findHighestListElementThatStartsAtPosition(position);
|
|
}
|
|
}
|
|
lastQueriedPosition = position;
|
|
Debug.assert(!current || current.pos === position);
|
|
return current;
|
|
}
|
|
};
|
|
function findHighestListElementThatStartsAtPosition(position) {
|
|
currentArray = void 0;
|
|
currentArrayIndex = InvalidPosition.Value;
|
|
current = void 0;
|
|
forEachChild(sourceFile, visitNode3, visitArray2);
|
|
return;
|
|
function visitNode3(node) {
|
|
if (position >= node.pos && position < node.end) {
|
|
forEachChild(node, visitNode3, visitArray2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function visitArray2(array) {
|
|
if (position >= array.pos && position < array.end) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
const child = array[i];
|
|
if (child) {
|
|
if (child.pos === position) {
|
|
currentArray = array;
|
|
currentArrayIndex = i;
|
|
current = child;
|
|
return true;
|
|
} else {
|
|
if (child.pos < position && position < child.end) {
|
|
forEachChild(child, visitNode3, visitArray2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
IncrementalParser2.createSyntaxCursor = createSyntaxCursor;
|
|
let InvalidPosition;
|
|
((InvalidPosition2) => {
|
|
InvalidPosition2[InvalidPosition2["Value"] = -1] = "Value";
|
|
})(InvalidPosition || (InvalidPosition = {}));
|
|
})(IncrementalParser || (IncrementalParser = {}));
|
|
function isDeclarationFileName(fileName) {
|
|
return fileExtensionIsOneOf(fileName, supportedDeclarationExtensions);
|
|
}
|
|
function parseResolutionMode(mode, pos, end, reportDiagnostic) {
|
|
if (!mode) {
|
|
return void 0;
|
|
}
|
|
if (mode === "import") {
|
|
return 99 /* ESNext */;
|
|
}
|
|
if (mode === "require") {
|
|
return 1 /* CommonJS */;
|
|
}
|
|
reportDiagnostic(pos, end - pos, Diagnostics.resolution_mode_should_be_either_require_or_import);
|
|
return void 0;
|
|
}
|
|
function processCommentPragmas(context, sourceText) {
|
|
const pragmas = [];
|
|
for (const range of getLeadingCommentRanges(sourceText, 0) || emptyArray) {
|
|
const comment = sourceText.substring(range.pos, range.end);
|
|
extractPragmas(pragmas, range, comment);
|
|
}
|
|
context.pragmas = /* @__PURE__ */ new Map();
|
|
for (const pragma of pragmas) {
|
|
if (context.pragmas.has(pragma.name)) {
|
|
const currentValue = context.pragmas.get(pragma.name);
|
|
if (currentValue instanceof Array) {
|
|
currentValue.push(pragma.args);
|
|
} else {
|
|
context.pragmas.set(pragma.name, [currentValue, pragma.args]);
|
|
}
|
|
continue;
|
|
}
|
|
context.pragmas.set(pragma.name, pragma.args);
|
|
}
|
|
}
|
|
function processPragmasIntoFields(context, reportDiagnostic) {
|
|
context.checkJsDirective = void 0;
|
|
context.referencedFiles = [];
|
|
context.typeReferenceDirectives = [];
|
|
context.libReferenceDirectives = [];
|
|
context.amdDependencies = [];
|
|
context.hasNoDefaultLib = false;
|
|
context.pragmas.forEach((entryOrList, key) => {
|
|
switch (key) {
|
|
case "reference": {
|
|
const referencedFiles = context.referencedFiles;
|
|
const typeReferenceDirectives = context.typeReferenceDirectives;
|
|
const libReferenceDirectives = context.libReferenceDirectives;
|
|
forEach(toArray(entryOrList), (arg) => {
|
|
const { types, lib, path, ["resolution-mode"]: res } = arg.arguments;
|
|
if (arg.arguments["no-default-lib"]) {
|
|
context.hasNoDefaultLib = true;
|
|
} else if (types) {
|
|
const parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic);
|
|
typeReferenceDirectives.push({ pos: types.pos, end: types.end, fileName: types.value, ...parsed ? { resolutionMode: parsed } : {} });
|
|
} else if (lib) {
|
|
libReferenceDirectives.push({ pos: lib.pos, end: lib.end, fileName: lib.value });
|
|
} else if (path) {
|
|
referencedFiles.push({ pos: path.pos, end: path.end, fileName: path.value });
|
|
} else {
|
|
reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, Diagnostics.Invalid_reference_directive_syntax);
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
case "amd-dependency": {
|
|
context.amdDependencies = map(
|
|
toArray(entryOrList),
|
|
(x) => ({ name: x.arguments.name, path: x.arguments.path })
|
|
);
|
|
break;
|
|
}
|
|
case "amd-module": {
|
|
if (entryOrList instanceof Array) {
|
|
for (const entry of entryOrList) {
|
|
if (context.moduleName) {
|
|
reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments);
|
|
}
|
|
context.moduleName = entry.arguments.name;
|
|
}
|
|
} else {
|
|
context.moduleName = entryOrList.arguments.name;
|
|
}
|
|
break;
|
|
}
|
|
case "ts-nocheck":
|
|
case "ts-check": {
|
|
forEach(toArray(entryOrList), (entry) => {
|
|
if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) {
|
|
context.checkJsDirective = {
|
|
enabled: key === "ts-check",
|
|
end: entry.range.end,
|
|
pos: entry.range.pos
|
|
};
|
|
}
|
|
});
|
|
break;
|
|
}
|
|
case "jsx":
|
|
case "jsxfrag":
|
|
case "jsximportsource":
|
|
case "jsxruntime":
|
|
return;
|
|
default:
|
|
Debug.fail("Unhandled pragma kind");
|
|
}
|
|
});
|
|
}
|
|
var namedArgRegExCache = /* @__PURE__ */ new Map();
|
|
function getNamedArgRegEx(name) {
|
|
if (namedArgRegExCache.has(name)) {
|
|
return namedArgRegExCache.get(name);
|
|
}
|
|
const result = new RegExp(`(\\s${name}\\s*=\\s*)(?:(?:'([^']*)')|(?:"([^"]*)"))`, "im");
|
|
namedArgRegExCache.set(name, result);
|
|
return result;
|
|
}
|
|
var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im;
|
|
var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im;
|
|
function extractPragmas(pragmas, range, text) {
|
|
const tripleSlash = range.kind === 2 /* SingleLineCommentTrivia */ && tripleSlashXMLCommentStartRegEx.exec(text);
|
|
if (tripleSlash) {
|
|
const name = tripleSlash[1].toLowerCase();
|
|
const pragma = commentPragmas[name];
|
|
if (!pragma || !(pragma.kind & 1 /* TripleSlashXML */)) {
|
|
return;
|
|
}
|
|
if (pragma.args) {
|
|
const argument = {};
|
|
for (const arg of pragma.args) {
|
|
const matcher = getNamedArgRegEx(arg.name);
|
|
const matchResult = matcher.exec(text);
|
|
if (!matchResult && !arg.optional) {
|
|
return;
|
|
} else if (matchResult) {
|
|
const value = matchResult[2] || matchResult[3];
|
|
if (arg.captureSpan) {
|
|
const startPos = range.pos + matchResult.index + matchResult[1].length + 1;
|
|
argument[arg.name] = {
|
|
value,
|
|
pos: startPos,
|
|
end: startPos + value.length
|
|
};
|
|
} else {
|
|
argument[arg.name] = value;
|
|
}
|
|
}
|
|
}
|
|
pragmas.push({ name, args: { arguments: argument, range } });
|
|
} else {
|
|
pragmas.push({ name, args: { arguments: {}, range } });
|
|
}
|
|
return;
|
|
}
|
|
const singleLine = range.kind === 2 /* SingleLineCommentTrivia */ && singleLinePragmaRegEx.exec(text);
|
|
if (singleLine) {
|
|
return addPragmaForMatch(pragmas, range, 2 /* SingleLine */, singleLine);
|
|
}
|
|
if (range.kind === 3 /* MultiLineCommentTrivia */) {
|
|
const multiLinePragmaRegEx = /@(\S+)(\s+.*)?$/gim;
|
|
let multiLineMatch;
|
|
while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
|
|
addPragmaForMatch(pragmas, range, 4 /* MultiLine */, multiLineMatch);
|
|
}
|
|
}
|
|
}
|
|
function addPragmaForMatch(pragmas, range, kind, match) {
|
|
if (!match)
|
|
return;
|
|
const name = match[1].toLowerCase();
|
|
const pragma = commentPragmas[name];
|
|
if (!pragma || !(pragma.kind & kind)) {
|
|
return;
|
|
}
|
|
const args = match[2];
|
|
const argument = getNamedPragmaArguments(pragma, args);
|
|
if (argument === "fail")
|
|
return;
|
|
pragmas.push({ name, args: { arguments: argument, range } });
|
|
return;
|
|
}
|
|
function getNamedPragmaArguments(pragma, text) {
|
|
if (!text)
|
|
return {};
|
|
if (!pragma.args)
|
|
return {};
|
|
const args = trimString(text).split(/\s+/);
|
|
const argMap = {};
|
|
for (let i = 0; i < pragma.args.length; i++) {
|
|
const argument = pragma.args[i];
|
|
if (!args[i] && !argument.optional) {
|
|
return "fail";
|
|
}
|
|
if (argument.captureSpan) {
|
|
return Debug.fail("Capture spans not yet implemented for non-xml pragmas");
|
|
}
|
|
argMap[argument.name] = args[i];
|
|
}
|
|
return argMap;
|
|
}
|
|
function tagNamesAreEquivalent(lhs, rhs) {
|
|
if (lhs.kind !== rhs.kind) {
|
|
return false;
|
|
}
|
|
if (lhs.kind === 79 /* Identifier */) {
|
|
return lhs.escapedText === rhs.escapedText;
|
|
}
|
|
if (lhs.kind === 108 /* ThisKeyword */) {
|
|
return true;
|
|
}
|
|
return lhs.name.escapedText === rhs.name.escapedText && tagNamesAreEquivalent(lhs.expression, rhs.expression);
|
|
}
|
|
|
|
// src/compiler/commandLineParser.ts
|
|
var compileOnSaveCommandLineOption = {
|
|
name: "compileOnSave",
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
};
|
|
var jsxOptionMap = new Map(getEntries({
|
|
"preserve": 1 /* Preserve */,
|
|
"react-native": 3 /* ReactNative */,
|
|
"react": 2 /* React */,
|
|
"react-jsx": 4 /* ReactJSX */,
|
|
"react-jsxdev": 5 /* ReactJSXDev */
|
|
}));
|
|
var inverseJsxOptionMap = new Map(arrayFrom(mapIterator(jsxOptionMap.entries(), ([key, value]) => ["" + value, key])));
|
|
var libEntries = [
|
|
["es5", "lib.es5.d.ts"],
|
|
["es6", "lib.es2015.d.ts"],
|
|
["es2015", "lib.es2015.d.ts"],
|
|
["es7", "lib.es2016.d.ts"],
|
|
["es2016", "lib.es2016.d.ts"],
|
|
["es2017", "lib.es2017.d.ts"],
|
|
["es2018", "lib.es2018.d.ts"],
|
|
["es2019", "lib.es2019.d.ts"],
|
|
["es2020", "lib.es2020.d.ts"],
|
|
["es2021", "lib.es2021.d.ts"],
|
|
["es2022", "lib.es2022.d.ts"],
|
|
["esnext", "lib.esnext.d.ts"],
|
|
["dom", "lib.dom.d.ts"],
|
|
["dom.iterable", "lib.dom.iterable.d.ts"],
|
|
["webworker", "lib.webworker.d.ts"],
|
|
["webworker.importscripts", "lib.webworker.importscripts.d.ts"],
|
|
["webworker.iterable", "lib.webworker.iterable.d.ts"],
|
|
["scripthost", "lib.scripthost.d.ts"],
|
|
["es2015.core", "lib.es2015.core.d.ts"],
|
|
["es2015.collection", "lib.es2015.collection.d.ts"],
|
|
["es2015.generator", "lib.es2015.generator.d.ts"],
|
|
["es2015.iterable", "lib.es2015.iterable.d.ts"],
|
|
["es2015.promise", "lib.es2015.promise.d.ts"],
|
|
["es2015.proxy", "lib.es2015.proxy.d.ts"],
|
|
["es2015.reflect", "lib.es2015.reflect.d.ts"],
|
|
["es2015.symbol", "lib.es2015.symbol.d.ts"],
|
|
["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"],
|
|
["es2016.array.include", "lib.es2016.array.include.d.ts"],
|
|
["es2017.object", "lib.es2017.object.d.ts"],
|
|
["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"],
|
|
["es2017.string", "lib.es2017.string.d.ts"],
|
|
["es2017.intl", "lib.es2017.intl.d.ts"],
|
|
["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"],
|
|
["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"],
|
|
["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
["es2018.intl", "lib.es2018.intl.d.ts"],
|
|
["es2018.promise", "lib.es2018.promise.d.ts"],
|
|
["es2018.regexp", "lib.es2018.regexp.d.ts"],
|
|
["es2019.array", "lib.es2019.array.d.ts"],
|
|
["es2019.object", "lib.es2019.object.d.ts"],
|
|
["es2019.string", "lib.es2019.string.d.ts"],
|
|
["es2019.symbol", "lib.es2019.symbol.d.ts"],
|
|
["es2019.intl", "lib.es2019.intl.d.ts"],
|
|
["es2020.bigint", "lib.es2020.bigint.d.ts"],
|
|
["es2020.date", "lib.es2020.date.d.ts"],
|
|
["es2020.promise", "lib.es2020.promise.d.ts"],
|
|
["es2020.sharedmemory", "lib.es2020.sharedmemory.d.ts"],
|
|
["es2020.string", "lib.es2020.string.d.ts"],
|
|
["es2020.symbol.wellknown", "lib.es2020.symbol.wellknown.d.ts"],
|
|
["es2020.intl", "lib.es2020.intl.d.ts"],
|
|
["es2020.number", "lib.es2020.number.d.ts"],
|
|
["es2021.promise", "lib.es2021.promise.d.ts"],
|
|
["es2021.string", "lib.es2021.string.d.ts"],
|
|
["es2021.weakref", "lib.es2021.weakref.d.ts"],
|
|
["es2021.intl", "lib.es2021.intl.d.ts"],
|
|
["es2022.array", "lib.es2022.array.d.ts"],
|
|
["es2022.error", "lib.es2022.error.d.ts"],
|
|
["es2022.intl", "lib.es2022.intl.d.ts"],
|
|
["es2022.object", "lib.es2022.object.d.ts"],
|
|
["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
|
|
["es2022.string", "lib.es2022.string.d.ts"],
|
|
["esnext.array", "lib.es2022.array.d.ts"],
|
|
["esnext.symbol", "lib.es2019.symbol.d.ts"],
|
|
["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
|
|
["esnext.intl", "lib.esnext.intl.d.ts"],
|
|
["esnext.bigint", "lib.es2020.bigint.d.ts"],
|
|
["esnext.string", "lib.es2022.string.d.ts"],
|
|
["esnext.promise", "lib.es2021.promise.d.ts"],
|
|
["esnext.weakref", "lib.es2021.weakref.d.ts"]
|
|
];
|
|
var libs = libEntries.map((entry) => entry[0]);
|
|
var libMap = new Map(libEntries);
|
|
var optionsForWatch = [
|
|
{
|
|
name: "watchFile",
|
|
type: new Map(getEntries({
|
|
fixedpollinginterval: 0 /* FixedPollingInterval */,
|
|
prioritypollinginterval: 1 /* PriorityPollingInterval */,
|
|
dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
|
|
fixedchunksizepolling: 3 /* FixedChunkSizePolling */,
|
|
usefsevents: 4 /* UseFsEvents */,
|
|
usefseventsonparentdirectory: 5 /* UseFsEventsOnParentDirectory */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_how_the_TypeScript_watch_mode_works,
|
|
defaultValueDescription: 4 /* UseFsEvents */
|
|
},
|
|
{
|
|
name: "watchDirectory",
|
|
type: new Map(getEntries({
|
|
usefsevents: 0 /* UseFsEvents */,
|
|
fixedpollinginterval: 1 /* FixedPollingInterval */,
|
|
dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
|
|
fixedchunksizepolling: 3 /* FixedChunkSizePolling */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality,
|
|
defaultValueDescription: 0 /* UseFsEvents */
|
|
},
|
|
{
|
|
name: "fallbackPolling",
|
|
type: new Map(getEntries({
|
|
fixedinterval: 0 /* FixedInterval */,
|
|
priorityinterval: 1 /* PriorityInterval */,
|
|
dynamicpriority: 2 /* DynamicPriority */,
|
|
fixedchunksize: 3 /* FixedChunkSize */
|
|
})),
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers,
|
|
defaultValueDescription: 1 /* PriorityInterval */
|
|
},
|
|
{
|
|
name: "synchronousWatchDirectory",
|
|
type: "boolean",
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "excludeDirectories",
|
|
type: "list",
|
|
element: {
|
|
name: "excludeDirectory",
|
|
type: "string",
|
|
isFilePath: true,
|
|
extraValidation: specToDiagnostic
|
|
},
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Remove_a_list_of_directories_from_the_watch_process
|
|
},
|
|
{
|
|
name: "excludeFiles",
|
|
type: "list",
|
|
element: {
|
|
name: "excludeFile",
|
|
type: "string",
|
|
isFilePath: true,
|
|
extraValidation: specToDiagnostic
|
|
},
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Remove_a_list_of_files_from_the_watch_mode_s_processing
|
|
}
|
|
];
|
|
var commonOptionsWithBuild = [
|
|
{
|
|
name: "help",
|
|
shortName: "h",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Print_this_message,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "help",
|
|
shortName: "?",
|
|
type: "boolean",
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "watch",
|
|
shortName: "w",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
isCommandLineOnly: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Watch_input_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveWatchOutput",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: false,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Disable_wiping_the_console_in_watch_mode,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_all_of_the_files_read_during_the_compilation,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "explainFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_files_read_during_the_compilation_including_why_it_was_included,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listEmittedFiles",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Print_the_names_of_emitted_files_after_a_compilation,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "pretty",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read,
|
|
defaultValueDescription: true
|
|
},
|
|
{
|
|
name: "traceResolution",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Log_paths_used_during_the_moduleResolution_process,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "diagnostics",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Output_compiler_performance_information_after_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "extendedDiagnostics",
|
|
type: "boolean",
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Output_more_detailed_compiler_performance_information_after_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "generateCpuProfile",
|
|
type: "string",
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE_OR_DIRECTORY,
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging,
|
|
defaultValueDescription: "profile.cpuprofile"
|
|
},
|
|
{
|
|
name: "generateTrace",
|
|
type: "string",
|
|
isFilePath: true,
|
|
isCommandLineOnly: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
category: Diagnostics.Compiler_Diagnostics,
|
|
description: Diagnostics.Generates_an_event_trace_and_a_list_of_types
|
|
},
|
|
{
|
|
name: "incremental",
|
|
shortName: "i",
|
|
type: "boolean",
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: Diagnostics.false_unless_composite_is_set
|
|
},
|
|
{
|
|
name: "declaration",
|
|
shortName: "d",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project,
|
|
defaultValueDescription: Diagnostics.false_unless_composite_is_set
|
|
},
|
|
{
|
|
name: "declarationMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Create_sourcemaps_for_d_ts_files
|
|
},
|
|
{
|
|
name: "emitDeclarationOnly",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "sourceMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Create_source_map_files_for_emitted_JavaScript_files
|
|
},
|
|
{
|
|
name: "inlineSourceMap",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "assumeChangesOnlyAffectDirectDependencies",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Watch_and_Build_Modes,
|
|
description: Diagnostics.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "locale",
|
|
type: "string",
|
|
category: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit,
|
|
defaultValueDescription: Diagnostics.Platform_specific
|
|
}
|
|
];
|
|
var targetOptionDeclaration = {
|
|
name: "target",
|
|
shortName: "t",
|
|
type: new Map(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 */,
|
|
es2021: 8 /* ES2021 */,
|
|
es2022: 9 /* ES2022 */,
|
|
esnext: 99 /* ESNext */
|
|
})),
|
|
affectsSourceFile: true,
|
|
affectsModuleResolution: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.VERSION,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations,
|
|
defaultValueDescription: 0 /* ES3 */
|
|
};
|
|
var moduleOptionDeclaration = {
|
|
name: "module",
|
|
shortName: "m",
|
|
type: new Map(getEntries({
|
|
none: 0 /* None */,
|
|
commonjs: 1 /* CommonJS */,
|
|
amd: 2 /* AMD */,
|
|
system: 4 /* System */,
|
|
umd: 3 /* UMD */,
|
|
es6: 5 /* ES2015 */,
|
|
es2015: 5 /* ES2015 */,
|
|
es2020: 6 /* ES2020 */,
|
|
es2022: 7 /* ES2022 */,
|
|
esnext: 99 /* ESNext */,
|
|
node16: 100 /* Node16 */,
|
|
nodenext: 199 /* NodeNext */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.KIND,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_what_module_code_is_generated,
|
|
defaultValueDescription: void 0
|
|
};
|
|
var commandOptionsWithoutBuild = [
|
|
{
|
|
name: "all",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Show_all_compiler_options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "version",
|
|
shortName: "v",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Print_the_compiler_s_version,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "init",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "project",
|
|
shortName: "p",
|
|
type: "string",
|
|
isFilePath: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
paramType: Diagnostics.FILE_OR_DIRECTORY,
|
|
description: Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json
|
|
},
|
|
{
|
|
name: "build",
|
|
type: "boolean",
|
|
shortName: "b",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "showConfig",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Print_the_final_configuration_instead_of_building,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "listFilesOnly",
|
|
type: "boolean",
|
|
category: Diagnostics.Command_line_Options,
|
|
isCommandLineOnly: true,
|
|
description: Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
|
|
defaultValueDescription: false
|
|
},
|
|
targetOptionDeclaration,
|
|
moduleOptionDeclaration,
|
|
{
|
|
name: "lib",
|
|
type: "list",
|
|
element: {
|
|
name: "lib",
|
|
type: libMap,
|
|
defaultValueDescription: void 0
|
|
},
|
|
affectsProgramStructure: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "allowJs",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.JavaScript_Support,
|
|
description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "checkJs",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.JavaScript_Support,
|
|
description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "jsx",
|
|
type: jsxOptionMap,
|
|
affectsSourceFile: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsModuleResolution: true,
|
|
paramType: Diagnostics.KIND,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_what_JSX_code_is_generated,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "outFile",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "outDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_an_output_folder_for_all_emitted_files
|
|
},
|
|
{
|
|
name: "rootDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_the_root_folder_within_your_source_files,
|
|
defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files
|
|
},
|
|
{
|
|
name: "composite",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references
|
|
},
|
|
{
|
|
name: "tsBuildInfoFile",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.FILE,
|
|
category: Diagnostics.Projects,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: ".tsbuildinfo",
|
|
description: Diagnostics.Specify_the_path_to_tsbuildinfo_incremental_compilation_file
|
|
},
|
|
{
|
|
name: "removeComments",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
defaultValueDescription: false,
|
|
description: Diagnostics.Disable_emitting_comments
|
|
},
|
|
{
|
|
name: "noEmit",
|
|
type: "boolean",
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_emitting_files_from_a_compilation,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "importHelpers",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "importsNotUsedAsValues",
|
|
type: new Map(getEntries({
|
|
remove: 0 /* Remove */,
|
|
preserve: 1 /* Preserve */,
|
|
error: 2 /* Error */
|
|
})),
|
|
affectsEmit: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types,
|
|
defaultValueDescription: 0 /* Remove */
|
|
},
|
|
{
|
|
name: "downlevelIteration",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "isolatedModules",
|
|
type: "boolean",
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "strict",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_all_strict_type_checking_options,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitAny",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictNullChecks",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.When_type_checking_take_into_account_null_and_undefined,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictFunctionTypes",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictBindCallApply",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "strictPropertyInitialization",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "noImplicitThis",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "useUnknownInCatchVariables",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "alwaysStrict",
|
|
type: "boolean",
|
|
affectsSourceFile: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
strictFlag: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Ensure_use_strict_is_always_emitted,
|
|
defaultValueDescription: Diagnostics.false_unless_strict_is_set
|
|
},
|
|
{
|
|
name: "noUnusedLocals",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noUnusedParameters",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "exactOptionalPropertyTypes",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitReturns",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noFallthroughCasesInSwitch",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noUncheckedIndexedAccess",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitOverride",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noPropertyAccessFromIndexSignature",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: false,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "moduleResolution",
|
|
type: new Map(getEntries({
|
|
node: 2 /* NodeJs */,
|
|
classic: 1 /* Classic */,
|
|
node16: 3 /* Node16 */,
|
|
nodenext: 99 /* NodeNext */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
paramType: Diagnostics.STRATEGY,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier,
|
|
defaultValueDescription: Diagnostics.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node
|
|
},
|
|
{
|
|
name: "baseUrl",
|
|
type: "string",
|
|
affectsModuleResolution: true,
|
|
isFilePath: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_the_base_directory_to_resolve_non_relative_module_names
|
|
},
|
|
{
|
|
name: "paths",
|
|
type: "object",
|
|
affectsModuleResolution: true,
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "rootDirs",
|
|
type: "list",
|
|
isTSConfigOnly: true,
|
|
element: {
|
|
name: "rootDirs",
|
|
type: "string",
|
|
isFilePath: true
|
|
},
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules,
|
|
transpileOptionValue: void 0,
|
|
defaultValueDescription: Diagnostics.Computed_from_the_list_of_input_files
|
|
},
|
|
{
|
|
name: "typeRoots",
|
|
type: "list",
|
|
element: {
|
|
name: "typeRoots",
|
|
type: "string",
|
|
isFilePath: true
|
|
},
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types
|
|
},
|
|
{
|
|
name: "types",
|
|
type: "list",
|
|
element: {
|
|
name: "types",
|
|
type: "string"
|
|
},
|
|
affectsProgramStructure: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file,
|
|
transpileOptionValue: void 0
|
|
},
|
|
{
|
|
name: "allowSyntheticDefaultImports",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export,
|
|
defaultValueDescription: Diagnostics.module_system_or_esModuleInterop
|
|
},
|
|
{
|
|
name: "esModuleInterop",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
showInSimplifiedHelpView: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveSymlinks",
|
|
type: "boolean",
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "allowUmdGlobalAccess",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Allow_accessing_UMD_globals_from_modules,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "moduleSuffixes",
|
|
type: "list",
|
|
element: {
|
|
name: "suffix",
|
|
type: "string"
|
|
},
|
|
listPreserveFalsyValues: true,
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module
|
|
},
|
|
{
|
|
name: "sourceRoot",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code
|
|
},
|
|
{
|
|
name: "mapRoot",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.LOCATION,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations
|
|
},
|
|
{
|
|
name: "inlineSources",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "experimentalDecorators",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Enable_experimental_support_for_TC39_stage_2_draft_decorators,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "emitDecoratorMetadata",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "jsxFactory",
|
|
type: "string",
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h,
|
|
defaultValueDescription: "`React.createElement`"
|
|
},
|
|
{
|
|
name: "jsxFragmentFactory",
|
|
type: "string",
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment,
|
|
defaultValueDescription: "React.Fragment"
|
|
},
|
|
{
|
|
name: "jsxImportSource",
|
|
type: "string",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk,
|
|
defaultValueDescription: "react"
|
|
},
|
|
{
|
|
name: "resolveJsonModule",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Enable_importing_json_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "out",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: false,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
paramType: Diagnostics.FILE,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Deprecated_setting_Use_outFile_instead
|
|
},
|
|
{
|
|
name: "reactNamespace",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit,
|
|
defaultValueDescription: "`React`"
|
|
},
|
|
{
|
|
name: "skipDefaultLibCheck",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Completeness,
|
|
description: Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "charset",
|
|
type: "string",
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files,
|
|
defaultValueDescription: "utf8"
|
|
},
|
|
{
|
|
name: "emitBOM",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "newLine",
|
|
type: new Map(getEntries({
|
|
crlf: 0 /* CarriageReturnLineFeed */,
|
|
lf: 1 /* LineFeed */
|
|
})),
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
paramType: Diagnostics.NEWLINE,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Set_the_newline_character_for_emitting_files,
|
|
defaultValueDescription: Diagnostics.Platform_specific
|
|
},
|
|
{
|
|
name: "noErrorTruncation",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Output_Formatting,
|
|
description: Diagnostics.Disable_truncating_types_in_error_messages,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noLib",
|
|
type: "boolean",
|
|
category: Diagnostics.Language_and_Environment,
|
|
affectsProgramStructure: true,
|
|
description: Diagnostics.Disable_including_any_library_files_including_the_default_lib_d_ts,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noResolve",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Modules,
|
|
description: Diagnostics.Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project,
|
|
transpileOptionValue: true,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "stripInternal",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableSizeLimit",
|
|
type: "boolean",
|
|
affectsProgramStructure: true,
|
|
category: Diagnostics.Editor_Support,
|
|
description: Diagnostics.Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableSourceOfProjectReferenceRedirect",
|
|
type: "boolean",
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableSolutionSearching",
|
|
type: "boolean",
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Opt_a_project_out_of_multi_project_reference_checking_when_editing,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "disableReferencedProjectLoad",
|
|
type: "boolean",
|
|
isTSConfigOnly: true,
|
|
category: Diagnostics.Projects,
|
|
description: Diagnostics.Reduce_the_number_of_projects_loaded_automatically_by_TypeScript,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noImplicitUseStrict",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noEmitHelpers",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "noEmitOnError",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "preserveConstEnums",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "declarationDir",
|
|
type: "string",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
affectsDeclarationPath: true,
|
|
isFilePath: true,
|
|
paramType: Diagnostics.DIRECTORY,
|
|
category: Diagnostics.Emit,
|
|
transpileOptionValue: void 0,
|
|
description: Diagnostics.Specify_the_output_directory_for_generated_declaration_files
|
|
},
|
|
{
|
|
name: "skipLibCheck",
|
|
type: "boolean",
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Completeness,
|
|
description: Diagnostics.Skip_type_checking_all_d_ts_files,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "allowUnusedLabels",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Disable_error_reporting_for_unused_labels,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "allowUnreachableCode",
|
|
type: "boolean",
|
|
affectsBindDiagnostics: true,
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Type_Checking,
|
|
description: Diagnostics.Disable_error_reporting_for_unreachable_code,
|
|
defaultValueDescription: void 0
|
|
},
|
|
{
|
|
name: "suppressExcessPropertyErrors",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "suppressImplicitAnyIndexErrors",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "forceConsistentCasingInFileNames",
|
|
type: "boolean",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.Interop_Constraints,
|
|
description: Diagnostics.Ensure_that_casing_is_correct_in_imports,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "maxNodeModuleJsDepth",
|
|
type: "number",
|
|
affectsModuleResolution: true,
|
|
category: Diagnostics.JavaScript_Support,
|
|
description: Diagnostics.Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs,
|
|
defaultValueDescription: 0
|
|
},
|
|
{
|
|
name: "noStrictGenericChecks",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "useDefineForClassFields",
|
|
type: "boolean",
|
|
affectsSemanticDiagnostics: true,
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Language_and_Environment,
|
|
description: Diagnostics.Emit_ECMAScript_standard_compliant_class_fields,
|
|
defaultValueDescription: Diagnostics.true_for_ES2022_and_above_including_ESNext
|
|
},
|
|
{
|
|
name: "preserveValueImports",
|
|
type: "boolean",
|
|
affectsEmit: true,
|
|
affectsBuildInfo: true,
|
|
category: Diagnostics.Emit,
|
|
description: Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "keyofStringsOnly",
|
|
type: "boolean",
|
|
category: Diagnostics.Backwards_Compatibility,
|
|
description: Diagnostics.Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option,
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "plugins",
|
|
type: "list",
|
|
isTSConfigOnly: true,
|
|
element: {
|
|
name: "plugin",
|
|
type: "object"
|
|
},
|
|
description: Diagnostics.Specify_a_list_of_language_service_plugins_to_include,
|
|
category: Diagnostics.Editor_Support
|
|
},
|
|
{
|
|
name: "moduleDetection",
|
|
type: new Map(getEntries({
|
|
auto: 2 /* Auto */,
|
|
legacy: 1 /* Legacy */,
|
|
force: 3 /* Force */
|
|
})),
|
|
affectsModuleResolution: true,
|
|
description: Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
|
|
category: Diagnostics.Language_and_Environment,
|
|
defaultValueDescription: Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules
|
|
}
|
|
];
|
|
var optionDeclarations = [
|
|
...commonOptionsWithBuild,
|
|
...commandOptionsWithoutBuild
|
|
];
|
|
var semanticDiagnosticsOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsSemanticDiagnostics);
|
|
var affectsEmitOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsEmit);
|
|
var affectsDeclarationPathOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsDeclarationPath);
|
|
var moduleResolutionOptionDeclarations = optionDeclarations.filter((option) => !!option.affectsModuleResolution);
|
|
var sourceFileAffectingCompilerOptions = optionDeclarations.filter((option) => !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics);
|
|
var optionsAffectingProgramStructure = optionDeclarations.filter((option) => !!option.affectsProgramStructure);
|
|
var transpileOptionValueCompilerOptions = optionDeclarations.filter((option) => hasProperty(option, "transpileOptionValue"));
|
|
var optionsForBuild = [
|
|
{
|
|
name: "verbose",
|
|
shortName: "v",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Enable_verbose_logging,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "dry",
|
|
shortName: "d",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "force",
|
|
shortName: "f",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "clean",
|
|
category: Diagnostics.Command_line_Options,
|
|
description: Diagnostics.Delete_the_outputs_of_all_projects,
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
}
|
|
];
|
|
var buildOpts = [
|
|
...commonOptionsWithBuild,
|
|
...optionsForBuild
|
|
];
|
|
var typeAcquisitionDeclarations = [
|
|
{
|
|
name: "enableAutoDiscovery",
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "enable",
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
},
|
|
{
|
|
name: "include",
|
|
type: "list",
|
|
element: {
|
|
name: "include",
|
|
type: "string"
|
|
}
|
|
},
|
|
{
|
|
name: "exclude",
|
|
type: "list",
|
|
element: {
|
|
name: "exclude",
|
|
type: "string"
|
|
}
|
|
},
|
|
{
|
|
name: "disableFilenameBasedTypeAcquisition",
|
|
type: "boolean",
|
|
defaultValueDescription: false
|
|
}
|
|
];
|
|
function createOptionNameMap(optionDeclarations2) {
|
|
const optionsNameMap = /* @__PURE__ */ new Map();
|
|
const shortOptionNames = /* @__PURE__ */ new Map();
|
|
forEach(optionDeclarations2, (option) => {
|
|
optionsNameMap.set(option.name.toLowerCase(), option);
|
|
if (option.shortName) {
|
|
shortOptionNames.set(option.shortName, option.name);
|
|
}
|
|
});
|
|
return { optionsNameMap, shortOptionNames };
|
|
}
|
|
var optionsNameMapCache;
|
|
function getOptionsNameMap() {
|
|
return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(optionDeclarations));
|
|
}
|
|
var compilerOptionsAlternateMode = {
|
|
diagnostic: Diagnostics.Compiler_option_0_may_only_be_used_with_build,
|
|
getOptionsNameMap: getBuildOptionsNameMap
|
|
};
|
|
var defaultInitCompilerOptions = {
|
|
module: 1 /* CommonJS */,
|
|
target: 3 /* ES2016 */,
|
|
strict: true,
|
|
esModuleInterop: true,
|
|
forceConsistentCasingInFileNames: true,
|
|
skipLibCheck: true
|
|
};
|
|
function convertEnableAutoDiscoveryToEnable(typeAcquisition) {
|
|
if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== void 0 && typeAcquisition.enable === void 0) {
|
|
return {
|
|
enable: typeAcquisition.enableAutoDiscovery,
|
|
include: typeAcquisition.include || [],
|
|
exclude: typeAcquisition.exclude || []
|
|
};
|
|
}
|
|
return typeAcquisition;
|
|
}
|
|
function createCompilerDiagnosticForInvalidCustomType(opt) {
|
|
return createDiagnosticForInvalidCustomType(opt, createCompilerDiagnostic);
|
|
}
|
|
function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
|
|
const namesOfType = arrayFrom(opt.type.keys()).map((key) => `'${key}'`).join(", ");
|
|
return createDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);
|
|
}
|
|
function parseCustomTypeOption(opt, value, errors) {
|
|
return convertJsonOptionOfCustomType(opt, trimString(value || ""), errors);
|
|
}
|
|
function parseListTypeOption(opt, value = "", errors) {
|
|
value = trimString(value);
|
|
if (startsWith(value, "-")) {
|
|
return void 0;
|
|
}
|
|
if (value === "") {
|
|
return [];
|
|
}
|
|
const values = value.split(",");
|
|
switch (opt.element.type) {
|
|
case "number":
|
|
return mapDefined(values, (v) => validateJsonOptionValue(opt.element, parseInt(v), errors));
|
|
case "string":
|
|
return mapDefined(values, (v) => validateJsonOptionValue(opt.element, v || "", errors));
|
|
default:
|
|
return mapDefined(values, (v) => parseCustomTypeOption(opt.element, v, errors));
|
|
}
|
|
}
|
|
function getOptionName(option) {
|
|
return option.name;
|
|
}
|
|
function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
|
|
var _a2;
|
|
if ((_a2 = diagnostics.alternateMode) == null ? void 0 : _a2.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) {
|
|
return createDiagnostics(diagnostics.alternateMode.diagnostic, unknownOption);
|
|
}
|
|
const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
|
|
return possibleOption ? createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
|
|
}
|
|
function parseCommandLineWorker(diagnostics, commandLine, readFile) {
|
|
const options = {};
|
|
let watchOptions;
|
|
const fileNames = [];
|
|
const errors = [];
|
|
parseStrings(commandLine);
|
|
return {
|
|
options,
|
|
watchOptions,
|
|
fileNames,
|
|
errors
|
|
};
|
|
function parseStrings(args) {
|
|
let i = 0;
|
|
while (i < args.length) {
|
|
const s = args[i];
|
|
i++;
|
|
if (s.charCodeAt(0) === 64 /* at */) {
|
|
parseResponseFile(s.slice(1));
|
|
} else if (s.charCodeAt(0) === 45 /* minus */) {
|
|
const inputOptionName = s.slice(s.charCodeAt(1) === 45 /* minus */ ? 2 : 1);
|
|
const opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, true);
|
|
if (opt) {
|
|
i = parseOptionValue(args, i, diagnostics, opt, options, errors);
|
|
} else {
|
|
const watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, true);
|
|
if (watchOpt) {
|
|
i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
|
|
} else {
|
|
errors.push(createUnknownOptionError(inputOptionName, diagnostics, createCompilerDiagnostic, s));
|
|
}
|
|
}
|
|
} else {
|
|
fileNames.push(s);
|
|
}
|
|
}
|
|
}
|
|
function parseResponseFile(fileName) {
|
|
const text = tryReadFile(fileName, readFile || ((fileName2) => sys.readFile(fileName2)));
|
|
if (!isString(text)) {
|
|
errors.push(text);
|
|
return;
|
|
}
|
|
const args = [];
|
|
let pos = 0;
|
|
while (true) {
|
|
while (pos < text.length && text.charCodeAt(pos) <= 32 /* space */)
|
|
pos++;
|
|
if (pos >= text.length)
|
|
break;
|
|
const start2 = pos;
|
|
if (text.charCodeAt(start2) === 34 /* doubleQuote */) {
|
|
pos++;
|
|
while (pos < text.length && text.charCodeAt(pos) !== 34 /* doubleQuote */)
|
|
pos++;
|
|
if (pos < text.length) {
|
|
args.push(text.substring(start2 + 1, pos));
|
|
pos++;
|
|
} else {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));
|
|
}
|
|
} else {
|
|
while (text.charCodeAt(pos) > 32 /* space */)
|
|
pos++;
|
|
args.push(text.substring(start2, pos));
|
|
}
|
|
}
|
|
parseStrings(args);
|
|
}
|
|
}
|
|
function parseOptionValue(args, i, diagnostics, opt, options, errors) {
|
|
if (opt.isTSConfigOnly) {
|
|
const optValue = args[i];
|
|
if (optValue === "null") {
|
|
options[opt.name] = void 0;
|
|
i++;
|
|
} else if (opt.type === "boolean") {
|
|
if (optValue === "false") {
|
|
options[opt.name] = validateJsonOptionValue(opt, false, errors);
|
|
i++;
|
|
} else {
|
|
if (optValue === "true")
|
|
i++;
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name));
|
|
}
|
|
} else {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name));
|
|
if (optValue && !startsWith(optValue, "-"))
|
|
i++;
|
|
}
|
|
} else {
|
|
if (!args[i] && opt.type !== "boolean") {
|
|
errors.push(createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt)));
|
|
}
|
|
if (args[i] !== "null") {
|
|
switch (opt.type) {
|
|
case "number":
|
|
options[opt.name] = validateJsonOptionValue(opt, parseInt(args[i]), errors);
|
|
i++;
|
|
break;
|
|
case "boolean":
|
|
const optValue = args[i];
|
|
options[opt.name] = validateJsonOptionValue(opt, optValue !== "false", errors);
|
|
if (optValue === "false" || optValue === "true") {
|
|
i++;
|
|
}
|
|
break;
|
|
case "string":
|
|
options[opt.name] = validateJsonOptionValue(opt, args[i] || "", errors);
|
|
i++;
|
|
break;
|
|
case "list":
|
|
const result = parseListTypeOption(opt, args[i], errors);
|
|
options[opt.name] = result || [];
|
|
if (result) {
|
|
i++;
|
|
}
|
|
break;
|
|
default:
|
|
options[opt.name] = parseCustomTypeOption(opt, args[i], errors);
|
|
i++;
|
|
break;
|
|
}
|
|
} else {
|
|
options[opt.name] = void 0;
|
|
i++;
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
var compilerOptionsDidYouMeanDiagnostics = {
|
|
alternateMode: compilerOptionsAlternateMode,
|
|
getOptionsNameMap,
|
|
optionDeclarations,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_compiler_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_compiler_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Compiler_option_0_expects_an_argument
|
|
};
|
|
function parseCommandLine(commandLine, readFile) {
|
|
return parseCommandLineWorker(compilerOptionsDidYouMeanDiagnostics, commandLine, readFile);
|
|
}
|
|
function getOptionFromName(optionName, allowShort) {
|
|
return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort);
|
|
}
|
|
function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort = false) {
|
|
optionName = optionName.toLowerCase();
|
|
const { optionsNameMap, shortOptionNames } = getOptionNameMap();
|
|
if (allowShort) {
|
|
const short = shortOptionNames.get(optionName);
|
|
if (short !== void 0) {
|
|
optionName = short;
|
|
}
|
|
}
|
|
return optionsNameMap.get(optionName);
|
|
}
|
|
var buildOptionsNameMapCache;
|
|
function getBuildOptionsNameMap() {
|
|
return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(buildOpts));
|
|
}
|
|
var buildOptionsAlternateMode = {
|
|
diagnostic: Diagnostics.Compiler_option_0_may_not_be_used_with_build,
|
|
getOptionsNameMap
|
|
};
|
|
var buildOptionsDidYouMeanDiagnostics = {
|
|
alternateMode: buildOptionsAlternateMode,
|
|
getOptionsNameMap: getBuildOptionsNameMap,
|
|
optionDeclarations: buildOpts,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_build_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_build_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Build_option_0_requires_a_value_of_type_1
|
|
};
|
|
function parseBuildCommand(args) {
|
|
const { options, watchOptions, fileNames: projects, errors } = parseCommandLineWorker(
|
|
buildOptionsDidYouMeanDiagnostics,
|
|
args
|
|
);
|
|
const buildOptions = options;
|
|
if (projects.length === 0) {
|
|
projects.push(".");
|
|
}
|
|
if (buildOptions.clean && buildOptions.force) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force"));
|
|
}
|
|
if (buildOptions.clean && buildOptions.verbose) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose"));
|
|
}
|
|
if (buildOptions.clean && buildOptions.watch) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch"));
|
|
}
|
|
if (buildOptions.watch && buildOptions.dry) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry"));
|
|
}
|
|
return { buildOptions, watchOptions, projects, errors };
|
|
}
|
|
function getDiagnosticText(_message, ..._args) {
|
|
const diagnostic = createCompilerDiagnostic.apply(void 0, arguments);
|
|
return diagnostic.messageText;
|
|
}
|
|
function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) {
|
|
const configFileText = tryReadFile(configFileName, (fileName) => host.readFile(fileName));
|
|
if (!isString(configFileText)) {
|
|
host.onUnRecoverableConfigFileDiagnostic(configFileText);
|
|
return void 0;
|
|
}
|
|
const result = parseJsonText(configFileName, configFileText);
|
|
const cwd = host.getCurrentDirectory();
|
|
result.path = toPath(configFileName, cwd, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
|
|
result.resolvedPath = result.path;
|
|
result.originalFileName = result.fileName;
|
|
return parseJsonSourceFileConfigFileContent(
|
|
result,
|
|
host,
|
|
getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd),
|
|
optionsToExtend,
|
|
getNormalizedAbsolutePath(configFileName, cwd),
|
|
void 0,
|
|
extraFileExtensions,
|
|
extendedConfigCache,
|
|
watchOptionsToExtend
|
|
);
|
|
}
|
|
function readConfigFile(fileName, readFile) {
|
|
const textOrDiagnostic = tryReadFile(fileName, readFile);
|
|
return isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic };
|
|
}
|
|
function parseConfigFileTextToJson(fileName, jsonText) {
|
|
const jsonSourceFile = parseJsonText(fileName, jsonText);
|
|
return {
|
|
config: convertConfigFileToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics, false, void 0),
|
|
error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
|
|
};
|
|
}
|
|
function readJsonConfigFile(fileName, readFile) {
|
|
const textOrDiagnostic = tryReadFile(fileName, readFile);
|
|
return isString(textOrDiagnostic) ? parseJsonText(fileName, textOrDiagnostic) : { fileName, parseDiagnostics: [textOrDiagnostic] };
|
|
}
|
|
function tryReadFile(fileName, readFile) {
|
|
let text;
|
|
try {
|
|
text = readFile(fileName);
|
|
} catch (e) {
|
|
return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);
|
|
}
|
|
return text === void 0 ? createCompilerDiagnostic(Diagnostics.Cannot_read_file_0, fileName) : text;
|
|
}
|
|
function commandLineOptionsToMap(options) {
|
|
return arrayToMap(options, getOptionName);
|
|
}
|
|
var typeAcquisitionDidYouMeanDiagnostics = {
|
|
optionDeclarations: typeAcquisitionDeclarations,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_type_acquisition_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1
|
|
};
|
|
var watchOptionsNameMapCache;
|
|
function getWatchOptionsNameMap() {
|
|
return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(optionsForWatch));
|
|
}
|
|
var watchOptionsDidYouMeanDiagnostics = {
|
|
getOptionsNameMap: getWatchOptionsNameMap,
|
|
optionDeclarations: optionsForWatch,
|
|
unknownOptionDiagnostic: Diagnostics.Unknown_watch_option_0,
|
|
unknownDidYouMeanDiagnostic: Diagnostics.Unknown_watch_option_0_Did_you_mean_1,
|
|
optionTypeMismatchDiagnostic: Diagnostics.Watch_option_0_requires_a_value_of_type_1
|
|
};
|
|
var commandLineCompilerOptionsMapCache;
|
|
function getCommandLineCompilerOptionsMap() {
|
|
return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(optionDeclarations));
|
|
}
|
|
var commandLineWatchOptionsMapCache;
|
|
function getCommandLineWatchOptionsMap() {
|
|
return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(optionsForWatch));
|
|
}
|
|
var commandLineTypeAcquisitionMapCache;
|
|
function getCommandLineTypeAcquisitionMap() {
|
|
return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(typeAcquisitionDeclarations));
|
|
}
|
|
var _tsconfigRootOptions;
|
|
function getTsconfigRootOptionsMap() {
|
|
if (_tsconfigRootOptions === void 0) {
|
|
_tsconfigRootOptions = {
|
|
name: void 0,
|
|
type: "object",
|
|
elementOptions: commandLineOptionsToMap([
|
|
{
|
|
name: "compilerOptions",
|
|
type: "object",
|
|
elementOptions: getCommandLineCompilerOptionsMap(),
|
|
extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
|
|
},
|
|
{
|
|
name: "watchOptions",
|
|
type: "object",
|
|
elementOptions: getCommandLineWatchOptionsMap(),
|
|
extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
|
|
},
|
|
{
|
|
name: "typingOptions",
|
|
type: "object",
|
|
elementOptions: getCommandLineTypeAcquisitionMap(),
|
|
extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
|
|
},
|
|
{
|
|
name: "typeAcquisition",
|
|
type: "object",
|
|
elementOptions: getCommandLineTypeAcquisitionMap(),
|
|
extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
|
|
},
|
|
{
|
|
name: "extends",
|
|
type: "string",
|
|
category: Diagnostics.File_Management
|
|
},
|
|
{
|
|
name: "references",
|
|
type: "list",
|
|
element: {
|
|
name: "references",
|
|
type: "object"
|
|
},
|
|
category: Diagnostics.Projects
|
|
},
|
|
{
|
|
name: "files",
|
|
type: "list",
|
|
element: {
|
|
name: "files",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management
|
|
},
|
|
{
|
|
name: "include",
|
|
type: "list",
|
|
element: {
|
|
name: "include",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management,
|
|
defaultValueDescription: Diagnostics.if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk
|
|
},
|
|
{
|
|
name: "exclude",
|
|
type: "list",
|
|
element: {
|
|
name: "exclude",
|
|
type: "string"
|
|
},
|
|
category: Diagnostics.File_Management,
|
|
defaultValueDescription: Diagnostics.node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified
|
|
},
|
|
compileOnSaveCommandLineOption
|
|
])
|
|
};
|
|
}
|
|
return _tsconfigRootOptions;
|
|
}
|
|
function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, optionsIterator) {
|
|
var _a2;
|
|
const rootExpression = (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression;
|
|
const knownRootOptions = reportOptionsErrors ? getTsconfigRootOptionsMap() : void 0;
|
|
if (rootExpression && rootExpression.kind !== 207 /* ObjectLiteralExpression */) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(
|
|
sourceFile,
|
|
rootExpression,
|
|
Diagnostics.The_root_value_of_a_0_file_must_be_an_object,
|
|
getBaseFileName(sourceFile.fileName) === "jsconfig.json" ? "jsconfig.json" : "tsconfig.json"
|
|
));
|
|
if (isArrayLiteralExpression(rootExpression)) {
|
|
const firstObject = find(rootExpression.elements, isObjectLiteralExpression);
|
|
if (firstObject) {
|
|
return convertToObjectWorker(sourceFile, firstObject, errors, true, knownRootOptions, optionsIterator);
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
return convertToObjectWorker(sourceFile, rootExpression, errors, true, knownRootOptions, optionsIterator);
|
|
}
|
|
function convertToObject(sourceFile, errors) {
|
|
var _a2;
|
|
return convertToObjectWorker(sourceFile, (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression, errors, true, void 0, void 0);
|
|
}
|
|
function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
|
|
if (!rootExpression) {
|
|
return returnValue ? {} : void 0;
|
|
}
|
|
return convertPropertyValueToJson(rootExpression, knownRootOptions);
|
|
function isRootOptionMap(knownOptions) {
|
|
return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
|
|
}
|
|
function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
|
|
const result = returnValue ? {} : void 0;
|
|
for (const element of node.properties) {
|
|
if (element.kind !== 299 /* PropertyAssignment */) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element, Diagnostics.Property_assignment_expected));
|
|
continue;
|
|
}
|
|
if (element.questionToken) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
|
|
}
|
|
if (!isDoubleQuotedString(element.name)) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, Diagnostics.String_literal_with_double_quotes_expected));
|
|
}
|
|
const textOfKey = isComputedNonLiteralName(element.name) ? void 0 : getTextOfPropertyName(element.name);
|
|
const keyText = textOfKey && unescapeLeadingUnderscores(textOfKey);
|
|
const option = keyText && knownOptions ? knownOptions.get(keyText) : void 0;
|
|
if (keyText && extraKeyDiagnostics && !option) {
|
|
if (knownOptions) {
|
|
errors.push(createUnknownOptionError(
|
|
keyText,
|
|
extraKeyDiagnostics,
|
|
(message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1)
|
|
));
|
|
} else {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
|
|
}
|
|
}
|
|
const value = convertPropertyValueToJson(element.initializer, option);
|
|
if (typeof keyText !== "undefined") {
|
|
if (returnValue) {
|
|
result[keyText] = value;
|
|
}
|
|
if (jsonConversionNotifier && (parentOption || isRootOptionMap(knownOptions))) {
|
|
const isValidOptionValue = isCompilerOptionsValue(option, value);
|
|
if (parentOption) {
|
|
if (isValidOptionValue) {
|
|
jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value);
|
|
}
|
|
} else if (isRootOptionMap(knownOptions)) {
|
|
if (isValidOptionValue) {
|
|
jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
|
|
} else if (!option) {
|
|
jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function convertArrayLiteralExpressionToJson(elements, elementOption) {
|
|
if (!returnValue) {
|
|
elements.forEach((element) => convertPropertyValueToJson(element, elementOption));
|
|
return void 0;
|
|
}
|
|
return filter(elements.map((element) => convertPropertyValueToJson(element, elementOption)), (v) => v !== void 0);
|
|
}
|
|
function convertPropertyValueToJson(valueExpression, option) {
|
|
let invalidReported;
|
|
switch (valueExpression.kind) {
|
|
case 110 /* TrueKeyword */:
|
|
reportInvalidOptionValue(option && option.type !== "boolean");
|
|
return validateValue(true);
|
|
case 95 /* FalseKeyword */:
|
|
reportInvalidOptionValue(option && option.type !== "boolean");
|
|
return validateValue(false);
|
|
case 104 /* NullKeyword */:
|
|
reportInvalidOptionValue(option && option.name === "extends");
|
|
return validateValue(null);
|
|
case 10 /* StringLiteral */:
|
|
if (!isDoubleQuotedString(valueExpression)) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
|
|
}
|
|
reportInvalidOptionValue(option && (isString(option.type) && option.type !== "string"));
|
|
const text = valueExpression.text;
|
|
if (option && !isString(option.type)) {
|
|
const customOption = option;
|
|
if (!customOption.type.has(text.toLowerCase())) {
|
|
errors.push(
|
|
createDiagnosticForInvalidCustomType(
|
|
customOption,
|
|
(message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1)
|
|
)
|
|
);
|
|
invalidReported = true;
|
|
}
|
|
}
|
|
return validateValue(text);
|
|
case 8 /* NumericLiteral */:
|
|
reportInvalidOptionValue(option && option.type !== "number");
|
|
return validateValue(Number(valueExpression.text));
|
|
case 221 /* PrefixUnaryExpression */:
|
|
if (valueExpression.operator !== 40 /* MinusToken */ || valueExpression.operand.kind !== 8 /* NumericLiteral */) {
|
|
break;
|
|
}
|
|
reportInvalidOptionValue(option && option.type !== "number");
|
|
return validateValue(-Number(valueExpression.operand.text));
|
|
case 207 /* ObjectLiteralExpression */:
|
|
reportInvalidOptionValue(option && option.type !== "object");
|
|
const objectLiteralExpression = valueExpression;
|
|
if (option) {
|
|
const { elementOptions, extraKeyDiagnostics, name: optionName } = option;
|
|
return validateValue(convertObjectLiteralExpressionToJson(
|
|
objectLiteralExpression,
|
|
elementOptions,
|
|
extraKeyDiagnostics,
|
|
optionName
|
|
));
|
|
} else {
|
|
return validateValue(convertObjectLiteralExpressionToJson(
|
|
objectLiteralExpression,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
));
|
|
}
|
|
case 206 /* ArrayLiteralExpression */:
|
|
reportInvalidOptionValue(option && option.type !== "list");
|
|
return validateValue(convertArrayLiteralExpressionToJson(
|
|
valueExpression.elements,
|
|
option && option.element
|
|
));
|
|
}
|
|
if (option) {
|
|
reportInvalidOptionValue(true);
|
|
} else {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
|
|
}
|
|
return void 0;
|
|
function validateValue(value) {
|
|
var _a2;
|
|
if (!invalidReported) {
|
|
const diagnostic = (_a2 = option == null ? void 0 : option.extraValidation) == null ? void 0 : _a2.call(option, value);
|
|
if (diagnostic) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ...diagnostic));
|
|
return void 0;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function reportInvalidOptionValue(isError) {
|
|
if (isError) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
|
|
invalidReported = true;
|
|
}
|
|
}
|
|
}
|
|
function isDoubleQuotedString(node) {
|
|
return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
|
|
}
|
|
}
|
|
function getCompilerOptionValueTypeString(option) {
|
|
return option.type === "list" ? "Array" : isString(option.type) ? option.type : "string";
|
|
}
|
|
function isCompilerOptionsValue(option, value) {
|
|
if (option) {
|
|
if (isNullOrUndefined(value))
|
|
return true;
|
|
if (option.type === "list") {
|
|
return isArray(value);
|
|
}
|
|
const expectedType = isString(option.type) ? option.type : "string";
|
|
return typeof value === expectedType;
|
|
}
|
|
return false;
|
|
}
|
|
function convertToTSConfig(configParseResult, configFileName, host) {
|
|
var _a2, _b, _c;
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
|
|
const files = map(
|
|
filter(
|
|
configParseResult.fileNames,
|
|
!((_b = (_a2 = configParseResult.options.configFile) == null ? void 0 : _a2.configFileSpecs) == null ? void 0 : _b.validatedIncludeSpecs) ? returnTrue : matchesSpecs(
|
|
configFileName,
|
|
configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs,
|
|
configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs,
|
|
host
|
|
)
|
|
),
|
|
(f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
|
|
);
|
|
const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
|
|
const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
|
|
const config = {
|
|
compilerOptions: {
|
|
...optionMapToObject(optionMap),
|
|
showConfig: void 0,
|
|
configFile: void 0,
|
|
configFilePath: void 0,
|
|
help: void 0,
|
|
init: void 0,
|
|
listFiles: void 0,
|
|
listEmittedFiles: void 0,
|
|
project: void 0,
|
|
build: void 0,
|
|
version: void 0
|
|
},
|
|
watchOptions: watchOptionMap && optionMapToObject(watchOptionMap),
|
|
references: map(configParseResult.projectReferences, (r) => ({ ...r, path: r.originalPath ? r.originalPath : "", originalPath: void 0 })),
|
|
files: length(files) ? files : void 0,
|
|
...((_c = configParseResult.options.configFile) == null ? void 0 : _c.configFileSpecs) ? {
|
|
include: filterSameAsDefaultInclude(configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs),
|
|
exclude: configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs
|
|
} : {},
|
|
compileOnSave: !!configParseResult.compileOnSave ? true : void 0
|
|
};
|
|
return config;
|
|
}
|
|
function optionMapToObject(optionMap) {
|
|
return {
|
|
...arrayFrom(optionMap.entries()).reduce((prev, cur) => ({ ...prev, [cur[0]]: cur[1] }), {})
|
|
};
|
|
}
|
|
function filterSameAsDefaultInclude(specs) {
|
|
if (!length(specs))
|
|
return void 0;
|
|
if (length(specs) !== 1)
|
|
return specs;
|
|
if (specs[0] === defaultIncludeSpec)
|
|
return void 0;
|
|
return specs;
|
|
}
|
|
function matchesSpecs(path, includeSpecs, excludeSpecs, host) {
|
|
if (!includeSpecs)
|
|
return returnTrue;
|
|
const patterns = getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory());
|
|
const excludeRe = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames);
|
|
const includeRe = patterns.includeFilePattern && getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames);
|
|
if (includeRe) {
|
|
if (excludeRe) {
|
|
return (path2) => !(includeRe.test(path2) && !excludeRe.test(path2));
|
|
}
|
|
return (path2) => !includeRe.test(path2);
|
|
}
|
|
if (excludeRe) {
|
|
return (path2) => excludeRe.test(path2);
|
|
}
|
|
return returnTrue;
|
|
}
|
|
function getCustomTypeMapOfCommandLineOption(optionDefinition) {
|
|
if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") {
|
|
return void 0;
|
|
} else if (optionDefinition.type === "list") {
|
|
return getCustomTypeMapOfCommandLineOption(optionDefinition.element);
|
|
} else {
|
|
return optionDefinition.type;
|
|
}
|
|
}
|
|
function getNameOfCompilerOptionValue(value, customTypeMap) {
|
|
return forEachEntry(customTypeMap, (mapValue, key) => {
|
|
if (mapValue === value) {
|
|
return key;
|
|
}
|
|
});
|
|
}
|
|
function serializeCompilerOptions(options, pathOptions) {
|
|
return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
|
|
}
|
|
function serializeWatchOptions(options) {
|
|
return serializeOptionBaseObject(options, getWatchOptionsNameMap());
|
|
}
|
|
function serializeOptionBaseObject(options, { optionsNameMap }, pathOptions) {
|
|
const result = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = pathOptions && createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);
|
|
for (const name in options) {
|
|
if (hasProperty(options, name)) {
|
|
if (optionsNameMap.has(name) && (optionsNameMap.get(name).category === Diagnostics.Command_line_Options || optionsNameMap.get(name).category === Diagnostics.Output_Formatting)) {
|
|
continue;
|
|
}
|
|
const value = options[name];
|
|
const optionDefinition = optionsNameMap.get(name.toLowerCase());
|
|
if (optionDefinition) {
|
|
const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);
|
|
if (!customTypeMap) {
|
|
if (pathOptions && optionDefinition.isFilePath) {
|
|
result.set(name, getRelativePathFromFile(pathOptions.configFilePath, getNormalizedAbsolutePath(value, getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName));
|
|
} else {
|
|
result.set(name, value);
|
|
}
|
|
} else {
|
|
if (optionDefinition.type === "list") {
|
|
result.set(name, value.map((element) => getNameOfCompilerOptionValue(element, customTypeMap)));
|
|
} else {
|
|
result.set(name, getNameOfCompilerOptionValue(value, customTypeMap));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getCompilerOptionsDiffValue(options, newLine) {
|
|
const compilerOptionsMap = getSerializedCompilerOption(options);
|
|
return getOverwrittenDefaultOptions();
|
|
function makePadding(paddingLength) {
|
|
return Array(paddingLength + 1).join(" ");
|
|
}
|
|
function getOverwrittenDefaultOptions() {
|
|
const result = [];
|
|
const tab = makePadding(2);
|
|
commandOptionsWithoutBuild.forEach((cmd) => {
|
|
if (!compilerOptionsMap.has(cmd.name)) {
|
|
return;
|
|
}
|
|
const newValue = compilerOptionsMap.get(cmd.name);
|
|
const defaultValue = getDefaultValueForOption(cmd);
|
|
if (newValue !== defaultValue) {
|
|
result.push(`${tab}${cmd.name}: ${newValue}`);
|
|
} else if (hasProperty(defaultInitCompilerOptions, cmd.name)) {
|
|
result.push(`${tab}${cmd.name}: ${defaultValue}`);
|
|
}
|
|
});
|
|
return result.join(newLine) + newLine;
|
|
}
|
|
}
|
|
function getSerializedCompilerOption(options) {
|
|
const compilerOptions = extend(options, defaultInitCompilerOptions);
|
|
return serializeCompilerOptions(compilerOptions);
|
|
}
|
|
function generateTSConfig(options, fileNames, newLine) {
|
|
const compilerOptionsMap = getSerializedCompilerOption(options);
|
|
return writeConfigurations();
|
|
function makePadding(paddingLength) {
|
|
return Array(paddingLength + 1).join(" ");
|
|
}
|
|
function isAllowedOptionForOutput({ category, name, isCommandLineOnly }) {
|
|
const categoriesToSkip = [Diagnostics.Command_line_Options, Diagnostics.Editor_Support, Diagnostics.Compiler_Diagnostics, Diagnostics.Backwards_Compatibility, Diagnostics.Watch_and_Build_Modes, Diagnostics.Output_Formatting];
|
|
return !isCommandLineOnly && category !== void 0 && (!categoriesToSkip.includes(category) || compilerOptionsMap.has(name));
|
|
}
|
|
function writeConfigurations() {
|
|
const categorizedOptions = /* @__PURE__ */ new Map();
|
|
categorizedOptions.set(Diagnostics.Projects, []);
|
|
categorizedOptions.set(Diagnostics.Language_and_Environment, []);
|
|
categorizedOptions.set(Diagnostics.Modules, []);
|
|
categorizedOptions.set(Diagnostics.JavaScript_Support, []);
|
|
categorizedOptions.set(Diagnostics.Emit, []);
|
|
categorizedOptions.set(Diagnostics.Interop_Constraints, []);
|
|
categorizedOptions.set(Diagnostics.Type_Checking, []);
|
|
categorizedOptions.set(Diagnostics.Completeness, []);
|
|
for (const option of optionDeclarations) {
|
|
if (isAllowedOptionForOutput(option)) {
|
|
let listForCategory = categorizedOptions.get(option.category);
|
|
if (!listForCategory)
|
|
categorizedOptions.set(option.category, listForCategory = []);
|
|
listForCategory.push(option);
|
|
}
|
|
}
|
|
let marginLength = 0;
|
|
let seenKnownKeys = 0;
|
|
const entries = [];
|
|
categorizedOptions.forEach((options2, category) => {
|
|
if (entries.length !== 0) {
|
|
entries.push({ value: "" });
|
|
}
|
|
entries.push({ value: `/* ${getLocaleSpecificMessage(category)} */` });
|
|
for (const option of options2) {
|
|
let optionName;
|
|
if (compilerOptionsMap.has(option.name)) {
|
|
optionName = `"${option.name}": ${JSON.stringify(compilerOptionsMap.get(option.name))}${(seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ","}`;
|
|
} else {
|
|
optionName = `// "${option.name}": ${JSON.stringify(getDefaultValueForOption(option))},`;
|
|
}
|
|
entries.push({
|
|
value: optionName,
|
|
description: `/* ${option.description && getLocaleSpecificMessage(option.description) || option.name} */`
|
|
});
|
|
marginLength = Math.max(optionName.length, marginLength);
|
|
}
|
|
});
|
|
const tab = makePadding(2);
|
|
const result = [];
|
|
result.push(`{`);
|
|
result.push(`${tab}"compilerOptions": {`);
|
|
result.push(`${tab}${tab}/* ${getLocaleSpecificMessage(Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file)} */`);
|
|
result.push("");
|
|
for (const entry of entries) {
|
|
const { value, description: description2 = "" } = entry;
|
|
result.push(value && `${tab}${tab}${value}${description2 && makePadding(marginLength - value.length + 2) + description2}`);
|
|
}
|
|
if (fileNames.length) {
|
|
result.push(`${tab}},`);
|
|
result.push(`${tab}"files": [`);
|
|
for (let i = 0; i < fileNames.length; i++) {
|
|
result.push(`${tab}${tab}${JSON.stringify(fileNames[i])}${i === fileNames.length - 1 ? "" : ","}`);
|
|
}
|
|
result.push(`${tab}]`);
|
|
} else {
|
|
result.push(`${tab}}`);
|
|
}
|
|
result.push(`}`);
|
|
return result.join(newLine) + newLine;
|
|
}
|
|
}
|
|
function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) {
|
|
const result = {};
|
|
const optionsNameMap = getOptionsNameMap().optionsNameMap;
|
|
for (const name in options) {
|
|
if (hasProperty(options, name)) {
|
|
result[name] = convertToOptionValueWithAbsolutePaths(
|
|
optionsNameMap.get(name.toLowerCase()),
|
|
options[name],
|
|
toAbsolutePath
|
|
);
|
|
}
|
|
}
|
|
if (result.configFilePath) {
|
|
result.configFilePath = toAbsolutePath(result.configFilePath);
|
|
}
|
|
return result;
|
|
}
|
|
function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) {
|
|
if (option && !isNullOrUndefined(value)) {
|
|
if (option.type === "list") {
|
|
const values = value;
|
|
if (option.element.isFilePath && values.length) {
|
|
return values.map(toAbsolutePath);
|
|
}
|
|
} else if (option.isFilePath) {
|
|
return toAbsolutePath(value);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
|
|
return parseJsonConfigFileContentWorker(json, void 0, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
|
|
}
|
|
function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Parse, "parseJsonSourceFileConfigFileContent", { path: sourceFile.fileName });
|
|
const result = parseJsonConfigFileContentWorker(void 0, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function setConfigFileInOptions(options, configFile) {
|
|
if (configFile) {
|
|
Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile });
|
|
}
|
|
}
|
|
function isNullOrUndefined(x) {
|
|
return x === void 0 || x === null;
|
|
}
|
|
function directoryOfCombinedPath(fileName, basePath) {
|
|
return getDirectoryPath(getNormalizedAbsolutePath(fileName, basePath));
|
|
}
|
|
var defaultIncludeSpec = "**/*";
|
|
function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions = {}, existingWatchOptions, configFileName, resolutionStack = [], extraFileExtensions = [], extendedConfigCache) {
|
|
Debug.assert(json === void 0 && sourceFile !== void 0 || json !== void 0 && sourceFile === void 0);
|
|
const errors = [];
|
|
const parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache);
|
|
const { raw } = parsedConfig;
|
|
const options = extend(existingOptions, parsedConfig.options || {});
|
|
const watchOptions = existingWatchOptions && parsedConfig.watchOptions ? extend(existingWatchOptions, parsedConfig.watchOptions) : parsedConfig.watchOptions || existingWatchOptions;
|
|
options.configFilePath = configFileName && normalizeSlashes(configFileName);
|
|
const configFileSpecs = getConfigFileSpecs();
|
|
if (sourceFile)
|
|
sourceFile.configFileSpecs = configFileSpecs;
|
|
setConfigFileInOptions(options, sourceFile);
|
|
const basePathForFileNames = normalizePath(configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath);
|
|
return {
|
|
options,
|
|
watchOptions,
|
|
fileNames: getFileNames(basePathForFileNames),
|
|
projectReferences: getProjectReferences(basePathForFileNames),
|
|
typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(),
|
|
raw,
|
|
errors,
|
|
wildcardDirectories: getWildcardDirectories(configFileSpecs, basePathForFileNames, host.useCaseSensitiveFileNames),
|
|
compileOnSave: !!raw.compileOnSave
|
|
};
|
|
function getConfigFileSpecs() {
|
|
const referencesOfRaw = getPropFromRaw("references", (element) => typeof element === "object", "object");
|
|
const filesSpecs = toPropValue(getSpecsFromRaw("files"));
|
|
if (filesSpecs) {
|
|
const hasZeroOrNoReferences = referencesOfRaw === "no-prop" || isArray(referencesOfRaw) && referencesOfRaw.length === 0;
|
|
const hasExtends = hasProperty(raw, "extends");
|
|
if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) {
|
|
if (sourceFile) {
|
|
const fileName = configFileName || "tsconfig.json";
|
|
const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
|
|
const nodeValue = firstDefined(getTsConfigPropArray(sourceFile, "files"), (property) => property.initializer);
|
|
const error = nodeValue ? createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName) : createCompilerDiagnostic(diagnosticMessage, fileName);
|
|
errors.push(error);
|
|
} else {
|
|
createCompilerDiagnosticOnlyIfJson(Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
|
|
}
|
|
}
|
|
}
|
|
let includeSpecs = toPropValue(getSpecsFromRaw("include"));
|
|
const excludeOfRaw = getSpecsFromRaw("exclude");
|
|
let isDefaultIncludeSpec = false;
|
|
let excludeSpecs = toPropValue(excludeOfRaw);
|
|
if (excludeOfRaw === "no-prop" && raw.compilerOptions) {
|
|
const outDir = raw.compilerOptions.outDir;
|
|
const declarationDir = raw.compilerOptions.declarationDir;
|
|
if (outDir || declarationDir) {
|
|
excludeSpecs = [outDir, declarationDir].filter((d) => !!d);
|
|
}
|
|
}
|
|
if (filesSpecs === void 0 && includeSpecs === void 0) {
|
|
includeSpecs = [defaultIncludeSpec];
|
|
isDefaultIncludeSpec = true;
|
|
}
|
|
let validatedIncludeSpecs, validatedExcludeSpecs;
|
|
if (includeSpecs) {
|
|
validatedIncludeSpecs = validateSpecs(includeSpecs, errors, true, sourceFile, "include");
|
|
}
|
|
if (excludeSpecs) {
|
|
validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, false, sourceFile, "exclude");
|
|
}
|
|
return {
|
|
filesSpecs,
|
|
includeSpecs,
|
|
excludeSpecs,
|
|
validatedFilesSpec: filter(filesSpecs, isString),
|
|
validatedIncludeSpecs,
|
|
validatedExcludeSpecs,
|
|
pathPatterns: void 0,
|
|
isDefaultIncludeSpec
|
|
};
|
|
}
|
|
function getFileNames(basePath2) {
|
|
const fileNames = getFileNamesFromConfigSpecs(configFileSpecs, basePath2, options, host, extraFileExtensions);
|
|
if (shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(raw), resolutionStack)) {
|
|
errors.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
|
|
}
|
|
return fileNames;
|
|
}
|
|
function getProjectReferences(basePath2) {
|
|
let projectReferences;
|
|
const referencesOfRaw = getPropFromRaw("references", (element) => typeof element === "object", "object");
|
|
if (isArray(referencesOfRaw)) {
|
|
for (const ref of referencesOfRaw) {
|
|
if (typeof ref.path !== "string") {
|
|
createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string");
|
|
} else {
|
|
(projectReferences || (projectReferences = [])).push({
|
|
path: getNormalizedAbsolutePath(ref.path, basePath2),
|
|
originalPath: ref.path,
|
|
prepend: ref.prepend,
|
|
circular: ref.circular
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return projectReferences;
|
|
}
|
|
function toPropValue(specResult) {
|
|
return isArray(specResult) ? specResult : void 0;
|
|
}
|
|
function getSpecsFromRaw(prop) {
|
|
return getPropFromRaw(prop, isString, "string");
|
|
}
|
|
function getPropFromRaw(prop, validateElement, elementTypeName) {
|
|
if (hasProperty(raw, prop) && !isNullOrUndefined(raw[prop])) {
|
|
if (isArray(raw[prop])) {
|
|
const result = raw[prop];
|
|
if (!sourceFile && !every(result, validateElement)) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, elementTypeName));
|
|
}
|
|
return result;
|
|
} else {
|
|
createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, "Array");
|
|
return "not-array";
|
|
}
|
|
}
|
|
return "no-prop";
|
|
}
|
|
function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) {
|
|
if (!sourceFile) {
|
|
errors.push(createCompilerDiagnostic(message, arg0, arg1));
|
|
}
|
|
}
|
|
}
|
|
function isErrorNoInputFiles(error) {
|
|
return error.code === Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code;
|
|
}
|
|
function getErrorForNoInputFiles({ includeSpecs, excludeSpecs }, configFileName) {
|
|
return createCompilerDiagnostic(
|
|
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(fileNames, canJsonReportNoInutFiles, resolutionStack) {
|
|
return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0);
|
|
}
|
|
function canJsonReportNoInputFiles(raw) {
|
|
return !hasProperty(raw, "files") && !hasProperty(raw, "references");
|
|
}
|
|
function updateErrorForNoInputFiles(fileNames, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) {
|
|
const existingErrors = configParseDiagnostics.length;
|
|
if (shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles)) {
|
|
configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName));
|
|
} else {
|
|
filterMutate(configParseDiagnostics, (error) => !isErrorNoInputFiles(error));
|
|
}
|
|
return existingErrors !== configParseDiagnostics.length;
|
|
}
|
|
function isSuccessfulParsedTsconfig(value) {
|
|
return !!value.options;
|
|
}
|
|
function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) {
|
|
var _a2;
|
|
basePath = normalizeSlashes(basePath);
|
|
const resolvedPath = getNormalizedAbsolutePath(configFileName || "", basePath);
|
|
if (resolutionStack.indexOf(resolvedPath) >= 0) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, [...resolutionStack, resolvedPath].join(" -> ")));
|
|
return { raw: json || convertToObject(sourceFile, errors) };
|
|
}
|
|
const ownConfig = json ? parseOwnConfigOfJson(json, host, basePath, configFileName, errors) : parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors);
|
|
if ((_a2 = ownConfig.options) == null ? void 0 : _a2.paths) {
|
|
ownConfig.options.pathsBasePath = basePath;
|
|
}
|
|
if (ownConfig.extendedConfigPath) {
|
|
resolutionStack = resolutionStack.concat([resolvedPath]);
|
|
const extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, resolutionStack, errors, extendedConfigCache);
|
|
if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) {
|
|
const baseRaw = extendedConfig.raw;
|
|
const raw = ownConfig.raw;
|
|
let relativeDifference;
|
|
const setPropertyInRawIfNotUndefined = (propertyName) => {
|
|
if (!raw[propertyName] && baseRaw[propertyName]) {
|
|
raw[propertyName] = map(baseRaw[propertyName], (path) => isRootedDiskPath(path) ? path : combinePaths(
|
|
relativeDifference || (relativeDifference = convertToRelativePath(getDirectoryPath(ownConfig.extendedConfigPath), basePath, createGetCanonicalFileName(host.useCaseSensitiveFileNames))),
|
|
path
|
|
));
|
|
}
|
|
};
|
|
setPropertyInRawIfNotUndefined("include");
|
|
setPropertyInRawIfNotUndefined("exclude");
|
|
setPropertyInRawIfNotUndefined("files");
|
|
if (raw.compileOnSave === void 0) {
|
|
raw.compileOnSave = baseRaw.compileOnSave;
|
|
}
|
|
ownConfig.options = assign({}, extendedConfig.options, ownConfig.options);
|
|
ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ? assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) : ownConfig.watchOptions || extendedConfig.watchOptions;
|
|
}
|
|
}
|
|
return ownConfig;
|
|
}
|
|
function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
|
|
if (hasProperty(json, "excludes")) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
|
|
}
|
|
const options = convertCompilerOptionsFromJsonWorker(json.compilerOptions, basePath, errors, configFileName);
|
|
const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName);
|
|
const watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
|
|
json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
|
|
let extendedConfigPath;
|
|
if (json.extends) {
|
|
if (!isString(json.extends)) {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));
|
|
} else {
|
|
const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
|
|
extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, createCompilerDiagnostic);
|
|
}
|
|
}
|
|
return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
|
|
}
|
|
function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
|
|
const options = getDefaultCompilerOptions(configFileName);
|
|
let typeAcquisition, typingOptionstypeAcquisition;
|
|
let watchOptions;
|
|
let extendedConfigPath;
|
|
let rootCompilerOptions;
|
|
const optionsIterator = {
|
|
onSetValidOptionKeyValueInParent(parentOption, option, value) {
|
|
let currentOption;
|
|
switch (parentOption) {
|
|
case "compilerOptions":
|
|
currentOption = options;
|
|
break;
|
|
case "watchOptions":
|
|
currentOption = watchOptions || (watchOptions = {});
|
|
break;
|
|
case "typeAcquisition":
|
|
currentOption = typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName));
|
|
break;
|
|
case "typingOptions":
|
|
currentOption = typingOptionstypeAcquisition || (typingOptionstypeAcquisition = getDefaultTypeAcquisition(configFileName));
|
|
break;
|
|
default:
|
|
Debug.fail("Unknown option");
|
|
}
|
|
currentOption[option.name] = normalizeOptionValue(option, basePath, value);
|
|
},
|
|
onSetValidOptionKeyValueInRoot(key, _keyNode, value, valueNode) {
|
|
switch (key) {
|
|
case "extends":
|
|
const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
|
|
extendedConfigPath = getExtendsConfigPath(
|
|
value,
|
|
host,
|
|
newBase,
|
|
errors,
|
|
(message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0)
|
|
);
|
|
return;
|
|
}
|
|
},
|
|
onSetUnknownOptionKeyValueInRoot(key, keyNode, _value, _valueNode) {
|
|
if (key === "excludes") {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, keyNode, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
|
|
}
|
|
if (find(commandOptionsWithoutBuild, (opt) => opt.name === key)) {
|
|
rootCompilerOptions = append(rootCompilerOptions, keyNode);
|
|
}
|
|
}
|
|
};
|
|
const json = convertConfigFileToObject(sourceFile, errors, true, optionsIterator);
|
|
if (!typeAcquisition) {
|
|
if (typingOptionstypeAcquisition) {
|
|
typeAcquisition = typingOptionstypeAcquisition.enableAutoDiscovery !== void 0 ? {
|
|
enable: typingOptionstypeAcquisition.enableAutoDiscovery,
|
|
include: typingOptionstypeAcquisition.include,
|
|
exclude: typingOptionstypeAcquisition.exclude
|
|
} : typingOptionstypeAcquisition;
|
|
} else {
|
|
typeAcquisition = getDefaultTypeAcquisition(configFileName);
|
|
}
|
|
}
|
|
if (rootCompilerOptions && json && json.compilerOptions === void 0) {
|
|
errors.push(createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, getTextOfPropertyName(rootCompilerOptions[0])));
|
|
}
|
|
return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
|
|
}
|
|
function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
|
|
extendedConfig = normalizeSlashes(extendedConfig);
|
|
if (isRootedDiskPath(extendedConfig) || startsWith(extendedConfig, "./") || startsWith(extendedConfig, "../")) {
|
|
let extendedConfigPath = getNormalizedAbsolutePath(extendedConfig, basePath);
|
|
if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json" /* Json */)) {
|
|
extendedConfigPath = `${extendedConfigPath}.json`;
|
|
if (!host.fileExists(extendedConfigPath)) {
|
|
errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
|
|
return void 0;
|
|
}
|
|
}
|
|
return extendedConfigPath;
|
|
}
|
|
const resolved = nodeModuleNameResolver(extendedConfig, combinePaths(basePath, "tsconfig.json"), { moduleResolution: 2 /* NodeJs */ }, host, void 0, void 0, true);
|
|
if (resolved.resolvedModule) {
|
|
return resolved.resolvedModule.resolvedFileName;
|
|
}
|
|
errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
|
|
return void 0;
|
|
}
|
|
function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache) {
|
|
const path = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
|
|
let value;
|
|
let extendedResult;
|
|
let extendedConfig;
|
|
if (extendedConfigCache && (value = extendedConfigCache.get(path))) {
|
|
({ extendedResult, extendedConfig } = value);
|
|
} else {
|
|
extendedResult = readJsonConfigFile(extendedConfigPath, (path2) => host.readFile(path2));
|
|
if (!extendedResult.parseDiagnostics.length) {
|
|
extendedConfig = parseConfig(
|
|
void 0,
|
|
extendedResult,
|
|
host,
|
|
getDirectoryPath(extendedConfigPath),
|
|
getBaseFileName(extendedConfigPath),
|
|
resolutionStack,
|
|
errors,
|
|
extendedConfigCache
|
|
);
|
|
}
|
|
if (extendedConfigCache) {
|
|
extendedConfigCache.set(path, { extendedResult, extendedConfig });
|
|
}
|
|
}
|
|
if (sourceFile) {
|
|
sourceFile.extendedSourceFiles = [extendedResult.fileName];
|
|
if (extendedResult.extendedSourceFiles) {
|
|
sourceFile.extendedSourceFiles.push(...extendedResult.extendedSourceFiles);
|
|
}
|
|
}
|
|
if (extendedResult.parseDiagnostics.length) {
|
|
errors.push(...extendedResult.parseDiagnostics);
|
|
return void 0;
|
|
}
|
|
return extendedConfig;
|
|
}
|
|
function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) {
|
|
if (!hasProperty(jsonOption, compileOnSaveCommandLineOption.name)) {
|
|
return false;
|
|
}
|
|
const result = convertJsonOption(compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors);
|
|
return typeof result === "boolean" && result;
|
|
}
|
|
function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) {
|
|
const errors = [];
|
|
const options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);
|
|
return { options, errors };
|
|
}
|
|
function convertTypeAcquisitionFromJson(jsonOptions, basePath, configFileName) {
|
|
const errors = [];
|
|
const options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName);
|
|
return { options, errors };
|
|
}
|
|
function getDefaultCompilerOptions(configFileName) {
|
|
const options = configFileName && getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true } : {};
|
|
return options;
|
|
}
|
|
function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
|
|
const options = getDefaultCompilerOptions(configFileName);
|
|
convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, compilerOptionsDidYouMeanDiagnostics, errors);
|
|
if (configFileName) {
|
|
options.configFilePath = normalizeSlashes(configFileName);
|
|
}
|
|
return options;
|
|
}
|
|
function getDefaultTypeAcquisition(configFileName) {
|
|
return { enable: !!configFileName && getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] };
|
|
}
|
|
function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) {
|
|
const options = getDefaultTypeAcquisition(configFileName);
|
|
const typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions);
|
|
convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors);
|
|
return options;
|
|
}
|
|
function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) {
|
|
return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, void 0, watchOptionsDidYouMeanDiagnostics, errors);
|
|
}
|
|
function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) {
|
|
if (!jsonOptions) {
|
|
return;
|
|
}
|
|
for (const id in jsonOptions) {
|
|
const opt = optionsNameMap.get(id);
|
|
if (opt) {
|
|
(defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
|
|
} else {
|
|
errors.push(createUnknownOptionError(id, diagnostics, createCompilerDiagnostic));
|
|
}
|
|
}
|
|
return defaultOptions;
|
|
}
|
|
function convertJsonOption(opt, value, basePath, errors) {
|
|
if (isCompilerOptionsValue(opt, value)) {
|
|
const optType = opt.type;
|
|
if (optType === "list" && isArray(value)) {
|
|
return convertJsonOptionOfListType(opt, value, basePath, errors);
|
|
} else if (!isString(optType)) {
|
|
return convertJsonOptionOfCustomType(opt, value, errors);
|
|
}
|
|
const validatedValue = validateJsonOptionValue(opt, value, errors);
|
|
return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue);
|
|
} else {
|
|
errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
|
|
}
|
|
}
|
|
function normalizeOptionValue(option, basePath, value) {
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
if (option.type === "list") {
|
|
const listOption = option;
|
|
if (listOption.element.isFilePath || !isString(listOption.element.type)) {
|
|
return filter(map(value, (v) => normalizeOptionValue(listOption.element, basePath, v)), (v) => listOption.listPreserveFalsyValues ? true : !!v);
|
|
}
|
|
return value;
|
|
} else if (!isString(option.type)) {
|
|
return option.type.get(isString(value) ? value.toLowerCase() : value);
|
|
}
|
|
return normalizeNonListOptionValue(option, basePath, value);
|
|
}
|
|
function normalizeNonListOptionValue(option, basePath, value) {
|
|
if (option.isFilePath) {
|
|
value = getNormalizedAbsolutePath(value, basePath);
|
|
if (value === "") {
|
|
value = ".";
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function validateJsonOptionValue(opt, value, errors) {
|
|
var _a2;
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
const d = (_a2 = opt.extraValidation) == null ? void 0 : _a2.call(opt, value);
|
|
if (!d)
|
|
return value;
|
|
errors.push(createCompilerDiagnostic(...d));
|
|
return void 0;
|
|
}
|
|
function convertJsonOptionOfCustomType(opt, value, errors) {
|
|
if (isNullOrUndefined(value))
|
|
return void 0;
|
|
const key = value.toLowerCase();
|
|
const val = opt.type.get(key);
|
|
if (val !== void 0) {
|
|
return validateJsonOptionValue(opt, val, errors);
|
|
} else {
|
|
errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
|
|
}
|
|
}
|
|
function convertJsonOptionOfListType(option, values, basePath, errors) {
|
|
return filter(map(values, (v) => convertJsonOption(option.element, v, basePath, errors)), (v) => option.listPreserveFalsyValues ? true : !!v);
|
|
}
|
|
var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
|
|
var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
|
|
function getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions = emptyArray) {
|
|
basePath = normalizePath(basePath);
|
|
const keyMapper = createGetCanonicalFileName(host.useCaseSensitiveFileNames);
|
|
const literalFileMap = /* @__PURE__ */ new Map();
|
|
const wildcardFileMap = /* @__PURE__ */ new Map();
|
|
const wildCardJsonFileMap = /* @__PURE__ */ new Map();
|
|
const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = configFileSpecs;
|
|
const supportedExtensions = getSupportedExtensions(options, extraFileExtensions);
|
|
const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
|
|
if (validatedFilesSpec) {
|
|
for (const fileName of validatedFilesSpec) {
|
|
const file = getNormalizedAbsolutePath(fileName, basePath);
|
|
literalFileMap.set(keyMapper(file), file);
|
|
}
|
|
}
|
|
let jsonOnlyIncludeRegexes;
|
|
if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) {
|
|
for (const file of host.readDirectory(basePath, flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, void 0)) {
|
|
if (fileExtensionIs(file, ".json" /* Json */)) {
|
|
if (!jsonOnlyIncludeRegexes) {
|
|
const includes = validatedIncludeSpecs.filter((s) => endsWith(s, ".json" /* Json */));
|
|
const includeFilePatterns = map(getRegularExpressionsForWildcards(includes, basePath, "files"), (pattern) => `^${pattern}$`);
|
|
jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map((pattern) => getRegexFromPattern(pattern, host.useCaseSensitiveFileNames)) : emptyArray;
|
|
}
|
|
const includeIndex = findIndex(jsonOnlyIncludeRegexes, (re) => re.test(file));
|
|
if (includeIndex !== -1) {
|
|
const key2 = keyMapper(file);
|
|
if (!literalFileMap.has(key2) && !wildCardJsonFileMap.has(key2)) {
|
|
wildCardJsonFileMap.set(key2, file);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) {
|
|
continue;
|
|
}
|
|
removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper);
|
|
const key = keyMapper(file);
|
|
if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) {
|
|
wildcardFileMap.set(key, file);
|
|
}
|
|
}
|
|
}
|
|
const literalFiles = arrayFrom(literalFileMap.values());
|
|
const wildcardFiles = arrayFrom(wildcardFileMap.values());
|
|
return literalFiles.concat(wildcardFiles, arrayFrom(wildCardJsonFileMap.values()));
|
|
}
|
|
function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames, currentDirectory) {
|
|
const { validatedFilesSpec, validatedIncludeSpecs, validatedExcludeSpecs } = spec;
|
|
if (!length(validatedIncludeSpecs) || !length(validatedExcludeSpecs))
|
|
return false;
|
|
basePath = normalizePath(basePath);
|
|
const keyMapper = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
if (validatedFilesSpec) {
|
|
for (const fileName of validatedFilesSpec) {
|
|
if (keyMapper(getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck)
|
|
return false;
|
|
}
|
|
}
|
|
return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath);
|
|
}
|
|
function invalidDotDotAfterRecursiveWildcard(s) {
|
|
const wildcardIndex = startsWith(s, "**/") ? 0 : s.indexOf("/**/");
|
|
if (wildcardIndex === -1) {
|
|
return false;
|
|
}
|
|
const lastDotIndex = endsWith(s, "/..") ? s.length : s.lastIndexOf("/../");
|
|
return lastDotIndex > wildcardIndex;
|
|
}
|
|
function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory) {
|
|
return matchesExcludeWorker(
|
|
pathToCheck,
|
|
filter(excludeSpecs, (spec) => !invalidDotDotAfterRecursiveWildcard(spec)),
|
|
useCaseSensitiveFileNames,
|
|
currentDirectory
|
|
);
|
|
}
|
|
function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath) {
|
|
const excludePattern = getRegularExpressionForWildcard(excludeSpecs, combinePaths(normalizePath(currentDirectory), basePath), "exclude");
|
|
const excludeRegex = excludePattern && getRegexFromPattern(excludePattern, useCaseSensitiveFileNames);
|
|
if (!excludeRegex)
|
|
return false;
|
|
if (excludeRegex.test(pathToCheck))
|
|
return true;
|
|
return !hasExtension(pathToCheck) && excludeRegex.test(ensureTrailingDirectorySeparator(pathToCheck));
|
|
}
|
|
function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile, specKey) {
|
|
return specs.filter((spec) => {
|
|
if (!isString(spec))
|
|
return false;
|
|
const diag2 = specToDiagnostic(spec, disallowTrailingRecursion);
|
|
if (diag2 !== void 0) {
|
|
errors.push(createDiagnostic(...diag2));
|
|
}
|
|
return diag2 === void 0;
|
|
});
|
|
function createDiagnostic(message, spec) {
|
|
const element = getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
|
|
return element ? createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : createCompilerDiagnostic(message, spec);
|
|
}
|
|
}
|
|
function specToDiagnostic(spec, disallowTrailingRecursion) {
|
|
if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) {
|
|
return [Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
|
|
} else if (invalidDotDotAfterRecursiveWildcard(spec)) {
|
|
return [Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec];
|
|
}
|
|
}
|
|
function getWildcardDirectories({ validatedIncludeSpecs: include, validatedExcludeSpecs: exclude }, path, useCaseSensitiveFileNames) {
|
|
const rawExcludeRegex = getRegularExpressionForWildcard(exclude, path, "exclude");
|
|
const excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i");
|
|
const wildcardDirectories = {};
|
|
if (include !== void 0) {
|
|
const recursiveKeys = [];
|
|
for (const file of include) {
|
|
const spec = normalizePath(combinePaths(path, file));
|
|
if (excludeRegex && excludeRegex.test(spec)) {
|
|
continue;
|
|
}
|
|
const match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames);
|
|
if (match) {
|
|
const { key, flags } = match;
|
|
const existingFlags = wildcardDirectories[key];
|
|
if (existingFlags === void 0 || existingFlags < flags) {
|
|
wildcardDirectories[key] = flags;
|
|
if (flags === 1 /* Recursive */) {
|
|
recursiveKeys.push(key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (const key in wildcardDirectories) {
|
|
if (hasProperty(wildcardDirectories, key)) {
|
|
for (const recursiveKey of recursiveKeys) {
|
|
if (key !== recursiveKey && containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) {
|
|
delete wildcardDirectories[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return wildcardDirectories;
|
|
}
|
|
function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) {
|
|
const match = wildcardDirectoryPattern.exec(spec);
|
|
if (match) {
|
|
const questionWildcardIndex = spec.indexOf("?");
|
|
const starWildcardIndex = spec.indexOf("*");
|
|
const lastDirectorySeperatorIndex = spec.lastIndexOf(directorySeparator);
|
|
return {
|
|
key: useCaseSensitiveFileNames ? match[0] : toFileNameLowerCase(match[0]),
|
|
flags: questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex || starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex ? 1 /* Recursive */ : 0 /* None */
|
|
};
|
|
}
|
|
if (isImplicitGlob(spec.substring(spec.lastIndexOf(directorySeparator) + 1))) {
|
|
return {
|
|
key: removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : toFileNameLowerCase(spec)),
|
|
flags: 1 /* Recursive */
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) {
|
|
const extensionGroup = forEach(extensions, (group2) => fileExtensionIsOneOf(file, group2) ? group2 : void 0);
|
|
if (!extensionGroup) {
|
|
return false;
|
|
}
|
|
for (const ext of extensionGroup) {
|
|
if (fileExtensionIs(file, ext)) {
|
|
return false;
|
|
}
|
|
const higherPriorityPath = keyMapper(changeExtension(file, ext));
|
|
if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) {
|
|
if (ext === ".d.ts" /* Dts */ && (fileExtensionIs(file, ".js" /* Js */) || fileExtensionIs(file, ".jsx" /* Jsx */))) {
|
|
continue;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) {
|
|
const extensionGroup = forEach(extensions, (group2) => fileExtensionIsOneOf(file, group2) ? group2 : void 0);
|
|
if (!extensionGroup) {
|
|
return;
|
|
}
|
|
for (let i = extensionGroup.length - 1; i >= 0; i--) {
|
|
const ext = extensionGroup[i];
|
|
if (fileExtensionIs(file, ext)) {
|
|
return;
|
|
}
|
|
const lowerPriorityPath = keyMapper(changeExtension(file, ext));
|
|
wildcardFiles.delete(lowerPriorityPath);
|
|
}
|
|
}
|
|
function convertCompilerOptionsForTelemetry(opts) {
|
|
const out = {};
|
|
for (const key in opts) {
|
|
if (hasProperty(opts, key)) {
|
|
const type = getOptionFromName(key);
|
|
if (type !== void 0) {
|
|
out[key] = getOptionValueWithEmptyStrings(opts[key], type);
|
|
}
|
|
}
|
|
}
|
|
return out;
|
|
}
|
|
function getOptionValueWithEmptyStrings(value, option) {
|
|
switch (option.type) {
|
|
case "object":
|
|
return "";
|
|
case "string":
|
|
return "";
|
|
case "number":
|
|
return typeof value === "number" ? value : "";
|
|
case "boolean":
|
|
return typeof value === "boolean" ? value : "";
|
|
case "list":
|
|
const elementType = option.element;
|
|
return isArray(value) ? value.map((v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
|
|
default:
|
|
return forEachEntry(option.type, (optionEnumValue, optionStringValue) => {
|
|
if (optionEnumValue === value) {
|
|
return optionStringValue;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function getDefaultValueForOption(option) {
|
|
switch (option.type) {
|
|
case "number":
|
|
return 1;
|
|
case "boolean":
|
|
return true;
|
|
case "string":
|
|
const defaultValue = option.defaultValueDescription;
|
|
return option.isFilePath ? `./${defaultValue && typeof defaultValue === "string" ? defaultValue : ""}` : "";
|
|
case "list":
|
|
return [];
|
|
case "object":
|
|
return {};
|
|
default:
|
|
const iterResult = option.type.keys().next();
|
|
if (!iterResult.done)
|
|
return iterResult.value;
|
|
return Debug.fail("Expected 'option.type' to have entries.");
|
|
}
|
|
}
|
|
|
|
// src/compiler/moduleNameResolver.ts
|
|
function trace(host) {
|
|
host.trace(formatMessage.apply(void 0, arguments));
|
|
}
|
|
function isTraceEnabled(compilerOptions, host) {
|
|
return !!compilerOptions.traceResolution && host.trace !== void 0;
|
|
}
|
|
function withPackageId(packageInfo, r) {
|
|
let packageId;
|
|
if (r && packageInfo) {
|
|
const packageJsonContent = packageInfo.contents.packageJsonContent;
|
|
if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") {
|
|
packageId = {
|
|
name: packageJsonContent.name,
|
|
subModuleName: r.path.slice(packageInfo.packageDirectory.length + directorySeparator.length),
|
|
version: packageJsonContent.version
|
|
};
|
|
}
|
|
}
|
|
return r && { path: r.path, extension: r.ext, packageId };
|
|
}
|
|
function noPackageId(r) {
|
|
return withPackageId(void 0, r);
|
|
}
|
|
function removeIgnoredPackageId(r) {
|
|
if (r) {
|
|
Debug.assert(r.packageId === void 0);
|
|
return { path: r.path, ext: r.extension };
|
|
}
|
|
}
|
|
function formatExtensions(extensions) {
|
|
const result = [];
|
|
if (extensions & 1 /* TypeScript */)
|
|
result.push("TypeScript");
|
|
if (extensions & 2 /* JavaScript */)
|
|
result.push("JavaScript");
|
|
if (extensions & 4 /* Declaration */)
|
|
result.push("Declaration");
|
|
if (extensions & 8 /* Json */)
|
|
result.push("JSON");
|
|
return result.join(", ");
|
|
}
|
|
function resolvedTypeScriptOnly(resolved) {
|
|
if (!resolved) {
|
|
return void 0;
|
|
}
|
|
Debug.assert(extensionIsTS(resolved.extension));
|
|
return { fileName: resolved.path, packageId: resolved.packageId };
|
|
}
|
|
function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) {
|
|
if (resultFromCache) {
|
|
resultFromCache.failedLookupLocations.push(...failedLookupLocations);
|
|
resultFromCache.affectingLocations.push(...affectingLocations);
|
|
return resultFromCache;
|
|
}
|
|
return {
|
|
resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? void 0 : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport, packageId: resolved.packageId },
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
resolutionDiagnostics: diagnostics
|
|
};
|
|
}
|
|
function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) {
|
|
if (!hasProperty(jsonContent, fieldName)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_does_not_have_a_0_field, fieldName);
|
|
}
|
|
return;
|
|
}
|
|
const value = jsonContent[fieldName];
|
|
if (typeof value !== typeOfTag || value === null) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value);
|
|
}
|
|
return;
|
|
}
|
|
return value;
|
|
}
|
|
function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) {
|
|
const fileName = readPackageJsonField(jsonContent, fieldName, "string", state);
|
|
if (fileName === void 0) {
|
|
return;
|
|
}
|
|
if (!fileName) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_had_a_falsy_0_field, fieldName);
|
|
}
|
|
return;
|
|
}
|
|
const path = normalizePath(combinePaths(baseDirectory, fileName));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path);
|
|
}
|
|
return path;
|
|
}
|
|
function readPackageJsonTypesFields(jsonContent, baseDirectory, state) {
|
|
return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) || readPackageJsonPathField(jsonContent, "types", baseDirectory, state);
|
|
}
|
|
function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) {
|
|
return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state);
|
|
}
|
|
function readPackageJsonMainField(jsonContent, baseDirectory, state) {
|
|
return readPackageJsonPathField(jsonContent, "main", baseDirectory, state);
|
|
}
|
|
function readPackageJsonTypesVersionsField(jsonContent, state) {
|
|
const typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state);
|
|
if (typesVersions === void 0)
|
|
return;
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings);
|
|
}
|
|
return typesVersions;
|
|
}
|
|
function readPackageJsonTypesVersionPaths(jsonContent, state) {
|
|
const typesVersions = readPackageJsonTypesVersionsField(jsonContent, state);
|
|
if (typesVersions === void 0)
|
|
return;
|
|
if (state.traceEnabled) {
|
|
for (const key in typesVersions) {
|
|
if (hasProperty(typesVersions, key) && !VersionRange.tryParse(key)) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key);
|
|
}
|
|
}
|
|
}
|
|
const result = getPackageJsonTypesVersionsPaths(typesVersions);
|
|
if (!result) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, versionMajorMinor);
|
|
}
|
|
return;
|
|
}
|
|
const { version: bestVersionKey, paths: bestVersionPaths } = result;
|
|
if (typeof bestVersionPaths !== "object") {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, `typesVersions['${bestVersionKey}']`, "object", typeof bestVersionPaths);
|
|
}
|
|
return;
|
|
}
|
|
return result;
|
|
}
|
|
var typeScriptVersion;
|
|
function getPackageJsonTypesVersionsPaths(typesVersions) {
|
|
if (!typeScriptVersion)
|
|
typeScriptVersion = new Version(version);
|
|
for (const key in typesVersions) {
|
|
if (!hasProperty(typesVersions, key))
|
|
continue;
|
|
const keyRange = VersionRange.tryParse(key);
|
|
if (keyRange === void 0) {
|
|
continue;
|
|
}
|
|
if (keyRange.test(typeScriptVersion)) {
|
|
return { version: key, paths: typesVersions[key] };
|
|
}
|
|
}
|
|
}
|
|
function getEffectiveTypeRoots(options, host) {
|
|
if (options.typeRoots) {
|
|
return options.typeRoots;
|
|
}
|
|
let currentDirectory;
|
|
if (options.configFilePath) {
|
|
currentDirectory = getDirectoryPath(options.configFilePath);
|
|
} else if (host.getCurrentDirectory) {
|
|
currentDirectory = host.getCurrentDirectory();
|
|
}
|
|
if (currentDirectory !== void 0) {
|
|
return getDefaultTypeRoots(currentDirectory, host);
|
|
}
|
|
}
|
|
function getDefaultTypeRoots(currentDirectory, host) {
|
|
if (!host.directoryExists) {
|
|
return [combinePaths(currentDirectory, nodeModulesAtTypes)];
|
|
}
|
|
let typeRoots;
|
|
forEachAncestorDirectory(normalizePath(currentDirectory), (directory) => {
|
|
const atTypes = combinePaths(directory, nodeModulesAtTypes);
|
|
if (host.directoryExists(atTypes)) {
|
|
(typeRoots || (typeRoots = [])).push(atTypes);
|
|
}
|
|
return void 0;
|
|
});
|
|
return typeRoots;
|
|
}
|
|
var nodeModulesAtTypes = combinePaths("node_modules", "@types");
|
|
function arePathsEqual(path1, path2, host) {
|
|
const useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames;
|
|
return comparePaths(path1, path2, !useCaseSensitiveFileNames) === 0 /* EqualTo */;
|
|
}
|
|
function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
|
|
Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
|
|
const traceEnabled = isTraceEnabled(options, host);
|
|
if (redirectedReference) {
|
|
options = redirectedReference.commandLine.options;
|
|
}
|
|
const containingDirectory = containingFile ? getDirectoryPath(containingFile) : void 0;
|
|
const perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : void 0;
|
|
let result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, resolutionMode);
|
|
if (result) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile);
|
|
if (redirectedReference)
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
trace(host, Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory);
|
|
traceResult(result);
|
|
}
|
|
return result;
|
|
}
|
|
const typeRoots = getEffectiveTypeRoots(options, host);
|
|
if (traceEnabled) {
|
|
if (containingFile === void 0) {
|
|
if (typeRoots === void 0) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
|
|
} else {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
|
|
}
|
|
} else {
|
|
if (typeRoots === void 0) {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
|
|
} else {
|
|
trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
|
|
}
|
|
}
|
|
if (redirectedReference) {
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
}
|
|
}
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
let features = getDefaultNodeResolutionFeatures(options);
|
|
if (resolutionMode === 99 /* ESNext */ && (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */)) {
|
|
features |= NodeResolutionFeatures.EsmMode;
|
|
}
|
|
const conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : [];
|
|
const diagnostics = [];
|
|
const moduleResolutionState = {
|
|
compilerOptions: options,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features,
|
|
conditions,
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
let resolved = primaryLookup();
|
|
let primary = true;
|
|
if (!resolved) {
|
|
resolved = secondaryLookup();
|
|
primary = false;
|
|
}
|
|
let resolvedTypeReferenceDirective;
|
|
if (resolved) {
|
|
const { fileName, packageId } = resolved;
|
|
const resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
|
|
const pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);
|
|
resolvedTypeReferenceDirective = {
|
|
primary,
|
|
resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,
|
|
originalPath: pathsAreEqual ? void 0 : fileName,
|
|
packageId,
|
|
isExternalLibraryImport: pathContainsNodeModules(fileName)
|
|
};
|
|
}
|
|
result = { resolvedTypeReferenceDirective, failedLookupLocations, affectingLocations, resolutionDiagnostics: diagnostics };
|
|
perFolderCache == null ? void 0 : perFolderCache.set(typeReferenceDirectiveName, resolutionMode, result);
|
|
if (traceEnabled)
|
|
traceResult(result);
|
|
return result;
|
|
function traceResult(result2) {
|
|
var _a2;
|
|
if (!((_a2 = result2.resolvedTypeReferenceDirective) == null ? void 0 : _a2.resolvedFileName)) {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName);
|
|
} else if (result2.resolvedTypeReferenceDirective.packageId) {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result2.resolvedTypeReferenceDirective.resolvedFileName, packageIdToString(result2.resolvedTypeReferenceDirective.packageId), result2.resolvedTypeReferenceDirective.primary);
|
|
} else {
|
|
trace(host, Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result2.resolvedTypeReferenceDirective.resolvedFileName, result2.resolvedTypeReferenceDirective.primary);
|
|
}
|
|
}
|
|
function primaryLookup() {
|
|
if (typeRoots && typeRoots.length) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
|
|
}
|
|
return firstDefined(typeRoots, (typeRoot) => {
|
|
const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
|
|
const candidateDirectory = getDirectoryPath(candidate);
|
|
const directoryExists = directoryProbablyExists(candidateDirectory, host);
|
|
if (!directoryExists && traceEnabled) {
|
|
trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory);
|
|
}
|
|
return resolvedTypeScriptOnly(
|
|
loadNodeModuleFromDirectory(
|
|
4 /* Declaration */,
|
|
candidate,
|
|
!directoryExists,
|
|
moduleResolutionState
|
|
)
|
|
);
|
|
});
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths);
|
|
}
|
|
}
|
|
}
|
|
function secondaryLookup() {
|
|
const initialLocationForSecondaryLookup = containingFile && getDirectoryPath(containingFile);
|
|
if (initialLocationForSecondaryLookup !== void 0) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup);
|
|
}
|
|
let result2;
|
|
if (!isExternalModuleNameRelative(typeReferenceDirectiveName)) {
|
|
const searchResult = loadModuleFromNearestNodeModulesDirectory(4 /* Declaration */, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, void 0, void 0);
|
|
result2 = searchResult && searchResult.value;
|
|
} else {
|
|
const { path: candidate } = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName);
|
|
result2 = nodeLoadModuleByRelativeName(4 /* Declaration */, candidate, false, moduleResolutionState, true);
|
|
}
|
|
return resolvedTypeScriptOnly(result2);
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getDefaultNodeResolutionFeatures(options) {
|
|
return getEmitModuleResolutionKind(options) === 3 /* Node16 */ ? NodeResolutionFeatures.Node16Default : getEmitModuleResolutionKind(options) === 99 /* NodeNext */ ? NodeResolutionFeatures.NodeNextDefault : NodeResolutionFeatures.None;
|
|
}
|
|
function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
|
|
const moduleResolutionState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options);
|
|
return forEachAncestorDirectory(containingDirectory, (ancestorDirectory) => {
|
|
if (getBaseFileName(ancestorDirectory) !== "node_modules") {
|
|
const nodeModulesFolder = combinePaths(ancestorDirectory, "node_modules");
|
|
const candidate = combinePaths(nodeModulesFolder, packageName);
|
|
return getPackageJsonInfo(candidate, false, moduleResolutionState);
|
|
}
|
|
});
|
|
}
|
|
function getAutomaticTypeDirectiveNames(options, host) {
|
|
if (options.types) {
|
|
return options.types;
|
|
}
|
|
const result = [];
|
|
if (host.directoryExists && host.getDirectories) {
|
|
const typeRoots = getEffectiveTypeRoots(options, host);
|
|
if (typeRoots) {
|
|
for (const root of typeRoots) {
|
|
if (host.directoryExists(root)) {
|
|
for (const typeDirectivePath of host.getDirectories(root)) {
|
|
const normalized = normalizePath(typeDirectivePath);
|
|
const packageJsonPath = combinePaths(root, normalized, "package.json");
|
|
const isNotNeededPackage = host.fileExists(packageJsonPath) && readJson(packageJsonPath, host).typings === null;
|
|
if (!isNotNeededPackage) {
|
|
const baseFileName = getBaseFileName(normalized);
|
|
if (baseFileName.charCodeAt(0) !== 46 /* dot */) {
|
|
result.push(baseFileName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function createCacheWithRedirects(options) {
|
|
let ownMap = /* @__PURE__ */ new Map();
|
|
const redirectsMap = /* @__PURE__ */ new Map();
|
|
return {
|
|
getOwnMap,
|
|
redirectsMap,
|
|
getOrCreateMapOfCacheRedirects,
|
|
clear: clear2,
|
|
setOwnOptions,
|
|
setOwnMap
|
|
};
|
|
function getOwnMap() {
|
|
return ownMap;
|
|
}
|
|
function setOwnOptions(newOptions) {
|
|
options = newOptions;
|
|
}
|
|
function setOwnMap(newOwnMap) {
|
|
ownMap = newOwnMap;
|
|
}
|
|
function getOrCreateMapOfCacheRedirects(redirectedReference) {
|
|
if (!redirectedReference) {
|
|
return ownMap;
|
|
}
|
|
const path = redirectedReference.sourceFile.path;
|
|
let redirects = redirectsMap.get(path);
|
|
if (!redirects) {
|
|
redirects = !options || optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? /* @__PURE__ */ new Map() : ownMap;
|
|
redirectsMap.set(path, redirects);
|
|
}
|
|
return redirects;
|
|
}
|
|
function clear2() {
|
|
ownMap.clear();
|
|
redirectsMap.clear();
|
|
}
|
|
}
|
|
function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) {
|
|
let cache;
|
|
return { getPackageJsonInfo: getPackageJsonInfo2, setPackageJsonInfo, clear: clear2, entries, getInternalMap };
|
|
function getPackageJsonInfo2(packageJsonPath) {
|
|
return cache == null ? void 0 : cache.get(toPath(packageJsonPath, currentDirectory, getCanonicalFileName));
|
|
}
|
|
function setPackageJsonInfo(packageJsonPath, info) {
|
|
(cache || (cache = /* @__PURE__ */ new Map())).set(toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info);
|
|
}
|
|
function clear2() {
|
|
cache = void 0;
|
|
}
|
|
function entries() {
|
|
const iter = cache == null ? void 0 : cache.entries();
|
|
return iter ? arrayFrom(iter) : [];
|
|
}
|
|
function getInternalMap() {
|
|
return cache;
|
|
}
|
|
}
|
|
function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) {
|
|
const cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
|
|
let result = cache.get(key);
|
|
if (!result) {
|
|
result = create();
|
|
cache.set(key, result);
|
|
}
|
|
return result;
|
|
}
|
|
function updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
|
|
if (!options.configFile)
|
|
return;
|
|
if (directoryToModuleNameMap.redirectsMap.size === 0) {
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size === 0);
|
|
Debug.assert(directoryToModuleNameMap.getOwnMap().size === 0);
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.getOwnMap().size === 0);
|
|
directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.getOwnMap());
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.getOwnMap());
|
|
} else {
|
|
Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size > 0);
|
|
const ref = {
|
|
sourceFile: options.configFile,
|
|
commandLine: { options }
|
|
};
|
|
directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref));
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref));
|
|
}
|
|
directoryToModuleNameMap.setOwnOptions(options);
|
|
moduleNameToDirectoryMap == null ? void 0 : moduleNameToDirectoryMap.setOwnOptions(options);
|
|
}
|
|
function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) {
|
|
return {
|
|
getOrCreateCacheForDirectory,
|
|
clear: clear2,
|
|
update
|
|
};
|
|
function clear2() {
|
|
directoryToModuleNameMap.clear();
|
|
}
|
|
function update(options) {
|
|
updateRedirectsMap(options, directoryToModuleNameMap);
|
|
}
|
|
function getOrCreateCacheForDirectory(directoryName, redirectedReference) {
|
|
const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
|
|
return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, () => createModeAwareCache());
|
|
}
|
|
}
|
|
function createModeAwareCache() {
|
|
const underlying = /* @__PURE__ */ new Map();
|
|
const memoizedReverseKeys = /* @__PURE__ */ new Map();
|
|
const cache = {
|
|
get(specifier, mode) {
|
|
return underlying.get(getUnderlyingCacheKey(specifier, mode));
|
|
},
|
|
set(specifier, mode, value) {
|
|
underlying.set(getUnderlyingCacheKey(specifier, mode), value);
|
|
return cache;
|
|
},
|
|
delete(specifier, mode) {
|
|
underlying.delete(getUnderlyingCacheKey(specifier, mode));
|
|
return cache;
|
|
},
|
|
has(specifier, mode) {
|
|
return underlying.has(getUnderlyingCacheKey(specifier, mode));
|
|
},
|
|
forEach(cb) {
|
|
return underlying.forEach((elem, key) => {
|
|
const [specifier, mode] = memoizedReverseKeys.get(key);
|
|
return cb(elem, specifier, mode);
|
|
});
|
|
},
|
|
size() {
|
|
return underlying.size;
|
|
}
|
|
};
|
|
return cache;
|
|
function getUnderlyingCacheKey(specifier, mode) {
|
|
const result = mode === void 0 ? specifier : `${mode}|${specifier}`;
|
|
memoizedReverseKeys.set(result, [specifier, mode]);
|
|
return result;
|
|
}
|
|
}
|
|
function getResolutionName(entry) {
|
|
return !isString(entry) ? isStringLiteralLike(entry) ? entry.text : toFileNameLowerCase(entry.fileName) : entry;
|
|
}
|
|
function getResolutionMode(entry, file) {
|
|
return isStringLiteralLike(entry) ? getModeForUsageLocation(file, entry) : entry.resolutionMode || file.impliedNodeFormat;
|
|
}
|
|
function zipToModeAwareCache(file, keys, values) {
|
|
Debug.assert(keys.length === values.length);
|
|
const map2 = createModeAwareCache();
|
|
for (let i = 0; i < keys.length; ++i) {
|
|
const entry = keys[i];
|
|
map2.set(getResolutionName(entry), getResolutionMode(entry, file), values[i]);
|
|
}
|
|
return map2;
|
|
}
|
|
function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) {
|
|
const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
|
|
moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options));
|
|
const packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName);
|
|
return {
|
|
...packageJsonInfoCache,
|
|
...perDirectoryResolutionCache,
|
|
getOrCreateCacheForModuleName,
|
|
clear: clear2,
|
|
update,
|
|
getPackageJsonInfoCache: () => packageJsonInfoCache,
|
|
clearAllExceptPackageJsonInfoCache
|
|
};
|
|
function clear2() {
|
|
clearAllExceptPackageJsonInfoCache();
|
|
packageJsonInfoCache.clear();
|
|
}
|
|
function clearAllExceptPackageJsonInfoCache() {
|
|
perDirectoryResolutionCache.clear();
|
|
moduleNameToDirectoryMap.clear();
|
|
}
|
|
function update(options2) {
|
|
updateRedirectsMap(options2, directoryToModuleNameMap, moduleNameToDirectoryMap);
|
|
}
|
|
function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) {
|
|
Debug.assert(!isExternalModuleNameRelative(nonRelativeModuleName));
|
|
return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === void 0 ? nonRelativeModuleName : `${mode}|${nonRelativeModuleName}`, createPerModuleNameCache);
|
|
}
|
|
function createPerModuleNameCache() {
|
|
const directoryPathMap = /* @__PURE__ */ new Map();
|
|
return { get, set };
|
|
function get(directory) {
|
|
return directoryPathMap.get(toPath(directory, currentDirectory, getCanonicalFileName));
|
|
}
|
|
function set(directory, result) {
|
|
const path = toPath(directory, currentDirectory, getCanonicalFileName);
|
|
if (directoryPathMap.has(path)) {
|
|
return;
|
|
}
|
|
directoryPathMap.set(path, result);
|
|
const resolvedFileName = result.resolvedModule && (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName);
|
|
const commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName);
|
|
let current = path;
|
|
while (current !== commonPrefix) {
|
|
const parent2 = getDirectoryPath(current);
|
|
if (parent2 === current || directoryPathMap.has(parent2)) {
|
|
break;
|
|
}
|
|
directoryPathMap.set(parent2, result);
|
|
current = parent2;
|
|
}
|
|
}
|
|
function getCommonPrefix(directory, resolution) {
|
|
const resolutionDirectory = toPath(getDirectoryPath(resolution), currentDirectory, getCanonicalFileName);
|
|
let i = 0;
|
|
const limit = Math.min(directory.length, resolutionDirectory.length);
|
|
while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) {
|
|
i++;
|
|
}
|
|
if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === directorySeparator)) {
|
|
return directory;
|
|
}
|
|
const rootLength = getRootLength(directory);
|
|
if (i < rootLength) {
|
|
return void 0;
|
|
}
|
|
const sep = directory.lastIndexOf(directorySeparator, i - 1);
|
|
if (sep === -1) {
|
|
return void 0;
|
|
}
|
|
return directory.substr(0, Math.max(sep, rootLength));
|
|
}
|
|
}
|
|
}
|
|
function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) {
|
|
const perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options)));
|
|
packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName));
|
|
return {
|
|
...packageJsonInfoCache,
|
|
...perDirectoryResolutionCache,
|
|
clear: clear2,
|
|
clearAllExceptPackageJsonInfoCache
|
|
};
|
|
function clear2() {
|
|
clearAllExceptPackageJsonInfoCache();
|
|
packageJsonInfoCache.clear();
|
|
}
|
|
function clearAllExceptPackageJsonInfoCache() {
|
|
perDirectoryResolutionCache.clear();
|
|
}
|
|
}
|
|
function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) {
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory);
|
|
if (!perFolderCache)
|
|
return void 0;
|
|
return perFolderCache.get(moduleName, mode);
|
|
}
|
|
function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
if (redirectedReference) {
|
|
compilerOptions = redirectedReference.commandLine.options;
|
|
}
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_module_0_from_1, moduleName, containingFile);
|
|
if (redirectedReference) {
|
|
trace(host, Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName);
|
|
}
|
|
}
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference);
|
|
let result = perFolderCache && perFolderCache.get(moduleName, resolutionMode);
|
|
if (result) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
|
|
}
|
|
} else {
|
|
let moduleResolution = compilerOptions.moduleResolution;
|
|
if (moduleResolution === void 0) {
|
|
switch (getEmitModuleKind(compilerOptions)) {
|
|
case 1 /* CommonJS */:
|
|
moduleResolution = 2 /* NodeJs */;
|
|
break;
|
|
case 100 /* Node16 */:
|
|
moduleResolution = 3 /* Node16 */;
|
|
break;
|
|
case 199 /* NodeNext */:
|
|
moduleResolution = 99 /* NodeNext */;
|
|
break;
|
|
default:
|
|
moduleResolution = 1 /* Classic */;
|
|
break;
|
|
}
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Module_resolution_kind_is_not_specified_using_0, ModuleResolutionKind[moduleResolution]);
|
|
}
|
|
} else {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ModuleResolutionKind[moduleResolution]);
|
|
}
|
|
}
|
|
perfLogger.logStartResolveModule(moduleName);
|
|
switch (moduleResolution) {
|
|
case 3 /* Node16 */:
|
|
result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
|
|
break;
|
|
case 99 /* NodeNext */:
|
|
result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode);
|
|
break;
|
|
case 2 /* NodeJs */:
|
|
result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
|
|
break;
|
|
case 1 /* Classic */:
|
|
result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference);
|
|
break;
|
|
default:
|
|
return Debug.fail(`Unexpected moduleResolution: ${moduleResolution}`);
|
|
}
|
|
if (result && result.resolvedModule)
|
|
perfLogger.logInfoEvent(`Module "${moduleName}" resolved to "${result.resolvedModule.resolvedFileName}"`);
|
|
perfLogger.logStopResolveModule(result && result.resolvedModule ? "" + result.resolvedModule.resolvedFileName : "null");
|
|
if (perFolderCache) {
|
|
perFolderCache.set(moduleName, resolutionMode, result);
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result);
|
|
}
|
|
}
|
|
}
|
|
if (traceEnabled) {
|
|
if (result.resolvedModule) {
|
|
if (result.resolvedModule.packageId) {
|
|
trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, packageIdToString(result.resolvedModule.packageId));
|
|
} else {
|
|
trace(host, Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName);
|
|
}
|
|
} else {
|
|
trace(host, Diagnostics.Module_name_0_was_not_resolved, moduleName);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) {
|
|
const resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state);
|
|
if (resolved)
|
|
return resolved.value;
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state);
|
|
} else {
|
|
return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state);
|
|
}
|
|
}
|
|
function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) {
|
|
var _a2;
|
|
const { baseUrl, paths, configFile } = state.compilerOptions;
|
|
if (paths && !pathIsRelative(moduleName)) {
|
|
if (state.traceEnabled) {
|
|
if (baseUrl) {
|
|
trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
|
|
}
|
|
trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
|
|
}
|
|
const baseDirectory = getPathsBasePath(state.compilerOptions, state.host);
|
|
const pathPatterns = (configFile == null ? void 0 : configFile.configFileSpecs) ? (_a2 = configFile.configFileSpecs).pathPatterns || (_a2.pathPatterns = tryParsePatterns(paths)) : void 0;
|
|
return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, false, state);
|
|
}
|
|
}
|
|
function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) {
|
|
if (!state.compilerOptions.rootDirs) {
|
|
return void 0;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName);
|
|
}
|
|
const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
|
|
let matchedRootDir;
|
|
let matchedNormalizedPrefix;
|
|
for (const rootDir of state.compilerOptions.rootDirs) {
|
|
let normalizedRoot = normalizePath(rootDir);
|
|
if (!endsWith(normalizedRoot, directorySeparator)) {
|
|
normalizedRoot += directorySeparator;
|
|
}
|
|
const isLongestMatchingPrefix = startsWith(candidate, normalizedRoot) && (matchedNormalizedPrefix === void 0 || matchedNormalizedPrefix.length < normalizedRoot.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix);
|
|
}
|
|
if (isLongestMatchingPrefix) {
|
|
matchedNormalizedPrefix = normalizedRoot;
|
|
matchedRootDir = rootDir;
|
|
}
|
|
}
|
|
if (matchedNormalizedPrefix) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix);
|
|
}
|
|
const suffix = candidate.substr(matchedNormalizedPrefix.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate);
|
|
}
|
|
const resolvedFileName = loader(extensions, candidate, !directoryProbablyExists(containingDirectory, state.host), state);
|
|
if (resolvedFileName) {
|
|
return resolvedFileName;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Trying_other_entries_in_rootDirs);
|
|
}
|
|
for (const rootDir of state.compilerOptions.rootDirs) {
|
|
if (rootDir === matchedRootDir) {
|
|
continue;
|
|
}
|
|
const candidate2 = combinePaths(normalizePath(rootDir), suffix);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate2);
|
|
}
|
|
const baseDirectory = getDirectoryPath(candidate2);
|
|
const resolvedFileName2 = loader(extensions, candidate2, !directoryProbablyExists(baseDirectory, state.host), state);
|
|
if (resolvedFileName2) {
|
|
return resolvedFileName2;
|
|
}
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Module_resolution_using_rootDirs_has_failed);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) {
|
|
const { baseUrl } = state.compilerOptions;
|
|
if (!baseUrl) {
|
|
return void 0;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName);
|
|
}
|
|
const candidate = normalizePath(combinePaths(baseUrl, moduleName));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate);
|
|
}
|
|
return loader(extensions, candidate, !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
|
|
}
|
|
function resolveJSModule(moduleName, initialDir, host) {
|
|
const { resolvedModule, failedLookupLocations } = tryResolveJSModuleWorker(moduleName, initialDir, host);
|
|
if (!resolvedModule) {
|
|
throw new Error(`Could not resolve JS module '${moduleName}' starting at '${initialDir}'. Looked in: ${failedLookupLocations.join(", ")}`);
|
|
}
|
|
return resolvedModule.resolvedFileName;
|
|
}
|
|
var NodeResolutionFeatures = /* @__PURE__ */ ((NodeResolutionFeatures2) => {
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["None"] = 0] = "None";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Imports"] = 2] = "Imports";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["SelfName"] = 4] = "SelfName";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Exports"] = 8] = "Exports";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["AllFeatures"] = 30] = "AllFeatures";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["Node16Default"] = 30] = "Node16Default";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["NodeNextDefault"] = 30 /* AllFeatures */] = "NodeNextDefault";
|
|
NodeResolutionFeatures2[NodeResolutionFeatures2["EsmMode"] = 32] = "EsmMode";
|
|
return NodeResolutionFeatures2;
|
|
})(NodeResolutionFeatures || {});
|
|
function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
return nodeNextModuleNameResolverWorker(
|
|
30 /* Node16Default */,
|
|
moduleName,
|
|
containingFile,
|
|
compilerOptions,
|
|
host,
|
|
cache,
|
|
redirectedReference,
|
|
resolutionMode
|
|
);
|
|
}
|
|
function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
return nodeNextModuleNameResolverWorker(
|
|
30 /* NodeNextDefault */,
|
|
moduleName,
|
|
containingFile,
|
|
compilerOptions,
|
|
host,
|
|
cache,
|
|
redirectedReference,
|
|
resolutionMode
|
|
);
|
|
}
|
|
function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) {
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const esmMode = resolutionMode === 99 /* ESNext */ ? 32 /* EsmMode */ : 0;
|
|
let extensions = compilerOptions.noDtsResolution ? 3 /* ImplementationFiles */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
|
|
if (compilerOptions.resolveJsonModule) {
|
|
extensions |= 8 /* Json */;
|
|
}
|
|
return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, false, redirectedReference);
|
|
}
|
|
function tryResolveJSModuleWorker(moduleName, initialDir, host) {
|
|
return nodeModuleNameResolverWorker(
|
|
0 /* None */,
|
|
moduleName,
|
|
initialDir,
|
|
{ moduleResolution: 2 /* NodeJs */, allowJs: true },
|
|
host,
|
|
void 0,
|
|
2 /* JavaScript */,
|
|
false,
|
|
void 0
|
|
);
|
|
}
|
|
function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, isConfigLookup) {
|
|
let extensions;
|
|
if (isConfigLookup) {
|
|
extensions = 8 /* Json */;
|
|
} else if (compilerOptions.noDtsResolution) {
|
|
extensions = 3 /* ImplementationFiles */;
|
|
if (compilerOptions.resolveJsonModule)
|
|
extensions |= 8 /* Json */;
|
|
} else {
|
|
extensions = compilerOptions.resolveJsonModule ? 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */ | 8 /* Json */ : 1 /* TypeScript */ | 2 /* JavaScript */ | 4 /* Declaration */;
|
|
}
|
|
return nodeModuleNameResolverWorker(0 /* None */, moduleName, getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, !!isConfigLookup, redirectedReference);
|
|
}
|
|
function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, isConfigLookup, redirectedReference) {
|
|
var _a2, _b;
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const conditions = features & 32 /* EsmMode */ ? ["node", "import", "types"] : ["node", "require", "types"];
|
|
if (compilerOptions.noDtsResolution) {
|
|
conditions.pop();
|
|
}
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features,
|
|
conditions,
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup
|
|
};
|
|
if (traceEnabled && getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) <= 99 /* NodeNext */) {
|
|
trace(host, Diagnostics.Resolving_in_0_mode_with_conditions_1, features & 32 /* EsmMode */ ? "ESM" : "CJS", conditions.map((c) => `'${c}'`).join(", "));
|
|
}
|
|
let result;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */) {
|
|
const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
|
|
const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
|
|
result = priorityExtensions && tryResolve(priorityExtensions) || secondaryExtensions && tryResolve(secondaryExtensions) || void 0;
|
|
} else {
|
|
result = tryResolve(extensions);
|
|
}
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
(_a2 = result == null ? void 0 : result.value) == null ? void 0 : _a2.resolved,
|
|
(_b = result == null ? void 0 : result.value) == null ? void 0 : _b.isExternalLibraryImport,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
function tryResolve(extensions2) {
|
|
const loader = (extensions3, candidate, onlyRecordFailures, state2) => nodeLoadModuleByRelativeName(extensions3, candidate, onlyRecordFailures, state2, true);
|
|
const resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions2, moduleName, containingDirectory, loader, state);
|
|
if (resolved) {
|
|
return toSearchResult({ resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) });
|
|
}
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
let resolved2;
|
|
if (features & 2 /* Imports */ && startsWith(moduleName, "#")) {
|
|
resolved2 = loadModuleFromImports(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2 && features & 4 /* SelfName */) {
|
|
resolved2 = loadModuleFromSelfNameReference(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2) {
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Loading_module_0_from_node_modules_folder_target_file_types_Colon_1, moduleName, formatExtensions(extensions2));
|
|
}
|
|
resolved2 = loadModuleFromNearestNodeModulesDirectory(extensions2, moduleName, containingDirectory, state, cache, redirectedReference);
|
|
}
|
|
if (!resolved2)
|
|
return void 0;
|
|
let resolvedValue = resolved2.value;
|
|
if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
|
|
const path = realPath(resolvedValue.path, host, traceEnabled);
|
|
const pathsAreEqual = arePathsEqual(path, resolvedValue.path, host);
|
|
const originalPath = pathsAreEqual ? void 0 : resolvedValue.path;
|
|
resolvedValue = { ...resolvedValue, path: pathsAreEqual ? resolvedValue.path : path, originalPath };
|
|
}
|
|
return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
|
|
} else {
|
|
const { path: candidate, parts } = normalizePathForCJSResolution(containingDirectory, moduleName);
|
|
const resolved2 = nodeLoadModuleByRelativeName(extensions2, candidate, false, state, true);
|
|
return resolved2 && toSearchResult({ resolved: resolved2, isExternalLibraryImport: contains(parts, "node_modules") });
|
|
}
|
|
}
|
|
}
|
|
function normalizePathForCJSResolution(containingDirectory, moduleName) {
|
|
const combined = combinePaths(containingDirectory, moduleName);
|
|
const parts = getPathComponents(combined);
|
|
const lastPart = lastOrUndefined(parts);
|
|
const path = lastPart === "." || lastPart === ".." ? ensureTrailingDirectorySeparator(normalizePath(combined)) : normalizePath(combined);
|
|
return { path, parts };
|
|
}
|
|
function realPath(path, host, traceEnabled) {
|
|
if (!host.realpath) {
|
|
return path;
|
|
}
|
|
const real = normalizePath(host.realpath(path));
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Resolving_real_path_for_0_result_1, path, real);
|
|
}
|
|
Debug.assert(host.fileExists(real), `${path} linked to nonexistent file ${real}`);
|
|
return real;
|
|
}
|
|
function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_types_Colon_1, candidate, formatExtensions(extensions));
|
|
}
|
|
if (!hasTrailingDirectorySeparator(candidate)) {
|
|
if (!onlyRecordFailures) {
|
|
const parentOfCandidate = getDirectoryPath(candidate);
|
|
if (!directoryProbablyExists(parentOfCandidate, state.host)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate);
|
|
}
|
|
onlyRecordFailures = true;
|
|
}
|
|
}
|
|
const resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state);
|
|
if (resolvedFromFile) {
|
|
const packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile.path) : void 0;
|
|
const packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, false, state) : void 0;
|
|
return withPackageId(packageInfo, resolvedFromFile);
|
|
}
|
|
}
|
|
if (!onlyRecordFailures) {
|
|
const candidateExists = directoryProbablyExists(candidate, state.host);
|
|
if (!candidateExists) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate);
|
|
}
|
|
onlyRecordFailures = true;
|
|
}
|
|
}
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson);
|
|
}
|
|
return void 0;
|
|
}
|
|
var nodeModulesPathPart = "/node_modules/";
|
|
function pathContainsNodeModules(path) {
|
|
return stringContains(path, nodeModulesPathPart);
|
|
}
|
|
function parseNodeModuleFromPath(resolved) {
|
|
const path = normalizePath(resolved);
|
|
const idx = path.lastIndexOf(nodeModulesPathPart);
|
|
if (idx === -1) {
|
|
return void 0;
|
|
}
|
|
const indexAfterNodeModules = idx + nodeModulesPathPart.length;
|
|
let indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules);
|
|
if (path.charCodeAt(indexAfterNodeModules) === 64 /* at */) {
|
|
indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName);
|
|
}
|
|
return path.slice(0, indexAfterPackageName);
|
|
}
|
|
function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) {
|
|
const nextSeparatorIndex = path.indexOf(directorySeparator, prevSeparatorIndex + 1);
|
|
return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex;
|
|
}
|
|
function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) {
|
|
return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state));
|
|
}
|
|
function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) {
|
|
const resolvedByReplacingExtension = loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
|
|
if (resolvedByReplacingExtension) {
|
|
return resolvedByReplacingExtension;
|
|
}
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
const resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, "", onlyRecordFailures, state);
|
|
if (resolvedByAddingExtension) {
|
|
return resolvedByAddingExtension;
|
|
}
|
|
}
|
|
}
|
|
function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state) {
|
|
if (hasJSFileExtension(candidate) || extensions & 8 /* Json */ && fileExtensionIs(candidate, ".json" /* Json */)) {
|
|
const extensionless = removeFileExtension(candidate);
|
|
const extension = candidate.substring(extensionless.length);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension);
|
|
}
|
|
return tryAddingExtensions(extensionless, extensions, extension, onlyRecordFailures, state);
|
|
}
|
|
}
|
|
function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) {
|
|
if (extensions & 1 /* TypeScript */ && fileExtensionIsOneOf(candidate, supportedTSImplementationExtensions) || extensions & 4 /* Declaration */ && fileExtensionIsOneOf(candidate, supportedDeclarationExtensions)) {
|
|
const result = tryFile(candidate, onlyRecordFailures, state);
|
|
return result !== void 0 ? { path: candidate, ext: tryExtractTSExtension(candidate) } : void 0;
|
|
}
|
|
return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state);
|
|
}
|
|
function tryAddingExtensions(candidate, extensions, originalExtension, onlyRecordFailures, state) {
|
|
if (!onlyRecordFailures) {
|
|
const directory = getDirectoryPath(candidate);
|
|
if (directory) {
|
|
onlyRecordFailures = !directoryProbablyExists(directory, state.host);
|
|
}
|
|
}
|
|
switch (originalExtension) {
|
|
case ".mjs" /* Mjs */:
|
|
case ".mts" /* Mts */:
|
|
case ".d.mts" /* Dmts */:
|
|
return extensions & 1 /* TypeScript */ && tryExtension(".mts" /* Mts */) || extensions & 4 /* Declaration */ && tryExtension(".d.mts" /* Dmts */) || extensions & 2 /* JavaScript */ && tryExtension(".mjs" /* Mjs */) || void 0;
|
|
case ".cjs" /* Cjs */:
|
|
case ".cts" /* Cts */:
|
|
case ".d.cts" /* Dcts */:
|
|
return extensions & 1 /* TypeScript */ && tryExtension(".cts" /* Cts */) || extensions & 4 /* Declaration */ && tryExtension(".d.cts" /* Dcts */) || extensions & 2 /* JavaScript */ && tryExtension(".cjs" /* Cjs */) || void 0;
|
|
case ".json" /* Json */:
|
|
const originalCandidate = candidate;
|
|
if (extensions & 4 /* Declaration */) {
|
|
candidate += ".json" /* Json */;
|
|
const result = tryExtension(".d.ts" /* Dts */);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (extensions & 8 /* Json */) {
|
|
candidate = originalCandidate;
|
|
const result = tryExtension(".json" /* Json */);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return void 0;
|
|
default:
|
|
return extensions & 1 /* TypeScript */ && (tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */)) || extensions & 4 /* Declaration */ && tryExtension(".d.ts" /* Dts */) || extensions & 2 /* JavaScript */ && (tryExtension(".js" /* Js */) || tryExtension(".jsx" /* Jsx */)) || state.isConfigLookup && tryExtension(".json" /* Json */) || void 0;
|
|
}
|
|
function tryExtension(ext) {
|
|
const path = tryFile(candidate + ext, onlyRecordFailures, state);
|
|
return path === void 0 ? void 0 : { path, ext };
|
|
}
|
|
}
|
|
function tryFile(fileName, onlyRecordFailures, state) {
|
|
var _a2, _b;
|
|
if (!((_a2 = state.compilerOptions.moduleSuffixes) == null ? void 0 : _a2.length)) {
|
|
return tryFileLookup(fileName, onlyRecordFailures, state);
|
|
}
|
|
const ext = (_b = tryGetExtensionFromPath2(fileName)) != null ? _b : "";
|
|
const fileNameNoExtension = ext ? removeExtension(fileName, ext) : fileName;
|
|
return forEach(state.compilerOptions.moduleSuffixes, (suffix) => tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state));
|
|
}
|
|
function tryFileLookup(fileName, onlyRecordFailures, state) {
|
|
if (!onlyRecordFailures) {
|
|
if (state.host.fileExists(fileName)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
|
|
}
|
|
return fileName;
|
|
} else {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.File_0_does_not_exist, fileName);
|
|
}
|
|
}
|
|
}
|
|
state.failedLookupLocations.push(fileName);
|
|
return void 0;
|
|
}
|
|
function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson = true) {
|
|
const packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : void 0;
|
|
const packageJsonContent = packageInfo && packageInfo.contents.packageJsonContent;
|
|
const versionPaths = packageInfo && packageInfo.contents.versionPaths;
|
|
return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths));
|
|
}
|
|
function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) {
|
|
if (!resolveJs && packageJsonInfo.contents.resolvedEntrypoints !== void 0) {
|
|
return packageJsonInfo.contents.resolvedEntrypoints;
|
|
}
|
|
let entrypoints;
|
|
const extensions = 1 /* TypeScript */ | 4 /* Declaration */ | (resolveJs ? 2 /* JavaScript */ : 0);
|
|
const features = getDefaultNodeResolutionFeatures(options);
|
|
const requireState = getTemporaryModuleResolutionState(cache == null ? void 0 : cache.getPackageJsonInfoCache(), host, options);
|
|
requireState.conditions = ["node", "require", "types"];
|
|
requireState.requestContainingDirectory = packageJsonInfo.packageDirectory;
|
|
const requireResolution = loadNodeModuleFromDirectoryWorker(
|
|
extensions,
|
|
packageJsonInfo.packageDirectory,
|
|
false,
|
|
requireState,
|
|
packageJsonInfo.contents.packageJsonContent,
|
|
packageJsonInfo.contents.versionPaths
|
|
);
|
|
entrypoints = append(entrypoints, requireResolution == null ? void 0 : requireResolution.path);
|
|
if (features & 8 /* Exports */ && packageJsonInfo.contents.packageJsonContent.exports) {
|
|
for (const conditions of [["node", "import", "types"], ["node", "require", "types"]]) {
|
|
const exportState = { ...requireState, failedLookupLocations: [], conditions };
|
|
const exportResolutions = loadEntrypointsFromExportMap(
|
|
packageJsonInfo,
|
|
packageJsonInfo.contents.packageJsonContent.exports,
|
|
exportState,
|
|
extensions
|
|
);
|
|
if (exportResolutions) {
|
|
for (const resolution of exportResolutions) {
|
|
entrypoints = appendIfUnique(entrypoints, resolution.path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return packageJsonInfo.contents.resolvedEntrypoints = entrypoints || false;
|
|
}
|
|
function loadEntrypointsFromExportMap(scope, exports, state, extensions) {
|
|
let entrypoints;
|
|
if (isArray(exports)) {
|
|
for (const target of exports) {
|
|
loadEntrypointsFromTargetExports(target);
|
|
}
|
|
} else if (typeof exports === "object" && exports !== null && allKeysStartWithDot(exports)) {
|
|
for (const key in exports) {
|
|
loadEntrypointsFromTargetExports(exports[key]);
|
|
}
|
|
} else {
|
|
loadEntrypointsFromTargetExports(exports);
|
|
}
|
|
return entrypoints;
|
|
function loadEntrypointsFromTargetExports(target) {
|
|
var _a2, _b;
|
|
if (typeof target === "string" && startsWith(target, "./") && target.indexOf("*") === -1) {
|
|
const partsAfterFirst = getPathComponents(target).slice(2);
|
|
if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
|
|
return false;
|
|
}
|
|
const resolvedTarget = combinePaths(scope.packageDirectory, target);
|
|
const finalPath = getNormalizedAbsolutePath(resolvedTarget, (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
const result = loadJSOrExactTSFileName(extensions, finalPath, false, state);
|
|
if (result) {
|
|
entrypoints = appendIfUnique(entrypoints, result, (a, b) => a.path === b.path);
|
|
return true;
|
|
}
|
|
} else if (Array.isArray(target)) {
|
|
for (const t of target) {
|
|
const success = loadEntrypointsFromTargetExports(t);
|
|
if (success) {
|
|
return true;
|
|
}
|
|
}
|
|
} else if (typeof target === "object" && target !== null) {
|
|
return forEach(getOwnKeys(target), (key) => {
|
|
if (key === "default" || contains(state.conditions, key) || isApplicableVersionedTypesKey(state.conditions, key)) {
|
|
loadEntrypointsFromTargetExports(target[key]);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options) {
|
|
return {
|
|
host,
|
|
compilerOptions: options,
|
|
traceEnabled: isTraceEnabled(options, host),
|
|
failedLookupLocations: noopPush,
|
|
affectingLocations: noopPush,
|
|
packageJsonInfoCache,
|
|
features: 0 /* None */,
|
|
conditions: emptyArray,
|
|
requestContainingDirectory: void 0,
|
|
reportDiagnostic: noop,
|
|
isConfigLookup: false
|
|
};
|
|
}
|
|
function getPackageScopeForPath(fileName, state) {
|
|
const parts = getPathComponents(fileName);
|
|
parts.pop();
|
|
while (parts.length > 0) {
|
|
const pkg = getPackageJsonInfo(getPathFromPathComponents(parts), false, state);
|
|
if (pkg) {
|
|
return pkg;
|
|
}
|
|
parts.pop();
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) {
|
|
var _a2, _b, _c;
|
|
const { host, traceEnabled } = state;
|
|
const packageJsonPath = combinePaths(packageDirectory, "package.json");
|
|
if (onlyRecordFailures) {
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
return void 0;
|
|
}
|
|
const existing = (_a2 = state.packageJsonInfoCache) == null ? void 0 : _a2.getPackageJsonInfo(packageJsonPath);
|
|
if (existing !== void 0) {
|
|
if (typeof existing !== "boolean") {
|
|
if (traceEnabled)
|
|
trace(host, Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath);
|
|
state.affectingLocations.push(packageJsonPath);
|
|
return existing.packageDirectory === packageDirectory ? existing : { packageDirectory, contents: existing.contents };
|
|
} else {
|
|
if (existing && traceEnabled)
|
|
trace(host, Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath);
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
return void 0;
|
|
}
|
|
}
|
|
const directoryExists = directoryProbablyExists(packageDirectory, host);
|
|
if (directoryExists && host.fileExists(packageJsonPath)) {
|
|
const packageJsonContent = readJson(packageJsonPath, host);
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
|
|
}
|
|
const versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state);
|
|
const result = { packageDirectory, contents: { packageJsonContent, versionPaths, resolvedEntrypoints: void 0 } };
|
|
(_b = state.packageJsonInfoCache) == null ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result);
|
|
state.affectingLocations.push(packageJsonPath);
|
|
return result;
|
|
} else {
|
|
if (directoryExists && traceEnabled) {
|
|
trace(host, Diagnostics.File_0_does_not_exist, packageJsonPath);
|
|
}
|
|
(_c = state.packageJsonInfoCache) == null ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists);
|
|
state.failedLookupLocations.push(packageJsonPath);
|
|
}
|
|
}
|
|
function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) {
|
|
let packageFile;
|
|
if (jsonContent) {
|
|
if (state.isConfigLookup) {
|
|
packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state);
|
|
} else {
|
|
packageFile = extensions & 4 /* Declaration */ && readPackageJsonTypesFields(jsonContent, candidate, state) || extensions & (3 /* ImplementationFiles */ | 4 /* Declaration */) && readPackageJsonMainField(jsonContent, candidate, state) || void 0;
|
|
}
|
|
}
|
|
const loader = (extensions2, candidate2, onlyRecordFailures2, state2) => {
|
|
const fromFile = tryFile(candidate2, onlyRecordFailures2, state2);
|
|
if (fromFile) {
|
|
const resolved = resolvedIfExtensionMatches(extensions2, fromFile);
|
|
if (resolved) {
|
|
return noPackageId(resolved);
|
|
}
|
|
if (state2.traceEnabled) {
|
|
trace(state2.host, Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile);
|
|
}
|
|
}
|
|
const expandedExtensions = extensions2 === 4 /* Declaration */ ? 1 /* TypeScript */ | 4 /* Declaration */ : extensions2;
|
|
const features = state2.features;
|
|
if ((jsonContent == null ? void 0 : jsonContent.type) !== "module") {
|
|
state2.features &= ~32 /* EsmMode */;
|
|
}
|
|
const result = nodeLoadModuleByRelativeName(expandedExtensions, candidate2, onlyRecordFailures2, state2, false);
|
|
state2.features = features;
|
|
return result;
|
|
};
|
|
const onlyRecordFailuresForPackageFile = packageFile ? !directoryProbablyExists(getDirectoryPath(packageFile), state.host) : void 0;
|
|
const onlyRecordFailuresForIndex = onlyRecordFailures || !directoryProbablyExists(candidate, state.host);
|
|
const indexPath = combinePaths(candidate, state.isConfigLookup ? "tsconfig" : "index");
|
|
if (versionPaths && (!packageFile || containsPath(candidate, packageFile))) {
|
|
const moduleName = getRelativePathFromDirectory(candidate, packageFile || indexPath, false);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName);
|
|
}
|
|
const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, void 0, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
|
|
if (result) {
|
|
return removeIgnoredPackageId(result.value);
|
|
}
|
|
}
|
|
const packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state));
|
|
if (packageFileResult)
|
|
return packageFileResult;
|
|
if (!(state.features & 32 /* EsmMode */)) {
|
|
return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state);
|
|
}
|
|
}
|
|
function resolvedIfExtensionMatches(extensions, path) {
|
|
const ext = tryGetExtensionFromPath2(path);
|
|
return ext !== void 0 && extensionIsOk(extensions, ext) ? { path, ext } : void 0;
|
|
}
|
|
function extensionIsOk(extensions, extension) {
|
|
return extensions & 2 /* JavaScript */ && (extension === ".js" /* Js */ || extension === ".jsx" /* Jsx */ || extension === ".mjs" /* Mjs */ || extension === ".cjs" /* Cjs */) || extensions & 1 /* TypeScript */ && (extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".mts" /* Mts */ || extension === ".cts" /* Cts */) || extensions & 4 /* Declaration */ && (extension === ".d.ts" /* Dts */ || extension === ".d.mts" /* Dmts */ || extension === ".d.cts" /* Dcts */) || extensions & 8 /* Json */ && extension === ".json" /* Json */ || false;
|
|
}
|
|
function parsePackageName(moduleName) {
|
|
let idx = moduleName.indexOf(directorySeparator);
|
|
if (moduleName[0] === "@") {
|
|
idx = moduleName.indexOf(directorySeparator, idx + 1);
|
|
}
|
|
return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) };
|
|
}
|
|
function allKeysStartWithDot(obj) {
|
|
return every(getOwnKeys(obj), (k) => startsWith(k, "."));
|
|
}
|
|
function noKeyStartsWithDot(obj) {
|
|
return !some(getOwnKeys(obj), (k) => startsWith(k, "."));
|
|
}
|
|
function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
var _a2, _b;
|
|
const directoryPath = getNormalizedAbsolutePath(combinePaths(directory, "dummy"), (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
const scope = getPackageScopeForPath(directoryPath, state);
|
|
if (!scope || !scope.contents.packageJsonContent.exports) {
|
|
return void 0;
|
|
}
|
|
if (typeof scope.contents.packageJsonContent.name !== "string") {
|
|
return void 0;
|
|
}
|
|
const parts = getPathComponents(moduleName);
|
|
const nameParts = getPathComponents(scope.contents.packageJsonContent.name);
|
|
if (!every(nameParts, (p, i) => parts[i] === p)) {
|
|
return void 0;
|
|
}
|
|
const trailingParts = parts.slice(nameParts.length);
|
|
return loadModuleFromExports(scope, extensions, !length(trailingParts) ? "." : `.${directorySeparator}${trailingParts.join(directorySeparator)}`, state, cache, redirectedReference);
|
|
}
|
|
function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) {
|
|
if (!scope.contents.packageJsonContent.exports) {
|
|
return void 0;
|
|
}
|
|
if (subpath === ".") {
|
|
let mainExport;
|
|
if (typeof scope.contents.packageJsonContent.exports === "string" || Array.isArray(scope.contents.packageJsonContent.exports) || typeof scope.contents.packageJsonContent.exports === "object" && noKeyStartsWithDot(scope.contents.packageJsonContent.exports)) {
|
|
mainExport = scope.contents.packageJsonContent.exports;
|
|
} else if (hasProperty(scope.contents.packageJsonContent.exports, ".")) {
|
|
mainExport = scope.contents.packageJsonContent.exports["."];
|
|
}
|
|
if (mainExport) {
|
|
const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, subpath, scope, false);
|
|
return loadModuleFromTargetImportOrExport(mainExport, "", false, ".");
|
|
}
|
|
} else if (allKeysStartWithDot(scope.contents.packageJsonContent.exports)) {
|
|
if (typeof scope.contents.packageJsonContent.exports !== "object") {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, subpath, scope.contents.packageJsonContent.exports, scope, false);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
function loadModuleFromImports(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
var _a2, _b;
|
|
if (moduleName === "#" || startsWith(moduleName, "#/")) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Invalid_import_specifier_0_has_no_possible_resolutions, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const directoryPath = getNormalizedAbsolutePath(combinePaths(directory, "dummy"), (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
const scope = getPackageScopeForPath(directoryPath, state);
|
|
if (!scope) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, directoryPath);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (!scope.contents.packageJsonContent.imports) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_no_imports_defined, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, scope.contents.packageJsonContent.imports, scope, true);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1, moduleName, scope.packageDirectory);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
function comparePatternKeys(a, b) {
|
|
const aPatternIndex = a.indexOf("*");
|
|
const bPatternIndex = b.indexOf("*");
|
|
const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
|
|
const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
|
|
if (baseLenA > baseLenB)
|
|
return -1;
|
|
if (baseLenB > baseLenA)
|
|
return 1;
|
|
if (aPatternIndex === -1)
|
|
return 1;
|
|
if (bPatternIndex === -1)
|
|
return -1;
|
|
if (a.length > b.length)
|
|
return -1;
|
|
if (b.length > a.length)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
|
|
const loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
|
|
if (!endsWith(moduleName, directorySeparator) && moduleName.indexOf("*") === -1 && hasProperty(lookupTable, moduleName)) {
|
|
const target = lookupTable[moduleName];
|
|
return loadModuleFromTargetImportOrExport(target, "", false, moduleName);
|
|
}
|
|
const expandingKeys = sort(filter(getOwnKeys(lookupTable), (k) => k.indexOf("*") !== -1 || endsWith(k, "/")), comparePatternKeys);
|
|
for (const potentialTarget of expandingKeys) {
|
|
if (state.features & 16 /* ExportsPatternTrailers */ && matchesPatternWithTrailer(potentialTarget, moduleName)) {
|
|
const target = lookupTable[potentialTarget];
|
|
const starPos = potentialTarget.indexOf("*");
|
|
const subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos));
|
|
return loadModuleFromTargetImportOrExport(target, subpath, true, potentialTarget);
|
|
} else if (endsWith(potentialTarget, "*") && startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) {
|
|
const target = lookupTable[potentialTarget];
|
|
const subpath = moduleName.substring(potentialTarget.length - 1);
|
|
return loadModuleFromTargetImportOrExport(target, subpath, true, potentialTarget);
|
|
} else if (startsWith(moduleName, potentialTarget)) {
|
|
const target = lookupTable[potentialTarget];
|
|
const subpath = moduleName.substring(potentialTarget.length);
|
|
return loadModuleFromTargetImportOrExport(target, subpath, false, potentialTarget);
|
|
}
|
|
}
|
|
function matchesPatternWithTrailer(target, name) {
|
|
if (endsWith(target, "*"))
|
|
return false;
|
|
const starPos = target.indexOf("*");
|
|
if (starPos === -1)
|
|
return false;
|
|
return startsWith(name, target.substring(0, starPos)) && endsWith(name, target.substring(starPos + 1));
|
|
}
|
|
}
|
|
function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) {
|
|
return loadModuleFromTargetImportOrExport;
|
|
function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) {
|
|
if (typeof target === "string") {
|
|
if (!pattern && subpath.length > 0 && !endsWith(target, "/")) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (!startsWith(target, "./")) {
|
|
if (isImports && !startsWith(target, "../") && !startsWith(target, "/") && !isRootedDiskPath(target)) {
|
|
const combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath;
|
|
traceIfEnabled(state, Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup);
|
|
traceIfEnabled(state, Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/");
|
|
const result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, extensions, false, redirectedReference);
|
|
return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const parts = pathIsRelative(target) ? getPathComponents(target).slice(1) : getPathComponents(target);
|
|
const partsAfterFirst = parts.slice(1);
|
|
if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
const resolvedTarget = combinePaths(scope.packageDirectory, target);
|
|
const subpathParts = getPathComponents(subpath);
|
|
if (subpathParts.indexOf("..") >= 0 || subpathParts.indexOf(".") >= 0 || subpathParts.indexOf("node_modules") >= 0) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(
|
|
state.host,
|
|
Diagnostics.Using_0_subpath_1_with_target_2,
|
|
isImports ? "imports" : "exports",
|
|
key,
|
|
pattern ? target.replace(/\*/g, subpath) : target + subpath
|
|
);
|
|
}
|
|
const finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath);
|
|
const inputLink = tryLoadInputFileForPath(finalPath, subpath, combinePaths(scope.packageDirectory, "package.json"), isImports);
|
|
if (inputLink)
|
|
return inputLink;
|
|
return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, false, state)));
|
|
} else if (typeof target === "object" && target !== null) {
|
|
if (!Array.isArray(target)) {
|
|
for (const condition of getOwnKeys(target)) {
|
|
if (condition === "default" || state.conditions.indexOf(condition) >= 0 || isApplicableVersionedTypesKey(state.conditions, condition)) {
|
|
traceIfEnabled(state, Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition);
|
|
const subTarget = target[condition];
|
|
const result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
} else {
|
|
traceIfEnabled(state, Diagnostics.Saw_non_matching_condition_0, condition);
|
|
}
|
|
}
|
|
return void 0;
|
|
} else {
|
|
if (!length(target)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
for (const elem of target) {
|
|
const result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
} else if (target === null) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_explicitly_maps_specifier_1_to_null, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
}
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName);
|
|
}
|
|
return toSearchResult(void 0);
|
|
function toAbsolutePath(path) {
|
|
var _a2, _b;
|
|
if (path === void 0)
|
|
return path;
|
|
return getNormalizedAbsolutePath(path, (_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2));
|
|
}
|
|
function combineDirectoryPath(root, dir) {
|
|
return ensureTrailingDirectorySeparator(combinePaths(root, dir));
|
|
}
|
|
function useCaseSensitiveFileNames() {
|
|
return !state.host.useCaseSensitiveFileNames ? true : typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : state.host.useCaseSensitiveFileNames();
|
|
}
|
|
function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports2) {
|
|
var _a2, _b, _c, _d;
|
|
if (!state.isConfigLookup && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) && finalPath.indexOf("/node_modules/") === -1 && (state.compilerOptions.configFile ? containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) {
|
|
const getCanonicalFileName = hostGetCanonicalFileName({ useCaseSensitiveFileNames });
|
|
const commonSourceDirGuesses = [];
|
|
if (state.compilerOptions.rootDir || state.compilerOptions.composite && state.compilerOptions.configFilePath) {
|
|
const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [], ((_b = (_a2 = state.host).getCurrentDirectory) == null ? void 0 : _b.call(_a2)) || "", getCanonicalFileName));
|
|
commonSourceDirGuesses.push(commonDir);
|
|
} else if (state.requestContainingDirectory) {
|
|
const requestingFile = toAbsolutePath(combinePaths(state.requestContainingDirectory, "index.ts"));
|
|
const commonDir = toAbsolutePath(getCommonSourceDirectory(state.compilerOptions, () => [requestingFile, toAbsolutePath(packagePath)], ((_d = (_c = state.host).getCurrentDirectory) == null ? void 0 : _d.call(_c)) || "", getCanonicalFileName));
|
|
commonSourceDirGuesses.push(commonDir);
|
|
let fragment = ensureTrailingDirectorySeparator(commonDir);
|
|
while (fragment && fragment.length > 1) {
|
|
const parts = getPathComponents(fragment);
|
|
parts.pop();
|
|
const commonDir2 = getPathFromPathComponents(parts);
|
|
commonSourceDirGuesses.unshift(commonDir2);
|
|
fragment = ensureTrailingDirectorySeparator(commonDir2);
|
|
}
|
|
}
|
|
if (commonSourceDirGuesses.length > 1) {
|
|
state.reportDiagnostic(createCompilerDiagnostic(
|
|
isImports2 ? Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate : Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate,
|
|
entry === "" ? "." : entry,
|
|
packagePath
|
|
));
|
|
}
|
|
for (const commonSourceDirGuess of commonSourceDirGuesses) {
|
|
const candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess);
|
|
for (const candidateDir of candidateDirectories) {
|
|
if (containsPath(candidateDir, finalPath, !useCaseSensitiveFileNames())) {
|
|
const pathFragment = finalPath.slice(candidateDir.length + 1);
|
|
const possibleInputBase = combinePaths(commonSourceDirGuess, pathFragment);
|
|
const jsAndDtsExtensions = [".mjs" /* Mjs */, ".cjs" /* Cjs */, ".js" /* Js */, ".json" /* Json */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".d.ts" /* Dts */];
|
|
for (const ext of jsAndDtsExtensions) {
|
|
if (fileExtensionIs(possibleInputBase, ext)) {
|
|
const inputExts = getPossibleOriginalInputExtensionForExtension(possibleInputBase);
|
|
for (const possibleExt of inputExts) {
|
|
if (!extensionIsOk(extensions, possibleExt))
|
|
continue;
|
|
const possibleInputWithInputExtension = changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames());
|
|
if (state.host.fileExists(possibleInputWithInputExtension)) {
|
|
return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, false, state)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) {
|
|
var _a3, _b2;
|
|
const currentDir = state.compilerOptions.configFile ? ((_b2 = (_a3 = state.host).getCurrentDirectory) == null ? void 0 : _b2.call(_a3)) || "" : commonSourceDirGuess;
|
|
const candidateDirectories = [];
|
|
if (state.compilerOptions.declarationDir) {
|
|
candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir)));
|
|
}
|
|
if (state.compilerOptions.outDir && state.compilerOptions.outDir !== state.compilerOptions.declarationDir) {
|
|
candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.outDir)));
|
|
}
|
|
return candidateDirectories;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isApplicableVersionedTypesKey(conditions, key) {
|
|
if (conditions.indexOf("types") === -1)
|
|
return false;
|
|
if (!startsWith(key, "types@"))
|
|
return false;
|
|
const range = VersionRange.tryParse(key.substring("types@".length));
|
|
if (!range)
|
|
return false;
|
|
return range.test(version);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
|
|
return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, false, cache, redirectedReference);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) {
|
|
return loadModuleFromNearestNodeModulesDirectoryWorker(4 /* Declaration */, moduleName, directory, state, true, void 0, void 0);
|
|
}
|
|
function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
|
|
const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? void 0 : state.features & 32 /* EsmMode */ ? 99 /* ESNext */ : 1 /* CommonJS */, redirectedReference);
|
|
const priorityExtensions = extensions & (1 /* TypeScript */ | 4 /* Declaration */);
|
|
const secondaryExtensions = extensions & ~(1 /* TypeScript */ | 4 /* Declaration */);
|
|
if (priorityExtensions) {
|
|
const result = lookup(priorityExtensions);
|
|
if (result)
|
|
return result;
|
|
}
|
|
if (secondaryExtensions && !typesScopeOnly) {
|
|
return lookup(secondaryExtensions);
|
|
}
|
|
function lookup(extensions2) {
|
|
return forEachAncestorDirectory(normalizeSlashes(directory), (ancestorDirectory) => {
|
|
if (getBaseFileName(ancestorDirectory) !== "node_modules") {
|
|
const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state);
|
|
if (resolutionFromCache) {
|
|
return resolutionFromCache;
|
|
}
|
|
return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions2, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) {
|
|
const nodeModulesFolder = combinePaths(directory, "node_modules");
|
|
const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, state.host);
|
|
if (!nodeModulesFolderExists && state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder);
|
|
}
|
|
if (!typesScopeOnly) {
|
|
const packageResult = loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference);
|
|
if (packageResult) {
|
|
return packageResult;
|
|
}
|
|
}
|
|
if (extensions & 4 /* Declaration */) {
|
|
const nodeModulesAtTypes2 = combinePaths(nodeModulesFolder, "@types");
|
|
let nodeModulesAtTypesExists = nodeModulesFolderExists;
|
|
if (nodeModulesFolderExists && !directoryProbablyExists(nodeModulesAtTypes2, state.host)) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes2);
|
|
}
|
|
nodeModulesAtTypesExists = false;
|
|
}
|
|
return loadModuleFromSpecificNodeModulesDirectory(4 /* Declaration */, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes2, nodeModulesAtTypesExists, state, cache, redirectedReference);
|
|
}
|
|
}
|
|
function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) {
|
|
var _a2;
|
|
const candidate = normalizePath(combinePaths(nodeModulesDirectory, moduleName));
|
|
let packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state);
|
|
if (!(state.features & 8 /* Exports */)) {
|
|
if (packageInfo) {
|
|
const fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state);
|
|
if (fromFile) {
|
|
return noPackageId(fromFile);
|
|
}
|
|
const fromDirectory = loadNodeModuleFromDirectoryWorker(
|
|
extensions,
|
|
candidate,
|
|
!nodeModulesDirectoryExists,
|
|
state,
|
|
packageInfo.contents.packageJsonContent,
|
|
packageInfo.contents.versionPaths
|
|
);
|
|
return withPackageId(packageInfo, fromDirectory);
|
|
}
|
|
}
|
|
const loader = (extensions2, candidate2, onlyRecordFailures, state2) => {
|
|
let pathAndExtension = loadModuleFromFile(extensions2, candidate2, onlyRecordFailures, state2) || loadNodeModuleFromDirectoryWorker(
|
|
extensions2,
|
|
candidate2,
|
|
onlyRecordFailures,
|
|
state2,
|
|
packageInfo && packageInfo.contents.packageJsonContent,
|
|
packageInfo && packageInfo.contents.versionPaths
|
|
);
|
|
if (!pathAndExtension && packageInfo && (packageInfo.contents.packageJsonContent.exports === void 0 || packageInfo.contents.packageJsonContent.exports === null) && state2.features & 32 /* EsmMode */) {
|
|
pathAndExtension = loadModuleFromFile(extensions2, combinePaths(candidate2, "index.js"), onlyRecordFailures, state2);
|
|
}
|
|
return withPackageId(packageInfo, pathAndExtension);
|
|
};
|
|
const { packageName, rest } = parsePackageName(moduleName);
|
|
const packageDirectory = combinePaths(nodeModulesDirectory, packageName);
|
|
if (rest !== "") {
|
|
packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state);
|
|
}
|
|
if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & 8 /* Exports */) {
|
|
return (_a2 = loadModuleFromExports(packageInfo, extensions, combinePaths(".", rest), state, cache, redirectedReference)) == null ? void 0 : _a2.value;
|
|
}
|
|
if (rest !== "" && packageInfo && packageInfo.contents.versionPaths) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.contents.versionPaths.version, version, rest);
|
|
}
|
|
const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
|
|
const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.contents.versionPaths.paths, void 0, loader, !packageDirectoryExists, state);
|
|
if (fromPaths) {
|
|
return fromPaths.value;
|
|
}
|
|
}
|
|
return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
|
|
}
|
|
function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, onlyRecordFailures, state) {
|
|
pathPatterns || (pathPatterns = tryParsePatterns(paths));
|
|
const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);
|
|
if (matchedPattern) {
|
|
const matchedStar = isString(matchedPattern) ? void 0 : matchedText(matchedPattern, moduleName);
|
|
const matchedPatternText = isString(matchedPattern) ? matchedPattern : patternText(matchedPattern);
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText);
|
|
}
|
|
const resolved = forEach(paths[matchedPatternText], (subst) => {
|
|
const path = matchedStar ? subst.replace("*", matchedStar) : subst;
|
|
const candidate = normalizePath(combinePaths(baseDirectory, path));
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
|
|
}
|
|
const extension = tryGetExtensionFromPath2(subst);
|
|
if (extension !== void 0) {
|
|
const path2 = tryFile(candidate, onlyRecordFailures, state);
|
|
if (path2 !== void 0) {
|
|
return noPackageId({ path: path2, ext: extension });
|
|
}
|
|
}
|
|
return loader(extensions, candidate, onlyRecordFailures || !directoryProbablyExists(getDirectoryPath(candidate), state.host), state);
|
|
});
|
|
return { value: resolved };
|
|
}
|
|
}
|
|
var mangledScopedPackageSeparator = "__";
|
|
function mangleScopedPackageNameWithTrace(packageName, state) {
|
|
const mangled = mangleScopedPackageName(packageName);
|
|
if (state.traceEnabled && mangled !== packageName) {
|
|
trace(state.host, Diagnostics.Scoped_package_detected_looking_in_0, mangled);
|
|
}
|
|
return mangled;
|
|
}
|
|
function getTypesPackageName(packageName) {
|
|
return `@types/${mangleScopedPackageName(packageName)}`;
|
|
}
|
|
function mangleScopedPackageName(packageName) {
|
|
if (startsWith(packageName, "@")) {
|
|
const replaceSlash = packageName.replace(directorySeparator, mangledScopedPackageSeparator);
|
|
if (replaceSlash !== packageName) {
|
|
return replaceSlash.slice(1);
|
|
}
|
|
}
|
|
return packageName;
|
|
}
|
|
function getPackageNameFromTypesPackageName(mangledName) {
|
|
const withoutAtTypePrefix = removePrefix(mangledName, "@types/");
|
|
if (withoutAtTypePrefix !== mangledName) {
|
|
return unmangleScopedPackageName(withoutAtTypePrefix);
|
|
}
|
|
return mangledName;
|
|
}
|
|
function unmangleScopedPackageName(typesPackageName) {
|
|
return stringContains(typesPackageName, mangledScopedPackageSeparator) ? "@" + typesPackageName.replace(mangledScopedPackageSeparator, directorySeparator) : typesPackageName;
|
|
}
|
|
function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) {
|
|
const result = cache && cache.get(containingDirectory);
|
|
if (result) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory);
|
|
}
|
|
state.resultFromCache = result;
|
|
return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, originalPath: result.resolvedModule.originalPath || true, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId } };
|
|
}
|
|
}
|
|
function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const containingDirectory = getDirectoryPath(containingFile);
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache: cache,
|
|
features: 0 /* None */,
|
|
conditions: [],
|
|
requestContainingDirectory: containingDirectory,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
const resolved = tryResolve(1 /* TypeScript */ | 4 /* Declaration */) || tryResolve(2 /* JavaScript */ | (compilerOptions.resolveJsonModule ? 8 /* Json */ : 0));
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
resolved && resolved.value,
|
|
false,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
function tryResolve(extensions) {
|
|
const resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state);
|
|
if (resolvedUsingSettings) {
|
|
return { value: resolvedUsingSettings };
|
|
}
|
|
if (!isExternalModuleNameRelative(moduleName)) {
|
|
const perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, void 0, redirectedReference);
|
|
const resolved2 = forEachAncestorDirectory(containingDirectory, (directory) => {
|
|
const resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, directory, state);
|
|
if (resolutionFromCache) {
|
|
return resolutionFromCache;
|
|
}
|
|
const searchName = normalizePath(combinePaths(directory, moduleName));
|
|
return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, false, state));
|
|
});
|
|
if (resolved2) {
|
|
return resolved2;
|
|
}
|
|
if (extensions & (1 /* TypeScript */ | 4 /* Declaration */)) {
|
|
return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state);
|
|
}
|
|
} else {
|
|
const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
|
|
return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, false, state));
|
|
}
|
|
}
|
|
}
|
|
function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) {
|
|
const traceEnabled = isTraceEnabled(compilerOptions, host);
|
|
if (traceEnabled) {
|
|
trace(host, Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache);
|
|
}
|
|
const failedLookupLocations = [];
|
|
const affectingLocations = [];
|
|
const diagnostics = [];
|
|
const state = {
|
|
compilerOptions,
|
|
host,
|
|
traceEnabled,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
packageJsonInfoCache,
|
|
features: 0 /* None */,
|
|
conditions: [],
|
|
requestContainingDirectory: void 0,
|
|
reportDiagnostic: (diag2) => void diagnostics.push(diag2),
|
|
isConfigLookup: false
|
|
};
|
|
const resolved = loadModuleFromImmediateNodeModulesDirectory(4 /* Declaration */, moduleName, globalCache, state, false, void 0, void 0);
|
|
return createResolvedModuleWithFailedLookupLocations(
|
|
resolved,
|
|
true,
|
|
failedLookupLocations,
|
|
affectingLocations,
|
|
diagnostics,
|
|
state.resultFromCache
|
|
);
|
|
}
|
|
function toSearchResult(value) {
|
|
return value !== void 0 ? { value } : void 0;
|
|
}
|
|
function traceIfEnabled(state, diagnostic, ...args) {
|
|
if (state.traceEnabled) {
|
|
trace(state.host, diagnostic, ...args);
|
|
}
|
|
}
|
|
|
|
// src/compiler/binder.ts
|
|
var ModuleInstanceState = /* @__PURE__ */ ((ModuleInstanceState2) => {
|
|
ModuleInstanceState2[ModuleInstanceState2["NonInstantiated"] = 0] = "NonInstantiated";
|
|
ModuleInstanceState2[ModuleInstanceState2["Instantiated"] = 1] = "Instantiated";
|
|
ModuleInstanceState2[ModuleInstanceState2["ConstEnumOnly"] = 2] = "ConstEnumOnly";
|
|
return ModuleInstanceState2;
|
|
})(ModuleInstanceState || {});
|
|
function getModuleInstanceState(node, visited) {
|
|
if (node.body && !node.body.parent) {
|
|
setParent(node.body, node);
|
|
setParentRecursive(node.body, false);
|
|
}
|
|
return node.body ? getModuleInstanceStateCached(node.body, visited) : 1 /* Instantiated */;
|
|
}
|
|
function getModuleInstanceStateCached(node, visited = /* @__PURE__ */ new Map()) {
|
|
const nodeId = getNodeId(node);
|
|
if (visited.has(nodeId)) {
|
|
return visited.get(nodeId) || 0 /* NonInstantiated */;
|
|
}
|
|
visited.set(nodeId, void 0);
|
|
const result = getModuleInstanceStateWorker(node, visited);
|
|
visited.set(nodeId, result);
|
|
return result;
|
|
}
|
|
function getModuleInstanceStateWorker(node, visited) {
|
|
switch (node.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return 0 /* NonInstantiated */;
|
|
case 263 /* EnumDeclaration */:
|
|
if (isEnumConst(node)) {
|
|
return 2 /* ConstEnumOnly */;
|
|
}
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (!hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return 0 /* NonInstantiated */;
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
const exportDeclaration = node;
|
|
if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 276 /* NamedExports */) {
|
|
let state = 0 /* NonInstantiated */;
|
|
for (const specifier of exportDeclaration.exportClause.elements) {
|
|
const specifierState = getModuleInstanceStateForAliasTarget(specifier, visited);
|
|
if (specifierState > state) {
|
|
state = specifierState;
|
|
}
|
|
if (state === 1 /* Instantiated */) {
|
|
return state;
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
break;
|
|
case 265 /* ModuleBlock */: {
|
|
let state = 0 /* NonInstantiated */;
|
|
forEachChild(node, (n) => {
|
|
const childState = getModuleInstanceStateCached(n, visited);
|
|
switch (childState) {
|
|
case 0 /* NonInstantiated */:
|
|
return;
|
|
case 2 /* ConstEnumOnly */:
|
|
state = 2 /* ConstEnumOnly */;
|
|
return;
|
|
case 1 /* Instantiated */:
|
|
state = 1 /* Instantiated */;
|
|
return true;
|
|
default:
|
|
Debug.assertNever(childState);
|
|
}
|
|
});
|
|
return state;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
return getModuleInstanceState(node, visited);
|
|
case 79 /* Identifier */:
|
|
if (node.isInJSDocNamespace) {
|
|
return 0 /* NonInstantiated */;
|
|
}
|
|
}
|
|
return 1 /* Instantiated */;
|
|
}
|
|
function getModuleInstanceStateForAliasTarget(specifier, visited) {
|
|
const name = specifier.propertyName || specifier.name;
|
|
let p = specifier.parent;
|
|
while (p) {
|
|
if (isBlock(p) || isModuleBlock(p) || isSourceFile(p)) {
|
|
const statements = p.statements;
|
|
let found;
|
|
for (const statement of statements) {
|
|
if (nodeHasName(statement, name)) {
|
|
if (!statement.parent) {
|
|
setParent(statement, p);
|
|
setParentRecursive(statement, false);
|
|
}
|
|
const state = getModuleInstanceStateCached(statement, visited);
|
|
if (found === void 0 || state > found) {
|
|
found = state;
|
|
}
|
|
if (found === 1 /* Instantiated */) {
|
|
return found;
|
|
}
|
|
}
|
|
}
|
|
if (found !== void 0) {
|
|
return found;
|
|
}
|
|
}
|
|
p = p.parent;
|
|
}
|
|
return 1 /* Instantiated */;
|
|
}
|
|
function initFlowNode(node) {
|
|
Debug.attachFlowNodeDebugInfo(node);
|
|
return node;
|
|
}
|
|
var binder = createBinder();
|
|
function bindSourceFile(file, options) {
|
|
mark("beforeBind");
|
|
perfLogger.logStartBindFile("" + file.fileName);
|
|
binder(file, options);
|
|
perfLogger.logStopBindFile();
|
|
mark("afterBind");
|
|
measure("Bind", "beforeBind", "afterBind");
|
|
}
|
|
function createBinder() {
|
|
let file;
|
|
let options;
|
|
let languageVersion;
|
|
let parent2;
|
|
let container;
|
|
let thisParentContainer;
|
|
let blockScopeContainer;
|
|
let lastContainer;
|
|
let delayedTypeAliases;
|
|
let seenThisKeyword;
|
|
let currentFlow;
|
|
let currentBreakTarget;
|
|
let currentContinueTarget;
|
|
let currentReturnTarget;
|
|
let currentTrueTarget;
|
|
let currentFalseTarget;
|
|
let currentExceptionTarget;
|
|
let preSwitchCaseFlow;
|
|
let activeLabelList;
|
|
let hasExplicitReturn;
|
|
let emitFlags;
|
|
let inStrictMode;
|
|
let inAssignmentPattern = false;
|
|
let symbolCount = 0;
|
|
let Symbol46;
|
|
let classifiableNames;
|
|
const unreachableFlow = { flags: 1 /* Unreachable */ };
|
|
const reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
|
|
const bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
|
|
function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
|
|
return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
|
|
}
|
|
function bindSourceFile2(f, opts) {
|
|
var _a2, _b;
|
|
file = f;
|
|
options = opts;
|
|
languageVersion = getEmitScriptTarget(options);
|
|
inStrictMode = bindInStrictMode(file, opts);
|
|
classifiableNames = /* @__PURE__ */ new Set();
|
|
symbolCount = 0;
|
|
Symbol46 = objectAllocator.getSymbolConstructor();
|
|
Debug.attachFlowNodeDebugInfo(unreachableFlow);
|
|
Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
|
|
if (!file.locals) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Bind, "bindSourceFile", { path: file.path }, true);
|
|
bind(file);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
file.symbolCount = symbolCount;
|
|
file.classifiableNames = classifiableNames;
|
|
delayedBindJSDocTypedefTag();
|
|
}
|
|
file = void 0;
|
|
options = void 0;
|
|
languageVersion = void 0;
|
|
parent2 = void 0;
|
|
container = void 0;
|
|
thisParentContainer = void 0;
|
|
blockScopeContainer = void 0;
|
|
lastContainer = void 0;
|
|
delayedTypeAliases = void 0;
|
|
seenThisKeyword = false;
|
|
currentFlow = void 0;
|
|
currentBreakTarget = void 0;
|
|
currentContinueTarget = void 0;
|
|
currentReturnTarget = void 0;
|
|
currentTrueTarget = void 0;
|
|
currentFalseTarget = void 0;
|
|
currentExceptionTarget = void 0;
|
|
activeLabelList = void 0;
|
|
hasExplicitReturn = false;
|
|
inAssignmentPattern = false;
|
|
emitFlags = 0 /* None */;
|
|
}
|
|
return bindSourceFile2;
|
|
function bindInStrictMode(file2, opts) {
|
|
if (getStrictOptionValue(opts, "alwaysStrict") && !file2.isDeclarationFile) {
|
|
return true;
|
|
} else {
|
|
return !!file2.externalModuleIndicator;
|
|
}
|
|
}
|
|
function createSymbol(flags, name) {
|
|
symbolCount++;
|
|
return new Symbol46(flags, name);
|
|
}
|
|
function addDeclarationToSymbol(symbol, node, symbolFlags) {
|
|
symbol.flags |= symbolFlags;
|
|
node.symbol = symbol;
|
|
symbol.declarations = appendIfUnique(symbol.declarations, node);
|
|
if (symbolFlags & (32 /* Class */ | 384 /* Enum */ | 1536 /* Module */ | 3 /* Variable */) && !symbol.exports) {
|
|
symbol.exports = createSymbolTable();
|
|
}
|
|
if (symbolFlags & (32 /* Class */ | 64 /* Interface */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && !symbol.members) {
|
|
symbol.members = createSymbolTable();
|
|
}
|
|
if (symbol.constEnumOnlyModule && symbol.flags & (16 /* Function */ | 32 /* Class */ | 256 /* RegularEnum */)) {
|
|
symbol.constEnumOnlyModule = false;
|
|
}
|
|
if (symbolFlags & 111551 /* Value */) {
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
}
|
|
function getDeclarationName(node) {
|
|
if (node.kind === 274 /* ExportAssignment */) {
|
|
return node.isExportEquals ? "export=" /* ExportEquals */ : "default" /* Default */;
|
|
}
|
|
const name = getNameOfDeclaration(node);
|
|
if (name) {
|
|
if (isAmbientModule(node)) {
|
|
const moduleName = getTextOfIdentifierOrLiteral(name);
|
|
return isGlobalScopeAugmentation(node) ? "__global" : `"${moduleName}"`;
|
|
}
|
|
if (name.kind === 164 /* ComputedPropertyName */) {
|
|
const nameExpression = name.expression;
|
|
if (isStringOrNumericLiteralLike(nameExpression)) {
|
|
return escapeLeadingUnderscores(nameExpression.text);
|
|
}
|
|
if (isSignedNumericLiteral(nameExpression)) {
|
|
return tokenToString(nameExpression.operator) + nameExpression.operand.text;
|
|
} else {
|
|
Debug.fail("Only computed properties with literal names have declaration names");
|
|
}
|
|
}
|
|
if (isPrivateIdentifier(name)) {
|
|
const containingClass = getContainingClass(node);
|
|
if (!containingClass) {
|
|
return void 0;
|
|
}
|
|
const containingClassSymbol = containingClass.symbol;
|
|
return getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText);
|
|
}
|
|
return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return "__constructor" /* Constructor */;
|
|
case 181 /* FunctionType */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
return "__call" /* Call */;
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
return "__new" /* New */;
|
|
case 178 /* IndexSignature */:
|
|
return "__index" /* Index */;
|
|
case 275 /* ExportDeclaration */:
|
|
return "__export" /* ExportStar */;
|
|
case 308 /* SourceFile */:
|
|
return "export=" /* ExportEquals */;
|
|
case 223 /* BinaryExpression */:
|
|
if (getAssignmentDeclarationKind(node) === 2 /* ModuleExports */) {
|
|
return "export=" /* ExportEquals */;
|
|
}
|
|
Debug.fail("Unknown binary declaration kind");
|
|
break;
|
|
case 320 /* JSDocFunctionType */:
|
|
return isJSDocConstructSignature(node) ? "__new" /* New */ : "__call" /* Call */;
|
|
case 166 /* Parameter */:
|
|
Debug.assert(node.parent.kind === 320 /* JSDocFunctionType */, "Impossible parameter parent kind", () => `parent is: ${Debug.formatSyntaxKind(node.parent.kind)}, expected JSDocFunctionType`);
|
|
const functionType = node.parent;
|
|
const index = functionType.parameters.indexOf(node);
|
|
return "arg" + index;
|
|
}
|
|
}
|
|
function getDisplayName(node) {
|
|
return isNamedDeclaration(node) ? declarationNameToString(node.name) : unescapeLeadingUnderscores(Debug.checkDefined(getDeclarationName(node)));
|
|
}
|
|
function declareSymbol(symbolTable, parent3, node, includes, excludes, isReplaceableByMethod, isComputedName) {
|
|
Debug.assert(isComputedName || !hasDynamicName(node));
|
|
const isDefaultExport = hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node) && node.name.escapedText === "default";
|
|
const name = isComputedName ? "__computed" /* Computed */ : isDefaultExport && parent3 ? "default" /* Default */ : getDeclarationName(node);
|
|
let symbol;
|
|
if (name === void 0) {
|
|
symbol = createSymbol(0 /* None */, "__missing" /* Missing */);
|
|
} else {
|
|
symbol = symbolTable.get(name);
|
|
if (includes & 2885600 /* Classifiable */) {
|
|
classifiableNames.add(name);
|
|
}
|
|
if (!symbol) {
|
|
symbolTable.set(name, symbol = createSymbol(0 /* None */, name));
|
|
if (isReplaceableByMethod)
|
|
symbol.isReplaceableByMethod = true;
|
|
} else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) {
|
|
return symbol;
|
|
} else if (symbol.flags & excludes) {
|
|
if (symbol.isReplaceableByMethod) {
|
|
symbolTable.set(name, symbol = createSymbol(0 /* None */, name));
|
|
} else if (!(includes & 3 /* Variable */ && symbol.flags & 67108864 /* Assignment */)) {
|
|
if (isNamedDeclaration(node)) {
|
|
setParent(node.name, node);
|
|
}
|
|
let message = symbol.flags & 2 /* BlockScopedVariable */ ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
let messageNeedsName = true;
|
|
if (symbol.flags & 384 /* Enum */ || includes & 384 /* Enum */) {
|
|
message = Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations;
|
|
messageNeedsName = false;
|
|
}
|
|
let multipleDefaultExports = false;
|
|
if (length(symbol.declarations)) {
|
|
if (isDefaultExport) {
|
|
message = Diagnostics.A_module_cannot_have_multiple_default_exports;
|
|
messageNeedsName = false;
|
|
multipleDefaultExports = true;
|
|
} else {
|
|
if (symbol.declarations && symbol.declarations.length && (node.kind === 274 /* ExportAssignment */ && !node.isExportEquals)) {
|
|
message = Diagnostics.A_module_cannot_have_multiple_default_exports;
|
|
messageNeedsName = false;
|
|
multipleDefaultExports = true;
|
|
}
|
|
}
|
|
}
|
|
const relatedInformation = [];
|
|
if (isTypeAliasDeclaration(node) && nodeIsMissing(node.type) && hasSyntacticModifier(node, 1 /* Export */) && symbol.flags & (2097152 /* Alias */ | 788968 /* Type */ | 1920 /* Namespace */)) {
|
|
relatedInformation.push(createDiagnosticForNode2(node, Diagnostics.Did_you_mean_0, `export type { ${unescapeLeadingUnderscores(node.name.escapedText)} }`));
|
|
}
|
|
const declarationName = getNameOfDeclaration(node) || node;
|
|
forEach(symbol.declarations, (declaration, index) => {
|
|
const decl = getNameOfDeclaration(declaration) || declaration;
|
|
const diag3 = createDiagnosticForNode2(decl, message, messageNeedsName ? getDisplayName(declaration) : void 0);
|
|
file.bindDiagnostics.push(
|
|
multipleDefaultExports ? addRelatedInfo(diag3, createDiagnosticForNode2(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag3
|
|
);
|
|
if (multipleDefaultExports) {
|
|
relatedInformation.push(createDiagnosticForNode2(decl, Diagnostics.The_first_export_default_is_here));
|
|
}
|
|
});
|
|
const diag2 = createDiagnosticForNode2(declarationName, message, messageNeedsName ? getDisplayName(node) : void 0);
|
|
file.bindDiagnostics.push(addRelatedInfo(diag2, ...relatedInformation));
|
|
symbol = createSymbol(0 /* None */, name);
|
|
}
|
|
}
|
|
}
|
|
addDeclarationToSymbol(symbol, node, includes);
|
|
if (symbol.parent) {
|
|
Debug.assert(symbol.parent === parent3, "Existing symbol parent should match new one");
|
|
} else {
|
|
symbol.parent = parent3;
|
|
}
|
|
return symbol;
|
|
}
|
|
function declareModuleMember(node, symbolFlags, symbolExcludes) {
|
|
const hasExportModifier = !!(getCombinedModifierFlags(node) & 1 /* Export */) || jsdocTreatAsExported(node);
|
|
if (symbolFlags & 2097152 /* Alias */) {
|
|
if (node.kind === 278 /* ExportSpecifier */ || node.kind === 268 /* ImportEqualsDeclaration */ && hasExportModifier) {
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
} else {
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
} else {
|
|
if (isJSDocTypeAlias(node))
|
|
Debug.assert(isInJSFile(node));
|
|
if (!isAmbientModule(node) && (hasExportModifier || container.flags & 64 /* ExportContext */)) {
|
|
if (!container.locals || hasSyntacticModifier(node, 1024 /* Default */) && !getDeclarationName(node)) {
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
}
|
|
const exportKind = symbolFlags & 111551 /* Value */ ? 1048576 /* ExportValue */ : 0;
|
|
const local = declareSymbol(container.locals, void 0, node, exportKind, symbolExcludes);
|
|
local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
node.localSymbol = local;
|
|
return local;
|
|
} else {
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
}
|
|
function jsdocTreatAsExported(node) {
|
|
if (node.parent && isModuleDeclaration(node)) {
|
|
node = node.parent;
|
|
}
|
|
if (!isJSDocTypeAlias(node))
|
|
return false;
|
|
if (!isJSDocEnumTag(node) && !!node.fullName)
|
|
return true;
|
|
const declName = getNameOfDeclaration(node);
|
|
if (!declName)
|
|
return false;
|
|
if (isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent))
|
|
return true;
|
|
if (isDeclaration(declName.parent) && getCombinedModifierFlags(declName.parent) & 1 /* Export */)
|
|
return true;
|
|
return false;
|
|
}
|
|
function bindContainer(node, containerFlags) {
|
|
const saveContainer = container;
|
|
const saveThisParentContainer = thisParentContainer;
|
|
const savedBlockScopeContainer = blockScopeContainer;
|
|
if (containerFlags & 1 /* IsContainer */) {
|
|
if (node.kind !== 216 /* ArrowFunction */) {
|
|
thisParentContainer = container;
|
|
}
|
|
container = blockScopeContainer = node;
|
|
if (containerFlags & 32 /* HasLocals */) {
|
|
container.locals = createSymbolTable();
|
|
}
|
|
addToContainerChain(container);
|
|
} else if (containerFlags & 2 /* IsBlockScopedContainer */) {
|
|
blockScopeContainer = node;
|
|
blockScopeContainer.locals = void 0;
|
|
}
|
|
if (containerFlags & 4 /* IsControlFlowContainer */) {
|
|
const saveCurrentFlow = currentFlow;
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const saveContinueTarget = currentContinueTarget;
|
|
const saveReturnTarget = currentReturnTarget;
|
|
const saveExceptionTarget = currentExceptionTarget;
|
|
const saveActiveLabelList = activeLabelList;
|
|
const saveHasExplicitReturn = hasExplicitReturn;
|
|
const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 512 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
if (!isImmediatelyInvoked) {
|
|
currentFlow = initFlowNode({ flags: 2 /* Start */ });
|
|
if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
|
|
currentFlow.node = node;
|
|
}
|
|
}
|
|
currentReturnTarget = isImmediatelyInvoked || node.kind === 173 /* Constructor */ || isInJSFile(node) && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */) ? createBranchLabel() : void 0;
|
|
currentExceptionTarget = void 0;
|
|
currentBreakTarget = void 0;
|
|
currentContinueTarget = void 0;
|
|
activeLabelList = void 0;
|
|
hasExplicitReturn = false;
|
|
bindChildren(node);
|
|
node.flags &= ~2816 /* ReachabilityAndEmitFlags */;
|
|
if (!(currentFlow.flags & 1 /* Unreachable */) && containerFlags & 8 /* IsFunctionLike */ && nodeIsPresent(node.body)) {
|
|
node.flags |= 256 /* HasImplicitReturn */;
|
|
if (hasExplicitReturn)
|
|
node.flags |= 512 /* HasExplicitReturn */;
|
|
node.endFlowNode = currentFlow;
|
|
}
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
node.flags |= emitFlags;
|
|
node.endFlowNode = currentFlow;
|
|
}
|
|
if (currentReturnTarget) {
|
|
addAntecedent(currentReturnTarget, currentFlow);
|
|
currentFlow = finishFlowLabel(currentReturnTarget);
|
|
if (node.kind === 173 /* Constructor */ || node.kind === 172 /* ClassStaticBlockDeclaration */ || isInJSFile(node) && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */)) {
|
|
node.returnFlowNode = currentFlow;
|
|
}
|
|
}
|
|
if (!isImmediatelyInvoked) {
|
|
currentFlow = saveCurrentFlow;
|
|
}
|
|
currentBreakTarget = saveBreakTarget;
|
|
currentContinueTarget = saveContinueTarget;
|
|
currentReturnTarget = saveReturnTarget;
|
|
currentExceptionTarget = saveExceptionTarget;
|
|
activeLabelList = saveActiveLabelList;
|
|
hasExplicitReturn = saveHasExplicitReturn;
|
|
} else if (containerFlags & 64 /* IsInterface */) {
|
|
seenThisKeyword = false;
|
|
bindChildren(node);
|
|
node.flags = seenThisKeyword ? node.flags | 128 /* ContainsThis */ : node.flags & ~128 /* ContainsThis */;
|
|
} else {
|
|
bindChildren(node);
|
|
}
|
|
container = saveContainer;
|
|
thisParentContainer = saveThisParentContainer;
|
|
blockScopeContainer = savedBlockScopeContainer;
|
|
}
|
|
function bindEachFunctionsFirst(nodes) {
|
|
bindEach(nodes, (n) => n.kind === 259 /* FunctionDeclaration */ ? bind(n) : void 0);
|
|
bindEach(nodes, (n) => n.kind !== 259 /* FunctionDeclaration */ ? bind(n) : void 0);
|
|
}
|
|
function bindEach(nodes, bindFunction = bind) {
|
|
if (nodes === void 0) {
|
|
return;
|
|
}
|
|
forEach(nodes, bindFunction);
|
|
}
|
|
function bindEachChild(node) {
|
|
forEachChild(node, bind, bindEach);
|
|
}
|
|
function bindChildren(node) {
|
|
const saveInAssignmentPattern = inAssignmentPattern;
|
|
inAssignmentPattern = false;
|
|
if (checkUnreachable(node)) {
|
|
bindEachChild(node);
|
|
bindJSDoc(node);
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
return;
|
|
}
|
|
if (node.kind >= 240 /* FirstStatement */ && node.kind <= 256 /* LastStatement */ && !options.allowUnreachableCode) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
switch (node.kind) {
|
|
case 244 /* WhileStatement */:
|
|
bindWhileStatement(node);
|
|
break;
|
|
case 243 /* DoStatement */:
|
|
bindDoStatement(node);
|
|
break;
|
|
case 245 /* ForStatement */:
|
|
bindForStatement(node);
|
|
break;
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
bindForInOrForOfStatement(node);
|
|
break;
|
|
case 242 /* IfStatement */:
|
|
bindIfStatement(node);
|
|
break;
|
|
case 250 /* ReturnStatement */:
|
|
case 254 /* ThrowStatement */:
|
|
bindReturnOrThrow(node);
|
|
break;
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
bindBreakOrContinueStatement(node);
|
|
break;
|
|
case 255 /* TryStatement */:
|
|
bindTryStatement(node);
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
bindSwitchStatement(node);
|
|
break;
|
|
case 266 /* CaseBlock */:
|
|
bindCaseBlock(node);
|
|
break;
|
|
case 292 /* CaseClause */:
|
|
bindCaseClause(node);
|
|
break;
|
|
case 241 /* ExpressionStatement */:
|
|
bindExpressionStatement(node);
|
|
break;
|
|
case 253 /* LabeledStatement */:
|
|
bindLabeledStatement(node);
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
bindPrefixUnaryExpressionFlow(node);
|
|
break;
|
|
case 222 /* PostfixUnaryExpression */:
|
|
bindPostfixUnaryExpressionFlow(node);
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
bindDestructuringAssignmentFlow(node);
|
|
return;
|
|
}
|
|
bindBinaryExpressionFlow(node);
|
|
break;
|
|
case 217 /* DeleteExpression */:
|
|
bindDeleteExpressionFlow(node);
|
|
break;
|
|
case 224 /* ConditionalExpression */:
|
|
bindConditionalExpressionFlow(node);
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
bindVariableDeclarationFlow(node);
|
|
break;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
bindAccessExpressionFlow(node);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
bindCallExpressionFlow(node);
|
|
break;
|
|
case 232 /* NonNullExpression */:
|
|
bindNonNullExpressionFlow(node);
|
|
break;
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
bindJSDocTypeAlias(node);
|
|
break;
|
|
case 308 /* SourceFile */: {
|
|
bindEachFunctionsFirst(node.statements);
|
|
bind(node.endOfFileToken);
|
|
break;
|
|
}
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
bindEachFunctionsFirst(node.statements);
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
bindBindingElementFlow(node);
|
|
break;
|
|
case 166 /* Parameter */:
|
|
bindParameterFlow(node);
|
|
break;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 227 /* SpreadElement */:
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
default:
|
|
bindEachChild(node);
|
|
break;
|
|
}
|
|
bindJSDoc(node);
|
|
inAssignmentPattern = saveInAssignmentPattern;
|
|
}
|
|
function isNarrowingExpression(expr) {
|
|
switch (expr.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 108 /* ThisKeyword */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return containsNarrowableReference(expr);
|
|
case 210 /* CallExpression */:
|
|
return hasNarrowableArgument(expr);
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return isNarrowingExpression(expr.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isNarrowingBinaryExpression(expr);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return expr.operator === 53 /* ExclamationToken */ && isNarrowingExpression(expr.operand);
|
|
case 218 /* TypeOfExpression */:
|
|
return isNarrowingExpression(expr.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowableReference(expr) {
|
|
return isDottedName(expr) || (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || isBinaryExpression(expr) && expr.operatorToken.kind === 27 /* CommaToken */ && isNarrowableReference(expr.right) || isElementAccessExpression(expr) && (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression) || isAssignmentExpression(expr) && isNarrowableReference(expr.left);
|
|
}
|
|
function containsNarrowableReference(expr) {
|
|
return isNarrowableReference(expr) || isOptionalChain(expr) && containsNarrowableReference(expr.expression);
|
|
}
|
|
function hasNarrowableArgument(expr) {
|
|
if (expr.arguments) {
|
|
for (const argument of expr.arguments) {
|
|
if (containsNarrowableReference(argument)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (expr.expression.kind === 208 /* PropertyAccessExpression */ && containsNarrowableReference(expr.expression.expression)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowingTypeofOperands(expr1, expr2) {
|
|
return isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && isStringLiteralLike(expr2);
|
|
}
|
|
function isNarrowingBinaryExpression(expr) {
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return containsNarrowableReference(expr.left);
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
|
|
case 102 /* InstanceOfKeyword */:
|
|
return isNarrowableOperand(expr.left);
|
|
case 101 /* InKeyword */:
|
|
return isNarrowingExpression(expr.right);
|
|
case 27 /* CommaToken */:
|
|
return isNarrowingExpression(expr.right);
|
|
}
|
|
return false;
|
|
}
|
|
function isNarrowableOperand(expr) {
|
|
switch (expr.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isNarrowableOperand(expr.expression);
|
|
case 223 /* BinaryExpression */:
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
return isNarrowableOperand(expr.left);
|
|
case 27 /* CommaToken */:
|
|
return isNarrowableOperand(expr.right);
|
|
}
|
|
}
|
|
return containsNarrowableReference(expr);
|
|
}
|
|
function createBranchLabel() {
|
|
return initFlowNode({ flags: 4 /* BranchLabel */, antecedents: void 0 });
|
|
}
|
|
function createLoopLabel() {
|
|
return initFlowNode({ flags: 8 /* LoopLabel */, antecedents: void 0 });
|
|
}
|
|
function createReduceLabel(target, antecedents, antecedent) {
|
|
return initFlowNode({ flags: 1024 /* ReduceLabel */, target, antecedents, antecedent });
|
|
}
|
|
function setFlowNodeReferenced(flow) {
|
|
flow.flags |= flow.flags & 2048 /* Referenced */ ? 4096 /* Shared */ : 2048 /* Referenced */;
|
|
}
|
|
function addAntecedent(label, antecedent) {
|
|
if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedents, antecedent)) {
|
|
(label.antecedents || (label.antecedents = [])).push(antecedent);
|
|
setFlowNodeReferenced(antecedent);
|
|
}
|
|
}
|
|
function createFlowCondition(flags, antecedent, expression) {
|
|
if (antecedent.flags & 1 /* Unreachable */) {
|
|
return antecedent;
|
|
}
|
|
if (!expression) {
|
|
return flags & 32 /* TrueCondition */ ? antecedent : unreachableFlow;
|
|
}
|
|
if ((expression.kind === 110 /* TrueKeyword */ && flags & 64 /* FalseCondition */ || expression.kind === 95 /* FalseKeyword */ && flags & 32 /* TrueCondition */) && !isExpressionOfOptionalChainRoot(expression) && !isNullishCoalesce(expression.parent)) {
|
|
return unreachableFlow;
|
|
}
|
|
if (!isNarrowingExpression(expression)) {
|
|
return antecedent;
|
|
}
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags, antecedent, node: expression });
|
|
}
|
|
function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags: 128 /* SwitchClause */, antecedent, switchStatement, clauseStart, clauseEnd });
|
|
}
|
|
function createFlowMutation(flags, antecedent, node) {
|
|
setFlowNodeReferenced(antecedent);
|
|
const result = initFlowNode({ flags, antecedent, node });
|
|
if (currentExceptionTarget) {
|
|
addAntecedent(currentExceptionTarget, result);
|
|
}
|
|
return result;
|
|
}
|
|
function createFlowCall(antecedent, node) {
|
|
setFlowNodeReferenced(antecedent);
|
|
return initFlowNode({ flags: 512 /* Call */, antecedent, node });
|
|
}
|
|
function finishFlowLabel(flow) {
|
|
const antecedents = flow.antecedents;
|
|
if (!antecedents) {
|
|
return unreachableFlow;
|
|
}
|
|
if (antecedents.length === 1) {
|
|
return antecedents[0];
|
|
}
|
|
return flow;
|
|
}
|
|
function isStatementCondition(node) {
|
|
const parent3 = node.parent;
|
|
switch (parent3.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 243 /* DoStatement */:
|
|
return parent3.expression === node;
|
|
case 245 /* ForStatement */:
|
|
case 224 /* ConditionalExpression */:
|
|
return parent3.condition === node;
|
|
}
|
|
return false;
|
|
}
|
|
function isLogicalExpression(node) {
|
|
while (true) {
|
|
if (node.kind === 214 /* ParenthesizedExpression */) {
|
|
node = node.expression;
|
|
} else if (node.kind === 221 /* PrefixUnaryExpression */ && node.operator === 53 /* ExclamationToken */) {
|
|
node = node.operand;
|
|
} else {
|
|
return node.kind === 223 /* BinaryExpression */ && (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || node.operatorToken.kind === 56 /* BarBarToken */ || node.operatorToken.kind === 60 /* QuestionQuestionToken */);
|
|
}
|
|
}
|
|
}
|
|
function isLogicalAssignmentExpression(node) {
|
|
node = skipParentheses(node);
|
|
return isBinaryExpression(node) && isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind);
|
|
}
|
|
function isTopLevelLogicalExpression(node) {
|
|
while (isParenthesizedExpression(node.parent) || isPrefixUnaryExpression(node.parent) && node.parent.operator === 53 /* ExclamationToken */) {
|
|
node = node.parent;
|
|
}
|
|
return !isStatementCondition(node) && !isLogicalExpression(node.parent) && !(isOptionalChain(node.parent) && node.parent.expression === node);
|
|
}
|
|
function doWithConditionalBranches(action, value, trueTarget, falseTarget) {
|
|
const savedTrueTarget = currentTrueTarget;
|
|
const savedFalseTarget = currentFalseTarget;
|
|
currentTrueTarget = trueTarget;
|
|
currentFalseTarget = falseTarget;
|
|
action(value);
|
|
currentTrueTarget = savedTrueTarget;
|
|
currentFalseTarget = savedFalseTarget;
|
|
}
|
|
function bindCondition(node, trueTarget, falseTarget) {
|
|
doWithConditionalBranches(bind, node, trueTarget, falseTarget);
|
|
if (!node || !isLogicalAssignmentExpression(node) && !isLogicalExpression(node) && !(isOptionalChain(node) && isOutermostOptionalChain(node))) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindIterativeStatement(node, breakTarget, continueTarget) {
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const saveContinueTarget = currentContinueTarget;
|
|
currentBreakTarget = breakTarget;
|
|
currentContinueTarget = continueTarget;
|
|
bind(node);
|
|
currentBreakTarget = saveBreakTarget;
|
|
currentContinueTarget = saveContinueTarget;
|
|
}
|
|
function setContinueTarget(node, target) {
|
|
let label = activeLabelList;
|
|
while (label && node.parent.kind === 253 /* LabeledStatement */) {
|
|
label.continueTarget = target;
|
|
label = label.next;
|
|
node = node.parent;
|
|
}
|
|
return target;
|
|
}
|
|
function bindWhileStatement(node) {
|
|
const preWhileLabel = setContinueTarget(node, createLoopLabel());
|
|
const preBodyLabel = createBranchLabel();
|
|
const postWhileLabel = createBranchLabel();
|
|
addAntecedent(preWhileLabel, currentFlow);
|
|
currentFlow = preWhileLabel;
|
|
bindCondition(node.expression, preBodyLabel, postWhileLabel);
|
|
currentFlow = finishFlowLabel(preBodyLabel);
|
|
bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel);
|
|
addAntecedent(preWhileLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postWhileLabel);
|
|
}
|
|
function bindDoStatement(node) {
|
|
const preDoLabel = createLoopLabel();
|
|
const preConditionLabel = setContinueTarget(node, createBranchLabel());
|
|
const postDoLabel = createBranchLabel();
|
|
addAntecedent(preDoLabel, currentFlow);
|
|
currentFlow = preDoLabel;
|
|
bindIterativeStatement(node.statement, postDoLabel, preConditionLabel);
|
|
addAntecedent(preConditionLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(preConditionLabel);
|
|
bindCondition(node.expression, preDoLabel, postDoLabel);
|
|
currentFlow = finishFlowLabel(postDoLabel);
|
|
}
|
|
function bindForStatement(node) {
|
|
const preLoopLabel = setContinueTarget(node, createLoopLabel());
|
|
const preBodyLabel = createBranchLabel();
|
|
const postLoopLabel = createBranchLabel();
|
|
bind(node.initializer);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = preLoopLabel;
|
|
bindCondition(node.condition, preBodyLabel, postLoopLabel);
|
|
currentFlow = finishFlowLabel(preBodyLabel);
|
|
bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
|
|
bind(node.incrementor);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postLoopLabel);
|
|
}
|
|
function bindForInOrForOfStatement(node) {
|
|
const preLoopLabel = setContinueTarget(node, createLoopLabel());
|
|
const postLoopLabel = createBranchLabel();
|
|
bind(node.expression);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = preLoopLabel;
|
|
if (node.kind === 247 /* ForOfStatement */) {
|
|
bind(node.awaitModifier);
|
|
}
|
|
addAntecedent(postLoopLabel, currentFlow);
|
|
bind(node.initializer);
|
|
if (node.initializer.kind !== 258 /* VariableDeclarationList */) {
|
|
bindAssignmentTargetFlow(node.initializer);
|
|
}
|
|
bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel);
|
|
addAntecedent(preLoopLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postLoopLabel);
|
|
}
|
|
function bindIfStatement(node) {
|
|
const thenLabel = createBranchLabel();
|
|
const elseLabel = createBranchLabel();
|
|
const postIfLabel = createBranchLabel();
|
|
bindCondition(node.expression, thenLabel, elseLabel);
|
|
currentFlow = finishFlowLabel(thenLabel);
|
|
bind(node.thenStatement);
|
|
addAntecedent(postIfLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(elseLabel);
|
|
bind(node.elseStatement);
|
|
addAntecedent(postIfLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postIfLabel);
|
|
}
|
|
function bindReturnOrThrow(node) {
|
|
bind(node.expression);
|
|
if (node.kind === 250 /* ReturnStatement */) {
|
|
hasExplicitReturn = true;
|
|
if (currentReturnTarget) {
|
|
addAntecedent(currentReturnTarget, currentFlow);
|
|
}
|
|
}
|
|
currentFlow = unreachableFlow;
|
|
}
|
|
function findActiveLabel(name) {
|
|
for (let label = activeLabelList; label; label = label.next) {
|
|
if (label.name === name) {
|
|
return label;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function bindBreakOrContinueFlow(node, breakTarget, continueTarget) {
|
|
const flowLabel = node.kind === 249 /* BreakStatement */ ? breakTarget : continueTarget;
|
|
if (flowLabel) {
|
|
addAntecedent(flowLabel, currentFlow);
|
|
currentFlow = unreachableFlow;
|
|
}
|
|
}
|
|
function bindBreakOrContinueStatement(node) {
|
|
bind(node.label);
|
|
if (node.label) {
|
|
const activeLabel = findActiveLabel(node.label.escapedText);
|
|
if (activeLabel) {
|
|
activeLabel.referenced = true;
|
|
bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget);
|
|
}
|
|
} else {
|
|
bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget);
|
|
}
|
|
}
|
|
function bindTryStatement(node) {
|
|
const saveReturnTarget = currentReturnTarget;
|
|
const saveExceptionTarget = currentExceptionTarget;
|
|
const normalExitLabel = createBranchLabel();
|
|
const returnLabel = createBranchLabel();
|
|
let exceptionLabel = createBranchLabel();
|
|
if (node.finallyBlock) {
|
|
currentReturnTarget = returnLabel;
|
|
}
|
|
addAntecedent(exceptionLabel, currentFlow);
|
|
currentExceptionTarget = exceptionLabel;
|
|
bind(node.tryBlock);
|
|
addAntecedent(normalExitLabel, currentFlow);
|
|
if (node.catchClause) {
|
|
currentFlow = finishFlowLabel(exceptionLabel);
|
|
exceptionLabel = createBranchLabel();
|
|
addAntecedent(exceptionLabel, currentFlow);
|
|
currentExceptionTarget = exceptionLabel;
|
|
bind(node.catchClause);
|
|
addAntecedent(normalExitLabel, currentFlow);
|
|
}
|
|
currentReturnTarget = saveReturnTarget;
|
|
currentExceptionTarget = saveExceptionTarget;
|
|
if (node.finallyBlock) {
|
|
const finallyLabel = createBranchLabel();
|
|
finallyLabel.antecedents = concatenate(concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
|
|
currentFlow = finallyLabel;
|
|
bind(node.finallyBlock);
|
|
if (currentFlow.flags & 1 /* Unreachable */) {
|
|
currentFlow = unreachableFlow;
|
|
} else {
|
|
if (currentReturnTarget && returnLabel.antecedents) {
|
|
addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
|
|
}
|
|
if (currentExceptionTarget && exceptionLabel.antecedents) {
|
|
addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow));
|
|
}
|
|
currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
|
|
}
|
|
} else {
|
|
currentFlow = finishFlowLabel(normalExitLabel);
|
|
}
|
|
}
|
|
function bindSwitchStatement(node) {
|
|
const postSwitchLabel = createBranchLabel();
|
|
bind(node.expression);
|
|
const saveBreakTarget = currentBreakTarget;
|
|
const savePreSwitchCaseFlow = preSwitchCaseFlow;
|
|
currentBreakTarget = postSwitchLabel;
|
|
preSwitchCaseFlow = currentFlow;
|
|
bind(node.caseBlock);
|
|
addAntecedent(postSwitchLabel, currentFlow);
|
|
const hasDefault = forEach(node.caseBlock.clauses, (c) => c.kind === 293 /* DefaultClause */);
|
|
node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
|
|
if (!hasDefault) {
|
|
addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
|
|
}
|
|
currentBreakTarget = saveBreakTarget;
|
|
preSwitchCaseFlow = savePreSwitchCaseFlow;
|
|
currentFlow = finishFlowLabel(postSwitchLabel);
|
|
}
|
|
function bindCaseBlock(node) {
|
|
const clauses = node.clauses;
|
|
const isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
|
|
let fallthroughFlow = unreachableFlow;
|
|
for (let i = 0; i < clauses.length; i++) {
|
|
const clauseStart = i;
|
|
while (!clauses[i].statements.length && i + 1 < clauses.length) {
|
|
bind(clauses[i]);
|
|
i++;
|
|
}
|
|
const preCaseLabel = createBranchLabel();
|
|
addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow);
|
|
addAntecedent(preCaseLabel, fallthroughFlow);
|
|
currentFlow = finishFlowLabel(preCaseLabel);
|
|
const clause = clauses[i];
|
|
bind(clause);
|
|
fallthroughFlow = currentFlow;
|
|
if (!(currentFlow.flags & 1 /* Unreachable */) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) {
|
|
clause.fallthroughFlowNode = currentFlow;
|
|
}
|
|
}
|
|
}
|
|
function bindCaseClause(node) {
|
|
const saveCurrentFlow = currentFlow;
|
|
currentFlow = preSwitchCaseFlow;
|
|
bind(node.expression);
|
|
currentFlow = saveCurrentFlow;
|
|
bindEach(node.statements);
|
|
}
|
|
function bindExpressionStatement(node) {
|
|
bind(node.expression);
|
|
maybeBindExpressionFlowIfCall(node.expression);
|
|
}
|
|
function maybeBindExpressionFlowIfCall(node) {
|
|
if (node.kind === 210 /* CallExpression */) {
|
|
const call = node;
|
|
if (call.expression.kind !== 106 /* SuperKeyword */ && isDottedName(call.expression)) {
|
|
currentFlow = createFlowCall(currentFlow, call);
|
|
}
|
|
}
|
|
}
|
|
function bindLabeledStatement(node) {
|
|
const postStatementLabel = createBranchLabel();
|
|
activeLabelList = {
|
|
next: activeLabelList,
|
|
name: node.label.escapedText,
|
|
breakTarget: postStatementLabel,
|
|
continueTarget: void 0,
|
|
referenced: false
|
|
};
|
|
bind(node.label);
|
|
bind(node.statement);
|
|
if (!activeLabelList.referenced && !options.allowUnusedLabels) {
|
|
errorOrSuggestionOnNode(unusedLabelIsError(options), node.label, Diagnostics.Unused_label);
|
|
}
|
|
activeLabelList = activeLabelList.next;
|
|
addAntecedent(postStatementLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postStatementLabel);
|
|
}
|
|
function bindDestructuringTargetFlow(node) {
|
|
if (node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 63 /* EqualsToken */) {
|
|
bindAssignmentTargetFlow(node.left);
|
|
} else {
|
|
bindAssignmentTargetFlow(node);
|
|
}
|
|
}
|
|
function bindAssignmentTargetFlow(node) {
|
|
if (isNarrowableReference(node)) {
|
|
currentFlow = createFlowMutation(16 /* Assignment */, currentFlow, node);
|
|
} else if (node.kind === 206 /* ArrayLiteralExpression */) {
|
|
for (const e of node.elements) {
|
|
if (e.kind === 227 /* SpreadElement */) {
|
|
bindAssignmentTargetFlow(e.expression);
|
|
} else {
|
|
bindDestructuringTargetFlow(e);
|
|
}
|
|
}
|
|
} else if (node.kind === 207 /* ObjectLiteralExpression */) {
|
|
for (const p of node.properties) {
|
|
if (p.kind === 299 /* PropertyAssignment */) {
|
|
bindDestructuringTargetFlow(p.initializer);
|
|
} else if (p.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
bindAssignmentTargetFlow(p.name);
|
|
} else if (p.kind === 301 /* SpreadAssignment */) {
|
|
bindAssignmentTargetFlow(p.expression);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function bindLogicalLikeExpression(node, trueTarget, falseTarget) {
|
|
const preRightLabel = createBranchLabel();
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || node.operatorToken.kind === 76 /* AmpersandAmpersandEqualsToken */) {
|
|
bindCondition(node.left, preRightLabel, falseTarget);
|
|
} else {
|
|
bindCondition(node.left, trueTarget, preRightLabel);
|
|
}
|
|
currentFlow = finishFlowLabel(preRightLabel);
|
|
bind(node.operatorToken);
|
|
if (isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind)) {
|
|
doWithConditionalBranches(bind, node.right, trueTarget, falseTarget);
|
|
bindAssignmentTargetFlow(node.left);
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
} else {
|
|
bindCondition(node.right, trueTarget, falseTarget);
|
|
}
|
|
}
|
|
function bindPrefixUnaryExpressionFlow(node) {
|
|
if (node.operator === 53 /* ExclamationToken */) {
|
|
const saveTrueTarget = currentTrueTarget;
|
|
currentTrueTarget = currentFalseTarget;
|
|
currentFalseTarget = saveTrueTarget;
|
|
bindEachChild(node);
|
|
currentFalseTarget = currentTrueTarget;
|
|
currentTrueTarget = saveTrueTarget;
|
|
} else {
|
|
bindEachChild(node);
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
bindAssignmentTargetFlow(node.operand);
|
|
}
|
|
}
|
|
}
|
|
function bindPostfixUnaryExpressionFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
bindAssignmentTargetFlow(node.operand);
|
|
}
|
|
}
|
|
function bindDestructuringAssignmentFlow(node) {
|
|
if (inAssignmentPattern) {
|
|
inAssignmentPattern = false;
|
|
bind(node.operatorToken);
|
|
bind(node.right);
|
|
inAssignmentPattern = true;
|
|
bind(node.left);
|
|
} else {
|
|
inAssignmentPattern = true;
|
|
bind(node.left);
|
|
inAssignmentPattern = false;
|
|
bind(node.operatorToken);
|
|
bind(node.right);
|
|
}
|
|
bindAssignmentTargetFlow(node.left);
|
|
}
|
|
function createBindBinaryExpressionFlow() {
|
|
return createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, void 0);
|
|
function onEnter(node, state) {
|
|
if (state) {
|
|
state.stackIndex++;
|
|
setParent(node, parent2);
|
|
const saveInStrictMode = inStrictMode;
|
|
bindWorker(node);
|
|
const saveParent = parent2;
|
|
parent2 = node;
|
|
state.skip = false;
|
|
state.inStrictModeStack[state.stackIndex] = saveInStrictMode;
|
|
state.parentStack[state.stackIndex] = saveParent;
|
|
} else {
|
|
state = {
|
|
stackIndex: 0,
|
|
skip: false,
|
|
inStrictModeStack: [void 0],
|
|
parentStack: [void 0]
|
|
};
|
|
}
|
|
const operator = node.operatorToken.kind;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */ || isLogicalOrCoalescingAssignmentOperator(operator)) {
|
|
if (isTopLevelLogicalExpression(node)) {
|
|
const postExpressionLabel = createBranchLabel();
|
|
bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel);
|
|
currentFlow = finishFlowLabel(postExpressionLabel);
|
|
} else {
|
|
bindLogicalLikeExpression(node, currentTrueTarget, currentFalseTarget);
|
|
}
|
|
state.skip = true;
|
|
}
|
|
return state;
|
|
}
|
|
function onLeft(left, state, node) {
|
|
if (!state.skip) {
|
|
const maybeBound = maybeBind2(left);
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
maybeBindExpressionFlowIfCall(left);
|
|
}
|
|
return maybeBound;
|
|
}
|
|
}
|
|
function onOperator(operatorToken, state, _node) {
|
|
if (!state.skip) {
|
|
bind(operatorToken);
|
|
}
|
|
}
|
|
function onRight(right, state, node) {
|
|
if (!state.skip) {
|
|
const maybeBound = maybeBind2(right);
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
maybeBindExpressionFlowIfCall(right);
|
|
}
|
|
return maybeBound;
|
|
}
|
|
}
|
|
function onExit(node, state) {
|
|
if (!state.skip) {
|
|
const operator = node.operatorToken.kind;
|
|
if (isAssignmentOperator(operator) && !isAssignmentTarget(node)) {
|
|
bindAssignmentTargetFlow(node.left);
|
|
if (operator === 63 /* EqualsToken */ && node.left.kind === 209 /* ElementAccessExpression */) {
|
|
const elementAccess = node.left;
|
|
if (isNarrowableOperand(elementAccess.expression)) {
|
|
currentFlow = createFlowMutation(256 /* ArrayMutation */, currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const savedInStrictMode = state.inStrictModeStack[state.stackIndex];
|
|
const savedParent = state.parentStack[state.stackIndex];
|
|
if (savedInStrictMode !== void 0) {
|
|
inStrictMode = savedInStrictMode;
|
|
}
|
|
if (savedParent !== void 0) {
|
|
parent2 = savedParent;
|
|
}
|
|
state.skip = false;
|
|
state.stackIndex--;
|
|
}
|
|
function maybeBind2(node) {
|
|
if (node && isBinaryExpression(node) && !isDestructuringAssignment(node)) {
|
|
return node;
|
|
}
|
|
bind(node);
|
|
}
|
|
}
|
|
function bindDeleteExpressionFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.expression.kind === 208 /* PropertyAccessExpression */) {
|
|
bindAssignmentTargetFlow(node.expression);
|
|
}
|
|
}
|
|
function bindConditionalExpressionFlow(node) {
|
|
const trueLabel = createBranchLabel();
|
|
const falseLabel = createBranchLabel();
|
|
const postExpressionLabel = createBranchLabel();
|
|
bindCondition(node.condition, trueLabel, falseLabel);
|
|
currentFlow = finishFlowLabel(trueLabel);
|
|
bind(node.questionToken);
|
|
bind(node.whenTrue);
|
|
addAntecedent(postExpressionLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(falseLabel);
|
|
bind(node.colonToken);
|
|
bind(node.whenFalse);
|
|
addAntecedent(postExpressionLabel, currentFlow);
|
|
currentFlow = finishFlowLabel(postExpressionLabel);
|
|
}
|
|
function bindInitializedVariableFlow(node) {
|
|
const name = !isOmittedExpression(node) ? node.name : void 0;
|
|
if (isBindingPattern(name)) {
|
|
for (const child of name.elements) {
|
|
bindInitializedVariableFlow(child);
|
|
}
|
|
} else {
|
|
currentFlow = createFlowMutation(16 /* Assignment */, currentFlow, node);
|
|
}
|
|
}
|
|
function bindVariableDeclarationFlow(node) {
|
|
bindEachChild(node);
|
|
if (node.initializer || isForInOrOfStatement(node.parent.parent)) {
|
|
bindInitializedVariableFlow(node);
|
|
}
|
|
}
|
|
function bindBindingElementFlow(node) {
|
|
bind(node.dotDotDotToken);
|
|
bind(node.propertyName);
|
|
bindInitializer(node.initializer);
|
|
bind(node.name);
|
|
}
|
|
function bindParameterFlow(node) {
|
|
bindEach(node.modifiers);
|
|
bind(node.dotDotDotToken);
|
|
bind(node.questionToken);
|
|
bind(node.type);
|
|
bindInitializer(node.initializer);
|
|
bind(node.name);
|
|
}
|
|
function bindInitializer(node) {
|
|
if (!node) {
|
|
return;
|
|
}
|
|
const entryFlow = currentFlow;
|
|
bind(node);
|
|
if (entryFlow === unreachableFlow || entryFlow === currentFlow) {
|
|
return;
|
|
}
|
|
const exitFlow = createBranchLabel();
|
|
addAntecedent(exitFlow, entryFlow);
|
|
addAntecedent(exitFlow, currentFlow);
|
|
currentFlow = finishFlowLabel(exitFlow);
|
|
}
|
|
function bindJSDocTypeAlias(node) {
|
|
bind(node.tagName);
|
|
if (node.kind !== 342 /* JSDocEnumTag */ && node.fullName) {
|
|
setParent(node.fullName, node);
|
|
setParentRecursive(node.fullName, false);
|
|
}
|
|
if (typeof node.comment !== "string") {
|
|
bindEach(node.comment);
|
|
}
|
|
}
|
|
function bindJSDocClassTag(node) {
|
|
bindEachChild(node);
|
|
const host = getHostSignatureFromJSDoc(node);
|
|
if (host && host.kind !== 171 /* MethodDeclaration */) {
|
|
addDeclarationToSymbol(host.symbol, host, 32 /* Class */);
|
|
}
|
|
}
|
|
function bindOptionalExpression(node, trueTarget, falseTarget) {
|
|
doWithConditionalBranches(bind, node, trueTarget, falseTarget);
|
|
if (!isOptionalChain(node) || isOutermostOptionalChain(node)) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindOptionalChainRest(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
bind(node.questionDotToken);
|
|
bind(node.name);
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
bind(node.questionDotToken);
|
|
bind(node.argumentExpression);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
bind(node.questionDotToken);
|
|
bindEach(node.typeArguments);
|
|
bindEach(node.arguments);
|
|
break;
|
|
}
|
|
}
|
|
function bindOptionalChain(node, trueTarget, falseTarget) {
|
|
const preChainLabel = isOptionalChainRoot(node) ? createBranchLabel() : void 0;
|
|
bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget);
|
|
if (preChainLabel) {
|
|
currentFlow = finishFlowLabel(preChainLabel);
|
|
}
|
|
doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget);
|
|
if (isOutermostOptionalChain(node)) {
|
|
addAntecedent(trueTarget, createFlowCondition(32 /* TrueCondition */, currentFlow, node));
|
|
addAntecedent(falseTarget, createFlowCondition(64 /* FalseCondition */, currentFlow, node));
|
|
}
|
|
}
|
|
function bindOptionalChainFlow(node) {
|
|
if (isTopLevelLogicalExpression(node)) {
|
|
const postExpressionLabel = createBranchLabel();
|
|
bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
|
|
currentFlow = finishFlowLabel(postExpressionLabel);
|
|
} else {
|
|
bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
|
|
}
|
|
}
|
|
function bindNonNullExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
bindEachChild(node);
|
|
}
|
|
}
|
|
function bindAccessExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
bindEachChild(node);
|
|
}
|
|
}
|
|
function bindCallExpressionFlow(node) {
|
|
if (isOptionalChain(node)) {
|
|
bindOptionalChainFlow(node);
|
|
} else {
|
|
const expr = skipParentheses(node.expression);
|
|
if (expr.kind === 215 /* FunctionExpression */ || expr.kind === 216 /* ArrowFunction */) {
|
|
bindEach(node.typeArguments);
|
|
bindEach(node.arguments);
|
|
bind(node.expression);
|
|
} else {
|
|
bindEachChild(node);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
currentFlow = createFlowCall(currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
if (node.expression.kind === 208 /* PropertyAccessExpression */) {
|
|
const propertyAccess = node.expression;
|
|
if (isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) {
|
|
currentFlow = createFlowMutation(256 /* ArrayMutation */, currentFlow, node);
|
|
}
|
|
}
|
|
}
|
|
function getContainerFlags(node) {
|
|
switch (node.kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 289 /* JsxAttributes */:
|
|
return 1 /* IsContainer */;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return 1 /* IsContainer */ | 64 /* IsInterface */;
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 197 /* MappedType */:
|
|
case 178 /* IndexSignature */:
|
|
return 1 /* IsContainer */ | 32 /* HasLocals */;
|
|
case 308 /* SourceFile */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */;
|
|
}
|
|
case 173 /* Constructor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 181 /* FunctionType */:
|
|
case 177 /* ConstructSignature */:
|
|
case 182 /* ConstructorType */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */;
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 16 /* IsFunctionExpression */;
|
|
case 265 /* ModuleBlock */:
|
|
return 4 /* IsControlFlowContainer */;
|
|
case 169 /* PropertyDeclaration */:
|
|
return node.initializer ? 4 /* IsControlFlowContainer */ : 0;
|
|
case 295 /* CatchClause */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 266 /* CaseBlock */:
|
|
return 2 /* IsBlockScopedContainer */;
|
|
case 238 /* Block */:
|
|
return isFunctionLike(node.parent) || isClassStaticBlockDeclaration(node.parent) ? 0 /* None */ : 2 /* IsBlockScopedContainer */;
|
|
}
|
|
return 0 /* None */;
|
|
}
|
|
function addToContainerChain(next) {
|
|
if (lastContainer) {
|
|
lastContainer.nextContainer = next;
|
|
}
|
|
lastContainer = next;
|
|
}
|
|
function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
|
|
switch (container.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
return declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
case 308 /* SourceFile */:
|
|
return declareSourceFileMember(node, symbolFlags, symbolExcludes);
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
return declareClassMember(node, symbolFlags, symbolExcludes);
|
|
case 263 /* EnumDeclaration */:
|
|
return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes);
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 289 /* JsxAttributes */:
|
|
return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 326 /* JSDocSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 197 /* MappedType */:
|
|
return declareSymbol(container.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
function declareClassMember(node, symbolFlags, symbolExcludes) {
|
|
return isStatic(node) ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes) : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes);
|
|
}
|
|
function declareSourceFileMember(node, symbolFlags, symbolExcludes) {
|
|
return isExternalModule(file) ? declareModuleMember(node, symbolFlags, symbolExcludes) : declareSymbol(file.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
function hasExportDeclarations(node) {
|
|
const body = isSourceFile(node) ? node : tryCast(node.body, isModuleBlock);
|
|
return !!body && body.statements.some((s) => isExportDeclaration(s) || isExportAssignment(s));
|
|
}
|
|
function setExportContextFlag(node) {
|
|
if (node.flags & 16777216 /* Ambient */ && !hasExportDeclarations(node)) {
|
|
node.flags |= 64 /* ExportContext */;
|
|
} else {
|
|
node.flags &= ~64 /* ExportContext */;
|
|
}
|
|
}
|
|
function bindModuleDeclaration(node) {
|
|
setExportContextFlag(node);
|
|
if (isAmbientModule(node)) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
errorOnFirstToken(node, Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible);
|
|
}
|
|
if (isModuleAugmentationExternal(node)) {
|
|
declareModuleSymbol(node);
|
|
} else {
|
|
let pattern;
|
|
if (node.name.kind === 10 /* StringLiteral */) {
|
|
const { text } = node.name;
|
|
pattern = tryParsePattern(text);
|
|
if (pattern === void 0) {
|
|
errorOnFirstToken(node.name, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
|
|
}
|
|
}
|
|
const symbol = declareSymbolAndAddToSymbolTable(node, 512 /* ValueModule */, 110735 /* ValueModuleExcludes */);
|
|
file.patternAmbientModules = append(file.patternAmbientModules, pattern && !isString(pattern) ? { pattern, symbol } : void 0);
|
|
}
|
|
} else {
|
|
const state = declareModuleSymbol(node);
|
|
if (state !== 0 /* NonInstantiated */) {
|
|
const { symbol } = node;
|
|
symbol.constEnumOnlyModule = !(symbol.flags & (16 /* Function */ | 32 /* Class */ | 256 /* RegularEnum */)) && state === 2 /* ConstEnumOnly */ && symbol.constEnumOnlyModule !== false;
|
|
}
|
|
}
|
|
}
|
|
function declareModuleSymbol(node) {
|
|
const state = getModuleInstanceState(node);
|
|
const instantiated = state !== 0 /* NonInstantiated */;
|
|
declareSymbolAndAddToSymbolTable(
|
|
node,
|
|
instantiated ? 512 /* ValueModule */ : 1024 /* NamespaceModule */,
|
|
instantiated ? 110735 /* ValueModuleExcludes */ : 0 /* NamespaceModuleExcludes */
|
|
);
|
|
return state;
|
|
}
|
|
function bindFunctionOrConstructorType(node) {
|
|
const symbol = createSymbol(131072 /* Signature */, getDeclarationName(node));
|
|
addDeclarationToSymbol(symbol, node, 131072 /* Signature */);
|
|
const typeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* TypeLiteral */);
|
|
typeLiteralSymbol.members = createSymbolTable();
|
|
typeLiteralSymbol.members.set(symbol.escapedName, symbol);
|
|
}
|
|
function bindObjectLiteralExpression(node) {
|
|
return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__object" /* Object */);
|
|
}
|
|
function bindJsxAttributes(node) {
|
|
return bindAnonymousDeclaration(node, 4096 /* ObjectLiteral */, "__jsxAttributes" /* JSXAttributes */);
|
|
}
|
|
function bindJsxAttribute(node, symbolFlags, symbolExcludes) {
|
|
return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
|
|
}
|
|
function bindAnonymousDeclaration(node, symbolFlags, name) {
|
|
const symbol = createSymbol(symbolFlags, name);
|
|
if (symbolFlags & (8 /* EnumMember */ | 106500 /* ClassMember */)) {
|
|
symbol.parent = container.symbol;
|
|
}
|
|
addDeclarationToSymbol(symbol, node, symbolFlags);
|
|
return symbol;
|
|
}
|
|
function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) {
|
|
switch (blockScopeContainer.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
if (isExternalOrCommonJsModule(container)) {
|
|
declareModuleMember(node, symbolFlags, symbolExcludes);
|
|
break;
|
|
}
|
|
default:
|
|
if (!blockScopeContainer.locals) {
|
|
blockScopeContainer.locals = createSymbolTable();
|
|
addToContainerChain(blockScopeContainer);
|
|
}
|
|
declareSymbol(blockScopeContainer.locals, void 0, node, symbolFlags, symbolExcludes);
|
|
}
|
|
}
|
|
function delayedBindJSDocTypedefTag() {
|
|
if (!delayedTypeAliases) {
|
|
return;
|
|
}
|
|
const saveContainer = container;
|
|
const saveLastContainer = lastContainer;
|
|
const saveBlockScopeContainer = blockScopeContainer;
|
|
const saveParent = parent2;
|
|
const saveCurrentFlow = currentFlow;
|
|
for (const typeAlias of delayedTypeAliases) {
|
|
const host = typeAlias.parent.parent;
|
|
container = findAncestor(host.parent, (n) => !!(getContainerFlags(n) & 1 /* IsContainer */)) || file;
|
|
blockScopeContainer = getEnclosingBlockScopeContainer(host) || file;
|
|
currentFlow = initFlowNode({ flags: 2 /* Start */ });
|
|
parent2 = typeAlias;
|
|
bind(typeAlias.typeExpression);
|
|
const declName = getNameOfDeclaration(typeAlias);
|
|
if ((isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && isPropertyAccessEntityNameExpression(declName.parent)) {
|
|
const isTopLevel = isTopLevelNamespaceAssignment(declName.parent);
|
|
if (isTopLevel) {
|
|
bindPotentiallyMissingNamespaces(
|
|
file.symbol,
|
|
declName.parent,
|
|
isTopLevel,
|
|
!!findAncestor(declName, (d) => isPropertyAccessExpression(d) && d.name.escapedText === "prototype"),
|
|
false
|
|
);
|
|
const oldContainer = container;
|
|
switch (getAssignmentDeclarationPropertyAccessKind(declName.parent)) {
|
|
case 1 /* ExportsProperty */:
|
|
case 2 /* ModuleExports */:
|
|
if (!isExternalOrCommonJsModule(file)) {
|
|
container = void 0;
|
|
} else {
|
|
container = file;
|
|
}
|
|
break;
|
|
case 4 /* ThisProperty */:
|
|
container = declName.parent.expression;
|
|
break;
|
|
case 3 /* PrototypeProperty */:
|
|
container = declName.parent.expression.name;
|
|
break;
|
|
case 5 /* Property */:
|
|
container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file : isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name : declName.parent.expression;
|
|
break;
|
|
case 0 /* None */:
|
|
return Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration");
|
|
}
|
|
if (container) {
|
|
declareModuleMember(typeAlias, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
}
|
|
container = oldContainer;
|
|
}
|
|
} else if (isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 79 /* Identifier */) {
|
|
parent2 = typeAlias.parent;
|
|
bindBlockScopedDeclaration(typeAlias, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
} else {
|
|
bind(typeAlias.fullName);
|
|
}
|
|
}
|
|
container = saveContainer;
|
|
lastContainer = saveLastContainer;
|
|
blockScopeContainer = saveBlockScopeContainer;
|
|
parent2 = saveParent;
|
|
currentFlow = saveCurrentFlow;
|
|
}
|
|
function checkContextualIdentifier(node) {
|
|
if (!file.parseDiagnostics.length && !(node.flags & 16777216 /* Ambient */) && !(node.flags & 8388608 /* JSDoc */) && !isIdentifierName(node)) {
|
|
if (inStrictMode && node.originalKeywordKind >= 117 /* FirstFutureReservedWord */ && node.originalKeywordKind <= 125 /* LastFutureReservedWord */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
getStrictModeIdentifierMessage(node),
|
|
declarationNameToString(node)
|
|
));
|
|
} else if (node.originalKeywordKind === 133 /* AwaitKeyword */) {
|
|
if (isExternalModule(file) && isInTopLevelContext(node)) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module,
|
|
declarationNameToString(node)
|
|
));
|
|
} else if (node.flags & 32768 /* AwaitContext */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
} else if (node.originalKeywordKind === 125 /* YieldKeyword */ && node.flags & 8192 /* YieldContext */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function getStrictModeIdentifierMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode;
|
|
}
|
|
if (file.externalModuleIndicator) {
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
|
|
}
|
|
function checkPrivateIdentifier(node) {
|
|
if (node.escapedText === "#constructor") {
|
|
if (!file.parseDiagnostics.length) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(
|
|
node,
|
|
Diagnostics.constructor_is_a_reserved_word,
|
|
declarationNameToString(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeBinaryExpression(node) {
|
|
if (inStrictMode && isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operatorToken.kind)) {
|
|
checkStrictModeEvalOrArguments(node, node.left);
|
|
}
|
|
}
|
|
function checkStrictModeCatchClause(node) {
|
|
if (inStrictMode && node.variableDeclaration) {
|
|
checkStrictModeEvalOrArguments(node, node.variableDeclaration.name);
|
|
}
|
|
}
|
|
function checkStrictModeDeleteExpression(node) {
|
|
if (inStrictMode && node.expression.kind === 79 /* Identifier */) {
|
|
const span = getErrorSpanForNode(file, node.expression);
|
|
file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode));
|
|
}
|
|
}
|
|
function isEvalOrArgumentsIdentifier(node) {
|
|
return isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments");
|
|
}
|
|
function checkStrictModeEvalOrArguments(contextNode, name) {
|
|
if (name && name.kind === 79 /* Identifier */) {
|
|
const identifier = name;
|
|
if (isEvalOrArgumentsIdentifier(identifier)) {
|
|
const span = getErrorSpanForNode(file, name);
|
|
file.bindDiagnostics.push(createFileDiagnostic(
|
|
file,
|
|
span.start,
|
|
span.length,
|
|
getStrictModeEvalOrArgumentsMessage(contextNode),
|
|
idText(identifier)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function getStrictModeEvalOrArgumentsMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode;
|
|
}
|
|
if (file.externalModuleIndicator) {
|
|
return Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Invalid_use_of_0_in_strict_mode;
|
|
}
|
|
function checkStrictModeFunctionName(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
}
|
|
function getStrictModeBlockScopeFunctionDeclarationMessage(node) {
|
|
if (getContainingClass(node)) {
|
|
return Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode;
|
|
}
|
|
if (file.externalModuleIndicator) {
|
|
return Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode;
|
|
}
|
|
return Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5;
|
|
}
|
|
function checkStrictModeFunctionDeclaration(node) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (blockScopeContainer.kind !== 308 /* SourceFile */ && blockScopeContainer.kind !== 264 /* ModuleDeclaration */ && !isFunctionLikeOrClassStaticBlockDeclaration(blockScopeContainer)) {
|
|
const errorSpan = getErrorSpanForNode(file, node);
|
|
file.bindDiagnostics.push(createFileDiagnostic(
|
|
file,
|
|
errorSpan.start,
|
|
errorSpan.length,
|
|
getStrictModeBlockScopeFunctionDeclarationMessage(node)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeNumericLiteral(node) {
|
|
if (languageVersion < 1 /* ES5 */ && inStrictMode && node.numericLiteralFlags & 32 /* Octal */) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
|
|
}
|
|
}
|
|
function checkStrictModePostfixUnaryExpression(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.operand);
|
|
}
|
|
}
|
|
function checkStrictModePrefixUnaryExpression(node) {
|
|
if (inStrictMode) {
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
checkStrictModeEvalOrArguments(node, node.operand);
|
|
}
|
|
}
|
|
}
|
|
function checkStrictModeWithStatement(node) {
|
|
if (inStrictMode) {
|
|
errorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode);
|
|
}
|
|
}
|
|
function checkStrictModeLabeledStatement(node) {
|
|
if (inStrictMode && getEmitScriptTarget(options) >= 2 /* ES2015 */) {
|
|
if (isDeclarationStatement(node.statement) || isVariableStatement(node.statement)) {
|
|
errorOnFirstToken(node.label, Diagnostics.A_label_is_not_allowed_here);
|
|
}
|
|
}
|
|
}
|
|
function errorOnFirstToken(node, message, arg0, arg1, arg2) {
|
|
const span = getSpanOfTokenAtPosition(file, node.pos);
|
|
file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
|
|
}
|
|
function errorOrSuggestionOnNode(isError, node, message) {
|
|
errorOrSuggestionOnRange(isError, node, node, message);
|
|
}
|
|
function errorOrSuggestionOnRange(isError, startNode2, endNode2, message) {
|
|
addErrorOrSuggestionDiagnostic(isError, { pos: getTokenPosOfNode(startNode2, file), end: endNode2.end }, message);
|
|
}
|
|
function addErrorOrSuggestionDiagnostic(isError, range, message) {
|
|
const diag2 = createFileDiagnostic(file, range.pos, range.end - range.pos, message);
|
|
if (isError) {
|
|
file.bindDiagnostics.push(diag2);
|
|
} else {
|
|
file.bindSuggestionDiagnostics = append(file.bindSuggestionDiagnostics, { ...diag2, category: 2 /* Suggestion */ });
|
|
}
|
|
}
|
|
function bind(node) {
|
|
if (!node) {
|
|
return;
|
|
}
|
|
setParent(node, parent2);
|
|
if (tracing)
|
|
node.tracingPath = file.path;
|
|
const saveInStrictMode = inStrictMode;
|
|
bindWorker(node);
|
|
if (node.kind > 162 /* LastToken */) {
|
|
const saveParent = parent2;
|
|
parent2 = node;
|
|
const containerFlags = getContainerFlags(node);
|
|
if (containerFlags === 0 /* None */) {
|
|
bindChildren(node);
|
|
} else {
|
|
bindContainer(node, containerFlags);
|
|
}
|
|
parent2 = saveParent;
|
|
} else {
|
|
const saveParent = parent2;
|
|
if (node.kind === 1 /* EndOfFileToken */)
|
|
parent2 = node;
|
|
bindJSDoc(node);
|
|
parent2 = saveParent;
|
|
}
|
|
inStrictMode = saveInStrictMode;
|
|
}
|
|
function bindJSDoc(node) {
|
|
if (hasJSDocNodes(node)) {
|
|
if (isInJSFile(node)) {
|
|
for (const j of node.jsDoc) {
|
|
bind(j);
|
|
}
|
|
} else {
|
|
for (const j of node.jsDoc) {
|
|
setParent(j, node);
|
|
setParentRecursive(j, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function updateStrictModeStatementList(statements) {
|
|
if (!inStrictMode) {
|
|
for (const statement of statements) {
|
|
if (!isPrologueDirective(statement)) {
|
|
return;
|
|
}
|
|
if (isUseStrictPrologueDirective(statement)) {
|
|
inStrictMode = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isUseStrictPrologueDirective(node) {
|
|
const nodeText2 = getSourceTextOfNodeFromSourceFile(file, node.expression);
|
|
return nodeText2 === '"use strict"' || nodeText2 === "'use strict'";
|
|
}
|
|
function bindWorker(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
if (node.isInJSDocNamespace) {
|
|
let parentNode = node.parent;
|
|
while (parentNode && !isJSDocTypeAlias(parentNode)) {
|
|
parentNode = parentNode.parent;
|
|
}
|
|
bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
break;
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
if (currentFlow && (isExpression(node) || parent2.kind === 300 /* ShorthandPropertyAssignment */)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
return checkContextualIdentifier(node);
|
|
case 163 /* QualifiedName */:
|
|
if (currentFlow && isPartOfTypeQuery(node)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
break;
|
|
case 233 /* MetaProperty */:
|
|
case 106 /* SuperKeyword */:
|
|
node.flowNode = currentFlow;
|
|
break;
|
|
case 80 /* PrivateIdentifier */:
|
|
return checkPrivateIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = node;
|
|
if (currentFlow && isNarrowableReference(expr)) {
|
|
expr.flowNode = currentFlow;
|
|
}
|
|
if (isSpecialPropertyDeclaration(expr)) {
|
|
bindSpecialPropertyDeclaration(expr);
|
|
}
|
|
if (isInJSFile(expr) && file.commonJsModuleIndicator && isModuleExportsAccessExpression(expr) && !lookupSymbolForName(blockScopeContainer, "module")) {
|
|
declareSymbol(
|
|
file.locals,
|
|
void 0,
|
|
expr.expression,
|
|
1 /* FunctionScopedVariable */ | 134217728 /* ModuleExports */,
|
|
111550 /* FunctionScopedVariableExcludes */
|
|
);
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
const specialKind = getAssignmentDeclarationKind(node);
|
|
switch (specialKind) {
|
|
case 1 /* ExportsProperty */:
|
|
bindExportsPropertyAssignment(node);
|
|
break;
|
|
case 2 /* ModuleExports */:
|
|
bindModuleExportsAssignment(node);
|
|
break;
|
|
case 3 /* PrototypeProperty */:
|
|
bindPrototypePropertyAssignment(node.left, node);
|
|
break;
|
|
case 6 /* Prototype */:
|
|
bindPrototypeAssignment(node);
|
|
break;
|
|
case 4 /* ThisProperty */:
|
|
bindThisPropertyAssignment(node);
|
|
break;
|
|
case 5 /* Property */:
|
|
const expression = node.left.expression;
|
|
if (isInJSFile(node) && isIdentifier(expression)) {
|
|
const symbol = lookupSymbolForName(blockScopeContainer, expression.escapedText);
|
|
if (isThisInitializedDeclaration(symbol == null ? void 0 : symbol.valueDeclaration)) {
|
|
bindThisPropertyAssignment(node);
|
|
break;
|
|
}
|
|
}
|
|
bindSpecialPropertyAssignment(node);
|
|
break;
|
|
case 0 /* None */:
|
|
break;
|
|
default:
|
|
Debug.fail("Unknown binary expression special property assignment kind");
|
|
}
|
|
return checkStrictModeBinaryExpression(node);
|
|
case 295 /* CatchClause */:
|
|
return checkStrictModeCatchClause(node);
|
|
case 217 /* DeleteExpression */:
|
|
return checkStrictModeDeleteExpression(node);
|
|
case 8 /* NumericLiteral */:
|
|
return checkStrictModeNumericLiteral(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return checkStrictModePostfixUnaryExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return checkStrictModePrefixUnaryExpression(node);
|
|
case 251 /* WithStatement */:
|
|
return checkStrictModeWithStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return checkStrictModeLabeledStatement(node);
|
|
case 194 /* ThisType */:
|
|
seenThisKeyword = true;
|
|
return;
|
|
case 179 /* TypePredicate */:
|
|
break;
|
|
case 165 /* TypeParameter */:
|
|
return bindTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return bindParameter(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return bindVariableDeclarationOrBindingElement(node);
|
|
case 205 /* BindingElement */:
|
|
node.flowNode = currentFlow;
|
|
return bindVariableDeclarationOrBindingElement(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return bindPropertyWorker(node);
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return bindPropertyOrMethodOrAccessor(node, 4 /* Property */, 0 /* PropertyExcludes */);
|
|
case 302 /* EnumMember */:
|
|
return bindPropertyOrMethodOrAccessor(node, 8 /* EnumMember */, 900095 /* EnumMemberExcludes */);
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return declareSymbolAndAddToSymbolTable(node, 131072 /* Signature */, 0 /* None */);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return bindPropertyOrMethodOrAccessor(
|
|
node,
|
|
8192 /* Method */ | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */),
|
|
isObjectLiteralMethod(node) ? 0 /* PropertyExcludes */ : 103359 /* MethodExcludes */
|
|
);
|
|
case 259 /* FunctionDeclaration */:
|
|
return bindFunctionDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return declareSymbolAndAddToSymbolTable(node, 16384 /* Constructor */, 0 /* None */);
|
|
case 174 /* GetAccessor */:
|
|
return bindPropertyOrMethodOrAccessor(node, 32768 /* GetAccessor */, 46015 /* GetAccessorExcludes */);
|
|
case 175 /* SetAccessor */:
|
|
return bindPropertyOrMethodOrAccessor(node, 65536 /* SetAccessor */, 78783 /* SetAccessorExcludes */);
|
|
case 181 /* FunctionType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 326 /* JSDocSignature */:
|
|
case 182 /* ConstructorType */:
|
|
return bindFunctionOrConstructorType(node);
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 197 /* MappedType */:
|
|
return bindAnonymousTypeWorker(node);
|
|
case 335 /* JSDocClassTag */:
|
|
return bindJSDocClassTag(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return bindObjectLiteralExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return bindFunctionExpression(node);
|
|
case 210 /* CallExpression */:
|
|
const assignmentKind = getAssignmentDeclarationKind(node);
|
|
switch (assignmentKind) {
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
return bindObjectDefinePropertyAssignment(node);
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
return bindObjectDefinePropertyExport(node);
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return bindObjectDefinePrototypeProperty(node);
|
|
case 0 /* None */:
|
|
break;
|
|
default:
|
|
return Debug.fail("Unknown call expression assignment declaration kind");
|
|
}
|
|
if (isInJSFile(node)) {
|
|
bindCallExpression(node);
|
|
}
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
inStrictMode = true;
|
|
return bindClassLikeDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return bindBlockScopedDeclaration(node, 64 /* Interface */, 788872 /* InterfaceExcludes */);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return bindBlockScopedDeclaration(node, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
|
|
case 263 /* EnumDeclaration */:
|
|
return bindEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return bindModuleDeclaration(node);
|
|
case 289 /* JsxAttributes */:
|
|
return bindJsxAttributes(node);
|
|
case 288 /* JsxAttribute */:
|
|
return bindJsxAttribute(node, 4 /* Property */, 0 /* PropertyExcludes */);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return bindNamespaceExportDeclaration(node);
|
|
case 270 /* ImportClause */:
|
|
return bindImportClause(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return bindExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return bindExportAssignment(node);
|
|
case 308 /* SourceFile */:
|
|
updateStrictModeStatementList(node.statements);
|
|
return bindSourceFileIfExternalModule();
|
|
case 238 /* Block */:
|
|
if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
|
|
return;
|
|
}
|
|
case 265 /* ModuleBlock */:
|
|
return updateStrictModeStatementList(node.statements);
|
|
case 343 /* JSDocParameterTag */:
|
|
if (node.parent.kind === 326 /* JSDocSignature */) {
|
|
return bindParameter(node);
|
|
}
|
|
if (node.parent.kind !== 325 /* JSDocTypeLiteral */) {
|
|
break;
|
|
}
|
|
case 350 /* JSDocPropertyTag */:
|
|
const propTag = node;
|
|
const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 319 /* JSDocOptionalType */ ? 4 /* Property */ | 16777216 /* Optional */ : 4 /* Property */;
|
|
return declareSymbolAndAddToSymbolTable(propTag, flags, 0 /* PropertyExcludes */);
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return (delayedTypeAliases || (delayedTypeAliases = [])).push(node);
|
|
}
|
|
}
|
|
function bindPropertyWorker(node) {
|
|
const isAutoAccessor = isAutoAccessorPropertyDeclaration(node);
|
|
const includes = isAutoAccessor ? 98304 /* Accessor */ : 4 /* Property */;
|
|
const excludes = isAutoAccessor ? 13247 /* AccessorExcludes */ : 0 /* PropertyExcludes */;
|
|
return bindPropertyOrMethodOrAccessor(node, includes | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */), excludes);
|
|
}
|
|
function bindAnonymousTypeWorker(node) {
|
|
return bindAnonymousDeclaration(node, 2048 /* TypeLiteral */, "__type" /* Type */);
|
|
}
|
|
function bindSourceFileIfExternalModule() {
|
|
setExportContextFlag(file);
|
|
if (isExternalModule(file)) {
|
|
bindSourceFileAsExternalModule();
|
|
} else if (isJsonSourceFile(file)) {
|
|
bindSourceFileAsExternalModule();
|
|
const originalSymbol = file.symbol;
|
|
declareSymbol(file.symbol.exports, file.symbol, file, 4 /* Property */, 67108863 /* All */);
|
|
file.symbol = originalSymbol;
|
|
}
|
|
}
|
|
function bindSourceFileAsExternalModule() {
|
|
bindAnonymousDeclaration(file, 512 /* ValueModule */, `"${removeFileExtension(file.fileName)}"`);
|
|
}
|
|
function bindExportAssignment(node) {
|
|
if (!container.symbol || !container.symbol.exports) {
|
|
bindAnonymousDeclaration(node, 111551 /* Value */, getDeclarationName(node));
|
|
} else {
|
|
const flags = exportAssignmentIsAlias(node) ? 2097152 /* Alias */ : 4 /* Property */;
|
|
const symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863 /* All */);
|
|
if (node.isExportEquals) {
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
}
|
|
}
|
|
function bindNamespaceExportDeclaration(node) {
|
|
if (some(node.modifiers)) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, Diagnostics.Modifiers_cannot_appear_here));
|
|
}
|
|
const diag2 = !isSourceFile(node.parent) ? Diagnostics.Global_module_exports_may_only_appear_at_top_level : !isExternalModule(node.parent) ? Diagnostics.Global_module_exports_may_only_appear_in_module_files : !node.parent.isDeclarationFile ? Diagnostics.Global_module_exports_may_only_appear_in_declaration_files : void 0;
|
|
if (diag2) {
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(node, diag2));
|
|
} else {
|
|
file.symbol.globalExports = file.symbol.globalExports || createSymbolTable();
|
|
declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
}
|
|
}
|
|
function bindExportDeclaration(node) {
|
|
if (!container.symbol || !container.symbol.exports) {
|
|
bindAnonymousDeclaration(node, 8388608 /* ExportStar */, getDeclarationName(node));
|
|
} else if (!node.exportClause) {
|
|
declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* ExportStar */, 0 /* None */);
|
|
} else if (isNamespaceExport(node.exportClause)) {
|
|
setParent(node.exportClause, node);
|
|
declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
}
|
|
}
|
|
function bindImportClause(node) {
|
|
if (node.name) {
|
|
declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
}
|
|
}
|
|
function setCommonJsModuleIndicator(node) {
|
|
if (file.externalModuleIndicator && file.externalModuleIndicator !== true) {
|
|
return false;
|
|
}
|
|
if (!file.commonJsModuleIndicator) {
|
|
file.commonJsModuleIndicator = node;
|
|
if (!file.externalModuleIndicator) {
|
|
bindSourceFileAsExternalModule();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function bindObjectDefinePropertyExport(node) {
|
|
if (!setCommonJsModuleIndicator(node)) {
|
|
return;
|
|
}
|
|
const symbol = forEachIdentifierInEntityName(node.arguments[0], void 0, (id, symbol2) => {
|
|
if (symbol2) {
|
|
addDeclarationToSymbol(symbol2, id, 1536 /* Module */ | 67108864 /* Assignment */);
|
|
}
|
|
return symbol2;
|
|
});
|
|
if (symbol) {
|
|
const flags = 4 /* Property */ | 1048576 /* ExportValue */;
|
|
declareSymbol(symbol.exports, symbol, node, flags, 0 /* None */);
|
|
}
|
|
}
|
|
function bindExportsPropertyAssignment(node) {
|
|
if (!setCommonJsModuleIndicator(node)) {
|
|
return;
|
|
}
|
|
const symbol = forEachIdentifierInEntityName(node.left.expression, void 0, (id, symbol2) => {
|
|
if (symbol2) {
|
|
addDeclarationToSymbol(symbol2, id, 1536 /* Module */ | 67108864 /* Assignment */);
|
|
}
|
|
return symbol2;
|
|
});
|
|
if (symbol) {
|
|
const isAlias = isAliasableExpression(node.right) && (isExportsIdentifier(node.left.expression) || isModuleExportsAccessExpression(node.left.expression));
|
|
const flags = isAlias ? 2097152 /* Alias */ : 4 /* Property */ | 1048576 /* ExportValue */;
|
|
setParent(node.left, node);
|
|
declareSymbol(symbol.exports, symbol, node.left, flags, 0 /* None */);
|
|
}
|
|
}
|
|
function bindModuleExportsAssignment(node) {
|
|
if (!setCommonJsModuleIndicator(node)) {
|
|
return;
|
|
}
|
|
const assignedExpression = getRightMostAssignedExpression(node.right);
|
|
if (isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) {
|
|
return;
|
|
}
|
|
if (isObjectLiteralExpression(assignedExpression) && every(assignedExpression.properties, isShorthandPropertyAssignment)) {
|
|
forEach(assignedExpression.properties, bindExportAssignedObjectMemberAlias);
|
|
return;
|
|
}
|
|
const flags = exportAssignmentIsAlias(node) ? 2097152 /* Alias */ : 4 /* Property */ | 1048576 /* ExportValue */ | 512 /* ValueModule */;
|
|
const symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864 /* Assignment */, 0 /* None */);
|
|
setValueDeclaration(symbol, node);
|
|
}
|
|
function bindExportAssignedObjectMemberAlias(node) {
|
|
declareSymbol(file.symbol.exports, file.symbol, node, 2097152 /* Alias */ | 67108864 /* Assignment */, 0 /* None */);
|
|
}
|
|
function bindThisPropertyAssignment(node) {
|
|
Debug.assert(isInJSFile(node));
|
|
const hasPrivateIdentifier = isBinaryExpression(node) && isPropertyAccessExpression(node.left) && isPrivateIdentifier(node.left.name) || isPropertyAccessExpression(node) && isPrivateIdentifier(node.name);
|
|
if (hasPrivateIdentifier) {
|
|
return;
|
|
}
|
|
const thisContainer = getThisContainer(node, false);
|
|
switch (thisContainer.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
let constructorSymbol = thisContainer.symbol;
|
|
if (isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const l = thisContainer.parent.left;
|
|
if (isBindableStaticAccessExpression(l) && isPrototypeAccess(l.expression)) {
|
|
constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer);
|
|
}
|
|
}
|
|
if (constructorSymbol && constructorSymbol.valueDeclaration) {
|
|
constructorSymbol.members = constructorSymbol.members || createSymbolTable();
|
|
if (hasDynamicName(node)) {
|
|
bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol, constructorSymbol.members);
|
|
} else {
|
|
declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 /* Property */ | 67108864 /* Assignment */, 0 /* PropertyExcludes */ & ~4 /* Property */);
|
|
}
|
|
addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
const containingClass = thisContainer.parent;
|
|
const symbolTable = isStatic(thisContainer) ? containingClass.symbol.exports : containingClass.symbol.members;
|
|
if (hasDynamicName(node)) {
|
|
bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol, symbolTable);
|
|
} else {
|
|
declareSymbol(symbolTable, containingClass.symbol, node, 4 /* Property */ | 67108864 /* Assignment */, 0 /* None */, true);
|
|
}
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
if (hasDynamicName(node)) {
|
|
break;
|
|
} else if (thisContainer.commonJsModuleIndicator) {
|
|
declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 /* Property */ | 1048576 /* ExportValue */, 0 /* None */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
|
|
}
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(thisContainer);
|
|
}
|
|
}
|
|
function bindDynamicallyNamedThisPropertyAssignment(node, symbol, symbolTable) {
|
|
declareSymbol(symbolTable, symbol, node, 4 /* Property */, 0 /* None */, true, true);
|
|
addLateBoundAssignmentDeclarationToSymbol(node, symbol);
|
|
}
|
|
function addLateBoundAssignmentDeclarationToSymbol(node, symbol) {
|
|
if (symbol) {
|
|
(symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = /* @__PURE__ */ new Map())).set(getNodeId(node), node);
|
|
}
|
|
}
|
|
function bindSpecialPropertyDeclaration(node) {
|
|
if (node.expression.kind === 108 /* ThisKeyword */) {
|
|
bindThisPropertyAssignment(node);
|
|
} else if (isBindableStaticAccessExpression(node) && node.parent.parent.kind === 308 /* SourceFile */) {
|
|
if (isPrototypeAccess(node.expression)) {
|
|
bindPrototypePropertyAssignment(node, node.parent);
|
|
} else {
|
|
bindStaticPropertyAssignment(node);
|
|
}
|
|
}
|
|
}
|
|
function bindPrototypeAssignment(node) {
|
|
setParent(node.left, node);
|
|
setParent(node.right, node);
|
|
bindPropertyAssignment(node.left.expression, node.left, false, true);
|
|
}
|
|
function bindObjectDefinePrototypeProperty(node) {
|
|
const namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression);
|
|
if (namespaceSymbol && namespaceSymbol.valueDeclaration) {
|
|
addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, true);
|
|
}
|
|
function bindPrototypePropertyAssignment(lhs, parent3) {
|
|
const classPrototype = lhs.expression;
|
|
const constructorFunction = classPrototype.expression;
|
|
setParent(constructorFunction, classPrototype);
|
|
setParent(classPrototype, lhs);
|
|
setParent(lhs, parent3);
|
|
bindPropertyAssignment(constructorFunction, lhs, true, true);
|
|
}
|
|
function bindObjectDefinePropertyAssignment(node) {
|
|
let namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]);
|
|
const isToplevel = node.parent.parent.kind === 308 /* SourceFile */;
|
|
namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, false, false);
|
|
bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, false);
|
|
}
|
|
function bindSpecialPropertyAssignment(node) {
|
|
var _a2;
|
|
const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
|
|
if (!isInJSFile(node) && !isFunctionSymbol(parentSymbol)) {
|
|
return;
|
|
}
|
|
const rootExpr = getLeftmostAccessExpression(node.left);
|
|
if (isIdentifier(rootExpr) && ((_a2 = lookupSymbolForName(container, rootExpr.escapedText)) == null ? void 0 : _a2.flags) & 2097152 /* Alias */) {
|
|
return;
|
|
}
|
|
setParent(node.left, node);
|
|
setParent(node.right, node);
|
|
if (isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) {
|
|
bindExportsPropertyAssignment(node);
|
|
} else if (hasDynamicName(node)) {
|
|
bindAnonymousDeclaration(node, 4 /* Property */ | 67108864 /* Assignment */, "__computed" /* Computed */);
|
|
const sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), false, false);
|
|
addLateBoundAssignmentDeclarationToSymbol(node, sym);
|
|
} else {
|
|
bindStaticPropertyAssignment(cast(node.left, isBindableStaticNameExpression));
|
|
}
|
|
}
|
|
function bindStaticPropertyAssignment(node) {
|
|
Debug.assert(!isIdentifier(node));
|
|
setParent(node.expression, node);
|
|
bindPropertyAssignment(node.expression, node, false, false);
|
|
}
|
|
function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) {
|
|
if ((namespaceSymbol == null ? void 0 : namespaceSymbol.flags) & 2097152 /* Alias */) {
|
|
return namespaceSymbol;
|
|
}
|
|
if (isToplevel && !isPrototypeProperty) {
|
|
const flags = 1536 /* Module */ | 67108864 /* Assignment */;
|
|
const excludeFlags = 110735 /* ValueModuleExcludes */ & ~67108864 /* Assignment */;
|
|
namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, (id, symbol, parent3) => {
|
|
if (symbol) {
|
|
addDeclarationToSymbol(symbol, id, flags);
|
|
return symbol;
|
|
} else {
|
|
const table = parent3 ? parent3.exports : file.jsGlobalAugmentations || (file.jsGlobalAugmentations = createSymbolTable());
|
|
return declareSymbol(table, parent3, id, flags, excludeFlags);
|
|
}
|
|
});
|
|
}
|
|
if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) {
|
|
addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* Class */);
|
|
}
|
|
return namespaceSymbol;
|
|
}
|
|
function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) {
|
|
if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) {
|
|
return;
|
|
}
|
|
const symbolTable = isPrototypeProperty ? namespaceSymbol.members || (namespaceSymbol.members = createSymbolTable()) : namespaceSymbol.exports || (namespaceSymbol.exports = createSymbolTable());
|
|
let includes = 0 /* None */;
|
|
let excludes = 0 /* None */;
|
|
if (isFunctionLikeDeclaration(getAssignedExpandoInitializer(declaration))) {
|
|
includes = 8192 /* Method */;
|
|
excludes = 103359 /* MethodExcludes */;
|
|
} else if (isCallExpression(declaration) && isBindableObjectDefinePropertyCall(declaration)) {
|
|
if (some(declaration.arguments[2].properties, (p) => {
|
|
const id = getNameOfDeclaration(p);
|
|
return !!id && isIdentifier(id) && idText(id) === "set";
|
|
})) {
|
|
includes |= 65536 /* SetAccessor */ | 4 /* Property */;
|
|
excludes |= 78783 /* SetAccessorExcludes */;
|
|
}
|
|
if (some(declaration.arguments[2].properties, (p) => {
|
|
const id = getNameOfDeclaration(p);
|
|
return !!id && isIdentifier(id) && idText(id) === "get";
|
|
})) {
|
|
includes |= 32768 /* GetAccessor */ | 4 /* Property */;
|
|
excludes |= 46015 /* GetAccessorExcludes */;
|
|
}
|
|
}
|
|
if (includes === 0 /* None */) {
|
|
includes = 4 /* Property */;
|
|
excludes = 0 /* PropertyExcludes */;
|
|
}
|
|
declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864 /* Assignment */, excludes & ~67108864 /* Assignment */);
|
|
}
|
|
function isTopLevelNamespaceAssignment(propertyAccess) {
|
|
return isBinaryExpression(propertyAccess.parent) ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 308 /* SourceFile */ : propertyAccess.parent.parent.kind === 308 /* SourceFile */;
|
|
}
|
|
function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
|
|
let namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
|
|
const isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
|
|
namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
|
|
bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
|
|
}
|
|
function isExpandoSymbol(symbol) {
|
|
if (symbol.flags & (16 /* Function */ | 32 /* Class */ | 1024 /* NamespaceModule */)) {
|
|
return true;
|
|
}
|
|
const node = symbol.valueDeclaration;
|
|
if (node && isCallExpression(node)) {
|
|
return !!getAssignedExpandoInitializer(node);
|
|
}
|
|
let init = !node ? void 0 : isVariableDeclaration(node) ? node.initializer : isBinaryExpression(node) ? node.right : isPropertyAccessExpression(node) && isBinaryExpression(node.parent) ? node.parent.right : void 0;
|
|
init = init && getRightMostAssignedExpression(init);
|
|
if (init) {
|
|
const isPrototypeAssignment = isPrototypeAccess(isVariableDeclaration(node) ? node.name : isBinaryExpression(node) ? node.left : node);
|
|
return !!getExpandoInitializer(isBinaryExpression(init) && (init.operatorToken.kind === 56 /* BarBarToken */ || init.operatorToken.kind === 60 /* QuestionQuestionToken */) ? init.right : init, isPrototypeAssignment);
|
|
}
|
|
return false;
|
|
}
|
|
function getParentOfBinaryExpression(expr) {
|
|
while (isBinaryExpression(expr.parent)) {
|
|
expr = expr.parent;
|
|
}
|
|
return expr.parent;
|
|
}
|
|
function lookupSymbolForPropertyAccess(node, lookupContainer = container) {
|
|
if (isIdentifier(node)) {
|
|
return lookupSymbolForName(lookupContainer, node.escapedText);
|
|
} else {
|
|
const symbol = lookupSymbolForPropertyAccess(node.expression);
|
|
return symbol && symbol.exports && symbol.exports.get(getElementOrPropertyAccessName(node));
|
|
}
|
|
}
|
|
function forEachIdentifierInEntityName(e, parent3, action) {
|
|
if (isExportsOrModuleExportsOrAlias(file, e)) {
|
|
return file.symbol;
|
|
} else if (isIdentifier(e)) {
|
|
return action(e, lookupSymbolForPropertyAccess(e), parent3);
|
|
} else {
|
|
const s = forEachIdentifierInEntityName(e.expression, parent3, action);
|
|
const name = getNameOrArgument(e);
|
|
if (isPrivateIdentifier(name)) {
|
|
Debug.fail("unexpected PrivateIdentifier");
|
|
}
|
|
return action(name, s && s.exports && s.exports.get(getElementOrPropertyAccessName(e)), s);
|
|
}
|
|
}
|
|
function bindCallExpression(node) {
|
|
if (!file.commonJsModuleIndicator && isRequireCall(node, false)) {
|
|
setCommonJsModuleIndicator(node);
|
|
}
|
|
}
|
|
function bindClassLikeDeclaration(node) {
|
|
if (node.kind === 260 /* ClassDeclaration */) {
|
|
bindBlockScopedDeclaration(node, 32 /* Class */, 899503 /* ClassExcludes */);
|
|
} else {
|
|
const bindingName = node.name ? node.name.escapedText : "__class" /* Class */;
|
|
bindAnonymousDeclaration(node, 32 /* Class */, bindingName);
|
|
if (node.name) {
|
|
classifiableNames.add(node.name.escapedText);
|
|
}
|
|
}
|
|
const { symbol } = node;
|
|
const prototypeSymbol = createSymbol(4 /* Property */ | 4194304 /* Prototype */, "prototype");
|
|
const symbolExport = symbol.exports.get(prototypeSymbol.escapedName);
|
|
if (symbolExport) {
|
|
if (node.name) {
|
|
setParent(node.name, node);
|
|
}
|
|
file.bindDiagnostics.push(createDiagnosticForNode2(symbolExport.declarations[0], Diagnostics.Duplicate_identifier_0, symbolName(prototypeSymbol)));
|
|
}
|
|
symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol);
|
|
prototypeSymbol.parent = symbol;
|
|
}
|
|
function bindEnumDeclaration(node) {
|
|
return isEnumConst(node) ? bindBlockScopedDeclaration(node, 128 /* ConstEnum */, 899967 /* ConstEnumExcludes */) : bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */);
|
|
}
|
|
function bindVariableDeclarationOrBindingElement(node) {
|
|
if (inStrictMode) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
if (!isBindingPattern(node.name)) {
|
|
const possibleVariableDecl = node.kind === 257 /* VariableDeclaration */ ? node : node.parent.parent;
|
|
if (isInJSFile(node) && isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && !getJSDocTypeTag(node) && !(getCombinedModifierFlags(node) & 1 /* Export */)) {
|
|
declareSymbolAndAddToSymbolTable(node, 2097152 /* Alias */, 2097152 /* AliasExcludes */);
|
|
} else if (isBlockOrCatchScoped(node)) {
|
|
bindBlockScopedDeclaration(node, 2 /* BlockScopedVariable */, 111551 /* BlockScopedVariableExcludes */);
|
|
} else if (isParameterDeclaration(node)) {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111551 /* ParameterExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
|
|
}
|
|
}
|
|
}
|
|
function bindParameter(node) {
|
|
if (node.kind === 343 /* JSDocParameterTag */ && container.kind !== 326 /* JSDocSignature */) {
|
|
return;
|
|
}
|
|
if (inStrictMode && !(node.flags & 16777216 /* Ambient */)) {
|
|
checkStrictModeEvalOrArguments(node, node.name);
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
bindAnonymousDeclaration(node, 1 /* FunctionScopedVariable */, "__" + node.parent.parameters.indexOf(node));
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111551 /* ParameterExcludes */);
|
|
}
|
|
if (isParameterPropertyDeclaration(node, node.parent)) {
|
|
const classDeclaration = node.parent.parent;
|
|
declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* Property */ | (node.questionToken ? 16777216 /* Optional */ : 0 /* None */), 0 /* PropertyExcludes */);
|
|
}
|
|
}
|
|
function bindFunctionDeclaration(node) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
}
|
|
checkStrictModeFunctionName(node);
|
|
if (inStrictMode) {
|
|
checkStrictModeFunctionDeclaration(node);
|
|
bindBlockScopedDeclaration(node, 16 /* Function */, 110991 /* FunctionExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 16 /* Function */, 110991 /* FunctionExcludes */);
|
|
}
|
|
}
|
|
function bindFunctionExpression(node) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
}
|
|
if (currentFlow) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
checkStrictModeFunctionName(node);
|
|
const bindingName = node.name ? node.name.escapedText : "__function" /* Function */;
|
|
return bindAnonymousDeclaration(node, 16 /* Function */, bindingName);
|
|
}
|
|
function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
|
|
if (!file.isDeclarationFile && !(node.flags & 16777216 /* Ambient */) && isAsyncFunction(node)) {
|
|
emitFlags |= 2048 /* HasAsyncFunctions */;
|
|
}
|
|
if (currentFlow && isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
|
|
node.flowNode = currentFlow;
|
|
}
|
|
return hasDynamicName(node) ? bindAnonymousDeclaration(node, symbolFlags, "__computed" /* Computed */) : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
|
|
}
|
|
function getInferTypeContainer(node) {
|
|
const extendsType = findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && n.parent.extendsType === n);
|
|
return extendsType && extendsType.parent;
|
|
}
|
|
function bindTypeParameter(node) {
|
|
if (isJSDocTemplateTag(node.parent)) {
|
|
const container2 = getEffectiveContainerForJSDocTemplateTag(node.parent);
|
|
if (container2) {
|
|
if (!container2.locals) {
|
|
container2.locals = createSymbolTable();
|
|
}
|
|
declareSymbol(container2.locals, void 0, node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
}
|
|
} else if (node.parent.kind === 192 /* InferType */) {
|
|
const container2 = getInferTypeContainer(node.parent);
|
|
if (container2) {
|
|
if (!container2.locals) {
|
|
container2.locals = createSymbolTable();
|
|
}
|
|
declareSymbol(container2.locals, void 0, node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
} else {
|
|
bindAnonymousDeclaration(node, 262144 /* TypeParameter */, getDeclarationName(node));
|
|
}
|
|
} else {
|
|
declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
|
|
}
|
|
}
|
|
function shouldReportErrorOnModuleDeclaration(node) {
|
|
const instanceState = getModuleInstanceState(node);
|
|
return instanceState === 1 /* Instantiated */ || instanceState === 2 /* ConstEnumOnly */ && shouldPreserveConstEnums(options);
|
|
}
|
|
function checkUnreachable(node) {
|
|
if (!(currentFlow.flags & 1 /* Unreachable */)) {
|
|
return false;
|
|
}
|
|
if (currentFlow === unreachableFlow) {
|
|
const reportError = isStatementButNotDeclaration(node) && node.kind !== 239 /* EmptyStatement */ || node.kind === 260 /* ClassDeclaration */ || node.kind === 264 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node);
|
|
if (reportError) {
|
|
currentFlow = reportedUnreachableFlow;
|
|
if (!options.allowUnreachableCode) {
|
|
const isError = unreachableCodeIsError(options) && !(node.flags & 16777216 /* Ambient */) && (!isVariableStatement(node) || !!(getCombinedNodeFlags(node.declarationList) & 3 /* BlockScoped */) || node.declarationList.declarations.some((d) => !!d.initializer));
|
|
eachUnreachableRange(node, (start2, end) => errorOrSuggestionOnRange(isError, start2, end, Diagnostics.Unreachable_code_detected));
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function eachUnreachableRange(node, cb) {
|
|
if (isStatement(node) && isExecutableStatement(node) && isBlock(node.parent)) {
|
|
const { statements } = node.parent;
|
|
const slice = sliceAfter(statements, node);
|
|
getRangesWhere(slice, isExecutableStatement, (start2, afterEnd) => cb(slice[start2], slice[afterEnd - 1]));
|
|
} else {
|
|
cb(node, node);
|
|
}
|
|
}
|
|
function isExecutableStatement(s) {
|
|
return !isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !isEnumDeclaration(s) && !(isVariableStatement(s) && !(getCombinedNodeFlags(s) & (1 /* Let */ | 2 /* Const */)) && s.declarationList.declarations.some((d) => !d.initializer));
|
|
}
|
|
function isPurelyTypeDeclaration(s) {
|
|
switch (s.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
case 264 /* ModuleDeclaration */:
|
|
return getModuleInstanceState(s) !== 1 /* Instantiated */;
|
|
case 263 /* EnumDeclaration */:
|
|
return hasSyntacticModifier(s, 2048 /* Const */);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isExportsOrModuleExportsOrAlias(sourceFile, node) {
|
|
let i = 0;
|
|
const q = createQueue();
|
|
q.enqueue(node);
|
|
while (!q.isEmpty() && i < 100) {
|
|
i++;
|
|
node = q.dequeue();
|
|
if (isExportsIdentifier(node) || isModuleExportsAccessExpression(node)) {
|
|
return true;
|
|
} else if (isIdentifier(node)) {
|
|
const symbol = lookupSymbolForName(sourceFile, node.escapedText);
|
|
if (!!symbol && !!symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) {
|
|
const init = symbol.valueDeclaration.initializer;
|
|
q.enqueue(init);
|
|
if (isAssignmentExpression(init, true)) {
|
|
q.enqueue(init.left);
|
|
q.enqueue(init.right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function lookupSymbolForName(container, name) {
|
|
const local = container.locals && container.locals.get(name);
|
|
if (local) {
|
|
return local.exportSymbol || local;
|
|
}
|
|
if (isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) {
|
|
return container.jsGlobalAugmentations.get(name);
|
|
}
|
|
return container.symbol && container.symbol.exports && container.symbol.exports.get(name);
|
|
}
|
|
|
|
// src/compiler/symbolWalker.ts
|
|
function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getConstraintOfTypeParameter, getFirstIdentifier2, getTypeArguments) {
|
|
return getSymbolWalker;
|
|
function getSymbolWalker(accept = () => true) {
|
|
const visitedTypes = [];
|
|
const visitedSymbols = [];
|
|
return {
|
|
walkType: (type) => {
|
|
try {
|
|
visitType(type);
|
|
return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
|
|
} finally {
|
|
clear(visitedTypes);
|
|
clear(visitedSymbols);
|
|
}
|
|
},
|
|
walkSymbol: (symbol) => {
|
|
try {
|
|
visitSymbol(symbol);
|
|
return { visitedTypes: getOwnValues(visitedTypes), visitedSymbols: getOwnValues(visitedSymbols) };
|
|
} finally {
|
|
clear(visitedTypes);
|
|
clear(visitedSymbols);
|
|
}
|
|
}
|
|
};
|
|
function visitType(type) {
|
|
if (!type) {
|
|
return;
|
|
}
|
|
if (visitedTypes[type.id]) {
|
|
return;
|
|
}
|
|
visitedTypes[type.id] = type;
|
|
const shouldBail = visitSymbol(type.symbol);
|
|
if (shouldBail)
|
|
return;
|
|
if (type.flags & 524288 /* Object */) {
|
|
const objectType = type;
|
|
const objectFlags = objectType.objectFlags;
|
|
if (objectFlags & 4 /* Reference */) {
|
|
visitTypeReference(type);
|
|
}
|
|
if (objectFlags & 32 /* Mapped */) {
|
|
visitMappedType(type);
|
|
}
|
|
if (objectFlags & (1 /* Class */ | 2 /* Interface */)) {
|
|
visitInterfaceType(type);
|
|
}
|
|
if (objectFlags & (8 /* Tuple */ | 16 /* Anonymous */)) {
|
|
visitObjectType(objectType);
|
|
}
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
visitTypeParameter(type);
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
visitUnionOrIntersectionType(type);
|
|
}
|
|
if (type.flags & 4194304 /* Index */) {
|
|
visitIndexType(type);
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
visitIndexedAccessType(type);
|
|
}
|
|
}
|
|
function visitTypeReference(type) {
|
|
visitType(type.target);
|
|
forEach(getTypeArguments(type), visitType);
|
|
}
|
|
function visitTypeParameter(type) {
|
|
visitType(getConstraintOfTypeParameter(type));
|
|
}
|
|
function visitUnionOrIntersectionType(type) {
|
|
forEach(type.types, visitType);
|
|
}
|
|
function visitIndexType(type) {
|
|
visitType(type.type);
|
|
}
|
|
function visitIndexedAccessType(type) {
|
|
visitType(type.objectType);
|
|
visitType(type.indexType);
|
|
visitType(type.constraint);
|
|
}
|
|
function visitMappedType(type) {
|
|
visitType(type.typeParameter);
|
|
visitType(type.constraintType);
|
|
visitType(type.templateType);
|
|
visitType(type.modifiersType);
|
|
}
|
|
function visitSignature(signature) {
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (typePredicate) {
|
|
visitType(typePredicate.type);
|
|
}
|
|
forEach(signature.typeParameters, visitType);
|
|
for (const parameter of signature.parameters) {
|
|
visitSymbol(parameter);
|
|
}
|
|
visitType(getRestTypeOfSignature(signature));
|
|
visitType(getReturnTypeOfSignature(signature));
|
|
}
|
|
function visitInterfaceType(interfaceT) {
|
|
visitObjectType(interfaceT);
|
|
forEach(interfaceT.typeParameters, visitType);
|
|
forEach(getBaseTypes(interfaceT), visitType);
|
|
visitType(interfaceT.thisType);
|
|
}
|
|
function visitObjectType(type) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
for (const info of resolved.indexInfos) {
|
|
visitType(info.keyType);
|
|
visitType(info.type);
|
|
}
|
|
for (const signature of resolved.callSignatures) {
|
|
visitSignature(signature);
|
|
}
|
|
for (const signature of resolved.constructSignatures) {
|
|
visitSignature(signature);
|
|
}
|
|
for (const p of resolved.properties) {
|
|
visitSymbol(p);
|
|
}
|
|
}
|
|
function visitSymbol(symbol) {
|
|
if (!symbol) {
|
|
return false;
|
|
}
|
|
const symbolId = getSymbolId(symbol);
|
|
if (visitedSymbols[symbolId]) {
|
|
return false;
|
|
}
|
|
visitedSymbols[symbolId] = symbol;
|
|
if (!accept(symbol)) {
|
|
return true;
|
|
}
|
|
const t = getTypeOfSymbol(symbol);
|
|
visitType(t);
|
|
if (symbol.exports) {
|
|
symbol.exports.forEach(visitSymbol);
|
|
}
|
|
forEach(symbol.declarations, (d) => {
|
|
if (d.type && d.type.kind === 183 /* TypeQuery */) {
|
|
const query = d.type;
|
|
const entity = getResolvedSymbol(getFirstIdentifier2(query.exprName));
|
|
visitSymbol(entity);
|
|
}
|
|
});
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/_namespaces/ts.moduleSpecifiers.ts
|
|
var ts_moduleSpecifiers_exports = {};
|
|
__export(ts_moduleSpecifiers_exports, {
|
|
countPathComponents: () => countPathComponents,
|
|
forEachFileNameOfModule: () => forEachFileNameOfModule,
|
|
getModuleSpecifier: () => getModuleSpecifier,
|
|
getModuleSpecifiers: () => getModuleSpecifiers,
|
|
getModuleSpecifiersWithCacheInfo: () => getModuleSpecifiersWithCacheInfo,
|
|
getNodeModulesPackageName: () => getNodeModulesPackageName,
|
|
tryGetJSExtensionForFile: () => tryGetJSExtensionForFile,
|
|
tryGetModuleSpecifiersFromCache: () => tryGetModuleSpecifiersFromCache,
|
|
updateModuleSpecifier: () => updateModuleSpecifier
|
|
});
|
|
|
|
// src/compiler/moduleSpecifiers.ts
|
|
function getPreferences(host, { importModuleSpecifierPreference, importModuleSpecifierEnding }, compilerOptions, importingSourceFile) {
|
|
return {
|
|
relativePreference: importModuleSpecifierPreference === "relative" ? 0 /* Relative */ : importModuleSpecifierPreference === "non-relative" ? 1 /* NonRelative */ : importModuleSpecifierPreference === "project-relative" ? 3 /* ExternalNonRelative */ : 2 /* Shortest */,
|
|
ending: getEnding()
|
|
};
|
|
function getEnding() {
|
|
switch (importModuleSpecifierEnding) {
|
|
case "minimal":
|
|
return 0 /* Minimal */;
|
|
case "index":
|
|
return 1 /* Index */;
|
|
case "js":
|
|
return 2 /* JsExtension */;
|
|
default:
|
|
return usesJsExtensionOnImports(importingSourceFile) || isFormatRequiringExtensions(compilerOptions, importingSourceFile.path, host) ? 2 /* JsExtension */ : getEmitModuleResolutionKind(compilerOptions) !== 2 /* NodeJs */ ? 1 /* Index */ : 0 /* Minimal */;
|
|
}
|
|
}
|
|
}
|
|
function getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host) {
|
|
return {
|
|
relativePreference: isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* Relative */ : 1 /* NonRelative */,
|
|
ending: hasJSFileExtension(oldImportSpecifier) || isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) ? 2 /* JsExtension */ : getEmitModuleResolutionKind(compilerOptions) !== 2 /* NodeJs */ || endsWith(oldImportSpecifier, "index") ? 1 /* Index */ : 0 /* Minimal */
|
|
};
|
|
}
|
|
function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) {
|
|
var _a2;
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
return false;
|
|
}
|
|
return getImpliedNodeFormatForFile(importingSourceFileName, (_a2 = host.getPackageJsonInfoCache) == null ? void 0 : _a2.call(host), getModuleResolutionHost(host), compilerOptions) !== 1 /* CommonJS */;
|
|
}
|
|
function getModuleResolutionHost(host) {
|
|
var _a2;
|
|
return {
|
|
fileExists: host.fileExists,
|
|
readFile: Debug.checkDefined(host.readFile),
|
|
directoryExists: host.directoryExists,
|
|
getCurrentDirectory: host.getCurrentDirectory,
|
|
realpath: host.realpath,
|
|
useCaseSensitiveFileNames: (_a2 = host.useCaseSensitiveFileNames) == null ? void 0 : _a2.call(host)
|
|
};
|
|
}
|
|
function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, oldImportSpecifier, options = {}) {
|
|
const res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {}, options);
|
|
if (res === oldImportSpecifier)
|
|
return void 0;
|
|
return res;
|
|
}
|
|
function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, options = {}) {
|
|
return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {}, options);
|
|
}
|
|
function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences, options = {}) {
|
|
const info = getInfo(importingSourceFile.path, host);
|
|
const modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences, options);
|
|
return firstDefined(
|
|
modulePaths,
|
|
(modulePath) => tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, preferences, true, options.overrideImportMode)
|
|
);
|
|
}
|
|
function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName2, host, preferences, userPreferences, options = {}) {
|
|
const info = getInfo(importingSourceFileName, host);
|
|
const modulePaths = getAllModulePaths(importingSourceFileName, toFileName2, host, userPreferences, options);
|
|
return firstDefined(modulePaths, (modulePath) => tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, void 0, options.overrideImportMode)) || getLocalModuleSpecifier(toFileName2, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences);
|
|
}
|
|
function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options = {}) {
|
|
return tryGetModuleSpecifiersFromCacheWorker(
|
|
moduleSymbol,
|
|
importingSourceFile,
|
|
host,
|
|
userPreferences,
|
|
options
|
|
)[0];
|
|
}
|
|
function tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options = {}) {
|
|
var _a2;
|
|
const moduleSourceFile = getSourceFileOfModule(moduleSymbol);
|
|
if (!moduleSourceFile) {
|
|
return emptyArray;
|
|
}
|
|
const cache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
const cached = cache == null ? void 0 : cache.get(importingSourceFile.path, moduleSourceFile.path, userPreferences, options);
|
|
return [cached == null ? void 0 : cached.moduleSpecifiers, moduleSourceFile, cached == null ? void 0 : cached.modulePaths, cache];
|
|
}
|
|
function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
return getModuleSpecifiersWithCacheInfo(
|
|
moduleSymbol,
|
|
checker,
|
|
compilerOptions,
|
|
importingSourceFile,
|
|
host,
|
|
userPreferences,
|
|
options
|
|
).moduleSpecifiers;
|
|
}
|
|
function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
let computedWithoutCache = false;
|
|
const ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker);
|
|
if (ambient)
|
|
return { moduleSpecifiers: [ambient], computedWithoutCache };
|
|
let [specifiers, moduleSourceFile, modulePaths, cache] = tryGetModuleSpecifiersFromCacheWorker(
|
|
moduleSymbol,
|
|
importingSourceFile,
|
|
host,
|
|
userPreferences,
|
|
options
|
|
);
|
|
if (specifiers)
|
|
return { moduleSpecifiers: specifiers, computedWithoutCache };
|
|
if (!moduleSourceFile)
|
|
return { moduleSpecifiers: emptyArray, computedWithoutCache };
|
|
computedWithoutCache = true;
|
|
modulePaths || (modulePaths = getAllModulePathsWorker(importingSourceFile.path, moduleSourceFile.originalFileName, host));
|
|
const result = computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options);
|
|
cache == null ? void 0 : cache.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, modulePaths, result);
|
|
return { moduleSpecifiers: result, computedWithoutCache };
|
|
}
|
|
function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options = {}) {
|
|
const info = getInfo(importingSourceFile.path, host);
|
|
const preferences = getPreferences(host, userPreferences, compilerOptions, importingSourceFile);
|
|
const existingSpecifier = forEach(modulePaths, (modulePath) => forEach(
|
|
host.getFileIncludeReasons().get(toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)),
|
|
(reason) => {
|
|
if (reason.kind !== 3 /* Import */ || reason.file !== importingSourceFile.path)
|
|
return void 0;
|
|
if (importingSourceFile.impliedNodeFormat && importingSourceFile.impliedNodeFormat !== getModeForResolutionAtIndex(importingSourceFile, reason.index))
|
|
return void 0;
|
|
const specifier = getModuleNameStringLiteralAt(importingSourceFile, reason.index).text;
|
|
return preferences.relativePreference !== 1 /* NonRelative */ || !pathIsRelative(specifier) ? specifier : void 0;
|
|
}
|
|
));
|
|
if (existingSpecifier) {
|
|
const moduleSpecifiers = [existingSpecifier];
|
|
return moduleSpecifiers;
|
|
}
|
|
const importedFileIsInNodeModules = some(modulePaths, (p) => p.isInNodeModules);
|
|
let nodeModulesSpecifiers;
|
|
let pathsSpecifiers;
|
|
let redirectPathsSpecifiers;
|
|
let relativeSpecifiers;
|
|
for (const modulePath of modulePaths) {
|
|
const specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, void 0, options.overrideImportMode);
|
|
nodeModulesSpecifiers = append(nodeModulesSpecifiers, specifier);
|
|
if (specifier && modulePath.isRedirect) {
|
|
return nodeModulesSpecifiers;
|
|
}
|
|
if (!specifier) {
|
|
const local = getLocalModuleSpecifier(
|
|
modulePath.path,
|
|
info,
|
|
compilerOptions,
|
|
host,
|
|
options.overrideImportMode || importingSourceFile.impliedNodeFormat,
|
|
preferences,
|
|
modulePath.isRedirect
|
|
);
|
|
if (!local) {
|
|
continue;
|
|
}
|
|
if (modulePath.isRedirect) {
|
|
redirectPathsSpecifiers = append(redirectPathsSpecifiers, local);
|
|
} else if (pathIsBareSpecifier(local)) {
|
|
pathsSpecifiers = append(pathsSpecifiers, local);
|
|
} else if (!importedFileIsInNodeModules || modulePath.isInNodeModules) {
|
|
relativeSpecifiers = append(relativeSpecifiers, local);
|
|
}
|
|
}
|
|
}
|
|
return (pathsSpecifiers == null ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : (redirectPathsSpecifiers == null ? void 0 : redirectPathsSpecifiers.length) ? redirectPathsSpecifiers : (nodeModulesSpecifiers == null ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : Debug.checkDefined(relativeSpecifiers);
|
|
}
|
|
function getInfo(importingSourceFileName, host) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true);
|
|
const sourceDirectory = getDirectoryPath(importingSourceFileName);
|
|
return { getCanonicalFileName, importingSourceFileName, sourceDirectory };
|
|
}
|
|
function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, { ending, relativePreference }, pathsOnly) {
|
|
const { baseUrl, paths, rootDirs } = compilerOptions;
|
|
if (pathsOnly && !paths) {
|
|
return void 0;
|
|
}
|
|
const { sourceDirectory, getCanonicalFileName } = info;
|
|
const relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || removeExtensionAndIndexPostFix(ensurePathIsNonModuleName(getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions);
|
|
if (!baseUrl && !paths || relativePreference === 0 /* Relative */) {
|
|
return pathsOnly ? void 0 : relativePath;
|
|
}
|
|
const baseDirectory = getNormalizedAbsolutePath(getPathsBasePath(compilerOptions, host) || baseUrl, host.getCurrentDirectory());
|
|
const relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseDirectory, getCanonicalFileName);
|
|
if (!relativeToBaseUrl) {
|
|
return pathsOnly ? void 0 : relativePath;
|
|
}
|
|
const fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, getAllowedEndings(ending, compilerOptions, importMode), host, compilerOptions);
|
|
if (pathsOnly) {
|
|
return fromPaths;
|
|
}
|
|
const maybeNonRelative = fromPaths === void 0 && baseUrl !== void 0 ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths;
|
|
if (!maybeNonRelative) {
|
|
return relativePath;
|
|
}
|
|
if (relativePreference === 1 /* NonRelative */ && !pathIsRelative(maybeNonRelative)) {
|
|
return maybeNonRelative;
|
|
}
|
|
if (relativePreference === 3 /* ExternalNonRelative */ && !pathIsRelative(maybeNonRelative)) {
|
|
const projectDirectory = compilerOptions.configFilePath ? toPath(getDirectoryPath(compilerOptions.configFilePath), host.getCurrentDirectory(), info.getCanonicalFileName) : info.getCanonicalFileName(host.getCurrentDirectory());
|
|
const modulePath = toPath(moduleFileName, projectDirectory, getCanonicalFileName);
|
|
const sourceIsInternal = startsWith(sourceDirectory, projectDirectory);
|
|
const targetIsInternal = startsWith(modulePath, projectDirectory);
|
|
if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) {
|
|
return maybeNonRelative;
|
|
}
|
|
const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
|
|
const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
|
|
if (nearestSourcePackageJson !== nearestTargetPackageJson) {
|
|
return maybeNonRelative;
|
|
}
|
|
return relativePath;
|
|
}
|
|
return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
|
|
}
|
|
function countPathComponents(path) {
|
|
let count = 0;
|
|
for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
|
|
if (path.charCodeAt(i) === 47 /* slash */)
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
function usesJsExtensionOnImports({ imports }) {
|
|
return firstDefined(imports, ({ text }) => pathIsRelative(text) ? hasJSFileExtension(text) : void 0) || false;
|
|
}
|
|
function comparePathsByRedirectAndNumberOfDirectorySeparators(a, b) {
|
|
return compareBooleans(b.isRedirect, a.isRedirect) || compareNumberOfDirectorySeparators(a.path, b.path);
|
|
}
|
|
function getNearestAncestorDirectoryWithPackageJson(host, fileName) {
|
|
if (host.getNearestAncestorDirectoryWithPackageJson) {
|
|
return host.getNearestAncestorDirectoryWithPackageJson(fileName);
|
|
}
|
|
return !!forEachAncestorDirectory(fileName, (directory) => {
|
|
return host.fileExists(combinePaths(directory, "package.json")) ? true : void 0;
|
|
});
|
|
}
|
|
function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) {
|
|
var _a2;
|
|
const getCanonicalFileName = hostGetCanonicalFileName(host);
|
|
const cwd = host.getCurrentDirectory();
|
|
const referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : void 0;
|
|
const importedPath = toPath(importedFileName, cwd, getCanonicalFileName);
|
|
const redirects = host.redirectTargetsMap.get(importedPath) || emptyArray;
|
|
const importedFileNames = [...referenceRedirect ? [referenceRedirect] : emptyArray, importedFileName, ...redirects];
|
|
const targets = importedFileNames.map((f) => getNormalizedAbsolutePath(f, cwd));
|
|
let shouldFilterIgnoredPaths = !every(targets, containsIgnoredPath);
|
|
if (!preferSymlinks) {
|
|
const result2 = forEach(targets, (p) => !(shouldFilterIgnoredPaths && containsIgnoredPath(p)) && cb(p, referenceRedirect === p));
|
|
if (result2)
|
|
return result2;
|
|
}
|
|
const symlinkedDirectories = (_a2 = host.getSymlinkCache) == null ? void 0 : _a2.call(host).getSymlinkedDirectoriesByRealpath();
|
|
const fullImportedFileName = getNormalizedAbsolutePath(importedFileName, cwd);
|
|
const result = symlinkedDirectories && forEachAncestorDirectory(getDirectoryPath(fullImportedFileName), (realPathDirectory) => {
|
|
const symlinkDirectories = symlinkedDirectories.get(ensureTrailingDirectorySeparator(toPath(realPathDirectory, cwd, getCanonicalFileName)));
|
|
if (!symlinkDirectories)
|
|
return void 0;
|
|
if (startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) {
|
|
return false;
|
|
}
|
|
return forEach(targets, (target) => {
|
|
if (!startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) {
|
|
return;
|
|
}
|
|
const relative = getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName);
|
|
for (const symlinkDirectory of symlinkDirectories) {
|
|
const option = resolvePath(symlinkDirectory, relative);
|
|
const result2 = cb(option, target === referenceRedirect);
|
|
shouldFilterIgnoredPaths = true;
|
|
if (result2)
|
|
return result2;
|
|
}
|
|
});
|
|
});
|
|
return result || (preferSymlinks ? forEach(targets, (p) => shouldFilterIgnoredPaths && containsIgnoredPath(p) ? void 0 : cb(p, p === referenceRedirect)) : void 0);
|
|
}
|
|
function getAllModulePaths(importingFilePath, importedFileName, host, preferences, options = {}) {
|
|
var _a2;
|
|
const importedFilePath = toPath(importedFileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
|
|
const cache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
if (cache) {
|
|
const cached = cache.get(importingFilePath, importedFilePath, preferences, options);
|
|
if (cached == null ? void 0 : cached.modulePaths)
|
|
return cached.modulePaths;
|
|
}
|
|
const modulePaths = getAllModulePathsWorker(importingFilePath, importedFileName, host);
|
|
if (cache) {
|
|
cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths);
|
|
}
|
|
return modulePaths;
|
|
}
|
|
function getAllModulePathsWorker(importingFileName, importedFileName, host) {
|
|
const getCanonicalFileName = hostGetCanonicalFileName(host);
|
|
const allFileNames = /* @__PURE__ */ new Map();
|
|
let importedFileFromNodeModules = false;
|
|
forEachFileNameOfModule(
|
|
importingFileName,
|
|
importedFileName,
|
|
host,
|
|
true,
|
|
(path, isRedirect) => {
|
|
const isInNodeModules = pathContainsNodeModules(path);
|
|
allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect, isInNodeModules });
|
|
importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules;
|
|
}
|
|
);
|
|
const sortedPaths = [];
|
|
for (let directory = getDirectoryPath(importingFileName); allFileNames.size !== 0; ) {
|
|
const directoryStart = ensureTrailingDirectorySeparator(directory);
|
|
let pathsInDirectory;
|
|
allFileNames.forEach(({ path, isRedirect, isInNodeModules }, fileName) => {
|
|
if (startsWith(path, directoryStart)) {
|
|
(pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect, isInNodeModules });
|
|
allFileNames.delete(fileName);
|
|
}
|
|
});
|
|
if (pathsInDirectory) {
|
|
if (pathsInDirectory.length > 1) {
|
|
pathsInDirectory.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
|
|
}
|
|
sortedPaths.push(...pathsInDirectory);
|
|
}
|
|
const newDirectory = getDirectoryPath(directory);
|
|
if (newDirectory === directory)
|
|
break;
|
|
directory = newDirectory;
|
|
}
|
|
if (allFileNames.size) {
|
|
const remainingPaths = arrayFrom(allFileNames.values());
|
|
if (remainingPaths.length > 1)
|
|
remainingPaths.sort(comparePathsByRedirectAndNumberOfDirectorySeparators);
|
|
sortedPaths.push(...remainingPaths);
|
|
}
|
|
return sortedPaths;
|
|
}
|
|
function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) {
|
|
var _a2;
|
|
const decl = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(
|
|
(d) => isNonGlobalAmbientModule(d) && (!isExternalModuleAugmentation(d) || !isExternalModuleNameRelative(getTextOfIdentifierOrLiteral(d.name)))
|
|
);
|
|
if (decl) {
|
|
return decl.name.text;
|
|
}
|
|
const ambientModuleDeclareCandidates = mapDefined(
|
|
moduleSymbol.declarations,
|
|
(d) => {
|
|
var _a3, _b, _c, _d;
|
|
if (!isModuleDeclaration(d))
|
|
return;
|
|
const topNamespace = getTopNamespace(d);
|
|
if (!(((_a3 = topNamespace == null ? void 0 : topNamespace.parent) == null ? void 0 : _a3.parent) && isModuleBlock(topNamespace.parent) && isAmbientModule(topNamespace.parent.parent) && isSourceFile(topNamespace.parent.parent.parent)))
|
|
return;
|
|
const exportAssignment = (_d = (_c = (_b = topNamespace.parent.parent.symbol.exports) == null ? void 0 : _b.get("export=")) == null ? void 0 : _c.valueDeclaration) == null ? void 0 : _d.expression;
|
|
if (!exportAssignment)
|
|
return;
|
|
const exportSymbol = checker.getSymbolAtLocation(exportAssignment);
|
|
if (!exportSymbol)
|
|
return;
|
|
const originalExportSymbol = (exportSymbol == null ? 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;
|
|
}
|
|
}
|
|
);
|
|
const ambientModuleDeclare = ambientModuleDeclareCandidates[0];
|
|
if (ambientModuleDeclare) {
|
|
return ambientModuleDeclare.name.text;
|
|
}
|
|
}
|
|
function getAllowedEndings(preferredEnding, compilerOptions, importMode) {
|
|
if (getEmitModuleResolutionKind(compilerOptions) >= 3 /* Node16 */ && importMode === 99 /* ESNext */) {
|
|
return [2 /* JsExtension */];
|
|
}
|
|
switch (preferredEnding) {
|
|
case 2 /* JsExtension */:
|
|
return [2 /* JsExtension */, 0 /* Minimal */, 1 /* Index */];
|
|
case 1 /* Index */:
|
|
return [1 /* Index */, 0 /* Minimal */, 2 /* JsExtension */];
|
|
case 0 /* Minimal */:
|
|
return [0 /* Minimal */, 1 /* Index */, 2 /* JsExtension */];
|
|
default:
|
|
Debug.assertNever(preferredEnding);
|
|
}
|
|
}
|
|
function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
|
|
for (const key in paths) {
|
|
for (const patternText2 of paths[key]) {
|
|
const pattern = normalizePath(patternText2);
|
|
const indexOfStar = pattern.indexOf("*");
|
|
const candidates = allowedEndings.map((ending) => ({
|
|
ending,
|
|
value: removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions)
|
|
}));
|
|
if (tryGetExtensionFromPath2(pattern)) {
|
|
candidates.push({ ending: void 0, value: relativeToBaseUrl });
|
|
}
|
|
if (indexOfStar !== -1) {
|
|
const prefix = pattern.substring(0, indexOfStar);
|
|
const suffix = pattern.substring(indexOfStar + 1);
|
|
for (const { ending, value } of candidates) {
|
|
if (value.length >= prefix.length + suffix.length && startsWith(value, prefix) && endsWith(value, suffix) && validateEnding({ ending, value })) {
|
|
const matchedStar = value.substring(prefix.length, value.length - suffix.length);
|
|
return key.replace("*", matchedStar);
|
|
}
|
|
}
|
|
} else if (some(candidates, (c) => c.ending !== 0 /* Minimal */ && pattern === c.value) || some(candidates, (c) => c.ending === 0 /* Minimal */ && pattern === c.value && validateEnding(c))) {
|
|
return key;
|
|
}
|
|
}
|
|
}
|
|
function validateEnding({ ending, value }) {
|
|
return ending !== 0 /* Minimal */ || value === removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions, host);
|
|
}
|
|
}
|
|
function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports, conditions, mode = 0 /* Exact */) {
|
|
if (typeof exports === "string") {
|
|
const pathOrPattern = getNormalizedAbsolutePath(combinePaths(packageDirectory, exports), void 0);
|
|
const extensionSwappedTarget = hasTSFileExtension(targetFilePath) ? removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : void 0;
|
|
switch (mode) {
|
|
case 0 /* Exact */:
|
|
if (comparePaths(targetFilePath, pathOrPattern) === 0 /* EqualTo */ || extensionSwappedTarget && comparePaths(extensionSwappedTarget, pathOrPattern) === 0 /* EqualTo */) {
|
|
return { moduleFileToTry: packageName };
|
|
}
|
|
break;
|
|
case 1 /* Directory */:
|
|
if (containsPath(pathOrPattern, targetFilePath)) {
|
|
const fragment = getRelativePathFromDirectory(pathOrPattern, targetFilePath, false);
|
|
return { moduleFileToTry: getNormalizedAbsolutePath(combinePaths(combinePaths(packageName, exports), fragment), void 0) };
|
|
}
|
|
break;
|
|
case 2 /* Pattern */:
|
|
const starPos = pathOrPattern.indexOf("*");
|
|
const leadingSlice = pathOrPattern.slice(0, starPos);
|
|
const trailingSlice = pathOrPattern.slice(starPos + 1);
|
|
if (startsWith(targetFilePath, leadingSlice) && endsWith(targetFilePath, trailingSlice)) {
|
|
const starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length);
|
|
return { moduleFileToTry: packageName.replace("*", starReplacement) };
|
|
}
|
|
if (extensionSwappedTarget && startsWith(extensionSwappedTarget, leadingSlice) && endsWith(extensionSwappedTarget, trailingSlice)) {
|
|
const starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length);
|
|
return { moduleFileToTry: packageName.replace("*", starReplacement) };
|
|
}
|
|
break;
|
|
}
|
|
} else if (Array.isArray(exports)) {
|
|
return forEach(exports, (e) => tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions));
|
|
} else if (typeof exports === "object" && exports !== null) {
|
|
if (allKeysStartWithDot(exports)) {
|
|
return forEach(getOwnKeys(exports), (k) => {
|
|
const subPackageName = getNormalizedAbsolutePath(combinePaths(packageName, k), void 0);
|
|
const mode2 = endsWith(k, "/") ? 1 /* Directory */ : stringContains(k, "*") ? 2 /* Pattern */ : 0 /* Exact */;
|
|
return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports[k], conditions, mode2);
|
|
});
|
|
} else {
|
|
for (const key of getOwnKeys(exports)) {
|
|
if (key === "default" || conditions.indexOf(key) >= 0 || isApplicableVersionedTypesKey(conditions, key)) {
|
|
const subTarget = exports[key];
|
|
const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
|
|
const normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
|
|
if (normalizedTargetPaths === void 0) {
|
|
return void 0;
|
|
}
|
|
const normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
|
|
const relativePaths = flatMap(normalizedSourcePaths, (sourcePath) => {
|
|
return map(normalizedTargetPaths, (targetPath) => ensurePathIsNonModuleName(getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)));
|
|
});
|
|
const shortest = min(relativePaths, compareNumberOfDirectorySeparators);
|
|
if (!shortest) {
|
|
return void 0;
|
|
}
|
|
return getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */ ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions) : removeFileExtension(shortest);
|
|
}
|
|
function tryGetModuleNameAsNodeModule({ path, isRedirect }, { getCanonicalFileName, sourceDirectory }, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
|
|
if (!host.fileExists || !host.readFile) {
|
|
return void 0;
|
|
}
|
|
const parts = getNodeModulePathParts(path);
|
|
if (!parts) {
|
|
return void 0;
|
|
}
|
|
const preferences = getPreferences(host, userPreferences, options, importingSourceFile);
|
|
let moduleSpecifier = path;
|
|
let isPackageRootPath = false;
|
|
if (!packageNameOnly) {
|
|
let packageRootIndex = parts.packageRootIndex;
|
|
let moduleFileName;
|
|
while (true) {
|
|
const { moduleFileToTry, packageRootPath, blockedByExports, verbatimFromExports } = tryDirectoryWithPackageJson(packageRootIndex);
|
|
if (getEmitModuleResolutionKind(options) !== 1 /* Classic */) {
|
|
if (blockedByExports) {
|
|
return void 0;
|
|
}
|
|
if (verbatimFromExports) {
|
|
return moduleFileToTry;
|
|
}
|
|
}
|
|
if (packageRootPath) {
|
|
moduleSpecifier = packageRootPath;
|
|
isPackageRootPath = true;
|
|
break;
|
|
}
|
|
if (!moduleFileName)
|
|
moduleFileName = moduleFileToTry;
|
|
packageRootIndex = path.indexOf(directorySeparator, packageRootIndex + 1);
|
|
if (packageRootIndex === -1) {
|
|
moduleSpecifier = removeExtensionAndIndexPostFix(moduleFileName, preferences.ending, options, host);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (isRedirect && !isPackageRootPath) {
|
|
return void 0;
|
|
}
|
|
const globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation();
|
|
const pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex));
|
|
if (!(startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) {
|
|
return void 0;
|
|
}
|
|
const nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1);
|
|
const packageName = getPackageNameFromTypesPackageName(nodeModulesDirectoryName);
|
|
return getEmitModuleResolutionKind(options) === 1 /* Classic */ && packageName === nodeModulesDirectoryName ? void 0 : packageName;
|
|
function tryDirectoryWithPackageJson(packageRootIndex) {
|
|
var _a2, _b;
|
|
const packageRootPath = path.substring(0, packageRootIndex);
|
|
const packageJsonPath = combinePaths(packageRootPath, "package.json");
|
|
let moduleFileToTry = path;
|
|
let maybeBlockedByTypesVersions = false;
|
|
const cachedPackageJson = (_b = (_a2 = host.getPackageJsonInfoCache) == null ? void 0 : _a2.call(host)) == null ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
|
|
if (typeof cachedPackageJson === "object" || cachedPackageJson === void 0 && host.fileExists(packageJsonPath)) {
|
|
const packageJsonContent = (cachedPackageJson == null ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
|
|
const importMode = overrideMode || importingSourceFile.impliedNodeFormat;
|
|
if (getEmitModuleResolutionKind(options) === 3 /* Node16 */ || getEmitModuleResolutionKind(options) === 99 /* NodeNext */) {
|
|
const conditions = ["node", importMode === 99 /* ESNext */ ? "import" : "require", "types"];
|
|
const fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" ? tryGetModuleNameFromExports(options, path, packageRootPath, getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions) : void 0;
|
|
if (fromExports) {
|
|
const withJsExtension = !hasTSFileExtension(fromExports.moduleFileToTry) ? fromExports : { moduleFileToTry: removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) };
|
|
return { ...withJsExtension, verbatimFromExports: true };
|
|
}
|
|
if (packageJsonContent.exports) {
|
|
return { moduleFileToTry: path, blockedByExports: true };
|
|
}
|
|
}
|
|
const versionPaths = packageJsonContent.typesVersions ? getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) : void 0;
|
|
if (versionPaths) {
|
|
const subModuleName = path.slice(packageRootPath.length + 1);
|
|
const fromPaths = tryGetModuleNameFromPaths(
|
|
subModuleName,
|
|
versionPaths.paths,
|
|
getAllowedEndings(preferences.ending, options, importMode),
|
|
host,
|
|
options
|
|
);
|
|
if (fromPaths === void 0) {
|
|
maybeBlockedByTypesVersions = true;
|
|
} else {
|
|
moduleFileToTry = combinePaths(packageRootPath, fromPaths);
|
|
}
|
|
}
|
|
const mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js";
|
|
if (isString(mainFileRelative) && !(maybeBlockedByTypesVersions && matchPatternOrExact(tryParsePatterns(versionPaths.paths), mainFileRelative))) {
|
|
const mainExportFile = toPath(mainFileRelative, packageRootPath, getCanonicalFileName);
|
|
if (removeFileExtension(mainExportFile) === removeFileExtension(getCanonicalFileName(moduleFileToTry))) {
|
|
return { packageRootPath, moduleFileToTry };
|
|
}
|
|
}
|
|
} else {
|
|
const fileName = getCanonicalFileName(moduleFileToTry.substring(parts.packageRootIndex + 1));
|
|
if (fileName === "index.d.ts" || fileName === "index.js" || fileName === "index.ts" || fileName === "index.tsx") {
|
|
return { moduleFileToTry, packageRootPath };
|
|
}
|
|
}
|
|
return { moduleFileToTry };
|
|
}
|
|
}
|
|
function tryGetAnyFileFromPath(host, path) {
|
|
if (!host.fileExists)
|
|
return;
|
|
const extensions = flatten(getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 /* JSON */ }]));
|
|
for (const e of extensions) {
|
|
const fullPath = path + e;
|
|
if (host.fileExists(fullPath)) {
|
|
return fullPath;
|
|
}
|
|
}
|
|
}
|
|
function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
|
|
return mapDefined(rootDirs, (rootDir) => {
|
|
const relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
|
|
return relativePath !== void 0 && isPathRelativeToParent(relativePath) ? void 0 : relativePath;
|
|
});
|
|
}
|
|
function removeExtensionAndIndexPostFix(fileName, ending, options, host) {
|
|
if (fileExtensionIsOneOf(fileName, [".json" /* Json */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]))
|
|
return fileName;
|
|
const noExtension = removeFileExtension(fileName);
|
|
if (fileName === noExtension)
|
|
return fileName;
|
|
if (fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".d.cts" /* Dcts */, ".cts" /* Cts */]))
|
|
return noExtension + getJSExtensionForFile(fileName, options);
|
|
switch (ending) {
|
|
case 0 /* Minimal */:
|
|
const withoutIndex = removeSuffix(noExtension, "/index");
|
|
if (host && withoutIndex !== noExtension && tryGetAnyFileFromPath(host, withoutIndex)) {
|
|
return noExtension;
|
|
}
|
|
return withoutIndex;
|
|
case 1 /* Index */:
|
|
return noExtension;
|
|
case 2 /* JsExtension */:
|
|
return noExtension + getJSExtensionForFile(fileName, options);
|
|
default:
|
|
return Debug.assertNever(ending);
|
|
}
|
|
}
|
|
function getJSExtensionForFile(fileName, options) {
|
|
var _a2;
|
|
return (_a2 = tryGetJSExtensionForFile(fileName, options)) != null ? _a2 : Debug.fail(`Extension ${extensionFromPath(fileName)} is unsupported:: FileName:: ${fileName}`);
|
|
}
|
|
function tryGetJSExtensionForFile(fileName, options) {
|
|
const ext = tryGetExtensionFromPath2(fileName);
|
|
switch (ext) {
|
|
case ".ts" /* Ts */:
|
|
case ".d.ts" /* Dts */:
|
|
return ".js" /* Js */;
|
|
case ".tsx" /* Tsx */:
|
|
return options.jsx === 1 /* Preserve */ ? ".jsx" /* Jsx */ : ".js" /* Js */;
|
|
case ".js" /* Js */:
|
|
case ".jsx" /* Jsx */:
|
|
case ".json" /* Json */:
|
|
return ext;
|
|
case ".d.mts" /* Dmts */:
|
|
case ".mts" /* Mts */:
|
|
case ".mjs" /* Mjs */:
|
|
return ".mjs" /* Mjs */;
|
|
case ".d.cts" /* Dcts */:
|
|
case ".cts" /* Cts */:
|
|
case ".cjs" /* Cjs */:
|
|
return ".cjs" /* Cjs */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getRelativePathIfInDirectory(path, directoryPath, getCanonicalFileName) {
|
|
const relativePath = getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, false);
|
|
return isRootedDiskPath(relativePath) ? void 0 : relativePath;
|
|
}
|
|
function isPathRelativeToParent(path) {
|
|
return startsWith(path, "..");
|
|
}
|
|
|
|
// src/compiler/checker.ts
|
|
var ambientModuleSymbolRegex = /^".+"$/;
|
|
var anon = "(anonymous)";
|
|
var nextSymbolId = 1;
|
|
var nextNodeId = 1;
|
|
var nextMergeId = 1;
|
|
var nextFlowId = 1;
|
|
var TypeFacts = /* @__PURE__ */ ((TypeFacts3) => {
|
|
TypeFacts3[TypeFacts3["None"] = 0] = "None";
|
|
TypeFacts3[TypeFacts3["TypeofEQString"] = 1] = "TypeofEQString";
|
|
TypeFacts3[TypeFacts3["TypeofEQNumber"] = 2] = "TypeofEQNumber";
|
|
TypeFacts3[TypeFacts3["TypeofEQBigInt"] = 4] = "TypeofEQBigInt";
|
|
TypeFacts3[TypeFacts3["TypeofEQBoolean"] = 8] = "TypeofEQBoolean";
|
|
TypeFacts3[TypeFacts3["TypeofEQSymbol"] = 16] = "TypeofEQSymbol";
|
|
TypeFacts3[TypeFacts3["TypeofEQObject"] = 32] = "TypeofEQObject";
|
|
TypeFacts3[TypeFacts3["TypeofEQFunction"] = 64] = "TypeofEQFunction";
|
|
TypeFacts3[TypeFacts3["TypeofEQHostObject"] = 128] = "TypeofEQHostObject";
|
|
TypeFacts3[TypeFacts3["TypeofNEString"] = 256] = "TypeofNEString";
|
|
TypeFacts3[TypeFacts3["TypeofNENumber"] = 512] = "TypeofNENumber";
|
|
TypeFacts3[TypeFacts3["TypeofNEBigInt"] = 1024] = "TypeofNEBigInt";
|
|
TypeFacts3[TypeFacts3["TypeofNEBoolean"] = 2048] = "TypeofNEBoolean";
|
|
TypeFacts3[TypeFacts3["TypeofNESymbol"] = 4096] = "TypeofNESymbol";
|
|
TypeFacts3[TypeFacts3["TypeofNEObject"] = 8192] = "TypeofNEObject";
|
|
TypeFacts3[TypeFacts3["TypeofNEFunction"] = 16384] = "TypeofNEFunction";
|
|
TypeFacts3[TypeFacts3["TypeofNEHostObject"] = 32768] = "TypeofNEHostObject";
|
|
TypeFacts3[TypeFacts3["EQUndefined"] = 65536] = "EQUndefined";
|
|
TypeFacts3[TypeFacts3["EQNull"] = 131072] = "EQNull";
|
|
TypeFacts3[TypeFacts3["EQUndefinedOrNull"] = 262144] = "EQUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["NEUndefined"] = 524288] = "NEUndefined";
|
|
TypeFacts3[TypeFacts3["NENull"] = 1048576] = "NENull";
|
|
TypeFacts3[TypeFacts3["NEUndefinedOrNull"] = 2097152] = "NEUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["Truthy"] = 4194304] = "Truthy";
|
|
TypeFacts3[TypeFacts3["Falsy"] = 8388608] = "Falsy";
|
|
TypeFacts3[TypeFacts3["IsUndefined"] = 16777216] = "IsUndefined";
|
|
TypeFacts3[TypeFacts3["IsNull"] = 33554432] = "IsNull";
|
|
TypeFacts3[TypeFacts3["IsUndefinedOrNull"] = 50331648] = "IsUndefinedOrNull";
|
|
TypeFacts3[TypeFacts3["All"] = 134217727] = "All";
|
|
TypeFacts3[TypeFacts3["BaseStringStrictFacts"] = 3735041] = "BaseStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseStringFacts"] = 12582401] = "BaseStringFacts";
|
|
TypeFacts3[TypeFacts3["StringStrictFacts"] = 16317953] = "StringStrictFacts";
|
|
TypeFacts3[TypeFacts3["StringFacts"] = 16776705] = "StringFacts";
|
|
TypeFacts3[TypeFacts3["EmptyStringStrictFacts"] = 12123649] = "EmptyStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["EmptyStringFacts"] = 12582401 /* BaseStringFacts */] = "EmptyStringFacts";
|
|
TypeFacts3[TypeFacts3["NonEmptyStringStrictFacts"] = 7929345] = "NonEmptyStringStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonEmptyStringFacts"] = 16776705] = "NonEmptyStringFacts";
|
|
TypeFacts3[TypeFacts3["BaseNumberStrictFacts"] = 3734786] = "BaseNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseNumberFacts"] = 12582146] = "BaseNumberFacts";
|
|
TypeFacts3[TypeFacts3["NumberStrictFacts"] = 16317698] = "NumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["NumberFacts"] = 16776450] = "NumberFacts";
|
|
TypeFacts3[TypeFacts3["ZeroNumberStrictFacts"] = 12123394] = "ZeroNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["ZeroNumberFacts"] = 12582146 /* BaseNumberFacts */] = "ZeroNumberFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroNumberStrictFacts"] = 7929090] = "NonZeroNumberStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroNumberFacts"] = 16776450] = "NonZeroNumberFacts";
|
|
TypeFacts3[TypeFacts3["BaseBigIntStrictFacts"] = 3734276] = "BaseBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseBigIntFacts"] = 12581636] = "BaseBigIntFacts";
|
|
TypeFacts3[TypeFacts3["BigIntStrictFacts"] = 16317188] = "BigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["BigIntFacts"] = 16775940] = "BigIntFacts";
|
|
TypeFacts3[TypeFacts3["ZeroBigIntStrictFacts"] = 12122884] = "ZeroBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["ZeroBigIntFacts"] = 12581636 /* BaseBigIntFacts */] = "ZeroBigIntFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroBigIntStrictFacts"] = 7928580] = "NonZeroBigIntStrictFacts";
|
|
TypeFacts3[TypeFacts3["NonZeroBigIntFacts"] = 16775940] = "NonZeroBigIntFacts";
|
|
TypeFacts3[TypeFacts3["BaseBooleanStrictFacts"] = 3733256] = "BaseBooleanStrictFacts";
|
|
TypeFacts3[TypeFacts3["BaseBooleanFacts"] = 12580616] = "BaseBooleanFacts";
|
|
TypeFacts3[TypeFacts3["BooleanStrictFacts"] = 16316168] = "BooleanStrictFacts";
|
|
TypeFacts3[TypeFacts3["BooleanFacts"] = 16774920] = "BooleanFacts";
|
|
TypeFacts3[TypeFacts3["FalseStrictFacts"] = 12121864] = "FalseStrictFacts";
|
|
TypeFacts3[TypeFacts3["FalseFacts"] = 12580616 /* BaseBooleanFacts */] = "FalseFacts";
|
|
TypeFacts3[TypeFacts3["TrueStrictFacts"] = 7927560] = "TrueStrictFacts";
|
|
TypeFacts3[TypeFacts3["TrueFacts"] = 16774920] = "TrueFacts";
|
|
TypeFacts3[TypeFacts3["SymbolStrictFacts"] = 7925520] = "SymbolStrictFacts";
|
|
TypeFacts3[TypeFacts3["SymbolFacts"] = 16772880] = "SymbolFacts";
|
|
TypeFacts3[TypeFacts3["ObjectStrictFacts"] = 7888800] = "ObjectStrictFacts";
|
|
TypeFacts3[TypeFacts3["ObjectFacts"] = 16736160] = "ObjectFacts";
|
|
TypeFacts3[TypeFacts3["FunctionStrictFacts"] = 7880640] = "FunctionStrictFacts";
|
|
TypeFacts3[TypeFacts3["FunctionFacts"] = 16728e3] = "FunctionFacts";
|
|
TypeFacts3[TypeFacts3["VoidFacts"] = 9830144] = "VoidFacts";
|
|
TypeFacts3[TypeFacts3["UndefinedFacts"] = 26607360] = "UndefinedFacts";
|
|
TypeFacts3[TypeFacts3["NullFacts"] = 42917664] = "NullFacts";
|
|
TypeFacts3[TypeFacts3["EmptyObjectStrictFacts"] = 83427327] = "EmptyObjectStrictFacts";
|
|
TypeFacts3[TypeFacts3["EmptyObjectFacts"] = 83886079] = "EmptyObjectFacts";
|
|
TypeFacts3[TypeFacts3["UnknownFacts"] = 83886079] = "UnknownFacts";
|
|
TypeFacts3[TypeFacts3["AllTypeofNE"] = 556800] = "AllTypeofNE";
|
|
TypeFacts3[TypeFacts3["OrFactsMask"] = 8256] = "OrFactsMask";
|
|
TypeFacts3[TypeFacts3["AndFactsMask"] = 134209471] = "AndFactsMask";
|
|
return TypeFacts3;
|
|
})(TypeFacts || {});
|
|
var typeofNEFacts = new Map(getEntries({
|
|
string: 256 /* TypeofNEString */,
|
|
number: 512 /* TypeofNENumber */,
|
|
bigint: 1024 /* TypeofNEBigInt */,
|
|
boolean: 2048 /* TypeofNEBoolean */,
|
|
symbol: 4096 /* TypeofNESymbol */,
|
|
undefined: 524288 /* NEUndefined */,
|
|
object: 8192 /* TypeofNEObject */,
|
|
function: 16384 /* TypeofNEFunction */
|
|
}));
|
|
var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
|
|
CheckMode3[CheckMode3["Normal"] = 0] = "Normal";
|
|
CheckMode3[CheckMode3["Contextual"] = 1] = "Contextual";
|
|
CheckMode3[CheckMode3["Inferential"] = 2] = "Inferential";
|
|
CheckMode3[CheckMode3["SkipContextSensitive"] = 4] = "SkipContextSensitive";
|
|
CheckMode3[CheckMode3["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
|
|
CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
|
|
CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
|
|
CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
|
|
return CheckMode3;
|
|
})(CheckMode || {});
|
|
var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
|
|
SignatureCheckMode3[SignatureCheckMode3["None"] = 0] = "None";
|
|
SignatureCheckMode3[SignatureCheckMode3["BivariantCallback"] = 1] = "BivariantCallback";
|
|
SignatureCheckMode3[SignatureCheckMode3["StrictCallback"] = 2] = "StrictCallback";
|
|
SignatureCheckMode3[SignatureCheckMode3["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
|
|
SignatureCheckMode3[SignatureCheckMode3["StrictArity"] = 8] = "StrictArity";
|
|
SignatureCheckMode3[SignatureCheckMode3["Callback"] = 3] = "Callback";
|
|
return SignatureCheckMode3;
|
|
})(SignatureCheckMode || {});
|
|
var isNotOverloadAndNotAccessor = and(isNotOverload, isNotAccessor);
|
|
var intrinsicTypeKinds = new Map(getEntries({
|
|
Uppercase: 0 /* Uppercase */,
|
|
Lowercase: 1 /* Lowercase */,
|
|
Capitalize: 2 /* Capitalize */,
|
|
Uncapitalize: 3 /* Uncapitalize */
|
|
}));
|
|
function SymbolLinks() {
|
|
}
|
|
function NodeLinks() {
|
|
this.flags = 0 /* None */;
|
|
}
|
|
function getNodeId(node) {
|
|
if (!node.id) {
|
|
node.id = nextNodeId;
|
|
nextNodeId++;
|
|
}
|
|
return node.id;
|
|
}
|
|
function getSymbolId(symbol) {
|
|
if (!symbol.id) {
|
|
symbol.id = nextSymbolId;
|
|
nextSymbolId++;
|
|
}
|
|
return symbol.id;
|
|
}
|
|
function isInstantiatedModule(node, preserveConstEnums) {
|
|
const moduleState = getModuleInstanceState(node);
|
|
return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
|
|
}
|
|
function createTypeChecker(host) {
|
|
const getPackagesMap = memoize(() => {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
host.getSourceFiles().forEach((sf) => {
|
|
if (!sf.resolvedModules)
|
|
return;
|
|
sf.resolvedModules.forEach((r) => {
|
|
if (r && r.packageId)
|
|
map2.set(r.packageId.name, r.extension === ".d.ts" /* Dts */ || !!map2.get(r.packageId.name));
|
|
});
|
|
});
|
|
return map2;
|
|
});
|
|
let deferredDiagnosticsCallbacks = [];
|
|
let addLazyDiagnostic = (arg) => {
|
|
deferredDiagnosticsCallbacks.push(arg);
|
|
};
|
|
let cancellationToken;
|
|
let requestedExternalEmitHelpers;
|
|
let externalHelpersModule;
|
|
const Symbol46 = objectAllocator.getSymbolConstructor();
|
|
const Type27 = objectAllocator.getTypeConstructor();
|
|
const Signature15 = objectAllocator.getSignatureConstructor();
|
|
let typeCount = 0;
|
|
let symbolCount = 0;
|
|
let totalInstantiationCount = 0;
|
|
let instantiationCount = 0;
|
|
let instantiationDepth = 0;
|
|
let inlineLevel = 0;
|
|
let currentNode;
|
|
let varianceTypeParameter;
|
|
const emptySymbols = createSymbolTable();
|
|
const arrayVariances = [1 /* Covariant */];
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
|
|
const allowSyntheticDefaultImports = getAllowSyntheticDefaultImports(compilerOptions);
|
|
const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
|
|
const strictFunctionTypes = getStrictOptionValue(compilerOptions, "strictFunctionTypes");
|
|
const strictBindCallApply = getStrictOptionValue(compilerOptions, "strictBindCallApply");
|
|
const strictPropertyInitialization = getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
|
|
const noImplicitAny = getStrictOptionValue(compilerOptions, "noImplicitAny");
|
|
const noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
|
|
const useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
|
|
const keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
|
|
const freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
|
|
const exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
|
|
const checkBinaryExpression = createCheckBinaryExpression();
|
|
const emitResolver = createResolver();
|
|
const nodeBuilder = createNodeBuilder();
|
|
const globals = createSymbolTable();
|
|
const undefinedSymbol = createSymbol(4 /* Property */, "undefined");
|
|
undefinedSymbol.declarations = [];
|
|
const globalThisSymbol = createSymbol(1536 /* Module */, "globalThis", 8 /* Readonly */);
|
|
globalThisSymbol.exports = globals;
|
|
globalThisSymbol.declarations = [];
|
|
globals.set(globalThisSymbol.escapedName, globalThisSymbol);
|
|
const argumentsSymbol = createSymbol(4 /* Property */, "arguments");
|
|
const requireSymbol = createSymbol(4 /* Property */, "require");
|
|
let apparentArgumentCount;
|
|
const checker = {
|
|
getNodeCount: () => sum(host.getSourceFiles(), "nodeCount"),
|
|
getIdentifierCount: () => sum(host.getSourceFiles(), "identifierCount"),
|
|
getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount") + symbolCount,
|
|
getTypeCount: () => typeCount,
|
|
getInstantiationCount: () => totalInstantiationCount,
|
|
getRelationCacheSizes: () => ({
|
|
assignable: assignableRelation.size,
|
|
identity: identityRelation.size,
|
|
subtype: subtypeRelation.size,
|
|
strictSubtype: strictSubtypeRelation.size
|
|
}),
|
|
isUndefinedSymbol: (symbol) => symbol === undefinedSymbol,
|
|
isArgumentsSymbol: (symbol) => symbol === argumentsSymbol,
|
|
isUnknownSymbol: (symbol) => symbol === unknownSymbol,
|
|
getMergedSymbol,
|
|
getDiagnostics: getDiagnostics2,
|
|
getGlobalDiagnostics,
|
|
getRecursionIdentity,
|
|
getUnmatchedProperties,
|
|
getTypeOfSymbolAtLocation: (symbol, locationIn) => {
|
|
const location2 = getParseTreeNode(locationIn);
|
|
return location2 ? getTypeOfSymbolAtLocation(symbol, location2) : errorType;
|
|
},
|
|
getTypeOfSymbol,
|
|
getSymbolsOfParameterPropertyDeclaration: (parameterIn, parameterName) => {
|
|
const parameter = getParseTreeNode(parameterIn, isParameter);
|
|
if (parameter === void 0)
|
|
return Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node.");
|
|
return getSymbolsOfParameterPropertyDeclaration(parameter, escapeLeadingUnderscores(parameterName));
|
|
},
|
|
getDeclaredTypeOfSymbol,
|
|
getPropertiesOfType,
|
|
getPropertyOfType: (type, name) => getPropertyOfType(type, escapeLeadingUnderscores(name)),
|
|
getPrivateIdentifierPropertyOfType: (leftType, name, location2) => {
|
|
const node = getParseTreeNode(location2);
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
const propName = escapeLeadingUnderscores(name);
|
|
const lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node);
|
|
return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : void 0;
|
|
},
|
|
getTypeOfPropertyOfType: (type, name) => getTypeOfPropertyOfType(type, escapeLeadingUnderscores(name)),
|
|
getIndexInfoOfType: (type, kind) => getIndexInfoOfType(type, kind === 0 /* String */ ? stringType : numberType),
|
|
getIndexInfosOfType,
|
|
getIndexInfosOfIndexSymbol,
|
|
getSignaturesOfType,
|
|
getIndexTypeOfType: (type, kind) => getIndexTypeOfType(type, kind === 0 /* String */ ? stringType : numberType),
|
|
getIndexType: (type) => getIndexType(type),
|
|
getBaseTypes,
|
|
getBaseTypeOfLiteralType,
|
|
getWidenedType,
|
|
getTypeFromTypeNode: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isTypeNode);
|
|
return node ? getTypeFromTypeNode(node) : errorType;
|
|
},
|
|
getParameterType: getTypeAtPosition,
|
|
getParameterIdentifierNameAtPosition,
|
|
getPromisedTypeOfPromise,
|
|
getAwaitedType: (type) => getAwaitedType(type),
|
|
getReturnTypeOfSignature,
|
|
isNullableType,
|
|
getNullableType,
|
|
getNonNullableType,
|
|
getNonOptionalType: removeOptionalTypeMarker,
|
|
getTypeArguments,
|
|
typeToTypeNode: nodeBuilder.typeToTypeNode,
|
|
indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration,
|
|
signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration,
|
|
symbolToEntityName: nodeBuilder.symbolToEntityName,
|
|
symbolToExpression: nodeBuilder.symbolToExpression,
|
|
symbolToNode: nodeBuilder.symbolToNode,
|
|
symbolToTypeParameterDeclarations: nodeBuilder.symbolToTypeParameterDeclarations,
|
|
symbolToParameterDeclaration: nodeBuilder.symbolToParameterDeclaration,
|
|
typeParameterToDeclaration: nodeBuilder.typeParameterToDeclaration,
|
|
getSymbolsInScope: (locationIn, meaning) => {
|
|
const location2 = getParseTreeNode(locationIn);
|
|
return location2 ? getSymbolsInScope(location2, meaning) : [];
|
|
},
|
|
getSymbolAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getSymbolAtLocation(node, true) : void 0;
|
|
},
|
|
getIndexInfosAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getIndexInfosAtLocation(node) : void 0;
|
|
},
|
|
getShorthandAssignmentValueSymbol: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getShorthandAssignmentValueSymbol(node) : void 0;
|
|
},
|
|
getExportSpecifierLocalTargetSymbol: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isExportSpecifier);
|
|
return node ? getExportSpecifierLocalTargetSymbol(node) : void 0;
|
|
},
|
|
getExportSymbolOfSymbol(symbol) {
|
|
return getMergedSymbol(symbol.exportSymbol || symbol);
|
|
},
|
|
getTypeAtLocation: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getTypeOfNode(node) : errorType;
|
|
},
|
|
getTypeOfAssignmentPattern: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isAssignmentPattern);
|
|
return node && getTypeOfAssignmentPattern(node) || errorType;
|
|
},
|
|
getPropertySymbolOfDestructuringAssignment: (locationIn) => {
|
|
const location2 = getParseTreeNode(locationIn, isIdentifier);
|
|
return location2 ? getPropertySymbolOfDestructuringAssignment(location2) : void 0;
|
|
},
|
|
signatureToString: (signature, enclosingDeclaration, flags, kind) => {
|
|
return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind);
|
|
},
|
|
typeToString: (type, enclosingDeclaration, flags) => {
|
|
return typeToString(type, getParseTreeNode(enclosingDeclaration), flags);
|
|
},
|
|
symbolToString: (symbol, enclosingDeclaration, meaning, flags) => {
|
|
return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags);
|
|
},
|
|
typePredicateToString: (predicate, enclosingDeclaration, flags) => {
|
|
return typePredicateToString(predicate, getParseTreeNode(enclosingDeclaration), flags);
|
|
},
|
|
writeSignature: (signature, enclosingDeclaration, flags, kind, writer) => {
|
|
return signatureToString(signature, getParseTreeNode(enclosingDeclaration), flags, kind, writer);
|
|
},
|
|
writeType: (type, enclosingDeclaration, flags, writer) => {
|
|
return typeToString(type, getParseTreeNode(enclosingDeclaration), flags, writer);
|
|
},
|
|
writeSymbol: (symbol, enclosingDeclaration, meaning, flags, writer) => {
|
|
return symbolToString(symbol, getParseTreeNode(enclosingDeclaration), meaning, flags, writer);
|
|
},
|
|
writeTypePredicate: (predicate, enclosingDeclaration, flags, writer) => {
|
|
return typePredicateToString(predicate, getParseTreeNode(enclosingDeclaration), flags, writer);
|
|
},
|
|
getAugmentedPropertiesOfType,
|
|
getRootSymbols,
|
|
getSymbolOfExpando,
|
|
getContextualType: (nodeIn, contextFlags) => {
|
|
const node = getParseTreeNode(nodeIn, isExpression);
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
if (contextFlags & 4 /* Completions */) {
|
|
return runWithInferenceBlockedFromSourceNode(node, () => getContextualType2(node, contextFlags));
|
|
}
|
|
return getContextualType2(node, contextFlags);
|
|
},
|
|
getContextualTypeForObjectLiteralElement: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isObjectLiteralElementLike);
|
|
return node ? getContextualTypeForObjectLiteralElement(node, void 0) : void 0;
|
|
},
|
|
getContextualTypeForArgumentAtIndex: (nodeIn, argIndex) => {
|
|
const node = getParseTreeNode(nodeIn, isCallLikeExpression);
|
|
return node && getContextualTypeForArgumentAtIndex(node, argIndex);
|
|
},
|
|
getContextualTypeForJsxAttribute: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isJsxAttributeLike);
|
|
return node && getContextualTypeForJsxAttribute(node, void 0);
|
|
},
|
|
isContextSensitive,
|
|
getTypeOfPropertyOfContextualType,
|
|
getFullyQualifiedName,
|
|
getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */),
|
|
getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => getResolvedSignatureWorker(call, candidatesOutArray, void 0, 32 /* IsForStringLiteralArgumentCompletions */, editingArgument),
|
|
getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */),
|
|
getExpandedParameters,
|
|
hasEffectiveRestParameter,
|
|
containsArgumentsReference,
|
|
getConstantValue: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, canHaveConstantValue);
|
|
return node ? getConstantValue2(node) : void 0;
|
|
},
|
|
isValidPropertyAccess: (nodeIn, propertyName) => {
|
|
const node = getParseTreeNode(nodeIn, isPropertyAccessOrQualifiedNameOrImportTypeNode);
|
|
return !!node && isValidPropertyAccess(node, escapeLeadingUnderscores(propertyName));
|
|
},
|
|
isValidPropertyAccessForCompletions: (nodeIn, type, property) => {
|
|
const node = getParseTreeNode(nodeIn, isPropertyAccessExpression);
|
|
return !!node && isValidPropertyAccessForCompletions(node, type, property);
|
|
},
|
|
getSignatureFromDeclaration: (declarationIn) => {
|
|
const declaration = getParseTreeNode(declarationIn, isFunctionLike);
|
|
return declaration ? getSignatureFromDeclaration(declaration) : void 0;
|
|
},
|
|
isImplementationOfOverload: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isFunctionLike);
|
|
return node ? isImplementationOfOverload(node) : void 0;
|
|
},
|
|
getImmediateAliasedSymbol,
|
|
getAliasedSymbol: resolveAlias,
|
|
getEmitResolver,
|
|
getExportsOfModule: getExportsOfModuleAsArray,
|
|
getExportsAndPropertiesOfModule,
|
|
forEachExportAndPropertyOfModule,
|
|
getSymbolWalker: createGetSymbolWalker(
|
|
getRestTypeOfSignature,
|
|
getTypePredicateOfSignature,
|
|
getReturnTypeOfSignature,
|
|
getBaseTypes,
|
|
resolveStructuredTypeMembers,
|
|
getTypeOfSymbol,
|
|
getResolvedSymbol,
|
|
getConstraintOfTypeParameter,
|
|
getFirstIdentifier,
|
|
getTypeArguments
|
|
),
|
|
getAmbientModules,
|
|
getJsxIntrinsicTagNamesAt,
|
|
isOptionalParameter: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isParameter);
|
|
return node ? isOptionalParameter(node) : false;
|
|
},
|
|
tryGetMemberInModuleExports: (name, symbol) => tryGetMemberInModuleExports(escapeLeadingUnderscores(name), symbol),
|
|
tryGetMemberInModuleExportsAndProperties: (name, symbol) => tryGetMemberInModuleExportsAndProperties(escapeLeadingUnderscores(name), symbol),
|
|
tryFindAmbientModule: (moduleName) => tryFindAmbientModule(moduleName, true),
|
|
tryFindAmbientModuleWithoutAugmentations: (moduleName) => {
|
|
return tryFindAmbientModule(moduleName, false);
|
|
},
|
|
getApparentType,
|
|
getUnionType,
|
|
isTypeAssignableTo,
|
|
createAnonymousType,
|
|
createSignature,
|
|
createSymbol,
|
|
createIndexInfo,
|
|
getAnyType: () => anyType,
|
|
getStringType: () => stringType,
|
|
getNumberType: () => numberType,
|
|
createPromiseType,
|
|
createArrayType,
|
|
getElementTypeOfArrayType,
|
|
getBooleanType: () => booleanType,
|
|
getFalseType: (fresh) => fresh ? falseType : regularFalseType,
|
|
getTrueType: (fresh) => fresh ? trueType : regularTrueType,
|
|
getVoidType: () => voidType,
|
|
getUndefinedType: () => undefinedType,
|
|
getNullType: () => nullType,
|
|
getESSymbolType: () => esSymbolType,
|
|
getNeverType: () => neverType,
|
|
getOptionalType: () => optionalType,
|
|
getPromiseType: () => getGlobalPromiseType(false),
|
|
getPromiseLikeType: () => getGlobalPromiseLikeType(false),
|
|
getAsyncIterableType: () => {
|
|
const type = getGlobalAsyncIterableType(false);
|
|
if (type === emptyGenericType)
|
|
return void 0;
|
|
return type;
|
|
},
|
|
isSymbolAccessible,
|
|
isArrayType,
|
|
isTupleType,
|
|
isArrayLikeType,
|
|
isTypeInvalidDueToUnionDiscriminant,
|
|
getExactOptionalProperties,
|
|
getAllPossiblePropertiesOfTypes,
|
|
getSuggestedSymbolForNonexistentProperty,
|
|
getSuggestionForNonexistentProperty,
|
|
getSuggestedSymbolForNonexistentJSXAttribute,
|
|
getSuggestedSymbolForNonexistentSymbol: (location2, name, meaning) => getSuggestedSymbolForNonexistentSymbol(location2, escapeLeadingUnderscores(name), meaning),
|
|
getSuggestionForNonexistentSymbol: (location2, name, meaning) => getSuggestionForNonexistentSymbol(location2, escapeLeadingUnderscores(name), meaning),
|
|
getSuggestedSymbolForNonexistentModule,
|
|
getSuggestionForNonexistentExport,
|
|
getSuggestedSymbolForNonexistentClassMember,
|
|
getBaseConstraintOfType,
|
|
getDefaultFromTypeParameter: (type) => type && type.flags & 262144 /* TypeParameter */ ? getDefaultFromTypeParameter(type) : void 0,
|
|
resolveName(name, location2, meaning, excludeGlobals) {
|
|
return resolveName(location2, escapeLeadingUnderscores(name), meaning, void 0, void 0, false, excludeGlobals);
|
|
},
|
|
getJsxNamespace: (n) => unescapeLeadingUnderscores(getJsxNamespace(n)),
|
|
getJsxFragmentFactory: (n) => {
|
|
const jsxFragmentFactory = getJsxFragmentFactoryEntity(n);
|
|
return jsxFragmentFactory && unescapeLeadingUnderscores(getFirstIdentifier(jsxFragmentFactory).escapedText);
|
|
},
|
|
getAccessibleSymbolChain,
|
|
getTypePredicateOfSignature,
|
|
resolveExternalModuleName: (moduleSpecifierIn) => {
|
|
const moduleSpecifier = getParseTreeNode(moduleSpecifierIn, isExpression);
|
|
return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, true);
|
|
},
|
|
resolveExternalModuleSymbol,
|
|
tryGetThisTypeAt: (nodeIn, includeGlobalThis, container) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node && tryGetThisTypeAt(node, includeGlobalThis, container);
|
|
},
|
|
getTypeArgumentConstraint: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isTypeNode);
|
|
return node && getTypeArgumentConstraint(node);
|
|
},
|
|
getSuggestionDiagnostics: (fileIn, ct) => {
|
|
const file = getParseTreeNode(fileIn, isSourceFile) || Debug.fail("Could not determine parsed source file.");
|
|
if (skipTypeChecking(file, compilerOptions, host)) {
|
|
return emptyArray;
|
|
}
|
|
let diagnostics2;
|
|
try {
|
|
cancellationToken = ct;
|
|
checkSourceFileWithEagerDiagnostics(file);
|
|
Debug.assert(!!(getNodeLinks(file).flags & 1 /* TypeChecked */));
|
|
diagnostics2 = addRange(diagnostics2, suggestionDiagnostics.getDiagnostics(file.fileName));
|
|
checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), (containingNode, kind, diag2) => {
|
|
if (!containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
|
|
(diagnostics2 || (diagnostics2 = [])).push({ ...diag2, category: 2 /* Suggestion */ });
|
|
}
|
|
});
|
|
return diagnostics2 || emptyArray;
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
},
|
|
runWithCancellationToken: (token, callback) => {
|
|
try {
|
|
cancellationToken = token;
|
|
return callback(checker);
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
},
|
|
getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
|
|
isDeclarationVisible,
|
|
isPropertyAccessible,
|
|
getTypeOnlyAliasDeclaration,
|
|
getMemberOverrideModifierStatus,
|
|
isTypeParameterPossiblyReferenced
|
|
};
|
|
function runWithInferenceBlockedFromSourceNode(node, fn) {
|
|
const containingCall = findAncestor(node, isCallLikeExpression);
|
|
const containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
|
|
if (containingCall) {
|
|
let toMarkSkip = node;
|
|
do {
|
|
getNodeLinks(toMarkSkip).skipDirectInference = true;
|
|
toMarkSkip = toMarkSkip.parent;
|
|
} while (toMarkSkip && toMarkSkip !== containingCall);
|
|
getNodeLinks(containingCall).resolvedSignature = void 0;
|
|
}
|
|
const result = fn();
|
|
if (containingCall) {
|
|
let toMarkSkip = node;
|
|
do {
|
|
getNodeLinks(toMarkSkip).skipDirectInference = void 0;
|
|
toMarkSkip = toMarkSkip.parent;
|
|
} while (toMarkSkip && toMarkSkip !== containingCall);
|
|
getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
|
|
}
|
|
return result;
|
|
}
|
|
function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
|
|
const node = getParseTreeNode(nodeIn, isCallLikeExpression);
|
|
apparentArgumentCount = argumentCount;
|
|
const res = !node ? void 0 : editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignature(node, candidatesOutArray, checkMode)) : getResolvedSignature(node, candidatesOutArray, checkMode);
|
|
apparentArgumentCount = void 0;
|
|
return res;
|
|
}
|
|
const tupleTypes = /* @__PURE__ */ new Map();
|
|
const unionTypes = /* @__PURE__ */ new Map();
|
|
const intersectionTypes = /* @__PURE__ */ new Map();
|
|
const stringLiteralTypes = /* @__PURE__ */ new Map();
|
|
const numberLiteralTypes = /* @__PURE__ */ new Map();
|
|
const bigIntLiteralTypes = /* @__PURE__ */ new Map();
|
|
const enumLiteralTypes = /* @__PURE__ */ new Map();
|
|
const indexedAccessTypes = /* @__PURE__ */ new Map();
|
|
const templateLiteralTypes = /* @__PURE__ */ new Map();
|
|
const stringMappingTypes = /* @__PURE__ */ new Map();
|
|
const substitutionTypes = /* @__PURE__ */ new Map();
|
|
const subtypeReductionCache = /* @__PURE__ */ new Map();
|
|
const cachedTypes = /* @__PURE__ */ new Map();
|
|
const evolvingArrayTypes = [];
|
|
const undefinedProperties = /* @__PURE__ */ new Map();
|
|
const markerTypes = /* @__PURE__ */ new Set();
|
|
const unknownSymbol = createSymbol(4 /* Property */, "unknown");
|
|
const resolvingSymbol = createSymbol(0, "__resolving__" /* Resolving */);
|
|
const unresolvedSymbols = /* @__PURE__ */ new Map();
|
|
const errorTypes = /* @__PURE__ */ new Map();
|
|
const anyType = createIntrinsicType(1 /* Any */, "any");
|
|
const autoType = createIntrinsicType(1 /* Any */, "any", 262144 /* NonInferrableType */);
|
|
const wildcardType = createIntrinsicType(1 /* Any */, "any");
|
|
const errorType = createIntrinsicType(1 /* Any */, "error");
|
|
const unresolvedType = createIntrinsicType(1 /* Any */, "unresolved");
|
|
const nonInferrableAnyType = createIntrinsicType(1 /* Any */, "any", 65536 /* ContainsWideningType */);
|
|
const intrinsicMarkerType = createIntrinsicType(1 /* Any */, "intrinsic");
|
|
const unknownType = createIntrinsicType(2 /* Unknown */, "unknown");
|
|
const nonNullUnknownType = createIntrinsicType(2 /* Unknown */, "unknown");
|
|
const undefinedType = createIntrinsicType(32768 /* Undefined */, "undefined");
|
|
const undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* Undefined */, "undefined", 65536 /* ContainsWideningType */);
|
|
const optionalType = createIntrinsicType(32768 /* Undefined */, "undefined");
|
|
const missingType = exactOptionalPropertyTypes ? createIntrinsicType(32768 /* Undefined */, "undefined") : undefinedType;
|
|
const nullType = createIntrinsicType(65536 /* Null */, "null");
|
|
const nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* Null */, "null", 65536 /* ContainsWideningType */);
|
|
const stringType = createIntrinsicType(4 /* String */, "string");
|
|
const numberType = createIntrinsicType(8 /* Number */, "number");
|
|
const bigintType = createIntrinsicType(64 /* BigInt */, "bigint");
|
|
const falseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
|
|
const regularFalseType = createIntrinsicType(512 /* BooleanLiteral */, "false");
|
|
const trueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
|
|
const regularTrueType = createIntrinsicType(512 /* BooleanLiteral */, "true");
|
|
trueType.regularType = regularTrueType;
|
|
trueType.freshType = trueType;
|
|
regularTrueType.regularType = regularTrueType;
|
|
regularTrueType.freshType = trueType;
|
|
falseType.regularType = regularFalseType;
|
|
falseType.freshType = falseType;
|
|
regularFalseType.regularType = regularFalseType;
|
|
regularFalseType.freshType = falseType;
|
|
const booleanType = getUnionType([regularFalseType, regularTrueType]);
|
|
const esSymbolType = createIntrinsicType(4096 /* ESSymbol */, "symbol");
|
|
const voidType = createIntrinsicType(16384 /* Void */, "void");
|
|
const neverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const silentNeverType = createIntrinsicType(131072 /* Never */, "never", 262144 /* NonInferrableType */);
|
|
const implicitNeverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const unreachableNeverType = createIntrinsicType(131072 /* Never */, "never");
|
|
const nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");
|
|
const stringOrNumberType = getUnionType([stringType, numberType]);
|
|
const stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);
|
|
const keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType;
|
|
const numberOrBigIntType = getUnionType([numberType, bigintType]);
|
|
const templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]);
|
|
const numericStringType = getTemplateLiteralType(["", ""], [numberType]);
|
|
const restrictiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? getRestrictiveTypeParameter(t) : t, () => "(restrictive mapper)");
|
|
const permissiveMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? wildcardType : t, () => "(permissive mapper)");
|
|
const uniqueLiteralType = createIntrinsicType(131072 /* Never */, "never");
|
|
const uniqueLiteralMapper = makeFunctionTypeMapper((t) => t.flags & 262144 /* TypeParameter */ ? uniqueLiteralType : t, () => "(unique literal mapper)");
|
|
let outofbandVarianceMarkerHandler;
|
|
const reportUnreliableMapper = makeFunctionTypeMapper((t) => {
|
|
if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
|
|
outofbandVarianceMarkerHandler(true);
|
|
}
|
|
return t;
|
|
}, () => "(unmeasurable reporter)");
|
|
const reportUnmeasurableMapper = makeFunctionTypeMapper((t) => {
|
|
if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) {
|
|
outofbandVarianceMarkerHandler(false);
|
|
}
|
|
return t;
|
|
}, () => "(unreliable reporter)");
|
|
const emptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const emptyJsxObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
emptyJsxObjectType.objectFlags |= 2048 /* JsxAttributes */;
|
|
const emptyTypeLiteralSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
emptyTypeLiteralSymbol.members = createSymbolTable();
|
|
const emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const unknownEmptyObjectType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType;
|
|
const emptyGenericType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
emptyGenericType.instantiations = /* @__PURE__ */ new Map();
|
|
const anyFunctionType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
anyFunctionType.objectFlags |= 262144 /* NonInferrableType */;
|
|
const noConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const circularConstraintType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const resolvingDefaultType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const markerSuperType = createTypeParameter();
|
|
const markerSubType = createTypeParameter();
|
|
markerSubType.constraint = markerSuperType;
|
|
const markerOtherType = createTypeParameter();
|
|
const markerSuperTypeForCheck = createTypeParameter();
|
|
const markerSubTypeForCheck = createTypeParameter();
|
|
markerSubTypeForCheck.constraint = markerSuperTypeForCheck;
|
|
const noTypePredicate = createTypePredicate(1 /* Identifier */, "<<unresolved>>", 0, anyType);
|
|
const anySignature = createSignature(void 0, void 0, void 0, emptyArray, anyType, void 0, 0, 0 /* None */);
|
|
const unknownSignature = createSignature(void 0, void 0, void 0, emptyArray, errorType, void 0, 0, 0 /* None */);
|
|
const resolvingSignature = createSignature(void 0, void 0, void 0, emptyArray, anyType, void 0, 0, 0 /* None */);
|
|
const silentNeverSignature = createSignature(void 0, void 0, void 0, emptyArray, silentNeverType, void 0, 0, 0 /* None */);
|
|
const enumNumberIndexInfo = createIndexInfo(numberType, stringType, true);
|
|
const iterationTypesCache = /* @__PURE__ */ new Map();
|
|
const noIterationTypes = {
|
|
get yieldType() {
|
|
return Debug.fail("Not supported");
|
|
},
|
|
get returnType() {
|
|
return Debug.fail("Not supported");
|
|
},
|
|
get nextType() {
|
|
return Debug.fail("Not supported");
|
|
}
|
|
};
|
|
const anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
|
|
const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
|
|
const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType);
|
|
const asyncIterationTypesResolver = {
|
|
iterableCacheKey: "iterationTypesOfAsyncIterable",
|
|
iteratorCacheKey: "iterationTypesOfAsyncIterator",
|
|
iteratorSymbolName: "asyncIterator",
|
|
getGlobalIteratorType: getGlobalAsyncIteratorType,
|
|
getGlobalIterableType: getGlobalAsyncIterableType,
|
|
getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
|
|
getGlobalGeneratorType: getGlobalAsyncGeneratorType,
|
|
resolveIterationType: getAwaitedType,
|
|
mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
|
|
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
|
|
mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
|
|
};
|
|
const syncIterationTypesResolver = {
|
|
iterableCacheKey: "iterationTypesOfIterable",
|
|
iteratorCacheKey: "iterationTypesOfIterator",
|
|
iteratorSymbolName: "iterator",
|
|
getGlobalIteratorType,
|
|
getGlobalIterableType,
|
|
getGlobalIterableIteratorType,
|
|
getGlobalGeneratorType,
|
|
resolveIterationType: (type, _errorNode) => type,
|
|
mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
|
|
mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
|
|
mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property
|
|
};
|
|
let amalgamatedDuplicates;
|
|
const reverseMappedCache = /* @__PURE__ */ new Map();
|
|
let inInferTypeForHomomorphicMappedType = false;
|
|
let ambientModulesCache;
|
|
let patternAmbientModules;
|
|
let patternAmbientModuleAugmentations;
|
|
let globalObjectType;
|
|
let globalFunctionType;
|
|
let globalCallableFunctionType;
|
|
let globalNewableFunctionType;
|
|
let globalArrayType;
|
|
let globalReadonlyArrayType;
|
|
let globalStringType;
|
|
let globalNumberType;
|
|
let globalBooleanType;
|
|
let globalRegExpType;
|
|
let globalThisType;
|
|
let anyArrayType;
|
|
let autoArrayType;
|
|
let anyReadonlyArrayType;
|
|
let deferredGlobalNonNullableTypeAlias;
|
|
let deferredGlobalESSymbolConstructorSymbol;
|
|
let deferredGlobalESSymbolConstructorTypeSymbol;
|
|
let deferredGlobalESSymbolType;
|
|
let deferredGlobalTypedPropertyDescriptorType;
|
|
let deferredGlobalPromiseType;
|
|
let deferredGlobalPromiseLikeType;
|
|
let deferredGlobalPromiseConstructorSymbol;
|
|
let deferredGlobalPromiseConstructorLikeType;
|
|
let deferredGlobalIterableType;
|
|
let deferredGlobalIteratorType;
|
|
let deferredGlobalIterableIteratorType;
|
|
let deferredGlobalGeneratorType;
|
|
let deferredGlobalIteratorYieldResultType;
|
|
let deferredGlobalIteratorReturnResultType;
|
|
let deferredGlobalAsyncIterableType;
|
|
let deferredGlobalAsyncIteratorType;
|
|
let deferredGlobalAsyncIterableIteratorType;
|
|
let deferredGlobalAsyncGeneratorType;
|
|
let deferredGlobalTemplateStringsArrayType;
|
|
let deferredGlobalImportMetaType;
|
|
let deferredGlobalImportMetaExpressionType;
|
|
let deferredGlobalImportCallOptionsType;
|
|
let deferredGlobalExtractSymbol;
|
|
let deferredGlobalOmitSymbol;
|
|
let deferredGlobalAwaitedSymbol;
|
|
let deferredGlobalBigIntType;
|
|
let deferredGlobalNaNSymbol;
|
|
let deferredGlobalRecordSymbol;
|
|
const allPotentiallyUnusedIdentifiers = /* @__PURE__ */ new Map();
|
|
let flowLoopStart = 0;
|
|
let flowLoopCount = 0;
|
|
let sharedFlowCount = 0;
|
|
let flowAnalysisDisabled = false;
|
|
let flowInvocationCount = 0;
|
|
let lastFlowNode;
|
|
let lastFlowNodeReachable;
|
|
let flowTypeCache;
|
|
const emptyStringType = getStringLiteralType("");
|
|
const zeroType = getNumberLiteralType(0);
|
|
const zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" });
|
|
const resolutionTargets = [];
|
|
const resolutionResults = [];
|
|
const resolutionPropertyNames = [];
|
|
let suggestionCount = 0;
|
|
const maximumSuggestionCount = 10;
|
|
const mergedSymbols = [];
|
|
const symbolLinks = [];
|
|
const nodeLinks = [];
|
|
const flowLoopCaches = [];
|
|
const flowLoopNodes = [];
|
|
const flowLoopKeys = [];
|
|
const flowLoopTypes = [];
|
|
const sharedFlowNodes = [];
|
|
const sharedFlowTypes = [];
|
|
const flowNodeReachable = [];
|
|
const flowNodePostSuper = [];
|
|
const potentialThisCollisions = [];
|
|
const potentialNewTargetCollisions = [];
|
|
const potentialWeakMapSetCollisions = [];
|
|
const potentialReflectCollisions = [];
|
|
const potentialUnusedRenamedBindingElementsInTypes = [];
|
|
const awaitedTypeStack = [];
|
|
const diagnostics = createDiagnosticCollection();
|
|
const suggestionDiagnostics = createDiagnosticCollection();
|
|
const typeofType = createTypeofType();
|
|
let _jsxNamespace;
|
|
let _jsxFactoryEntity;
|
|
const subtypeRelation = /* @__PURE__ */ new Map();
|
|
const strictSubtypeRelation = /* @__PURE__ */ new Map();
|
|
const assignableRelation = /* @__PURE__ */ new Map();
|
|
const comparableRelation = /* @__PURE__ */ new Map();
|
|
const identityRelation = /* @__PURE__ */ new Map();
|
|
const enumRelation = /* @__PURE__ */ new Map();
|
|
const builtinGlobals = createSymbolTable();
|
|
builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
|
|
const suggestedExtensions = [
|
|
[".mts", ".mjs"],
|
|
[".ts", ".js"],
|
|
[".cts", ".cjs"],
|
|
[".mjs", ".mjs"],
|
|
[".js", ".js"],
|
|
[".cjs", ".cjs"],
|
|
[".tsx", compilerOptions.jsx === 1 /* Preserve */ ? ".jsx" : ".js"],
|
|
[".jsx", ".jsx"],
|
|
[".json", ".json"]
|
|
];
|
|
initializeTypeChecker();
|
|
return checker;
|
|
function getCachedType(key) {
|
|
return key ? cachedTypes.get(key) : void 0;
|
|
}
|
|
function setCachedType(key, type) {
|
|
if (key)
|
|
cachedTypes.set(key, type);
|
|
return type;
|
|
}
|
|
function getJsxNamespace(location2) {
|
|
if (location2) {
|
|
const file = getSourceFileOfNode(location2);
|
|
if (file) {
|
|
if (isJsxOpeningFragment(location2)) {
|
|
if (file.localJsxFragmentNamespace) {
|
|
return file.localJsxFragmentNamespace;
|
|
}
|
|
const jsxFragmentPragma = file.pragmas.get("jsxfrag");
|
|
if (jsxFragmentPragma) {
|
|
const chosenPragma = isArray(jsxFragmentPragma) ? jsxFragmentPragma[0] : jsxFragmentPragma;
|
|
file.localJsxFragmentFactory = parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
|
|
visitNode(file.localJsxFragmentFactory, markAsSynthetic);
|
|
if (file.localJsxFragmentFactory) {
|
|
return file.localJsxFragmentNamespace = getFirstIdentifier(file.localJsxFragmentFactory).escapedText;
|
|
}
|
|
}
|
|
const entity = getJsxFragmentFactoryEntity(location2);
|
|
if (entity) {
|
|
file.localJsxFragmentFactory = entity;
|
|
return file.localJsxFragmentNamespace = getFirstIdentifier(entity).escapedText;
|
|
}
|
|
} else {
|
|
const localJsxNamespace = getLocalJsxNamespace(file);
|
|
if (localJsxNamespace) {
|
|
return file.localJsxNamespace = localJsxNamespace;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!_jsxNamespace) {
|
|
_jsxNamespace = "React";
|
|
if (compilerOptions.jsxFactory) {
|
|
_jsxFactoryEntity = parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion);
|
|
visitNode(_jsxFactoryEntity, markAsSynthetic);
|
|
if (_jsxFactoryEntity) {
|
|
_jsxNamespace = getFirstIdentifier(_jsxFactoryEntity).escapedText;
|
|
}
|
|
} else if (compilerOptions.reactNamespace) {
|
|
_jsxNamespace = escapeLeadingUnderscores(compilerOptions.reactNamespace);
|
|
}
|
|
}
|
|
if (!_jsxFactoryEntity) {
|
|
_jsxFactoryEntity = factory.createQualifiedName(factory.createIdentifier(unescapeLeadingUnderscores(_jsxNamespace)), "createElement");
|
|
}
|
|
return _jsxNamespace;
|
|
}
|
|
function getLocalJsxNamespace(file) {
|
|
if (file.localJsxNamespace) {
|
|
return file.localJsxNamespace;
|
|
}
|
|
const jsxPragma = file.pragmas.get("jsx");
|
|
if (jsxPragma) {
|
|
const chosenPragma = isArray(jsxPragma) ? jsxPragma[0] : jsxPragma;
|
|
file.localJsxFactory = parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion);
|
|
visitNode(file.localJsxFactory, markAsSynthetic);
|
|
if (file.localJsxFactory) {
|
|
return file.localJsxNamespace = getFirstIdentifier(file.localJsxFactory).escapedText;
|
|
}
|
|
}
|
|
}
|
|
function markAsSynthetic(node) {
|
|
setTextRangePosEnd(node, -1, -1);
|
|
return visitEachChild(node, markAsSynthetic, nullTransformationContext);
|
|
}
|
|
function getEmitResolver(sourceFile, cancellationToken2) {
|
|
getDiagnostics2(sourceFile, cancellationToken2);
|
|
return emitResolver;
|
|
}
|
|
function lookupOrIssueError(location2, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = location2 ? createDiagnosticForNode(location2, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
|
|
const existing = diagnostics.lookup(diagnostic);
|
|
if (existing) {
|
|
return existing;
|
|
} else {
|
|
diagnostics.add(diagnostic);
|
|
return diagnostic;
|
|
}
|
|
}
|
|
function errorSkippedOn(key, location2, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = error(location2, message, arg0, arg1, arg2, arg3);
|
|
diagnostic.skippedOn = key;
|
|
return diagnostic;
|
|
}
|
|
function createError(location2, message, arg0, arg1, arg2, arg3) {
|
|
return location2 ? createDiagnosticForNode(location2, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function error(location2, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = createError(location2, message, arg0, arg1, arg2, arg3);
|
|
diagnostics.add(diagnostic);
|
|
return diagnostic;
|
|
}
|
|
function addErrorOrSuggestion(isError, diagnostic) {
|
|
if (isError) {
|
|
diagnostics.add(diagnostic);
|
|
} else {
|
|
suggestionDiagnostics.add({ ...diagnostic, category: 2 /* Suggestion */ });
|
|
}
|
|
}
|
|
function errorOrSuggestion(isError, location2, message, arg0, arg1, arg2, arg3) {
|
|
if (location2.pos < 0 || location2.end < 0) {
|
|
if (!isError) {
|
|
return;
|
|
}
|
|
const file = getSourceFileOfNode(location2);
|
|
addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message));
|
|
return;
|
|
}
|
|
addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location2, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(location2, message));
|
|
}
|
|
function errorAndMaybeSuggestAwait(location2, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
|
|
const diagnostic = error(location2, message, arg0, arg1, arg2, arg3);
|
|
if (maybeMissingAwait) {
|
|
const related = createDiagnosticForNode(location2, Diagnostics.Did_you_forget_to_use_await);
|
|
addRelatedInfo(diagnostic, related);
|
|
}
|
|
return diagnostic;
|
|
}
|
|
function addDeprecatedSuggestionWorker(declarations, diagnostic) {
|
|
const deprecatedTag = Array.isArray(declarations) ? forEach(declarations, getJSDocDeprecatedTag) : getJSDocDeprecatedTag(declarations);
|
|
if (deprecatedTag) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(deprecatedTag, Diagnostics.The_declaration_was_marked_as_deprecated_here)
|
|
);
|
|
}
|
|
suggestionDiagnostics.add(diagnostic);
|
|
return diagnostic;
|
|
}
|
|
function isDeprecatedSymbol(symbol) {
|
|
return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* Deprecated */);
|
|
}
|
|
function addDeprecatedSuggestion(location2, declarations, deprecatedEntity) {
|
|
const diagnostic = createDiagnosticForNode(location2, Diagnostics._0_is_deprecated, deprecatedEntity);
|
|
return addDeprecatedSuggestionWorker(declarations, diagnostic);
|
|
}
|
|
function addDeprecatedSuggestionWithSignature(location2, declaration, deprecatedEntity, signatureString) {
|
|
const diagnostic = deprecatedEntity ? createDiagnosticForNode(location2, Diagnostics.The_signature_0_of_1_is_deprecated, signatureString, deprecatedEntity) : createDiagnosticForNode(location2, Diagnostics._0_is_deprecated, signatureString);
|
|
return addDeprecatedSuggestionWorker(declaration, diagnostic);
|
|
}
|
|
function createSymbol(flags, name, checkFlags) {
|
|
symbolCount++;
|
|
const symbol = new Symbol46(flags | 33554432 /* Transient */, name);
|
|
symbol.checkFlags = checkFlags || 0 /* None */;
|
|
return symbol;
|
|
}
|
|
function getExcludedSymbolFlags(flags) {
|
|
let result = 0;
|
|
if (flags & 2 /* BlockScopedVariable */)
|
|
result |= 111551 /* BlockScopedVariableExcludes */;
|
|
if (flags & 1 /* FunctionScopedVariable */)
|
|
result |= 111550 /* FunctionScopedVariableExcludes */;
|
|
if (flags & 4 /* Property */)
|
|
result |= 0 /* PropertyExcludes */;
|
|
if (flags & 8 /* EnumMember */)
|
|
result |= 900095 /* EnumMemberExcludes */;
|
|
if (flags & 16 /* Function */)
|
|
result |= 110991 /* FunctionExcludes */;
|
|
if (flags & 32 /* Class */)
|
|
result |= 899503 /* ClassExcludes */;
|
|
if (flags & 64 /* Interface */)
|
|
result |= 788872 /* InterfaceExcludes */;
|
|
if (flags & 256 /* RegularEnum */)
|
|
result |= 899327 /* RegularEnumExcludes */;
|
|
if (flags & 128 /* ConstEnum */)
|
|
result |= 899967 /* ConstEnumExcludes */;
|
|
if (flags & 512 /* ValueModule */)
|
|
result |= 110735 /* ValueModuleExcludes */;
|
|
if (flags & 8192 /* Method */)
|
|
result |= 103359 /* MethodExcludes */;
|
|
if (flags & 32768 /* GetAccessor */)
|
|
result |= 46015 /* GetAccessorExcludes */;
|
|
if (flags & 65536 /* SetAccessor */)
|
|
result |= 78783 /* SetAccessorExcludes */;
|
|
if (flags & 262144 /* TypeParameter */)
|
|
result |= 526824 /* TypeParameterExcludes */;
|
|
if (flags & 524288 /* TypeAlias */)
|
|
result |= 788968 /* TypeAliasExcludes */;
|
|
if (flags & 2097152 /* Alias */)
|
|
result |= 2097152 /* AliasExcludes */;
|
|
return result;
|
|
}
|
|
function recordMergedSymbol(target, source) {
|
|
if (!source.mergeId) {
|
|
source.mergeId = nextMergeId;
|
|
nextMergeId++;
|
|
}
|
|
mergedSymbols[source.mergeId] = target;
|
|
}
|
|
function cloneSymbol(symbol) {
|
|
const result = createSymbol(symbol.flags, symbol.escapedName);
|
|
result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
|
|
result.parent = symbol.parent;
|
|
if (symbol.valueDeclaration)
|
|
result.valueDeclaration = symbol.valueDeclaration;
|
|
if (symbol.constEnumOnlyModule)
|
|
result.constEnumOnlyModule = true;
|
|
if (symbol.members)
|
|
result.members = new Map(symbol.members);
|
|
if (symbol.exports)
|
|
result.exports = new Map(symbol.exports);
|
|
recordMergedSymbol(result, symbol);
|
|
return result;
|
|
}
|
|
function mergeSymbol(target, source, unidirectional = false) {
|
|
if (!(target.flags & getExcludedSymbolFlags(source.flags)) || (source.flags | target.flags) & 67108864 /* Assignment */) {
|
|
if (source === target) {
|
|
return target;
|
|
}
|
|
if (!(target.flags & 33554432 /* Transient */)) {
|
|
const resolvedTarget = resolveSymbol(target);
|
|
if (resolvedTarget === unknownSymbol) {
|
|
return source;
|
|
}
|
|
target = cloneSymbol(resolvedTarget);
|
|
}
|
|
if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
|
|
target.constEnumOnlyModule = false;
|
|
}
|
|
target.flags |= source.flags;
|
|
if (source.valueDeclaration) {
|
|
setValueDeclaration(target, source.valueDeclaration);
|
|
}
|
|
addRange(target.declarations, source.declarations);
|
|
if (source.members) {
|
|
if (!target.members)
|
|
target.members = createSymbolTable();
|
|
mergeSymbolTable(target.members, source.members, unidirectional);
|
|
}
|
|
if (source.exports) {
|
|
if (!target.exports)
|
|
target.exports = createSymbolTable();
|
|
mergeSymbolTable(target.exports, source.exports, unidirectional);
|
|
}
|
|
if (!unidirectional) {
|
|
recordMergedSymbol(target, source);
|
|
}
|
|
} else if (target.flags & 1024 /* NamespaceModule */) {
|
|
if (target !== globalThisSymbol) {
|
|
error(
|
|
source.declarations && getNameOfDeclaration(source.declarations[0]),
|
|
Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity,
|
|
symbolToString(target)
|
|
);
|
|
}
|
|
} else {
|
|
const isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
|
|
const isEitherBlockScoped = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
|
|
const message = isEitherEnum ? Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations : isEitherBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
const sourceSymbolFile = source.declarations && getSourceFileOfNode(source.declarations[0]);
|
|
const targetSymbolFile = target.declarations && getSourceFileOfNode(target.declarations[0]);
|
|
const isSourcePlainJs = isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
|
|
const isTargetPlainJs = isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
|
|
const symbolName2 = symbolToString(source);
|
|
if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
|
|
const firstFile = comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* LessThan */ ? sourceSymbolFile : targetSymbolFile;
|
|
const secondFile = firstFile === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
|
|
const filesDuplicates = getOrUpdate(amalgamatedDuplicates, `${firstFile.path}|${secondFile.path}`, () => ({ firstFile, secondFile, conflictingSymbols: /* @__PURE__ */ new Map() }));
|
|
const conflictingSymbolInfo = getOrUpdate(filesDuplicates.conflictingSymbols, symbolName2, () => ({ isBlockScoped: isEitherBlockScoped, firstFileLocations: [], secondFileLocations: [] }));
|
|
if (!isSourcePlainJs)
|
|
addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
|
|
if (!isTargetPlainJs)
|
|
addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
|
|
} else {
|
|
if (!isSourcePlainJs)
|
|
addDuplicateDeclarationErrorsForSymbols(source, message, symbolName2, target);
|
|
if (!isTargetPlainJs)
|
|
addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source);
|
|
}
|
|
}
|
|
return target;
|
|
function addDuplicateLocations(locs, symbol) {
|
|
if (symbol.declarations) {
|
|
for (const decl of symbol.declarations) {
|
|
pushIfUnique(locs, decl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source) {
|
|
forEach(target.declarations, (node) => {
|
|
addDuplicateDeclarationError(node, message, symbolName2, source.declarations);
|
|
});
|
|
}
|
|
function addDuplicateDeclarationError(node, message, symbolName2, relatedNodes) {
|
|
const errorNode = (getExpandoInitializer(node, false) ? getNameOfExpando(node) : getNameOfDeclaration(node)) || node;
|
|
const err = lookupOrIssueError(errorNode, message, symbolName2);
|
|
for (const relatedNode of relatedNodes || emptyArray) {
|
|
const adjustedNode = (getExpandoInitializer(relatedNode, false) ? getNameOfExpando(relatedNode) : getNameOfDeclaration(relatedNode)) || relatedNode;
|
|
if (adjustedNode === errorNode)
|
|
continue;
|
|
err.relatedInformation = err.relatedInformation || [];
|
|
const leadingMessage = createDiagnosticForNode(adjustedNode, Diagnostics._0_was_also_declared_here, symbolName2);
|
|
const followOnMessage = createDiagnosticForNode(adjustedNode, Diagnostics.and_here);
|
|
if (length(err.relatedInformation) >= 5 || some(err.relatedInformation, (r) => compareDiagnostics(r, followOnMessage) === 0 /* EqualTo */ || compareDiagnostics(r, leadingMessage) === 0 /* EqualTo */))
|
|
continue;
|
|
addRelatedInfo(err, !length(err.relatedInformation) ? leadingMessage : followOnMessage);
|
|
}
|
|
}
|
|
function combineSymbolTables(first2, second) {
|
|
if (!(first2 == null ? void 0 : first2.size))
|
|
return second;
|
|
if (!(second == null ? void 0 : second.size))
|
|
return first2;
|
|
const combined = createSymbolTable();
|
|
mergeSymbolTable(combined, first2);
|
|
mergeSymbolTable(combined, second);
|
|
return combined;
|
|
}
|
|
function mergeSymbolTable(target, source, unidirectional = false) {
|
|
source.forEach((sourceSymbol, id) => {
|
|
const targetSymbol = target.get(id);
|
|
target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : getMergedSymbol(sourceSymbol));
|
|
});
|
|
}
|
|
function mergeModuleAugmentation(moduleName) {
|
|
var _a2, _b, _c;
|
|
const moduleAugmentation = moduleName.parent;
|
|
if (((_a2 = moduleAugmentation.symbol.declarations) == null ? void 0 : _a2[0]) !== moduleAugmentation) {
|
|
Debug.assert(moduleAugmentation.symbol.declarations.length > 1);
|
|
return;
|
|
}
|
|
if (isGlobalScopeAugmentation(moduleAugmentation)) {
|
|
mergeSymbolTable(globals, moduleAugmentation.symbol.exports);
|
|
} else {
|
|
const moduleNotFoundError = !(moduleName.parent.parent.flags & 16777216 /* Ambient */) ? Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found : void 0;
|
|
let mainModule = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, true);
|
|
if (!mainModule) {
|
|
return;
|
|
}
|
|
mainModule = resolveExternalModuleSymbol(mainModule);
|
|
if (mainModule.flags & 1920 /* Namespace */) {
|
|
if (some(patternAmbientModules, (module2) => mainModule === module2.symbol)) {
|
|
const merged = mergeSymbol(moduleAugmentation.symbol, mainModule, true);
|
|
if (!patternAmbientModuleAugmentations) {
|
|
patternAmbientModuleAugmentations = /* @__PURE__ */ new Map();
|
|
}
|
|
patternAmbientModuleAugmentations.set(moduleName.text, merged);
|
|
} else {
|
|
if (((_b = mainModule.exports) == null ? void 0 : _b.get("__export" /* ExportStar */)) && ((_c = moduleAugmentation.symbol.exports) == null ? void 0 : _c.size)) {
|
|
const resolvedExports = getResolvedMembersOrExportsOfSymbol(mainModule, "resolvedExports" /* resolvedExports */);
|
|
for (const [key, value] of arrayFrom(moduleAugmentation.symbol.exports.entries())) {
|
|
if (resolvedExports.has(key) && !mainModule.exports.has(key)) {
|
|
mergeSymbol(resolvedExports.get(key), value);
|
|
}
|
|
}
|
|
}
|
|
mergeSymbol(mainModule, moduleAugmentation.symbol);
|
|
}
|
|
} else {
|
|
error(moduleName, Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text);
|
|
}
|
|
}
|
|
}
|
|
function addToSymbolTable(target, source, message) {
|
|
source.forEach((sourceSymbol, id) => {
|
|
const targetSymbol = target.get(id);
|
|
if (targetSymbol) {
|
|
forEach(targetSymbol.declarations, addDeclarationDiagnostic(unescapeLeadingUnderscores(id), message));
|
|
} else {
|
|
target.set(id, sourceSymbol);
|
|
}
|
|
});
|
|
function addDeclarationDiagnostic(id, message2) {
|
|
return (declaration) => diagnostics.add(createDiagnosticForNode(declaration, message2, id));
|
|
}
|
|
}
|
|
function getSymbolLinks(symbol) {
|
|
if (symbol.flags & 33554432 /* Transient */)
|
|
return symbol;
|
|
const id = getSymbolId(symbol);
|
|
return symbolLinks[id] || (symbolLinks[id] = new SymbolLinks());
|
|
}
|
|
function getNodeLinks(node) {
|
|
const nodeId = getNodeId(node);
|
|
return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
|
|
}
|
|
function isGlobalSourceFile(node) {
|
|
return node.kind === 308 /* SourceFile */ && !isExternalOrCommonJsModule(node);
|
|
}
|
|
function getSymbol2(symbols, name, meaning) {
|
|
if (meaning) {
|
|
const symbol = getMergedSymbol(symbols.get(name));
|
|
if (symbol) {
|
|
Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
|
|
if (symbol.flags & meaning) {
|
|
return symbol;
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
const targetFlags = getAllSymbolFlags(symbol);
|
|
if (targetFlags & meaning) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
|
|
const constructorDeclaration = parameter.parent;
|
|
const classDeclaration = parameter.parent.parent;
|
|
const parameterSymbol = getSymbol2(constructorDeclaration.locals, parameterName, 111551 /* Value */);
|
|
const propertySymbol = getSymbol2(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551 /* Value */);
|
|
if (parameterSymbol && propertySymbol) {
|
|
return [parameterSymbol, propertySymbol];
|
|
}
|
|
return Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
|
|
}
|
|
function isBlockScopedNameDeclaredBeforeUse(declaration, usage) {
|
|
const declarationFile = getSourceFileOfNode(declaration);
|
|
const useFile = getSourceFileOfNode(usage);
|
|
const declContainer = getEnclosingBlockScopeContainer(declaration);
|
|
if (declarationFile !== useFile) {
|
|
if (moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator) || !outFile(compilerOptions) || isInTypeQuery(usage) || declaration.flags & 16777216 /* Ambient */) {
|
|
return true;
|
|
}
|
|
if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
|
|
return true;
|
|
}
|
|
const sourceFiles = host.getSourceFiles();
|
|
return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
|
|
}
|
|
if (declaration.pos <= usage.pos && !(isPropertyDeclaration(declaration) && isThisProperty(usage.parent) && !declaration.initializer && !declaration.exclamationToken)) {
|
|
if (declaration.kind === 205 /* BindingElement */) {
|
|
const errorBindingElement = getAncestor(usage, 205 /* BindingElement */);
|
|
if (errorBindingElement) {
|
|
return findAncestor(errorBindingElement, isBindingElement) !== findAncestor(declaration, isBindingElement) || declaration.pos < errorBindingElement.pos;
|
|
}
|
|
return isBlockScopedNameDeclaredBeforeUse(getAncestor(declaration, 257 /* VariableDeclaration */), usage);
|
|
} else if (declaration.kind === 257 /* VariableDeclaration */) {
|
|
return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
|
|
} else if (isClassDeclaration(declaration)) {
|
|
return !findAncestor(usage, (n) => isComputedPropertyName(n) && n.parent.parent === declaration);
|
|
} else if (isPropertyDeclaration(declaration)) {
|
|
return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
|
|
} else if (isParameterPropertyDeclaration(declaration, declaration.parent)) {
|
|
return !(getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) === getContainingClass(usage) && isUsedInFunctionOrInstanceProperty(usage, declaration));
|
|
}
|
|
return true;
|
|
}
|
|
if (usage.parent.kind === 278 /* ExportSpecifier */ || usage.parent.kind === 274 /* ExportAssignment */ && usage.parent.isExportEquals) {
|
|
return true;
|
|
}
|
|
if (usage.kind === 274 /* ExportAssignment */ && usage.isExportEquals) {
|
|
return true;
|
|
}
|
|
if (!!(usage.flags & 8388608 /* JSDoc */) || isInTypeQuery(usage) || usageInTypeDeclaration()) {
|
|
return true;
|
|
}
|
|
if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
|
|
if (getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
|
|
return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
function usageInTypeDeclaration() {
|
|
return !!findAncestor(usage, (node) => isInterfaceDeclaration(node) || isTypeAliasDeclaration(node));
|
|
}
|
|
function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration2, usage2) {
|
|
switch (declaration2.parent.parent.kind) {
|
|
case 240 /* VariableStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
if (isSameScopeDescendentOf(usage2, declaration2, declContainer)) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
const grandparent = declaration2.parent.parent;
|
|
return isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage2, grandparent.expression, declContainer);
|
|
}
|
|
function isUsedInFunctionOrInstanceProperty(usage2, declaration2) {
|
|
return !!findAncestor(usage2, (current) => {
|
|
if (current === declContainer) {
|
|
return "quit";
|
|
}
|
|
if (isFunctionLike(current)) {
|
|
return true;
|
|
}
|
|
if (isClassStaticBlockDeclaration(current)) {
|
|
return declaration2.pos < usage2.pos;
|
|
}
|
|
const propertyDeclaration = tryCast(current.parent, isPropertyDeclaration);
|
|
if (propertyDeclaration) {
|
|
const initializerOfProperty = propertyDeclaration.initializer === current;
|
|
if (initializerOfProperty) {
|
|
if (isStatic(current.parent)) {
|
|
if (declaration2.kind === 171 /* MethodDeclaration */) {
|
|
return true;
|
|
}
|
|
if (isPropertyDeclaration(declaration2) && getContainingClass(usage2) === getContainingClass(declaration2)) {
|
|
const propName = declaration2.name;
|
|
if (isIdentifier(propName) || isPrivateIdentifier(propName)) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(declaration2));
|
|
const staticBlocks = filter(declaration2.parent.members, isClassStaticBlockDeclaration);
|
|
if (isPropertyInitializedInStaticBlocks(propName, type, staticBlocks, declaration2.parent.pos, current.pos)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const isDeclarationInstanceProperty = declaration2.kind === 169 /* PropertyDeclaration */ && !isStatic(declaration2);
|
|
if (!isDeclarationInstanceProperty || getContainingClass(usage2) !== getContainingClass(declaration2)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function isPropertyImmediatelyReferencedWithinDeclaration(declaration2, usage2, stopAtAnyPropertyDeclaration) {
|
|
if (usage2.end > declaration2.end) {
|
|
return false;
|
|
}
|
|
const ancestorChangingReferenceScope = findAncestor(usage2, (node) => {
|
|
if (node === declaration2) {
|
|
return "quit";
|
|
}
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
case 169 /* PropertyDeclaration */:
|
|
return stopAtAnyPropertyDeclaration && (isPropertyDeclaration(declaration2) && node.parent === declaration2.parent || isParameterPropertyDeclaration(declaration2, declaration2.parent) && node.parent === declaration2.parent.parent) ? "quit" : true;
|
|
case 238 /* Block */:
|
|
switch (node.parent.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
});
|
|
return ancestorChangingReferenceScope === void 0;
|
|
}
|
|
}
|
|
function useOuterVariableScopeInParameter(result, location2, lastLocation) {
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
const functionLocation = location2;
|
|
if (isParameter(lastLocation) && functionLocation.body && result.valueDeclaration && result.valueDeclaration.pos >= functionLocation.body.pos && result.valueDeclaration.end <= functionLocation.body.end) {
|
|
if (target >= 2 /* ES2015 */) {
|
|
const links = getNodeLinks(functionLocation);
|
|
if (links.declarationRequiresScopeChange === void 0) {
|
|
links.declarationRequiresScopeChange = forEach(functionLocation.parameters, requiresScopeChange) || false;
|
|
}
|
|
return !links.declarationRequiresScopeChange;
|
|
}
|
|
}
|
|
return false;
|
|
function requiresScopeChange(node) {
|
|
return requiresScopeChangeWorker(node.name) || !!node.initializer && requiresScopeChangeWorker(node.initializer);
|
|
}
|
|
function requiresScopeChangeWorker(node) {
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 173 /* Constructor */:
|
|
return false;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 299 /* PropertyAssignment */:
|
|
return requiresScopeChangeWorker(node.name);
|
|
case 169 /* PropertyDeclaration */:
|
|
if (hasStaticModifier(node)) {
|
|
return target < 99 /* ESNext */ || !useDefineForClassFields;
|
|
}
|
|
return requiresScopeChangeWorker(node.name);
|
|
default:
|
|
if (isNullishCoalesce(node) || isOptionalChain(node)) {
|
|
return target < 7 /* ES2020 */;
|
|
}
|
|
if (isBindingElement(node) && node.dotDotDotToken && isObjectBindingPattern(node.parent)) {
|
|
return target < 4 /* ES2017 */;
|
|
}
|
|
if (isTypeNode(node))
|
|
return false;
|
|
return forEachChild(node, requiresScopeChangeWorker) || false;
|
|
}
|
|
}
|
|
}
|
|
function isConstAssertion(location2) {
|
|
return isAssertionExpression(location2) && isConstTypeReference(location2.type) || isJSDocTypeTag(location2) && isConstTypeReference(location2.typeExpression);
|
|
}
|
|
function resolveName(location2, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals = false, getSpellingSuggestions = true) {
|
|
return resolveNameHelper(location2, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, getSymbol2);
|
|
}
|
|
function resolveNameHelper(location2, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, lookup) {
|
|
var _a2, _b, _c;
|
|
const originalLocation = location2;
|
|
let result;
|
|
let lastLocation;
|
|
let lastSelfReferenceLocation;
|
|
let propertyWithInvalidInitializer;
|
|
let associatedDeclarationForContainingInitializerOrBindingName;
|
|
let withinDeferredContext = false;
|
|
const errorLocation = location2;
|
|
let grandparent;
|
|
let isInExternalModule = false;
|
|
loop:
|
|
while (location2) {
|
|
if (name === "const" && isConstAssertion(location2)) {
|
|
return void 0;
|
|
}
|
|
if (location2.locals && !isGlobalSourceFile(location2)) {
|
|
if (result = lookup(location2.locals, name, meaning)) {
|
|
let useResult = true;
|
|
if (isFunctionLike(location2) && lastLocation && lastLocation !== location2.body) {
|
|
if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 323 /* JSDoc */) {
|
|
useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location2.type || lastLocation.kind === 166 /* Parameter */ || lastLocation.kind === 343 /* JSDocParameterTag */ || lastLocation.kind === 344 /* JSDocReturnTag */ || lastLocation.kind === 165 /* TypeParameter */ : false;
|
|
}
|
|
if (meaning & result.flags & 3 /* Variable */) {
|
|
if (useOuterVariableScopeInParameter(result, location2, lastLocation)) {
|
|
useResult = false;
|
|
} else if (result.flags & 1 /* FunctionScopedVariable */) {
|
|
useResult = lastLocation.kind === 166 /* Parameter */ || lastLocation === location2.type && !!findAncestor(result.valueDeclaration, isParameter);
|
|
}
|
|
}
|
|
} else if (location2.kind === 191 /* ConditionalType */) {
|
|
useResult = lastLocation === location2.trueType;
|
|
}
|
|
if (useResult) {
|
|
break loop;
|
|
} else {
|
|
result = void 0;
|
|
}
|
|
}
|
|
}
|
|
withinDeferredContext = withinDeferredContext || getIsDeferredContext(location2, lastLocation);
|
|
switch (location2.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalOrCommonJsModule(location2))
|
|
break;
|
|
isInExternalModule = true;
|
|
case 264 /* ModuleDeclaration */:
|
|
const moduleExports = ((_a2 = getSymbolOfNode(location2)) == null ? void 0 : _a2.exports) || emptySymbols;
|
|
if (location2.kind === 308 /* SourceFile */ || isModuleDeclaration(location2) && location2.flags & 16777216 /* Ambient */ && !isGlobalScopeAugmentation(location2)) {
|
|
if (result = moduleExports.get("default" /* Default */)) {
|
|
const localSymbol = getLocalSymbolForExportDefault(result);
|
|
if (localSymbol && result.flags & meaning && localSymbol.escapedName === name) {
|
|
break loop;
|
|
}
|
|
result = void 0;
|
|
}
|
|
const moduleExport = moduleExports.get(name);
|
|
if (moduleExport && moduleExport.flags === 2097152 /* Alias */ && (getDeclarationOfKind(moduleExport, 278 /* ExportSpecifier */) || getDeclarationOfKind(moduleExport, 277 /* NamespaceExport */))) {
|
|
break;
|
|
}
|
|
}
|
|
if (name !== "default" /* Default */ && (result = lookup(moduleExports, name, meaning & 2623475 /* ModuleMember */))) {
|
|
if (isSourceFile(location2) && location2.commonJsModuleIndicator && !((_b = result.declarations) == null ? void 0 : _b.some(isJSDocTypeAlias))) {
|
|
result = void 0;
|
|
} else {
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
if (result = lookup(((_c = getSymbolOfNode(location2)) == null ? void 0 : _c.exports) || emptySymbols, name, meaning & 8 /* EnumMember */)) {
|
|
break loop;
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (!isStatic(location2)) {
|
|
const ctor = findConstructorDeclaration(location2.parent);
|
|
if (ctor && ctor.locals) {
|
|
if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
|
|
Debug.assertNode(location2, isPropertyDeclaration);
|
|
propertyWithInvalidInitializer = location2;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
if (result = lookup(getSymbolOfNode(location2).members || emptySymbols, name, meaning & 788968 /* Type */)) {
|
|
if (!isTypeParameterSymbolDeclaredInContainer(result, location2)) {
|
|
result = void 0;
|
|
break;
|
|
}
|
|
if (lastLocation && isStatic(lastLocation)) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.Static_members_cannot_reference_class_type_parameters);
|
|
}
|
|
return void 0;
|
|
}
|
|
break loop;
|
|
}
|
|
if (location2.kind === 228 /* ClassExpression */ && meaning & 32 /* Class */) {
|
|
const className = location2.name;
|
|
if (className && name === className.escapedText) {
|
|
result = location2.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
if (lastLocation === location2.expression && location2.parent.token === 94 /* ExtendsKeyword */) {
|
|
const container = location2.parent.parent;
|
|
if (isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968 /* Type */))) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
break;
|
|
case 164 /* ComputedPropertyName */:
|
|
grandparent = location2.parent.parent;
|
|
if (isClassLike(grandparent) || grandparent.kind === 261 /* InterfaceDeclaration */) {
|
|
if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968 /* Type */)) {
|
|
if (nameNotFoundMessage) {
|
|
error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
|
|
break;
|
|
}
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
if (meaning & 3 /* Variable */ && name === "arguments") {
|
|
result = argumentsSymbol;
|
|
break loop;
|
|
}
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
if (meaning & 3 /* Variable */ && name === "arguments") {
|
|
result = argumentsSymbol;
|
|
break loop;
|
|
}
|
|
if (meaning & 16 /* Function */) {
|
|
const functionName = location2.name;
|
|
if (functionName && name === functionName.escapedText) {
|
|
result = location2.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
case 167 /* Decorator */:
|
|
if (location2.parent && location2.parent.kind === 166 /* Parameter */) {
|
|
location2 = location2.parent;
|
|
}
|
|
if (location2.parent && (isClassElement(location2.parent) || location2.parent.kind === 260 /* ClassDeclaration */)) {
|
|
location2 = location2.parent;
|
|
}
|
|
break;
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
const root = getJSDocRoot(location2);
|
|
if (root) {
|
|
location2 = root.parent;
|
|
}
|
|
break;
|
|
case 166 /* Parameter */:
|
|
if (lastLocation && (lastLocation === location2.initializer || lastLocation === location2.name && isBindingPattern(lastLocation))) {
|
|
if (!associatedDeclarationForContainingInitializerOrBindingName) {
|
|
associatedDeclarationForContainingInitializerOrBindingName = location2;
|
|
}
|
|
}
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
if (lastLocation && (lastLocation === location2.initializer || lastLocation === location2.name && isBindingPattern(lastLocation))) {
|
|
if (isParameterDeclaration(location2) && !associatedDeclarationForContainingInitializerOrBindingName) {
|
|
associatedDeclarationForContainingInitializerOrBindingName = location2;
|
|
}
|
|
}
|
|
break;
|
|
case 192 /* InferType */:
|
|
if (meaning & 262144 /* TypeParameter */) {
|
|
const parameterName = location2.typeParameter.name;
|
|
if (parameterName && name === parameterName.escapedText) {
|
|
result = location2.typeParameter.symbol;
|
|
break loop;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
if (isSelfReferenceLocation(location2)) {
|
|
lastSelfReferenceLocation = location2;
|
|
}
|
|
lastLocation = location2;
|
|
location2 = isJSDocTemplateTag(location2) ? getEffectiveContainerForJSDocTemplateTag(location2) || location2.parent : isJSDocParameterTag(location2) || isJSDocReturnTag(location2) ? getHostSignatureFromJSDoc(location2) || location2.parent : location2.parent;
|
|
}
|
|
if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) {
|
|
result.isReferenced |= meaning;
|
|
}
|
|
if (!result) {
|
|
if (lastLocation) {
|
|
Debug.assert(lastLocation.kind === 308 /* SourceFile */);
|
|
if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) {
|
|
return lastLocation.symbol;
|
|
}
|
|
}
|
|
if (!excludeGlobals) {
|
|
result = lookup(globals, name, meaning);
|
|
}
|
|
}
|
|
if (!result) {
|
|
if (originalLocation && isInJSFile(originalLocation) && originalLocation.parent) {
|
|
if (isRequireCall(originalLocation.parent, false)) {
|
|
return requireSymbol;
|
|
}
|
|
}
|
|
}
|
|
function checkAndReportErrorForInvalidInitializer() {
|
|
if (propertyWithInvalidInitializer && !(useDefineForClassFields && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */)) {
|
|
error(
|
|
errorLocation,
|
|
errorLocation && propertyWithInvalidInitializer.type && textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos) ? Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor : Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor,
|
|
declarationNameToString(propertyWithInvalidInitializer.name),
|
|
diagnosticName(nameArg)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (!result) {
|
|
if (nameNotFoundMessage) {
|
|
addLazyDiagnostic(() => {
|
|
if (!errorLocation || !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && !checkAndReportErrorForInvalidInitializer() && !checkAndReportErrorForExtendingInterface(errorLocation) && !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
|
|
let suggestion;
|
|
let suggestedLib;
|
|
if (nameArg) {
|
|
suggestedLib = getSuggestedLibForNonExistentName(nameArg);
|
|
if (suggestedLib) {
|
|
error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
|
|
}
|
|
}
|
|
if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
|
|
suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
|
|
const isGlobalScopeAugmentationDeclaration = (suggestion == null ? void 0 : suggestion.valueDeclaration) && isAmbientModule(suggestion.valueDeclaration) && isGlobalScopeAugmentation(suggestion.valueDeclaration);
|
|
if (isGlobalScopeAugmentationDeclaration) {
|
|
suggestion = void 0;
|
|
}
|
|
if (suggestion) {
|
|
const suggestionName = symbolToString(suggestion);
|
|
const isUncheckedJS = isUncheckedJSSuggestion(originalLocation, suggestion, false);
|
|
const message = meaning === 1920 /* Namespace */ || nameArg && typeof nameArg !== "string" && nodeIsSynthesized(nameArg) ? Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 : isUncheckedJS ? Diagnostics.Could_not_find_name_0_Did_you_mean_1 : Diagnostics.Cannot_find_name_0_Did_you_mean_1;
|
|
const diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName);
|
|
addErrorOrSuggestion(!isUncheckedJS, diagnostic);
|
|
if (suggestion.valueDeclaration) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (!suggestion && !suggestedLib && nameArg) {
|
|
error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
|
|
}
|
|
suggestionCount++;
|
|
}
|
|
});
|
|
}
|
|
return void 0;
|
|
} else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) {
|
|
return void 0;
|
|
}
|
|
if (nameNotFoundMessage) {
|
|
addLazyDiagnostic(() => {
|
|
if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
|
|
const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
|
|
if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
|
|
checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);
|
|
}
|
|
}
|
|
if (result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */ && !(originalLocation.flags & 8388608 /* JSDoc */)) {
|
|
const merged = getMergedSymbol(result);
|
|
if (length(merged.declarations) && every(merged.declarations, (d) => isNamespaceExportDeclaration(d) || isSourceFile(d) && !!d.symbol.globalExports)) {
|
|
errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, unescapeLeadingUnderscores(name));
|
|
}
|
|
}
|
|
if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* Value */) === 111551 /* Value */) {
|
|
const candidate = getMergedSymbol(getLateBoundSymbol(result));
|
|
const root = getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName);
|
|
if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) {
|
|
error(errorLocation, Diagnostics.Parameter_0_cannot_reference_itself, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name));
|
|
} else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) {
|
|
error(errorLocation, Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), declarationNameToString(errorLocation));
|
|
}
|
|
}
|
|
if (result && errorLocation && meaning & 111551 /* Value */ && result.flags & 2097152 /* Alias */ && !(result.flags & 111551 /* Value */) && !isValidTypeOnlyAliasUseSite(errorLocation)) {
|
|
const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* Value */);
|
|
if (typeOnlyDeclaration) {
|
|
const message = typeOnlyDeclaration.kind === 278 /* ExportSpecifier */ ? Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type : Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type;
|
|
const unescapedName = unescapeLeadingUnderscores(name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(errorLocation, message, unescapedName),
|
|
typeOnlyDeclaration,
|
|
unescapedName
|
|
);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, unescapedName) {
|
|
if (!typeOnlyDeclaration)
|
|
return diagnostic;
|
|
return addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(
|
|
typeOnlyDeclaration,
|
|
typeOnlyDeclaration.kind === 278 /* ExportSpecifier */ ? Diagnostics._0_was_exported_here : Diagnostics._0_was_imported_here,
|
|
unescapedName
|
|
)
|
|
);
|
|
}
|
|
function getIsDeferredContext(location2, lastLocation) {
|
|
if (location2.kind !== 216 /* ArrowFunction */ && location2.kind !== 215 /* FunctionExpression */) {
|
|
return isTypeQueryNode(location2) || (isFunctionLikeDeclaration(location2) || location2.kind === 169 /* PropertyDeclaration */ && !isStatic(location2)) && (!lastLocation || lastLocation !== location2.name);
|
|
}
|
|
if (lastLocation && lastLocation === location2.name) {
|
|
return false;
|
|
}
|
|
if (location2.asteriskToken || hasSyntacticModifier(location2, 512 /* Async */)) {
|
|
return true;
|
|
}
|
|
return !getImmediatelyInvokedFunctionExpression(location2);
|
|
}
|
|
function isSelfReferenceLocation(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function diagnosticName(nameArg) {
|
|
return isString(nameArg) ? unescapeLeadingUnderscores(nameArg) : declarationNameToString(nameArg);
|
|
}
|
|
function isTypeParameterSymbolDeclaredInContainer(symbol, container) {
|
|
if (symbol.declarations) {
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.kind === 165 /* TypeParameter */) {
|
|
const parent2 = isJSDocTemplateTag(decl.parent) ? getJSDocHost(decl.parent) : decl.parent;
|
|
if (parent2 === container) {
|
|
return !(isJSDocTemplateTag(decl.parent) && find(decl.parent.parent.tags, isJSDocTypeAlias));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) {
|
|
if (!isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) {
|
|
return false;
|
|
}
|
|
const container = getThisContainer(errorLocation, false);
|
|
let location2 = container;
|
|
while (location2) {
|
|
if (isClassLike(location2.parent)) {
|
|
const classSymbol = getSymbolOfNode(location2.parent);
|
|
if (!classSymbol) {
|
|
break;
|
|
}
|
|
const constructorType = getTypeOfSymbol(classSymbol);
|
|
if (getPropertyOfType(constructorType, name)) {
|
|
error(errorLocation, Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol));
|
|
return true;
|
|
}
|
|
if (location2 === container && !isStatic(location2)) {
|
|
const instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType;
|
|
if (getPropertyOfType(instanceType, name)) {
|
|
error(errorLocation, Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, diagnosticName(nameArg));
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
location2 = location2.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForExtendingInterface(errorLocation) {
|
|
const expression = getEntityNameForExtendingInterface(errorLocation);
|
|
if (expression && resolveEntityName(expression, 64 /* Interface */, true)) {
|
|
error(errorLocation, Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, getTextOfNode(expression));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getEntityNameForExtendingInterface(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.parent ? getEntityNameForExtendingInterface(node.parent) : void 0;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
if (isEntityNameExpression(node.expression)) {
|
|
return node.expression;
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) {
|
|
const namespaceMeaning = 1920 /* Namespace */ | (isInJSFile(errorLocation) ? 111551 /* Value */ : 0);
|
|
if (meaning === namespaceMeaning) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~namespaceMeaning, void 0, void 0, false));
|
|
const parent2 = errorLocation.parent;
|
|
if (symbol) {
|
|
if (isQualifiedName(parent2)) {
|
|
Debug.assert(parent2.left === errorLocation, "Should only be resolving left side of qualified name as a namespace");
|
|
const propName = parent2.right.escapedText;
|
|
const propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName);
|
|
if (propType) {
|
|
error(
|
|
parent2,
|
|
Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1,
|
|
unescapeLeadingUnderscores(name),
|
|
unescapeLeadingUnderscores(propName)
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, unescapeLeadingUnderscores(name));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) {
|
|
if (meaning & (788968 /* Type */ & ~1920 /* Namespace */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 /* Type */ & 111551 /* Value */, void 0, void 0, false));
|
|
if (symbol && !(symbol.flags & 1920 /* Namespace */)) {
|
|
error(errorLocation, Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, unescapeLeadingUnderscores(name));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isPrimitiveTypeName(name) {
|
|
return name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never" || name === "unknown";
|
|
}
|
|
function checkAndReportErrorForExportingPrimitiveType(errorLocation, name) {
|
|
if (isPrimitiveTypeName(name) && errorLocation.parent.kind === 278 /* ExportSpecifier */) {
|
|
error(errorLocation, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, name);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) {
|
|
if (meaning & 111551 /* Value */) {
|
|
if (isPrimitiveTypeName(name)) {
|
|
if (isExtendedByInterface(errorLocation)) {
|
|
error(errorLocation, Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, unescapeLeadingUnderscores(name));
|
|
} else {
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, unescapeLeadingUnderscores(name));
|
|
}
|
|
return true;
|
|
}
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* Type */ & ~111551 /* Value */, void 0, void 0, false));
|
|
const allFlags = symbol && getAllSymbolFlags(symbol);
|
|
if (symbol && allFlags !== void 0 && !(allFlags & 111551 /* Value */)) {
|
|
const rawName = unescapeLeadingUnderscores(name);
|
|
if (isES2015OrLaterConstructorName(name)) {
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName);
|
|
} else if (maybeMappedType(errorLocation, symbol)) {
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0, rawName, rawName === "K" ? "P" : "K");
|
|
} else {
|
|
error(errorLocation, Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, rawName);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isExtendedByInterface(node) {
|
|
const grandparent = node.parent.parent;
|
|
const parentOfGrandparent = grandparent.parent;
|
|
if (grandparent && parentOfGrandparent) {
|
|
const isExtending = isHeritageClause(grandparent) && grandparent.token === 94 /* ExtendsKeyword */;
|
|
const isInterface = isInterfaceDeclaration(parentOfGrandparent);
|
|
return isExtending && isInterface;
|
|
}
|
|
return false;
|
|
}
|
|
function maybeMappedType(node, symbol) {
|
|
const container = findAncestor(node.parent, (n) => isComputedPropertyName(n) || isPropertySignature(n) ? false : isTypeLiteralNode(n) || "quit");
|
|
if (container && container.members.length === 1) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
return !!(type.flags & 1048576 /* Union */) && allTypesAssignableToKind(type, 384 /* StringOrNumberLiteral */, true);
|
|
}
|
|
return false;
|
|
}
|
|
function isES2015OrLaterConstructorName(n) {
|
|
switch (n) {
|
|
case "Promise":
|
|
case "Symbol":
|
|
case "Map":
|
|
case "WeakMap":
|
|
case "Set":
|
|
case "WeakSet":
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) {
|
|
if (meaning & (111551 /* Value */ & ~788968 /* Type */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* NamespaceModule */, void 0, void 0, false));
|
|
if (symbol) {
|
|
error(
|
|
errorLocation,
|
|
Diagnostics.Cannot_use_namespace_0_as_a_value,
|
|
unescapeLeadingUnderscores(name)
|
|
);
|
|
return true;
|
|
}
|
|
} else if (meaning & (788968 /* Type */ & ~111551 /* Value */)) {
|
|
const symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* Module */, void 0, void 0, false));
|
|
if (symbol) {
|
|
error(errorLocation, Diagnostics.Cannot_use_namespace_0_as_a_type, unescapeLeadingUnderscores(name));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkResolvedBlockScopedVariable(result, errorLocation) {
|
|
var _a2;
|
|
Debug.assert(!!(result.flags & 2 /* BlockScopedVariable */ || result.flags & 32 /* Class */ || result.flags & 384 /* Enum */));
|
|
if (result.flags & (16 /* Function */ | 1 /* FunctionScopedVariable */ | 67108864 /* Assignment */) && result.flags & 32 /* Class */) {
|
|
return;
|
|
}
|
|
const declaration = (_a2 = result.declarations) == null ? void 0 : _a2.find(
|
|
(d) => isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 263 /* EnumDeclaration */
|
|
);
|
|
if (declaration === void 0)
|
|
return Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration");
|
|
if (!(declaration.flags & 16777216 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) {
|
|
let diagnosticMessage;
|
|
const declarationName = declarationNameToString(getNameOfDeclaration(declaration));
|
|
if (result.flags & 2 /* BlockScopedVariable */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName);
|
|
} else if (result.flags & 32 /* Class */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
|
|
} else if (result.flags & 256 /* RegularEnum */) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
|
|
} else {
|
|
Debug.assert(!!(result.flags & 128 /* ConstEnum */));
|
|
if (shouldPreserveConstEnums(compilerOptions)) {
|
|
diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
|
|
}
|
|
}
|
|
if (diagnosticMessage) {
|
|
addRelatedInfo(
|
|
diagnosticMessage,
|
|
createDiagnosticForNode(declaration, Diagnostics._0_is_declared_here, declarationName)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function isSameScopeDescendentOf(initial, parent2, stopAt) {
|
|
return !!parent2 && !!findAncestor(initial, (n) => n === parent2 || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || isAsyncFunction(n)) ? "quit" : false));
|
|
}
|
|
function getAnyImportSyntax(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node;
|
|
case 270 /* ImportClause */:
|
|
return node.parent;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.parent;
|
|
case 273 /* ImportSpecifier */:
|
|
return node.parent.parent.parent;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getDeclarationOfAliasSymbol(symbol) {
|
|
return symbol.declarations && findLast(symbol.declarations, isAliasSymbolDeclaration2);
|
|
}
|
|
function isAliasSymbolDeclaration2(node) {
|
|
return node.kind === 268 /* ImportEqualsDeclaration */ || node.kind === 267 /* NamespaceExportDeclaration */ || node.kind === 270 /* ImportClause */ && !!node.name || node.kind === 271 /* NamespaceImport */ || node.kind === 277 /* NamespaceExport */ || node.kind === 273 /* ImportSpecifier */ || node.kind === 278 /* ExportSpecifier */ || node.kind === 274 /* ExportAssignment */ && exportAssignmentIsAlias(node) || isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) || isAccessExpression(node) && isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableOrJsExpression(node.parent.right) || node.kind === 300 /* ShorthandPropertyAssignment */ || node.kind === 299 /* PropertyAssignment */ && isAliasableOrJsExpression(node.initializer) || node.kind === 257 /* VariableDeclaration */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node) || node.kind === 205 /* BindingElement */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node.parent.parent);
|
|
}
|
|
function isAliasableOrJsExpression(e) {
|
|
return isAliasableExpression(e) || isFunctionExpression(e) && isJSConstructor(e);
|
|
}
|
|
function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) {
|
|
const commonJSPropertyAccess = getCommonJSPropertyAccess(node);
|
|
if (commonJSPropertyAccess) {
|
|
const name = getLeftmostAccessExpression(commonJSPropertyAccess.expression).arguments[0];
|
|
return isIdentifier(commonJSPropertyAccess.name) ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), commonJSPropertyAccess.name.escapedText)) : void 0;
|
|
}
|
|
if (isVariableDeclaration(node) || node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
const immediate = resolveExternalModuleName(
|
|
node,
|
|
getExternalModuleRequireArgument(node) || getExternalModuleImportEqualsDeclarationExpression(node)
|
|
);
|
|
const resolved2 = resolveExternalModuleSymbol(immediate);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved2, false);
|
|
return resolved2;
|
|
}
|
|
const resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias);
|
|
checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved);
|
|
return resolved;
|
|
}
|
|
function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) {
|
|
if (markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false) && !node.isTypeOnly) {
|
|
const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node));
|
|
const isExport = typeOnlyDeclaration.kind === 278 /* ExportSpecifier */;
|
|
const message = isExport ? Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type : Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type;
|
|
const relatedMessage = isExport ? Diagnostics._0_was_exported_here : Diagnostics._0_was_imported_here;
|
|
const name = unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText);
|
|
addRelatedInfo(error(node.moduleReference, message), createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name));
|
|
}
|
|
}
|
|
function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) {
|
|
const exportValue = moduleSymbol.exports.get("export=" /* ExportEquals */);
|
|
const exportSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), name) : moduleSymbol.exports.get(name);
|
|
const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
function isSyntacticDefault(node) {
|
|
return isExportAssignment(node) && !node.isExportEquals || hasSyntacticModifier(node, 1024 /* Default */) || isExportSpecifier(node);
|
|
}
|
|
function getUsageModeForExpression(usage) {
|
|
return isStringLiteralLike(usage) ? getModeForUsageLocation(getSourceFileOfNode(usage), usage) : void 0;
|
|
}
|
|
function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
|
|
return usageMode === 99 /* ESNext */ && targetMode === 1 /* CommonJS */;
|
|
}
|
|
function isOnlyImportedAsDefault(usage) {
|
|
const usageMode = getUsageModeForExpression(usage);
|
|
return usageMode === 99 /* ESNext */ && endsWith(usage.text, ".json" /* Json */);
|
|
}
|
|
function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
|
|
const usageMode = file && getUsageModeForExpression(usage);
|
|
if (file && usageMode !== void 0) {
|
|
const result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat);
|
|
if (usageMode === 99 /* ESNext */ || result) {
|
|
return result;
|
|
}
|
|
}
|
|
if (!allowSyntheticDefaultImports) {
|
|
return false;
|
|
}
|
|
if (!file || file.isDeclarationFile) {
|
|
const defaultExportSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, void 0, true);
|
|
if (defaultExportSymbol && some(defaultExportSymbol.declarations, isSyntacticDefault)) {
|
|
return false;
|
|
}
|
|
if (resolveExportByName(moduleSymbol, escapeLeadingUnderscores("__esModule"), void 0, dontResolveAlias)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (!isSourceFileJS(file)) {
|
|
return hasExportAssignmentSymbol(moduleSymbol);
|
|
}
|
|
return typeof file.externalModuleIndicator !== "object" && !resolveExportByName(moduleSymbol, escapeLeadingUnderscores("__esModule"), void 0, dontResolveAlias);
|
|
}
|
|
function getTargetOfImportClause(node, dontResolveAlias) {
|
|
const moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias);
|
|
}
|
|
}
|
|
function getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias) {
|
|
var _a2;
|
|
let exportDefaultSymbol;
|
|
if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
exportDefaultSymbol = moduleSymbol;
|
|
} else {
|
|
exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
|
|
}
|
|
const file = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
if (!specifier) {
|
|
return exportDefaultSymbol;
|
|
}
|
|
const hasDefaultOnly = isOnlyImportedAsDefault(specifier);
|
|
const hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier);
|
|
if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
|
|
if (hasExportAssignmentSymbol(moduleSymbol)) {
|
|
const compilerOptionName = moduleKind >= 5 /* ES2015 */ ? "allowSyntheticDefaultImports" : "esModuleInterop";
|
|
const exportEqualsSymbol = moduleSymbol.exports.get("export=" /* ExportEquals */);
|
|
const exportAssignment = exportEqualsSymbol.valueDeclaration;
|
|
const err = error(node.name, Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName);
|
|
if (exportAssignment) {
|
|
addRelatedInfo(err, createDiagnosticForNode(
|
|
exportAssignment,
|
|
Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag,
|
|
compilerOptionName
|
|
));
|
|
}
|
|
} else if (isImportClause(node)) {
|
|
reportNonDefaultExport(moduleSymbol, node);
|
|
} else {
|
|
errorNoModuleMemberSymbol(moduleSymbol, moduleSymbol, node, isImportOrExportSpecifier(node) && node.propertyName || node.name);
|
|
}
|
|
} else if (hasSyntheticDefault || hasDefaultOnly) {
|
|
const resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, void 0, false);
|
|
return exportDefaultSymbol;
|
|
}
|
|
function getModuleSpecifierForImportOrExport(node) {
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
return node.parent.moduleSpecifier;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return isExternalModuleReference(node.moduleReference) ? node.moduleReference.expression : void 0;
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.parent.moduleSpecifier;
|
|
case 273 /* ImportSpecifier */:
|
|
return node.parent.parent.parent.moduleSpecifier;
|
|
case 278 /* ExportSpecifier */:
|
|
return node.parent.parent.moduleSpecifier;
|
|
default:
|
|
return Debug.assertNever(node);
|
|
}
|
|
}
|
|
function reportNonDefaultExport(moduleSymbol, node) {
|
|
var _a2, _b, _c;
|
|
if ((_a2 = moduleSymbol.exports) == null ? void 0 : _a2.has(node.symbol.escapedName)) {
|
|
error(
|
|
node.name,
|
|
Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead,
|
|
symbolToString(moduleSymbol),
|
|
symbolToString(node.symbol)
|
|
);
|
|
} else {
|
|
const diagnostic = error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));
|
|
const exportStar = (_b = moduleSymbol.exports) == null ? void 0 : _b.get("__export" /* ExportStar */);
|
|
if (exportStar) {
|
|
const defaultExport = (_c = exportStar.declarations) == null ? void 0 : _c.find((decl) => {
|
|
var _a3, _b2;
|
|
return !!(isExportDeclaration(decl) && decl.moduleSpecifier && ((_b2 = (_a3 = resolveExternalModuleName(decl, decl.moduleSpecifier)) == null ? void 0 : _a3.exports) == null ? void 0 : _b2.has("default" /* Default */)));
|
|
});
|
|
if (defaultExport) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(defaultExport, Diagnostics.export_Asterisk_does_not_re_export_a_default));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTargetOfNamespaceImport(node, dontResolveAlias) {
|
|
const moduleSpecifier = node.parent.parent.moduleSpecifier;
|
|
const immediate = resolveExternalModuleName(node, moduleSpecifier);
|
|
const resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfNamespaceExport(node, dontResolveAlias) {
|
|
const moduleSpecifier = node.parent.moduleSpecifier;
|
|
const immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier);
|
|
const resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, false);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, false);
|
|
return resolved;
|
|
}
|
|
function combineValueAndTypeSymbols(valueSymbol, typeSymbol) {
|
|
if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) {
|
|
return unknownSymbol;
|
|
}
|
|
if (valueSymbol.flags & (788968 /* Type */ | 1920 /* Namespace */)) {
|
|
return valueSymbol;
|
|
}
|
|
const result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName);
|
|
result.declarations = deduplicate(concatenate(valueSymbol.declarations, typeSymbol.declarations), equateValues);
|
|
result.parent = valueSymbol.parent || typeSymbol.parent;
|
|
if (valueSymbol.valueDeclaration)
|
|
result.valueDeclaration = valueSymbol.valueDeclaration;
|
|
if (typeSymbol.members)
|
|
result.members = new Map(typeSymbol.members);
|
|
if (valueSymbol.exports)
|
|
result.exports = new Map(valueSymbol.exports);
|
|
return result;
|
|
}
|
|
function getExportOfModule(symbol, name, specifier, dontResolveAlias) {
|
|
if (symbol.flags & 1536 /* Module */) {
|
|
const exportSymbol = getExportsOfSymbol(symbol).get(name.escapedText);
|
|
const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, false);
|
|
return resolved;
|
|
}
|
|
}
|
|
function getPropertyOfVariable(symbol, name) {
|
|
if (symbol.flags & 3 /* Variable */) {
|
|
const typeAnnotation = symbol.valueDeclaration.type;
|
|
if (typeAnnotation) {
|
|
return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name));
|
|
}
|
|
}
|
|
}
|
|
function getExternalModuleMember(node, specifier, dontResolveAlias = false) {
|
|
var _a2;
|
|
const moduleSpecifier = getExternalModuleRequireArgument(node) || node.moduleSpecifier;
|
|
const moduleSymbol = resolveExternalModuleName(node, moduleSpecifier);
|
|
const name = !isPropertyAccessExpression(specifier) && specifier.propertyName || specifier.name;
|
|
if (!isIdentifier(name)) {
|
|
return void 0;
|
|
}
|
|
const suppressInteropError = name.escapedText === "default" /* Default */ && !!(compilerOptions.allowSyntheticDefaultImports || getESModuleInterop(compilerOptions));
|
|
const targetSymbol = resolveESModuleSymbol(moduleSymbol, moduleSpecifier, false, suppressInteropError);
|
|
if (targetSymbol) {
|
|
if (name.escapedText) {
|
|
if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
return moduleSymbol;
|
|
}
|
|
let symbolFromVariable;
|
|
if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=" /* ExportEquals */)) {
|
|
symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText, true);
|
|
} else {
|
|
symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText);
|
|
}
|
|
symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
|
|
let symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
|
|
if (symbolFromModule === void 0 && name.escapedText === "default" /* Default */) {
|
|
const file = (_a2 = moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
|
|
symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
|
|
}
|
|
}
|
|
const symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ? combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : symbolFromModule || symbolFromVariable;
|
|
if (!symbol) {
|
|
errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name);
|
|
}
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
function errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name) {
|
|
var _a2;
|
|
const moduleName = getFullyQualifiedName(moduleSymbol, node);
|
|
const declarationName = declarationNameToString(name);
|
|
const suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol);
|
|
if (suggestion !== void 0) {
|
|
const suggestionName = symbolToString(suggestion);
|
|
const diagnostic = error(name, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName);
|
|
if (suggestion.valueDeclaration) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestionName)
|
|
);
|
|
}
|
|
} else {
|
|
if ((_a2 = moduleSymbol.exports) == null ? void 0 : _a2.has("default" /* Default */)) {
|
|
error(
|
|
name,
|
|
Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead,
|
|
moduleName,
|
|
declarationName
|
|
);
|
|
} else {
|
|
reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName);
|
|
}
|
|
}
|
|
}
|
|
function reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName) {
|
|
var _a2, _b;
|
|
const localSymbol = (_b = (_a2 = moduleSymbol.valueDeclaration) == null ? void 0 : _a2.locals) == null ? void 0 : _b.get(name.escapedText);
|
|
const exports = moduleSymbol.exports;
|
|
if (localSymbol) {
|
|
const exportedEqualsSymbol = exports == null ? void 0 : exports.get("export=" /* ExportEquals */);
|
|
if (exportedEqualsSymbol) {
|
|
getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) : error(name, Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
|
|
} else {
|
|
const exportedSymbol = exports ? find(symbolsToArray(exports), (symbol) => !!getSymbolIfSameReference(symbol, localSymbol)) : void 0;
|
|
const diagnostic = exportedSymbol ? error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) : error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
|
|
if (localSymbol.declarations) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
...map(localSymbol.declarations, (decl, index) => createDiagnosticForNode(decl, index === 0 ? Diagnostics._0_is_declared_here : Diagnostics.and_here, declarationName))
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
error(name, Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
|
|
}
|
|
}
|
|
function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) {
|
|
if (moduleKind >= 5 /* ES2015 */) {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_a_default_import : Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
|
|
error(name, message, declarationName);
|
|
} else {
|
|
if (isInJSFile(node)) {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import : Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
|
|
error(name, message, declarationName);
|
|
} else {
|
|
const message = getESModuleInterop(compilerOptions) ? Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import : Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import;
|
|
error(name, message, declarationName, declarationName, moduleName);
|
|
}
|
|
}
|
|
}
|
|
function getTargetOfImportSpecifier(node, dontResolveAlias) {
|
|
if (isImportSpecifier(node) && idText(node.propertyName || node.name) === "default" /* Default */) {
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
const moduleSymbol = specifier && resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias);
|
|
}
|
|
}
|
|
const root = isBindingElement(node) ? getRootDeclaration(node) : node.parent.parent.parent;
|
|
const commonJSPropertyAccess = getCommonJSPropertyAccess(root);
|
|
const resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias);
|
|
const name = node.propertyName || node.name;
|
|
if (commonJSPropertyAccess && resolved && isIdentifier(name)) {
|
|
return resolveSymbol(getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText), dontResolveAlias);
|
|
}
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getCommonJSPropertyAccess(node) {
|
|
if (isVariableDeclaration(node) && node.initializer && isPropertyAccessExpression(node.initializer)) {
|
|
return node.initializer;
|
|
}
|
|
}
|
|
function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) {
|
|
const resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) {
|
|
if (idText(node.propertyName || node.name) === "default" /* Default */) {
|
|
const specifier = getModuleSpecifierForImportOrExport(node);
|
|
const moduleSymbol = specifier && resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
return getTargetofModuleDefault(moduleSymbol, node, !!dontResolveAlias);
|
|
}
|
|
}
|
|
const resolved = node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : resolveEntityName(node.propertyName || node.name, meaning, false, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfExportAssignment(node, dontResolveAlias) {
|
|
const expression = isExportAssignment(node) ? node.expression : node.right;
|
|
const resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias);
|
|
markSymbolOfAliasDeclarationIfTypeOnly(node, void 0, resolved, false);
|
|
return resolved;
|
|
}
|
|
function getTargetOfAliasLikeExpression(expression, dontResolveAlias) {
|
|
if (isClassExpression(expression)) {
|
|
return checkExpressionCached(expression).symbol;
|
|
}
|
|
if (!isEntityName(expression) && !isEntityNameExpression(expression)) {
|
|
return void 0;
|
|
}
|
|
const aliasLike = resolveEntityName(expression, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, true, dontResolveAlias);
|
|
if (aliasLike) {
|
|
return aliasLike;
|
|
}
|
|
checkExpressionCached(expression);
|
|
return getNodeLinks(expression).resolvedSymbol;
|
|
}
|
|
function getTargetOfAccessExpression(node, dontRecursivelyResolve) {
|
|
if (!(isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */)) {
|
|
return void 0;
|
|
}
|
|
return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve);
|
|
}
|
|
function getTargetOfAliasDeclaration(node, dontRecursivelyResolve = false) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 257 /* VariableDeclaration */:
|
|
return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve);
|
|
case 270 /* ImportClause */:
|
|
return getTargetOfImportClause(node, dontRecursivelyResolve);
|
|
case 271 /* NamespaceImport */:
|
|
return getTargetOfNamespaceImport(node, dontRecursivelyResolve);
|
|
case 277 /* NamespaceExport */:
|
|
return getTargetOfNamespaceExport(node, dontRecursivelyResolve);
|
|
case 273 /* ImportSpecifier */:
|
|
case 205 /* BindingElement */:
|
|
return getTargetOfImportSpecifier(node, dontRecursivelyResolve);
|
|
case 278 /* ExportSpecifier */:
|
|
return getTargetOfExportSpecifier(node, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, dontRecursivelyResolve);
|
|
case 274 /* ExportAssignment */:
|
|
case 223 /* BinaryExpression */:
|
|
return getTargetOfExportAssignment(node, dontRecursivelyResolve);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return resolveEntityName(node.name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, true, dontRecursivelyResolve);
|
|
case 299 /* PropertyAssignment */:
|
|
return getTargetOfAliasLikeExpression(node.initializer, dontRecursivelyResolve);
|
|
case 209 /* ElementAccessExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return getTargetOfAccessExpression(node, dontRecursivelyResolve);
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function isNonLocalAlias(symbol, excludes = 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */) {
|
|
if (!symbol)
|
|
return false;
|
|
return (symbol.flags & (2097152 /* Alias */ | excludes)) === 2097152 /* Alias */ || !!(symbol.flags & 2097152 /* Alias */ && symbol.flags & 67108864 /* Assignment */);
|
|
}
|
|
function resolveSymbol(symbol, dontResolveAlias) {
|
|
return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol;
|
|
}
|
|
function resolveAlias(symbol) {
|
|
Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.aliasTarget) {
|
|
links.aliasTarget = resolvingSymbol;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
const target = getTargetOfAliasDeclaration(node);
|
|
if (links.aliasTarget === resolvingSymbol) {
|
|
links.aliasTarget = target || unknownSymbol;
|
|
} else {
|
|
error(node, Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol));
|
|
}
|
|
} else if (links.aliasTarget === resolvingSymbol) {
|
|
links.aliasTarget = unknownSymbol;
|
|
}
|
|
return links.aliasTarget;
|
|
}
|
|
function tryResolveAlias(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.aliasTarget !== resolvingSymbol) {
|
|
return resolveAlias(symbol);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAllSymbolFlags(symbol) {
|
|
let flags = symbol.flags;
|
|
let seenSymbols;
|
|
while (symbol.flags & 2097152 /* Alias */) {
|
|
const target = resolveAlias(symbol);
|
|
if (target === unknownSymbol) {
|
|
return 67108863 /* All */;
|
|
}
|
|
if (target === symbol || (seenSymbols == null ? void 0 : seenSymbols.has(target))) {
|
|
break;
|
|
}
|
|
if (target.flags & 2097152 /* Alias */) {
|
|
if (seenSymbols) {
|
|
seenSymbols.add(target);
|
|
} else {
|
|
seenSymbols = /* @__PURE__ */ new Set([symbol, target]);
|
|
}
|
|
}
|
|
flags |= target.flags;
|
|
symbol = target;
|
|
}
|
|
return flags;
|
|
}
|
|
function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) {
|
|
if (!aliasDeclaration || isPropertyAccessExpression(aliasDeclaration))
|
|
return false;
|
|
const sourceSymbol = getSymbolOfNode(aliasDeclaration);
|
|
if (isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) {
|
|
const links2 = getSymbolLinks(sourceSymbol);
|
|
links2.typeOnlyDeclaration = aliasDeclaration;
|
|
return true;
|
|
}
|
|
const links = getSymbolLinks(sourceSymbol);
|
|
return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty) || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty);
|
|
}
|
|
function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) {
|
|
var _a2, _b, _c;
|
|
if (target && (aliasDeclarationLinks.typeOnlyDeclaration === void 0 || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) {
|
|
const exportSymbol = (_b = (_a2 = target.exports) == null ? void 0 : _a2.get("export=" /* ExportEquals */)) != null ? _b : target;
|
|
const typeOnly = exportSymbol.declarations && find(exportSymbol.declarations, isTypeOnlyImportOrExportDeclaration);
|
|
aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly != null ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) != null ? _c : false;
|
|
}
|
|
return !!aliasDeclarationLinks.typeOnlyDeclaration;
|
|
}
|
|
function getTypeOnlyAliasDeclaration(symbol, include) {
|
|
if (!(symbol.flags & 2097152 /* Alias */)) {
|
|
return void 0;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
if (include === void 0) {
|
|
return links.typeOnlyDeclaration || void 0;
|
|
}
|
|
if (links.typeOnlyDeclaration) {
|
|
return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function markExportAsReferenced(node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const target = resolveAlias(symbol);
|
|
if (target) {
|
|
const markAlias = target === unknownSymbol || getAllSymbolFlags(target) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
|
|
if (markAlias) {
|
|
markAliasSymbolAsReferenced(symbol);
|
|
}
|
|
}
|
|
}
|
|
function markAliasSymbolAsReferenced(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.referenced) {
|
|
links.referenced = true;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
if (isInternalModuleImportEqualsDeclaration(node)) {
|
|
if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
|
|
checkExpressionCached(node.moduleReference);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function markConstEnumAliasAsReferenced(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.constEnumReferenced) {
|
|
links.constEnumReferenced = true;
|
|
}
|
|
}
|
|
function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
|
|
if (entityName.kind === 79 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
|
|
entityName = entityName.parent;
|
|
}
|
|
if (entityName.kind === 79 /* Identifier */ || entityName.parent.kind === 163 /* QualifiedName */) {
|
|
return resolveEntityName(entityName, 1920 /* Namespace */, false, dontResolveAlias);
|
|
} else {
|
|
Debug.assert(entityName.parent.kind === 268 /* ImportEqualsDeclaration */);
|
|
return resolveEntityName(entityName, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */, false, dontResolveAlias);
|
|
}
|
|
}
|
|
function getFullyQualifiedName(symbol, containingLocation) {
|
|
return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, void 0, 32 /* DoNotIncludeSymbolChain */ | 4 /* AllowAnyNodeKind */);
|
|
}
|
|
function getContainingQualifiedNameNode(node) {
|
|
while (isQualifiedName(node.parent)) {
|
|
node = node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetQualifiedNameAsValue(node) {
|
|
let left = getFirstIdentifier(node);
|
|
let symbol = resolveName(left, left.escapedText, 111551 /* Value */, void 0, left, true);
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
while (isQualifiedName(left.parent)) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
symbol = getPropertyOfType(type, left.parent.right.escapedText);
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
left = left.parent;
|
|
}
|
|
return symbol;
|
|
}
|
|
function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location2) {
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
const namespaceMeaning = 1920 /* Namespace */ | (isInJSFile(name) ? meaning & 111551 /* Value */ : 0);
|
|
let symbol;
|
|
if (name.kind === 79 /* Identifier */) {
|
|
const message = meaning === namespaceMeaning || nodeIsSynthesized(name) ? Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(getFirstIdentifier(name));
|
|
const symbolFromJSPrototype = isInJSFile(name) && !nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : void 0;
|
|
symbol = getMergedSymbol(resolveName(location2 || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? void 0 : message, name, true, false));
|
|
if (!symbol) {
|
|
return getMergedSymbol(symbolFromJSPrototype);
|
|
}
|
|
} else if (name.kind === 163 /* QualifiedName */ || name.kind === 208 /* PropertyAccessExpression */) {
|
|
const left = name.kind === 163 /* QualifiedName */ ? name.left : name.expression;
|
|
const right = name.kind === 163 /* QualifiedName */ ? name.right : name.name;
|
|
let namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, false, location2);
|
|
if (!namespace || nodeIsMissing(right)) {
|
|
return void 0;
|
|
} else if (namespace === unknownSymbol) {
|
|
return namespace;
|
|
}
|
|
if (namespace.valueDeclaration && isInJSFile(namespace.valueDeclaration) && isVariableDeclaration(namespace.valueDeclaration) && namespace.valueDeclaration.initializer && isCommonJsRequire(namespace.valueDeclaration.initializer)) {
|
|
const moduleName = namespace.valueDeclaration.initializer.arguments[0];
|
|
const moduleSym = resolveExternalModuleName(moduleName, moduleName);
|
|
if (moduleSym) {
|
|
const resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
|
|
if (resolvedModuleSymbol) {
|
|
namespace = resolvedModuleSymbol;
|
|
}
|
|
}
|
|
}
|
|
symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(namespace), right.escapedText, meaning));
|
|
if (!symbol) {
|
|
if (!ignoreErrors) {
|
|
const namespaceName = getFullyQualifiedName(namespace);
|
|
const declarationName = declarationNameToString(right);
|
|
const suggestionForNonexistentModule = getSuggestedSymbolForNonexistentModule(right, namespace);
|
|
if (suggestionForNonexistentModule) {
|
|
error(right, Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, namespaceName, declarationName, symbolToString(suggestionForNonexistentModule));
|
|
return void 0;
|
|
}
|
|
const containingQualifiedName = isQualifiedName(name) && getContainingQualifiedNameNode(name);
|
|
const canSuggestTypeof = globalObjectType && meaning & 788968 /* Type */ && containingQualifiedName && !isTypeOfExpression(containingQualifiedName.parent) && tryGetQualifiedNameAsValue(containingQualifiedName);
|
|
if (canSuggestTypeof) {
|
|
error(
|
|
containingQualifiedName,
|
|
Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0,
|
|
entityNameToString(containingQualifiedName)
|
|
);
|
|
return void 0;
|
|
}
|
|
if (meaning & 1920 /* Namespace */ && isQualifiedName(name.parent)) {
|
|
const exportedTypeSymbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(namespace), right.escapedText, 788968 /* Type */));
|
|
if (exportedTypeSymbol) {
|
|
error(
|
|
name.parent.right,
|
|
Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1,
|
|
symbolToString(exportedTypeSymbol),
|
|
unescapeLeadingUnderscores(name.parent.right.escapedText)
|
|
);
|
|
return void 0;
|
|
}
|
|
}
|
|
error(right, Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName);
|
|
}
|
|
return void 0;
|
|
}
|
|
} else {
|
|
throw Debug.assertNever(name, "Unknown entity name kind.");
|
|
}
|
|
Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
|
|
if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 274 /* ExportAssignment */)) {
|
|
markSymbolOfAliasDeclarationIfTypeOnly(getAliasDeclarationFromName(name), symbol, void 0, true);
|
|
}
|
|
return symbol.flags & meaning || dontResolveAlias ? symbol : resolveAlias(symbol);
|
|
}
|
|
function resolveEntityNameFromAssignmentDeclaration(name, meaning) {
|
|
if (isJSDocTypeReference(name.parent)) {
|
|
const secondaryLocation = getAssignmentDeclarationLocation(name.parent);
|
|
if (secondaryLocation) {
|
|
return resolveName(secondaryLocation, name.escapedText, meaning, void 0, name, true);
|
|
}
|
|
}
|
|
}
|
|
function getAssignmentDeclarationLocation(node) {
|
|
const typeAlias = findAncestor(node, (node2) => !(isJSDocNode(node2) || node2.flags & 8388608 /* JSDoc */) ? "quit" : isJSDocTypeAlias(node2));
|
|
if (typeAlias) {
|
|
return;
|
|
}
|
|
const host2 = getJSDocHost(node);
|
|
if (host2 && isExpressionStatement(host2) && isPrototypePropertyAssignment(host2.expression)) {
|
|
const symbol = getSymbolOfNode(host2.expression.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
if (host2 && isFunctionExpression(host2) && isPrototypePropertyAssignment(host2.parent) && isExpressionStatement(host2.parent.parent)) {
|
|
const symbol = getSymbolOfNode(host2.parent.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
if (host2 && (isObjectLiteralMethod(host2) || isPropertyAssignment(host2)) && isBinaryExpression(host2.parent.parent) && getAssignmentDeclarationKind(host2.parent.parent) === 6 /* Prototype */) {
|
|
const symbol = getSymbolOfNode(host2.parent.parent.left);
|
|
if (symbol) {
|
|
return getDeclarationOfJSPrototypeContainer(symbol);
|
|
}
|
|
}
|
|
const sig = getEffectiveJSDocHost(node);
|
|
if (sig && isFunctionLike(sig)) {
|
|
const symbol = getSymbolOfNode(sig);
|
|
return symbol && symbol.valueDeclaration;
|
|
}
|
|
}
|
|
function getDeclarationOfJSPrototypeContainer(symbol) {
|
|
const decl = symbol.parent.valueDeclaration;
|
|
if (!decl) {
|
|
return void 0;
|
|
}
|
|
const initializer = isAssignmentDeclaration(decl) ? getAssignedExpandoInitializer(decl) : hasOnlyExpressionInitializer(decl) ? getDeclaredExpandoInitializer(decl) : void 0;
|
|
return initializer || decl;
|
|
}
|
|
function getExpandoSymbol(symbol) {
|
|
const decl = symbol.valueDeclaration;
|
|
if (!decl || !isInJSFile(decl) || symbol.flags & 524288 /* TypeAlias */ || getExpandoInitializer(decl, false)) {
|
|
return void 0;
|
|
}
|
|
const init = isVariableDeclaration(decl) ? getDeclaredExpandoInitializer(decl) : getAssignedExpandoInitializer(decl);
|
|
if (init) {
|
|
const initSymbol = getSymbolOfNode(init);
|
|
if (initSymbol) {
|
|
return mergeJSSymbols(initSymbol, symbol);
|
|
}
|
|
}
|
|
}
|
|
function resolveExternalModuleName(location2, moduleReferenceExpression, ignoreErrors) {
|
|
const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */;
|
|
const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
|
|
return resolveExternalModuleNameWorker(location2, moduleReferenceExpression, ignoreErrors ? void 0 : errorMessage);
|
|
}
|
|
function resolveExternalModuleNameWorker(location2, moduleReferenceExpression, moduleNotFoundError, isForAugmentation = false) {
|
|
return isStringLiteralLike(moduleReferenceExpression) ? resolveExternalModule(location2, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation) : void 0;
|
|
}
|
|
function resolveExternalModule(location2, moduleReference, moduleNotFoundError, errorNode, isForAugmentation = false) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h;
|
|
if (startsWith(moduleReference, "@types/")) {
|
|
const diag2 = Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
|
|
const withoutAtTypePrefix = removePrefix(moduleReference, "@types/");
|
|
error(errorNode, diag2, withoutAtTypePrefix, moduleReference);
|
|
}
|
|
const ambientModule = tryFindAmbientModule(moduleReference, true);
|
|
if (ambientModule) {
|
|
return ambientModule;
|
|
}
|
|
const currentSourceFile = getSourceFileOfNode(location2);
|
|
const contextSpecifier = isStringLiteralLike(location2) ? location2 : ((_a2 = findAncestor(location2, isImportCall)) == null ? void 0 : _a2.arguments[0]) || ((_b = findAncestor(location2, isImportDeclaration)) == null ? void 0 : _b.moduleSpecifier) || ((_c = findAncestor(location2, isExternalModuleImportEqualsDeclaration)) == null ? void 0 : _c.moduleReference.expression) || ((_d = findAncestor(location2, isExportDeclaration)) == null ? void 0 : _d.moduleSpecifier) || ((_e = isModuleDeclaration(location2) ? location2 : location2.parent && isModuleDeclaration(location2.parent) && location2.parent.name === location2 ? location2.parent : void 0) == null ? void 0 : _e.name) || ((_f = isLiteralImportTypeNode(location2) ? location2 : void 0) == null ? void 0 : _f.argument.literal);
|
|
const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
|
|
const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode);
|
|
const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule);
|
|
const sourceFile = resolvedModule && (!resolutionDiagnostic || resolutionDiagnostic === Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set) && host.getSourceFile(resolvedModule.resolvedFileName);
|
|
if (sourceFile) {
|
|
if (resolutionDiagnostic) {
|
|
error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
|
|
}
|
|
if (sourceFile.symbol) {
|
|
if (resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
|
|
errorOnImplicitAnyModule(false, errorNode, resolvedModule, moduleReference);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
const isSyncImport = currentSourceFile.impliedNodeFormat === 1 /* CommonJS */ && !findAncestor(location2, isImportCall) || !!findAncestor(location2, isImportEqualsDeclaration);
|
|
const overrideClauseHost = findAncestor(location2, (l) => isImportTypeNode(l) || isExportDeclaration(l) || isImportDeclaration(l));
|
|
const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? (_g = overrideClauseHost.assertions) == null ? void 0 : _g.assertClause : overrideClauseHost == null ? void 0 : overrideClauseHost.assertClause;
|
|
if (isSyncImport && sourceFile.impliedNodeFormat === 99 /* ESNext */ && !getResolutionModeOverrideForClause(overrideClause)) {
|
|
if (findAncestor(location2, isImportEqualsDeclaration)) {
|
|
error(errorNode, Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead, moduleReference);
|
|
} else {
|
|
let diagnosticDetails;
|
|
const ext = tryGetExtensionFromPath2(currentSourceFile.fileName);
|
|
if (ext === ".ts" /* Ts */ || ext === ".js" /* Js */ || ext === ".tsx" /* Tsx */ || ext === ".jsx" /* Jsx */) {
|
|
const scope = currentSourceFile.packageJsonScope;
|
|
const targetExt = ext === ".ts" /* Ts */ ? ".mts" /* Mts */ : ext === ".js" /* Js */ ? ".mjs" /* Mjs */ : void 0;
|
|
if (scope && !scope.contents.packageJsonContent.type) {
|
|
if (targetExt) {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1,
|
|
targetExt,
|
|
combinePaths(scope.packageDirectory, "package.json")
|
|
);
|
|
} else {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0,
|
|
combinePaths(scope.packageDirectory, "package.json")
|
|
);
|
|
}
|
|
} else {
|
|
if (targetExt) {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module,
|
|
targetExt
|
|
);
|
|
} else {
|
|
diagnosticDetails = chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module
|
|
);
|
|
}
|
|
}
|
|
}
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(errorNode, chainDiagnosticMessages(
|
|
diagnosticDetails,
|
|
Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead,
|
|
moduleReference
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
return getMergedSymbol(sourceFile.symbol);
|
|
}
|
|
if (moduleNotFoundError) {
|
|
error(errorNode, Diagnostics.File_0_is_not_a_module, sourceFile.fileName);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (patternAmbientModules) {
|
|
const pattern = findBestPatternMatch(patternAmbientModules, (_) => _.pattern, moduleReference);
|
|
if (pattern) {
|
|
const augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference);
|
|
if (augmentation) {
|
|
return getMergedSymbol(augmentation);
|
|
}
|
|
return getMergedSymbol(pattern.symbol);
|
|
}
|
|
}
|
|
if (resolvedModule && !resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === void 0 || resolutionDiagnostic === Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) {
|
|
if (isForAugmentation) {
|
|
const diag2 = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;
|
|
error(errorNode, diag2, moduleReference, resolvedModule.resolvedFileName);
|
|
} else {
|
|
errorOnImplicitAnyModule(noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (moduleNotFoundError) {
|
|
if (resolvedModule) {
|
|
const redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName);
|
|
if (redirect) {
|
|
error(errorNode, Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName);
|
|
return void 0;
|
|
}
|
|
}
|
|
if (resolutionDiagnostic) {
|
|
error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName);
|
|
} else {
|
|
const tsExtension = tryExtractTSExtension(moduleReference);
|
|
const isExtensionlessRelativePathImport = pathIsRelative(moduleReference) && !hasExtension(moduleReference);
|
|
const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
|
|
const resolutionIsNode16OrNext = moduleResolutionKind === 3 /* Node16 */ || moduleResolutionKind === 99 /* NodeNext */;
|
|
if (tsExtension) {
|
|
const diag2 = Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
|
|
const importSourceWithoutExtension = removeExtension(moduleReference, tsExtension);
|
|
let replacedImportSource = importSourceWithoutExtension;
|
|
if (moduleKind >= 5 /* ES2015 */) {
|
|
replacedImportSource += tsExtension === ".mts" /* Mts */ ? ".mjs" : tsExtension === ".cts" /* Cts */ ? ".cjs" : ".js";
|
|
}
|
|
error(errorNode, diag2, tsExtension, replacedImportSource);
|
|
} else if (!compilerOptions.resolveJsonModule && fileExtensionIs(moduleReference, ".json" /* Json */) && getEmitModuleResolutionKind(compilerOptions) !== 1 /* Classic */ && hasJsonModuleEmitEnabled(compilerOptions)) {
|
|
error(errorNode, Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
|
|
} else if (mode === 99 /* ESNext */ && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) {
|
|
const absoluteRef = getNormalizedAbsolutePath(moduleReference, getDirectoryPath(currentSourceFile.path));
|
|
const suggestedExt = (_h = suggestedExtensions.find(([actualExt, _importExt]) => host.fileExists(absoluteRef + actualExt))) == null ? void 0 : _h[1];
|
|
if (suggestedExt) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0,
|
|
moduleReference + suggestedExt
|
|
);
|
|
} else {
|
|
error(errorNode, Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path);
|
|
}
|
|
} else {
|
|
error(errorNode, moduleNotFoundError, moduleReference);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function errorOnImplicitAnyModule(isError, errorNode, { packageId, resolvedFileName }, moduleReference) {
|
|
const errorInfo = !isExternalModuleNameRelative(moduleReference) && packageId ? typesPackageExists(packageId.name) ? chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1,
|
|
packageId.name,
|
|
mangleScopedPackageName(packageId.name)
|
|
) : packageBundlesTypes(packageId.name) ? chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1,
|
|
packageId.name,
|
|
moduleReference
|
|
) : chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0,
|
|
moduleReference,
|
|
mangleScopedPackageName(packageId.name)
|
|
) : void 0;
|
|
errorOrSuggestion(isError, errorNode, chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type,
|
|
moduleReference,
|
|
resolvedFileName
|
|
));
|
|
}
|
|
function typesPackageExists(packageName) {
|
|
return getPackagesMap().has(getTypesPackageName(packageName));
|
|
}
|
|
function packageBundlesTypes(packageName) {
|
|
return !!getPackagesMap().get(packageName);
|
|
}
|
|
function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) {
|
|
if (moduleSymbol == null ? void 0 : moduleSymbol.exports) {
|
|
const exportEquals = resolveSymbol(moduleSymbol.exports.get("export=" /* ExportEquals */), dontResolveAlias);
|
|
const exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol));
|
|
return getMergedSymbol(exported) || moduleSymbol;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getCommonJsExportEquals(exported, moduleSymbol) {
|
|
if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152 /* Alias */) {
|
|
return exported;
|
|
}
|
|
const links = getSymbolLinks(exported);
|
|
if (links.cjsExportMerged) {
|
|
return links.cjsExportMerged;
|
|
}
|
|
const merged = exported.flags & 33554432 /* Transient */ ? exported : cloneSymbol(exported);
|
|
merged.flags = merged.flags | 512 /* ValueModule */;
|
|
if (merged.exports === void 0) {
|
|
merged.exports = createSymbolTable();
|
|
}
|
|
moduleSymbol.exports.forEach((s, name) => {
|
|
if (name === "export=" /* ExportEquals */)
|
|
return;
|
|
merged.exports.set(name, merged.exports.has(name) ? mergeSymbol(merged.exports.get(name), s) : s);
|
|
});
|
|
getSymbolLinks(merged).cjsExportMerged = merged;
|
|
return links.cjsExportMerged = merged;
|
|
}
|
|
function resolveESModuleSymbol(moduleSymbol, referencingLocation, dontResolveAlias, suppressInteropError) {
|
|
var _a2;
|
|
const symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias);
|
|
if (!dontResolveAlias && symbol) {
|
|
if (!suppressInteropError && !(symbol.flags & (1536 /* Module */ | 3 /* Variable */)) && !getDeclarationOfKind(symbol, 308 /* SourceFile */)) {
|
|
const compilerOptionName = moduleKind >= 5 /* ES2015 */ ? "allowSyntheticDefaultImports" : "esModuleInterop";
|
|
error(referencingLocation, Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
|
|
return symbol;
|
|
}
|
|
const referenceParent = referencingLocation.parent;
|
|
if (isImportDeclaration(referenceParent) && getNamespaceDeclarationNode(referenceParent) || isImportCall(referenceParent)) {
|
|
const reference = isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier;
|
|
const type = getTypeOfSymbol(symbol);
|
|
const defaultOnlyType = getTypeWithSyntheticDefaultOnly(type, symbol, moduleSymbol, reference);
|
|
if (defaultOnlyType) {
|
|
return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent);
|
|
}
|
|
const targetFile = (_a2 = moduleSymbol == null ? void 0 : moduleSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const isEsmCjsRef = targetFile && isESMFormatImportImportingCommonjsFormatFile(getUsageModeForExpression(reference), targetFile.impliedNodeFormat);
|
|
if (getESModuleInterop(compilerOptions) || isEsmCjsRef) {
|
|
let sigs = getSignaturesOfStructuredType(type, 0 /* Call */);
|
|
if (!sigs || !sigs.length) {
|
|
sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
|
|
}
|
|
if (sigs && sigs.length || getPropertyOfType(type, "default" /* Default */, true) || isEsmCjsRef) {
|
|
const moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
|
|
return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return symbol;
|
|
}
|
|
function cloneTypeAsModuleType(symbol, moduleType, referenceParent) {
|
|
const result = createSymbol(symbol.flags, symbol.escapedName);
|
|
result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
|
|
result.parent = symbol.parent;
|
|
result.target = symbol;
|
|
result.originatingImport = referenceParent;
|
|
if (symbol.valueDeclaration)
|
|
result.valueDeclaration = symbol.valueDeclaration;
|
|
if (symbol.constEnumOnlyModule)
|
|
result.constEnumOnlyModule = true;
|
|
if (symbol.members)
|
|
result.members = new Map(symbol.members);
|
|
if (symbol.exports)
|
|
result.exports = new Map(symbol.exports);
|
|
const resolvedModuleType = resolveStructuredTypeMembers(moduleType);
|
|
result.type = createAnonymousType(result, resolvedModuleType.members, emptyArray, emptyArray, resolvedModuleType.indexInfos);
|
|
return result;
|
|
}
|
|
function hasExportAssignmentSymbol(moduleSymbol) {
|
|
return moduleSymbol.exports.get("export=" /* ExportEquals */) !== void 0;
|
|
}
|
|
function getExportsOfModuleAsArray(moduleSymbol) {
|
|
return symbolsToArray(getExportsOfModule(moduleSymbol));
|
|
}
|
|
function getExportsAndPropertiesOfModule(moduleSymbol) {
|
|
const exports = getExportsOfModuleAsArray(moduleSymbol);
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals !== moduleSymbol) {
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
|
|
addRange(exports, getPropertiesOfType(type));
|
|
}
|
|
}
|
|
return exports;
|
|
}
|
|
function forEachExportAndPropertyOfModule(moduleSymbol, cb) {
|
|
const exports = getExportsOfModule(moduleSymbol);
|
|
exports.forEach((symbol, key) => {
|
|
if (!isReservedMemberName(key)) {
|
|
cb(symbol, key);
|
|
}
|
|
});
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals !== moduleSymbol) {
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
|
|
forEachPropertyOfType(type, (symbol, escapedName) => {
|
|
cb(symbol, escapedName);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function tryGetMemberInModuleExports(memberName, moduleSymbol) {
|
|
const symbolTable = getExportsOfModule(moduleSymbol);
|
|
if (symbolTable) {
|
|
return symbolTable.get(memberName);
|
|
}
|
|
}
|
|
function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) {
|
|
const symbol = tryGetMemberInModuleExports(memberName, moduleSymbol);
|
|
if (symbol) {
|
|
return symbol;
|
|
}
|
|
const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals === moduleSymbol) {
|
|
return void 0;
|
|
}
|
|
const type = getTypeOfSymbol(exportEquals);
|
|
return shouldTreatPropertiesOfExternalModuleAsExports(type) ? getPropertyOfType(type, memberName) : void 0;
|
|
}
|
|
function shouldTreatPropertiesOfExternalModuleAsExports(resolvedExternalModuleType) {
|
|
return !(resolvedExternalModuleType.flags & 131068 /* Primitive */ || getObjectFlags(resolvedExternalModuleType) & 1 /* Class */ || isArrayType(resolvedExternalModuleType) || isTupleType(resolvedExternalModuleType));
|
|
}
|
|
function getExportsOfSymbol(symbol) {
|
|
return symbol.flags & 6256 /* LateBindingContainer */ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports" /* resolvedExports */) : symbol.flags & 1536 /* Module */ ? getExportsOfModule(symbol) : symbol.exports || emptySymbols;
|
|
}
|
|
function getExportsOfModule(moduleSymbol) {
|
|
const links = getSymbolLinks(moduleSymbol);
|
|
return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol));
|
|
}
|
|
function extendExportSymbols(target, source, lookupTable, exportNode) {
|
|
if (!source)
|
|
return;
|
|
source.forEach((sourceSymbol, id) => {
|
|
if (id === "default" /* Default */)
|
|
return;
|
|
const targetSymbol = target.get(id);
|
|
if (!targetSymbol) {
|
|
target.set(id, sourceSymbol);
|
|
if (lookupTable && exportNode) {
|
|
lookupTable.set(id, {
|
|
specifierText: getTextOfNode(exportNode.moduleSpecifier)
|
|
});
|
|
}
|
|
} else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) {
|
|
const collisionTracker = lookupTable.get(id);
|
|
if (!collisionTracker.exportsWithDuplicate) {
|
|
collisionTracker.exportsWithDuplicate = [exportNode];
|
|
} else {
|
|
collisionTracker.exportsWithDuplicate.push(exportNode);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function getExportsOfModuleWorker(moduleSymbol) {
|
|
const visitedSymbols = [];
|
|
moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
|
|
return visit(moduleSymbol) || emptySymbols;
|
|
function visit(symbol) {
|
|
if (!(symbol && symbol.exports && pushIfUnique(visitedSymbols, symbol))) {
|
|
return;
|
|
}
|
|
const symbols = new Map(symbol.exports);
|
|
const exportStars = symbol.exports.get("__export" /* ExportStar */);
|
|
if (exportStars) {
|
|
const nestedSymbols = createSymbolTable();
|
|
const lookupTable = /* @__PURE__ */ new Map();
|
|
if (exportStars.declarations) {
|
|
for (const node of exportStars.declarations) {
|
|
const resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
const exportedSymbols = visit(resolvedModule);
|
|
extendExportSymbols(
|
|
nestedSymbols,
|
|
exportedSymbols,
|
|
lookupTable,
|
|
node
|
|
);
|
|
}
|
|
}
|
|
lookupTable.forEach(({ exportsWithDuplicate }, id) => {
|
|
if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) {
|
|
return;
|
|
}
|
|
for (const node of exportsWithDuplicate) {
|
|
diagnostics.add(createDiagnosticForNode(
|
|
node,
|
|
Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity,
|
|
lookupTable.get(id).specifierText,
|
|
unescapeLeadingUnderscores(id)
|
|
));
|
|
}
|
|
});
|
|
extendExportSymbols(symbols, nestedSymbols);
|
|
}
|
|
return symbols;
|
|
}
|
|
}
|
|
function getMergedSymbol(symbol) {
|
|
let merged;
|
|
return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol;
|
|
}
|
|
function getSymbolOfNode(node) {
|
|
return getMergedSymbol(node.symbol && getLateBoundSymbol(node.symbol));
|
|
}
|
|
function getParentOfSymbol(symbol) {
|
|
return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent));
|
|
}
|
|
function getAlternativeContainingModules(symbol, enclosingDeclaration) {
|
|
const containingFile = getSourceFileOfNode(enclosingDeclaration);
|
|
const id = getNodeId(containingFile);
|
|
const links = getSymbolLinks(symbol);
|
|
let results;
|
|
if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) {
|
|
return results;
|
|
}
|
|
if (containingFile && containingFile.imports) {
|
|
for (const importRef of containingFile.imports) {
|
|
if (nodeIsSynthesized(importRef))
|
|
continue;
|
|
const resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, true);
|
|
if (!resolvedModule)
|
|
continue;
|
|
const ref = getAliasForSymbolInContainer(resolvedModule, symbol);
|
|
if (!ref)
|
|
continue;
|
|
results = append(results, resolvedModule);
|
|
}
|
|
if (length(results)) {
|
|
(links.extendedContainersByFile || (links.extendedContainersByFile = /* @__PURE__ */ new Map())).set(id, results);
|
|
return results;
|
|
}
|
|
}
|
|
if (links.extendedContainers) {
|
|
return links.extendedContainers;
|
|
}
|
|
const otherFiles = host.getSourceFiles();
|
|
for (const file of otherFiles) {
|
|
if (!isExternalModule(file))
|
|
continue;
|
|
const sym = getSymbolOfNode(file);
|
|
const ref = getAliasForSymbolInContainer(sym, symbol);
|
|
if (!ref)
|
|
continue;
|
|
results = append(results, sym);
|
|
}
|
|
return links.extendedContainers = results || emptyArray;
|
|
}
|
|
function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
|
|
const container = getParentOfSymbol(symbol);
|
|
if (container && !(symbol.flags & 262144 /* TypeParameter */)) {
|
|
const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
|
|
const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
|
|
const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
|
|
if (enclosingDeclaration && container.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(container, enclosingDeclaration, 1920 /* Namespace */, false)) {
|
|
return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
|
|
}
|
|
const firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) && container.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
|
|
return forEachEntry(t, (s) => {
|
|
if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) {
|
|
return s;
|
|
}
|
|
});
|
|
}) : void 0;
|
|
let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container] : [...additionalContainers, container];
|
|
res = append(res, objectLiteralContainer);
|
|
res = addRange(res, reexportContainers);
|
|
return res;
|
|
}
|
|
const candidates = mapDefined(symbol.declarations, (d) => {
|
|
if (!isAmbientModule(d) && d.parent) {
|
|
if (hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) {
|
|
return getSymbolOfNode(d.parent);
|
|
}
|
|
if (isModuleBlock(d.parent) && d.parent.parent && resolveExternalModuleSymbol(getSymbolOfNode(d.parent.parent)) === symbol) {
|
|
return getSymbolOfNode(d.parent.parent);
|
|
}
|
|
}
|
|
if (isClassExpression(d) && isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 63 /* EqualsToken */ && isAccessExpression(d.parent.left) && isEntityNameExpression(d.parent.left.expression)) {
|
|
if (isModuleExportsAccessExpression(d.parent.left) || isExportsIdentifier(d.parent.left.expression)) {
|
|
return getSymbolOfNode(getSourceFileOfNode(d));
|
|
}
|
|
checkExpressionCached(d.parent.left.expression);
|
|
return getNodeLinks(d.parent.left.expression).resolvedSymbol;
|
|
}
|
|
});
|
|
if (!length(candidates)) {
|
|
return void 0;
|
|
}
|
|
return mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
|
|
function fileSymbolIfFileSymbolExportEqualsContainer(d) {
|
|
return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
|
|
}
|
|
}
|
|
function getVariableDeclarationOfObjectLiteral(symbol, meaning) {
|
|
const firstDecl = !!length(symbol.declarations) && first(symbol.declarations);
|
|
if (meaning & 111551 /* Value */ && firstDecl && firstDecl.parent && isVariableDeclaration(firstDecl.parent)) {
|
|
if (isObjectLiteralExpression(firstDecl) && firstDecl === firstDecl.parent.initializer || isTypeLiteralNode(firstDecl) && firstDecl === firstDecl.parent.type) {
|
|
return getSymbolOfNode(firstDecl.parent);
|
|
}
|
|
}
|
|
}
|
|
function getFileSymbolIfFileSymbolExportEqualsContainer(d, container) {
|
|
const fileSymbol = getExternalModuleContainer(d);
|
|
const exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export=" /* ExportEquals */);
|
|
return exported && getSymbolIfSameReference(exported, container) ? fileSymbol : void 0;
|
|
}
|
|
function getAliasForSymbolInContainer(container, symbol) {
|
|
if (container === getParentOfSymbol(symbol)) {
|
|
return symbol;
|
|
}
|
|
const exportEquals = container.exports && container.exports.get("export=" /* ExportEquals */);
|
|
if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) {
|
|
return container;
|
|
}
|
|
const exports = getExportsOfSymbol(container);
|
|
const quick = exports.get(symbol.escapedName);
|
|
if (quick && getSymbolIfSameReference(quick, symbol)) {
|
|
return quick;
|
|
}
|
|
return forEachEntry(exports, (exported) => {
|
|
if (getSymbolIfSameReference(exported, symbol)) {
|
|
return exported;
|
|
}
|
|
});
|
|
}
|
|
function getSymbolIfSameReference(s1, s2) {
|
|
if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
|
|
return s1;
|
|
}
|
|
}
|
|
function getExportSymbolOfValueSymbolIfExported(symbol) {
|
|
return getMergedSymbol(symbol && (symbol.flags & 1048576 /* ExportValue */) !== 0 && symbol.exportSymbol || symbol);
|
|
}
|
|
function symbolIsValue(symbol, includeTypeOnlyMembers) {
|
|
return !!(symbol.flags & 111551 /* Value */ || symbol.flags & 2097152 /* Alias */ && getAllSymbolFlags(symbol) & 111551 /* Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol)));
|
|
}
|
|
function findConstructorDeclaration(node) {
|
|
const members = node.members;
|
|
for (const member of members) {
|
|
if (member.kind === 173 /* Constructor */ && nodeIsPresent(member.body)) {
|
|
return member;
|
|
}
|
|
}
|
|
}
|
|
function createType(flags) {
|
|
var _a2;
|
|
const result = new Type27(checker, flags);
|
|
typeCount++;
|
|
result.id = typeCount;
|
|
(_a2 = tracing) == null ? void 0 : _a2.recordType(result);
|
|
return result;
|
|
}
|
|
function createTypeWithSymbol(flags, symbol) {
|
|
const result = createType(flags);
|
|
result.symbol = symbol;
|
|
return result;
|
|
}
|
|
function createOriginType(flags) {
|
|
return new Type27(checker, flags);
|
|
}
|
|
function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */) {
|
|
const type = createType(kind);
|
|
type.intrinsicName = intrinsicName;
|
|
type.objectFlags = objectFlags;
|
|
return type;
|
|
}
|
|
function createObjectType(objectFlags, symbol) {
|
|
const type = createTypeWithSymbol(524288 /* Object */, symbol);
|
|
type.objectFlags = objectFlags;
|
|
type.members = void 0;
|
|
type.properties = void 0;
|
|
type.callSignatures = void 0;
|
|
type.constructSignatures = void 0;
|
|
type.indexInfos = void 0;
|
|
return type;
|
|
}
|
|
function createTypeofType() {
|
|
return getUnionType(arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
|
|
}
|
|
function createTypeParameter(symbol) {
|
|
return createTypeWithSymbol(262144 /* TypeParameter */, symbol);
|
|
}
|
|
function isReservedMemberName(name) {
|
|
return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) !== 95 /* _ */ && name.charCodeAt(2) !== 64 /* at */ && name.charCodeAt(2) !== 35 /* hash */;
|
|
}
|
|
function getNamedMembers(members) {
|
|
let result;
|
|
members.forEach((symbol, id) => {
|
|
if (isNamedMember(symbol, id)) {
|
|
(result || (result = [])).push(symbol);
|
|
}
|
|
});
|
|
return result || emptyArray;
|
|
}
|
|
function isNamedMember(member, escapedName) {
|
|
return !isReservedMemberName(escapedName) && symbolIsValue(member);
|
|
}
|
|
function getNamedOrIndexSignatureMembers(members) {
|
|
const result = getNamedMembers(members);
|
|
const index = getIndexSymbolFromSymbolTable(members);
|
|
return index ? concatenate(result, [index]) : result;
|
|
}
|
|
function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos) {
|
|
const resolved = type;
|
|
resolved.members = members;
|
|
resolved.properties = emptyArray;
|
|
resolved.callSignatures = callSignatures;
|
|
resolved.constructSignatures = constructSignatures;
|
|
resolved.indexInfos = indexInfos;
|
|
if (members !== emptySymbols)
|
|
resolved.properties = getNamedMembers(members);
|
|
return resolved;
|
|
}
|
|
function createAnonymousType(symbol, members, callSignatures, constructSignatures, indexInfos) {
|
|
return setStructuredTypeMembers(
|
|
createObjectType(16 /* Anonymous */, symbol),
|
|
members,
|
|
callSignatures,
|
|
constructSignatures,
|
|
indexInfos
|
|
);
|
|
}
|
|
function getResolvedTypeWithoutAbstractConstructSignatures(type) {
|
|
if (type.constructSignatures.length === 0)
|
|
return type;
|
|
if (type.objectTypeWithoutAbstractConstructSignatures)
|
|
return type.objectTypeWithoutAbstractConstructSignatures;
|
|
const constructSignatures = filter(type.constructSignatures, (signature) => !(signature.flags & 4 /* Abstract */));
|
|
if (type.constructSignatures === constructSignatures)
|
|
return type;
|
|
const typeCopy = createAnonymousType(
|
|
type.symbol,
|
|
type.members,
|
|
type.callSignatures,
|
|
some(constructSignatures) ? constructSignatures : emptyArray,
|
|
type.indexInfos
|
|
);
|
|
type.objectTypeWithoutAbstractConstructSignatures = typeCopy;
|
|
typeCopy.objectTypeWithoutAbstractConstructSignatures = typeCopy;
|
|
return typeCopy;
|
|
}
|
|
function forEachSymbolTableInScope(enclosingDeclaration, callback) {
|
|
let result;
|
|
for (let location2 = enclosingDeclaration; location2; location2 = location2.parent) {
|
|
if (location2.locals && !isGlobalSourceFile(location2)) {
|
|
if (result = callback(location2.locals, void 0, true, location2)) {
|
|
return result;
|
|
}
|
|
}
|
|
switch (location2.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalOrCommonJsModule(location2)) {
|
|
break;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
const sym = getSymbolOfNode(location2);
|
|
if (result = callback((sym == null ? void 0 : sym.exports) || emptySymbols, void 0, true, location2)) {
|
|
return result;
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
let table;
|
|
(getSymbolOfNode(location2).members || emptySymbols).forEach((memberSymbol, key) => {
|
|
if (memberSymbol.flags & (788968 /* Type */ & ~67108864 /* Assignment */)) {
|
|
(table || (table = createSymbolTable())).set(key, memberSymbol);
|
|
}
|
|
});
|
|
if (table && (result = callback(table, void 0, false, location2))) {
|
|
return result;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return callback(globals, void 0, true);
|
|
}
|
|
function getQualifiedLeftMeaning(rightMeaning) {
|
|
return rightMeaning === 111551 /* Value */ ? 111551 /* Value */ : 1920 /* Namespace */;
|
|
}
|
|
function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap = /* @__PURE__ */ new Map()) {
|
|
if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
|
|
return void 0;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
const cache = links.accessibleChainCache || (links.accessibleChainCache = /* @__PURE__ */ new Map());
|
|
const firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, (_, __, ___, node) => node);
|
|
const key = `${useOnlyExternalAliasing ? 0 : 1}|${firstRelevantLocation && getNodeId(firstRelevantLocation)}|${meaning}`;
|
|
if (cache.has(key)) {
|
|
return cache.get(key);
|
|
}
|
|
const id = getSymbolId(symbol);
|
|
let visitedSymbolTables = visitedSymbolTablesMap.get(id);
|
|
if (!visitedSymbolTables) {
|
|
visitedSymbolTablesMap.set(id, visitedSymbolTables = []);
|
|
}
|
|
const result = forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable);
|
|
cache.set(key, result);
|
|
return result;
|
|
function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification, isLocalNameLookup) {
|
|
if (!pushIfUnique(visitedSymbolTables, symbols)) {
|
|
return void 0;
|
|
}
|
|
const result2 = trySymbolTable(symbols, ignoreQualification, isLocalNameLookup);
|
|
visitedSymbolTables.pop();
|
|
return result2;
|
|
}
|
|
function canQualifySymbol(symbolFromSymbolTable, meaning2) {
|
|
return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning2) || !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning2), useOnlyExternalAliasing, visitedSymbolTablesMap);
|
|
}
|
|
function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) {
|
|
return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) && !some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) && (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning));
|
|
}
|
|
function trySymbolTable(symbols, ignoreQualification, isLocalNameLookup) {
|
|
if (isAccessible(symbols.get(symbol.escapedName), void 0, ignoreQualification)) {
|
|
return [symbol];
|
|
}
|
|
const result2 = forEachEntry(symbols, (symbolFromSymbolTable) => {
|
|
if (symbolFromSymbolTable.flags & 2097152 /* Alias */ && symbolFromSymbolTable.escapedName !== "export=" /* ExportEquals */ && symbolFromSymbolTable.escapedName !== "default" /* Default */ && !(isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && isExternalModule(getSourceFileOfNode(enclosingDeclaration))) && (!useOnlyExternalAliasing || some(symbolFromSymbolTable.declarations, isExternalModuleImportEqualsDeclaration)) && (isLocalNameLookup ? !some(symbolFromSymbolTable.declarations, isNamespaceReexportDeclaration) : true) && (ignoreQualification || !getDeclarationOfKind(symbolFromSymbolTable, 278 /* ExportSpecifier */))) {
|
|
const resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable);
|
|
const candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification);
|
|
if (candidate) {
|
|
return candidate;
|
|
}
|
|
}
|
|
if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) {
|
|
if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), void 0, ignoreQualification)) {
|
|
return [symbol];
|
|
}
|
|
}
|
|
});
|
|
return result2 || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : void 0);
|
|
}
|
|
function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) {
|
|
if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) {
|
|
return [symbolFromSymbolTable];
|
|
}
|
|
const candidateTable = getExportsOfSymbol(resolvedImportedSymbol);
|
|
const accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, true);
|
|
if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) {
|
|
return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports);
|
|
}
|
|
}
|
|
}
|
|
function needsQualification(symbol, enclosingDeclaration, meaning) {
|
|
let qualify = false;
|
|
forEachSymbolTableInScope(enclosingDeclaration, (symbolTable) => {
|
|
let symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName));
|
|
if (!symbolFromSymbolTable) {
|
|
return false;
|
|
}
|
|
if (symbolFromSymbolTable === symbol) {
|
|
return true;
|
|
}
|
|
const shouldResolveAlias = symbolFromSymbolTable.flags & 2097152 /* Alias */ && !getDeclarationOfKind(symbolFromSymbolTable, 278 /* ExportSpecifier */);
|
|
symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable;
|
|
const flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags;
|
|
if (flags & meaning) {
|
|
qualify = true;
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
return qualify;
|
|
}
|
|
function isPropertyOrMethodDeclarationSymbol(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length) {
|
|
for (const declaration of symbol.declarations) {
|
|
switch (declaration.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
continue;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 788968 /* Type */, false, true);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 111551 /* Value */, false, true);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isSymbolAccessibleByFlags(typeSymbol, enclosingDeclaration, flags) {
|
|
const access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, flags, false, false);
|
|
return access.accessibility === 0 /* Accessible */;
|
|
}
|
|
function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
|
|
if (!length(symbols))
|
|
return;
|
|
let hadAccessibleChain;
|
|
let earlyModuleBail = false;
|
|
for (const symbol of symbols) {
|
|
const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, false);
|
|
if (accessibleSymbolChain) {
|
|
hadAccessibleChain = symbol;
|
|
const hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
|
|
if (hasAccessibleDeclarations) {
|
|
return hasAccessibleDeclarations;
|
|
}
|
|
}
|
|
if (allowModules) {
|
|
if (some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
if (shouldComputeAliasesToMakeVisible) {
|
|
earlyModuleBail = true;
|
|
continue;
|
|
}
|
|
return {
|
|
accessibility: 0 /* Accessible */
|
|
};
|
|
}
|
|
}
|
|
const containers = getContainersOfSymbol(symbol, enclosingDeclaration, meaning);
|
|
const parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible, allowModules);
|
|
if (parentResult) {
|
|
return parentResult;
|
|
}
|
|
}
|
|
if (earlyModuleBail) {
|
|
return {
|
|
accessibility: 0 /* Accessible */
|
|
};
|
|
}
|
|
if (hadAccessibleChain) {
|
|
return {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
|
|
errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920 /* Namespace */) : void 0
|
|
};
|
|
}
|
|
}
|
|
function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
|
|
return isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, true);
|
|
}
|
|
function isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, allowModules) {
|
|
if (symbol && enclosingDeclaration) {
|
|
const result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible, allowModules);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
const symbolExternalModule = forEach(symbol.declarations, getExternalModuleContainer);
|
|
if (symbolExternalModule) {
|
|
const enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
|
|
if (symbolExternalModule !== enclosingExternalModule) {
|
|
return {
|
|
accessibility: 2 /* CannotBeNamed */,
|
|
errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning),
|
|
errorModuleName: symbolToString(symbolExternalModule),
|
|
errorNode: isInJSFile(enclosingDeclaration) ? enclosingDeclaration : void 0
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning)
|
|
};
|
|
}
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
function getExternalModuleContainer(declaration) {
|
|
const node = findAncestor(declaration, hasExternalModuleSymbol);
|
|
return node && getSymbolOfNode(node);
|
|
}
|
|
function hasExternalModuleSymbol(declaration) {
|
|
return isAmbientModule(declaration) || declaration.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(declaration);
|
|
}
|
|
function hasNonGlobalAugmentationExternalModuleSymbol(declaration) {
|
|
return isModuleWithStringLiteralName(declaration) || declaration.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(declaration);
|
|
}
|
|
function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
|
|
let aliasesToMakeVisible;
|
|
if (!every(filter(symbol.declarations, (d) => d.kind !== 79 /* Identifier */), getIsDeclarationVisible)) {
|
|
return void 0;
|
|
}
|
|
return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
|
|
function getIsDeclarationVisible(declaration) {
|
|
var _a2, _b;
|
|
if (!isDeclarationVisible(declaration)) {
|
|
const anyImportSyntax = getAnyImportSyntax(declaration);
|
|
if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 1 /* Export */) && isDeclarationVisible(anyImportSyntax.parent)) {
|
|
return addVisibleAlias(declaration, anyImportSyntax);
|
|
} else if (isVariableDeclaration(declaration) && isVariableStatement(declaration.parent.parent) && !hasSyntacticModifier(declaration.parent.parent, 1 /* Export */) && isDeclarationVisible(declaration.parent.parent.parent)) {
|
|
return addVisibleAlias(declaration, declaration.parent.parent);
|
|
} else if (isLateVisibilityPaintedStatement(declaration) && !hasSyntacticModifier(declaration, 1 /* Export */) && isDeclarationVisible(declaration.parent)) {
|
|
return addVisibleAlias(declaration, declaration);
|
|
} else if (isBindingElement(declaration)) {
|
|
if (symbol.flags & 2097152 /* Alias */ && isInJSFile(declaration) && ((_a2 = declaration.parent) == null ? void 0 : _a2.parent) && isVariableDeclaration(declaration.parent.parent) && ((_b = declaration.parent.parent.parent) == null ? void 0 : _b.parent) && isVariableStatement(declaration.parent.parent.parent.parent) && !hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */) && declaration.parent.parent.parent.parent.parent && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
|
|
return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
|
|
} else if (symbol.flags & 2 /* BlockScopedVariable */) {
|
|
const variableStatement = findAncestor(declaration, isVariableStatement);
|
|
if (hasSyntacticModifier(variableStatement, 1 /* Export */)) {
|
|
return true;
|
|
}
|
|
if (!isDeclarationVisible(variableStatement.parent)) {
|
|
return false;
|
|
}
|
|
return addVisibleAlias(declaration, variableStatement);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function addVisibleAlias(declaration, aliasingStatement) {
|
|
if (shouldComputeAliasToMakeVisible) {
|
|
getNodeLinks(declaration).isVisible = true;
|
|
aliasesToMakeVisible = appendIfUnique(aliasesToMakeVisible, aliasingStatement);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function isEntityNameVisible(entityName, enclosingDeclaration) {
|
|
let meaning;
|
|
if (entityName.parent.kind === 183 /* TypeQuery */ || entityName.parent.kind === 230 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 164 /* ComputedPropertyName */) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
} else if (entityName.kind === 163 /* QualifiedName */ || entityName.kind === 208 /* PropertyAccessExpression */ || entityName.parent.kind === 268 /* ImportEqualsDeclaration */) {
|
|
meaning = 1920 /* Namespace */;
|
|
} else {
|
|
meaning = 788968 /* Type */;
|
|
}
|
|
const firstIdentifier = getFirstIdentifier(entityName);
|
|
const symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, void 0, void 0, false);
|
|
if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
if (!symbol && isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(getThisContainer(firstIdentifier, false)), firstIdentifier, meaning, false).accessibility === 0 /* Accessible */) {
|
|
return { accessibility: 0 /* Accessible */ };
|
|
}
|
|
return symbol && hasVisibleDeclarations(symbol, true) || {
|
|
accessibility: 1 /* NotAccessible */,
|
|
errorSymbolName: getTextOfNode(firstIdentifier),
|
|
errorNode: firstIdentifier
|
|
};
|
|
}
|
|
function symbolToString(symbol, enclosingDeclaration, meaning, flags = 4 /* AllowAnyNodeKind */, writer) {
|
|
let nodeFlags = 70221824 /* IgnoreErrors */;
|
|
if (flags & 2 /* UseOnlyExternalAliasing */) {
|
|
nodeFlags |= 128 /* UseOnlyExternalAliasing */;
|
|
}
|
|
if (flags & 1 /* WriteTypeParametersOrArguments */) {
|
|
nodeFlags |= 512 /* WriteTypeParametersInQualifiedName */;
|
|
}
|
|
if (flags & 8 /* UseAliasDefinedOutsideCurrentScope */) {
|
|
nodeFlags |= 16384 /* UseAliasDefinedOutsideCurrentScope */;
|
|
}
|
|
if (flags & 32 /* DoNotIncludeSymbolChain */) {
|
|
nodeFlags |= 134217728 /* DoNotIncludeSymbolChain */;
|
|
}
|
|
if (flags & 16 /* WriteComputedProps */) {
|
|
nodeFlags |= 1073741824 /* WriteComputedProps */;
|
|
}
|
|
const builder = flags & 4 /* AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName;
|
|
return writer ? symbolToStringWorker(writer).getText() : usingSingleLineStringWriter(symbolToStringWorker);
|
|
function symbolToStringWorker(writer2) {
|
|
const entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags);
|
|
const printer = (enclosingDeclaration == null ? void 0 : enclosingDeclaration.kind) === 308 /* SourceFile */ ? createPrinter({ removeComments: true, neverAsciiEscape: true }) : createPrinter({ removeComments: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, entity, sourceFile, writer2);
|
|
return writer2;
|
|
}
|
|
}
|
|
function signatureToString(signature, enclosingDeclaration, flags = 0 /* None */, kind, writer) {
|
|
return writer ? signatureToStringWorker(writer).getText() : usingSingleLineStringWriter(signatureToStringWorker);
|
|
function signatureToStringWorker(writer2) {
|
|
let sigOutput;
|
|
if (flags & 262144 /* WriteArrowStyleSignature */) {
|
|
sigOutput = kind === 1 /* Construct */ ? 182 /* ConstructorType */ : 181 /* FunctionType */;
|
|
} else {
|
|
sigOutput = kind === 1 /* Construct */ ? 177 /* ConstructSignature */ : 176 /* CallSignature */;
|
|
}
|
|
const sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */);
|
|
const printer = createPrinter({ removeComments: true, omitTrailingSemicolon: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, sig, sourceFile, getTrailingSemicolonDeferringWriter(writer2));
|
|
return writer2;
|
|
}
|
|
}
|
|
function typeToString(type, enclosingDeclaration, flags = 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer = createTextWriter("")) {
|
|
const noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* NoTruncation */;
|
|
const typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | (noTruncation ? 1 /* NoTruncation */ : 0), writer);
|
|
if (typeNode === void 0)
|
|
return Debug.fail("should always get typenode");
|
|
const options = { removeComments: type !== unresolvedType };
|
|
const printer = createPrinter(options);
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, typeNode, sourceFile, writer);
|
|
const result = writer.getText();
|
|
const maxLength2 = noTruncation ? noTruncationMaximumTruncationLength * 2 : defaultMaximumTruncationLength * 2;
|
|
if (maxLength2 && result && result.length >= maxLength2) {
|
|
return result.substr(0, maxLength2 - "...".length) + "...";
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeNamesForErrorDisplay(left, right) {
|
|
let leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left);
|
|
let rightStr = symbolValueDeclarationIsContextSensitive(right.symbol) ? typeToString(right, right.symbol.valueDeclaration) : typeToString(right);
|
|
if (leftStr === rightStr) {
|
|
leftStr = getTypeNameForErrorDisplay(left);
|
|
rightStr = getTypeNameForErrorDisplay(right);
|
|
}
|
|
return [leftStr, rightStr];
|
|
}
|
|
function getTypeNameForErrorDisplay(type) {
|
|
return typeToString(type, void 0, 64 /* UseFullyQualifiedType */);
|
|
}
|
|
function symbolValueDeclarationIsContextSensitive(symbol) {
|
|
return symbol && !!symbol.valueDeclaration && isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration);
|
|
}
|
|
function toNodeBuilderFlags(flags = 0 /* None */) {
|
|
return flags & 848330091 /* NodeBuilderFlagsMask */;
|
|
}
|
|
function isClassInstanceSide(type) {
|
|
return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
|
|
}
|
|
function createNodeBuilder() {
|
|
return {
|
|
typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
|
|
indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, void 0)),
|
|
signatureToSignatureDeclaration: (signature, kind, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => signatureToSignatureDeclarationHelper(signature, kind, context)),
|
|
symbolToEntityName: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToName(symbol, context, meaning, false)),
|
|
symbolToExpression: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToExpression(symbol, context, meaning)),
|
|
symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
|
|
symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
|
|
typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
|
|
symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
|
|
symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
|
|
};
|
|
function symbolToNode(symbol, context, meaning) {
|
|
if (context.flags & 1073741824 /* WriteComputedProps */) {
|
|
if (symbol.valueDeclaration) {
|
|
const name = getNameOfDeclaration(symbol.valueDeclaration);
|
|
if (name && isComputedPropertyName(name))
|
|
return name;
|
|
}
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType && nameType.flags & (1024 /* EnumLiteral */ | 8192 /* UniqueESSymbol */)) {
|
|
context.enclosingDeclaration = nameType.symbol.valueDeclaration;
|
|
return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, meaning));
|
|
}
|
|
}
|
|
return symbolToExpression(symbol, context, meaning);
|
|
}
|
|
function withContext(enclosingDeclaration, flags, tracker, cb) {
|
|
var _a2, _b;
|
|
Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 8 /* Synthesized */) === 0);
|
|
const context = {
|
|
enclosingDeclaration,
|
|
flags: flags || 0 /* None */,
|
|
tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: () => false, moduleResolverHost: flags & 134217728 /* DoNotIncludeSymbolChain */ ? {
|
|
getCommonSourceDirectory: !!host.getCommonSourceDirectory ? () => host.getCommonSourceDirectory() : () => "",
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
getSymlinkCache: maybeBind(host, host.getSymlinkCache),
|
|
getPackageJsonInfoCache: () => {
|
|
var _a3;
|
|
return (_a3 = host.getPackageJsonInfoCache) == null ? void 0 : _a3.call(host);
|
|
},
|
|
useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
|
|
redirectTargetsMap: host.redirectTargetsMap,
|
|
getProjectReferenceRedirect: (fileName) => host.getProjectReferenceRedirect(fileName),
|
|
isSourceOfProjectReferenceRedirect: (fileName) => host.isSourceOfProjectReferenceRedirect(fileName),
|
|
fileExists: (fileName) => host.fileExists(fileName),
|
|
getFileIncludeReasons: () => host.getFileIncludeReasons(),
|
|
readFile: host.readFile ? (fileName) => host.readFile(fileName) : void 0
|
|
} : void 0 },
|
|
encounteredError: false,
|
|
reportedDiagnostic: false,
|
|
visitedTypes: void 0,
|
|
symbolDepth: void 0,
|
|
inferTypeParameters: void 0,
|
|
approximateLength: 0
|
|
};
|
|
context.tracker = wrapSymbolTrackerToReportForContext(context, context.tracker);
|
|
const resultingNode = cb(context);
|
|
if (context.truncating && context.flags & 1 /* NoTruncation */) {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.reportTruncationError) == null ? void 0 : _b.call(_a2);
|
|
}
|
|
return context.encounteredError ? void 0 : resultingNode;
|
|
}
|
|
function wrapSymbolTrackerToReportForContext(context, tracker) {
|
|
const oldTrackSymbol = tracker.trackSymbol;
|
|
return {
|
|
...tracker,
|
|
reportCyclicStructureError: wrapReportedDiagnostic(tracker.reportCyclicStructureError),
|
|
reportInaccessibleThisError: wrapReportedDiagnostic(tracker.reportInaccessibleThisError),
|
|
reportInaccessibleUniqueSymbolError: wrapReportedDiagnostic(tracker.reportInaccessibleUniqueSymbolError),
|
|
reportLikelyUnsafeImportRequiredError: wrapReportedDiagnostic(tracker.reportLikelyUnsafeImportRequiredError),
|
|
reportNonlocalAugmentation: wrapReportedDiagnostic(tracker.reportNonlocalAugmentation),
|
|
reportPrivateInBaseOfClassExpression: wrapReportedDiagnostic(tracker.reportPrivateInBaseOfClassExpression),
|
|
reportNonSerializableProperty: wrapReportedDiagnostic(tracker.reportNonSerializableProperty),
|
|
trackSymbol: oldTrackSymbol && ((...args) => {
|
|
const result = oldTrackSymbol(...args);
|
|
if (result) {
|
|
context.reportedDiagnostic = true;
|
|
}
|
|
return result;
|
|
})
|
|
};
|
|
function wrapReportedDiagnostic(method) {
|
|
if (!method) {
|
|
return method;
|
|
}
|
|
return (...args) => {
|
|
context.reportedDiagnostic = true;
|
|
return method(...args);
|
|
};
|
|
}
|
|
}
|
|
function checkTruncationLength(context) {
|
|
if (context.truncating)
|
|
return context.truncating;
|
|
return context.truncating = context.approximateLength > (context.flags & 1 /* NoTruncation */ ? noTruncationMaximumTruncationLength : defaultMaximumTruncationLength);
|
|
}
|
|
function typeToTypeNodeHelper(type, context) {
|
|
const savedFlags = context.flags;
|
|
const typeNode = typeToTypeNodeWorker(type, context);
|
|
context.flags = savedFlags;
|
|
return typeNode;
|
|
}
|
|
function typeToTypeNodeWorker(type, context) {
|
|
if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
const inTypeAlias = context.flags & 8388608 /* InTypeAlias */;
|
|
context.flags &= ~8388608 /* InTypeAlias */;
|
|
if (!type) {
|
|
if (!(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) {
|
|
context.encounteredError = true;
|
|
return void 0;
|
|
}
|
|
context.approximateLength += 3;
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (!(context.flags & 536870912 /* NoTypeReduction */)) {
|
|
type = getReducedType(type);
|
|
}
|
|
if (type.flags & 1 /* Any */) {
|
|
if (type.aliasSymbol) {
|
|
return factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context));
|
|
}
|
|
if (type === unresolvedType) {
|
|
return addSyntheticLeadingComment(factory.createKeywordTypeNode(131 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "unresolved");
|
|
}
|
|
context.approximateLength += 3;
|
|
return factory.createKeywordTypeNode(type === intrinsicMarkerType ? 139 /* IntrinsicKeyword */ : 131 /* AnyKeyword */);
|
|
}
|
|
if (type.flags & 2 /* Unknown */) {
|
|
return factory.createKeywordTypeNode(157 /* UnknownKeyword */);
|
|
}
|
|
if (type.flags & 4 /* String */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(152 /* StringKeyword */);
|
|
}
|
|
if (type.flags & 8 /* Number */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(148 /* NumberKeyword */);
|
|
}
|
|
if (type.flags & 64 /* BigInt */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(160 /* BigIntKeyword */);
|
|
}
|
|
if (type.flags & 16 /* Boolean */ && !type.aliasSymbol) {
|
|
context.approximateLength += 7;
|
|
return factory.createKeywordTypeNode(134 /* BooleanKeyword */);
|
|
}
|
|
if (type.flags & 1056 /* EnumLike */) {
|
|
if (type.symbol.flags & 8 /* EnumMember */) {
|
|
const parentSymbol = getParentOfSymbol(type.symbol);
|
|
const parentName = symbolToTypeNode(parentSymbol, context, 788968 /* Type */);
|
|
if (getDeclaredTypeOfSymbol(parentSymbol) === type) {
|
|
return parentName;
|
|
}
|
|
const memberName = symbolName(type.symbol);
|
|
if (isIdentifierText(memberName, 0 /* ES3 */)) {
|
|
return appendReferenceToType(
|
|
parentName,
|
|
factory.createTypeReferenceNode(memberName, void 0)
|
|
);
|
|
}
|
|
if (isImportTypeNode(parentName)) {
|
|
parentName.isTypeOf = true;
|
|
return factory.createIndexedAccessTypeNode(parentName, factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
|
|
} else if (isTypeReferenceNode(parentName)) {
|
|
return factory.createIndexedAccessTypeNode(factory.createTypeQueryNode(parentName.typeName), factory.createLiteralTypeNode(factory.createStringLiteral(memberName)));
|
|
} else {
|
|
return Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`.");
|
|
}
|
|
}
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
|
|
}
|
|
if (type.flags & 128 /* StringLiteral */) {
|
|
context.approximateLength += type.value.length + 2;
|
|
return factory.createLiteralTypeNode(setEmitFlags(factory.createStringLiteral(type.value, !!(context.flags & 268435456 /* UseSingleQuotesForStringLiteralType */)), 33554432 /* NoAsciiEscaping */));
|
|
}
|
|
if (type.flags & 256 /* NumberLiteral */) {
|
|
const value = type.value;
|
|
context.approximateLength += ("" + value).length;
|
|
return factory.createLiteralTypeNode(value < 0 ? factory.createPrefixUnaryExpression(40 /* MinusToken */, factory.createNumericLiteral(-value)) : factory.createNumericLiteral(value));
|
|
}
|
|
if (type.flags & 2048 /* BigIntLiteral */) {
|
|
context.approximateLength += pseudoBigIntToString(type.value).length + 1;
|
|
return factory.createLiteralTypeNode(factory.createBigIntLiteral(type.value));
|
|
}
|
|
if (type.flags & 512 /* BooleanLiteral */) {
|
|
context.approximateLength += type.intrinsicName.length;
|
|
return factory.createLiteralTypeNode(type.intrinsicName === "true" ? factory.createTrue() : factory.createFalse());
|
|
}
|
|
if (type.flags & 8192 /* UniqueESSymbol */) {
|
|
if (!(context.flags & 1048576 /* AllowUniqueESSymbolType */)) {
|
|
if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
|
|
context.approximateLength += 6;
|
|
return symbolToTypeNode(type.symbol, context, 111551 /* Value */);
|
|
}
|
|
if (context.tracker.reportInaccessibleUniqueSymbolError) {
|
|
context.tracker.reportInaccessibleUniqueSymbolError();
|
|
}
|
|
}
|
|
context.approximateLength += 13;
|
|
return factory.createTypeOperatorNode(156 /* UniqueKeyword */, factory.createKeywordTypeNode(153 /* SymbolKeyword */));
|
|
}
|
|
if (type.flags & 16384 /* Void */) {
|
|
context.approximateLength += 4;
|
|
return factory.createKeywordTypeNode(114 /* VoidKeyword */);
|
|
}
|
|
if (type.flags & 32768 /* Undefined */) {
|
|
context.approximateLength += 9;
|
|
return factory.createKeywordTypeNode(155 /* UndefinedKeyword */);
|
|
}
|
|
if (type.flags & 65536 /* Null */) {
|
|
context.approximateLength += 4;
|
|
return factory.createLiteralTypeNode(factory.createNull());
|
|
}
|
|
if (type.flags & 131072 /* Never */) {
|
|
context.approximateLength += 5;
|
|
return factory.createKeywordTypeNode(144 /* NeverKeyword */);
|
|
}
|
|
if (type.flags & 4096 /* ESSymbol */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(153 /* SymbolKeyword */);
|
|
}
|
|
if (type.flags & 67108864 /* NonPrimitive */) {
|
|
context.approximateLength += 6;
|
|
return factory.createKeywordTypeNode(149 /* ObjectKeyword */);
|
|
}
|
|
if (isThisTypeParameter(type)) {
|
|
if (context.flags & 4194304 /* InObjectTypeLiteral */) {
|
|
if (!context.encounteredError && !(context.flags & 32768 /* AllowThisInObjectLiteral */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
if (context.tracker.reportInaccessibleThisError) {
|
|
context.tracker.reportInaccessibleThisError();
|
|
}
|
|
}
|
|
context.approximateLength += 4;
|
|
return factory.createThisTypeNode();
|
|
}
|
|
if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) {
|
|
const typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context);
|
|
if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* Class */))
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(""), typeArgumentNodes);
|
|
if (length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) {
|
|
return factory.createArrayTypeNode(typeArgumentNodes[0]);
|
|
}
|
|
return symbolToTypeNode(type.aliasSymbol, context, 788968 /* Type */, typeArgumentNodes);
|
|
}
|
|
const objectFlags = getObjectFlags(type);
|
|
if (objectFlags & 4 /* Reference */) {
|
|
Debug.assert(!!(type.flags & 524288 /* Object */));
|
|
return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type);
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */ || objectFlags & 3 /* ClassOrInterface */) {
|
|
if (type.flags & 262144 /* TypeParameter */ && contains(context.inferTypeParameters, type)) {
|
|
context.approximateLength += symbolName(type.symbol).length + 6;
|
|
let constraintNode;
|
|
const constraint = getConstraintOfTypeParameter(type);
|
|
if (constraint) {
|
|
const inferredConstraint = getInferredTypeParameterConstraint(type, true);
|
|
if (!(inferredConstraint && isTypeIdenticalTo(constraint, inferredConstraint))) {
|
|
context.approximateLength += 9;
|
|
constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
|
|
}
|
|
}
|
|
return factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, constraintNode));
|
|
}
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) {
|
|
const name2 = typeParameterToName(type, context);
|
|
context.approximateLength += idText(name2).length;
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(idText(name2)), void 0);
|
|
}
|
|
if (type.symbol) {
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */);
|
|
}
|
|
const name = (type === markerSuperTypeForCheck || type === markerSubTypeForCheck) && varianceTypeParameter && varianceTypeParameter.symbol ? (type === markerSubTypeForCheck ? "sub-" : "super-") + symbolName(varianceTypeParameter.symbol) : "?";
|
|
return factory.createTypeReferenceNode(factory.createIdentifier(name), void 0);
|
|
}
|
|
if (type.flags & 1048576 /* Union */ && type.origin) {
|
|
type = type.origin;
|
|
}
|
|
if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
|
|
const types = type.flags & 1048576 /* Union */ ? formatUnionTypes(type.types) : type.types;
|
|
if (length(types) === 1) {
|
|
return typeToTypeNodeHelper(types[0], context);
|
|
}
|
|
const typeNodes = mapToTypeNodes(types, context, true);
|
|
if (typeNodes && typeNodes.length > 0) {
|
|
return type.flags & 1048576 /* Union */ ? factory.createUnionTypeNode(typeNodes) : factory.createIntersectionTypeNode(typeNodes);
|
|
} else {
|
|
if (!context.encounteredError && !(context.flags & 262144 /* AllowEmptyUnionOrIntersection */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
if (objectFlags & (16 /* Anonymous */ | 32 /* Mapped */)) {
|
|
Debug.assert(!!(type.flags & 524288 /* Object */));
|
|
return createAnonymousTypeNode(type);
|
|
}
|
|
if (type.flags & 4194304 /* Index */) {
|
|
const indexedType = type.type;
|
|
context.approximateLength += 6;
|
|
const indexTypeNode = typeToTypeNodeHelper(indexedType, context);
|
|
return factory.createTypeOperatorNode(141 /* KeyOfKeyword */, indexTypeNode);
|
|
}
|
|
if (type.flags & 134217728 /* TemplateLiteral */) {
|
|
const texts = type.texts;
|
|
const types = type.types;
|
|
const templateHead = factory.createTemplateHead(texts[0]);
|
|
const templateSpans = factory.createNodeArray(
|
|
map(types, (t, i) => factory.createTemplateLiteralTypeSpan(
|
|
typeToTypeNodeHelper(t, context),
|
|
(i < types.length - 1 ? factory.createTemplateMiddle : factory.createTemplateTail)(texts[i + 1])
|
|
))
|
|
);
|
|
context.approximateLength += 2;
|
|
return factory.createTemplateLiteralType(templateHead, templateSpans);
|
|
}
|
|
if (type.flags & 268435456 /* StringMapping */) {
|
|
const typeNode = typeToTypeNodeHelper(type.type, context);
|
|
return symbolToTypeNode(type.symbol, context, 788968 /* Type */, [typeNode]);
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
const objectTypeNode = typeToTypeNodeHelper(type.objectType, context);
|
|
const indexTypeNode = typeToTypeNodeHelper(type.indexType, context);
|
|
context.approximateLength += 2;
|
|
return factory.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode);
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
|
|
}
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
return typeToTypeNodeHelper(type.baseType, context);
|
|
}
|
|
return Debug.fail("Should be unreachable.");
|
|
function conditionalTypeToTypeNode(type2) {
|
|
const checkTypeNode = typeToTypeNodeHelper(type2.checkType, context);
|
|
context.approximateLength += 15;
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && type2.root.isDistributive && !(type2.checkType.flags & 262144 /* TypeParameter */)) {
|
|
const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
|
|
const name = typeParameterToName(newParam, context);
|
|
const newTypeVariable = factory.createTypeReferenceNode(name);
|
|
context.approximateLength += 37;
|
|
const newMapper = prependTypeMapping(type2.root.checkType, newParam, type2.mapper);
|
|
const saveInferTypeParameters2 = context.inferTypeParameters;
|
|
context.inferTypeParameters = type2.root.inferTypeParameters;
|
|
const extendsTypeNode2 = typeToTypeNodeHelper(instantiateType(type2.root.extendsType, newMapper), context);
|
|
context.inferTypeParameters = saveInferTypeParameters2;
|
|
const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.trueType), newMapper));
|
|
const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.falseType), newMapper));
|
|
return factory.createConditionalTypeNode(
|
|
checkTypeNode,
|
|
factory.createInferTypeNode(factory.createTypeParameterDeclaration(void 0, factory.cloneNode(newTypeVariable.typeName))),
|
|
factory.createConditionalTypeNode(
|
|
factory.createTypeReferenceNode(factory.cloneNode(name)),
|
|
typeToTypeNodeHelper(type2.checkType, context),
|
|
factory.createConditionalTypeNode(newTypeVariable, extendsTypeNode2, trueTypeNode2, falseTypeNode2),
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
),
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
);
|
|
}
|
|
const saveInferTypeParameters = context.inferTypeParameters;
|
|
context.inferTypeParameters = type2.root.inferTypeParameters;
|
|
const extendsTypeNode = typeToTypeNodeHelper(type2.extendsType, context);
|
|
context.inferTypeParameters = saveInferTypeParameters;
|
|
const trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type2));
|
|
const falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type2));
|
|
return factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode);
|
|
}
|
|
function typeToTypeNodeOrCircularityElision(type2) {
|
|
var _a2, _b, _c;
|
|
if (type2.flags & 1048576 /* Union */) {
|
|
if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(getTypeId(type2))) {
|
|
if (!(context.flags & 131072 /* AllowAnonymousIdentifier */)) {
|
|
context.encounteredError = true;
|
|
(_c = (_b = context.tracker) == null ? void 0 : _b.reportCyclicStructureError) == null ? void 0 : _c.call(_b);
|
|
}
|
|
return createElidedInformationPlaceholder(context);
|
|
}
|
|
return visitAndTransformType(type2, (type3) => typeToTypeNodeHelper(type3, context));
|
|
}
|
|
return typeToTypeNodeHelper(type2, context);
|
|
}
|
|
function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) {
|
|
return isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 262144 /* TypeParameter */);
|
|
}
|
|
function createMappedTypeNodeFromType(type2) {
|
|
Debug.assert(!!(type2.flags & 524288 /* Object */));
|
|
const readonlyToken = type2.declaration.readonlyToken ? factory.createToken(type2.declaration.readonlyToken.kind) : void 0;
|
|
const questionToken = type2.declaration.questionToken ? factory.createToken(type2.declaration.questionToken.kind) : void 0;
|
|
let appropriateConstraintTypeNode;
|
|
let newTypeVariable;
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type2)) {
|
|
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
|
|
const name = typeParameterToName(newParam, context);
|
|
newTypeVariable = factory.createTypeReferenceNode(name);
|
|
}
|
|
appropriateConstraintTypeNode = factory.createTypeOperatorNode(141 /* KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context));
|
|
} else {
|
|
appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type2), context);
|
|
}
|
|
const typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type2), context, appropriateConstraintTypeNode);
|
|
const nameTypeNode = type2.declaration.nameType ? typeToTypeNodeHelper(getNameTypeFromMappedType(type2), context) : void 0;
|
|
const templateTypeNode = typeToTypeNodeHelper(removeMissingType(getTemplateTypeFromMappedType(type2), !!(getMappedTypeModifiers(type2) & 4 /* IncludeOptional */)), context);
|
|
const mappedTypeNode = factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, void 0);
|
|
context.approximateLength += 10;
|
|
const result = setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
|
|
if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
|
|
return factory.createConditionalTypeNode(
|
|
typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context),
|
|
factory.createInferTypeNode(factory.createTypeParameterDeclaration(void 0, factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* Unknown */ ? void 0 : typeToTypeNodeHelper(originalConstraint, context))),
|
|
result,
|
|
factory.createKeywordTypeNode(144 /* NeverKeyword */)
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
function createAnonymousTypeNode(type2) {
|
|
var _a2;
|
|
const typeId = type2.id;
|
|
const symbol = type2.symbol;
|
|
if (symbol) {
|
|
const isInstanceType = isClassInstanceSide(type2) ? 788968 /* Type */ : 111551 /* Value */;
|
|
if (isJSConstructor(symbol.valueDeclaration)) {
|
|
return symbolToTypeNode(symbol, context, isInstanceType);
|
|
} else if (symbol.flags & 32 /* Class */ && !getBaseTypeVariableOfClass(symbol) && !(symbol.valueDeclaration && isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && (!isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(symbol, context.enclosingDeclaration, isInstanceType, false).accessibility !== 0 /* Accessible */)) || symbol.flags & (384 /* Enum */ | 512 /* ValueModule */) || shouldWriteTypeOfFunctionSymbol()) {
|
|
return symbolToTypeNode(symbol, context, isInstanceType);
|
|
} else if ((_a2 = context.visitedTypes) == null ? void 0 : _a2.has(typeId)) {
|
|
const typeAlias = getTypeAliasForTypeLiteral(type2);
|
|
if (typeAlias) {
|
|
return symbolToTypeNode(typeAlias, context, 788968 /* Type */);
|
|
} else {
|
|
return createElidedInformationPlaceholder(context);
|
|
}
|
|
} else {
|
|
return visitAndTransformType(type2, createTypeNodeFromObjectType);
|
|
}
|
|
} else {
|
|
return createTypeNodeFromObjectType(type2);
|
|
}
|
|
function shouldWriteTypeOfFunctionSymbol() {
|
|
var _a3;
|
|
const isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */) && some(symbol.declarations, (declaration) => isStatic(declaration));
|
|
const isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* Function */) && (symbol.parent || forEach(symbol.declarations, (declaration) => declaration.parent.kind === 308 /* SourceFile */ || declaration.parent.kind === 265 /* ModuleBlock */));
|
|
if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
|
|
return (!!(context.flags & 4096 /* UseTypeOfFunction */) || ((_a3 = context.visitedTypes) == null ? void 0 : _a3.has(typeId))) && (!(context.flags & 8 /* UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration));
|
|
}
|
|
}
|
|
}
|
|
function visitAndTransformType(type2, transform2) {
|
|
var _a2, _b;
|
|
const typeId = type2.id;
|
|
const isConstructorObject = getObjectFlags(type2) & 16 /* Anonymous */ && type2.symbol && type2.symbol.flags & 32 /* Class */;
|
|
const id = getObjectFlags(type2) & 4 /* Reference */ && type2.node ? "N" + getNodeId(type2.node) : type2.flags & 16777216 /* Conditional */ ? "N" + getNodeId(type2.root.node) : type2.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type2.symbol) : void 0;
|
|
if (!context.visitedTypes) {
|
|
context.visitedTypes = /* @__PURE__ */ new Set();
|
|
}
|
|
if (id && !context.symbolDepth) {
|
|
context.symbolDepth = /* @__PURE__ */ new Map();
|
|
}
|
|
const links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration);
|
|
const key = `${getTypeId(type2)}|${context.flags}`;
|
|
if (links) {
|
|
links.serializedTypes || (links.serializedTypes = /* @__PURE__ */ new Map());
|
|
}
|
|
const cachedResult = (_a2 = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _a2.get(key);
|
|
if (cachedResult) {
|
|
if (cachedResult.truncating) {
|
|
context.truncating = true;
|
|
}
|
|
context.approximateLength += cachedResult.addedLength;
|
|
return deepCloneOrReuseNode(cachedResult);
|
|
}
|
|
let depth;
|
|
if (id) {
|
|
depth = context.symbolDepth.get(id) || 0;
|
|
if (depth > 10) {
|
|
return createElidedInformationPlaceholder(context);
|
|
}
|
|
context.symbolDepth.set(id, depth + 1);
|
|
}
|
|
context.visitedTypes.add(typeId);
|
|
const startLength = context.approximateLength;
|
|
const result = transform2(type2);
|
|
const addedLength = context.approximateLength - startLength;
|
|
if (!context.reportedDiagnostic && !context.encounteredError) {
|
|
if (context.truncating) {
|
|
result.truncating = true;
|
|
}
|
|
result.addedLength = addedLength;
|
|
(_b = links == null ? void 0 : links.serializedTypes) == null ? void 0 : _b.set(key, result);
|
|
}
|
|
context.visitedTypes.delete(typeId);
|
|
if (id) {
|
|
context.symbolDepth.set(id, depth);
|
|
}
|
|
return result;
|
|
function deepCloneOrReuseNode(node) {
|
|
if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
|
|
return node;
|
|
}
|
|
return setTextRange(factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, nullTransformationContext, deepCloneOrReuseNodes)), node);
|
|
}
|
|
function deepCloneOrReuseNodes(nodes, visitor, test, start2, count) {
|
|
if (nodes && nodes.length === 0) {
|
|
return setTextRange(factory.createNodeArray(void 0, nodes.hasTrailingComma), nodes);
|
|
}
|
|
return visitNodes2(nodes, visitor, test, start2, count);
|
|
}
|
|
}
|
|
function createTypeNodeFromObjectType(type2) {
|
|
if (isGenericMappedType(type2) || type2.containsError) {
|
|
return createMappedTypeNodeFromType(type2);
|
|
}
|
|
const resolved = resolveStructuredTypeMembers(type2);
|
|
if (!resolved.properties.length && !resolved.indexInfos.length) {
|
|
if (!resolved.callSignatures.length && !resolved.constructSignatures.length) {
|
|
context.approximateLength += 2;
|
|
return setEmitFlags(factory.createTypeLiteralNode(void 0), 1 /* SingleLine */);
|
|
}
|
|
if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
|
|
const signature = resolved.callSignatures[0];
|
|
const signatureNode = signatureToSignatureDeclarationHelper(signature, 181 /* FunctionType */, context);
|
|
return signatureNode;
|
|
}
|
|
if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
|
|
const signature = resolved.constructSignatures[0];
|
|
const signatureNode = signatureToSignatureDeclarationHelper(signature, 182 /* ConstructorType */, context);
|
|
return signatureNode;
|
|
}
|
|
}
|
|
const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
|
|
if (some(abstractSignatures)) {
|
|
const types = map(abstractSignatures, getOrCreateTypeFromSignature);
|
|
const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
|
|
if (typeElementCount) {
|
|
types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved));
|
|
}
|
|
return typeToTypeNodeHelper(getIntersectionType(types), context);
|
|
}
|
|
const savedFlags = context.flags;
|
|
context.flags |= 4194304 /* InObjectTypeLiteral */;
|
|
const members = createTypeNodesFromResolvedType(resolved);
|
|
context.flags = savedFlags;
|
|
const typeLiteralNode = factory.createTypeLiteralNode(members);
|
|
context.approximateLength += 2;
|
|
setEmitFlags(typeLiteralNode, context.flags & 1024 /* MultilineObjectLiterals */ ? 0 : 1 /* SingleLine */);
|
|
return typeLiteralNode;
|
|
}
|
|
function typeReferenceToTypeNode(type2) {
|
|
let typeArguments = getTypeArguments(type2);
|
|
if (type2.target === globalArrayType || type2.target === globalReadonlyArrayType) {
|
|
if (context.flags & 2 /* WriteArrayAsGenericType */) {
|
|
const typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context);
|
|
return factory.createTypeReferenceNode(type2.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]);
|
|
}
|
|
const elementType = typeToTypeNodeHelper(typeArguments[0], context);
|
|
const arrayType = factory.createArrayTypeNode(elementType);
|
|
return type2.target === globalArrayType ? arrayType : factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, arrayType);
|
|
} else if (type2.target.objectFlags & 8 /* Tuple */) {
|
|
typeArguments = sameMap(typeArguments, (t, i) => removeMissingType(t, !!(type2.target.elementFlags[i] & 2 /* Optional */)));
|
|
if (typeArguments.length > 0) {
|
|
const arity = getTypeReferenceArity(type2);
|
|
const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
|
|
if (tupleConstituentNodes) {
|
|
if (type2.target.labeledElementDeclarations) {
|
|
for (let i = 0; i < tupleConstituentNodes.length; i++) {
|
|
const flags = type2.target.elementFlags[i];
|
|
tupleConstituentNodes[i] = factory.createNamedTupleMember(
|
|
flags & 12 /* Variable */ ? factory.createToken(25 /* DotDotDotToken */) : void 0,
|
|
factory.createIdentifier(unescapeLeadingUnderscores(getTupleElementLabel(type2.target.labeledElementDeclarations[i]))),
|
|
flags & 2 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]
|
|
);
|
|
}
|
|
} else {
|
|
for (let i = 0; i < Math.min(arity, tupleConstituentNodes.length); i++) {
|
|
const flags = type2.target.elementFlags[i];
|
|
tupleConstituentNodes[i] = flags & 12 /* Variable */ ? factory.createRestTypeNode(flags & 4 /* Rest */ ? factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) : flags & 2 /* Optional */ ? factory.createOptionalTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i];
|
|
}
|
|
}
|
|
const tupleTypeNode = setEmitFlags(factory.createTupleTypeNode(tupleConstituentNodes), 1 /* SingleLine */);
|
|
return type2.target.readonly ? factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode;
|
|
}
|
|
}
|
|
if (context.encounteredError || context.flags & 524288 /* AllowEmptyTuple */) {
|
|
const tupleTypeNode = setEmitFlags(factory.createTupleTypeNode([]), 1 /* SingleLine */);
|
|
return type2.target.readonly ? factory.createTypeOperatorNode(146 /* ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode;
|
|
}
|
|
context.encounteredError = true;
|
|
return void 0;
|
|
} else if (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ && type2.symbol.valueDeclaration && isClassLike(type2.symbol.valueDeclaration) && !isValueSymbolAccessible(type2.symbol, context.enclosingDeclaration)) {
|
|
return createAnonymousTypeNode(type2);
|
|
} else {
|
|
const outerTypeParameters = type2.target.outerTypeParameters;
|
|
let i = 0;
|
|
let resultType;
|
|
if (outerTypeParameters) {
|
|
const length2 = outerTypeParameters.length;
|
|
while (i < length2) {
|
|
const start2 = i;
|
|
const parent2 = getParentSymbolOfTypeParameter(outerTypeParameters[i]);
|
|
do {
|
|
i++;
|
|
} while (i < length2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent2);
|
|
if (!rangeEquals(outerTypeParameters, typeArguments, start2, i)) {
|
|
const typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start2, i), context);
|
|
const flags2 = context.flags;
|
|
context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
|
|
const ref = symbolToTypeNode(parent2, context, 788968 /* Type */, typeArgumentSlice);
|
|
context.flags = flags2;
|
|
resultType = !resultType ? ref : appendReferenceToType(resultType, ref);
|
|
}
|
|
}
|
|
}
|
|
let typeArgumentNodes;
|
|
if (typeArguments.length > 0) {
|
|
const typeParameterCount = (type2.target.typeParameters || emptyArray).length;
|
|
typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context);
|
|
}
|
|
const flags = context.flags;
|
|
context.flags |= 16 /* ForbidIndexedAccessSymbolReferences */;
|
|
const finalRef = symbolToTypeNode(type2.symbol, context, 788968 /* Type */, typeArgumentNodes);
|
|
context.flags = flags;
|
|
return !resultType ? finalRef : appendReferenceToType(resultType, finalRef);
|
|
}
|
|
}
|
|
function appendReferenceToType(root, ref) {
|
|
if (isImportTypeNode(root)) {
|
|
let typeArguments = root.typeArguments;
|
|
let qualifier = root.qualifier;
|
|
if (qualifier) {
|
|
if (isIdentifier(qualifier)) {
|
|
qualifier = factory.updateIdentifier(qualifier, typeArguments);
|
|
} else {
|
|
qualifier = factory.updateQualifiedName(
|
|
qualifier,
|
|
qualifier.left,
|
|
factory.updateIdentifier(qualifier.right, typeArguments)
|
|
);
|
|
}
|
|
}
|
|
typeArguments = ref.typeArguments;
|
|
const ids = getAccessStack(ref);
|
|
for (const id of ids) {
|
|
qualifier = qualifier ? factory.createQualifiedName(qualifier, id) : id;
|
|
}
|
|
return factory.updateImportTypeNode(
|
|
root,
|
|
root.argument,
|
|
root.assertions,
|
|
qualifier,
|
|
typeArguments,
|
|
root.isTypeOf
|
|
);
|
|
} else {
|
|
let typeArguments = root.typeArguments;
|
|
let typeName = root.typeName;
|
|
if (isIdentifier(typeName)) {
|
|
typeName = factory.updateIdentifier(typeName, typeArguments);
|
|
} else {
|
|
typeName = factory.updateQualifiedName(
|
|
typeName,
|
|
typeName.left,
|
|
factory.updateIdentifier(typeName.right, typeArguments)
|
|
);
|
|
}
|
|
typeArguments = ref.typeArguments;
|
|
const ids = getAccessStack(ref);
|
|
for (const id of ids) {
|
|
typeName = factory.createQualifiedName(typeName, id);
|
|
}
|
|
return factory.updateTypeReferenceNode(
|
|
root,
|
|
typeName,
|
|
typeArguments
|
|
);
|
|
}
|
|
}
|
|
function getAccessStack(ref) {
|
|
let state = ref.typeName;
|
|
const ids = [];
|
|
while (!isIdentifier(state)) {
|
|
ids.unshift(state.right);
|
|
state = state.left;
|
|
}
|
|
ids.unshift(state);
|
|
return ids;
|
|
}
|
|
function createTypeNodesFromResolvedType(resolvedType) {
|
|
if (checkTruncationLength(context)) {
|
|
return [factory.createPropertySignature(void 0, "...", void 0, void 0)];
|
|
}
|
|
const typeElements = [];
|
|
for (const signature of resolvedType.callSignatures) {
|
|
typeElements.push(signatureToSignatureDeclarationHelper(signature, 176 /* CallSignature */, context));
|
|
}
|
|
for (const signature of resolvedType.constructSignatures) {
|
|
if (signature.flags & 4 /* Abstract */)
|
|
continue;
|
|
typeElements.push(signatureToSignatureDeclarationHelper(signature, 177 /* ConstructSignature */, context));
|
|
}
|
|
for (const info of resolvedType.indexInfos) {
|
|
typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 1024 /* ReverseMapped */ ? createElidedInformationPlaceholder(context) : void 0));
|
|
}
|
|
const properties = resolvedType.properties;
|
|
if (!properties) {
|
|
return typeElements;
|
|
}
|
|
let i = 0;
|
|
for (const propertySymbol of properties) {
|
|
i++;
|
|
if (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */) {
|
|
if (propertySymbol.flags & 4194304 /* Prototype */) {
|
|
continue;
|
|
}
|
|
if (getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 /* Private */ | 16 /* Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) {
|
|
context.tracker.reportPrivateInBaseOfClassExpression(unescapeLeadingUnderscores(propertySymbol.escapedName));
|
|
}
|
|
}
|
|
if (checkTruncationLength(context) && i + 2 < properties.length - 1) {
|
|
typeElements.push(factory.createPropertySignature(void 0, `... ${properties.length - i} more ...`, void 0, void 0));
|
|
addPropertyToElementList(properties[properties.length - 1], context, typeElements);
|
|
break;
|
|
}
|
|
addPropertyToElementList(propertySymbol, context, typeElements);
|
|
}
|
|
return typeElements.length ? typeElements : void 0;
|
|
}
|
|
}
|
|
function createElidedInformationPlaceholder(context) {
|
|
context.approximateLength += 3;
|
|
if (!(context.flags & 1 /* NoTruncation */)) {
|
|
return factory.createTypeReferenceNode(factory.createIdentifier("..."), void 0);
|
|
}
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
function shouldUsePlaceholderForProperty(propertySymbol, context) {
|
|
var _a2;
|
|
return !!(getCheckFlags(propertySymbol) & 8192 /* ReverseMapped */) && (contains(context.reverseMappedStack, propertySymbol) || ((_a2 = context.reverseMappedStack) == null ? void 0 : _a2[0]) && !(getObjectFlags(last(context.reverseMappedStack).propertyType) & 16 /* Anonymous */));
|
|
}
|
|
function addPropertyToElementList(propertySymbol, context, typeElements) {
|
|
var _a2, _b;
|
|
const propertyIsReverseMapped = !!(getCheckFlags(propertySymbol) & 8192 /* ReverseMapped */);
|
|
const propertyType = shouldUsePlaceholderForProperty(propertySymbol, context) ? anyType : getNonMissingTypeOfSymbol(propertySymbol);
|
|
const saveEnclosingDeclaration = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = void 0;
|
|
if (context.tracker.trackSymbol && isLateBoundName(propertySymbol.escapedName)) {
|
|
if (propertySymbol.declarations) {
|
|
const decl = first(propertySymbol.declarations);
|
|
if (hasLateBindableName(decl)) {
|
|
if (isBinaryExpression(decl)) {
|
|
const name = getNameOfDeclaration(decl);
|
|
if (name && isElementAccessExpression(name) && isPropertyAccessEntityNameExpression(name.argumentExpression)) {
|
|
trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context);
|
|
}
|
|
} else {
|
|
trackComputedName(decl.name.expression, saveEnclosingDeclaration, context);
|
|
}
|
|
}
|
|
} else if ((_a2 = context.tracker) == null ? void 0 : _a2.reportNonSerializableProperty) {
|
|
context.tracker.reportNonSerializableProperty(symbolToString(propertySymbol));
|
|
}
|
|
}
|
|
context.enclosingDeclaration = propertySymbol.valueDeclaration || ((_b = propertySymbol.declarations) == null ? void 0 : _b[0]) || saveEnclosingDeclaration;
|
|
const propertyName = getPropertyNameNodeForSymbol(propertySymbol, context);
|
|
context.enclosingDeclaration = saveEnclosingDeclaration;
|
|
context.approximateLength += symbolName(propertySymbol).length + 1;
|
|
const optionalToken = propertySymbol.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0;
|
|
if (propertySymbol.flags & (16 /* Function */ | 8192 /* Method */) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) {
|
|
const signatures = getSignaturesOfType(filterType(propertyType, (t) => !(t.flags & 32768 /* Undefined */)), 0 /* Call */);
|
|
for (const signature of signatures) {
|
|
const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 170 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
|
|
typeElements.push(preserveCommentsOn(methodDeclaration));
|
|
}
|
|
} else {
|
|
let propertyTypeNode;
|
|
if (shouldUsePlaceholderForProperty(propertySymbol, context)) {
|
|
propertyTypeNode = createElidedInformationPlaceholder(context);
|
|
} else {
|
|
if (propertyIsReverseMapped) {
|
|
context.reverseMappedStack || (context.reverseMappedStack = []);
|
|
context.reverseMappedStack.push(propertySymbol);
|
|
}
|
|
propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
if (propertyIsReverseMapped) {
|
|
context.reverseMappedStack.pop();
|
|
}
|
|
}
|
|
const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(146 /* ReadonlyKeyword */)] : void 0;
|
|
if (modifiers) {
|
|
context.approximateLength += 9;
|
|
}
|
|
const propertySignature = factory.createPropertySignature(
|
|
modifiers,
|
|
propertyName,
|
|
optionalToken,
|
|
propertyTypeNode
|
|
);
|
|
typeElements.push(preserveCommentsOn(propertySignature));
|
|
}
|
|
function preserveCommentsOn(node) {
|
|
var _a3;
|
|
if (some(propertySymbol.declarations, (d) => d.kind === 350 /* JSDocPropertyTag */)) {
|
|
const d = (_a3 = propertySymbol.declarations) == null ? void 0 : _a3.find((d2) => d2.kind === 350 /* JSDocPropertyTag */);
|
|
const commentText = getTextOfJSDocComment(d.comment);
|
|
if (commentText) {
|
|
setSyntheticLeadingComments(node, [{ kind: 3 /* MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
|
|
}
|
|
} else if (propertySymbol.valueDeclaration) {
|
|
setCommentRange(node, propertySymbol.valueDeclaration);
|
|
}
|
|
return node;
|
|
}
|
|
}
|
|
function mapToTypeNodes(types, context, isBareList) {
|
|
if (some(types)) {
|
|
if (checkTruncationLength(context)) {
|
|
if (!isBareList) {
|
|
return [factory.createTypeReferenceNode("...", void 0)];
|
|
} else if (types.length > 2) {
|
|
return [
|
|
typeToTypeNodeHelper(types[0], context),
|
|
factory.createTypeReferenceNode(`... ${types.length - 2} more ...`, void 0),
|
|
typeToTypeNodeHelper(types[types.length - 1], context)
|
|
];
|
|
}
|
|
}
|
|
const mayHaveNameCollisions = !(context.flags & 64 /* UseFullyQualifiedType */);
|
|
const seenNames = mayHaveNameCollisions ? createUnderscoreEscapedMultiMap() : void 0;
|
|
const result = [];
|
|
let i = 0;
|
|
for (const type of types) {
|
|
i++;
|
|
if (checkTruncationLength(context) && i + 2 < types.length - 1) {
|
|
result.push(factory.createTypeReferenceNode(`... ${types.length - i} more ...`, void 0));
|
|
const typeNode2 = typeToTypeNodeHelper(types[types.length - 1], context);
|
|
if (typeNode2) {
|
|
result.push(typeNode2);
|
|
}
|
|
break;
|
|
}
|
|
context.approximateLength += 2;
|
|
const typeNode = typeToTypeNodeHelper(type, context);
|
|
if (typeNode) {
|
|
result.push(typeNode);
|
|
if (seenNames && isIdentifierTypeReference(typeNode)) {
|
|
seenNames.add(typeNode.typeName.escapedText, [type, result.length - 1]);
|
|
}
|
|
}
|
|
}
|
|
if (seenNames) {
|
|
const saveContextFlags = context.flags;
|
|
context.flags |= 64 /* UseFullyQualifiedType */;
|
|
seenNames.forEach((types2) => {
|
|
if (!arrayIsHomogeneous(types2, ([a], [b]) => typesAreSameReference(a, b))) {
|
|
for (const [type, resultIndex] of types2) {
|
|
result[resultIndex] = typeToTypeNodeHelper(type, context);
|
|
}
|
|
}
|
|
});
|
|
context.flags = saveContextFlags;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function typesAreSameReference(a, b) {
|
|
return a === b || !!a.symbol && a.symbol === b.symbol || !!a.aliasSymbol && a.aliasSymbol === b.aliasSymbol;
|
|
}
|
|
function indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, typeNode) {
|
|
const name = getNameFromIndexInfo(indexInfo) || "x";
|
|
const indexerTypeNode = typeToTypeNodeHelper(indexInfo.keyType, context);
|
|
const indexingParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
indexerTypeNode,
|
|
void 0
|
|
);
|
|
if (!typeNode) {
|
|
typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context);
|
|
}
|
|
if (!indexInfo.type && !(context.flags & 2097152 /* AllowEmptyIndexInfoType */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
context.approximateLength += name.length + 4;
|
|
return factory.createIndexSignature(
|
|
indexInfo.isReadonly ? [factory.createToken(146 /* ReadonlyKeyword */)] : void 0,
|
|
[indexingParameter],
|
|
typeNode
|
|
);
|
|
}
|
|
function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
|
|
var _a2, _b, _c, _d;
|
|
const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
|
|
if (suppressAny)
|
|
context.flags &= ~256 /* SuppressAnyReturnType */;
|
|
context.approximateLength += 3;
|
|
let typeParameters;
|
|
let typeArguments;
|
|
if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
|
|
typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
|
|
} else {
|
|
typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
|
|
}
|
|
const expandedParams = getExpandedParameters(signature, true)[0];
|
|
const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 173 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
|
|
const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
|
|
if (thisParameter) {
|
|
parameters.unshift(thisParameter);
|
|
}
|
|
let returnTypeNode;
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (typePredicate) {
|
|
const assertsModifier = typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(129 /* AssertsKeyword */) : void 0;
|
|
const parameterName = typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? setEmitFlags(factory.createIdentifier(typePredicate.parameterName), 33554432 /* NoAsciiEscaping */) : factory.createThisTypeNode();
|
|
const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
|
|
returnTypeNode = factory.createTypePredicateNode(assertsModifier, parameterName, typeNode);
|
|
} else {
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType && !(suppressAny && isTypeAny(returnType))) {
|
|
returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
|
|
} else if (!suppressAny) {
|
|
returnTypeNode = factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
}
|
|
let modifiers = options == null ? void 0 : options.modifiers;
|
|
if (kind === 182 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
|
|
const flags = modifiersToFlags(modifiers);
|
|
modifiers = factory.createModifiersFromModifierFlags(flags | 256 /* Abstract */);
|
|
}
|
|
const node = kind === 176 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 177 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 170 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (_a2 = options == null ? void 0 : options.name) != null ? _a2 : factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 171 /* MethodDeclaration */ ? factory.createMethodDeclaration(modifiers, void 0, (_b = options == null ? void 0 : options.name) != null ? _b : factory.createIdentifier(""), void 0, typeParameters, parameters, returnTypeNode, void 0) : kind === 173 /* Constructor */ ? factory.createConstructorDeclaration(modifiers, parameters, void 0) : kind === 174 /* GetAccessor */ ? factory.createGetAccessorDeclaration(modifiers, (_c = options == null ? void 0 : options.name) != null ? _c : factory.createIdentifier(""), parameters, returnTypeNode, void 0) : kind === 175 /* SetAccessor */ ? factory.createSetAccessorDeclaration(modifiers, (_d = options == null ? void 0 : options.name) != null ? _d : factory.createIdentifier(""), parameters, void 0) : kind === 178 /* IndexSignature */ ? factory.createIndexSignature(modifiers, parameters, returnTypeNode) : kind === 320 /* JSDocFunctionType */ ? factory.createJSDocFunctionType(parameters, returnTypeNode) : kind === 181 /* FunctionType */ ? factory.createFunctionTypeNode(typeParameters, parameters, returnTypeNode != null ? returnTypeNode : factory.createTypeReferenceNode(factory.createIdentifier(""))) : kind === 182 /* ConstructorType */ ? factory.createConstructorTypeNode(modifiers, typeParameters, parameters, returnTypeNode != null ? returnTypeNode : factory.createTypeReferenceNode(factory.createIdentifier(""))) : kind === 259 /* FunctionDeclaration */ ? factory.createFunctionDeclaration(modifiers, void 0, (options == null ? void 0 : options.name) ? cast(options.name, isIdentifier) : factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, void 0) : kind === 215 /* FunctionExpression */ ? factory.createFunctionExpression(modifiers, void 0, (options == null ? void 0 : options.name) ? cast(options.name, isIdentifier) : factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, factory.createBlock([])) : kind === 216 /* ArrowFunction */ ? factory.createArrowFunction(modifiers, typeParameters, parameters, returnTypeNode, void 0, factory.createBlock([])) : Debug.assertNever(kind);
|
|
if (typeArguments) {
|
|
node.typeArguments = factory.createNodeArray(typeArguments);
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetThisParameterDeclaration(signature, context) {
|
|
if (signature.thisParameter) {
|
|
return symbolToParameterDeclaration(signature.thisParameter, context);
|
|
}
|
|
if (signature.declaration) {
|
|
const thisTag = getJSDocThisTag(signature.declaration);
|
|
if (thisTag && thisTag.typeExpression) {
|
|
return factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"this",
|
|
void 0,
|
|
typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function typeParameterToDeclarationWithConstraint(type, context, constraintNode) {
|
|
const savedContextFlags = context.flags;
|
|
context.flags &= ~512 /* WriteTypeParametersInQualifiedName */;
|
|
const modifiers = factory.createModifiersFromModifierFlags(getVarianceModifiers(type));
|
|
const name = typeParameterToName(type, context);
|
|
const defaultParameter = getDefaultFromTypeParameter(type);
|
|
const defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context);
|
|
context.flags = savedContextFlags;
|
|
return factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode);
|
|
}
|
|
function typeParameterToDeclaration(type, context, constraint = getConstraintOfTypeParameter(type)) {
|
|
const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
|
|
return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
|
|
}
|
|
function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
|
|
let parameterDeclaration = getDeclarationOfKind(parameterSymbol, 166 /* Parameter */);
|
|
if (!parameterDeclaration && !isTransientSymbol(parameterSymbol)) {
|
|
parameterDeclaration = getDeclarationOfKind(parameterSymbol, 343 /* JSDocParameterTag */);
|
|
}
|
|
let parameterType = getTypeOfSymbol(parameterSymbol);
|
|
if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
|
|
parameterType = getOptionalType(parameterType);
|
|
}
|
|
const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
|
|
const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
|
|
const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
|
|
const dotDotDotToken = isRest ? factory.createToken(25 /* DotDotDotToken */) : void 0;
|
|
const name = parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 79 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 33554432 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 163 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 33554432 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
|
|
const isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 16384 /* OptionalParameter */;
|
|
const questionToken = isOptional ? factory.createToken(57 /* QuestionToken */) : void 0;
|
|
const parameterNode = factory.createParameterDeclaration(
|
|
modifiers,
|
|
dotDotDotToken,
|
|
name,
|
|
questionToken,
|
|
parameterTypeNode,
|
|
void 0
|
|
);
|
|
context.approximateLength += symbolName(parameterSymbol).length + 3;
|
|
return parameterNode;
|
|
function cloneBindingName(node) {
|
|
return elideInitializerAndSetEmitFlags(node);
|
|
function elideInitializerAndSetEmitFlags(node2) {
|
|
if (context.tracker.trackSymbol && isComputedPropertyName(node2) && isLateBindableName(node2)) {
|
|
trackComputedName(node2.expression, context.enclosingDeclaration, context);
|
|
}
|
|
let visited = visitEachChild(node2, elideInitializerAndSetEmitFlags, nullTransformationContext, void 0, elideInitializerAndSetEmitFlags);
|
|
if (isBindingElement(visited)) {
|
|
visited = factory.updateBindingElement(
|
|
visited,
|
|
visited.dotDotDotToken,
|
|
visited.propertyName,
|
|
visited.name,
|
|
void 0
|
|
);
|
|
}
|
|
if (!nodeIsSynthesized(visited)) {
|
|
visited = factory.cloneNode(visited);
|
|
}
|
|
return setEmitFlags(visited, 1 /* SingleLine */ | 33554432 /* NoAsciiEscaping */);
|
|
}
|
|
}
|
|
}
|
|
function trackComputedName(accessExpression, enclosingDeclaration, context) {
|
|
if (!context.tracker.trackSymbol)
|
|
return;
|
|
const firstIdentifier = getFirstIdentifier(accessExpression);
|
|
const name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 /* Value */ | 1048576 /* ExportValue */, void 0, void 0, true);
|
|
if (name) {
|
|
context.tracker.trackSymbol(name, enclosingDeclaration, 111551 /* Value */);
|
|
}
|
|
}
|
|
function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) {
|
|
context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning);
|
|
return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol);
|
|
}
|
|
function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) {
|
|
let chain;
|
|
const isTypeParameter = symbol.flags & 262144 /* TypeParameter */;
|
|
if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* UseFullyQualifiedType */) && !(context.flags & 134217728 /* DoNotIncludeSymbolChain */)) {
|
|
chain = Debug.checkDefined(getSymbolChain(symbol, meaning, true));
|
|
Debug.assert(chain && chain.length > 0);
|
|
} else {
|
|
chain = [symbol];
|
|
}
|
|
return chain;
|
|
function getSymbolChain(symbol2, meaning2, endOfChain) {
|
|
let accessibleSymbolChain = getAccessibleSymbolChain(symbol2, context.enclosingDeclaration, meaning2, !!(context.flags & 128 /* UseOnlyExternalAliasing */));
|
|
let parentSpecifiers;
|
|
if (!accessibleSymbolChain || needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning2 : getQualifiedLeftMeaning(meaning2))) {
|
|
const parents = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol2, context.enclosingDeclaration, meaning2);
|
|
if (length(parents)) {
|
|
parentSpecifiers = parents.map((symbol3) => some(symbol3.declarations, hasNonGlobalAugmentationExternalModuleSymbol) ? getSpecifierForModuleSymbol(symbol3, context) : void 0);
|
|
const indices = parents.map((_, i) => i);
|
|
indices.sort(sortByBestName);
|
|
const sortedParents = indices.map((i) => parents[i]);
|
|
for (const parent2 of sortedParents) {
|
|
const parentChain = getSymbolChain(parent2, getQualifiedLeftMeaning(meaning2), false);
|
|
if (parentChain) {
|
|
if (parent2.exports && parent2.exports.get("export=" /* ExportEquals */) && getSymbolIfSameReference(parent2.exports.get("export=" /* ExportEquals */), symbol2)) {
|
|
accessibleSymbolChain = parentChain;
|
|
break;
|
|
}
|
|
accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent2, symbol2) || symbol2]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (accessibleSymbolChain) {
|
|
return accessibleSymbolChain;
|
|
}
|
|
if (endOfChain || !(symbol2.flags & (2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */))) {
|
|
if (!endOfChain && !yieldModuleSymbol && !!forEach(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
return;
|
|
}
|
|
return [symbol2];
|
|
}
|
|
function sortByBestName(a, b) {
|
|
const specifierA = parentSpecifiers[a];
|
|
const specifierB = parentSpecifiers[b];
|
|
if (specifierA && specifierB) {
|
|
const isBRelative = pathIsRelative(specifierB);
|
|
if (pathIsRelative(specifierA) === isBRelative) {
|
|
return countPathComponents(specifierA) - countPathComponents(specifierB);
|
|
}
|
|
if (isBRelative) {
|
|
return -1;
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
function typeParametersToTypeParameterDeclarations(symbol, context) {
|
|
let typeParameterNodes;
|
|
const targetSymbol = getTargetSymbol(symbol);
|
|
if (targetSymbol.flags & (32 /* Class */ | 64 /* Interface */ | 524288 /* TypeAlias */)) {
|
|
typeParameterNodes = factory.createNodeArray(map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), (tp) => typeParameterToDeclaration(tp, context)));
|
|
}
|
|
return typeParameterNodes;
|
|
}
|
|
function lookupTypeParameterNodes(chain, index, context) {
|
|
var _a2;
|
|
Debug.assert(chain && 0 <= index && index < chain.length);
|
|
const symbol = chain[index];
|
|
const symbolId = getSymbolId(symbol);
|
|
if ((_a2 = context.typeParameterSymbolList) == null ? void 0 : _a2.has(symbolId)) {
|
|
return void 0;
|
|
}
|
|
(context.typeParameterSymbolList || (context.typeParameterSymbolList = /* @__PURE__ */ new Set())).add(symbolId);
|
|
let typeParameterNodes;
|
|
if (context.flags & 512 /* WriteTypeParametersInQualifiedName */ && index < chain.length - 1) {
|
|
const parentSymbol = symbol;
|
|
const nextSymbol = chain[index + 1];
|
|
if (getCheckFlags(nextSymbol) & 1 /* Instantiated */) {
|
|
const params = getTypeParametersOfClassOrInterface(
|
|
parentSymbol.flags & 2097152 /* Alias */ ? resolveAlias(parentSymbol) : parentSymbol
|
|
);
|
|
typeParameterNodes = mapToTypeNodes(map(params, (t) => getMappedType(t, nextSymbol.mapper)), context);
|
|
} else {
|
|
typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context);
|
|
}
|
|
}
|
|
return typeParameterNodes;
|
|
}
|
|
function getTopmostIndexedAccessType(top) {
|
|
if (isIndexedAccessTypeNode(top.objectType)) {
|
|
return getTopmostIndexedAccessType(top.objectType);
|
|
}
|
|
return top;
|
|
}
|
|
function getSpecifierForModuleSymbol(symbol, context, overrideImportMode) {
|
|
var _a2;
|
|
let file = getDeclarationOfKind(symbol, 308 /* SourceFile */);
|
|
if (!file) {
|
|
const equivalentFileSymbol = firstDefined(symbol.declarations, (d) => getFileSymbolIfFileSymbolExportEqualsContainer(d, symbol));
|
|
if (equivalentFileSymbol) {
|
|
file = getDeclarationOfKind(equivalentFileSymbol, 308 /* SourceFile */);
|
|
}
|
|
}
|
|
if (file && file.moduleName !== void 0) {
|
|
return file.moduleName;
|
|
}
|
|
if (!file) {
|
|
if (context.tracker.trackReferencedAmbientModule) {
|
|
const ambientDecls = filter(symbol.declarations, isAmbientModule);
|
|
if (length(ambientDecls)) {
|
|
for (const decl of ambientDecls) {
|
|
context.tracker.trackReferencedAmbientModule(decl, symbol);
|
|
}
|
|
}
|
|
}
|
|
if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
|
|
return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
|
|
}
|
|
}
|
|
if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) {
|
|
if (ambientModuleSymbolRegex.test(symbol.escapedName)) {
|
|
return symbol.escapedName.substring(1, symbol.escapedName.length - 1);
|
|
}
|
|
return getSourceFileOfNode(getNonAugmentationDeclaration(symbol)).fileName;
|
|
}
|
|
const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration));
|
|
const resolutionMode = overrideImportMode || (contextFile == null ? void 0 : contextFile.impliedNodeFormat);
|
|
const cacheKey = getSpecifierCacheKey(contextFile.path, resolutionMode);
|
|
const links = getSymbolLinks(symbol);
|
|
let specifier = links.specifierCache && links.specifierCache.get(cacheKey);
|
|
if (!specifier) {
|
|
const isBundle2 = !!outFile(compilerOptions);
|
|
const { moduleResolverHost } = context.tracker;
|
|
const specifierCompilerOptions = isBundle2 ? { ...compilerOptions, baseUrl: moduleResolverHost.getCommonSourceDirectory() } : compilerOptions;
|
|
specifier = first(getModuleSpecifiers(
|
|
symbol,
|
|
checker,
|
|
specifierCompilerOptions,
|
|
contextFile,
|
|
moduleResolverHost,
|
|
{
|
|
importModuleSpecifierPreference: isBundle2 ? "non-relative" : "project-relative",
|
|
importModuleSpecifierEnding: isBundle2 ? "minimal" : resolutionMode === 99 /* ESNext */ ? "js" : void 0
|
|
},
|
|
{ overrideImportMode }
|
|
));
|
|
(_a2 = links.specifierCache) != null ? _a2 : links.specifierCache = /* @__PURE__ */ new Map();
|
|
links.specifierCache.set(cacheKey, specifier);
|
|
}
|
|
return specifier;
|
|
function getSpecifierCacheKey(path, mode) {
|
|
return mode === void 0 ? path : `${mode}|${path}`;
|
|
}
|
|
}
|
|
function symbolToEntityNameNode(symbol) {
|
|
const identifier = factory.createIdentifier(unescapeLeadingUnderscores(symbol.escapedName));
|
|
return symbol.parent ? factory.createQualifiedName(symbolToEntityNameNode(symbol.parent), identifier) : identifier;
|
|
}
|
|
function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) {
|
|
var _a2, _b, _c, _d;
|
|
const chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */));
|
|
const isTypeOf = meaning === 111551 /* Value */;
|
|
if (some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
const nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : void 0;
|
|
const typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context);
|
|
const contextFile = getSourceFileOfNode(getOriginalNode(context.enclosingDeclaration));
|
|
const targetFile = getSourceFileOfModule(chain[0]);
|
|
let specifier;
|
|
let assertion;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
if ((targetFile == null ? void 0 : targetFile.impliedNodeFormat) === 99 /* ESNext */ && targetFile.impliedNodeFormat !== (contextFile == null ? void 0 : contextFile.impliedNodeFormat)) {
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context, 99 /* ESNext */);
|
|
assertion = factory.createImportTypeAssertionContainer(factory.createAssertClause(factory.createNodeArray([
|
|
factory.createAssertEntry(
|
|
factory.createStringLiteral("resolution-mode"),
|
|
factory.createStringLiteral("import")
|
|
)
|
|
])));
|
|
(_b = (_a2 = context.tracker).reportImportTypeNodeResolutionModeOverride) == null ? void 0 : _b.call(_a2);
|
|
}
|
|
}
|
|
if (!specifier) {
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context);
|
|
}
|
|
if (!(context.flags & 67108864 /* AllowNodeModulesRelativePaths */) && getEmitModuleResolutionKind(compilerOptions) !== 1 /* Classic */ && specifier.indexOf("/node_modules/") >= 0) {
|
|
const oldSpecifier = specifier;
|
|
if (getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */) {
|
|
const swappedMode = (contextFile == null ? void 0 : contextFile.impliedNodeFormat) === 99 /* ESNext */ ? 1 /* CommonJS */ : 99 /* ESNext */;
|
|
specifier = getSpecifierForModuleSymbol(chain[0], context, swappedMode);
|
|
if (specifier.indexOf("/node_modules/") >= 0) {
|
|
specifier = oldSpecifier;
|
|
} else {
|
|
assertion = factory.createImportTypeAssertionContainer(factory.createAssertClause(factory.createNodeArray([
|
|
factory.createAssertEntry(
|
|
factory.createStringLiteral("resolution-mode"),
|
|
factory.createStringLiteral(swappedMode === 99 /* ESNext */ ? "import" : "require")
|
|
)
|
|
])));
|
|
(_d = (_c = context.tracker).reportImportTypeNodeResolutionModeOverride) == null ? void 0 : _d.call(_c);
|
|
}
|
|
}
|
|
if (!assertion) {
|
|
context.encounteredError = true;
|
|
if (context.tracker.reportLikelyUnsafeImportRequiredError) {
|
|
context.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier);
|
|
}
|
|
}
|
|
}
|
|
const lit = factory.createLiteralTypeNode(factory.createStringLiteral(specifier));
|
|
if (context.tracker.trackExternalModuleSymbolOfImportTypeNode)
|
|
context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]);
|
|
context.approximateLength += specifier.length + 10;
|
|
if (!nonRootParts || isEntityName(nonRootParts)) {
|
|
if (nonRootParts) {
|
|
const lastId = isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right;
|
|
lastId.typeArguments = void 0;
|
|
}
|
|
return factory.createImportTypeNode(lit, assertion, nonRootParts, typeParameterNodes, isTypeOf);
|
|
} else {
|
|
const splitNode = getTopmostIndexedAccessType(nonRootParts);
|
|
const qualifier = splitNode.objectType.typeName;
|
|
return factory.createIndexedAccessTypeNode(factory.createImportTypeNode(lit, assertion, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType);
|
|
}
|
|
}
|
|
const entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0);
|
|
if (isIndexedAccessTypeNode(entityName)) {
|
|
return entityName;
|
|
}
|
|
if (isTypeOf) {
|
|
return factory.createTypeQueryNode(entityName);
|
|
} else {
|
|
const lastId = isIdentifier(entityName) ? entityName : entityName.right;
|
|
const lastTypeArgs = lastId.typeArguments;
|
|
lastId.typeArguments = void 0;
|
|
return factory.createTypeReferenceNode(entityName, lastTypeArgs);
|
|
}
|
|
function createAccessFromSymbolChain(chain2, index, stopper) {
|
|
const typeParameterNodes = index === chain2.length - 1 ? overrideTypeArguments : lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
const parent2 = chain2[index - 1];
|
|
let symbolName2;
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
context.approximateLength += (symbolName2 ? symbolName2.length : 0) + 1;
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
} else {
|
|
if (parent2 && getExportsOfSymbol(parent2)) {
|
|
const exports = getExportsOfSymbol(parent2);
|
|
forEachEntry(exports, (ex, name) => {
|
|
if (getSymbolIfSameReference(ex, symbol2) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
|
|
symbolName2 = unescapeLeadingUnderscores(name);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (symbolName2 === void 0) {
|
|
const name = firstDefined(symbol2.declarations, getNameOfDeclaration);
|
|
if (name && isComputedPropertyName(name) && isEntityName(name.expression)) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (isEntityName(LHS)) {
|
|
return factory.createIndexedAccessTypeNode(factory.createParenthesizedType(factory.createTypeQueryNode(LHS)), factory.createTypeQueryNode(name.expression));
|
|
}
|
|
return LHS;
|
|
}
|
|
symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
}
|
|
context.approximateLength += symbolName2.length + 1;
|
|
if (!(context.flags & 16 /* ForbidIndexedAccessSymbolReferences */) && parent2 && getMembersOfSymbol(parent2) && getMembersOfSymbol(parent2).get(symbol2.escapedName) && getSymbolIfSameReference(getMembersOfSymbol(parent2).get(symbol2.escapedName), symbol2)) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (isIndexedAccessTypeNode(LHS)) {
|
|
return factory.createIndexedAccessTypeNode(LHS, factory.createLiteralTypeNode(factory.createStringLiteral(symbolName2)));
|
|
} else {
|
|
return factory.createIndexedAccessTypeNode(factory.createTypeReferenceNode(LHS, typeParameterNodes), factory.createLiteralTypeNode(factory.createStringLiteral(symbolName2)));
|
|
}
|
|
}
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
if (index > stopper) {
|
|
const LHS = createAccessFromSymbolChain(chain2, index - 1, stopper);
|
|
if (!isEntityName(LHS)) {
|
|
return Debug.fail("Impossible construct - an export of an indexed access cannot be reachable");
|
|
}
|
|
return factory.createQualifiedName(LHS, identifier);
|
|
}
|
|
return identifier;
|
|
}
|
|
}
|
|
function typeParameterShadowsNameInScope(escapedName, context, type) {
|
|
const result = resolveName(context.enclosingDeclaration, escapedName, 788968 /* Type */, void 0, escapedName, false);
|
|
if (result) {
|
|
if (result.flags & 262144 /* TypeParameter */ && result === type.symbol) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function typeParameterToName(type, context) {
|
|
var _a2, _b;
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) {
|
|
const cached = context.typeParameterNames.get(getTypeId(type));
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
}
|
|
let result = symbolToName(type.symbol, context, 788968 /* Type */, true);
|
|
if (!(result.kind & 79 /* Identifier */)) {
|
|
return factory.createIdentifier("(Missing type parameter)");
|
|
}
|
|
if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
|
|
const rawtext = result.escapedText;
|
|
let i = ((_a2 = context.typeParameterNamesByTextNextNameCount) == null ? void 0 : _a2.get(rawtext)) || 0;
|
|
let text = rawtext;
|
|
while (((_b = context.typeParameterNamesByText) == null ? void 0 : _b.has(text)) || typeParameterShadowsNameInScope(text, context, type)) {
|
|
i++;
|
|
text = `${rawtext}_${i}`;
|
|
}
|
|
if (text !== rawtext) {
|
|
result = factory.createIdentifier(text, result.typeArguments);
|
|
}
|
|
(context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
|
|
(context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
|
|
(context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(rawtext);
|
|
}
|
|
return result;
|
|
}
|
|
function symbolToName(symbol, context, meaning, expectsIdentifier) {
|
|
const chain = lookupSymbolChain(symbol, context, meaning);
|
|
if (expectsIdentifier && chain.length !== 1 && !context.encounteredError && !(context.flags & 65536 /* AllowQualifiedNameInPlaceOfIdentifier */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return createEntityNameFromSymbolChain(chain, chain.length - 1);
|
|
function createEntityNameFromSymbolChain(chain2, index) {
|
|
const typeParameterNodes = lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
}
|
|
const symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
if (index === 0) {
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
}
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
return index > 0 ? factory.createQualifiedName(createEntityNameFromSymbolChain(chain2, index - 1), identifier) : identifier;
|
|
}
|
|
}
|
|
function symbolToExpression(symbol, context, meaning) {
|
|
const chain = lookupSymbolChain(symbol, context, meaning);
|
|
return createExpressionFromSymbolChain(chain, chain.length - 1);
|
|
function createExpressionFromSymbolChain(chain2, index) {
|
|
const typeParameterNodes = lookupTypeParameterNodes(chain2, index, context);
|
|
const symbol2 = chain2[index];
|
|
if (index === 0) {
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
}
|
|
let symbolName2 = getNameOfSymbolAsWritten(symbol2, context);
|
|
if (index === 0) {
|
|
context.flags ^= 16777216 /* InInitialEntityName */;
|
|
}
|
|
let firstChar = symbolName2.charCodeAt(0);
|
|
if (isSingleOrDoubleQuote(firstChar) && some(symbol2.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) {
|
|
return factory.createStringLiteral(getSpecifierForModuleSymbol(symbol2, context));
|
|
}
|
|
const canUsePropertyAccess = firstChar === 35 /* hash */ ? symbolName2.length > 1 && isIdentifierStart(symbolName2.charCodeAt(1), languageVersion) : isIdentifierStart(firstChar, languageVersion);
|
|
if (index === 0 || canUsePropertyAccess) {
|
|
const identifier = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
identifier.symbol = symbol2;
|
|
return index > 0 ? factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), identifier) : identifier;
|
|
} else {
|
|
if (firstChar === 91 /* openBracket */) {
|
|
symbolName2 = symbolName2.substring(1, symbolName2.length - 1);
|
|
firstChar = symbolName2.charCodeAt(0);
|
|
}
|
|
let expression;
|
|
if (isSingleOrDoubleQuote(firstChar) && !(symbol2.flags & 8 /* EnumMember */)) {
|
|
expression = factory.createStringLiteral(stripQuotes(symbolName2).replace(/\\./g, (s) => s.substring(1)), firstChar === 39 /* singleQuote */);
|
|
} else if ("" + +symbolName2 === symbolName2) {
|
|
expression = factory.createNumericLiteral(+symbolName2);
|
|
}
|
|
if (!expression) {
|
|
expression = setEmitFlags(factory.createIdentifier(symbolName2, typeParameterNodes), 33554432 /* NoAsciiEscaping */);
|
|
expression.symbol = symbol2;
|
|
}
|
|
return factory.createElementAccessExpression(createExpressionFromSymbolChain(chain2, index - 1), expression);
|
|
}
|
|
}
|
|
}
|
|
function isStringNamed(d) {
|
|
const name = getNameOfDeclaration(d);
|
|
return !!name && isStringLiteral(name);
|
|
}
|
|
function isSingleQuotedStringNamed(d) {
|
|
const name = getNameOfDeclaration(d);
|
|
return !!(name && isStringLiteral(name) && (name.singleQuote || !nodeIsSynthesized(name) && startsWith(getTextOfNode(name, false), "'")));
|
|
}
|
|
function getPropertyNameNodeForSymbol(symbol, context) {
|
|
const stringNamed = !!length(symbol.declarations) && every(symbol.declarations, isStringNamed);
|
|
const singleQuote = !!length(symbol.declarations) && every(symbol.declarations, isSingleQuotedStringNamed);
|
|
const fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote, stringNamed);
|
|
if (fromNameType) {
|
|
return fromNameType;
|
|
}
|
|
const rawName = unescapeLeadingUnderscores(symbol.escapedName);
|
|
return createPropertyNameNodeForIdentifierOrLiteral(rawName, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed);
|
|
}
|
|
function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote, stringNamed) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType) {
|
|
if (nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const name = "" + nameType.value;
|
|
if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && (stringNamed || !isNumericLiteralName(name))) {
|
|
return factory.createStringLiteral(name, !!singleQuote);
|
|
}
|
|
if (isNumericLiteralName(name) && startsWith(name, "-")) {
|
|
return factory.createComputedPropertyName(factory.createNumericLiteral(+name));
|
|
}
|
|
return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions));
|
|
}
|
|
if (nameType.flags & 8192 /* UniqueESSymbol */) {
|
|
return factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* Value */));
|
|
}
|
|
}
|
|
}
|
|
function cloneNodeBuilderContext(context) {
|
|
const initial = { ...context };
|
|
if (initial.typeParameterNames) {
|
|
initial.typeParameterNames = new Map(initial.typeParameterNames);
|
|
}
|
|
if (initial.typeParameterNamesByText) {
|
|
initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
|
|
}
|
|
if (initial.typeParameterSymbolList) {
|
|
initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
|
|
}
|
|
initial.tracker = wrapSymbolTrackerToReportForContext(initial, initial.tracker);
|
|
return initial;
|
|
}
|
|
function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
|
|
return symbol.declarations && find(symbol.declarations, (s) => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
|
|
}
|
|
function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
|
|
return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
|
|
}
|
|
function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
|
|
if (!isErrorType(type) && enclosingDeclaration) {
|
|
const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration);
|
|
if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
|
|
const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
|
|
if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
|
|
const result2 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const oldFlags = context.flags;
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
|
|
context.flags |= 1048576 /* AllowUniqueESSymbolType */;
|
|
}
|
|
const result = typeToTypeNodeHelper(type, context);
|
|
context.flags = oldFlags;
|
|
return result;
|
|
}
|
|
function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
|
|
const typeFromTypeNode = getTypeFromTypeNode(typeNode);
|
|
if (typeFromTypeNode === type) {
|
|
return true;
|
|
}
|
|
if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
|
|
return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
|
|
}
|
|
return false;
|
|
}
|
|
function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
|
|
if (!isErrorType(type) && context.enclosingDeclaration) {
|
|
const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
|
|
if (!!findAncestor(annotation, (n) => n === context.enclosingDeclaration) && annotation) {
|
|
const annotated = getTypeFromTypeNode(annotation);
|
|
const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
|
|
if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
|
|
const result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return typeToTypeNodeHelper(type, context);
|
|
}
|
|
function trackExistingEntityName(node, context, includePrivateSymbol) {
|
|
var _a2, _b;
|
|
let introducesError = false;
|
|
const leftmost = getFirstIdentifier(node);
|
|
if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
|
|
introducesError = true;
|
|
return { introducesError, node };
|
|
}
|
|
const sym = resolveEntityName(leftmost, 67108863 /* All */, true, true);
|
|
if (sym) {
|
|
if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863 /* All */, false).accessibility !== 0 /* Accessible */) {
|
|
introducesError = true;
|
|
} else {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.trackSymbol) == null ? void 0 : _b.call(_a2, sym, context.enclosingDeclaration, 67108863 /* All */);
|
|
includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
|
|
}
|
|
if (isIdentifier(node)) {
|
|
const type = getDeclaredTypeOfSymbol(sym);
|
|
const name = sym.flags & 262144 /* TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : factory.cloneNode(node);
|
|
name.symbol = sym;
|
|
return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 33554432 /* NoAsciiEscaping */) };
|
|
}
|
|
}
|
|
return { introducesError, node };
|
|
}
|
|
function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
|
|
if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
let hadError = false;
|
|
const file = getSourceFileOfNode(existing);
|
|
const transformed = visitNode(existing, visitExistingNodeTreeSymbols);
|
|
if (hadError) {
|
|
return void 0;
|
|
}
|
|
return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
|
|
function visitExistingNodeTreeSymbols(node) {
|
|
if (isJSDocAllType(node) || node.kind === 322 /* JSDocNamepathType */) {
|
|
return factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (isJSDocUnknownType(node)) {
|
|
return factory.createKeywordTypeNode(157 /* UnknownKeyword */);
|
|
}
|
|
if (isJSDocNullableType(node)) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols), factory.createLiteralTypeNode(factory.createNull())]);
|
|
}
|
|
if (isJSDocOptionalType(node)) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, visitExistingNodeTreeSymbols), factory.createKeywordTypeNode(155 /* UndefinedKeyword */)]);
|
|
}
|
|
if (isJSDocNonNullableType(node)) {
|
|
return visitNode(node.type, visitExistingNodeTreeSymbols);
|
|
}
|
|
if (isJSDocVariadicType(node)) {
|
|
return factory.createArrayTypeNode(visitNode(node.type, visitExistingNodeTreeSymbols));
|
|
}
|
|
if (isJSDocTypeLiteral(node)) {
|
|
return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
|
|
const name = isIdentifier(t.name) ? t.name : t.name.right;
|
|
const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
|
|
const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
|
|
return factory.createPropertySignature(
|
|
void 0,
|
|
name,
|
|
t.isBracketed || t.typeExpression && isJSDocOptionalType(t.typeExpression.type) ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
overrideTypeNode || t.typeExpression && visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
}));
|
|
}
|
|
if (isTypeReferenceNode(node) && isIdentifier(node.typeName) && node.typeName.escapedText === "") {
|
|
return setOriginalNode(factory.createKeywordTypeNode(131 /* AnyKeyword */), node);
|
|
}
|
|
if ((isExpressionWithTypeArguments(node) || isTypeReferenceNode(node)) && isJSDocIndexSignature(node)) {
|
|
return factory.createTypeLiteralNode([factory.createIndexSignature(
|
|
void 0,
|
|
[factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"x",
|
|
void 0,
|
|
visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols)
|
|
)],
|
|
visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols)
|
|
)]);
|
|
}
|
|
if (isJSDocFunctionType(node)) {
|
|
if (isJSDocConstructSignature(node)) {
|
|
let newTypeNode;
|
|
return factory.createConstructorTypeNode(
|
|
void 0,
|
|
visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols),
|
|
mapDefined(node.parameters, (p, i) => p.name && isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode = p.type, void 0) : factory.createParameterDeclaration(
|
|
void 0,
|
|
getEffectiveDotDotDotForParameter(p),
|
|
getNameForJSDocFunctionParameter(p, i),
|
|
p.questionToken,
|
|
visitNode(p.type, visitExistingNodeTreeSymbols),
|
|
void 0
|
|
)),
|
|
visitNode(newTypeNode || node.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
} else {
|
|
return factory.createFunctionTypeNode(
|
|
visitNodes2(node.typeParameters, visitExistingNodeTreeSymbols),
|
|
map(node.parameters, (p, i) => factory.createParameterDeclaration(
|
|
void 0,
|
|
getEffectiveDotDotDotForParameter(p),
|
|
getNameForJSDocFunctionParameter(p, i),
|
|
p.questionToken,
|
|
visitNode(p.type, visitExistingNodeTreeSymbols),
|
|
void 0
|
|
)),
|
|
visitNode(node.type, visitExistingNodeTreeSymbols) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
}
|
|
}
|
|
if (isTypeReferenceNode(node) && isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(node, 788968 /* Type */, true))) {
|
|
return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
|
|
}
|
|
if (isLiteralImportTypeNode(node)) {
|
|
const nodeSymbol = getNodeLinks(node).resolvedSymbol;
|
|
if (isInJSDoc(node) && nodeSymbol && (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
|
|
return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
|
|
}
|
|
return factory.updateImportTypeNode(
|
|
node,
|
|
factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)),
|
|
node.assertions,
|
|
node.qualifier,
|
|
visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
|
|
node.isTypeOf
|
|
);
|
|
}
|
|
if (isEntityName(node) || isEntityNameExpression(node)) {
|
|
const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
|
|
hadError = hadError || introducesError;
|
|
if (result !== node) {
|
|
return result;
|
|
}
|
|
}
|
|
if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
|
|
setEmitFlags(node, 1 /* SingleLine */);
|
|
}
|
|
return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
|
|
function getEffectiveDotDotDotForParameter(p) {
|
|
return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(25 /* DotDotDotToken */) : void 0);
|
|
}
|
|
function getNameForJSDocFunctionParameter(p, index) {
|
|
return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
|
|
}
|
|
function rewriteModuleSpecifier(parent2, lit) {
|
|
if (bundled) {
|
|
if (context.tracker && context.tracker.moduleResolverHost) {
|
|
const targetFile = getExternalModuleFileFromDeclaration(parent2);
|
|
if (targetFile) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(!!host.useCaseSensitiveFileNames);
|
|
const resolverHost = {
|
|
getCanonicalFileName,
|
|
getCurrentDirectory: () => context.tracker.moduleResolverHost.getCurrentDirectory(),
|
|
getCommonSourceDirectory: () => context.tracker.moduleResolverHost.getCommonSourceDirectory()
|
|
};
|
|
const newName = getResolvedExternalModuleName(resolverHost, targetFile);
|
|
return factory.createStringLiteral(newName);
|
|
}
|
|
}
|
|
} else {
|
|
if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) {
|
|
const moduleSym = resolveExternalModuleNameWorker(lit, lit, void 0);
|
|
if (moduleSym) {
|
|
context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym);
|
|
}
|
|
}
|
|
}
|
|
return lit;
|
|
}
|
|
}
|
|
}
|
|
function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
|
|
const serializePropertySymbolForClass = makeSerializePropertySymbol(factory.createPropertyDeclaration, 171 /* MethodDeclaration */, true);
|
|
const serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol((mods, name, question, type) => factory.createPropertySignature(mods, name, question, type), 170 /* MethodSignature */, false);
|
|
const enclosingDeclaration = context.enclosingDeclaration;
|
|
let results = [];
|
|
const visitedSymbols = /* @__PURE__ */ new Set();
|
|
const deferredPrivatesStack = [];
|
|
const oldcontext = context;
|
|
context = {
|
|
...oldcontext,
|
|
usedSymbolNames: new Set(oldcontext.usedSymbolNames),
|
|
remappedSymbolNames: /* @__PURE__ */ new Map(),
|
|
tracker: {
|
|
...oldcontext.tracker,
|
|
trackSymbol: (sym, decl, meaning) => {
|
|
const accessibleResult = isSymbolAccessible(sym, decl, meaning, false);
|
|
if (accessibleResult.accessibility === 0 /* Accessible */) {
|
|
const chain = lookupSymbolChainWorker(sym, context, meaning);
|
|
if (!(sym.flags & 4 /* Property */)) {
|
|
includePrivateSymbol(chain[0]);
|
|
}
|
|
} else if (oldcontext.tracker && oldcontext.tracker.trackSymbol) {
|
|
return oldcontext.tracker.trackSymbol(sym, decl, meaning);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
context.tracker = wrapSymbolTrackerToReportForContext(context, context.tracker);
|
|
forEachEntry(symbolTable, (symbol, name) => {
|
|
const baseName = unescapeLeadingUnderscores(name);
|
|
void getInternalSymbolName(symbol, baseName);
|
|
});
|
|
let addingDeclare = !bundled;
|
|
const exportEquals = symbolTable.get("export=" /* ExportEquals */);
|
|
if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152 /* Alias */) {
|
|
symbolTable = createSymbolTable();
|
|
symbolTable.set("export=" /* ExportEquals */, exportEquals);
|
|
}
|
|
visitSymbolTable(symbolTable);
|
|
return mergeRedundantStatements(results);
|
|
function isIdentifierAndNotUndefined(node) {
|
|
return !!node && node.kind === 79 /* Identifier */;
|
|
}
|
|
function getNamesOfDeclaration(statement) {
|
|
if (isVariableStatement(statement)) {
|
|
return filter(map(statement.declarationList.declarations, getNameOfDeclaration), isIdentifierAndNotUndefined);
|
|
}
|
|
return filter([getNameOfDeclaration(statement)], isIdentifierAndNotUndefined);
|
|
}
|
|
function flattenExportAssignedNamespace(statements) {
|
|
const exportAssignment = find(statements, isExportAssignment);
|
|
const nsIndex = findIndex(statements, isModuleDeclaration);
|
|
let ns = nsIndex !== -1 ? statements[nsIndex] : void 0;
|
|
if (ns && exportAssignment && exportAssignment.isExportEquals && isIdentifier(exportAssignment.expression) && isIdentifier(ns.name) && idText(ns.name) === idText(exportAssignment.expression) && ns.body && isModuleBlock(ns.body)) {
|
|
const excessExports = filter(statements, (s) => !!(getEffectiveModifierFlags(s) & 1 /* Export */));
|
|
const name = ns.name;
|
|
let body = ns.body;
|
|
if (length(excessExports)) {
|
|
ns = factory.updateModuleDeclaration(
|
|
ns,
|
|
ns.modifiers,
|
|
ns.name,
|
|
body = factory.updateModuleBlock(
|
|
body,
|
|
factory.createNodeArray([...ns.body.statements, factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(map(flatMap(excessExports, (e) => getNamesOfDeclaration(e)), (id) => factory.createExportSpecifier(false, void 0, id))),
|
|
void 0
|
|
)])
|
|
)
|
|
);
|
|
statements = [...statements.slice(0, nsIndex), ns, ...statements.slice(nsIndex + 1)];
|
|
}
|
|
if (!find(statements, (s) => s !== ns && nodeHasName(s, name))) {
|
|
results = [];
|
|
const mixinExportFlag = !some(body.statements, (s) => hasSyntacticModifier(s, 1 /* Export */) || isExportAssignment(s) || isExportDeclaration(s));
|
|
forEach(body.statements, (s) => {
|
|
addResult(s, mixinExportFlag ? 1 /* Export */ : 0 /* None */);
|
|
});
|
|
statements = [...filter(statements, (s) => s !== ns && s !== exportAssignment), ...results];
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function mergeExportDeclarations(statements) {
|
|
const exports = filter(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (length(exports) > 1) {
|
|
const nonExports = filter(statements, (d) => !isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause);
|
|
statements = [...nonExports, factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(flatMap(exports, (e) => cast(e.exportClause, isNamedExports).elements)),
|
|
void 0
|
|
)];
|
|
}
|
|
const reexports = filter(statements, (d) => isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (length(reexports) > 1) {
|
|
const groups = group(reexports, (decl) => isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">");
|
|
if (groups.length !== reexports.length) {
|
|
for (const group2 of groups) {
|
|
if (group2.length > 1) {
|
|
statements = [
|
|
...filter(statements, (s) => group2.indexOf(s) === -1),
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(flatMap(group2, (e) => cast(e.exportClause, isNamedExports).elements)),
|
|
group2[0].moduleSpecifier
|
|
)
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function inlineExportModifiers(statements) {
|
|
const index = findIndex(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !d.assertClause && !!d.exportClause && isNamedExports(d.exportClause));
|
|
if (index >= 0) {
|
|
const exportDecl = statements[index];
|
|
const replacements = mapDefined(exportDecl.exportClause.elements, (e) => {
|
|
if (!e.propertyName) {
|
|
const indices = indicesOf(statements);
|
|
const associatedIndices = filter(indices, (i) => nodeHasName(statements[i], e.name));
|
|
if (length(associatedIndices) && every(associatedIndices, (i) => canHaveExportModifier(statements[i]))) {
|
|
for (const index2 of associatedIndices) {
|
|
statements[index2] = addExportModifier(statements[index2]);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
return e;
|
|
});
|
|
if (!length(replacements)) {
|
|
orderedRemoveItemAt(statements, index);
|
|
} else {
|
|
statements[index] = factory.updateExportDeclaration(
|
|
exportDecl,
|
|
exportDecl.modifiers,
|
|
exportDecl.isTypeOnly,
|
|
factory.updateNamedExports(
|
|
exportDecl.exportClause,
|
|
replacements
|
|
),
|
|
exportDecl.moduleSpecifier,
|
|
exportDecl.assertClause
|
|
);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function mergeRedundantStatements(statements) {
|
|
statements = flattenExportAssignedNamespace(statements);
|
|
statements = mergeExportDeclarations(statements);
|
|
statements = inlineExportModifiers(statements);
|
|
if (enclosingDeclaration && (isSourceFile(enclosingDeclaration) && isExternalOrCommonJsModule(enclosingDeclaration) || isModuleDeclaration(enclosingDeclaration)) && (!some(statements, isExternalModuleIndicator) || !hasScopeMarker(statements) && some(statements, needsScopeMarker))) {
|
|
statements.push(createEmptyExports(factory));
|
|
}
|
|
return statements;
|
|
}
|
|
function addExportModifier(node) {
|
|
const flags = (getEffectiveModifierFlags(node) | 1 /* Export */) & ~2 /* Ambient */;
|
|
return factory.updateModifiers(node, flags);
|
|
}
|
|
function removeExportModifier(node) {
|
|
const flags = getEffectiveModifierFlags(node) & ~1 /* Export */;
|
|
return factory.updateModifiers(node, flags);
|
|
}
|
|
function visitSymbolTable(symbolTable2, suppressNewPrivateContext, propertyAsAlias) {
|
|
if (!suppressNewPrivateContext) {
|
|
deferredPrivatesStack.push(/* @__PURE__ */ new Map());
|
|
}
|
|
symbolTable2.forEach((symbol) => {
|
|
serializeSymbol(symbol, false, !!propertyAsAlias);
|
|
});
|
|
if (!suppressNewPrivateContext) {
|
|
deferredPrivatesStack[deferredPrivatesStack.length - 1].forEach((symbol) => {
|
|
serializeSymbol(symbol, true, !!propertyAsAlias);
|
|
});
|
|
deferredPrivatesStack.pop();
|
|
}
|
|
}
|
|
function serializeSymbol(symbol, isPrivate, propertyAsAlias) {
|
|
const visitedSym = getMergedSymbol(symbol);
|
|
if (visitedSymbols.has(getSymbolId(visitedSym))) {
|
|
return;
|
|
}
|
|
visitedSymbols.add(getSymbolId(visitedSym));
|
|
const skipMembershipCheck = !isPrivate;
|
|
if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) {
|
|
const oldContext = context;
|
|
context = cloneNodeBuilderContext(context);
|
|
serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
|
|
if (context.reportedDiagnostic) {
|
|
oldcontext.reportedDiagnostic = context.reportedDiagnostic;
|
|
}
|
|
context = oldContext;
|
|
}
|
|
}
|
|
function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) {
|
|
var _a2, _b, _c, _d;
|
|
const symbolName2 = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const isDefault = symbol.escapedName === "default" /* Default */;
|
|
if (isPrivate && !(context.flags & 131072 /* AllowAnonymousIdentifier */) && isStringANonContextualKeyword(symbolName2) && !isDefault) {
|
|
context.encounteredError = true;
|
|
return;
|
|
}
|
|
let needsPostExportDefault = isDefault && !!(symbol.flags & -113 /* ExportDoesNotSupportDefaultModifier */ || symbol.flags & 16 /* Function */ && length(getPropertiesOfType(getTypeOfSymbol(symbol)))) && !(symbol.flags & 2097152 /* Alias */);
|
|
let needsExportDeclaration = !needsPostExportDefault && !isPrivate && isStringANonContextualKeyword(symbolName2) && !isDefault;
|
|
if (needsPostExportDefault || needsExportDeclaration) {
|
|
isPrivate = true;
|
|
}
|
|
const modifierFlags = (!isPrivate ? 1 /* Export */ : 0) | (isDefault && !needsPostExportDefault ? 1024 /* Default */ : 0);
|
|
const isConstMergedWithNS = symbol.flags & 1536 /* Module */ && symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && symbol.escapedName !== "export=" /* ExportEquals */;
|
|
const isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */) || isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
serializeTypeAlias(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & (2 /* BlockScopedVariable */ | 1 /* FunctionScopedVariable */ | 4 /* Property */) && symbol.escapedName !== "export=" /* ExportEquals */ && !(symbol.flags & 4194304 /* Prototype */) && !(symbol.flags & 32 /* Class */) && !(symbol.flags & 8192 /* Method */) && !isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
if (propertyAsAlias) {
|
|
const createdExport = serializeMaybeAliasAssignment(symbol);
|
|
if (createdExport) {
|
|
needsExportDeclaration = false;
|
|
needsPostExportDefault = false;
|
|
}
|
|
} else {
|
|
const type = getTypeOfSymbol(symbol);
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
if (!(symbol.flags & 16 /* Function */) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) {
|
|
serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags);
|
|
} else {
|
|
const flags = !(symbol.flags & 2 /* BlockScopedVariable */) ? ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) && isSourceFile((_b = symbol.parent) == null ? void 0 : _b.valueDeclaration) ? 2 /* Const */ : void 0 : isConstVariable(symbol) ? 2 /* Const */ : 1 /* Let */;
|
|
const name = needsPostExportDefault || !(symbol.flags & 4 /* Property */) ? localName : getUnusedName(localName, symbol);
|
|
let textRange = symbol.declarations && find(symbol.declarations, (d) => isVariableDeclaration(d));
|
|
if (textRange && isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) {
|
|
textRange = textRange.parent.parent;
|
|
}
|
|
const propertyAccessRequire = (_c = symbol.declarations) == null ? void 0 : _c.find(isPropertyAccessExpression);
|
|
if (propertyAccessRequire && isBinaryExpression(propertyAccessRequire.parent) && isIdentifier(propertyAccessRequire.parent.right) && ((_d = type.symbol) == null ? void 0 : _d.valueDeclaration) && isSourceFile(type.symbol.valueDeclaration)) {
|
|
const alias = localName === propertyAccessRequire.parent.right.escapedText ? void 0 : propertyAccessRequire.parent.right;
|
|
addResult(
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, alias, localName)])
|
|
),
|
|
0 /* None */
|
|
);
|
|
context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* Value */);
|
|
} else {
|
|
const statement = setTextRange(factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(name, void 0, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
|
|
], flags)), textRange);
|
|
addResult(statement, name !== localName ? modifierFlags & ~1 /* Export */ : modifierFlags);
|
|
if (name !== localName && !isPrivate) {
|
|
addResult(
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, name, localName)])
|
|
),
|
|
0 /* None */
|
|
);
|
|
needsExportDeclaration = false;
|
|
needsPostExportDefault = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (symbol.flags & 384 /* Enum */) {
|
|
serializeEnum(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 32 /* Class */) {
|
|
if (symbol.flags & 4 /* Property */ && symbol.valueDeclaration && isBinaryExpression(symbol.valueDeclaration.parent) && isClassExpression(symbol.valueDeclaration.parent.right)) {
|
|
serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
} else {
|
|
serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
}
|
|
if (symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol)) || isConstMergedWithNSPrintableAsSignatureMerge) {
|
|
serializeModule(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 64 /* Interface */ && !(symbol.flags & 32 /* Class */)) {
|
|
serializeInterface(symbol, symbolName2, modifierFlags);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName2), modifierFlags);
|
|
}
|
|
if (symbol.flags & 4 /* Property */ && symbol.escapedName === "export=" /* ExportEquals */) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
}
|
|
if (symbol.flags & 8388608 /* ExportStar */) {
|
|
if (symbol.declarations) {
|
|
for (const node of symbol.declarations) {
|
|
const resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (!resolvedModule)
|
|
continue;
|
|
addResult(factory.createExportDeclaration(void 0, false, void 0, factory.createStringLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
if (needsPostExportDefault) {
|
|
addResult(factory.createExportAssignment(void 0, false, factory.createIdentifier(getInternalSymbolName(symbol, symbolName2))), 0 /* None */);
|
|
} else if (needsExportDeclaration) {
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, getInternalSymbolName(symbol, symbolName2), symbolName2)])
|
|
), 0 /* None */);
|
|
}
|
|
}
|
|
function includePrivateSymbol(symbol) {
|
|
if (some(symbol.declarations, isParameterDeclaration))
|
|
return;
|
|
Debug.assertIsDefined(deferredPrivatesStack[deferredPrivatesStack.length - 1]);
|
|
getUnusedName(unescapeLeadingUnderscores(symbol.escapedName), symbol);
|
|
const isExternalImportAlias = !!(symbol.flags & 2097152 /* Alias */) && !some(
|
|
symbol.declarations,
|
|
(d) => !!findAncestor(d, isExportDeclaration) || isNamespaceExport(d) || isImportEqualsDeclaration(d) && !isExternalModuleReference(d.moduleReference)
|
|
);
|
|
deferredPrivatesStack[isExternalImportAlias ? 0 : deferredPrivatesStack.length - 1].set(getSymbolId(symbol), symbol);
|
|
}
|
|
function isExportingScope(enclosingDeclaration2) {
|
|
return isSourceFile(enclosingDeclaration2) && (isExternalOrCommonJsModule(enclosingDeclaration2) || isJsonSourceFile(enclosingDeclaration2)) || isAmbientModule(enclosingDeclaration2) && !isGlobalScopeAugmentation(enclosingDeclaration2);
|
|
}
|
|
function addResult(node, additionalModifierFlags) {
|
|
if (canHaveModifiers(node)) {
|
|
let newModifierFlags = 0 /* None */;
|
|
const enclosingDeclaration2 = context.enclosingDeclaration && (isJSDocTypeAlias(context.enclosingDeclaration) ? getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
|
|
if (additionalModifierFlags & 1 /* Export */ && enclosingDeclaration2 && (isExportingScope(enclosingDeclaration2) || isModuleDeclaration(enclosingDeclaration2)) && canHaveExportModifier(node)) {
|
|
newModifierFlags |= 1 /* Export */;
|
|
}
|
|
if (addingDeclare && !(newModifierFlags & 1 /* Export */) && (!enclosingDeclaration2 || !(enclosingDeclaration2.flags & 16777216 /* Ambient */)) && (isEnumDeclaration(node) || isVariableStatement(node) || isFunctionDeclaration(node) || isClassDeclaration(node) || isModuleDeclaration(node))) {
|
|
newModifierFlags |= 2 /* Ambient */;
|
|
}
|
|
if (additionalModifierFlags & 1024 /* Default */ && (isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionDeclaration(node))) {
|
|
newModifierFlags |= 1024 /* Default */;
|
|
}
|
|
if (newModifierFlags) {
|
|
node = factory.updateModifiers(node, newModifierFlags | getEffectiveModifierFlags(node));
|
|
}
|
|
}
|
|
results.push(node);
|
|
}
|
|
function serializeTypeAlias(symbol, symbolName2, modifierFlags) {
|
|
var _a2;
|
|
const aliasType = getDeclaredTypeOfTypeAlias(symbol);
|
|
const typeParams = getSymbolLinks(symbol).typeParameters;
|
|
const typeParamDecls = map(typeParams, (p) => typeParameterToDeclaration(p, context));
|
|
const jsdocAliasDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isJSDocTypeAlias);
|
|
const commentText = getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : void 0);
|
|
const oldFlags = context.flags;
|
|
context.flags |= 8388608 /* InTypeAlias */;
|
|
const oldEnclosingDecl = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = jsdocAliasDecl;
|
|
const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) || typeToTypeNodeHelper(aliasType, context);
|
|
addResult(setSyntheticLeadingComments(
|
|
factory.createTypeAliasDeclaration(void 0, getInternalSymbolName(symbol, symbolName2), 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, symbolName2, modifierFlags) {
|
|
const interfaceType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
|
|
const baseTypes = getBaseTypes(interfaceType);
|
|
const baseType = length(baseTypes) ? getIntersectionType(baseTypes) : void 0;
|
|
const members = flatMap(getPropertiesOfType(interfaceType), (p) => serializePropertySymbolForInterface(p, baseType));
|
|
const callSignatures = serializeSignatures(0 /* Call */, interfaceType, baseType, 176 /* CallSignature */);
|
|
const constructSignatures = serializeSignatures(1 /* Construct */, interfaceType, baseType, 177 /* ConstructSignature */);
|
|
const indexSignatures = serializeIndexSignatures(interfaceType, baseType);
|
|
const heritageClauses = !length(baseTypes) ? void 0 : [factory.createHeritageClause(94 /* ExtendsKeyword */, mapDefined(baseTypes, (b) => trySerializeAsTypeReference(b, 111551 /* Value */)))];
|
|
addResult(factory.createInterfaceDeclaration(
|
|
void 0,
|
|
getInternalSymbolName(symbol, symbolName2),
|
|
typeParamDecls,
|
|
heritageClauses,
|
|
[...indexSignatures, ...constructSignatures, ...callSignatures, ...members]
|
|
), modifierFlags);
|
|
}
|
|
function getNamespaceMembersForSerialization(symbol) {
|
|
return !symbol.exports ? [] : filter(arrayFrom(symbol.exports.values()), isNamespaceMember);
|
|
}
|
|
function isTypeOnlyNamespace(symbol) {
|
|
return every(getNamespaceMembersForSerialization(symbol), (m) => !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
|
|
}
|
|
function serializeModule(symbol, symbolName2, modifierFlags) {
|
|
const members = getNamespaceMembersForSerialization(symbol);
|
|
const locationMap = arrayToMultiMap(members, (m) => m.parent && m.parent === symbol ? "real" : "merged");
|
|
const realMembers = locationMap.get("real") || emptyArray;
|
|
const mergedMembers = locationMap.get("merged") || emptyArray;
|
|
if (length(realMembers)) {
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 /* Function */ | 67108864 /* Assignment */)));
|
|
}
|
|
if (length(mergedMembers)) {
|
|
const containingFile = getSourceFileOfNode(context.enclosingDeclaration);
|
|
const localName = getInternalSymbolName(symbol, symbolName2);
|
|
const nsBody = factory.createModuleBlock([factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(mapDefined(filter(mergedMembers, (n) => n.escapedName !== "export=" /* ExportEquals */), (s) => {
|
|
var _a2, _b;
|
|
const name = unescapeLeadingUnderscores(s.escapedName);
|
|
const localName2 = getInternalSymbolName(s, name);
|
|
const aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s);
|
|
if (containingFile && (aliasDecl ? containingFile !== getSourceFileOfNode(aliasDecl) : !some(s.declarations, (d) => getSourceFileOfNode(d) === containingFile))) {
|
|
(_b = (_a2 = context.tracker) == null ? void 0 : _a2.reportNonlocalAugmentation) == null ? void 0 : _b.call(_a2, containingFile, symbol, s);
|
|
return void 0;
|
|
}
|
|
const target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
|
|
includePrivateSymbol(target || s);
|
|
const targetName = target ? getInternalSymbolName(target, unescapeLeadingUnderscores(target.escapedName)) : localName2;
|
|
return factory.createExportSpecifier(false, name === targetName ? void 0 : targetName, name);
|
|
}))
|
|
)]);
|
|
addResult(factory.createModuleDeclaration(
|
|
void 0,
|
|
factory.createIdentifier(localName),
|
|
nsBody,
|
|
16 /* Namespace */
|
|
), 0 /* None */);
|
|
}
|
|
}
|
|
function serializeEnum(symbol, symbolName2, modifierFlags) {
|
|
addResult(factory.createEnumDeclaration(
|
|
factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 /* Const */ : 0),
|
|
getInternalSymbolName(symbol, symbolName2),
|
|
map(filter(getPropertiesOfType(getTypeOfSymbol(symbol)), (p) => !!(p.flags & 8 /* EnumMember */)), (p) => {
|
|
const initializedValue = p.declarations && p.declarations[0] && isEnumMember(p.declarations[0]) ? getConstantValue2(p.declarations[0]) : void 0;
|
|
return factory.createEnumMember(unescapeLeadingUnderscores(p.escapedName), initializedValue === void 0 ? void 0 : typeof initializedValue === "string" ? factory.createStringLiteral(initializedValue) : factory.createNumericLiteral(initializedValue));
|
|
})
|
|
), modifierFlags);
|
|
}
|
|
function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(sig, 259 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
|
|
addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
|
|
}
|
|
if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
|
|
const props = filter(getPropertiesOfType(type), isNamespaceMember);
|
|
serializeAsNamespaceDeclaration(props, localName, modifierFlags, true);
|
|
}
|
|
}
|
|
function getSignatureTextRangeLocation(signature) {
|
|
if (signature.declaration && signature.declaration.parent) {
|
|
if (isBinaryExpression(signature.declaration.parent) && getAssignmentDeclarationKind(signature.declaration.parent) === 5 /* Property */) {
|
|
return signature.declaration.parent;
|
|
}
|
|
if (isVariableDeclaration(signature.declaration.parent) && signature.declaration.parent.parent) {
|
|
return signature.declaration.parent.parent;
|
|
}
|
|
}
|
|
return signature.declaration;
|
|
}
|
|
function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) {
|
|
if (length(props)) {
|
|
const localVsRemoteMap = arrayToMultiMap(
|
|
props,
|
|
(p) => !length(p.declarations) || some(
|
|
p.declarations,
|
|
(d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)
|
|
) ? "local" : "remote"
|
|
);
|
|
const localProps = localVsRemoteMap.get("local") || emptyArray;
|
|
let fakespace = parseNodeFactory.createModuleDeclaration(void 0, factory.createIdentifier(localName), factory.createModuleBlock([]), 16 /* Namespace */);
|
|
setParent(fakespace, enclosingDeclaration);
|
|
fakespace.locals = createSymbolTable(props);
|
|
fakespace.symbol = props[0].parent;
|
|
const oldResults = results;
|
|
results = [];
|
|
const oldAddingDeclare = addingDeclare;
|
|
addingDeclare = false;
|
|
const subcontext = { ...context, enclosingDeclaration: fakespace };
|
|
const oldContext = context;
|
|
context = subcontext;
|
|
visitSymbolTable(createSymbolTable(localProps), suppressNewPrivateContext, true);
|
|
context = oldContext;
|
|
addingDeclare = oldAddingDeclare;
|
|
const declarations = results;
|
|
results = oldResults;
|
|
const defaultReplaced = map(declarations, (d) => isExportAssignment(d) && !d.isExportEquals && isIdentifier(d.expression) ? factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, d.expression, factory.createIdentifier("default" /* Default */))])
|
|
) : d);
|
|
const exportModifierStripped = every(defaultReplaced, (d) => hasSyntacticModifier(d, 1 /* Export */)) ? map(defaultReplaced, removeExportModifier) : defaultReplaced;
|
|
fakespace = factory.updateModuleDeclaration(
|
|
fakespace,
|
|
fakespace.modifiers,
|
|
fakespace.name,
|
|
factory.createModuleBlock(exportModifierStripped)
|
|
);
|
|
addResult(fakespace, modifierFlags);
|
|
}
|
|
}
|
|
function isNamespaceMember(p) {
|
|
return !!(p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) || !(p.flags & 4194304 /* Prototype */ || p.escapedName === "prototype" || p.valueDeclaration && isStatic(p.valueDeclaration) && isClassLike(p.valueDeclaration.parent));
|
|
}
|
|
function sanitizeJSDocImplements(clauses) {
|
|
const result = mapDefined(clauses, (e) => {
|
|
const oldEnclosing = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = e;
|
|
let expr = e.expression;
|
|
if (isEntityNameExpression(expr)) {
|
|
if (isIdentifier(expr) && idText(expr) === "") {
|
|
return cleanup(void 0);
|
|
}
|
|
let introducesError;
|
|
({ introducesError, node: expr } = trackExistingEntityName(expr, context, includePrivateSymbol));
|
|
if (introducesError) {
|
|
return cleanup(void 0);
|
|
}
|
|
}
|
|
return cleanup(factory.createExpressionWithTypeArguments(
|
|
expr,
|
|
map(
|
|
e.typeArguments,
|
|
(a) => serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context)
|
|
)
|
|
));
|
|
function cleanup(result2) {
|
|
context.enclosingDeclaration = oldEnclosing;
|
|
return result2;
|
|
}
|
|
});
|
|
if (result.length === clauses.length) {
|
|
return result;
|
|
}
|
|
return void 0;
|
|
}
|
|
function serializeAsClass(symbol, localName, modifierFlags) {
|
|
var _a2, _b;
|
|
const originalDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
|
|
const oldEnclosing = context.enclosingDeclaration;
|
|
context.enclosingDeclaration = originalDecl || oldEnclosing;
|
|
const localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
const typeParamDecls = map(localParams, (p) => typeParameterToDeclaration(p, context));
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const baseTypes = getBaseTypes(classType);
|
|
const originalImplements = originalDecl && getEffectiveImplementsTypeNodes(originalDecl);
|
|
const implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) || mapDefined(getImplementsTypes(classType), serializeImplementedType);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
const isClass = !!((_b = staticType.symbol) == null ? void 0 : _b.valueDeclaration) && isClassLike(staticType.symbol.valueDeclaration);
|
|
const staticBaseType = isClass ? getBaseConstructorTypeOfClass(staticType) : anyType;
|
|
const heritageClauses = [
|
|
...!length(baseTypes) ? [] : [factory.createHeritageClause(94 /* ExtendsKeyword */, map(baseTypes, (b) => serializeBaseType(b, staticBaseType, localName)))],
|
|
...!length(implementsExpressions) ? [] : [factory.createHeritageClause(117 /* ImplementsKeyword */, implementsExpressions)]
|
|
];
|
|
const symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType));
|
|
const publicSymbolProps = filter(symbolProps, (s) => {
|
|
const valueDecl = s.valueDeclaration;
|
|
return !!valueDecl && !(isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name));
|
|
});
|
|
const hasPrivateIdentifier = some(symbolProps, (s) => {
|
|
const valueDecl = s.valueDeclaration;
|
|
return !!valueDecl && isNamedDeclaration(valueDecl) && isPrivateIdentifier(valueDecl.name);
|
|
});
|
|
const privateProperties = hasPrivateIdentifier ? [factory.createPropertyDeclaration(
|
|
void 0,
|
|
factory.createPrivateIdentifier("#private"),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)] : emptyArray;
|
|
const publicProperties = flatMap(publicSymbolProps, (p) => serializePropertySymbolForClass(p, false, baseTypes[0]));
|
|
const staticMembers = flatMap(
|
|
filter(getPropertiesOfType(staticType), (p) => !(p.flags & 4194304 /* Prototype */) && p.escapedName !== "prototype" && !isNamespaceMember(p)),
|
|
(p) => serializePropertySymbolForClass(p, true, staticBaseType)
|
|
);
|
|
const isNonConstructableClassLikeInJsFile = !isClass && !!symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && !some(getSignaturesOfType(staticType, 1 /* Construct */));
|
|
const constructors = isNonConstructableClassLikeInJsFile ? [factory.createConstructorDeclaration(factory.createModifiersFromModifierFlags(8 /* Private */), [], void 0)] : serializeSignatures(1 /* Construct */, staticType, staticBaseType, 173 /* Constructor */);
|
|
const indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
|
|
context.enclosingDeclaration = oldEnclosing;
|
|
addResult(setTextRange(factory.createClassDeclaration(
|
|
void 0,
|
|
localName,
|
|
typeParamDecls,
|
|
heritageClauses,
|
|
[...indexSignatures, ...staticMembers, ...constructors, ...publicProperties, ...privateProperties]
|
|
), symbol.declarations && filter(symbol.declarations, (d) => isClassDeclaration(d) || isClassExpression(d))[0]), modifierFlags);
|
|
}
|
|
function getSomeTargetNameFromDeclarations(declarations) {
|
|
return firstDefined(declarations, (d) => {
|
|
if (isImportSpecifier(d) || isExportSpecifier(d)) {
|
|
return idText(d.propertyName || d.name);
|
|
}
|
|
if (isBinaryExpression(d) || isExportAssignment(d)) {
|
|
const expression = isExportAssignment(d) ? d.expression : d.right;
|
|
if (isPropertyAccessExpression(expression)) {
|
|
return idText(expression.name);
|
|
}
|
|
}
|
|
if (isAliasSymbolDeclaration2(d)) {
|
|
const name = getNameOfDeclaration(d);
|
|
if (name && isIdentifier(name)) {
|
|
return idText(name);
|
|
}
|
|
}
|
|
return void 0;
|
|
});
|
|
}
|
|
function serializeAsAlias(symbol, localName, modifierFlags) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
const target = getMergedSymbol(getTargetOfAliasDeclaration(node, true));
|
|
if (!target) {
|
|
return;
|
|
}
|
|
let verbatimTargetName = isShorthandAmbientModuleSymbol(target) && getSomeTargetNameFromDeclarations(symbol.declarations) || unescapeLeadingUnderscores(target.escapedName);
|
|
if (verbatimTargetName === "export=" /* ExportEquals */ && (getESModuleInterop(compilerOptions) || compilerOptions.allowSyntheticDefaultImports)) {
|
|
verbatimTargetName = "default" /* Default */;
|
|
}
|
|
const targetName = getInternalSymbolName(target, verbatimTargetName);
|
|
includePrivateSymbol(target);
|
|
switch (node.kind) {
|
|
case 205 /* BindingElement */:
|
|
if (((_b = (_a2 = node.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.kind) === 257 /* VariableDeclaration */) {
|
|
const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
|
|
const { propertyName } = node;
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, void 0, factory.createNamedImports([factory.createImportSpecifier(
|
|
false,
|
|
propertyName && isIdentifier(propertyName) ? factory.createIdentifier(idText(propertyName)) : void 0,
|
|
factory.createIdentifier(localName)
|
|
)])),
|
|
factory.createStringLiteral(specifier2),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
}
|
|
Debug.failBadSyntaxKind(((_c = node.parent) == null ? void 0 : _c.parent) || node, "Unhandled binding element grandparent kind in declaration serialization");
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (((_e = (_d = node.parent) == null ? void 0 : _d.parent) == null ? void 0 : _e.kind) === 223 /* BinaryExpression */) {
|
|
serializeExportSpecifier(
|
|
unescapeLeadingUnderscores(symbol.escapedName),
|
|
targetName
|
|
);
|
|
}
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
if (isPropertyAccessExpression(node.initializer)) {
|
|
const initializer = node.initializer;
|
|
const uniqueName = factory.createUniqueName(localName);
|
|
const specifier2 = getSpecifierForModuleSymbol(target.parent || target, context);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
uniqueName,
|
|
factory.createExternalModuleReference(factory.createStringLiteral(specifier2))
|
|
), 0 /* None */);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(localName),
|
|
factory.createQualifiedName(uniqueName, initializer.name)
|
|
), modifierFlags);
|
|
break;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (target.escapedName === "export=" /* ExportEquals */ && some(target.declarations, isJsonSourceFile)) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
break;
|
|
}
|
|
const isLocalImport = !(target.flags & 512 /* ValueModule */) && !isVariableDeclaration(node);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(localName),
|
|
isLocalImport ? symbolToName(target, context, 67108863 /* All */, false) : factory.createExternalModuleReference(factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)))
|
|
), isLocalImport ? modifierFlags : 0 /* None */);
|
|
break;
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
addResult(factory.createNamespaceExportDeclaration(idText(node.name)), 0 /* None */);
|
|
break;
|
|
case 270 /* ImportClause */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, factory.createIdentifier(localName), void 0),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 271 /* NamespaceImport */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, void 0, factory.createNamespaceImport(factory.createIdentifier(localName))),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 277 /* NamespaceExport */:
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamespaceExport(factory.createIdentifier(localName)),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))
|
|
), 0 /* None */);
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
addResult(factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory.createNamedImports([
|
|
factory.createImportSpecifier(
|
|
false,
|
|
localName !== verbatimTargetName ? factory.createIdentifier(verbatimTargetName) : void 0,
|
|
factory.createIdentifier(localName)
|
|
)
|
|
])
|
|
),
|
|
factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)),
|
|
void 0
|
|
), 0 /* None */);
|
|
break;
|
|
case 278 /* ExportSpecifier */:
|
|
const specifier = node.parent.parent.moduleSpecifier;
|
|
serializeExportSpecifier(
|
|
unescapeLeadingUnderscores(symbol.escapedName),
|
|
specifier ? verbatimTargetName : targetName,
|
|
specifier && isStringLiteralLike(specifier) ? factory.createStringLiteral(specifier.text) : void 0
|
|
);
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
serializeMaybeAliasAssignment(symbol);
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (symbol.escapedName === "default" /* Default */ || symbol.escapedName === "export=" /* ExportEquals */) {
|
|
serializeMaybeAliasAssignment(symbol);
|
|
} else {
|
|
serializeExportSpecifier(localName, targetName);
|
|
}
|
|
break;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!");
|
|
}
|
|
}
|
|
function serializeExportSpecifier(localName, targetName, specifier) {
|
|
addResult(factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([factory.createExportSpecifier(false, localName !== targetName ? targetName : void 0, localName)]),
|
|
specifier
|
|
), 0 /* None */);
|
|
}
|
|
function serializeMaybeAliasAssignment(symbol) {
|
|
if (symbol.flags & 4194304 /* Prototype */) {
|
|
return false;
|
|
}
|
|
const name = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const isExportEquals = name === "export=" /* ExportEquals */;
|
|
const isDefault = name === "default" /* Default */;
|
|
const isExportAssignmentCompatibleSymbolName = isExportEquals || isDefault;
|
|
const aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol);
|
|
const target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, true);
|
|
if (target && length(target.declarations) && some(target.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(enclosingDeclaration))) {
|
|
const expr = aliasDecl && (isExportAssignment(aliasDecl) || isBinaryExpression(aliasDecl) ? getExportAssignmentExpression(aliasDecl) : getPropertyAssignmentAliasLikeExpression(aliasDecl));
|
|
const first2 = expr && isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : void 0;
|
|
const referenced = first2 && resolveEntityName(first2, 67108863 /* All */, true, true, enclosingDeclaration);
|
|
if (referenced || target) {
|
|
includePrivateSymbol(referenced || target);
|
|
}
|
|
const oldTrack = context.tracker.trackSymbol;
|
|
context.tracker.trackSymbol = () => false;
|
|
if (isExportAssignmentCompatibleSymbolName) {
|
|
results.push(factory.createExportAssignment(
|
|
void 0,
|
|
isExportEquals,
|
|
symbolToExpression(target, context, 67108863 /* All */)
|
|
));
|
|
} else {
|
|
if (first2 === expr && first2) {
|
|
serializeExportSpecifier(name, idText(first2));
|
|
} else if (expr && isClassExpression(expr)) {
|
|
serializeExportSpecifier(name, getInternalSymbolName(target, symbolName(target)));
|
|
} else {
|
|
const varName = getUnusedName(name, symbol);
|
|
addResult(factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createIdentifier(varName),
|
|
symbolToName(target, context, 67108863 /* All */, false)
|
|
), 0 /* None */);
|
|
serializeExportSpecifier(name, varName);
|
|
}
|
|
}
|
|
context.tracker.trackSymbol = oldTrack;
|
|
return true;
|
|
} else {
|
|
const varName = getUnusedName(name, symbol);
|
|
const typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol)));
|
|
if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) {
|
|
serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* None */ : 1 /* Export */);
|
|
} else {
|
|
const statement = factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(varName, void 0, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled))
|
|
], 2 /* Const */));
|
|
addResult(
|
|
statement,
|
|
target && target.flags & 4 /* Property */ && target.escapedName === "export=" /* ExportEquals */ ? 2 /* Ambient */ : name === varName ? 1 /* Export */ : 0 /* None */
|
|
);
|
|
}
|
|
if (isExportAssignmentCompatibleSymbolName) {
|
|
results.push(factory.createExportAssignment(
|
|
void 0,
|
|
isExportEquals,
|
|
factory.createIdentifier(varName)
|
|
));
|
|
return true;
|
|
} else if (name !== varName) {
|
|
serializeExportSpecifier(name, varName);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
|
|
const ctxSrc = getSourceFileOfNode(context.enclosingDeclaration);
|
|
return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && !!(length(filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || length(getSignaturesOfType(typeToSerialize, 0 /* Call */))) && !length(getSignaturesOfType(typeToSerialize, 1 /* Construct */)) && !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) && !(typeToSerialize.symbol && some(typeToSerialize.symbol.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && !some(getPropertiesOfType(typeToSerialize), (p) => isLateBoundName(p.escapedName)) && !some(getPropertiesOfType(typeToSerialize), (p) => some(p.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && every(getPropertiesOfType(typeToSerialize), (p) => isIdentifierText(symbolName(p), languageVersion));
|
|
}
|
|
function makeSerializePropertySymbol(createProperty2, methodKind, useAccessors) {
|
|
return function serializePropertySymbol(p, isStatic2, baseType) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const modifierFlags = getDeclarationModifierFlagsFromSymbol(p);
|
|
const isPrivate = !!(modifierFlags & 8 /* Private */);
|
|
if (isStatic2 && p.flags & (788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */)) {
|
|
return [];
|
|
}
|
|
if (p.flags & 4194304 /* Prototype */ || baseType && getPropertyOfType(baseType, p.escapedName) && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) && (p.flags & 16777216 /* Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* Optional */) && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName))) {
|
|
return [];
|
|
}
|
|
const flag = modifierFlags & ~512 /* Async */ | (isStatic2 ? 32 /* Static */ : 0);
|
|
const name = getPropertyNameNodeForSymbol(p, context);
|
|
const firstPropertyLikeDecl = (_a2 = p.declarations) == null ? void 0 : _a2.find(or(isPropertyDeclaration, isAccessor, isVariableDeclaration, isPropertySignature, isBinaryExpression, isPropertyAccessExpression));
|
|
if (p.flags & 98304 /* Accessor */ && useAccessors) {
|
|
const result = [];
|
|
if (p.flags & 65536 /* SetAccessor */) {
|
|
result.push(setTextRange(factory.createSetAccessorDeclaration(
|
|
factory.createModifiersFromModifierFlags(flag),
|
|
name,
|
|
[factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"arg",
|
|
void 0,
|
|
isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
|
|
)],
|
|
void 0
|
|
), ((_b = p.declarations) == null ? void 0 : _b.find(isSetAccessor)) || firstPropertyLikeDecl));
|
|
}
|
|
if (p.flags & 32768 /* GetAccessor */) {
|
|
const isPrivate2 = modifierFlags & 8 /* Private */;
|
|
result.push(setTextRange(factory.createGetAccessorDeclaration(
|
|
factory.createModifiersFromModifierFlags(flag),
|
|
name,
|
|
[],
|
|
isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
|
|
void 0
|
|
), ((_c = p.declarations) == null ? void 0 : _c.find(isGetAccessor)) || firstPropertyLikeDecl));
|
|
}
|
|
return result;
|
|
} else if (p.flags & (4 /* Property */ | 3 /* Variable */ | 98304 /* Accessor */)) {
|
|
return setTextRange(createProperty2(
|
|
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
|
|
name,
|
|
p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
|
|
void 0
|
|
), ((_d = p.declarations) == null ? void 0 : _d.find(or(isPropertyDeclaration, isVariableDeclaration))) || firstPropertyLikeDecl);
|
|
}
|
|
if (p.flags & (8192 /* Method */ | 16 /* Function */)) {
|
|
const type = getTypeOfSymbol(p);
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
if (flag & 8 /* Private */) {
|
|
return setTextRange(createProperty2(
|
|
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* Readonly */ : 0) | flag),
|
|
name,
|
|
p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
void 0,
|
|
void 0
|
|
), ((_e = p.declarations) == null ? void 0 : _e.find(isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0]);
|
|
}
|
|
const results2 = [];
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(
|
|
sig,
|
|
methodKind,
|
|
context,
|
|
{
|
|
name,
|
|
questionToken: p.flags & 16777216 /* Optional */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
modifiers: flag ? factory.createModifiersFromModifierFlags(flag) : void 0
|
|
}
|
|
);
|
|
const location2 = sig.declaration && isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration;
|
|
results2.push(setTextRange(decl, location2));
|
|
}
|
|
return results2;
|
|
}
|
|
return Debug.fail(`Unhandled class member kind! ${p.__debugFlags || p.flags}`);
|
|
};
|
|
}
|
|
function serializePropertySymbolForInterface(p, baseType) {
|
|
return serializePropertySymbolForInterfaceWorker(p, false, baseType);
|
|
}
|
|
function serializeSignatures(kind, input, baseType, outputKind) {
|
|
const signatures = getSignaturesOfType(input, kind);
|
|
if (kind === 1 /* Construct */) {
|
|
if (!baseType && every(signatures, (s) => length(s.parameters) === 0)) {
|
|
return [];
|
|
}
|
|
if (baseType) {
|
|
const baseSigs = getSignaturesOfType(baseType, 1 /* Construct */);
|
|
if (!length(baseSigs) && every(signatures, (s) => length(s.parameters) === 0)) {
|
|
return [];
|
|
}
|
|
if (baseSigs.length === signatures.length) {
|
|
let failed = false;
|
|
for (let i = 0; i < baseSigs.length; i++) {
|
|
if (!compareSignaturesIdentical(signatures[i], baseSigs[i], false, false, true, compareTypesIdentical)) {
|
|
failed = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!failed) {
|
|
return [];
|
|
}
|
|
}
|
|
}
|
|
let privateProtected = 0;
|
|
for (const s of signatures) {
|
|
if (s.declaration) {
|
|
privateProtected |= getSelectedEffectiveModifierFlags(s.declaration, 8 /* Private */ | 16 /* Protected */);
|
|
}
|
|
}
|
|
if (privateProtected) {
|
|
return [setTextRange(factory.createConstructorDeclaration(
|
|
factory.createModifiersFromModifierFlags(privateProtected),
|
|
[],
|
|
void 0
|
|
), signatures[0].declaration)];
|
|
}
|
|
}
|
|
const results2 = [];
|
|
for (const sig of signatures) {
|
|
const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
|
|
results2.push(setTextRange(decl, sig.declaration));
|
|
}
|
|
return results2;
|
|
}
|
|
function serializeIndexSignatures(input, baseType) {
|
|
const results2 = [];
|
|
for (const info of getIndexInfosOfType(input)) {
|
|
if (baseType) {
|
|
const baseInfo = getIndexInfoOfType(baseType, info.keyType);
|
|
if (baseInfo) {
|
|
if (isTypeIdenticalTo(info.type, baseInfo.type)) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
results2.push(indexInfoToIndexSignatureDeclarationHelper(info, context, void 0));
|
|
}
|
|
return results2;
|
|
}
|
|
function serializeBaseType(t, staticType, rootName) {
|
|
const ref = trySerializeAsTypeReference(t, 111551 /* Value */);
|
|
if (ref) {
|
|
return ref;
|
|
}
|
|
const tempName = getUnusedName(`${rootName}_base`);
|
|
const statement = factory.createVariableStatement(void 0, factory.createVariableDeclarationList([
|
|
factory.createVariableDeclaration(tempName, void 0, typeToTypeNodeHelper(staticType, context))
|
|
], 2 /* Const */));
|
|
addResult(statement, 0 /* None */);
|
|
return factory.createExpressionWithTypeArguments(factory.createIdentifier(tempName), void 0);
|
|
}
|
|
function trySerializeAsTypeReference(t, flags) {
|
|
let typeArgs;
|
|
let reference;
|
|
if (t.target && isSymbolAccessibleByFlags(t.target.symbol, enclosingDeclaration, flags)) {
|
|
typeArgs = map(getTypeArguments(t), (t2) => typeToTypeNodeHelper(t2, context));
|
|
reference = symbolToExpression(t.target.symbol, context, 788968 /* Type */);
|
|
} else if (t.symbol && isSymbolAccessibleByFlags(t.symbol, enclosingDeclaration, flags)) {
|
|
reference = symbolToExpression(t.symbol, context, 788968 /* Type */);
|
|
}
|
|
if (reference) {
|
|
return factory.createExpressionWithTypeArguments(reference, typeArgs);
|
|
}
|
|
}
|
|
function serializeImplementedType(t) {
|
|
const ref = trySerializeAsTypeReference(t, 788968 /* Type */);
|
|
if (ref) {
|
|
return ref;
|
|
}
|
|
if (t.symbol) {
|
|
return factory.createExpressionWithTypeArguments(symbolToExpression(t.symbol, context, 788968 /* Type */), void 0);
|
|
}
|
|
}
|
|
function getUnusedName(input, symbol) {
|
|
var _a2, _b;
|
|
const id = symbol ? getSymbolId(symbol) : void 0;
|
|
if (id) {
|
|
if (context.remappedSymbolNames.has(id)) {
|
|
return context.remappedSymbolNames.get(id);
|
|
}
|
|
}
|
|
if (symbol) {
|
|
input = getNameCandidateWorker(symbol, input);
|
|
}
|
|
let i = 0;
|
|
const original = input;
|
|
while ((_a2 = context.usedSymbolNames) == null ? void 0 : _a2.has(input)) {
|
|
i++;
|
|
input = `${original}_${i}`;
|
|
}
|
|
(_b = context.usedSymbolNames) == null ? void 0 : _b.add(input);
|
|
if (id) {
|
|
context.remappedSymbolNames.set(id, input);
|
|
}
|
|
return input;
|
|
}
|
|
function getNameCandidateWorker(symbol, localName) {
|
|
if (localName === "default" /* Default */ || localName === "__class" /* Class */ || localName === "__function" /* Function */) {
|
|
const flags = context.flags;
|
|
context.flags |= 16777216 /* InInitialEntityName */;
|
|
const nameCandidate = getNameOfSymbolAsWritten(symbol, context);
|
|
context.flags = flags;
|
|
localName = nameCandidate.length > 0 && isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? stripQuotes(nameCandidate) : nameCandidate;
|
|
}
|
|
if (localName === "default" /* Default */) {
|
|
localName = "_default";
|
|
} else if (localName === "export=" /* ExportEquals */) {
|
|
localName = "_exports";
|
|
}
|
|
localName = isIdentifierText(localName, languageVersion) && !isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_");
|
|
return localName;
|
|
}
|
|
function getInternalSymbolName(symbol, localName) {
|
|
const id = getSymbolId(symbol);
|
|
if (context.remappedSymbolNames.has(id)) {
|
|
return context.remappedSymbolNames.get(id);
|
|
}
|
|
localName = getNameCandidateWorker(symbol, localName);
|
|
context.remappedSymbolNames.set(id, localName);
|
|
return localName;
|
|
}
|
|
}
|
|
}
|
|
function typePredicateToString(typePredicate, enclosingDeclaration, flags = 16384 /* UseAliasDefinedOutsideCurrentScope */, writer) {
|
|
return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
|
|
function typePredicateToStringWorker(writer2) {
|
|
const predicate = factory.createTypePredicateNode(
|
|
typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(129 /* AssertsKeyword */) : void 0,
|
|
typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createIdentifier(typePredicate.parameterName) : factory.createThisTypeNode(),
|
|
typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */)
|
|
);
|
|
const printer = createPrinter({ removeComments: true });
|
|
const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
|
|
printer.writeNode(4 /* Unspecified */, predicate, sourceFile, writer2);
|
|
return writer2;
|
|
}
|
|
}
|
|
function formatUnionTypes(types) {
|
|
const result = [];
|
|
let flags = 0;
|
|
for (let i = 0; i < types.length; i++) {
|
|
const t = types[i];
|
|
flags |= t.flags;
|
|
if (!(t.flags & 98304 /* Nullable */)) {
|
|
if (t.flags & (512 /* BooleanLiteral */ | 1024 /* EnumLiteral */)) {
|
|
const baseType = t.flags & 512 /* BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLiteralType(t);
|
|
if (baseType.flags & 1048576 /* Union */) {
|
|
const count = baseType.types.length;
|
|
if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) {
|
|
result.push(baseType);
|
|
i += count - 1;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
result.push(t);
|
|
}
|
|
}
|
|
if (flags & 65536 /* Null */)
|
|
result.push(nullType);
|
|
if (flags & 32768 /* Undefined */)
|
|
result.push(undefinedType);
|
|
return result || types;
|
|
}
|
|
function visibilityToString(flags) {
|
|
if (flags === 8 /* Private */) {
|
|
return "private";
|
|
}
|
|
if (flags === 16 /* Protected */) {
|
|
return "protected";
|
|
}
|
|
return "public";
|
|
}
|
|
function getTypeAliasForTypeLiteral(type) {
|
|
if (type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && type.symbol.declarations) {
|
|
const node = walkUpParenthesizedTypes(type.symbol.declarations[0].parent);
|
|
if (node.kind === 262 /* TypeAliasDeclaration */) {
|
|
return getSymbolOfNode(node);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isTopLevelInExternalModuleAugmentation(node) {
|
|
return node && node.parent && node.parent.kind === 265 /* ModuleBlock */ && isExternalModuleAugmentation(node.parent.parent);
|
|
}
|
|
function isDefaultBindingContext(location2) {
|
|
return location2.kind === 308 /* SourceFile */ || isAmbientModule(location2);
|
|
}
|
|
function getNameOfSymbolFromNameType(symbol, context) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType) {
|
|
if (nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const name = "" + nameType.value;
|
|
if (!isIdentifierText(name, getEmitScriptTarget(compilerOptions)) && !isNumericLiteralName(name)) {
|
|
return `"${escapeString(name, 34 /* doubleQuote */)}"`;
|
|
}
|
|
if (isNumericLiteralName(name) && startsWith(name, "-")) {
|
|
return `[${name}]`;
|
|
}
|
|
return name;
|
|
}
|
|
if (nameType.flags & 8192 /* UniqueESSymbol */) {
|
|
return `[${getNameOfSymbolAsWritten(nameType.symbol, context)}]`;
|
|
}
|
|
}
|
|
}
|
|
function getNameOfSymbolAsWritten(symbol, context) {
|
|
if (context && symbol.escapedName === "default" /* Default */ && !(context.flags & 16384 /* UseAliasDefinedOutsideCurrentScope */) && (!(context.flags & 16777216 /* InInitialEntityName */) || !symbol.declarations || context.enclosingDeclaration && findAncestor(symbol.declarations[0], isDefaultBindingContext) !== findAncestor(context.enclosingDeclaration, isDefaultBindingContext))) {
|
|
return "default";
|
|
}
|
|
if (symbol.declarations && symbol.declarations.length) {
|
|
let declaration = firstDefined(symbol.declarations, (d) => getNameOfDeclaration(d) ? d : void 0);
|
|
const name2 = declaration && getNameOfDeclaration(declaration);
|
|
if (declaration && name2) {
|
|
if (isCallExpression(declaration) && isBindableObjectDefinePropertyCall(declaration)) {
|
|
return symbolName(symbol);
|
|
}
|
|
if (isComputedPropertyName(name2) && !(getCheckFlags(symbol) & 4096 /* Late */)) {
|
|
const nameType = getSymbolLinks(symbol).nameType;
|
|
if (nameType && nameType.flags & 384 /* StringOrNumberLiteral */) {
|
|
const result = getNameOfSymbolFromNameType(symbol, context);
|
|
if (result !== void 0) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return declarationNameToString(name2);
|
|
}
|
|
if (!declaration) {
|
|
declaration = symbol.declarations[0];
|
|
}
|
|
if (declaration.parent && declaration.parent.kind === 257 /* VariableDeclaration */) {
|
|
return declarationNameToString(declaration.parent.name);
|
|
}
|
|
switch (declaration.kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (context && !context.encounteredError && !(context.flags & 131072 /* AllowAnonymousIdentifier */)) {
|
|
context.encounteredError = true;
|
|
}
|
|
return declaration.kind === 228 /* ClassExpression */ ? "(Anonymous class)" : "(Anonymous function)";
|
|
}
|
|
}
|
|
const name = getNameOfSymbolFromNameType(symbol, context);
|
|
return name !== void 0 ? name : symbolName(symbol);
|
|
}
|
|
function isDeclarationVisible(node) {
|
|
if (node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.isVisible === void 0) {
|
|
links.isVisible = !!determineIfDeclarationIsVisible();
|
|
}
|
|
return links.isVisible;
|
|
}
|
|
return false;
|
|
function determineIfDeclarationIsVisible() {
|
|
switch (node.kind) {
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return !!(node.parent && node.parent.parent && node.parent.parent.parent && isSourceFile(node.parent.parent.parent));
|
|
case 205 /* BindingElement */:
|
|
return isDeclarationVisible(node.parent.parent);
|
|
case 257 /* VariableDeclaration */:
|
|
if (isBindingPattern(node.name) && !node.name.elements.length) {
|
|
return false;
|
|
}
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (isExternalModuleAugmentation(node)) {
|
|
return true;
|
|
}
|
|
const parent2 = getDeclarationContainer(node);
|
|
if (!(getCombinedModifierFlags(node) & 1 /* Export */) && !(node.kind !== 268 /* ImportEqualsDeclaration */ && parent2.kind !== 308 /* SourceFile */ && parent2.flags & 16777216 /* Ambient */)) {
|
|
return isGlobalSourceFile(parent2);
|
|
}
|
|
return isDeclarationVisible(parent2);
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (hasEffectiveModifier(node, 8 /* Private */ | 16 /* Protected */)) {
|
|
return false;
|
|
}
|
|
case 173 /* Constructor */:
|
|
case 177 /* ConstructSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 166 /* Parameter */:
|
|
case 265 /* ModuleBlock */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 180 /* TypeReference */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
return isDeclarationVisible(node.parent);
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
return false;
|
|
case 165 /* TypeParameter */:
|
|
case 308 /* SourceFile */:
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return true;
|
|
case 274 /* ExportAssignment */:
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
function collectLinkedAliases(node, setVisibility) {
|
|
let exportSymbol;
|
|
if (node.parent && node.parent.kind === 274 /* ExportAssignment */) {
|
|
exportSymbol = resolveName(node, node.escapedText, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */, void 0, node, false);
|
|
} else if (node.parent.kind === 278 /* ExportSpecifier */) {
|
|
exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
}
|
|
let result;
|
|
let visited;
|
|
if (exportSymbol) {
|
|
visited = /* @__PURE__ */ new Set();
|
|
visited.add(getSymbolId(exportSymbol));
|
|
buildVisibleNodeList(exportSymbol.declarations);
|
|
}
|
|
return result;
|
|
function buildVisibleNodeList(declarations) {
|
|
forEach(declarations, (declaration) => {
|
|
const resultNode = getAnyImportSyntax(declaration) || declaration;
|
|
if (setVisibility) {
|
|
getNodeLinks(declaration).isVisible = true;
|
|
} else {
|
|
result = result || [];
|
|
pushIfUnique(result, resultNode);
|
|
}
|
|
if (isInternalModuleImportEqualsDeclaration(declaration)) {
|
|
const internalModuleReference = declaration.moduleReference;
|
|
const firstIdentifier = getFirstIdentifier(internalModuleReference);
|
|
const importSymbol = resolveName(
|
|
declaration,
|
|
firstIdentifier.escapedText,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */,
|
|
void 0,
|
|
void 0,
|
|
false
|
|
);
|
|
if (importSymbol && visited) {
|
|
if (tryAddToSet(visited, getSymbolId(importSymbol))) {
|
|
buildVisibleNodeList(importSymbol.declarations);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function pushTypeResolution(target, propertyName) {
|
|
const resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
|
|
if (resolutionCycleStartIndex >= 0) {
|
|
const { length: length2 } = resolutionTargets;
|
|
for (let i = resolutionCycleStartIndex; i < length2; i++) {
|
|
resolutionResults[i] = false;
|
|
}
|
|
return false;
|
|
}
|
|
resolutionTargets.push(target);
|
|
resolutionResults.push(true);
|
|
resolutionPropertyNames.push(propertyName);
|
|
return true;
|
|
}
|
|
function findResolutionCycleStartIndex(target, propertyName) {
|
|
for (let i = resolutionTargets.length - 1; i >= 0; i--) {
|
|
if (hasType2(resolutionTargets[i], resolutionPropertyNames[i])) {
|
|
return -1;
|
|
}
|
|
if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function hasType2(target, propertyName) {
|
|
switch (propertyName) {
|
|
case 0 /* Type */:
|
|
return !!getSymbolLinks(target).type;
|
|
case 5 /* EnumTagType */:
|
|
return !!getNodeLinks(target).resolvedEnumType;
|
|
case 2 /* DeclaredType */:
|
|
return !!getSymbolLinks(target).declaredType;
|
|
case 1 /* ResolvedBaseConstructorType */:
|
|
return !!target.resolvedBaseConstructorType;
|
|
case 3 /* ResolvedReturnType */:
|
|
return !!target.resolvedReturnType;
|
|
case 4 /* ImmediateBaseConstraint */:
|
|
return !!target.immediateBaseConstraint;
|
|
case 6 /* ResolvedTypeArguments */:
|
|
return !!target.resolvedTypeArguments;
|
|
case 7 /* ResolvedBaseTypes */:
|
|
return !!target.baseTypesResolved;
|
|
case 8 /* WriteType */:
|
|
return !!getSymbolLinks(target).writeType;
|
|
}
|
|
return Debug.assertNever(propertyName);
|
|
}
|
|
function popTypeResolution() {
|
|
resolutionTargets.pop();
|
|
resolutionPropertyNames.pop();
|
|
return resolutionResults.pop();
|
|
}
|
|
function getDeclarationContainer(node) {
|
|
return findAncestor(getRootDeclaration(node), (node2) => {
|
|
switch (node2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 258 /* VariableDeclarationList */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 272 /* NamedImports */:
|
|
case 271 /* NamespaceImport */:
|
|
case 270 /* ImportClause */:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}).parent;
|
|
}
|
|
function getTypeOfPrototypeProperty(prototype) {
|
|
const classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype));
|
|
return classType.typeParameters ? createTypeReference(classType, map(classType.typeParameters, (_) => anyType)) : classType;
|
|
}
|
|
function getTypeOfPropertyOfType(type, name) {
|
|
const prop = getPropertyOfType(type, name);
|
|
return prop ? getTypeOfSymbol(prop) : void 0;
|
|
}
|
|
function getTypeOfPropertyOrIndexSignature(type, name) {
|
|
var _a2;
|
|
return getTypeOfPropertyOfType(type, name) || ((_a2 = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a2.type) || unknownType;
|
|
}
|
|
function isTypeAny(type) {
|
|
return type && (type.flags & 1 /* Any */) !== 0;
|
|
}
|
|
function isErrorType(type) {
|
|
return type === errorType || !!(type.flags & 1 /* Any */ && type.aliasSymbol);
|
|
}
|
|
function getTypeForBindingElementParent(node, checkMode) {
|
|
if (checkMode !== 0 /* Normal */) {
|
|
return getTypeForVariableLikeDeclaration(node, false, checkMode);
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, false, checkMode);
|
|
}
|
|
function getRestType(source, properties, symbol) {
|
|
source = filterType(source, (t) => !(t.flags & 98304 /* Nullable */));
|
|
if (source.flags & 131072 /* Never */) {
|
|
return emptyObjectType;
|
|
}
|
|
if (source.flags & 1048576 /* Union */) {
|
|
return mapType(source, (t) => getRestType(t, properties, symbol));
|
|
}
|
|
let omitKeyType = getUnionType(map(properties, getLiteralTypeFromPropertyName));
|
|
const spreadableProperties = [];
|
|
const unspreadableToRestKeys = [];
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
const literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */);
|
|
if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) && !(getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) && isSpreadableProperty(prop)) {
|
|
spreadableProperties.push(prop);
|
|
} else {
|
|
unspreadableToRestKeys.push(literalTypeFromProperty);
|
|
}
|
|
}
|
|
if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) {
|
|
if (unspreadableToRestKeys.length) {
|
|
omitKeyType = getUnionType([omitKeyType, ...unspreadableToRestKeys]);
|
|
}
|
|
if (omitKeyType.flags & 131072 /* Never */) {
|
|
return source;
|
|
}
|
|
const omitTypeAlias = getGlobalOmitSymbol();
|
|
if (!omitTypeAlias) {
|
|
return errorType;
|
|
}
|
|
return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
|
|
}
|
|
const members = createSymbolTable();
|
|
for (const prop of spreadableProperties) {
|
|
members.set(prop.escapedName, getSpreadSymbol(prop, false));
|
|
}
|
|
const result = createAnonymousType(symbol, members, emptyArray, emptyArray, getIndexInfosOfType(source));
|
|
result.objectFlags |= 4194304 /* ObjectRestType */;
|
|
return result;
|
|
}
|
|
function isGenericTypeWithUndefinedConstraint(type) {
|
|
return !!(type.flags & 465829888 /* Instantiable */) && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 32768 /* Undefined */);
|
|
}
|
|
function getNonUndefinedType(type) {
|
|
const typeOrConstraint = someType(type, isGenericTypeWithUndefinedConstraint) ? mapType(type, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t) : type;
|
|
return getTypeWithFacts(typeOrConstraint, 524288 /* NEUndefined */);
|
|
}
|
|
function getFlowTypeOfDestructuring(node, declaredType) {
|
|
const reference = getSyntheticElementAccess(node);
|
|
return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType;
|
|
}
|
|
function getSyntheticElementAccess(node) {
|
|
const parentAccess = getParentElementAccess(node);
|
|
if (parentAccess && parentAccess.flowNode) {
|
|
const propName = getDestructuringPropertyName(node);
|
|
if (propName) {
|
|
const literal = setTextRange(parseNodeFactory.createStringLiteral(propName), node);
|
|
const lhsExpr = isLeftHandSideExpression(parentAccess) ? parentAccess : parseNodeFactory.createParenthesizedExpression(parentAccess);
|
|
const result = setTextRange(parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
|
|
setParent(literal, result);
|
|
setParent(result, node);
|
|
if (lhsExpr !== parentAccess) {
|
|
setParent(lhsExpr, result);
|
|
}
|
|
result.flowNode = parentAccess.flowNode;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function getParentElementAccess(node) {
|
|
const ancestor = node.parent.parent;
|
|
switch (ancestor.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 299 /* PropertyAssignment */:
|
|
return getSyntheticElementAccess(ancestor);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return getSyntheticElementAccess(node.parent);
|
|
case 257 /* VariableDeclaration */:
|
|
return ancestor.initializer;
|
|
case 223 /* BinaryExpression */:
|
|
return ancestor.right;
|
|
}
|
|
}
|
|
function getDestructuringPropertyName(node) {
|
|
const parent2 = node.parent;
|
|
if (node.kind === 205 /* BindingElement */ && parent2.kind === 203 /* ObjectBindingPattern */) {
|
|
return getLiteralPropertyNameText(node.propertyName || node.name);
|
|
}
|
|
if (node.kind === 299 /* PropertyAssignment */ || node.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return getLiteralPropertyNameText(node.name);
|
|
}
|
|
return "" + parent2.elements.indexOf(node);
|
|
}
|
|
function getLiteralPropertyNameText(name) {
|
|
const type = getLiteralTypeFromPropertyName(name);
|
|
return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
|
|
}
|
|
function getTypeForBindingElement(declaration) {
|
|
const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
|
|
const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
|
|
return parentType && getBindingElementTypeFromParentType(declaration, parentType);
|
|
}
|
|
function getBindingElementTypeFromParentType(declaration, parentType) {
|
|
if (isTypeAny(parentType)) {
|
|
return parentType;
|
|
}
|
|
const pattern = declaration.parent;
|
|
if (strictNullChecks && declaration.flags & 16777216 /* Ambient */ && isParameterDeclaration(declaration)) {
|
|
parentType = getNonNullableType(parentType);
|
|
} else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* EQUndefined */)) {
|
|
parentType = getTypeWithFacts(parentType, 524288 /* NEUndefined */);
|
|
}
|
|
let type;
|
|
if (pattern.kind === 203 /* ObjectBindingPattern */) {
|
|
if (declaration.dotDotDotToken) {
|
|
parentType = getReducedType(parentType);
|
|
if (parentType.flags & 2 /* Unknown */ || !isValidSpreadType(parentType)) {
|
|
error(declaration, Diagnostics.Rest_types_may_only_be_created_from_object_types);
|
|
return errorType;
|
|
}
|
|
const literalMembers = [];
|
|
for (const element of pattern.elements) {
|
|
if (!element.dotDotDotToken) {
|
|
literalMembers.push(element.propertyName || element.name);
|
|
}
|
|
}
|
|
type = getRestType(parentType, literalMembers, declaration.symbol);
|
|
} else {
|
|
const name = declaration.propertyName || declaration.name;
|
|
const indexType = getLiteralTypeFromPropertyName(name);
|
|
const declaredType = getIndexedAccessType(parentType, indexType, 32 /* ExpressionPosition */, name);
|
|
type = getFlowTypeOfDestructuring(declaration, declaredType);
|
|
}
|
|
} else {
|
|
const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */ | (declaration.dotDotDotToken ? 0 : 128 /* PossiblyOutOfBounds */), parentType, undefinedType, pattern);
|
|
const index = pattern.elements.indexOf(declaration);
|
|
if (declaration.dotDotDotToken) {
|
|
type = everyType(parentType, isTupleType) ? mapType(parentType, (t) => sliceTupleType(t, index)) : createArrayType(elementType);
|
|
} else if (isArrayLikeType(parentType)) {
|
|
const indexType = getNumberLiteralType(index);
|
|
const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(declaration) ? 16 /* NoTupleBoundsCheck */ : 0);
|
|
const declaredType = getIndexedAccessTypeOrUndefined(parentType, indexType, accessFlags, declaration.name) || errorType;
|
|
type = getFlowTypeOfDestructuring(declaration, declaredType);
|
|
} else {
|
|
type = elementType;
|
|
}
|
|
}
|
|
if (!declaration.initializer) {
|
|
return type;
|
|
}
|
|
if (getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration))) {
|
|
return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
|
|
}
|
|
return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
|
|
}
|
|
function getTypeForDeclarationFromJSDocComment(declaration) {
|
|
const jsdocType = getJSDocType(declaration);
|
|
if (jsdocType) {
|
|
return getTypeFromTypeNode(jsdocType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isNullOrUndefined3(node) {
|
|
const expr = skipParentheses(node, true);
|
|
return expr.kind === 104 /* NullKeyword */ || expr.kind === 79 /* Identifier */ && getResolvedSymbol(expr) === undefinedSymbol;
|
|
}
|
|
function isEmptyArrayLiteral2(node) {
|
|
const expr = skipParentheses(node, true);
|
|
return expr.kind === 206 /* ArrayLiteralExpression */ && expr.elements.length === 0;
|
|
}
|
|
function addOptionality(type, isProperty = false, isOptional = true) {
|
|
return strictNullChecks && isOptional ? getOptionalType(type, isProperty) : type;
|
|
}
|
|
function getTypeForVariableLikeDeclaration(declaration, includeOptionality, checkMode) {
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 246 /* ForInStatement */) {
|
|
const indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression, checkMode)));
|
|
return indexType.flags & (262144 /* TypeParameter */ | 4194304 /* Index */) ? getExtractStringType(indexType) : stringType;
|
|
}
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
const forOfStatement = declaration.parent.parent;
|
|
return checkRightHandSideOfForOf(forOfStatement) || anyType;
|
|
}
|
|
if (isBindingPattern(declaration.parent)) {
|
|
return getTypeForBindingElement(declaration);
|
|
}
|
|
const isProperty = isPropertyDeclaration(declaration) && !hasAccessorModifier(declaration) || isPropertySignature(declaration);
|
|
const isOptional = includeOptionality && (isProperty && !!declaration.questionToken || isParameter(declaration) && (!!declaration.questionToken || isJSDocOptionalParameter(declaration)) || isOptionalJSDocPropertyLikeTag(declaration));
|
|
const declaredType = tryGetTypeFromEffectiveTypeNode(declaration);
|
|
if (declaredType) {
|
|
return addOptionality(declaredType, isProperty, isOptional);
|
|
}
|
|
if ((noImplicitAny || isInJSFile(declaration)) && isVariableDeclaration(declaration) && !isBindingPattern(declaration.name) && !(getCombinedModifierFlags(declaration) & 1 /* Export */) && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
if (!(getCombinedNodeFlags(declaration) & 2 /* Const */) && (!declaration.initializer || isNullOrUndefined3(declaration.initializer))) {
|
|
return autoType;
|
|
}
|
|
if (declaration.initializer && isEmptyArrayLiteral2(declaration.initializer)) {
|
|
return autoArrayType;
|
|
}
|
|
}
|
|
if (isParameter(declaration)) {
|
|
const func = declaration.parent;
|
|
if (func.kind === 175 /* SetAccessor */ && hasBindableName(func)) {
|
|
const getter = getDeclarationOfKind(getSymbolOfNode(declaration.parent), 174 /* GetAccessor */);
|
|
if (getter) {
|
|
const getterSignature = getSignatureFromDeclaration(getter);
|
|
const thisParameter = getAccessorThisParameter(func);
|
|
if (thisParameter && declaration === thisParameter) {
|
|
Debug.assert(!thisParameter.type);
|
|
return getTypeOfSymbol(getterSignature.thisParameter);
|
|
}
|
|
return getReturnTypeOfSignature(getterSignature);
|
|
}
|
|
}
|
|
const parameterTypeOfTypeTag = getParameterTypeOfTypeTag(func, declaration);
|
|
if (parameterTypeOfTypeTag)
|
|
return parameterTypeOfTypeTag;
|
|
const type = declaration.symbol.escapedName === "this" /* This */ ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration);
|
|
if (type) {
|
|
return addOptionality(type, false, isOptional);
|
|
}
|
|
}
|
|
if (hasOnlyExpressionInitializer(declaration) && !!declaration.initializer) {
|
|
if (isInJSFile(declaration) && !isParameter(declaration)) {
|
|
const containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), getDeclaredExpandoInitializer(declaration));
|
|
if (containerObjectType) {
|
|
return containerObjectType;
|
|
}
|
|
}
|
|
const type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, checkMode));
|
|
return addOptionality(type, isProperty, isOptional);
|
|
}
|
|
if (isPropertyDeclaration(declaration) && (noImplicitAny || isInJSFile(declaration))) {
|
|
if (!hasStaticModifier(declaration)) {
|
|
const constructor = findConstructorDeclaration(declaration.parent);
|
|
const type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
|
|
return type && addOptionality(type, true, isOptional);
|
|
} else {
|
|
const staticBlocks = filter(declaration.parent.members, isClassStaticBlockDeclaration);
|
|
const type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : getEffectiveModifierFlags(declaration) & 2 /* Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : void 0;
|
|
return type && addOptionality(type, true, isOptional);
|
|
}
|
|
}
|
|
if (isJsxAttribute(declaration)) {
|
|
return trueType;
|
|
}
|
|
if (isBindingPattern(declaration.name)) {
|
|
return getTypeFromBindingPattern(declaration.name, false, true);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isConstructorDeclaredProperty(symbol) {
|
|
if (symbol.valueDeclaration && isBinaryExpression(symbol.valueDeclaration)) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.isConstructorDeclaredProperty === void 0) {
|
|
links.isConstructorDeclaredProperty = false;
|
|
links.isConstructorDeclaredProperty = !!getDeclaringConstructor(symbol) && every(symbol.declarations, (declaration) => isBinaryExpression(declaration) && isPossiblyAliasedThisProperty(declaration) && (declaration.left.kind !== 209 /* ElementAccessExpression */ || isStringOrNumericLiteralLike(declaration.left.argumentExpression)) && !getAnnotatedTypeForAssignmentDeclaration(void 0, declaration, symbol, declaration));
|
|
}
|
|
return links.isConstructorDeclaredProperty;
|
|
}
|
|
return false;
|
|
}
|
|
function isAutoTypedProperty(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
return declaration && isPropertyDeclaration(declaration) && !getEffectiveTypeAnnotationNode(declaration) && !declaration.initializer && (noImplicitAny || isInJSFile(declaration));
|
|
}
|
|
function getDeclaringConstructor(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
const container = getThisContainer(declaration, false);
|
|
if (container && (container.kind === 173 /* Constructor */ || isJSConstructor(container))) {
|
|
return container;
|
|
}
|
|
}
|
|
}
|
|
function getFlowTypeFromCommonJSExport(symbol) {
|
|
const file = getSourceFileOfNode(symbol.declarations[0]);
|
|
const accessName = unescapeLeadingUnderscores(symbol.escapedName);
|
|
const areAllModuleExports = symbol.declarations.every((d) => isInJSFile(d) && isAccessExpression(d) && isModuleExportsAccessExpression(d.expression));
|
|
const reference = areAllModuleExports ? factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier("module"), factory.createIdentifier("exports")), accessName) : factory.createPropertyAccessExpression(factory.createIdentifier("exports"), accessName);
|
|
if (areAllModuleExports) {
|
|
setParent(reference.expression.expression, reference.expression);
|
|
}
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, file);
|
|
reference.flowNode = file.endFlowNode;
|
|
return getFlowTypeOfReference(reference, autoType, undefinedType);
|
|
}
|
|
function getFlowTypeInStaticBlocks(symbol, staticBlocks) {
|
|
const accessName = startsWith(symbol.escapedName, "__#") ? factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) : unescapeLeadingUnderscores(symbol.escapedName);
|
|
for (const staticBlock of staticBlocks) {
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), accessName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, staticBlock);
|
|
reference.flowNode = staticBlock.returnFlowNode;
|
|
const flowType = getFlowTypeOfProperty(reference, symbol);
|
|
if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) {
|
|
error(symbol.valueDeclaration, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
if (everyType(flowType, isNullableType)) {
|
|
continue;
|
|
}
|
|
return convertAutoToAny(flowType);
|
|
}
|
|
}
|
|
function getFlowTypeInConstructor(symbol, constructor) {
|
|
const accessName = startsWith(symbol.escapedName, "__#") ? factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) : unescapeLeadingUnderscores(symbol.escapedName);
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), accessName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, constructor);
|
|
reference.flowNode = constructor.returnFlowNode;
|
|
const flowType = getFlowTypeOfProperty(reference, symbol);
|
|
if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) {
|
|
error(symbol.valueDeclaration, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
return everyType(flowType, isNullableType) ? void 0 : convertAutoToAny(flowType);
|
|
}
|
|
function getFlowTypeOfProperty(reference, prop) {
|
|
const initialType = (prop == null ? void 0 : prop.valueDeclaration) && (!isAutoTypedProperty(prop) || getEffectiveModifierFlags(prop.valueDeclaration) & 2 /* Ambient */) && getTypeOfPropertyInBaseClass(prop) || undefinedType;
|
|
return getFlowTypeOfReference(reference, autoType, initialType);
|
|
}
|
|
function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) {
|
|
const container = getAssignedExpandoInitializer(symbol.valueDeclaration);
|
|
if (container) {
|
|
const tag = getJSDocTypeTag(container);
|
|
if (tag && tag.typeExpression) {
|
|
return getTypeFromTypeNode(tag.typeExpression);
|
|
}
|
|
const containerObjectType = symbol.valueDeclaration && getJSContainerObjectType(symbol.valueDeclaration, symbol, container);
|
|
return containerObjectType || getWidenedLiteralType(checkExpressionCached(container));
|
|
}
|
|
let type;
|
|
let definedInConstructor = false;
|
|
let definedInMethod = false;
|
|
if (isConstructorDeclaredProperty(symbol)) {
|
|
type = getFlowTypeInConstructor(symbol, getDeclaringConstructor(symbol));
|
|
}
|
|
if (!type) {
|
|
let types;
|
|
if (symbol.declarations) {
|
|
let jsdocType;
|
|
for (const declaration of symbol.declarations) {
|
|
const expression = isBinaryExpression(declaration) || isCallExpression(declaration) ? declaration : isAccessExpression(declaration) ? isBinaryExpression(declaration.parent) ? declaration.parent : declaration : void 0;
|
|
if (!expression) {
|
|
continue;
|
|
}
|
|
const kind = isAccessExpression(expression) ? getAssignmentDeclarationPropertyAccessKind(expression) : getAssignmentDeclarationKind(expression);
|
|
if (kind === 4 /* ThisProperty */ || isBinaryExpression(expression) && isPossiblyAliasedThisProperty(expression, kind)) {
|
|
if (isDeclarationInConstructor(expression)) {
|
|
definedInConstructor = true;
|
|
} else {
|
|
definedInMethod = true;
|
|
}
|
|
}
|
|
if (!isCallExpression(expression)) {
|
|
jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration);
|
|
}
|
|
if (!jsdocType) {
|
|
(types || (types = [])).push(isBinaryExpression(expression) || isCallExpression(expression) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType);
|
|
}
|
|
}
|
|
type = jsdocType;
|
|
}
|
|
if (!type) {
|
|
if (!length(types)) {
|
|
return errorType;
|
|
}
|
|
let constructorTypes = definedInConstructor && symbol.declarations ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : void 0;
|
|
if (definedInMethod) {
|
|
const propType = getTypeOfPropertyInBaseClass(symbol);
|
|
if (propType) {
|
|
(constructorTypes || (constructorTypes = [])).push(propType);
|
|
definedInConstructor = true;
|
|
}
|
|
}
|
|
const sourceTypes = some(constructorTypes, (t) => !!(t.flags & ~98304 /* Nullable */)) ? constructorTypes : types;
|
|
type = getUnionType(sourceTypes);
|
|
}
|
|
}
|
|
const widened = getWidenedType(addOptionality(type, false, definedInMethod && !definedInConstructor));
|
|
if (symbol.valueDeclaration && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
|
|
reportImplicitAny(symbol.valueDeclaration, anyType);
|
|
return anyType;
|
|
}
|
|
return widened;
|
|
}
|
|
function getJSContainerObjectType(decl, symbol, init) {
|
|
var _a2, _b;
|
|
if (!isInJSFile(decl) || !init || !isObjectLiteralExpression(init) || init.properties.length) {
|
|
return void 0;
|
|
}
|
|
const exports = createSymbolTable();
|
|
while (isBinaryExpression(decl) || isPropertyAccessExpression(decl)) {
|
|
const s2 = getSymbolOfNode(decl);
|
|
if ((_a2 = s2 == null ? void 0 : s2.exports) == null ? void 0 : _a2.size) {
|
|
mergeSymbolTable(exports, s2.exports);
|
|
}
|
|
decl = isBinaryExpression(decl) ? decl.parent : decl.parent.parent;
|
|
}
|
|
const s = getSymbolOfNode(decl);
|
|
if ((_b = s == null ? void 0 : s.exports) == null ? void 0 : _b.size) {
|
|
mergeSymbolTable(exports, s.exports);
|
|
}
|
|
const type = createAnonymousType(symbol, exports, emptyArray, emptyArray, emptyArray);
|
|
type.objectFlags |= 4096 /* JSLiteral */;
|
|
return type;
|
|
}
|
|
function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) {
|
|
var _a2;
|
|
const typeNode = getEffectiveTypeAnnotationNode(expression.parent);
|
|
if (typeNode) {
|
|
const type = getWidenedType(getTypeFromTypeNode(typeNode));
|
|
if (!declaredType) {
|
|
return type;
|
|
} else if (!isErrorType(declaredType) && !isErrorType(type) && !isTypeIdenticalTo(declaredType, type)) {
|
|
errorNextVariableOrPropertyDeclarationMustHaveSameType(void 0, declaredType, declaration, type);
|
|
}
|
|
}
|
|
if ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) {
|
|
const typeNode2 = getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration);
|
|
if (typeNode2) {
|
|
const annotationSymbol = getPropertyOfType(getTypeFromTypeNode(typeNode2), symbol.escapedName);
|
|
if (annotationSymbol) {
|
|
return getNonMissingTypeOfSymbol(annotationSymbol);
|
|
}
|
|
}
|
|
}
|
|
return declaredType;
|
|
}
|
|
function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) {
|
|
if (isCallExpression(expression)) {
|
|
if (resolvedSymbol) {
|
|
return getTypeOfSymbol(resolvedSymbol);
|
|
}
|
|
const objectLitType = checkExpressionCached(expression.arguments[2]);
|
|
const valueType = getTypeOfPropertyOfType(objectLitType, "value");
|
|
if (valueType) {
|
|
return valueType;
|
|
}
|
|
const getFunc = getTypeOfPropertyOfType(objectLitType, "get");
|
|
if (getFunc) {
|
|
const getSig = getSingleCallSignature(getFunc);
|
|
if (getSig) {
|
|
return getReturnTypeOfSignature(getSig);
|
|
}
|
|
}
|
|
const setFunc = getTypeOfPropertyOfType(objectLitType, "set");
|
|
if (setFunc) {
|
|
const setSig = getSingleCallSignature(setFunc);
|
|
if (setSig) {
|
|
return getTypeOfFirstParameterOfSignature(setSig);
|
|
}
|
|
}
|
|
return anyType;
|
|
}
|
|
if (containsSameNamedThisProperty(expression.left, expression.right)) {
|
|
return anyType;
|
|
}
|
|
const isDirectExport = kind === 1 /* ExportsProperty */ && (isPropertyAccessExpression(expression.left) || isElementAccessExpression(expression.left)) && (isModuleExportsAccessExpression(expression.left.expression) || isIdentifier(expression.left.expression) && isExportsIdentifier(expression.left.expression));
|
|
const type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : isDirectExport ? getRegularTypeOfLiteralType(checkExpressionCached(expression.right)) : getWidenedLiteralType(checkExpressionCached(expression.right));
|
|
if (type.flags & 524288 /* Object */ && kind === 2 /* ModuleExports */ && symbol.escapedName === "export=" /* ExportEquals */) {
|
|
const exportedType = resolveStructuredTypeMembers(type);
|
|
const members = createSymbolTable();
|
|
copyEntries(exportedType.members, members);
|
|
const initialSize = members.size;
|
|
if (resolvedSymbol && !resolvedSymbol.exports) {
|
|
resolvedSymbol.exports = createSymbolTable();
|
|
}
|
|
(resolvedSymbol || symbol).exports.forEach((s, name) => {
|
|
var _a2;
|
|
const exportedMember = members.get(name);
|
|
if (exportedMember && exportedMember !== s && !(s.flags & 2097152 /* Alias */)) {
|
|
if (s.flags & 111551 /* Value */ && exportedMember.flags & 111551 /* Value */) {
|
|
if (s.valueDeclaration && exportedMember.valueDeclaration && getSourceFileOfNode(s.valueDeclaration) !== getSourceFileOfNode(exportedMember.valueDeclaration)) {
|
|
const unescapedName = unescapeLeadingUnderscores(s.escapedName);
|
|
const exportedMemberName = ((_a2 = tryCast(exportedMember.valueDeclaration, isNamedDeclaration)) == null ? void 0 : _a2.name) || exportedMember.valueDeclaration;
|
|
addRelatedInfo(
|
|
error(s.valueDeclaration, Diagnostics.Duplicate_identifier_0, unescapedName),
|
|
createDiagnosticForNode(exportedMemberName, Diagnostics._0_was_also_declared_here, unescapedName)
|
|
);
|
|
addRelatedInfo(
|
|
error(exportedMemberName, Diagnostics.Duplicate_identifier_0, unescapedName),
|
|
createDiagnosticForNode(s.valueDeclaration, Diagnostics._0_was_also_declared_here, unescapedName)
|
|
);
|
|
}
|
|
const union = createSymbol(s.flags | exportedMember.flags, name);
|
|
union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]);
|
|
union.valueDeclaration = exportedMember.valueDeclaration;
|
|
union.declarations = concatenate(exportedMember.declarations, s.declarations);
|
|
members.set(name, union);
|
|
} else {
|
|
members.set(name, mergeSymbol(s, exportedMember));
|
|
}
|
|
} else {
|
|
members.set(name, s);
|
|
}
|
|
});
|
|
const result = createAnonymousType(
|
|
initialSize !== members.size ? void 0 : exportedType.symbol,
|
|
members,
|
|
exportedType.callSignatures,
|
|
exportedType.constructSignatures,
|
|
exportedType.indexInfos
|
|
);
|
|
if (initialSize === members.size) {
|
|
if (type.aliasSymbol) {
|
|
result.aliasSymbol = type.aliasSymbol;
|
|
result.aliasTypeArguments = type.aliasTypeArguments;
|
|
}
|
|
if (getObjectFlags(type) & 4 /* Reference */) {
|
|
result.aliasSymbol = type.symbol;
|
|
const args = getTypeArguments(type);
|
|
result.aliasTypeArguments = length(args) ? args : void 0;
|
|
}
|
|
}
|
|
result.objectFlags |= getObjectFlags(type) & 4096 /* JSLiteral */;
|
|
if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
|
|
result.objectFlags |= 16777216 /* IsClassInstanceClone */;
|
|
}
|
|
return result;
|
|
}
|
|
if (isEmptyArrayLiteralType(type)) {
|
|
reportImplicitAny(expression, anyArrayType);
|
|
return anyArrayType;
|
|
}
|
|
return type;
|
|
}
|
|
function containsSameNamedThisProperty(thisProperty, expression) {
|
|
return isPropertyAccessExpression(thisProperty) && thisProperty.expression.kind === 108 /* ThisKeyword */ && forEachChildRecursively(expression, (n) => isMatchingReference(thisProperty, n));
|
|
}
|
|
function isDeclarationInConstructor(expression) {
|
|
const thisContainer = getThisContainer(expression, false);
|
|
return thisContainer.kind === 173 /* Constructor */ || thisContainer.kind === 259 /* FunctionDeclaration */ || thisContainer.kind === 215 /* FunctionExpression */ && !isPrototypePropertyAssignment(thisContainer.parent);
|
|
}
|
|
function getConstructorDefinedThisAssignmentTypes(types, declarations) {
|
|
Debug.assert(types.length === declarations.length);
|
|
return types.filter((_, i) => {
|
|
const declaration = declarations[i];
|
|
const expression = isBinaryExpression(declaration) ? declaration : isBinaryExpression(declaration.parent) ? declaration.parent : void 0;
|
|
return expression && isDeclarationInConstructor(expression);
|
|
});
|
|
}
|
|
function getTypeFromBindingElement(element, includePatternInType, reportErrors2) {
|
|
if (element.initializer) {
|
|
const contextualType = isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, true, false) : unknownType;
|
|
return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
|
|
}
|
|
if (isBindingPattern(element.name)) {
|
|
return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2);
|
|
}
|
|
if (reportErrors2 && !declarationBelongsToPrivateAmbientMember(element)) {
|
|
reportImplicitAny(element, anyType);
|
|
}
|
|
return includePatternInType ? nonInferrableAnyType : anyType;
|
|
}
|
|
function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors2) {
|
|
const members = createSymbolTable();
|
|
let stringIndexInfo;
|
|
let objectFlags = 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
forEach(pattern.elements, (e) => {
|
|
const name = e.propertyName || e.name;
|
|
if (e.dotDotDotToken) {
|
|
stringIndexInfo = createIndexInfo(stringType, anyType, false);
|
|
return;
|
|
}
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (!isTypeUsableAsPropertyName(exprType)) {
|
|
objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
|
|
return;
|
|
}
|
|
const text = getPropertyNameFromType(exprType);
|
|
const flags = 4 /* Property */ | (e.initializer ? 16777216 /* Optional */ : 0);
|
|
const symbol = createSymbol(flags, text);
|
|
symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors2);
|
|
symbol.bindingElement = e;
|
|
members.set(symbol.escapedName, symbol);
|
|
});
|
|
const result = createAnonymousType(void 0, members, emptyArray, emptyArray, stringIndexInfo ? [stringIndexInfo] : emptyArray);
|
|
result.objectFlags |= objectFlags;
|
|
if (includePatternInType) {
|
|
result.pattern = pattern;
|
|
result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors2) {
|
|
const elements = pattern.elements;
|
|
const lastElement = lastOrUndefined(elements);
|
|
const restElement = lastElement && lastElement.kind === 205 /* BindingElement */ && lastElement.dotDotDotToken ? lastElement : void 0;
|
|
if (elements.length === 0 || elements.length === 1 && restElement) {
|
|
return languageVersion >= 2 /* ES2015 */ ? createIterableType(anyType) : anyArrayType;
|
|
}
|
|
const elementTypes = map(elements, (e) => isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors2));
|
|
const minLength = findLastIndex(elements, (e) => !(e === restElement || isOmittedExpression(e) || hasDefaultValue(e)), elements.length - 1) + 1;
|
|
const elementFlags = map(elements, (e, i) => e === restElement ? 4 /* Rest */ : i >= minLength ? 2 /* Optional */ : 1 /* Required */);
|
|
let result = createTupleType(elementTypes, elementFlags);
|
|
if (includePatternInType) {
|
|
result = cloneTypeReference(result);
|
|
result.pattern = pattern;
|
|
result.objectFlags |= 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeFromBindingPattern(pattern, includePatternInType = false, reportErrors2 = false) {
|
|
return pattern.kind === 203 /* ObjectBindingPattern */ ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors2) : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors2);
|
|
}
|
|
function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors2) {
|
|
return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, true, 0 /* Normal */), declaration, reportErrors2);
|
|
}
|
|
function isGlobalSymbolConstructor(node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const globalSymbol = getGlobalESSymbolConstructorTypeSymbol(false);
|
|
return globalSymbol && symbol && symbol === globalSymbol;
|
|
}
|
|
function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors2) {
|
|
if (type) {
|
|
if (type.flags & 4096 /* ESSymbol */ && isGlobalSymbolConstructor(declaration.parent)) {
|
|
type = getESSymbolLikeTypeForNode(declaration);
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorsFromWidening(declaration, type);
|
|
}
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && (isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) {
|
|
type = esSymbolType;
|
|
}
|
|
return getWidenedType(type);
|
|
}
|
|
type = isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType;
|
|
if (reportErrors2) {
|
|
if (!declarationBelongsToPrivateAmbientMember(declaration)) {
|
|
reportImplicitAny(declaration, type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function declarationBelongsToPrivateAmbientMember(declaration) {
|
|
const root = getRootDeclaration(declaration);
|
|
const memberDeclaration = root.kind === 166 /* Parameter */ ? root.parent : root;
|
|
return isPrivateWithinAmbient(memberDeclaration);
|
|
}
|
|
function tryGetTypeFromEffectiveTypeNode(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
}
|
|
function isParameterOfContextSensitiveSignature(symbol) {
|
|
let decl = symbol.valueDeclaration;
|
|
if (!decl) {
|
|
return false;
|
|
}
|
|
if (isBindingElement(decl)) {
|
|
decl = walkUpBindingElementsAndPatterns(decl);
|
|
}
|
|
if (isParameter(decl)) {
|
|
return isContextSensitiveFunctionOrObjectLiteralMethod(decl.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function getTypeOfVariableOrParameterOrProperty(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
|
|
if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
|
|
links.type = type;
|
|
}
|
|
return type;
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
|
|
if (symbol.flags & 4194304 /* Prototype */) {
|
|
return getTypeOfPrototypeProperty(symbol);
|
|
}
|
|
if (symbol === requireSymbol) {
|
|
return anyType;
|
|
}
|
|
if (symbol.flags & 134217728 /* ModuleExports */ && symbol.valueDeclaration) {
|
|
const fileSymbol = getSymbolOfNode(getSourceFileOfNode(symbol.valueDeclaration));
|
|
const 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 Map(fileSymbol.members);
|
|
if (fileSymbol.exports)
|
|
result.exports = new Map(fileSymbol.exports);
|
|
const members = createSymbolTable();
|
|
members.set("exports", result);
|
|
return createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
Debug.assertIsDefined(symbol.valueDeclaration);
|
|
const declaration = symbol.valueDeclaration;
|
|
if (isCatchClauseVariableDeclarationOrBindingElement(declaration)) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(declaration);
|
|
if (typeNode === void 0) {
|
|
return useUnknownInCatchVariables ? unknownType : anyType;
|
|
}
|
|
const type2 = getTypeOfNode(typeNode);
|
|
return isTypeAny(type2) || type2 === unknownType ? type2 : errorType;
|
|
}
|
|
if (isSourceFile(declaration) && isJsonSourceFile(declaration)) {
|
|
if (!declaration.statements.length) {
|
|
return emptyObjectType;
|
|
}
|
|
return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
|
|
}
|
|
if (isAccessor(declaration)) {
|
|
return getTypeOfAccessors(symbol);
|
|
}
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
return reportCircularityError(symbol);
|
|
}
|
|
let type;
|
|
if (declaration.kind === 274 /* ExportAssignment */) {
|
|
type = widenTypeForVariableLikeDeclaration(tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionCached(declaration.expression), declaration);
|
|
} else if (isBinaryExpression(declaration) || isInJSFile(declaration) && (isCallExpression(declaration) || (isPropertyAccessExpression(declaration) || isBindableStaticElementAccessExpression(declaration)) && isBinaryExpression(declaration.parent))) {
|
|
type = getWidenedTypeForAssignmentDeclaration(symbol);
|
|
} else if (isPropertyAccessExpression(declaration) || isElementAccessExpression(declaration) || isIdentifier(declaration) || isStringLiteralLike(declaration) || isNumericLiteral(declaration) || isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isMethodDeclaration(declaration) && !isObjectLiteralMethod(declaration) || isMethodSignature(declaration) || isSourceFile(declaration)) {
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
type = isBinaryExpression(declaration.parent) ? getWidenedTypeForAssignmentDeclaration(symbol) : tryGetTypeFromEffectiveTypeNode(declaration) || anyType;
|
|
} else if (isPropertyAssignment(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration);
|
|
} else if (isJsxAttribute(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration);
|
|
} else if (isShorthandPropertyAssignment(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0 /* Normal */);
|
|
} else if (isObjectLiteralMethod(declaration)) {
|
|
type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0 /* Normal */);
|
|
} else if (isParameter(declaration) || isPropertyDeclaration(declaration) || isPropertySignature(declaration) || isVariableDeclaration(declaration) || isBindingElement(declaration) || isJSDocPropertyLikeTag(declaration)) {
|
|
type = getWidenedTypeForVariableLikeDeclaration(declaration, true);
|
|
} else if (isEnumDeclaration(declaration)) {
|
|
type = getTypeOfFuncClassEnumModule(symbol);
|
|
} else if (isEnumMember(declaration)) {
|
|
type = getTypeOfEnumMember(symbol);
|
|
} else {
|
|
return Debug.fail("Unhandled declaration kind! " + Debug.formatSyntaxKind(declaration.kind) + " for " + Debug.formatSymbol(symbol));
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
return reportCircularityError(symbol);
|
|
}
|
|
return type;
|
|
}
|
|
function getAnnotatedAccessorTypeNode(accessor) {
|
|
if (accessor) {
|
|
switch (accessor.kind) {
|
|
case 174 /* GetAccessor */:
|
|
const getterTypeAnnotation = getEffectiveReturnTypeNode(accessor);
|
|
return getterTypeAnnotation;
|
|
case 175 /* SetAccessor */:
|
|
const setterTypeAnnotation = getEffectiveSetAccessorTypeAnnotationNode(accessor);
|
|
return setterTypeAnnotation;
|
|
case 169 /* PropertyDeclaration */:
|
|
Debug.assert(hasAccessorModifier(accessor));
|
|
const accessorTypeAnnotation = getEffectiveTypeAnnotationNode(accessor);
|
|
return accessorTypeAnnotation;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAnnotatedAccessorType(accessor) {
|
|
const node = getAnnotatedAccessorTypeNode(accessor);
|
|
return node && getTypeFromTypeNode(node);
|
|
}
|
|
function getAnnotatedAccessorThisParameter(accessor) {
|
|
const parameter = getAccessorThisParameter(accessor);
|
|
return parameter && parameter.symbol;
|
|
}
|
|
function getThisTypeOfDeclaration(declaration) {
|
|
return getThisTypeOfSignature(getSignatureFromDeclaration(declaration));
|
|
}
|
|
function getTypeOfAccessors(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
return errorType;
|
|
}
|
|
const getter = getDeclarationOfKind(symbol, 174 /* GetAccessor */);
|
|
const setter = getDeclarationOfKind(symbol, 175 /* SetAccessor */);
|
|
const accessor = tryCast(getDeclarationOfKind(symbol, 169 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
|
|
let type = getter && isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || getAnnotatedAccessorType(getter) || getAnnotatedAccessorType(setter) || getAnnotatedAccessorType(accessor) || getter && getter.body && getReturnTypeFromBody(getter) || accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(accessor, true);
|
|
if (!type) {
|
|
if (setter && !isPrivateWithinAmbient(setter)) {
|
|
errorOrSuggestion(noImplicitAny, setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
|
|
} else if (getter && !isPrivateWithinAmbient(getter)) {
|
|
errorOrSuggestion(noImplicitAny, getter, Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
|
|
} else if (accessor && !isPrivateWithinAmbient(accessor)) {
|
|
errorOrSuggestion(noImplicitAny, accessor, Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), "any");
|
|
}
|
|
type = anyType;
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (getAnnotatedAccessorTypeNode(getter)) {
|
|
error(getter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getAnnotatedAccessorTypeNode(setter)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getAnnotatedAccessorTypeNode(accessor)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
} else if (getter && noImplicitAny) {
|
|
error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
|
|
}
|
|
type = anyType;
|
|
}
|
|
links.type = type;
|
|
}
|
|
return links.type;
|
|
}
|
|
function getWriteTypeOfAccessors(symbol) {
|
|
var _a2;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.writeType) {
|
|
if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
|
|
return errorType;
|
|
}
|
|
const setter = (_a2 = getDeclarationOfKind(symbol, 175 /* SetAccessor */)) != null ? _a2 : tryCast(getDeclarationOfKind(symbol, 169 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
|
|
let writeType = getAnnotatedAccessorType(setter);
|
|
if (!popTypeResolution()) {
|
|
if (getAnnotatedAccessorTypeNode(setter)) {
|
|
error(setter, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
|
|
}
|
|
writeType = anyType;
|
|
}
|
|
links.writeType = writeType || getTypeOfAccessors(symbol);
|
|
}
|
|
return links.writeType;
|
|
}
|
|
function getBaseTypeVariableOfClass(symbol) {
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
|
|
return baseConstructorType.flags & 8650752 /* TypeVariable */ ? baseConstructorType : baseConstructorType.flags & 2097152 /* Intersection */ ? find(baseConstructorType.types, (t) => !!(t.flags & 8650752 /* TypeVariable */)) : void 0;
|
|
}
|
|
function getTypeOfFuncClassEnumModule(symbol) {
|
|
let links = getSymbolLinks(symbol);
|
|
const originalLinks = links;
|
|
if (!links.type) {
|
|
const expando = symbol.valueDeclaration && getSymbolOfExpando(symbol.valueDeclaration, false);
|
|
if (expando) {
|
|
const merged = mergeJSSymbols(symbol, expando);
|
|
if (merged) {
|
|
symbol = links = merged;
|
|
}
|
|
}
|
|
originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol);
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfFuncClassEnumModuleWorker(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (symbol.flags & 1536 /* Module */ && isShorthandAmbientModuleSymbol(symbol)) {
|
|
return anyType;
|
|
} else if (declaration && (declaration.kind === 223 /* BinaryExpression */ || isAccessExpression(declaration) && declaration.parent.kind === 223 /* BinaryExpression */)) {
|
|
return getWidenedTypeForAssignmentDeclaration(symbol);
|
|
} else if (symbol.flags & 512 /* ValueModule */ && declaration && isSourceFile(declaration) && declaration.commonJsModuleIndicator) {
|
|
const resolvedModule = resolveExternalModuleSymbol(symbol);
|
|
if (resolvedModule !== symbol) {
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
return errorType;
|
|
}
|
|
const exportEquals = getMergedSymbol(symbol.exports.get("export=" /* ExportEquals */));
|
|
const type2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? void 0 : resolvedModule);
|
|
if (!popTypeResolution()) {
|
|
return reportCircularityError(symbol);
|
|
}
|
|
return type2;
|
|
}
|
|
}
|
|
const type = createObjectType(16 /* Anonymous */, symbol);
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const baseTypeVariable = getBaseTypeVariableOfClass(symbol);
|
|
return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type;
|
|
} else {
|
|
return strictNullChecks && symbol.flags & 16777216 /* Optional */ ? getOptionalType(type) : type;
|
|
}
|
|
}
|
|
function getTypeOfEnumMember(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol));
|
|
}
|
|
function getTypeOfAlias(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
const targetSymbol = resolveAlias(symbol);
|
|
const exportSymbol = symbol.declarations && getTargetOfAliasDeclaration(getDeclarationOfAliasSymbol(symbol), true);
|
|
const declaredType = firstDefined(exportSymbol == null ? void 0 : exportSymbol.declarations, (d) => isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : void 0);
|
|
links.type = (exportSymbol == null ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) : isDuplicatedCommonJSExport(symbol.declarations) ? autoType : declaredType ? declaredType : getAllSymbolFlags(targetSymbol) & 111551 /* Value */ ? getTypeOfSymbol(targetSymbol) : errorType;
|
|
}
|
|
return links.type;
|
|
}
|
|
function getTypeOfInstantiatedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper));
|
|
}
|
|
function getWriteTypeOfInstantiatedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target), links.mapper));
|
|
}
|
|
function reportCircularityError(symbol) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (getEffectiveTypeAnnotationNode(declaration)) {
|
|
error(
|
|
symbol.valueDeclaration,
|
|
Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation,
|
|
symbolToString(symbol)
|
|
);
|
|
return errorType;
|
|
}
|
|
if (noImplicitAny && (declaration.kind !== 166 /* Parameter */ || declaration.initializer)) {
|
|
error(
|
|
symbol.valueDeclaration,
|
|
Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer,
|
|
symbolToString(symbol)
|
|
);
|
|
}
|
|
return anyType;
|
|
}
|
|
function getTypeOfSymbolWithDeferredType(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
Debug.assertIsDefined(links.deferralParent);
|
|
Debug.assertIsDefined(links.deferralConstituents);
|
|
links.type = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents);
|
|
}
|
|
return links.type;
|
|
}
|
|
function getWriteTypeOfSymbolWithDeferredType(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.writeType && links.deferralWriteConstituents) {
|
|
Debug.assertIsDefined(links.deferralParent);
|
|
Debug.assertIsDefined(links.deferralConstituents);
|
|
links.writeType = links.deferralParent.flags & 1048576 /* Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents);
|
|
}
|
|
return links.writeType;
|
|
}
|
|
function getWriteTypeOfSymbol(symbol) {
|
|
const checkFlags = getCheckFlags(symbol);
|
|
if (symbol.flags & 4 /* Property */) {
|
|
return checkFlags & 2 /* SyntheticProperty */ ? checkFlags & 65536 /* DeferredType */ ? getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : symbol.writeType || symbol.type : getTypeOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & 98304 /* Accessor */) {
|
|
return checkFlags & 1 /* Instantiated */ ? getWriteTypeOfInstantiatedSymbol(symbol) : getWriteTypeOfAccessors(symbol);
|
|
}
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
function getTypeOfSymbol(symbol) {
|
|
const checkFlags = getCheckFlags(symbol);
|
|
if (checkFlags & 65536 /* DeferredType */) {
|
|
return getTypeOfSymbolWithDeferredType(symbol);
|
|
}
|
|
if (checkFlags & 1 /* Instantiated */) {
|
|
return getTypeOfInstantiatedSymbol(symbol);
|
|
}
|
|
if (checkFlags & 262144 /* Mapped */) {
|
|
return getTypeOfMappedSymbol(symbol);
|
|
}
|
|
if (checkFlags & 8192 /* ReverseMapped */) {
|
|
return getTypeOfReverseMappedSymbol(symbol);
|
|
}
|
|
if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
|
|
return getTypeOfVariableOrParameterOrProperty(symbol);
|
|
}
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
|
|
return getTypeOfFuncClassEnumModule(symbol);
|
|
}
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return getTypeOfEnumMember(symbol);
|
|
}
|
|
if (symbol.flags & 98304 /* Accessor */) {
|
|
return getTypeOfAccessors(symbol);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
return getTypeOfAlias(symbol);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getNonMissingTypeOfSymbol(symbol) {
|
|
return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & 16777216 /* Optional */));
|
|
}
|
|
function isReferenceToType2(type, target) {
|
|
return type !== void 0 && target !== void 0 && (getObjectFlags(type) & 4 /* Reference */) !== 0 && type.target === target;
|
|
}
|
|
function getTargetType(type) {
|
|
return getObjectFlags(type) & 4 /* Reference */ ? type.target : type;
|
|
}
|
|
function hasBaseType(type, checkBase) {
|
|
return check(type);
|
|
function check(type2) {
|
|
if (getObjectFlags(type2) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
|
|
const target = getTargetType(type2);
|
|
return target === checkBase || some(getBaseTypes(target), check);
|
|
} else if (type2.flags & 2097152 /* Intersection */) {
|
|
return some(type2.types, check);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function appendTypeParameters(typeParameters, declarations) {
|
|
for (const declaration of declarations) {
|
|
typeParameters = appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration)));
|
|
}
|
|
return typeParameters;
|
|
}
|
|
function getOuterTypeParameters(node, includeThisTypes) {
|
|
while (true) {
|
|
node = node.parent;
|
|
if (node && isBinaryExpression(node)) {
|
|
const assignmentKind = getAssignmentDeclarationKind(node);
|
|
if (assignmentKind === 6 /* Prototype */ || assignmentKind === 3 /* PrototypeProperty */) {
|
|
const symbol = getSymbolOfNode(node.left);
|
|
if (symbol && symbol.parent && !findAncestor(symbol.parent.valueDeclaration, (d) => node === d)) {
|
|
node = symbol.parent.valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 347 /* JSDocTemplateTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 197 /* MappedType */:
|
|
case 191 /* ConditionalType */: {
|
|
const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
|
|
if (node.kind === 197 /* MappedType */) {
|
|
return append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)));
|
|
} else if (node.kind === 191 /* ConditionalType */) {
|
|
return concatenate(outerTypeParameters, getInferTypeParameters(node));
|
|
}
|
|
const outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(node));
|
|
const thisType = includeThisTypes && (node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */ || node.kind === 261 /* InterfaceDeclaration */ || isJSConstructor(node)) && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType;
|
|
return thisType ? append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters;
|
|
}
|
|
case 343 /* JSDocParameterTag */:
|
|
const paramSymbol = getParameterSymbolFromJSDoc(node);
|
|
if (paramSymbol) {
|
|
node = paramSymbol.valueDeclaration;
|
|
}
|
|
break;
|
|
case 323 /* JSDoc */: {
|
|
const outerTypeParameters = getOuterTypeParameters(node, includeThisTypes);
|
|
return node.tags ? appendTypeParameters(outerTypeParameters, flatMap(node.tags, (t) => isJSDocTemplateTag(t) ? t.typeParameters : void 0)) : outerTypeParameters;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getOuterTypeParametersOfClassOrInterface(symbol) {
|
|
const declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : getDeclarationOfKind(symbol, 261 /* InterfaceDeclaration */);
|
|
Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations");
|
|
return getOuterTypeParameters(declaration);
|
|
}
|
|
function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
let result;
|
|
for (const node of symbol.declarations) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */ || node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */ || isJSConstructor(node) || isTypeAlias(node)) {
|
|
const declaration = node;
|
|
result = appendTypeParameters(result, getEffectiveTypeParameterDeclarations(declaration));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeParametersOfClassOrInterface(symbol) {
|
|
return concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
|
|
}
|
|
function isMixinConstructorType(type) {
|
|
const signatures = getSignaturesOfType(type, 1 /* Construct */);
|
|
if (signatures.length === 1) {
|
|
const s = signatures[0];
|
|
if (!s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s)) {
|
|
const paramType = getTypeOfParameter(s.parameters[0]);
|
|
return isTypeAny(paramType) || getElementTypeOfArrayType(paramType) === anyType;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isConstructorType(type) {
|
|
if (getSignaturesOfType(type, 1 /* Construct */).length > 0) {
|
|
return true;
|
|
}
|
|
if (type.flags & 8650752 /* TypeVariable */) {
|
|
const constraint = getBaseConstraintOfType(type);
|
|
return !!constraint && isMixinConstructorType(constraint);
|
|
}
|
|
return false;
|
|
}
|
|
function getBaseTypeNodeOfClass(type) {
|
|
const decl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
return decl && getEffectiveBaseTypeNode(decl);
|
|
}
|
|
function getConstructorsForTypeArguments(type, typeArgumentNodes, location2) {
|
|
const typeArgCount = length(typeArgumentNodes);
|
|
const isJavascript = isInJSFile(location2);
|
|
return filter(
|
|
getSignaturesOfType(type, 1 /* Construct */),
|
|
(sig) => (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= length(sig.typeParameters)
|
|
);
|
|
}
|
|
function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location2) {
|
|
const signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location2);
|
|
const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
|
|
return sameMap(signatures, (sig) => some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, isInJSFile(location2)) : sig);
|
|
}
|
|
function getBaseConstructorTypeOfClass(type) {
|
|
if (!type.resolvedBaseConstructorType) {
|
|
const decl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
const extended = decl && getEffectiveBaseTypeNode(decl);
|
|
const baseTypeNode = getBaseTypeNodeOfClass(type);
|
|
if (!baseTypeNode) {
|
|
return type.resolvedBaseConstructorType = undefinedType;
|
|
}
|
|
if (!pushTypeResolution(type, 1 /* ResolvedBaseConstructorType */)) {
|
|
return errorType;
|
|
}
|
|
const baseConstructorType = checkExpression(baseTypeNode.expression);
|
|
if (extended && baseTypeNode !== extended) {
|
|
Debug.assert(!extended.typeArguments);
|
|
checkExpression(extended.expression);
|
|
}
|
|
if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */)) {
|
|
resolveStructuredTypeMembers(baseConstructorType);
|
|
}
|
|
if (!popTypeResolution()) {
|
|
error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
|
|
return type.resolvedBaseConstructorType = errorType;
|
|
}
|
|
if (!(baseConstructorType.flags & 1 /* Any */) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) {
|
|
const err = error(baseTypeNode.expression, Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
|
|
if (baseConstructorType.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getConstraintFromTypeParameter(baseConstructorType);
|
|
let ctorReturn = unknownType;
|
|
if (constraint) {
|
|
const ctorSig = getSignaturesOfType(constraint, 1 /* Construct */);
|
|
if (ctorSig[0]) {
|
|
ctorReturn = getReturnTypeOfSignature(ctorSig[0]);
|
|
}
|
|
}
|
|
if (baseConstructorType.symbol.declarations) {
|
|
addRelatedInfo(err, createDiagnosticForNode(baseConstructorType.symbol.declarations[0], Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn)));
|
|
}
|
|
}
|
|
return type.resolvedBaseConstructorType = errorType;
|
|
}
|
|
type.resolvedBaseConstructorType = baseConstructorType;
|
|
}
|
|
return type.resolvedBaseConstructorType;
|
|
}
|
|
function getImplementsTypes(type) {
|
|
let resolvedImplementsTypes = emptyArray;
|
|
if (type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
const implementsTypeNodes = getEffectiveImplementsTypeNodes(declaration);
|
|
if (!implementsTypeNodes)
|
|
continue;
|
|
for (const node of implementsTypeNodes) {
|
|
const implementsType = getTypeFromTypeNode(node);
|
|
if (!isErrorType(implementsType)) {
|
|
if (resolvedImplementsTypes === emptyArray) {
|
|
resolvedImplementsTypes = [implementsType];
|
|
} else {
|
|
resolvedImplementsTypes.push(implementsType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return resolvedImplementsTypes;
|
|
}
|
|
function reportCircularBaseType(node, type) {
|
|
error(node, Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, void 0, 2 /* WriteArrayAsGenericType */));
|
|
}
|
|
function getBaseTypes(type) {
|
|
if (!type.baseTypesResolved) {
|
|
if (pushTypeResolution(type, 7 /* ResolvedBaseTypes */)) {
|
|
if (type.objectFlags & 8 /* Tuple */) {
|
|
type.resolvedBaseTypes = [getTupleBaseType(type)];
|
|
} else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
|
|
if (type.symbol.flags & 32 /* Class */) {
|
|
resolveBaseTypesOfClass(type);
|
|
}
|
|
if (type.symbol.flags & 64 /* Interface */) {
|
|
resolveBaseTypesOfInterface(type);
|
|
}
|
|
} else {
|
|
Debug.fail("type must be class or interface");
|
|
}
|
|
if (!popTypeResolution() && type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
if (declaration.kind === 260 /* ClassDeclaration */ || declaration.kind === 261 /* InterfaceDeclaration */) {
|
|
reportCircularBaseType(declaration, type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
type.baseTypesResolved = true;
|
|
}
|
|
return type.resolvedBaseTypes;
|
|
}
|
|
function getTupleBaseType(type) {
|
|
const elementTypes = sameMap(type.typeParameters, (t, i) => type.elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t);
|
|
return createArrayType(getUnionType(elementTypes || emptyArray), type.readonly);
|
|
}
|
|
function resolveBaseTypesOfClass(type) {
|
|
type.resolvedBaseTypes = resolvingEmptyArray;
|
|
const baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type));
|
|
if (!(baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 1 /* Any */))) {
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
const baseTypeNode = getBaseTypeNodeOfClass(type);
|
|
let baseType;
|
|
const originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : void 0;
|
|
if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 /* Class */ && areAllOuterTypeParametersApplied(originalBaseType)) {
|
|
baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol);
|
|
} else if (baseConstructorType.flags & 1 /* Any */) {
|
|
baseType = baseConstructorType;
|
|
} else {
|
|
const constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode);
|
|
if (!constructors.length) {
|
|
error(baseTypeNode.expression, Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
baseType = getReturnTypeOfSignature(constructors[0]);
|
|
}
|
|
if (isErrorType(baseType)) {
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
const reducedBaseType = getReducedType(baseType);
|
|
if (!isValidBaseType(reducedBaseType)) {
|
|
const elaboration = elaborateNeverIntersection(void 0, baseType);
|
|
const diagnostic = chainDiagnosticMessages(elaboration, Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(reducedBaseType));
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(baseTypeNode.expression, diagnostic));
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
if (type === reducedBaseType || hasBaseType(reducedBaseType, type)) {
|
|
error(
|
|
type.symbol.valueDeclaration,
|
|
Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
|
|
typeToString(type, void 0, 2 /* WriteArrayAsGenericType */)
|
|
);
|
|
return type.resolvedBaseTypes = emptyArray;
|
|
}
|
|
if (type.resolvedBaseTypes === resolvingEmptyArray) {
|
|
type.members = void 0;
|
|
}
|
|
return type.resolvedBaseTypes = [reducedBaseType];
|
|
}
|
|
function areAllOuterTypeParametersApplied(type) {
|
|
const outerTypeParameters = type.outerTypeParameters;
|
|
if (outerTypeParameters) {
|
|
const last2 = outerTypeParameters.length - 1;
|
|
const typeArguments = getTypeArguments(type);
|
|
return outerTypeParameters[last2].symbol !== typeArguments[last2].symbol;
|
|
}
|
|
return true;
|
|
}
|
|
function isValidBaseType(type) {
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getBaseConstraintOfType(type);
|
|
if (constraint) {
|
|
return isValidBaseType(constraint);
|
|
}
|
|
}
|
|
return !!(type.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 1 /* Any */) && !isGenericMappedType(type) || type.flags & 2097152 /* Intersection */ && every(type.types, isValidBaseType));
|
|
}
|
|
function resolveBaseTypesOfInterface(type) {
|
|
type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
|
|
if (type.symbol.declarations) {
|
|
for (const declaration of type.symbol.declarations) {
|
|
if (declaration.kind === 261 /* InterfaceDeclaration */ && getInterfaceBaseTypeNodes(declaration)) {
|
|
for (const node of getInterfaceBaseTypeNodes(declaration)) {
|
|
const baseType = getReducedType(getTypeFromTypeNode(node));
|
|
if (!isErrorType(baseType)) {
|
|
if (isValidBaseType(baseType)) {
|
|
if (type !== baseType && !hasBaseType(baseType, type)) {
|
|
if (type.resolvedBaseTypes === emptyArray) {
|
|
type.resolvedBaseTypes = [baseType];
|
|
} else {
|
|
type.resolvedBaseTypes.push(baseType);
|
|
}
|
|
} else {
|
|
reportCircularBaseType(declaration, type);
|
|
}
|
|
} else {
|
|
error(node, Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isThislessInterface(symbol) {
|
|
if (!symbol.declarations) {
|
|
return true;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
if (declaration.kind === 261 /* InterfaceDeclaration */) {
|
|
if (declaration.flags & 128 /* ContainsThis */) {
|
|
return false;
|
|
}
|
|
const baseTypeNodes = getInterfaceBaseTypeNodes(declaration);
|
|
if (baseTypeNodes) {
|
|
for (const node of baseTypeNodes) {
|
|
if (isEntityNameExpression(node.expression)) {
|
|
const baseSymbol = resolveEntityName(node.expression, 788968 /* Type */, true);
|
|
if (!baseSymbol || !(baseSymbol.flags & 64 /* Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getDeclaredTypeOfClassOrInterface(symbol) {
|
|
let links = getSymbolLinks(symbol);
|
|
const originalLinks = links;
|
|
if (!links.declaredType) {
|
|
const kind = symbol.flags & 32 /* Class */ ? 1 /* Class */ : 2 /* Interface */;
|
|
const merged = mergeJSSymbols(symbol, symbol.valueDeclaration && getAssignedClassSymbol(symbol.valueDeclaration));
|
|
if (merged) {
|
|
symbol = links = merged;
|
|
}
|
|
const type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol);
|
|
const outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol);
|
|
const localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
if (outerTypeParameters || localTypeParameters || kind === 1 /* Class */ || !isThislessInterface(symbol)) {
|
|
type.objectFlags |= 4 /* Reference */;
|
|
type.typeParameters = concatenate(outerTypeParameters, localTypeParameters);
|
|
type.outerTypeParameters = outerTypeParameters;
|
|
type.localTypeParameters = localTypeParameters;
|
|
type.instantiations = /* @__PURE__ */ new Map();
|
|
type.instantiations.set(getTypeListId(type.typeParameters), type);
|
|
type.target = type;
|
|
type.resolvedTypeArguments = type.typeParameters;
|
|
type.thisType = createTypeParameter(symbol);
|
|
type.thisType.isThisType = true;
|
|
type.thisType.constraint = type;
|
|
}
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getDeclaredTypeOfTypeAlias(symbol) {
|
|
var _a2;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
if (!pushTypeResolution(symbol, 2 /* DeclaredType */)) {
|
|
return errorType;
|
|
}
|
|
const declaration = Debug.checkDefined((_a2 = symbol.declarations) == null ? void 0 : _a2.find(isTypeAlias), "Type alias symbol with no valid declaration found");
|
|
const typeNode = isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type;
|
|
let type = typeNode ? getTypeFromTypeNode(typeNode) : errorType;
|
|
if (popTypeResolution()) {
|
|
const typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
if (typeParameters) {
|
|
links.typeParameters = typeParameters;
|
|
links.instantiations = /* @__PURE__ */ new Map();
|
|
links.instantiations.set(getTypeListId(typeParameters), type);
|
|
}
|
|
} else {
|
|
type = errorType;
|
|
if (declaration.kind === 342 /* JSDocEnumTag */) {
|
|
error(declaration.typeExpression.type, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
|
|
} else {
|
|
error(isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol));
|
|
}
|
|
}
|
|
links.declaredType = type;
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getBaseTypeOfEnumLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ && !(type.flags & 1048576 /* Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type;
|
|
}
|
|
function getDeclaredTypeOfEnum(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
const memberTypeList = [];
|
|
if (symbol.declarations) {
|
|
for (const declaration of symbol.declarations) {
|
|
if (declaration.kind === 263 /* EnumDeclaration */) {
|
|
for (const member of declaration.members) {
|
|
if (hasBindableName(member)) {
|
|
const memberSymbol = getSymbolOfNode(member);
|
|
const value = getEnumMemberValue(member);
|
|
const memberType = value !== void 0 ? getFreshTypeOfLiteralType(getEnumLiteralType(value, getSymbolId(symbol), memberSymbol)) : createTypeWithSymbol(32 /* Enum */, memberSymbol);
|
|
getSymbolLinks(memberSymbol).declaredType = memberType;
|
|
memberTypeList.push(getRegularTypeOfLiteralType(memberType));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const enumType = memberTypeList.length ? getUnionType(memberTypeList, 1 /* Literal */, symbol, void 0) : createTypeWithSymbol(32 /* Enum */, symbol);
|
|
if (enumType.flags & 1048576 /* Union */) {
|
|
enumType.flags |= 1024 /* EnumLiteral */;
|
|
enumType.symbol = symbol;
|
|
}
|
|
links.declaredType = enumType;
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getDeclaredTypeOfEnumMember(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.declaredType) {
|
|
const enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
|
|
if (!links.declaredType) {
|
|
links.declaredType = enumType;
|
|
}
|
|
}
|
|
return links.declaredType;
|
|
}
|
|
function getDeclaredTypeOfTypeParameter(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.declaredType || (links.declaredType = createTypeParameter(symbol));
|
|
}
|
|
function getDeclaredTypeOfAlias(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol)));
|
|
}
|
|
function getDeclaredTypeOfSymbol(symbol) {
|
|
return tryGetDeclaredTypeOfSymbol(symbol) || errorType;
|
|
}
|
|
function tryGetDeclaredTypeOfSymbol(symbol) {
|
|
if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
|
|
return getDeclaredTypeOfClassOrInterface(symbol);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
return getDeclaredTypeOfTypeAlias(symbol);
|
|
}
|
|
if (symbol.flags & 262144 /* TypeParameter */) {
|
|
return getDeclaredTypeOfTypeParameter(symbol);
|
|
}
|
|
if (symbol.flags & 384 /* Enum */) {
|
|
return getDeclaredTypeOfEnum(symbol);
|
|
}
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return getDeclaredTypeOfEnumMember(symbol);
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
return getDeclaredTypeOfAlias(symbol);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isThislessType(node) {
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 198 /* LiteralType */:
|
|
return true;
|
|
case 185 /* ArrayType */:
|
|
return isThislessType(node.elementType);
|
|
case 180 /* TypeReference */:
|
|
return !node.typeArguments || node.typeArguments.every(isThislessType);
|
|
}
|
|
return false;
|
|
}
|
|
function isThislessTypeParameter(node) {
|
|
const constraint = getEffectiveConstraintOfTypeParameter(node);
|
|
return !constraint || isThislessType(constraint);
|
|
}
|
|
function isThislessVariableLikeDeclaration(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
return typeNode ? isThislessType(typeNode) : !hasInitializer(node);
|
|
}
|
|
function isThislessFunctionLikeDeclaration(node) {
|
|
const returnType = getEffectiveReturnTypeNode(node);
|
|
const typeParameters = getEffectiveTypeParameterDeclarations(node);
|
|
return (node.kind === 173 /* Constructor */ || !!returnType && isThislessType(returnType)) && node.parameters.every(isThislessVariableLikeDeclaration) && typeParameters.every(isThislessTypeParameter);
|
|
}
|
|
function isThisless(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length === 1) {
|
|
const declaration = symbol.declarations[0];
|
|
if (declaration) {
|
|
switch (declaration.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return isThislessVariableLikeDeclaration(declaration);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return isThislessFunctionLikeDeclaration(declaration);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) {
|
|
const result = createSymbolTable();
|
|
for (const symbol of symbols) {
|
|
result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper));
|
|
}
|
|
return result;
|
|
}
|
|
function addInheritedMembers(symbols, baseSymbols) {
|
|
for (const s of baseSymbols) {
|
|
if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) {
|
|
symbols.set(s.escapedName, s);
|
|
}
|
|
}
|
|
}
|
|
function isStaticPrivateIdentifierProperty(s) {
|
|
return !!s.valueDeclaration && isPrivateIdentifierClassElementDeclaration(s.valueDeclaration) && isStatic(s.valueDeclaration);
|
|
}
|
|
function resolveDeclaredMembers(type) {
|
|
if (!type.declaredProperties) {
|
|
const symbol = type.symbol;
|
|
const members = getMembersOfSymbol(symbol);
|
|
type.declaredProperties = getNamedMembers(members);
|
|
type.declaredCallSignatures = emptyArray;
|
|
type.declaredConstructSignatures = emptyArray;
|
|
type.declaredIndexInfos = emptyArray;
|
|
type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call" /* Call */));
|
|
type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new" /* New */));
|
|
type.declaredIndexInfos = getIndexInfosOfSymbol(symbol);
|
|
}
|
|
return type;
|
|
}
|
|
function isTypeUsableAsPropertyName(type) {
|
|
return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
|
|
}
|
|
function isLateBindableName(node) {
|
|
if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
|
|
return false;
|
|
}
|
|
const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
|
|
return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
|
|
}
|
|
function isLateBoundName(name) {
|
|
return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) === 64 /* at */;
|
|
}
|
|
function hasLateBindableName(node) {
|
|
const name = getNameOfDeclaration(node);
|
|
return !!name && isLateBindableName(name);
|
|
}
|
|
function hasBindableName(node) {
|
|
return !hasDynamicName(node) || hasLateBindableName(node);
|
|
}
|
|
function isNonBindableDynamicName(node) {
|
|
return isDynamicName(node) && !isLateBindableName(node);
|
|
}
|
|
function getPropertyNameFromType(type) {
|
|
if (type.flags & 8192 /* UniqueESSymbol */) {
|
|
return type.escapedName;
|
|
}
|
|
if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
return escapeLeadingUnderscores("" + type.value);
|
|
}
|
|
return Debug.fail();
|
|
}
|
|
function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
|
|
Debug.assert(!!(getCheckFlags(symbol) & 4096 /* Late */), "Expected a late-bound symbol.");
|
|
symbol.flags |= symbolFlags;
|
|
getSymbolLinks(member.symbol).lateSymbol = symbol;
|
|
if (!symbol.declarations) {
|
|
symbol.declarations = [member];
|
|
} else if (!member.symbol.isReplaceableByMethod) {
|
|
symbol.declarations.push(member);
|
|
}
|
|
if (symbolFlags & 111551 /* Value */) {
|
|
if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) {
|
|
symbol.valueDeclaration = member;
|
|
}
|
|
}
|
|
}
|
|
function lateBindMember(parent2, earlySymbols, lateSymbols, decl) {
|
|
Debug.assert(!!decl.symbol, "The member is expected to have a symbol.");
|
|
const links = getNodeLinks(decl);
|
|
if (!links.resolvedSymbol) {
|
|
links.resolvedSymbol = decl.symbol;
|
|
const declName = isBinaryExpression(decl) ? decl.left : decl.name;
|
|
const type = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
|
|
if (isTypeUsableAsPropertyName(type)) {
|
|
const memberName = getPropertyNameFromType(type);
|
|
const symbolFlags = decl.symbol.flags;
|
|
let lateSymbol = lateSymbols.get(memberName);
|
|
if (!lateSymbol)
|
|
lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */));
|
|
const earlySymbol = earlySymbols && earlySymbols.get(memberName);
|
|
if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) {
|
|
const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
|
|
const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
|
|
forEach(declarations, (declaration) => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
|
|
error(declName || decl, Diagnostics.Duplicate_property_0, name);
|
|
lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */);
|
|
}
|
|
lateSymbol.nameType = type;
|
|
addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags);
|
|
if (lateSymbol.parent) {
|
|
Debug.assert(lateSymbol.parent === parent2, "Existing symbol parent should match new one");
|
|
} else {
|
|
lateSymbol.parent = parent2;
|
|
}
|
|
return links.resolvedSymbol = lateSymbol;
|
|
}
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links[resolutionKind]) {
|
|
const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
|
|
const earlySymbols = !isStatic2 ? symbol.members : symbol.flags & 1536 /* Module */ ? getExportsOfModuleWorker(symbol) : symbol.exports;
|
|
links[resolutionKind] = earlySymbols || emptySymbols;
|
|
const lateSymbols = createSymbolTable();
|
|
for (const decl of symbol.declarations || emptyArray) {
|
|
const members = getMembersOfDeclaration(decl);
|
|
if (members) {
|
|
for (const member of members) {
|
|
if (isStatic2 === hasStaticModifier(member)) {
|
|
if (hasLateBindableName(member)) {
|
|
lateBindMember(symbol, earlySymbols, lateSymbols, member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const assignments = symbol.assignmentDeclarationMembers;
|
|
if (assignments) {
|
|
const decls = arrayFrom(assignments.values());
|
|
for (const member of decls) {
|
|
const assignmentKind = getAssignmentDeclarationKind(member);
|
|
const isInstanceMember = assignmentKind === 3 /* PrototypeProperty */ || isBinaryExpression(member) && isPossiblyAliasedThisProperty(member, assignmentKind) || assignmentKind === 9 /* ObjectDefinePrototypeProperty */ || assignmentKind === 6 /* Prototype */;
|
|
if (isStatic2 === !isInstanceMember) {
|
|
if (hasLateBindableName(member)) {
|
|
lateBindMember(symbol, earlySymbols, lateSymbols, member);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols;
|
|
}
|
|
return links[resolutionKind];
|
|
}
|
|
function getMembersOfSymbol(symbol) {
|
|
return symbol.flags & 6256 /* LateBindingContainer */ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers" /* resolvedMembers */) : symbol.members || emptySymbols;
|
|
}
|
|
function getLateBoundSymbol(symbol) {
|
|
if (symbol.flags & 106500 /* ClassMember */ && symbol.escapedName === "__computed" /* Computed */) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.lateSymbol && some(symbol.declarations, hasLateBindableName)) {
|
|
const parent2 = getMergedSymbol(symbol.parent);
|
|
if (some(symbol.declarations, hasStaticModifier)) {
|
|
getExportsOfSymbol(parent2);
|
|
} else {
|
|
getMembersOfSymbol(parent2);
|
|
}
|
|
}
|
|
return links.lateSymbol || (links.lateSymbol = symbol);
|
|
}
|
|
return symbol;
|
|
}
|
|
function getTypeWithThisArgument(type, thisArgument, needApparentType) {
|
|
if (getObjectFlags(type) & 4 /* Reference */) {
|
|
const target = type.target;
|
|
const typeArguments = getTypeArguments(type);
|
|
if (length(target.typeParameters) === length(typeArguments)) {
|
|
const ref = createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
|
|
return needApparentType ? getApparentType(ref) : ref;
|
|
}
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
const types = sameMap(type.types, (t) => getTypeWithThisArgument(t, thisArgument, needApparentType));
|
|
return types !== type.types ? getIntersectionType(types) : type;
|
|
}
|
|
return needApparentType ? getApparentType(type) : type;
|
|
}
|
|
function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
|
|
let mapper;
|
|
let members;
|
|
let callSignatures;
|
|
let constructSignatures;
|
|
let indexInfos;
|
|
if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
|
|
members = source.symbol ? getMembersOfSymbol(source.symbol) : createSymbolTable(source.declaredProperties);
|
|
callSignatures = source.declaredCallSignatures;
|
|
constructSignatures = source.declaredConstructSignatures;
|
|
indexInfos = source.declaredIndexInfos;
|
|
} else {
|
|
mapper = createTypeMapper(typeParameters, typeArguments);
|
|
members = createInstantiatedSymbolTable(source.declaredProperties, mapper, typeParameters.length === 1);
|
|
callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper);
|
|
constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper);
|
|
indexInfos = instantiateIndexInfos(source.declaredIndexInfos, mapper);
|
|
}
|
|
const baseTypes = getBaseTypes(source);
|
|
if (baseTypes.length) {
|
|
if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
|
|
members = createSymbolTable(source.declaredProperties);
|
|
}
|
|
setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
|
|
const thisArgument = lastOrUndefined(typeArguments);
|
|
for (const baseType of baseTypes) {
|
|
const instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType;
|
|
addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType));
|
|
callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* Call */));
|
|
constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* Construct */));
|
|
const inheritedIndexInfos = instantiatedBaseType !== anyType ? getIndexInfosOfType(instantiatedBaseType) : [createIndexInfo(stringType, anyType, false)];
|
|
indexInfos = concatenate(indexInfos, filter(inheritedIndexInfos, (info) => !findIndexInfo(indexInfos, info.keyType)));
|
|
}
|
|
}
|
|
setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
|
|
}
|
|
function resolveClassOrInterfaceMembers(type) {
|
|
resolveObjectTypeMembers(type, resolveDeclaredMembers(type), emptyArray, emptyArray);
|
|
}
|
|
function resolveTypeReferenceMembers(type) {
|
|
const source = resolveDeclaredMembers(type.target);
|
|
const typeParameters = concatenate(source.typeParameters, [source.thisType]);
|
|
const typeArguments = getTypeArguments(type);
|
|
const paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : concatenate(typeArguments, [type]);
|
|
resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments);
|
|
}
|
|
function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) {
|
|
const sig = new Signature15(checker, flags);
|
|
sig.declaration = declaration;
|
|
sig.typeParameters = typeParameters;
|
|
sig.parameters = parameters;
|
|
sig.thisParameter = thisParameter;
|
|
sig.resolvedReturnType = resolvedReturnType;
|
|
sig.resolvedTypePredicate = resolvedTypePredicate;
|
|
sig.minArgumentCount = minArgumentCount;
|
|
sig.resolvedMinArgumentCount = void 0;
|
|
sig.target = void 0;
|
|
sig.mapper = void 0;
|
|
sig.compositeSignatures = void 0;
|
|
sig.compositeKind = void 0;
|
|
return sig;
|
|
}
|
|
function cloneSignature(sig) {
|
|
const result = createSignature(
|
|
sig.declaration,
|
|
sig.typeParameters,
|
|
sig.thisParameter,
|
|
sig.parameters,
|
|
void 0,
|
|
void 0,
|
|
sig.minArgumentCount,
|
|
sig.flags & 39 /* PropagatingFlags */
|
|
);
|
|
result.target = sig.target;
|
|
result.mapper = sig.mapper;
|
|
result.compositeSignatures = sig.compositeSignatures;
|
|
result.compositeKind = sig.compositeKind;
|
|
return result;
|
|
}
|
|
function createUnionSignature(signature, unionSignatures) {
|
|
const result = cloneSignature(signature);
|
|
result.compositeSignatures = unionSignatures;
|
|
result.compositeKind = 1048576 /* Union */;
|
|
result.target = void 0;
|
|
result.mapper = void 0;
|
|
return result;
|
|
}
|
|
function getOptionalCallSignature(signature, callChainFlags) {
|
|
if ((signature.flags & 24 /* CallChainFlags */) === callChainFlags) {
|
|
return signature;
|
|
}
|
|
if (!signature.optionalCallSignatureCache) {
|
|
signature.optionalCallSignatureCache = {};
|
|
}
|
|
const key = callChainFlags === 8 /* IsInnerCallChain */ ? "inner" : "outer";
|
|
return signature.optionalCallSignatureCache[key] || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags));
|
|
}
|
|
function createOptionalCallSignature(signature, callChainFlags) {
|
|
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."
|
|
);
|
|
const result = cloneSignature(signature);
|
|
result.flags |= callChainFlags;
|
|
return result;
|
|
}
|
|
function getExpandedParameters(sig, skipUnionExpanding) {
|
|
if (signatureHasRestParameter(sig)) {
|
|
const restIndex = sig.parameters.length - 1;
|
|
const restType = getTypeOfSymbol(sig.parameters[restIndex]);
|
|
if (isTupleType(restType)) {
|
|
return [expandSignatureParametersWithTupleMembers(restType, restIndex)];
|
|
} else if (!skipUnionExpanding && restType.flags & 1048576 /* Union */ && every(restType.types, isTupleType)) {
|
|
return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex));
|
|
}
|
|
}
|
|
return [sig.parameters];
|
|
function expandSignatureParametersWithTupleMembers(restType, restIndex) {
|
|
const elementTypes = getTypeArguments(restType);
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const restParams = map(elementTypes, (t, i) => {
|
|
const tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]);
|
|
const name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i, restType);
|
|
const flags = restType.target.elementFlags[i];
|
|
const checkFlags = flags & 12 /* Variable */ ? 32768 /* RestParameter */ : flags & 2 /* Optional */ ? 16384 /* OptionalParameter */ : 0;
|
|
const symbol = createSymbol(1 /* FunctionScopedVariable */, name, checkFlags);
|
|
symbol.type = flags & 4 /* Rest */ ? createArrayType(t) : t;
|
|
return symbol;
|
|
});
|
|
return concatenate(sig.parameters.slice(0, restIndex), restParams);
|
|
}
|
|
}
|
|
function getDefaultConstructSignatures(classType) {
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classType);
|
|
const baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
|
|
const declaration = getClassLikeDeclarationOfSymbol(classType.symbol);
|
|
const isAbstract = !!declaration && hasSyntacticModifier(declaration, 256 /* Abstract */);
|
|
if (baseSignatures.length === 0) {
|
|
return [createSignature(void 0, classType.localTypeParameters, void 0, emptyArray, classType, void 0, 0, isAbstract ? 4 /* Abstract */ : 0 /* None */)];
|
|
}
|
|
const baseTypeNode = getBaseTypeNodeOfClass(classType);
|
|
const isJavaScript = isInJSFile(baseTypeNode);
|
|
const typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode);
|
|
const typeArgCount = length(typeArguments);
|
|
const result = [];
|
|
for (const baseSig of baseSignatures) {
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
|
|
const typeParamCount = length(baseSig.typeParameters);
|
|
if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) {
|
|
const 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);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) {
|
|
for (const s of signatureList) {
|
|
if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) {
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
function findMatchingSignatures(signatureLists, signature, listIndex) {
|
|
if (signature.typeParameters) {
|
|
if (listIndex > 0) {
|
|
return void 0;
|
|
}
|
|
for (let i = 1; i < signatureLists.length; i++) {
|
|
if (!findMatchingSignature(signatureLists[i], signature, false, false, false)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return [signature];
|
|
}
|
|
let result;
|
|
for (let i = 0; i < signatureLists.length; i++) {
|
|
const match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, true, false, true);
|
|
if (!match) {
|
|
return void 0;
|
|
}
|
|
result = appendIfUnique(result, match);
|
|
}
|
|
return result;
|
|
}
|
|
function getUnionSignatures(signatureLists) {
|
|
let result;
|
|
let indexWithLengthOverOne;
|
|
for (let i = 0; i < signatureLists.length; i++) {
|
|
if (signatureLists[i].length === 0)
|
|
return emptyArray;
|
|
if (signatureLists[i].length > 1) {
|
|
indexWithLengthOverOne = indexWithLengthOverOne === void 0 ? i : -1;
|
|
}
|
|
for (const signature of signatureLists[i]) {
|
|
if (!result || !findMatchingSignature(result, signature, false, false, true)) {
|
|
const unionSignatures = findMatchingSignatures(signatureLists, signature, i);
|
|
if (unionSignatures) {
|
|
let s = signature;
|
|
if (unionSignatures.length > 1) {
|
|
let thisParameter = signature.thisParameter;
|
|
const firstThisParameterOfUnionSignatures = forEach(unionSignatures, (sig) => sig.thisParameter);
|
|
if (firstThisParameterOfUnionSignatures) {
|
|
const thisType = getIntersectionType(mapDefined(unionSignatures, (sig) => sig.thisParameter && getTypeOfSymbol(sig.thisParameter)));
|
|
thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType);
|
|
}
|
|
s = createUnionSignature(signature, unionSignatures);
|
|
s.thisParameter = thisParameter;
|
|
}
|
|
(result || (result = [])).push(s);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!length(result) && indexWithLengthOverOne !== -1) {
|
|
const masterList = signatureLists[indexWithLengthOverOne !== void 0 ? indexWithLengthOverOne : 0];
|
|
let results = masterList.slice();
|
|
for (const signatures of signatureLists) {
|
|
if (signatures !== masterList) {
|
|
const signature = signatures[0];
|
|
Debug.assert(!!signature, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
|
|
results = !!signature.typeParameters && some(results, (s) => !!s.typeParameters && !compareTypeParametersIdentical(signature.typeParameters, s.typeParameters)) ? void 0 : map(results, (sig) => combineSignaturesOfUnionMembers(sig, signature));
|
|
if (!results) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
result = results;
|
|
}
|
|
return result || emptyArray;
|
|
}
|
|
function compareTypeParametersIdentical(sourceParams, targetParams) {
|
|
if (length(sourceParams) !== length(targetParams)) {
|
|
return false;
|
|
}
|
|
if (!sourceParams || !targetParams) {
|
|
return true;
|
|
}
|
|
const mapper = createTypeMapper(targetParams, sourceParams);
|
|
for (let i = 0; i < sourceParams.length; i++) {
|
|
const source = sourceParams[i];
|
|
const target = targetParams[i];
|
|
if (source === target)
|
|
continue;
|
|
if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, instantiateType(getConstraintFromTypeParameter(target) || unknownType, mapper)))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function combineUnionThisParam(left, right, mapper) {
|
|
if (!left || !right) {
|
|
return left || right;
|
|
}
|
|
const thisType = getIntersectionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]);
|
|
return createSymbolWithType(left, thisType);
|
|
}
|
|
function combineUnionParameters(left, right, mapper) {
|
|
const leftCount = getParameterCount(left);
|
|
const rightCount = getParameterCount(right);
|
|
const longest = leftCount >= rightCount ? left : right;
|
|
const shorter = longest === left ? right : left;
|
|
const longestCount = longest === left ? leftCount : rightCount;
|
|
const eitherHasEffectiveRest = hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right);
|
|
const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
|
|
const params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
|
|
for (let i = 0; i < longestCount; i++) {
|
|
let longestParamType = tryGetTypeAtPosition(longest, i);
|
|
if (longest === right) {
|
|
longestParamType = instantiateType(longestParamType, mapper);
|
|
}
|
|
let shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
|
|
if (shorter === right) {
|
|
shorterParamType = instantiateType(shorterParamType, mapper);
|
|
}
|
|
const unionParamType = getIntersectionType([longestParamType, shorterParamType]);
|
|
const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === longestCount - 1;
|
|
const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
|
|
const leftName = i >= leftCount ? void 0 : getParameterNameAtPosition(left, i);
|
|
const rightName = i >= rightCount ? void 0 : getParameterNameAtPosition(right, i);
|
|
const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
|
|
const paramSymbol = createSymbol(
|
|
1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
|
|
paramName || `arg${i}`
|
|
);
|
|
paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
|
|
params[i] = paramSymbol;
|
|
}
|
|
if (needsExtraRestElement) {
|
|
const 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) {
|
|
const typeParams = left.typeParameters || right.typeParameters;
|
|
let paramMapper;
|
|
if (left.typeParameters && right.typeParameters) {
|
|
paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
|
|
}
|
|
const declaration = left.declaration;
|
|
const params = combineUnionParameters(left, right, paramMapper);
|
|
const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper);
|
|
const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
|
|
const result = createSignature(
|
|
declaration,
|
|
typeParams,
|
|
thisParam,
|
|
params,
|
|
void 0,
|
|
void 0,
|
|
minArgCount,
|
|
(left.flags | right.flags) & 39 /* PropagatingFlags */
|
|
);
|
|
result.compositeKind = 1048576 /* Union */;
|
|
result.compositeSignatures = concatenate(left.compositeKind !== 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
|
|
if (paramMapper) {
|
|
result.mapper = left.compositeKind !== 2097152 /* Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper;
|
|
}
|
|
return result;
|
|
}
|
|
function getUnionIndexInfos(types) {
|
|
const sourceInfos = getIndexInfosOfType(types[0]);
|
|
if (sourceInfos) {
|
|
const result = [];
|
|
for (const info of sourceInfos) {
|
|
const indexType = info.keyType;
|
|
if (every(types, (t) => !!getIndexInfoOfType(t, indexType))) {
|
|
result.push(createIndexInfo(
|
|
indexType,
|
|
getUnionType(map(types, (t) => getIndexTypeOfType(t, indexType))),
|
|
some(types, (t) => getIndexInfoOfType(t, indexType).isReadonly)
|
|
));
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function resolveUnionTypeMembers(type) {
|
|
const callSignatures = getUnionSignatures(map(type.types, (t) => t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0 /* Call */)));
|
|
const constructSignatures = getUnionSignatures(map(type.types, (t) => getSignaturesOfType(t, 1 /* Construct */)));
|
|
const indexInfos = getUnionIndexInfos(type.types);
|
|
setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, indexInfos);
|
|
}
|
|
function intersectTypes(type1, type2) {
|
|
return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]);
|
|
}
|
|
function findMixins(types) {
|
|
const constructorTypeCount = countWhere(types, (t) => getSignaturesOfType(t, 1 /* Construct */).length > 0);
|
|
const mixinFlags = map(types, isMixinConstructorType);
|
|
if (constructorTypeCount > 0 && constructorTypeCount === countWhere(mixinFlags, (b) => b)) {
|
|
const firstMixinIndex = mixinFlags.indexOf(true);
|
|
mixinFlags[firstMixinIndex] = false;
|
|
}
|
|
return mixinFlags;
|
|
}
|
|
function includeMixinType(type, types, mixinFlags, index) {
|
|
const mixedTypes = [];
|
|
for (let i = 0; i < types.length; i++) {
|
|
if (i === index) {
|
|
mixedTypes.push(type);
|
|
} else if (mixinFlags[i]) {
|
|
mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1 /* Construct */)[0]));
|
|
}
|
|
}
|
|
return getIntersectionType(mixedTypes);
|
|
}
|
|
function resolveIntersectionTypeMembers(type) {
|
|
let callSignatures;
|
|
let constructSignatures;
|
|
let indexInfos;
|
|
const types = type.types;
|
|
const mixinFlags = findMixins(types);
|
|
const mixinCount = countWhere(mixinFlags, (b) => b);
|
|
for (let i = 0; i < types.length; i++) {
|
|
const t = type.types[i];
|
|
if (!mixinFlags[i]) {
|
|
let signatures = getSignaturesOfType(t, 1 /* Construct */);
|
|
if (signatures.length && mixinCount > 0) {
|
|
signatures = map(signatures, (s) => {
|
|
const clone2 = cloneSignature(s);
|
|
clone2.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i);
|
|
return clone2;
|
|
});
|
|
}
|
|
constructSignatures = appendSignatures(constructSignatures, signatures);
|
|
}
|
|
callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0 /* Call */));
|
|
indexInfos = reduceLeft(getIndexInfosOfType(t), (infos, newInfo) => appendIndexInfo(infos, newInfo, false), indexInfos);
|
|
}
|
|
setStructuredTypeMembers(type, emptySymbols, callSignatures || emptyArray, constructSignatures || emptyArray, indexInfos || emptyArray);
|
|
}
|
|
function appendSignatures(signatures, newSignatures) {
|
|
for (const sig of newSignatures) {
|
|
if (!signatures || every(signatures, (s) => !compareSignaturesIdentical(s, sig, false, false, false, compareTypesIdentical))) {
|
|
signatures = append(signatures, sig);
|
|
}
|
|
}
|
|
return signatures;
|
|
}
|
|
function appendIndexInfo(indexInfos, newInfo, union) {
|
|
if (indexInfos) {
|
|
for (let i = 0; i < indexInfos.length; i++) {
|
|
const info = indexInfos[i];
|
|
if (info.keyType === newInfo.keyType) {
|
|
indexInfos[i] = createIndexInfo(
|
|
info.keyType,
|
|
union ? getUnionType([info.type, newInfo.type]) : getIntersectionType([info.type, newInfo.type]),
|
|
union ? info.isReadonly || newInfo.isReadonly : info.isReadonly && newInfo.isReadonly
|
|
);
|
|
return indexInfos;
|
|
}
|
|
}
|
|
}
|
|
return append(indexInfos, newInfo);
|
|
}
|
|
function resolveAnonymousTypeMembers(type) {
|
|
if (type.target) {
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const members2 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, false);
|
|
const callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* Call */), type.mapper);
|
|
const constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper);
|
|
const indexInfos2 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
|
|
setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
|
|
return;
|
|
}
|
|
const symbol = getMergedSymbol(type.symbol);
|
|
if (symbol.flags & 2048 /* TypeLiteral */) {
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const members2 = getMembersOfSymbol(symbol);
|
|
const callSignatures = getSignaturesOfSymbol(members2.get("__call" /* Call */));
|
|
const constructSignatures = getSignaturesOfSymbol(members2.get("__new" /* New */));
|
|
const indexInfos2 = getIndexInfosOfSymbol(symbol);
|
|
setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
|
|
return;
|
|
}
|
|
let members = emptySymbols;
|
|
let indexInfos;
|
|
if (symbol.exports) {
|
|
members = getExportsOfSymbol(symbol);
|
|
if (symbol === globalThisSymbol) {
|
|
const varsOnly = /* @__PURE__ */ new Map();
|
|
members.forEach((p) => {
|
|
var _a2;
|
|
if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a2 = p.declarations) == null ? void 0 : _a2.length) && every(p.declarations, isAmbientModule))) {
|
|
varsOnly.set(p.escapedName, p);
|
|
}
|
|
});
|
|
members = varsOnly;
|
|
}
|
|
}
|
|
let baseConstructorIndexInfo;
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, emptyArray);
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classType);
|
|
if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
|
|
members = createSymbolTable(getNamedOrIndexSignatureMembers(members));
|
|
addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
|
|
} else if (baseConstructorType === anyType) {
|
|
baseConstructorIndexInfo = createIndexInfo(stringType, anyType, false);
|
|
}
|
|
}
|
|
const indexSymbol = getIndexSymbolFromSymbolTable(members);
|
|
if (indexSymbol) {
|
|
indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
|
|
} else {
|
|
if (baseConstructorIndexInfo) {
|
|
indexInfos = append(indexInfos, baseConstructorIndexInfo);
|
|
}
|
|
if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ || some(type.properties, (prop) => !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */)))) {
|
|
indexInfos = append(indexInfos, enumNumberIndexInfo);
|
|
}
|
|
}
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos || emptyArray);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
|
|
type.callSignatures = getSignaturesOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & 32 /* Class */) {
|
|
const classType = getDeclaredTypeOfClassOrInterface(symbol);
|
|
let constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : emptyArray;
|
|
if (symbol.flags & 16 /* Function */) {
|
|
constructSignatures = addRange(constructSignatures.slice(), mapDefined(
|
|
type.callSignatures,
|
|
(sig) => isJSConstructor(sig.declaration) ? createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType, void 0, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) : void 0
|
|
));
|
|
}
|
|
if (!constructSignatures.length) {
|
|
constructSignatures = getDefaultConstructSignatures(classType);
|
|
}
|
|
type.constructSignatures = constructSignatures;
|
|
}
|
|
}
|
|
function replaceIndexedAccess(instantiable, type, replacement) {
|
|
return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])]));
|
|
}
|
|
function resolveReverseMappedTypeMembers(type) {
|
|
const indexInfo = getIndexInfoOfType(type.source, stringType);
|
|
const modifiers = getMappedTypeModifiers(type.mappedType);
|
|
const readonlyMask = modifiers & 1 /* IncludeReadonly */ ? false : true;
|
|
const optionalMask = modifiers & 4 /* IncludeOptional */ ? 0 : 16777216 /* Optional */;
|
|
const indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : emptyArray;
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfType(type.source)) {
|
|
const checkFlags = 8192 /* ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* Readonly */ : 0);
|
|
const inferredProp = createSymbol(4 /* Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags);
|
|
inferredProp.declarations = prop.declarations;
|
|
inferredProp.nameType = getSymbolLinks(prop).nameType;
|
|
inferredProp.propertyType = getTypeOfSymbol(prop);
|
|
if (type.constraintType.type.flags & 8388608 /* IndexedAccess */ && type.constraintType.type.objectType.flags & 262144 /* TypeParameter */ && type.constraintType.type.indexType.flags & 262144 /* TypeParameter */) {
|
|
const newTypeParam = type.constraintType.type.objectType;
|
|
const newMappedType = replaceIndexedAccess(type.mappedType, type.constraintType.type, newTypeParam);
|
|
inferredProp.mappedType = newMappedType;
|
|
inferredProp.constraintType = getIndexType(newTypeParam);
|
|
} else {
|
|
inferredProp.mappedType = type.mappedType;
|
|
inferredProp.constraintType = type.constraintType;
|
|
}
|
|
members.set(prop.escapedName, inferredProp);
|
|
}
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos);
|
|
}
|
|
function getLowerBoundOfKeyType(type) {
|
|
if (type.flags & 4194304 /* Index */) {
|
|
const t = getApparentType(type.type);
|
|
return isGenericTupleType(t) ? getKnownKeysOfTupleType(t) : getIndexType(t);
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
if (type.root.isDistributive) {
|
|
const checkType = type.checkType;
|
|
const constraint = getLowerBoundOfKeyType(checkType);
|
|
if (constraint !== checkType) {
|
|
return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return mapType(type, getLowerBoundOfKeyType, true);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
const types = type.types;
|
|
if (types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType) {
|
|
return type;
|
|
}
|
|
return getIntersectionType(sameMap(type.types, getLowerBoundOfKeyType));
|
|
}
|
|
return type;
|
|
}
|
|
function getIsLateCheckFlag(s) {
|
|
return getCheckFlags(s) & 4096 /* Late */;
|
|
}
|
|
function forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(type, include, stringsOnly, cb) {
|
|
for (const prop of getPropertiesOfType(type)) {
|
|
cb(getLiteralTypeFromProperty(prop, include));
|
|
}
|
|
if (type.flags & 1 /* Any */) {
|
|
cb(stringType);
|
|
} else {
|
|
for (const info of getIndexInfosOfType(type)) {
|
|
if (!stringsOnly || info.keyType.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
|
|
cb(info.keyType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function resolveMappedTypeMembers(type) {
|
|
const members = createSymbolTable();
|
|
let indexInfos;
|
|
setStructuredTypeMembers(type, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
const typeParameter = getTypeParameterFromMappedType(type);
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
const nameType = getNameTypeFromMappedType(type.target || type);
|
|
const templateType = getTemplateTypeFromMappedType(type.target || type);
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
|
|
const templateModifiers = getMappedTypeModifiers(type);
|
|
const include = keyofStringsOnly ? 128 /* StringLiteral */ : 8576 /* StringOrNumberLiteralOrUnique */;
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType);
|
|
} else {
|
|
forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
|
|
}
|
|
setStructuredTypeMembers(type, members, emptyArray, emptyArray, indexInfos || emptyArray);
|
|
function addMemberForKeyType(keyType) {
|
|
const propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
|
|
forEachType(propNameType, (t) => addMemberForKeyTypeWorker(keyType, t));
|
|
}
|
|
function addMemberForKeyTypeWorker(keyType, propNameType) {
|
|
if (isTypeUsableAsPropertyName(propNameType)) {
|
|
const propName = getPropertyNameFromType(propNameType);
|
|
const existingProp = members.get(propName);
|
|
if (existingProp) {
|
|
existingProp.nameType = getUnionType([existingProp.nameType, propNameType]);
|
|
existingProp.keyType = getUnionType([existingProp.keyType, keyType]);
|
|
} else {
|
|
const modifiersProp = isTypeUsableAsPropertyName(keyType) ? getPropertyOfType(modifiersType, getPropertyNameFromType(keyType)) : void 0;
|
|
const isOptional = !!(templateModifiers & 4 /* IncludeOptional */ || !(templateModifiers & 8 /* ExcludeOptional */) && modifiersProp && modifiersProp.flags & 16777216 /* Optional */);
|
|
const isReadonly = !!(templateModifiers & 1 /* IncludeReadonly */ || !(templateModifiers & 2 /* ExcludeReadonly */) && modifiersProp && isReadonlySymbol(modifiersProp));
|
|
const stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 /* Optional */;
|
|
const lateFlag = modifiersProp ? getIsLateCheckFlag(modifiersProp) : 0;
|
|
const 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;
|
|
if (modifiersProp) {
|
|
prop.syntheticOrigin = modifiersProp;
|
|
prop.declarations = nameType ? void 0 : modifiersProp.declarations;
|
|
}
|
|
members.set(propName, prop);
|
|
}
|
|
} else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* Any */ | 32 /* Enum */)) {
|
|
const indexKeyType = propNameType.flags & (1 /* Any */ | 4 /* String */) ? stringType : propNameType.flags & (8 /* Number */ | 32 /* Enum */) ? numberType : propNameType;
|
|
const propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType));
|
|
const indexInfo = createIndexInfo(indexKeyType, propType, !!(templateModifiers & 1 /* IncludeReadonly */));
|
|
indexInfos = appendIndexInfo(indexInfos, indexInfo, true);
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfMappedSymbol(symbol) {
|
|
if (!symbol.type) {
|
|
const mappedType = symbol.mappedType;
|
|
if (!pushTypeResolution(symbol, 0 /* Type */)) {
|
|
mappedType.containsError = true;
|
|
return errorType;
|
|
}
|
|
const templateType = getTemplateTypeFromMappedType(mappedType.target || mappedType);
|
|
const mapper = appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), symbol.keyType);
|
|
const propType = instantiateType(templateType, mapper);
|
|
let type = strictNullChecks && symbol.flags & 16777216 /* Optional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(propType, true) : symbol.checkFlags & 524288 /* StripOptional */ ? removeMissingOrUndefinedType(propType) : propType;
|
|
if (!popTypeResolution()) {
|
|
error(currentNode, Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, symbolToString(symbol), typeToString(mappedType));
|
|
type = errorType;
|
|
}
|
|
symbol.type = type;
|
|
}
|
|
return symbol.type;
|
|
}
|
|
function getTypeParameterFromMappedType(type) {
|
|
return type.typeParameter || (type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter)));
|
|
}
|
|
function getConstraintTypeFromMappedType(type) {
|
|
return type.constraintType || (type.constraintType = getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)) || errorType);
|
|
}
|
|
function getNameTypeFromMappedType(type) {
|
|
return type.declaration.nameType ? type.nameType || (type.nameType = instantiateType(getTypeFromTypeNode(type.declaration.nameType), type.mapper)) : void 0;
|
|
}
|
|
function getTemplateTypeFromMappedType(type) {
|
|
return type.templateType || (type.templateType = type.declaration.type ? instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), true, !!(getMappedTypeModifiers(type) & 4 /* IncludeOptional */)), type.mapper) : errorType);
|
|
}
|
|
function getConstraintDeclarationForMappedType(type) {
|
|
return getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter);
|
|
}
|
|
function isMappedTypeWithKeyofConstraintDeclaration(type) {
|
|
const constraintDeclaration = getConstraintDeclarationForMappedType(type);
|
|
return constraintDeclaration.kind === 195 /* TypeOperator */ && constraintDeclaration.operator === 141 /* KeyOfKeyword */;
|
|
}
|
|
function getModifiersTypeFromMappedType(type) {
|
|
if (!type.modifiersType) {
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper);
|
|
} else {
|
|
const declaredType = getTypeFromMappedTypeNode(type.declaration);
|
|
const constraint = getConstraintTypeFromMappedType(declaredType);
|
|
const extendedConstraint = constraint && constraint.flags & 262144 /* TypeParameter */ ? getConstraintOfTypeParameter(constraint) : constraint;
|
|
type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 /* Index */ ? instantiateType(extendedConstraint.type, type.mapper) : unknownType;
|
|
}
|
|
}
|
|
return type.modifiersType;
|
|
}
|
|
function getMappedTypeModifiers(type) {
|
|
const declaration = type.declaration;
|
|
return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 /* MinusToken */ ? 2 /* ExcludeReadonly */ : 1 /* IncludeReadonly */ : 0) | (declaration.questionToken ? declaration.questionToken.kind === 40 /* MinusToken */ ? 8 /* ExcludeOptional */ : 4 /* IncludeOptional */ : 0);
|
|
}
|
|
function getMappedTypeOptionality(type) {
|
|
const modifiers = getMappedTypeModifiers(type);
|
|
return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
|
|
}
|
|
function getCombinedMappedTypeOptionality(type) {
|
|
const optionality = getMappedTypeOptionality(type);
|
|
const modifiersType = getModifiersTypeFromMappedType(type);
|
|
return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0);
|
|
}
|
|
function isPartialMappedType(type) {
|
|
return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
|
|
}
|
|
function isGenericMappedType(type) {
|
|
if (getObjectFlags(type) & 32 /* Mapped */) {
|
|
const constraint = getConstraintTypeFromMappedType(type);
|
|
if (isGenericIndexType(constraint)) {
|
|
return true;
|
|
}
|
|
const nameType = getNameTypeFromMappedType(type);
|
|
if (nameType && isGenericIndexType(instantiateType(nameType, makeUnaryTypeMapper(getTypeParameterFromMappedType(type), constraint)))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function resolveStructuredTypeMembers(type) {
|
|
if (!type.members) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
if (type.objectFlags & 4 /* Reference */) {
|
|
resolveTypeReferenceMembers(type);
|
|
} else if (type.objectFlags & 3 /* ClassOrInterface */) {
|
|
resolveClassOrInterfaceMembers(type);
|
|
} else if (type.objectFlags & 1024 /* ReverseMapped */) {
|
|
resolveReverseMappedTypeMembers(type);
|
|
} else if (type.objectFlags & 16 /* Anonymous */) {
|
|
resolveAnonymousTypeMembers(type);
|
|
} else if (type.objectFlags & 32 /* Mapped */) {
|
|
resolveMappedTypeMembers(type);
|
|
} else {
|
|
Debug.fail("Unhandled object type " + Debug.formatObjectFlags(type.objectFlags));
|
|
}
|
|
} else if (type.flags & 1048576 /* Union */) {
|
|
resolveUnionTypeMembers(type);
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
resolveIntersectionTypeMembers(type);
|
|
} else {
|
|
Debug.fail("Unhandled type " + Debug.formatTypeFlags(type.flags));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function getPropertiesOfObjectType(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
return resolveStructuredTypeMembers(type).properties;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getPropertyOfObjectType(type, name) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
const symbol = resolved.members.get(name);
|
|
if (symbol && symbolIsValue(symbol)) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
function getPropertiesOfUnionOrIntersectionType(type) {
|
|
if (!type.resolvedProperties) {
|
|
const members = createSymbolTable();
|
|
for (const current of type.types) {
|
|
for (const prop of getPropertiesOfType(current)) {
|
|
if (!members.has(prop.escapedName)) {
|
|
const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
|
|
if (combinedProp) {
|
|
members.set(prop.escapedName, combinedProp);
|
|
}
|
|
}
|
|
}
|
|
if (type.flags & 1048576 /* Union */ && getIndexInfosOfType(current).length === 0) {
|
|
break;
|
|
}
|
|
}
|
|
type.resolvedProperties = getNamedMembers(members);
|
|
}
|
|
return type.resolvedProperties;
|
|
}
|
|
function getPropertiesOfType(type) {
|
|
type = getReducedApparentType(type);
|
|
return type.flags & 3145728 /* UnionOrIntersection */ ? getPropertiesOfUnionOrIntersectionType(type) : getPropertiesOfObjectType(type);
|
|
}
|
|
function forEachPropertyOfType(type, action) {
|
|
type = getReducedApparentType(type);
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
resolveStructuredTypeMembers(type).members.forEach((symbol, escapedName) => {
|
|
if (isNamedMember(symbol, escapedName)) {
|
|
action(symbol, escapedName);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) {
|
|
const list = obj.properties;
|
|
return list.some((property) => {
|
|
const nameType = property.name && getLiteralTypeFromPropertyName(property.name);
|
|
const name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : void 0;
|
|
const expected = name === void 0 ? void 0 : getTypeOfPropertyOfType(contextualType, name);
|
|
return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected);
|
|
});
|
|
}
|
|
function getAllPossiblePropertiesOfTypes(types) {
|
|
const unionType = getUnionType(types);
|
|
if (!(unionType.flags & 1048576 /* Union */)) {
|
|
return getAugmentedPropertiesOfType(unionType);
|
|
}
|
|
const props = createSymbolTable();
|
|
for (const memberType of types) {
|
|
for (const { escapedName } of getAugmentedPropertiesOfType(memberType)) {
|
|
if (!props.has(escapedName)) {
|
|
const prop = createUnionOrIntersectionProperty(unionType, escapedName);
|
|
if (prop)
|
|
props.set(escapedName, prop);
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(props.values());
|
|
}
|
|
function getConstraintOfType(type) {
|
|
return type.flags & 262144 /* TypeParameter */ ? getConstraintOfTypeParameter(type) : type.flags & 8388608 /* IndexedAccess */ ? getConstraintOfIndexedAccess(type) : type.flags & 16777216 /* Conditional */ ? getConstraintOfConditionalType(type) : getBaseConstraintOfType(type);
|
|
}
|
|
function getConstraintOfTypeParameter(typeParameter) {
|
|
return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : void 0;
|
|
}
|
|
function getConstraintOfIndexedAccess(type) {
|
|
return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
|
|
}
|
|
function getSimplifiedTypeOrConstraint(type) {
|
|
const simplified = getSimplifiedType(type, false);
|
|
return simplified !== type ? simplified : getConstraintOfType(type);
|
|
}
|
|
function getConstraintFromIndexedAccess(type) {
|
|
if (isMappedTypeGenericIndexedAccess(type)) {
|
|
return substituteIndexedMappedType(type.objectType, type.indexType);
|
|
}
|
|
const indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
|
|
if (indexConstraint && indexConstraint !== type.indexType) {
|
|
const indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags);
|
|
if (indexedAccess) {
|
|
return indexedAccess;
|
|
}
|
|
}
|
|
const objectConstraint = getSimplifiedTypeOrConstraint(type.objectType);
|
|
if (objectConstraint && objectConstraint !== type.objectType) {
|
|
return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType, type.accessFlags);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDefaultConstraintOfConditionalType(type) {
|
|
if (!type.resolvedDefaultConstraint) {
|
|
const trueConstraint = getInferredTrueTypeFromConditionalType(type);
|
|
const falseConstraint = getFalseTypeFromConditionalType(type);
|
|
type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]);
|
|
}
|
|
return type.resolvedDefaultConstraint;
|
|
}
|
|
function getConstraintOfDistributiveConditionalType(type) {
|
|
if (type.root.isDistributive && type.restrictiveInstantiation !== type) {
|
|
const simplified = getSimplifiedType(type.checkType, false);
|
|
const constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified;
|
|
if (constraint && constraint !== type.checkType) {
|
|
const instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper));
|
|
if (!(instantiated.flags & 131072 /* Never */)) {
|
|
return instantiated;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getConstraintFromConditionalType(type) {
|
|
return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type);
|
|
}
|
|
function getConstraintOfConditionalType(type) {
|
|
return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : void 0;
|
|
}
|
|
function getEffectiveConstraintOfIntersection(types, targetIsUnion) {
|
|
let constraints;
|
|
let hasDisjointDomainType = false;
|
|
for (const t of types) {
|
|
if (t.flags & 465829888 /* Instantiable */) {
|
|
let constraint = getConstraintOfType(t);
|
|
while (constraint && constraint.flags & (262144 /* TypeParameter */ | 4194304 /* Index */ | 16777216 /* Conditional */)) {
|
|
constraint = getConstraintOfType(constraint);
|
|
}
|
|
if (constraint) {
|
|
constraints = append(constraints, constraint);
|
|
if (targetIsUnion) {
|
|
constraints = append(constraints, t);
|
|
}
|
|
}
|
|
} else if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
|
|
hasDisjointDomainType = true;
|
|
}
|
|
}
|
|
if (constraints && (targetIsUnion || hasDisjointDomainType)) {
|
|
if (hasDisjointDomainType) {
|
|
for (const t of types) {
|
|
if (t.flags & 469892092 /* DisjointDomains */ || isEmptyAnonymousObjectType(t)) {
|
|
constraints = append(constraints, t);
|
|
}
|
|
}
|
|
}
|
|
return getNormalizedType(getIntersectionType(constraints), false);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getBaseConstraintOfType(type) {
|
|
if (type.flags & (58982400 /* InstantiableNonPrimitive */ | 3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */)) {
|
|
const constraint = getResolvedBaseConstraint(type);
|
|
return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : void 0;
|
|
}
|
|
return type.flags & 4194304 /* Index */ ? keyofConstraintType : void 0;
|
|
}
|
|
function getBaseConstraintOrType(type) {
|
|
return getBaseConstraintOfType(type) || type;
|
|
}
|
|
function hasNonCircularBaseConstraint(type) {
|
|
return getResolvedBaseConstraint(type) !== circularConstraintType;
|
|
}
|
|
function getResolvedBaseConstraint(type) {
|
|
if (type.resolvedBaseConstraint) {
|
|
return type.resolvedBaseConstraint;
|
|
}
|
|
const stack = [];
|
|
return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type);
|
|
function getImmediateBaseConstraint(t) {
|
|
if (!t.immediateBaseConstraint) {
|
|
if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
|
|
return circularConstraintType;
|
|
}
|
|
let result;
|
|
const identity2 = getRecursionIdentity(t);
|
|
if (stack.length < 10 || stack.length < 50 && !contains(stack, identity2)) {
|
|
stack.push(identity2);
|
|
result = computeBaseConstraint(getSimplifiedType(t, false));
|
|
stack.pop();
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
const errorNode = getConstraintDeclaration(t);
|
|
if (errorNode) {
|
|
const diagnostic = error(errorNode, Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t));
|
|
if (currentNode && !isNodeDescendantOf(errorNode, currentNode) && !isNodeDescendantOf(currentNode, errorNode)) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(currentNode, Diagnostics.Circularity_originates_in_type_at_this_location));
|
|
}
|
|
}
|
|
}
|
|
result = circularConstraintType;
|
|
}
|
|
t.immediateBaseConstraint = result || noConstraintType;
|
|
}
|
|
return t.immediateBaseConstraint;
|
|
}
|
|
function getBaseConstraint(t) {
|
|
const c = getImmediateBaseConstraint(t);
|
|
return c !== noConstraintType && c !== circularConstraintType ? c : void 0;
|
|
}
|
|
function computeBaseConstraint(t) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
const constraint = getConstraintFromTypeParameter(t);
|
|
return t.isThisType || !constraint ? constraint : getBaseConstraint(constraint);
|
|
}
|
|
if (t.flags & 3145728 /* UnionOrIntersection */) {
|
|
const types = t.types;
|
|
const baseTypes = [];
|
|
let different = false;
|
|
for (const type2 of types) {
|
|
const baseType = getBaseConstraint(type2);
|
|
if (baseType) {
|
|
if (baseType !== type2) {
|
|
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) : void 0;
|
|
}
|
|
if (t.flags & 4194304 /* Index */) {
|
|
return keyofConstraintType;
|
|
}
|
|
if (t.flags & 134217728 /* TemplateLiteral */) {
|
|
const types = t.types;
|
|
const constraints = mapDefined(types, getBaseConstraint);
|
|
return constraints.length === types.length ? getTemplateLiteralType(t.texts, constraints) : stringType;
|
|
}
|
|
if (t.flags & 268435456 /* StringMapping */) {
|
|
const constraint = getBaseConstraint(t.type);
|
|
return constraint && constraint !== t.type ? getStringMappingType(t.symbol, constraint) : stringType;
|
|
}
|
|
if (t.flags & 8388608 /* IndexedAccess */) {
|
|
if (isMappedTypeGenericIndexedAccess(t)) {
|
|
return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType));
|
|
}
|
|
const baseObjectType = getBaseConstraint(t.objectType);
|
|
const baseIndexType = getBaseConstraint(t.indexType);
|
|
const baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags);
|
|
return baseIndexedAccess && getBaseConstraint(baseIndexedAccess);
|
|
}
|
|
if (t.flags & 16777216 /* Conditional */) {
|
|
const constraint = getConstraintFromConditionalType(t);
|
|
return constraint && getBaseConstraint(constraint);
|
|
}
|
|
if (t.flags & 33554432 /* Substitution */) {
|
|
return getBaseConstraint(getSubstitutionIntersection(t));
|
|
}
|
|
return t;
|
|
}
|
|
}
|
|
function getApparentTypeOfIntersectionType(type) {
|
|
return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, true));
|
|
}
|
|
function getResolvedTypeParameterDefault(typeParameter) {
|
|
if (!typeParameter.default) {
|
|
if (typeParameter.target) {
|
|
const targetDefault = getResolvedTypeParameterDefault(typeParameter.target);
|
|
typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType;
|
|
} else {
|
|
typeParameter.default = resolvingDefaultType;
|
|
const defaultDeclaration = typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default);
|
|
const defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType;
|
|
if (typeParameter.default === resolvingDefaultType) {
|
|
typeParameter.default = defaultType;
|
|
}
|
|
}
|
|
} else if (typeParameter.default === resolvingDefaultType) {
|
|
typeParameter.default = circularConstraintType;
|
|
}
|
|
return typeParameter.default;
|
|
}
|
|
function getDefaultFromTypeParameter(typeParameter) {
|
|
const defaultType = getResolvedTypeParameterDefault(typeParameter);
|
|
return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : void 0;
|
|
}
|
|
function hasNonCircularTypeParameterDefault(typeParameter) {
|
|
return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType;
|
|
}
|
|
function hasTypeParameterDefault(typeParameter) {
|
|
return !!(typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default));
|
|
}
|
|
function getApparentTypeOfMappedType(type) {
|
|
return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
|
|
}
|
|
function getResolvedApparentTypeOfMappedType(type) {
|
|
const typeVariable = getHomomorphicTypeVariable(type);
|
|
if (typeVariable && !type.declaration.nameType) {
|
|
const constraint = getConstraintOfTypeParameter(typeVariable);
|
|
if (constraint && isArrayOrTupleType(constraint)) {
|
|
return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function isMappedTypeGenericIndexedAccess(type) {
|
|
let objectType;
|
|
return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
|
|
}
|
|
function getApparentType(type) {
|
|
const t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
|
|
return getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
|
|
}
|
|
function getReducedApparentType(type) {
|
|
return getReducedType(getApparentType(getReducedType(type)));
|
|
}
|
|
function createUnionOrIntersectionProperty(containingType, name, skipObjectFunctionPropertyAugment) {
|
|
var _a2, _b;
|
|
let singleProp;
|
|
let propSet;
|
|
let indexTypes;
|
|
const isUnion = containingType.flags & 1048576 /* Union */;
|
|
let optionalFlag;
|
|
let syntheticFlag = 4 /* SyntheticMethod */;
|
|
let checkFlags = isUnion ? 0 : 8 /* Readonly */;
|
|
let mergedInstantiations = false;
|
|
for (const current of containingType.types) {
|
|
const type = getApparentType(current);
|
|
if (!(isErrorType(type) || type.flags & 131072 /* Never */)) {
|
|
const prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment);
|
|
const modifiers = prop ? getDeclarationModifierFlagsFromSymbol(prop) : 0;
|
|
if (prop) {
|
|
if (prop.flags & 106500 /* ClassMember */) {
|
|
optionalFlag != null ? optionalFlag : optionalFlag = isUnion ? 0 /* None */ : 16777216 /* Optional */;
|
|
if (isUnion) {
|
|
optionalFlag |= prop.flags & 16777216 /* Optional */;
|
|
} else {
|
|
optionalFlag &= prop.flags;
|
|
}
|
|
}
|
|
if (!singleProp) {
|
|
singleProp = prop;
|
|
} else if (prop !== singleProp) {
|
|
const isInstantiation = (getTargetSymbol(prop) || prop) === (getTargetSymbol(singleProp) || singleProp);
|
|
if (isInstantiation && compareProperties2(singleProp, prop, (a, b) => a === b ? -1 /* True */ : 0 /* False */) === -1 /* True */) {
|
|
mergedInstantiations = !!singleProp.parent && !!length(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(singleProp.parent));
|
|
} else {
|
|
if (!propSet) {
|
|
propSet = /* @__PURE__ */ new Map();
|
|
propSet.set(getSymbolId(singleProp), singleProp);
|
|
}
|
|
const id = getSymbolId(prop);
|
|
if (!propSet.has(id)) {
|
|
propSet.set(id, prop);
|
|
}
|
|
}
|
|
}
|
|
if (isUnion && isReadonlySymbol(prop)) {
|
|
checkFlags |= 8 /* Readonly */;
|
|
} else if (!isUnion && !isReadonlySymbol(prop)) {
|
|
checkFlags &= ~8 /* Readonly */;
|
|
}
|
|
checkFlags |= (!(modifiers & 24 /* NonPublicAccessibilityModifier */) ? 256 /* ContainsPublic */ : 0) | (modifiers & 16 /* Protected */ ? 512 /* ContainsProtected */ : 0) | (modifiers & 8 /* Private */ ? 1024 /* ContainsPrivate */ : 0) | (modifiers & 32 /* Static */ ? 2048 /* ContainsStatic */ : 0);
|
|
if (!isPrototypeProperty(prop)) {
|
|
syntheticFlag = 2 /* SyntheticProperty */;
|
|
}
|
|
} else if (isUnion) {
|
|
const indexInfo = !isLateBoundName(name) && getApplicableIndexInfoForName(type, name);
|
|
if (indexInfo) {
|
|
checkFlags |= 32 /* WritePartial */ | (indexInfo.isReadonly ? 8 /* Readonly */ : 0);
|
|
indexTypes = append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type);
|
|
} else if (isObjectLiteralType2(type) && !(getObjectFlags(type) & 2097152 /* ContainsSpread */)) {
|
|
checkFlags |= 32 /* WritePartial */;
|
|
indexTypes = append(indexTypes, undefinedType);
|
|
} else {
|
|
checkFlags |= 16 /* ReadPartial */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!singleProp || isUnion && (propSet || checkFlags & 48 /* Partial */) && checkFlags & (1024 /* ContainsPrivate */ | 512 /* ContainsProtected */) && !(propSet && getCommonDeclarationsOfSymbols(arrayFrom(propSet.values())))) {
|
|
return void 0;
|
|
}
|
|
if (!propSet && !(checkFlags & 16 /* ReadPartial */) && !indexTypes) {
|
|
if (mergedInstantiations) {
|
|
const clone2 = createSymbolWithType(singleProp, singleProp.type);
|
|
clone2.parent = (_b = (_a2 = singleProp.valueDeclaration) == null ? void 0 : _a2.symbol) == null ? void 0 : _b.parent;
|
|
clone2.containingType = containingType;
|
|
clone2.mapper = singleProp.mapper;
|
|
return clone2;
|
|
} else {
|
|
return singleProp;
|
|
}
|
|
}
|
|
const props = propSet ? arrayFrom(propSet.values()) : [singleProp];
|
|
let declarations;
|
|
let firstType;
|
|
let nameType;
|
|
const propTypes = [];
|
|
let writeTypes;
|
|
let firstValueDeclaration;
|
|
let hasNonUniformValueDeclaration = false;
|
|
for (const prop of props) {
|
|
if (!firstValueDeclaration) {
|
|
firstValueDeclaration = prop.valueDeclaration;
|
|
} else if (prop.valueDeclaration && prop.valueDeclaration !== firstValueDeclaration) {
|
|
hasNonUniformValueDeclaration = true;
|
|
}
|
|
declarations = addRange(declarations, prop.declarations);
|
|
const type = getTypeOfSymbol(prop);
|
|
if (!firstType) {
|
|
firstType = type;
|
|
nameType = getSymbolLinks(prop).nameType;
|
|
}
|
|
const writeType = getWriteTypeOfSymbol(prop);
|
|
if (writeTypes || writeType !== type) {
|
|
writeTypes = append(!writeTypes ? propTypes.slice() : writeTypes, writeType);
|
|
} else if (type !== firstType) {
|
|
checkFlags |= 64 /* HasNonUniformType */;
|
|
}
|
|
if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) {
|
|
checkFlags |= 128 /* HasLiteralType */;
|
|
}
|
|
if (type.flags & 131072 /* Never */ && type !== uniqueLiteralType) {
|
|
checkFlags |= 131072 /* HasNeverType */;
|
|
}
|
|
propTypes.push(type);
|
|
}
|
|
addRange(propTypes, indexTypes);
|
|
const result = createSymbol(4 /* Property */ | (optionalFlag != null ? optionalFlag : 0), name, syntheticFlag | checkFlags);
|
|
result.containingType = containingType;
|
|
if (!hasNonUniformValueDeclaration && firstValueDeclaration) {
|
|
result.valueDeclaration = firstValueDeclaration;
|
|
if (firstValueDeclaration.symbol.parent) {
|
|
result.parent = firstValueDeclaration.symbol.parent;
|
|
}
|
|
}
|
|
result.declarations = declarations;
|
|
result.nameType = nameType;
|
|
if (propTypes.length > 2) {
|
|
result.checkFlags |= 65536 /* DeferredType */;
|
|
result.deferralParent = containingType;
|
|
result.deferralConstituents = propTypes;
|
|
result.deferralWriteConstituents = writeTypes;
|
|
} else {
|
|
result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes);
|
|
if (writeTypes) {
|
|
result.writeType = isUnion ? getUnionType(writeTypes) : getIntersectionType(writeTypes);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
|
|
var _a2, _b;
|
|
let property = ((_a2 = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a2.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
|
|
if (!property) {
|
|
property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
|
|
if (property) {
|
|
const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
|
|
properties.set(name, property);
|
|
}
|
|
}
|
|
return property;
|
|
}
|
|
function getCommonDeclarationsOfSymbols(symbols) {
|
|
let commonDeclarations;
|
|
for (const symbol of symbols) {
|
|
if (!symbol.declarations) {
|
|
return void 0;
|
|
}
|
|
if (!commonDeclarations) {
|
|
commonDeclarations = new Set(symbol.declarations);
|
|
continue;
|
|
}
|
|
commonDeclarations.forEach((declaration) => {
|
|
if (!contains(symbol.declarations, declaration)) {
|
|
commonDeclarations.delete(declaration);
|
|
}
|
|
});
|
|
if (commonDeclarations.size === 0) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return commonDeclarations;
|
|
}
|
|
function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) {
|
|
const property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
|
|
return property && !(getCheckFlags(property) & 16 /* ReadPartial */) ? property : void 0;
|
|
}
|
|
function getReducedType(type) {
|
|
if (type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */) {
|
|
return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type));
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
if (!(type.objectFlags & 16777216 /* IsNeverIntersectionComputed */)) {
|
|
type.objectFlags |= 16777216 /* IsNeverIntersectionComputed */ | (some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 33554432 /* IsNeverIntersection */ : 0);
|
|
}
|
|
return type.objectFlags & 33554432 /* IsNeverIntersection */ ? neverType : type;
|
|
}
|
|
return type;
|
|
}
|
|
function getReducedUnionType(unionType) {
|
|
const reducedTypes = sameMap(unionType.types, getReducedType);
|
|
if (reducedTypes === unionType.types) {
|
|
return unionType;
|
|
}
|
|
const reduced = getUnionType(reducedTypes);
|
|
if (reduced.flags & 1048576 /* Union */) {
|
|
reduced.resolvedReducedType = reduced;
|
|
}
|
|
return reduced;
|
|
}
|
|
function isNeverReducedProperty(prop) {
|
|
return isDiscriminantWithNeverType(prop) || isConflictingPrivateProperty(prop);
|
|
}
|
|
function isDiscriminantWithNeverType(prop) {
|
|
return !(prop.flags & 16777216 /* Optional */) && (getCheckFlags(prop) & (192 /* Discriminant */ | 131072 /* HasNeverType */)) === 192 /* Discriminant */ && !!(getTypeOfSymbol(prop).flags & 131072 /* Never */);
|
|
}
|
|
function isConflictingPrivateProperty(prop) {
|
|
return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
|
|
}
|
|
function elaborateNeverIntersection(errorInfo, type) {
|
|
if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
|
|
const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
|
|
if (neverProp) {
|
|
return chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents,
|
|
typeToString(type, void 0, 536870912 /* NoTypeReduction */),
|
|
symbolToString(neverProp)
|
|
);
|
|
}
|
|
const privateProp = find(getPropertiesOfUnionOrIntersectionType(type), isConflictingPrivateProperty);
|
|
if (privateProp) {
|
|
return chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some,
|
|
typeToString(type, void 0, 536870912 /* NoTypeReduction */),
|
|
symbolToString(privateProp)
|
|
);
|
|
}
|
|
}
|
|
return errorInfo;
|
|
}
|
|
function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment, includeTypeOnlyMembers) {
|
|
type = getReducedApparentType(type);
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
const symbol = resolved.members.get(name);
|
|
if (symbol && symbolIsValue(symbol, includeTypeOnlyMembers)) {
|
|
return symbol;
|
|
}
|
|
if (skipObjectFunctionPropertyAugment)
|
|
return void 0;
|
|
const functionType = resolved === anyFunctionType ? globalFunctionType : resolved.callSignatures.length ? globalCallableFunctionType : resolved.constructSignatures.length ? globalNewableFunctionType : void 0;
|
|
if (functionType) {
|
|
const symbol2 = getPropertyOfObjectType(functionType, name);
|
|
if (symbol2) {
|
|
return symbol2;
|
|
}
|
|
}
|
|
return getPropertyOfObjectType(globalObjectType, name);
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSignaturesOfStructuredType(type, kind) {
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return kind === 0 /* Call */ ? resolved.callSignatures : resolved.constructSignatures;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getSignaturesOfType(type, kind) {
|
|
return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
|
|
}
|
|
function findIndexInfo(indexInfos, keyType) {
|
|
return find(indexInfos, (info) => info.keyType === keyType);
|
|
}
|
|
function findApplicableIndexInfo(indexInfos, keyType) {
|
|
let stringIndexInfo;
|
|
let applicableInfo;
|
|
let applicableInfos;
|
|
for (const info of indexInfos) {
|
|
if (info.keyType === stringType) {
|
|
stringIndexInfo = info;
|
|
} else if (isApplicableIndexType(keyType, info.keyType)) {
|
|
if (!applicableInfo) {
|
|
applicableInfo = info;
|
|
} else {
|
|
(applicableInfos || (applicableInfos = [applicableInfo])).push(info);
|
|
}
|
|
}
|
|
}
|
|
return applicableInfos ? createIndexInfo(
|
|
unknownType,
|
|
getIntersectionType(map(applicableInfos, (info) => info.type)),
|
|
reduceLeft(applicableInfos, (isReadonly, info) => isReadonly && info.isReadonly, true)
|
|
) : applicableInfo ? applicableInfo : stringIndexInfo && isApplicableIndexType(keyType, stringType) ? stringIndexInfo : void 0;
|
|
}
|
|
function isApplicableIndexType(source, target) {
|
|
return isTypeAssignableTo(source, target) || target === stringType && isTypeAssignableTo(source, numberType) || target === numberType && (source === numericStringType || !!(source.flags & 128 /* StringLiteral */) && isNumericLiteralName(source.value));
|
|
}
|
|
function getIndexInfosOfStructuredType(type) {
|
|
if (type.flags & 3670016 /* StructuredType */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return resolved.indexInfos;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getIndexInfosOfType(type) {
|
|
return getIndexInfosOfStructuredType(getReducedApparentType(type));
|
|
}
|
|
function getIndexInfoOfType(type, keyType) {
|
|
return findIndexInfo(getIndexInfosOfType(type), keyType);
|
|
}
|
|
function getIndexTypeOfType(type, keyType) {
|
|
var _a2;
|
|
return (_a2 = getIndexInfoOfType(type, keyType)) == null ? void 0 : _a2.type;
|
|
}
|
|
function getApplicableIndexInfos(type, keyType) {
|
|
return getIndexInfosOfType(type).filter((info) => isApplicableIndexType(keyType, info.keyType));
|
|
}
|
|
function getApplicableIndexInfo(type, keyType) {
|
|
return findApplicableIndexInfo(getIndexInfosOfType(type), keyType);
|
|
}
|
|
function getApplicableIndexInfoForName(type, name) {
|
|
return getApplicableIndexInfo(type, isLateBoundName(name) ? esSymbolType : getStringLiteralType(unescapeLeadingUnderscores(name)));
|
|
}
|
|
function getTypeParametersFromDeclaration(declaration) {
|
|
var _a2;
|
|
let result;
|
|
for (const node of getEffectiveTypeParameterDeclarations(declaration)) {
|
|
result = appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol));
|
|
}
|
|
return (result == null ? void 0 : result.length) ? result : isFunctionDeclaration(declaration) ? (_a2 = getSignatureOfTypeTag(declaration)) == null ? void 0 : _a2.typeParameters : void 0;
|
|
}
|
|
function symbolsToArray(symbols) {
|
|
const result = [];
|
|
symbols.forEach((symbol, id) => {
|
|
if (!isReservedMemberName(id)) {
|
|
result.push(symbol);
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function isJSDocOptionalParameter(node) {
|
|
return isInJSFile(node) && (node.type && node.type.kind === 319 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(({ isBracketed, typeExpression }) => isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* JSDocOptionalType */));
|
|
}
|
|
function tryFindAmbientModule(moduleName, withAugmentations) {
|
|
if (isExternalModuleNameRelative(moduleName)) {
|
|
return void 0;
|
|
}
|
|
const symbol = getSymbol2(globals, '"' + moduleName + '"', 512 /* ValueModule */);
|
|
return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
|
|
}
|
|
function isOptionalParameter(node) {
|
|
if (hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) {
|
|
return true;
|
|
}
|
|
if (node.initializer) {
|
|
const signature = getSignatureFromDeclaration(node.parent);
|
|
const parameterIndex = node.parent.parameters.indexOf(node);
|
|
Debug.assert(parameterIndex >= 0);
|
|
return parameterIndex >= getMinArgumentCount(signature, 1 /* StrongArityForUntypedJS */ | 2 /* VoidIsNonOptional */);
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(node.parent);
|
|
if (iife) {
|
|
return !node.type && !node.dotDotDotToken && node.parent.parameters.indexOf(node) >= iife.arguments.length;
|
|
}
|
|
return false;
|
|
}
|
|
function isOptionalPropertyDeclaration(node) {
|
|
return isPropertyDeclaration(node) && !hasAccessorModifier(node) && node.questionToken;
|
|
}
|
|
function createTypePredicate(kind, parameterName, parameterIndex, type) {
|
|
return { kind, parameterName, parameterIndex, type };
|
|
}
|
|
function getMinTypeArgumentCount(typeParameters) {
|
|
let minTypeArgumentCount = 0;
|
|
if (typeParameters) {
|
|
for (let i = 0; i < typeParameters.length; i++) {
|
|
if (!hasTypeParameterDefault(typeParameters[i])) {
|
|
minTypeArgumentCount = i + 1;
|
|
}
|
|
}
|
|
}
|
|
return minTypeArgumentCount;
|
|
}
|
|
function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) {
|
|
const numTypeParameters = length(typeParameters);
|
|
if (!numTypeParameters) {
|
|
return [];
|
|
}
|
|
const numTypeArguments = length(typeArguments);
|
|
if (isJavaScriptImplicitAny || numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters) {
|
|
const result = typeArguments ? typeArguments.slice() : [];
|
|
for (let i = numTypeArguments; i < numTypeParameters; i++) {
|
|
result[i] = errorType;
|
|
}
|
|
const baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny);
|
|
for (let i = numTypeArguments; i < numTypeParameters; i++) {
|
|
let defaultType = getDefaultFromTypeParameter(typeParameters[i]);
|
|
if (isJavaScriptImplicitAny && defaultType && (isTypeIdenticalTo(defaultType, unknownType) || isTypeIdenticalTo(defaultType, emptyObjectType))) {
|
|
defaultType = anyType;
|
|
}
|
|
result[i] = defaultType ? instantiateType(defaultType, createTypeMapper(typeParameters, result)) : baseDefaultType;
|
|
}
|
|
result.length = typeParameters.length;
|
|
return result;
|
|
}
|
|
return typeArguments && typeArguments.slice();
|
|
}
|
|
function getSignatureFromDeclaration(declaration) {
|
|
const links = getNodeLinks(declaration);
|
|
if (!links.resolvedSignature) {
|
|
const parameters = [];
|
|
let flags = 0 /* None */;
|
|
let minArgumentCount = 0;
|
|
let thisParameter;
|
|
let hasThisParameter2 = false;
|
|
const iife = getImmediatelyInvokedFunctionExpression(declaration);
|
|
const isJSConstructSignature = isJSDocConstructSignature(declaration);
|
|
const isUntypedSignatureInJSFile = !iife && isInJSFile(declaration) && isValueSignatureDeclaration(declaration) && !hasJSDocParameterTags(declaration) && !getJSDocType(declaration);
|
|
if (isUntypedSignatureInJSFile) {
|
|
flags |= 32 /* IsUntypedSignatureInJSFile */;
|
|
}
|
|
for (let i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) {
|
|
const param = declaration.parameters[i];
|
|
let paramSymbol = param.symbol;
|
|
const type = isJSDocParameterTag(param) ? param.typeExpression && param.typeExpression.type : param.type;
|
|
if (paramSymbol && !!(paramSymbol.flags & 4 /* Property */) && !isBindingPattern(param.name)) {
|
|
const resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551 /* Value */, void 0, void 0, false);
|
|
paramSymbol = resolvedSymbol;
|
|
}
|
|
if (i === 0 && paramSymbol.escapedName === "this" /* This */) {
|
|
hasThisParameter2 = true;
|
|
thisParameter = param.symbol;
|
|
} else {
|
|
parameters.push(paramSymbol);
|
|
}
|
|
if (type && type.kind === 198 /* LiteralType */) {
|
|
flags |= 2 /* HasLiteralTypes */;
|
|
}
|
|
const isOptionalParameter2 = isOptionalJSDocPropertyLikeTag(param) || param.initializer || param.questionToken || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type || isJSDocOptionalParameter(param);
|
|
if (!isOptionalParameter2) {
|
|
minArgumentCount = parameters.length;
|
|
}
|
|
}
|
|
if ((declaration.kind === 174 /* GetAccessor */ || declaration.kind === 175 /* SetAccessor */) && hasBindableName(declaration) && (!hasThisParameter2 || !thisParameter)) {
|
|
const otherKind = declaration.kind === 174 /* GetAccessor */ ? 175 /* SetAccessor */ : 174 /* GetAccessor */;
|
|
const other = getDeclarationOfKind(getSymbolOfNode(declaration), otherKind);
|
|
if (other) {
|
|
thisParameter = getAnnotatedAccessorThisParameter(other);
|
|
}
|
|
}
|
|
const classType = declaration.kind === 173 /* Constructor */ ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)) : void 0;
|
|
const typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration);
|
|
if (hasRestParameter(declaration) || isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) {
|
|
flags |= 1 /* HasRestParameter */;
|
|
}
|
|
if (isConstructorTypeNode(declaration) && hasSyntacticModifier(declaration, 256 /* Abstract */) || isConstructorDeclaration(declaration) && hasSyntacticModifier(declaration.parent, 256 /* Abstract */)) {
|
|
flags |= 4 /* Abstract */;
|
|
}
|
|
links.resolvedSignature = createSignature(
|
|
declaration,
|
|
typeParameters,
|
|
thisParameter,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
minArgumentCount,
|
|
flags
|
|
);
|
|
}
|
|
return links.resolvedSignature;
|
|
}
|
|
function maybeAddJsSyntheticRestParameter(declaration, parameters) {
|
|
if (isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) {
|
|
return false;
|
|
}
|
|
const lastParam = lastOrUndefined(declaration.parameters);
|
|
const lastParamTags = lastParam ? getJSDocParameterTags(lastParam) : getJSDocTags(declaration).filter(isJSDocParameterTag);
|
|
const lastParamVariadicType = firstDefined(lastParamTags, (p) => p.typeExpression && isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : void 0);
|
|
const syntheticArgsSymbol = createSymbol(3 /* Variable */, "args", 32768 /* RestParameter */);
|
|
if (lastParamVariadicType) {
|
|
syntheticArgsSymbol.type = createArrayType(getTypeFromTypeNode(lastParamVariadicType.type));
|
|
} else {
|
|
syntheticArgsSymbol.checkFlags |= 65536 /* DeferredType */;
|
|
syntheticArgsSymbol.deferralParent = neverType;
|
|
syntheticArgsSymbol.deferralConstituents = [anyArrayType];
|
|
syntheticArgsSymbol.deferralWriteConstituents = [anyArrayType];
|
|
}
|
|
if (lastParamVariadicType) {
|
|
parameters.pop();
|
|
}
|
|
parameters.push(syntheticArgsSymbol);
|
|
return true;
|
|
}
|
|
function getSignatureOfTypeTag(node) {
|
|
if (!(isInJSFile(node) && isFunctionLikeDeclaration(node)))
|
|
return void 0;
|
|
const typeTag = getJSDocTypeTag(node);
|
|
return (typeTag == null ? void 0 : typeTag.typeExpression) && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
|
|
}
|
|
function getParameterTypeOfTypeTag(func, parameter) {
|
|
const signature = getSignatureOfTypeTag(func);
|
|
if (!signature)
|
|
return void 0;
|
|
const pos = func.parameters.indexOf(parameter);
|
|
return parameter.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos);
|
|
}
|
|
function getReturnTypeOfTypeTag(node) {
|
|
const signature = getSignatureOfTypeTag(node);
|
|
return signature && getReturnTypeOfSignature(signature);
|
|
}
|
|
function containsArgumentsReference(declaration) {
|
|
const links = getNodeLinks(declaration);
|
|
if (links.containsArgumentsReference === void 0) {
|
|
if (links.flags & 512 /* CaptureArguments */) {
|
|
links.containsArgumentsReference = true;
|
|
} else {
|
|
links.containsArgumentsReference = traverse(declaration.body);
|
|
}
|
|
}
|
|
return links.containsArgumentsReference;
|
|
function traverse(node) {
|
|
if (!node)
|
|
return false;
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node.escapedText === argumentsSymbol.escapedName && getReferencedValueSymbol(node) === argumentsSymbol;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return node.name.kind === 164 /* ComputedPropertyName */ && traverse(node.name);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return traverse(node.expression);
|
|
case 299 /* PropertyAssignment */:
|
|
return traverse(node.initializer);
|
|
default:
|
|
return !nodeStartsNewLexicalEnvironment(node) && !isPartOfTypeNode(node) && !!forEachChild(node, traverse);
|
|
}
|
|
}
|
|
}
|
|
function getSignaturesOfSymbol(symbol) {
|
|
if (!symbol || !symbol.declarations)
|
|
return emptyArray;
|
|
const result = [];
|
|
for (let i = 0; i < symbol.declarations.length; i++) {
|
|
const decl = symbol.declarations[i];
|
|
if (!isFunctionLike(decl))
|
|
continue;
|
|
if (i > 0 && decl.body) {
|
|
const previous = symbol.declarations[i - 1];
|
|
if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) {
|
|
continue;
|
|
}
|
|
}
|
|
result.push(
|
|
!isFunctionExpressionOrArrowFunction(decl) && !isObjectLiteralMethod(decl) && getSignatureOfTypeTag(decl) || getSignatureFromDeclaration(decl)
|
|
);
|
|
}
|
|
return result;
|
|
}
|
|
function resolveExternalModuleTypeByLiteral(name) {
|
|
const moduleSym = resolveExternalModuleName(name, name);
|
|
if (moduleSym) {
|
|
const resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym);
|
|
if (resolvedModuleSymbol) {
|
|
return getTypeOfSymbol(resolvedModuleSymbol);
|
|
}
|
|
}
|
|
return anyType;
|
|
}
|
|
function getThisTypeOfSignature(signature) {
|
|
if (signature.thisParameter) {
|
|
return getTypeOfSymbol(signature.thisParameter);
|
|
}
|
|
}
|
|
function getTypePredicateOfSignature(signature) {
|
|
if (!signature.resolvedTypePredicate) {
|
|
if (signature.target) {
|
|
const targetTypePredicate = getTypePredicateOfSignature(signature.target);
|
|
signature.resolvedTypePredicate = targetTypePredicate ? instantiateTypePredicate(targetTypePredicate, signature.mapper) : noTypePredicate;
|
|
} else if (signature.compositeSignatures) {
|
|
signature.resolvedTypePredicate = getUnionOrIntersectionTypePredicate(signature.compositeSignatures, signature.compositeKind) || noTypePredicate;
|
|
} else {
|
|
const type = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
|
|
let jsdocPredicate;
|
|
if (!type) {
|
|
const jsdocSignature = getSignatureOfTypeTag(signature.declaration);
|
|
if (jsdocSignature && signature !== jsdocSignature) {
|
|
jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
|
|
}
|
|
}
|
|
signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
|
|
}
|
|
Debug.assert(!!signature.resolvedTypePredicate);
|
|
}
|
|
return signature.resolvedTypePredicate === noTypePredicate ? void 0 : signature.resolvedTypePredicate;
|
|
}
|
|
function createTypePredicateFromTypePredicateNode(node, signature) {
|
|
const parameterName = node.parameterName;
|
|
const type = node.type && getTypeFromTypeNode(node.type);
|
|
return parameterName.kind === 194 /* ThisType */ ? createTypePredicate(node.assertsModifier ? 2 /* AssertsThis */ : 0 /* This */, void 0, void 0, type) : createTypePredicate(
|
|
node.assertsModifier ? 3 /* AssertsIdentifier */ : 1 /* Identifier */,
|
|
parameterName.escapedText,
|
|
findIndex(signature.parameters, (p) => p.escapedName === parameterName.escapedText),
|
|
type
|
|
);
|
|
}
|
|
function getUnionOrIntersectionType(types, kind, unionReduction) {
|
|
return kind !== 2097152 /* Intersection */ ? getUnionType(types, unionReduction) : getIntersectionType(types);
|
|
}
|
|
function getReturnTypeOfSignature(signature) {
|
|
if (!signature.resolvedReturnType) {
|
|
if (!pushTypeResolution(signature, 3 /* ResolvedReturnType */)) {
|
|
return errorType;
|
|
}
|
|
let type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) : signature.compositeSignatures ? instantiateType(getUnionOrIntersectionType(map(signature.compositeSignatures, getReturnTypeOfSignature), signature.compositeKind, 2 /* Subtype */), signature.mapper) : getReturnTypeFromAnnotation(signature.declaration) || (nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration));
|
|
if (signature.flags & 8 /* IsInnerCallChain */) {
|
|
type = addOptionalTypeMarker(type);
|
|
} else if (signature.flags & 16 /* IsOuterCallChain */) {
|
|
type = getOptionalType(type);
|
|
}
|
|
if (!popTypeResolution()) {
|
|
if (signature.declaration) {
|
|
const typeNode = getEffectiveReturnTypeNode(signature.declaration);
|
|
if (typeNode) {
|
|
error(typeNode, Diagnostics.Return_type_annotation_circularly_references_itself);
|
|
} else if (noImplicitAny) {
|
|
const declaration = signature.declaration;
|
|
const name = getNameOfDeclaration(declaration);
|
|
if (name) {
|
|
error(name, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, declarationNameToString(name));
|
|
} else {
|
|
error(declaration, Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions);
|
|
}
|
|
}
|
|
}
|
|
type = anyType;
|
|
}
|
|
signature.resolvedReturnType = type;
|
|
}
|
|
return signature.resolvedReturnType;
|
|
}
|
|
function getReturnTypeFromAnnotation(declaration) {
|
|
if (declaration.kind === 173 /* Constructor */) {
|
|
return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol));
|
|
}
|
|
if (isJSDocConstructSignature(declaration)) {
|
|
return getTypeFromTypeNode(declaration.parameters[0].type);
|
|
}
|
|
const typeNode = getEffectiveReturnTypeNode(declaration);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
if (declaration.kind === 174 /* GetAccessor */ && hasBindableName(declaration)) {
|
|
const jsDocType = isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration);
|
|
if (jsDocType) {
|
|
return jsDocType;
|
|
}
|
|
const setter = getDeclarationOfKind(getSymbolOfNode(declaration), 175 /* SetAccessor */);
|
|
const setterType = getAnnotatedAccessorType(setter);
|
|
if (setterType) {
|
|
return setterType;
|
|
}
|
|
}
|
|
return getReturnTypeOfTypeTag(declaration);
|
|
}
|
|
function isResolvingReturnTypeOfSignature(signature) {
|
|
return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3 /* ResolvedReturnType */) >= 0;
|
|
}
|
|
function getRestTypeOfSignature(signature) {
|
|
return tryGetRestTypeOfSignature(signature) || anyType;
|
|
}
|
|
function tryGetRestTypeOfSignature(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
const restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType;
|
|
return restType && getIndexTypeOfType(restType, numberType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) {
|
|
const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript));
|
|
if (inferredTypeParameters) {
|
|
const returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature));
|
|
if (returnSignature) {
|
|
const newReturnSignature = cloneSignature(returnSignature);
|
|
newReturnSignature.typeParameters = inferredTypeParameters;
|
|
const newInstantiatedSignature = cloneSignature(instantiatedSignature);
|
|
newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature);
|
|
return newInstantiatedSignature;
|
|
}
|
|
}
|
|
return instantiatedSignature;
|
|
}
|
|
function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) {
|
|
const instantiations = signature.instantiations || (signature.instantiations = /* @__PURE__ */ new Map());
|
|
const id = getTypeListId(typeArguments);
|
|
let instantiation = instantiations.get(id);
|
|
if (!instantiation) {
|
|
instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments));
|
|
}
|
|
return instantiation;
|
|
}
|
|
function createSignatureInstantiation(signature, typeArguments) {
|
|
return instantiateSignature(signature, createSignatureTypeMapper(signature, typeArguments), true);
|
|
}
|
|
function createSignatureTypeMapper(signature, typeArguments) {
|
|
return createTypeMapper(signature.typeParameters, typeArguments);
|
|
}
|
|
function getErasedSignature(signature) {
|
|
return signature.typeParameters ? signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : signature;
|
|
}
|
|
function createErasedSignature(signature) {
|
|
return instantiateSignature(signature, createTypeEraser(signature.typeParameters), true);
|
|
}
|
|
function getCanonicalSignature(signature) {
|
|
return signature.typeParameters ? signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) : signature;
|
|
}
|
|
function createCanonicalSignature(signature) {
|
|
return getSignatureInstantiation(
|
|
signature,
|
|
map(signature.typeParameters, (tp) => tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp),
|
|
isInJSFile(signature.declaration)
|
|
);
|
|
}
|
|
function getBaseSignature(signature) {
|
|
const typeParameters = signature.typeParameters;
|
|
if (typeParameters) {
|
|
if (signature.baseSignatureCache) {
|
|
return signature.baseSignatureCache;
|
|
}
|
|
const typeEraser = createTypeEraser(typeParameters);
|
|
const baseConstraintMapper = createTypeMapper(typeParameters, map(typeParameters, (tp) => getConstraintOfTypeParameter(tp) || unknownType));
|
|
let baseConstraints = map(typeParameters, (tp) => instantiateType(tp, baseConstraintMapper) || unknownType);
|
|
for (let i = 0; i < typeParameters.length - 1; i++) {
|
|
baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper);
|
|
}
|
|
baseConstraints = instantiateTypes(baseConstraints, typeEraser);
|
|
return signature.baseSignatureCache = instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), true);
|
|
}
|
|
return signature;
|
|
}
|
|
function getOrCreateTypeFromSignature(signature) {
|
|
var _a2;
|
|
if (!signature.isolatedSignatureType) {
|
|
const kind = (_a2 = signature.declaration) == null ? void 0 : _a2.kind;
|
|
const isConstructor = kind === void 0 || kind === 173 /* Constructor */ || kind === 177 /* ConstructSignature */ || kind === 182 /* ConstructorType */;
|
|
const type = createObjectType(16 /* Anonymous */);
|
|
type.members = emptySymbols;
|
|
type.properties = emptyArray;
|
|
type.callSignatures = !isConstructor ? [signature] : emptyArray;
|
|
type.constructSignatures = isConstructor ? [signature] : emptyArray;
|
|
type.indexInfos = emptyArray;
|
|
signature.isolatedSignatureType = type;
|
|
}
|
|
return signature.isolatedSignatureType;
|
|
}
|
|
function getIndexSymbol(symbol) {
|
|
return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : void 0;
|
|
}
|
|
function getIndexSymbolFromSymbolTable(symbolTable) {
|
|
return symbolTable.get("__index" /* Index */);
|
|
}
|
|
function createIndexInfo(keyType, type, isReadonly, declaration) {
|
|
return { keyType, type, isReadonly, declaration };
|
|
}
|
|
function getIndexInfosOfSymbol(symbol) {
|
|
const indexSymbol = getIndexSymbol(symbol);
|
|
return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol) : emptyArray;
|
|
}
|
|
function getIndexInfosOfIndexSymbol(indexSymbol) {
|
|
if (indexSymbol.declarations) {
|
|
const indexInfos = [];
|
|
for (const declaration of indexSymbol.declarations) {
|
|
if (declaration.parameters.length === 1) {
|
|
const parameter = declaration.parameters[0];
|
|
if (parameter.type) {
|
|
forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
|
|
if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
|
|
indexInfos.push(createIndexInfo(
|
|
keyType,
|
|
declaration.type ? getTypeFromTypeNode(declaration.type) : anyType,
|
|
hasEffectiveModifier(declaration, 64 /* Readonly */),
|
|
declaration
|
|
));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return indexInfos;
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function isValidIndexKeyType(type) {
|
|
return !!(type.flags & (4 /* String */ | 8 /* Number */ | 4096 /* ESSymbol */)) || isPatternLiteralType(type) || !!(type.flags & 2097152 /* Intersection */) && !isGenericType(type) && some(type.types, isValidIndexKeyType);
|
|
}
|
|
function getConstraintDeclaration(type) {
|
|
return mapDefined(filter(type.symbol && type.symbol.declarations, isTypeParameterDeclaration), getEffectiveConstraintOfTypeParameter)[0];
|
|
}
|
|
function getInferredTypeParameterConstraint(typeParameter, omitTypeReferences) {
|
|
var _a2;
|
|
let inferences;
|
|
if ((_a2 = typeParameter.symbol) == null ? void 0 : _a2.declarations) {
|
|
for (const declaration of typeParameter.symbol.declarations) {
|
|
if (declaration.parent.kind === 192 /* InferType */) {
|
|
const [childTypeParameter = declaration.parent, grandParent] = walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent);
|
|
if (grandParent.kind === 180 /* TypeReference */ && !omitTypeReferences) {
|
|
const typeReference = grandParent;
|
|
const typeParameters = getTypeParametersForTypeReference(typeReference);
|
|
if (typeParameters) {
|
|
const index = typeReference.typeArguments.indexOf(childTypeParameter);
|
|
if (index < typeParameters.length) {
|
|
const declaredConstraint = getConstraintOfTypeParameter(typeParameters[index]);
|
|
if (declaredConstraint) {
|
|
const mapper = makeDeferredTypeMapper(typeParameters, typeParameters.map((_, index2) => () => {
|
|
return getEffectiveTypeArgumentAtIndex(typeReference, typeParameters, index2);
|
|
}));
|
|
const constraint = instantiateType(declaredConstraint, mapper);
|
|
if (constraint !== typeParameter) {
|
|
inferences = append(inferences, constraint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (grandParent.kind === 166 /* Parameter */ && grandParent.dotDotDotToken || grandParent.kind === 188 /* RestType */ || grandParent.kind === 199 /* NamedTupleMember */ && grandParent.dotDotDotToken) {
|
|
inferences = append(inferences, createArrayType(unknownType));
|
|
} else if (grandParent.kind === 201 /* TemplateLiteralTypeSpan */) {
|
|
inferences = append(inferences, stringType);
|
|
} else if (grandParent.kind === 165 /* TypeParameter */ && grandParent.parent.kind === 197 /* MappedType */) {
|
|
inferences = append(inferences, keyofConstraintType);
|
|
} else if (grandParent.kind === 197 /* MappedType */ && grandParent.type && skipParentheses(grandParent.type) === declaration.parent && grandParent.parent.kind === 191 /* ConditionalType */ && grandParent.parent.extendsType === grandParent && grandParent.parent.checkType.kind === 197 /* MappedType */ && grandParent.parent.checkType.type) {
|
|
const checkMappedType2 = grandParent.parent.checkType;
|
|
const nodeType = getTypeFromTypeNode(checkMappedType2.type);
|
|
inferences = append(inferences, instantiateType(
|
|
nodeType,
|
|
makeUnaryTypeMapper(getDeclaredTypeOfTypeParameter(getSymbolOfNode(checkMappedType2.typeParameter)), checkMappedType2.typeParameter.constraint ? getTypeFromTypeNode(checkMappedType2.typeParameter.constraint) : keyofConstraintType)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return inferences && getIntersectionType(inferences);
|
|
}
|
|
function getConstraintFromTypeParameter(typeParameter) {
|
|
if (!typeParameter.constraint) {
|
|
if (typeParameter.target) {
|
|
const targetConstraint = getConstraintOfTypeParameter(typeParameter.target);
|
|
typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType;
|
|
} else {
|
|
const constraintDeclaration = getConstraintDeclaration(typeParameter);
|
|
if (!constraintDeclaration) {
|
|
typeParameter.constraint = getInferredTypeParameterConstraint(typeParameter) || noConstraintType;
|
|
} else {
|
|
let type = getTypeFromTypeNode(constraintDeclaration);
|
|
if (type.flags & 1 /* Any */ && !isErrorType(type)) {
|
|
type = constraintDeclaration.parent.parent.kind === 197 /* MappedType */ ? keyofConstraintType : unknownType;
|
|
}
|
|
typeParameter.constraint = type;
|
|
}
|
|
}
|
|
}
|
|
return typeParameter.constraint === noConstraintType ? void 0 : typeParameter.constraint;
|
|
}
|
|
function getParentSymbolOfTypeParameter(typeParameter) {
|
|
const tp = getDeclarationOfKind(typeParameter.symbol, 165 /* TypeParameter */);
|
|
const host2 = isJSDocTemplateTag(tp.parent) ? getEffectiveContainerForJSDocTemplateTag(tp.parent) : tp.parent;
|
|
return host2 && getSymbolOfNode(host2);
|
|
}
|
|
function getTypeListId(types) {
|
|
let result = "";
|
|
if (types) {
|
|
const length2 = types.length;
|
|
let i = 0;
|
|
while (i < length2) {
|
|
const startId = types[i].id;
|
|
let count = 1;
|
|
while (i + count < length2 && types[i + count].id === startId + count) {
|
|
count++;
|
|
}
|
|
if (result.length) {
|
|
result += ",";
|
|
}
|
|
result += startId;
|
|
if (count > 1) {
|
|
result += ":" + count;
|
|
}
|
|
i += count;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getAliasId(aliasSymbol, aliasTypeArguments) {
|
|
return aliasSymbol ? `@${getSymbolId(aliasSymbol)}` + (aliasTypeArguments ? `:${getTypeListId(aliasTypeArguments)}` : "") : "";
|
|
}
|
|
function getPropagatingFlagsOfTypes(types, excludeKinds) {
|
|
let result = 0;
|
|
for (const type of types) {
|
|
if (excludeKinds === void 0 || !(type.flags & excludeKinds)) {
|
|
result |= getObjectFlags(type);
|
|
}
|
|
}
|
|
return result & 458752 /* PropagatingFlags */;
|
|
}
|
|
function createTypeReference(target, typeArguments) {
|
|
const id = getTypeListId(typeArguments);
|
|
let type = target.instantiations.get(id);
|
|
if (!type) {
|
|
type = createObjectType(4 /* Reference */, target.symbol);
|
|
target.instantiations.set(id, type);
|
|
type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0;
|
|
type.target = target;
|
|
type.resolvedTypeArguments = typeArguments;
|
|
}
|
|
return type;
|
|
}
|
|
function cloneTypeReference(source) {
|
|
const type = createTypeWithSymbol(source.flags, source.symbol);
|
|
type.objectFlags = source.objectFlags;
|
|
type.target = source.target;
|
|
type.resolvedTypeArguments = source.resolvedTypeArguments;
|
|
return type;
|
|
}
|
|
function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments) {
|
|
if (!aliasSymbol) {
|
|
aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
const localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
aliasTypeArguments = mapper ? instantiateTypes(localAliasTypeArguments, mapper) : localAliasTypeArguments;
|
|
}
|
|
const type = createObjectType(4 /* Reference */, target.symbol);
|
|
type.target = target;
|
|
type.node = node;
|
|
type.mapper = mapper;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
return type;
|
|
}
|
|
function getTypeArguments(type) {
|
|
var _a2, _b;
|
|
if (!type.resolvedTypeArguments) {
|
|
if (!pushTypeResolution(type, 6 /* ResolvedTypeArguments */)) {
|
|
return ((_a2 = type.target.localTypeParameters) == null ? void 0 : _a2.map(() => errorType)) || emptyArray;
|
|
}
|
|
const node = type.node;
|
|
const typeArguments = !node ? emptyArray : node.kind === 180 /* TypeReference */ ? concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments2(node, type.target.localTypeParameters)) : node.kind === 185 /* ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode);
|
|
if (popTypeResolution()) {
|
|
type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments;
|
|
} else {
|
|
type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) == null ? void 0 : _b.map(() => errorType)) || emptyArray;
|
|
error(
|
|
type.node || currentNode,
|
|
type.target.symbol ? Diagnostics.Type_arguments_for_0_circularly_reference_themselves : Diagnostics.Tuple_type_arguments_circularly_reference_themselves,
|
|
type.target.symbol && symbolToString(type.target.symbol)
|
|
);
|
|
}
|
|
}
|
|
return type.resolvedTypeArguments;
|
|
}
|
|
function getTypeReferenceArity(type) {
|
|
return length(type.target.typeParameters);
|
|
}
|
|
function getTypeFromClassOrInterfaceReference(node, symbol) {
|
|
const type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
|
|
const typeParameters = type.localTypeParameters;
|
|
if (typeParameters) {
|
|
const numTypeArguments = length(node.typeArguments);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
|
|
const isJs = isInJSFile(node);
|
|
const isJsImplicitAny = !noImplicitAny && isJs;
|
|
if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
|
|
const missingAugmentsTag = isJs && isExpressionWithTypeArguments(node) && !isJSDocAugmentsTag(node.parent);
|
|
const diag2 = minTypeArgumentCount === typeParameters.length ? missingAugmentsTag ? Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag : Diagnostics.Generic_type_0_requires_1_type_argument_s : missingAugmentsTag ? Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
|
|
const typeStr = typeToString(type, void 0, 2 /* WriteArrayAsGenericType */);
|
|
error(node, diag2, typeStr, minTypeArgumentCount, typeParameters.length);
|
|
if (!isJs) {
|
|
return errorType;
|
|
}
|
|
}
|
|
if (node.kind === 180 /* TypeReference */ && isDeferredTypeReferenceNode(node, length(node.typeArguments) !== typeParameters.length)) {
|
|
return createDeferredTypeReference(type, node, void 0);
|
|
}
|
|
const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs));
|
|
return createTypeReference(type, typeArguments);
|
|
}
|
|
return checkNoTypeArguments(node, symbol) ? type : errorType;
|
|
}
|
|
function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
|
|
return getStringMappingType(symbol, typeArguments[0]);
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
const typeParameters = links.typeParameters;
|
|
const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let instantiation = links.instantiations.get(id);
|
|
if (!instantiation) {
|
|
links.instantiations.set(id, instantiation = instantiateTypeWithAlias(
|
|
type,
|
|
createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(symbol.valueDeclaration))),
|
|
aliasSymbol,
|
|
aliasTypeArguments
|
|
));
|
|
}
|
|
return instantiation;
|
|
}
|
|
function getTypeFromTypeAliasReference(node, symbol) {
|
|
if (getCheckFlags(symbol) & 1048576 /* Unresolved */) {
|
|
const typeArguments = typeArgumentsFromTypeReferenceNode(node);
|
|
const id = getAliasId(symbol, typeArguments);
|
|
let errorType2 = errorTypes.get(id);
|
|
if (!errorType2) {
|
|
errorType2 = createIntrinsicType(1 /* Any */, "error");
|
|
errorType2.aliasSymbol = symbol;
|
|
errorType2.aliasTypeArguments = typeArguments;
|
|
errorTypes.set(id, errorType2);
|
|
}
|
|
return errorType2;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeParameters = getSymbolLinks(symbol).typeParameters;
|
|
if (typeParameters) {
|
|
const numTypeArguments = length(node.typeArguments);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
|
|
if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
|
|
error(
|
|
node,
|
|
minTypeArgumentCount === typeParameters.length ? Diagnostics.Generic_type_0_requires_1_type_argument_s : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments,
|
|
symbolToString(symbol),
|
|
minTypeArgumentCount,
|
|
typeParameters.length
|
|
);
|
|
return errorType;
|
|
}
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
let newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : void 0;
|
|
let aliasTypeArguments;
|
|
if (newAliasSymbol) {
|
|
aliasTypeArguments = getTypeArgumentsForAliasSymbol(newAliasSymbol);
|
|
} else if (isTypeReferenceType(node)) {
|
|
const aliasSymbol2 = resolveTypeReferenceName(node, 2097152 /* Alias */, true);
|
|
if (aliasSymbol2 && aliasSymbol2 !== unknownSymbol) {
|
|
const resolved = resolveAlias(aliasSymbol2);
|
|
if (resolved && resolved.flags & 524288 /* TypeAlias */) {
|
|
newAliasSymbol = resolved;
|
|
aliasTypeArguments = typeArgumentsFromTypeReferenceNode(node);
|
|
}
|
|
}
|
|
}
|
|
return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, aliasTypeArguments);
|
|
}
|
|
return checkNoTypeArguments(node, symbol) ? type : errorType;
|
|
}
|
|
function isLocalTypeAlias(symbol) {
|
|
var _a2;
|
|
const declaration = (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isTypeAlias);
|
|
return !!(declaration && getContainingFunction(declaration));
|
|
}
|
|
function getTypeReferenceName(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
const expr = node.expression;
|
|
if (isEntityNameExpression(expr)) {
|
|
return expr;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSymbolPath(symbol) {
|
|
return symbol.parent ? `${getSymbolPath(symbol.parent)}.${symbol.escapedName}` : symbol.escapedName;
|
|
}
|
|
function getUnresolvedSymbolForEntityName(name) {
|
|
const identifier = name.kind === 163 /* QualifiedName */ ? name.right : name.kind === 208 /* PropertyAccessExpression */ ? name.name : name;
|
|
const text = identifier.escapedText;
|
|
if (text) {
|
|
const parentSymbol = name.kind === 163 /* QualifiedName */ ? getUnresolvedSymbolForEntityName(name.left) : name.kind === 208 /* PropertyAccessExpression */ ? getUnresolvedSymbolForEntityName(name.expression) : void 0;
|
|
const path = parentSymbol ? `${getSymbolPath(parentSymbol)}.${text}` : text;
|
|
let result = unresolvedSymbols.get(path);
|
|
if (!result) {
|
|
unresolvedSymbols.set(path, result = createSymbol(524288 /* TypeAlias */, text, 1048576 /* Unresolved */));
|
|
result.parent = parentSymbol;
|
|
result.declaredType = unresolvedType;
|
|
}
|
|
return result;
|
|
}
|
|
return unknownSymbol;
|
|
}
|
|
function resolveTypeReferenceName(typeReference, meaning, ignoreErrors) {
|
|
const name = getTypeReferenceName(typeReference);
|
|
if (!name) {
|
|
return unknownSymbol;
|
|
}
|
|
const symbol = resolveEntityName(name, meaning, ignoreErrors);
|
|
return symbol && symbol !== unknownSymbol ? symbol : ignoreErrors ? unknownSymbol : getUnresolvedSymbolForEntityName(name);
|
|
}
|
|
function getTypeReferenceType(node, symbol) {
|
|
if (symbol === unknownSymbol) {
|
|
return errorType;
|
|
}
|
|
symbol = getExpandoSymbol(symbol) || symbol;
|
|
if (symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
|
|
return getTypeFromClassOrInterfaceReference(node, symbol);
|
|
}
|
|
if (symbol.flags & 524288 /* TypeAlias */) {
|
|
return getTypeFromTypeAliasReference(node, symbol);
|
|
}
|
|
const res = tryGetDeclaredTypeOfSymbol(symbol);
|
|
if (res) {
|
|
return checkNoTypeArguments(node, symbol) ? getRegularTypeOfLiteralType(res) : errorType;
|
|
}
|
|
if (symbol.flags & 111551 /* Value */ && isJSDocTypeReference(node)) {
|
|
const jsdocType = getTypeFromJSDocValueReference(node, symbol);
|
|
if (jsdocType) {
|
|
return jsdocType;
|
|
} else {
|
|
resolveTypeReferenceName(node, 788968 /* Type */);
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
return errorType;
|
|
}
|
|
function getTypeFromJSDocValueReference(node, symbol) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedJSDocType) {
|
|
const valueType = getTypeOfSymbol(symbol);
|
|
let typeType = valueType;
|
|
if (symbol.valueDeclaration) {
|
|
const isImportTypeWithQualifier = node.kind === 202 /* ImportType */ && node.qualifier;
|
|
if (valueType.symbol && valueType.symbol !== symbol && isImportTypeWithQualifier) {
|
|
typeType = getTypeReferenceType(node, valueType.symbol);
|
|
}
|
|
}
|
|
links.resolvedJSDocType = typeType;
|
|
}
|
|
return links.resolvedJSDocType;
|
|
}
|
|
function getSubstitutionType(baseType, constraint) {
|
|
if (constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || !isGenericType(baseType) && !isGenericType(constraint)) {
|
|
return baseType;
|
|
}
|
|
const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
|
|
const cached = substitutionTypes.get(id);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
const result = createType(33554432 /* Substitution */);
|
|
result.baseType = baseType;
|
|
result.constraint = constraint;
|
|
substitutionTypes.set(id, result);
|
|
return result;
|
|
}
|
|
function getSubstitutionIntersection(substitutionType) {
|
|
return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
|
|
}
|
|
function isUnaryTupleTypeNode(node) {
|
|
return node.kind === 186 /* TupleType */ && node.elements.length === 1;
|
|
}
|
|
function getImpliedConstraint(type, checkNode, extendsNode) {
|
|
return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, checkNode.elements[0], extendsNode.elements[0]) : getActualTypeVariable(getTypeFromTypeNode(checkNode)) === getActualTypeVariable(type) ? getTypeFromTypeNode(extendsNode) : void 0;
|
|
}
|
|
function getConditionalFlowTypeOfType(type, node) {
|
|
let constraints;
|
|
let covariant = true;
|
|
while (node && !isStatement(node) && node.kind !== 323 /* JSDoc */) {
|
|
const parent2 = node.parent;
|
|
if (parent2.kind === 166 /* Parameter */) {
|
|
covariant = !covariant;
|
|
}
|
|
if ((covariant || type.flags & 8650752 /* TypeVariable */) && parent2.kind === 191 /* ConditionalType */ && node === parent2.trueType) {
|
|
const constraint = getImpliedConstraint(type, parent2.checkType, parent2.extendsType);
|
|
if (constraint) {
|
|
constraints = append(constraints, constraint);
|
|
}
|
|
} else if (type.flags & 262144 /* TypeParameter */ && parent2.kind === 197 /* MappedType */ && node === parent2.type) {
|
|
const mappedType = getTypeFromTypeNode(parent2);
|
|
if (getTypeParameterFromMappedType(mappedType) === getActualTypeVariable(type)) {
|
|
const typeParameter = getHomomorphicTypeVariable(mappedType);
|
|
if (typeParameter) {
|
|
const constraint = getConstraintOfTypeParameter(typeParameter);
|
|
if (constraint && everyType(constraint, isArrayOrTupleType)) {
|
|
constraints = append(constraints, getUnionType([numberType, numericStringType]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
node = parent2;
|
|
}
|
|
return constraints ? getSubstitutionType(type, getIntersectionType(constraints)) : type;
|
|
}
|
|
function isJSDocTypeReference(node) {
|
|
return !!(node.flags & 8388608 /* JSDoc */) && (node.kind === 180 /* TypeReference */ || node.kind === 202 /* ImportType */);
|
|
}
|
|
function checkNoTypeArguments(node, symbol) {
|
|
if (node.typeArguments) {
|
|
error(node, Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? declarationNameToString(node.typeName) : anon);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getIntendedTypeFromJSDocTypeReference(node) {
|
|
if (isIdentifier(node.typeName)) {
|
|
const typeArgs = node.typeArguments;
|
|
switch (node.typeName.escapedText) {
|
|
case "String":
|
|
checkNoTypeArguments(node);
|
|
return stringType;
|
|
case "Number":
|
|
checkNoTypeArguments(node);
|
|
return numberType;
|
|
case "Boolean":
|
|
checkNoTypeArguments(node);
|
|
return booleanType;
|
|
case "Void":
|
|
checkNoTypeArguments(node);
|
|
return voidType;
|
|
case "Undefined":
|
|
checkNoTypeArguments(node);
|
|
return undefinedType;
|
|
case "Null":
|
|
checkNoTypeArguments(node);
|
|
return nullType;
|
|
case "Function":
|
|
case "function":
|
|
checkNoTypeArguments(node);
|
|
return globalFunctionType;
|
|
case "array":
|
|
return (!typeArgs || !typeArgs.length) && !noImplicitAny ? anyArrayType : void 0;
|
|
case "promise":
|
|
return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : void 0;
|
|
case "Object":
|
|
if (typeArgs && typeArgs.length === 2) {
|
|
if (isJSDocIndexSignature(node)) {
|
|
const indexed = getTypeFromTypeNode(typeArgs[0]);
|
|
const target = getTypeFromTypeNode(typeArgs[1]);
|
|
const indexInfo = indexed === stringType || indexed === numberType ? [createIndexInfo(indexed, target, false)] : emptyArray;
|
|
return createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, indexInfo);
|
|
}
|
|
return anyType;
|
|
}
|
|
checkNoTypeArguments(node);
|
|
return !noImplicitAny ? anyType : void 0;
|
|
}
|
|
}
|
|
}
|
|
function getTypeFromJSDocNullableTypeNode(node) {
|
|
const type = getTypeFromTypeNode(node.type);
|
|
return strictNullChecks ? getNullableType(type, 65536 /* Null */) : type;
|
|
}
|
|
function getTypeFromTypeReference(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
if (isConstTypeReference(node) && isAssertionExpression(node.parent)) {
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = checkExpressionCached(node.parent.expression);
|
|
}
|
|
let symbol;
|
|
let type;
|
|
const meaning = 788968 /* Type */;
|
|
if (isJSDocTypeReference(node)) {
|
|
type = getIntendedTypeFromJSDocTypeReference(node);
|
|
if (!type) {
|
|
symbol = resolveTypeReferenceName(node, meaning, true);
|
|
if (symbol === unknownSymbol) {
|
|
symbol = resolveTypeReferenceName(node, meaning | 111551 /* Value */);
|
|
} else {
|
|
resolveTypeReferenceName(node, meaning);
|
|
}
|
|
type = getTypeReferenceType(node, symbol);
|
|
}
|
|
}
|
|
if (!type) {
|
|
symbol = resolveTypeReferenceName(node, meaning);
|
|
type = getTypeReferenceType(node, symbol);
|
|
}
|
|
links.resolvedSymbol = symbol;
|
|
links.resolvedType = type;
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function typeArgumentsFromTypeReferenceNode(node) {
|
|
return map(node.typeArguments, getTypeFromTypeNode);
|
|
}
|
|
function getTypeFromTypeQueryNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const type = checkExpressionWithTypeArguments(node);
|
|
links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeOfGlobalSymbol(symbol, arity) {
|
|
function getTypeDeclaration(symbol2) {
|
|
const declarations = symbol2.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
switch (declaration.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!symbol) {
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (!(type.flags & 524288 /* Object */)) {
|
|
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_be_a_class_or_interface_type, symbolName(symbol));
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
if (length(type.typeParameters) !== arity) {
|
|
error(getTypeDeclaration(symbol), Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbolName(symbol), arity);
|
|
return arity ? emptyGenericType : emptyObjectType;
|
|
}
|
|
return type;
|
|
}
|
|
function getGlobalValueSymbol(name, reportErrors2) {
|
|
return getGlobalSymbol(name, 111551 /* Value */, reportErrors2 ? Diagnostics.Cannot_find_global_value_0 : void 0);
|
|
}
|
|
function getGlobalTypeSymbol(name, reportErrors2) {
|
|
return getGlobalSymbol(name, 788968 /* Type */, reportErrors2 ? Diagnostics.Cannot_find_global_type_0 : void 0);
|
|
}
|
|
function getGlobalTypeAliasSymbol(name, arity, reportErrors2) {
|
|
const symbol = getGlobalSymbol(name, 788968 /* Type */, reportErrors2 ? Diagnostics.Cannot_find_global_type_0 : void 0);
|
|
if (symbol) {
|
|
getDeclaredTypeOfSymbol(symbol);
|
|
if (length(getSymbolLinks(symbol).typeParameters) !== arity) {
|
|
const decl = symbol.declarations && find(symbol.declarations, isTypeAliasDeclaration);
|
|
error(decl, Diagnostics.Global_type_0_must_have_1_type_parameter_s, symbolName(symbol), arity);
|
|
return void 0;
|
|
}
|
|
}
|
|
return symbol;
|
|
}
|
|
function getGlobalSymbol(name, meaning, diagnostic) {
|
|
return resolveName(void 0, name, meaning, diagnostic, name, false, false, false);
|
|
}
|
|
function getGlobalType(name, arity, reportErrors2) {
|
|
const symbol = getGlobalTypeSymbol(name, reportErrors2);
|
|
return symbol || reportErrors2 ? getTypeOfGlobalSymbol(symbol, arity) : void 0;
|
|
}
|
|
function getGlobalTypedPropertyDescriptorType() {
|
|
return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType("TypedPropertyDescriptor", 1, true) || emptyGenericType);
|
|
}
|
|
function getGlobalTemplateStringsArrayType() {
|
|
return deferredGlobalTemplateStringsArrayType || (deferredGlobalTemplateStringsArrayType = getGlobalType("TemplateStringsArray", 0, true) || emptyObjectType);
|
|
}
|
|
function getGlobalImportMetaType() {
|
|
return deferredGlobalImportMetaType || (deferredGlobalImportMetaType = getGlobalType("ImportMeta", 0, true) || emptyObjectType);
|
|
}
|
|
function getGlobalImportMetaExpressionType() {
|
|
if (!deferredGlobalImportMetaExpressionType) {
|
|
const symbol = createSymbol(0 /* None */, "ImportMetaExpression");
|
|
const importMetaType = getGlobalImportMetaType();
|
|
const metaPropertySymbol = createSymbol(4 /* Property */, "meta", 8 /* Readonly */);
|
|
metaPropertySymbol.parent = symbol;
|
|
metaPropertySymbol.type = importMetaType;
|
|
const members = createSymbolTable([metaPropertySymbol]);
|
|
symbol.members = members;
|
|
deferredGlobalImportMetaExpressionType = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
return deferredGlobalImportMetaExpressionType;
|
|
}
|
|
function getGlobalImportCallOptionsType(reportErrors2) {
|
|
return deferredGlobalImportCallOptionsType || (deferredGlobalImportCallOptionsType = getGlobalType("ImportCallOptions", 0, reportErrors2)) || emptyObjectType;
|
|
}
|
|
function getGlobalESSymbolConstructorSymbol(reportErrors2) {
|
|
return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors2));
|
|
}
|
|
function getGlobalESSymbolConstructorTypeSymbol(reportErrors2) {
|
|
return deferredGlobalESSymbolConstructorTypeSymbol || (deferredGlobalESSymbolConstructorTypeSymbol = getGlobalTypeSymbol("SymbolConstructor", reportErrors2));
|
|
}
|
|
function getGlobalESSymbolType() {
|
|
return deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", 0, false)) || emptyObjectType;
|
|
}
|
|
function getGlobalPromiseType(reportErrors2) {
|
|
return deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalPromiseLikeType(reportErrors2) {
|
|
return deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalPromiseConstructorSymbol(reportErrors2) {
|
|
return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors2));
|
|
}
|
|
function getGlobalPromiseConstructorLikeType(reportErrors2) {
|
|
return deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", 0, reportErrors2)) || emptyObjectType;
|
|
}
|
|
function getGlobalAsyncIterableType(reportErrors2) {
|
|
return deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncIteratorType(reportErrors2) {
|
|
return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncIterableIteratorType(reportErrors2) {
|
|
return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalAsyncGeneratorType(reportErrors2) {
|
|
return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIterableType(reportErrors2) {
|
|
return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorType(reportErrors2) {
|
|
return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIterableIteratorType(reportErrors2) {
|
|
return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalGeneratorType(reportErrors2) {
|
|
return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", 3, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorYieldResultType(reportErrors2) {
|
|
return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalIteratorReturnResultType(reportErrors2) {
|
|
return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", 1, reportErrors2)) || emptyGenericType;
|
|
}
|
|
function getGlobalTypeOrUndefined(name, arity = 0) {
|
|
const symbol = getGlobalSymbol(name, 788968 /* Type */, void 0);
|
|
return symbol && getTypeOfGlobalSymbol(symbol, arity);
|
|
}
|
|
function getGlobalExtractSymbol() {
|
|
deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalTypeAliasSymbol("Extract", 2, true) || unknownSymbol);
|
|
return deferredGlobalExtractSymbol === unknownSymbol ? void 0 : deferredGlobalExtractSymbol;
|
|
}
|
|
function getGlobalOmitSymbol() {
|
|
deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalTypeAliasSymbol("Omit", 2, true) || unknownSymbol);
|
|
return deferredGlobalOmitSymbol === unknownSymbol ? void 0 : deferredGlobalOmitSymbol;
|
|
}
|
|
function getGlobalAwaitedSymbol(reportErrors2) {
|
|
deferredGlobalAwaitedSymbol || (deferredGlobalAwaitedSymbol = getGlobalTypeAliasSymbol("Awaited", 1, reportErrors2) || (reportErrors2 ? unknownSymbol : void 0));
|
|
return deferredGlobalAwaitedSymbol === unknownSymbol ? void 0 : deferredGlobalAwaitedSymbol;
|
|
}
|
|
function getGlobalBigIntType() {
|
|
return deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", 0, false)) || emptyObjectType;
|
|
}
|
|
function getGlobalNaNSymbol() {
|
|
return deferredGlobalNaNSymbol || (deferredGlobalNaNSymbol = getGlobalValueSymbol("NaN", false));
|
|
}
|
|
function getGlobalRecordSymbol() {
|
|
deferredGlobalRecordSymbol || (deferredGlobalRecordSymbol = getGlobalTypeAliasSymbol("Record", 2, true) || unknownSymbol);
|
|
return deferredGlobalRecordSymbol === unknownSymbol ? void 0 : deferredGlobalRecordSymbol;
|
|
}
|
|
function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) {
|
|
return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType;
|
|
}
|
|
function createTypedPropertyDescriptorType(propertyType) {
|
|
return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]);
|
|
}
|
|
function createIterableType(iteratedType) {
|
|
return createTypeFromGenericGlobalType(getGlobalIterableType(true), [iteratedType]);
|
|
}
|
|
function createArrayType(elementType, readonly) {
|
|
return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]);
|
|
}
|
|
function getTupleElementFlags(node) {
|
|
switch (node.kind) {
|
|
case 187 /* OptionalType */:
|
|
return 2 /* Optional */;
|
|
case 188 /* RestType */:
|
|
return getRestTypeElementFlags(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return node.questionToken ? 2 /* Optional */ : node.dotDotDotToken ? getRestTypeElementFlags(node) : 1 /* Required */;
|
|
default:
|
|
return 1 /* Required */;
|
|
}
|
|
}
|
|
function getRestTypeElementFlags(node) {
|
|
return getArrayElementTypeNode(node.type) ? 4 /* Rest */ : 8 /* Variadic */;
|
|
}
|
|
function getArrayOrTupleTargetType(node) {
|
|
const readonly = isReadonlyTypeOperator(node.parent);
|
|
const elementType = getArrayElementTypeNode(node);
|
|
if (elementType) {
|
|
return readonly ? globalReadonlyArrayType : globalArrayType;
|
|
}
|
|
const elementFlags = map(node.elements, getTupleElementFlags);
|
|
const missingName = some(node.elements, (e) => e.kind !== 199 /* NamedTupleMember */);
|
|
return getTupleTargetType(elementFlags, readonly, missingName ? void 0 : node.elements);
|
|
}
|
|
function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) {
|
|
return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 185 /* ArrayType */ ? mayResolveTypeAlias(node.elementType) : node.kind === 186 /* TupleType */ ? some(node.elements, mayResolveTypeAlias) : hasDefaultTypeArguments || some(node.typeArguments, mayResolveTypeAlias));
|
|
}
|
|
function isResolvedByTypeAlias(node) {
|
|
const parent2 = node.parent;
|
|
switch (parent2.kind) {
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
case 180 /* TypeReference */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 191 /* ConditionalType */:
|
|
case 195 /* TypeOperator */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return isResolvedByTypeAlias(parent2);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function mayResolveTypeAlias(node) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node, 788968 /* Type */).flags & 524288 /* TypeAlias */);
|
|
case 183 /* TypeQuery */:
|
|
return true;
|
|
case 195 /* TypeOperator */:
|
|
return node.operator !== 156 /* UniqueKeyword */ && mayResolveTypeAlias(node.type);
|
|
case 193 /* ParenthesizedType */:
|
|
case 187 /* OptionalType */:
|
|
case 199 /* NamedTupleMember */:
|
|
case 319 /* JSDocOptionalType */:
|
|
case 317 /* JSDocNullableType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 312 /* JSDocTypeExpression */:
|
|
return mayResolveTypeAlias(node.type);
|
|
case 188 /* RestType */:
|
|
return node.type.kind !== 185 /* ArrayType */ || mayResolveTypeAlias(node.type.elementType);
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return some(node.types, mayResolveTypeAlias);
|
|
case 196 /* IndexedAccessType */:
|
|
return mayResolveTypeAlias(node.objectType) || mayResolveTypeAlias(node.indexType);
|
|
case 191 /* ConditionalType */:
|
|
return mayResolveTypeAlias(node.checkType) || mayResolveTypeAlias(node.extendsType) || mayResolveTypeAlias(node.trueType) || mayResolveTypeAlias(node.falseType);
|
|
}
|
|
return false;
|
|
}
|
|
function getTypeFromArrayOrTupleTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const target = getArrayOrTupleTargetType(node);
|
|
if (target === emptyGenericType) {
|
|
links.resolvedType = emptyObjectType;
|
|
} else if (!(node.kind === 186 /* TupleType */ && some(node.elements, (e) => !!(getTupleElementFlags(e) & 8 /* Variadic */))) && isDeferredTypeReferenceNode(node)) {
|
|
links.resolvedType = node.kind === 186 /* TupleType */ && node.elements.length === 0 ? target : createDeferredTypeReference(target, node, void 0);
|
|
} else {
|
|
const elementTypes = node.kind === 185 /* ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : map(node.elements, getTypeFromTypeNode);
|
|
links.resolvedType = createNormalizedTypeReference(target, elementTypes);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isReadonlyTypeOperator(node) {
|
|
return isTypeOperatorNode(node) && node.operator === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function createTupleType(elementTypes, elementFlags, readonly = false, namedMemberDeclarations) {
|
|
const tupleTarget = getTupleTargetType(elementFlags || map(elementTypes, (_) => 1 /* Required */), readonly, namedMemberDeclarations);
|
|
return tupleTarget === emptyGenericType ? emptyObjectType : elementTypes.length ? createNormalizedTypeReference(tupleTarget, elementTypes) : tupleTarget;
|
|
}
|
|
function getTupleTargetType(elementFlags, readonly, namedMemberDeclarations) {
|
|
if (elementFlags.length === 1 && elementFlags[0] & 4 /* Rest */) {
|
|
return readonly ? globalReadonlyArrayType : globalArrayType;
|
|
}
|
|
const key = map(elementFlags, (f) => f & 1 /* Required */ ? "#" : f & 2 /* Optional */ ? "?" : f & 4 /* Rest */ ? "." : "*").join() + (readonly ? "R" : "") + (namedMemberDeclarations && namedMemberDeclarations.length ? "," + map(namedMemberDeclarations, getNodeId).join(",") : "");
|
|
let type = tupleTypes.get(key);
|
|
if (!type) {
|
|
tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations));
|
|
}
|
|
return type;
|
|
}
|
|
function createTupleTargetType(elementFlags, readonly, namedMemberDeclarations) {
|
|
const arity = elementFlags.length;
|
|
const minLength = countWhere(elementFlags, (f) => !!(f & (1 /* Required */ | 8 /* Variadic */)));
|
|
let typeParameters;
|
|
const properties = [];
|
|
let combinedFlags = 0;
|
|
if (arity) {
|
|
typeParameters = new Array(arity);
|
|
for (let i = 0; i < arity; i++) {
|
|
const typeParameter = typeParameters[i] = createTypeParameter();
|
|
const flags = elementFlags[i];
|
|
combinedFlags |= flags;
|
|
if (!(combinedFlags & 12 /* Variable */)) {
|
|
const property = createSymbol(
|
|
4 /* Property */ | (flags & 2 /* Optional */ ? 16777216 /* Optional */ : 0),
|
|
"" + i,
|
|
readonly ? 8 /* Readonly */ : 0
|
|
);
|
|
property.tupleLabelDeclaration = namedMemberDeclarations == null ? void 0 : namedMemberDeclarations[i];
|
|
property.type = typeParameter;
|
|
properties.push(property);
|
|
}
|
|
}
|
|
}
|
|
const fixedLength = properties.length;
|
|
const lengthSymbol = createSymbol(4 /* Property */, "length", readonly ? 8 /* Readonly */ : 0);
|
|
if (combinedFlags & 12 /* Variable */) {
|
|
lengthSymbol.type = numberType;
|
|
} else {
|
|
const literalTypes = [];
|
|
for (let i = minLength; i <= arity; i++)
|
|
literalTypes.push(getNumberLiteralType(i));
|
|
lengthSymbol.type = getUnionType(literalTypes);
|
|
}
|
|
properties.push(lengthSymbol);
|
|
const type = createObjectType(8 /* Tuple */ | 4 /* Reference */);
|
|
type.typeParameters = typeParameters;
|
|
type.outerTypeParameters = void 0;
|
|
type.localTypeParameters = typeParameters;
|
|
type.instantiations = /* @__PURE__ */ new Map();
|
|
type.instantiations.set(getTypeListId(type.typeParameters), type);
|
|
type.target = type;
|
|
type.resolvedTypeArguments = type.typeParameters;
|
|
type.thisType = createTypeParameter();
|
|
type.thisType.isThisType = true;
|
|
type.thisType.constraint = type;
|
|
type.declaredProperties = properties;
|
|
type.declaredCallSignatures = emptyArray;
|
|
type.declaredConstructSignatures = emptyArray;
|
|
type.declaredIndexInfos = emptyArray;
|
|
type.elementFlags = elementFlags;
|
|
type.minLength = minLength;
|
|
type.fixedLength = fixedLength;
|
|
type.hasRestElement = !!(combinedFlags & 12 /* Variable */);
|
|
type.combinedFlags = combinedFlags;
|
|
type.readonly = readonly;
|
|
type.labeledElementDeclarations = namedMemberDeclarations;
|
|
return type;
|
|
}
|
|
function createNormalizedTypeReference(target, typeArguments) {
|
|
return target.objectFlags & 8 /* Tuple */ ? createNormalizedTupleType(target, typeArguments) : createTypeReference(target, typeArguments);
|
|
}
|
|
function createNormalizedTupleType(target, elementTypes) {
|
|
var _a2, _b, _c;
|
|
if (!(target.combinedFlags & 14 /* NonRequired */)) {
|
|
return createTypeReference(target, elementTypes);
|
|
}
|
|
if (target.combinedFlags & 8 /* Variadic */) {
|
|
const unionIndex = findIndex(elementTypes, (t, i) => !!(target.elementFlags[i] & 8 /* Variadic */ && t.flags & (131072 /* Never */ | 1048576 /* Union */)));
|
|
if (unionIndex >= 0) {
|
|
return checkCrossProductUnion(map(elementTypes, (t, i) => target.elementFlags[i] & 8 /* Variadic */ ? t : unknownType)) ? mapType(elementTypes[unionIndex], (t) => createNormalizedTupleType(target, replaceElement(elementTypes, unionIndex, t))) : errorType;
|
|
}
|
|
}
|
|
const expandedTypes = [];
|
|
const expandedFlags = [];
|
|
let expandedDeclarations = [];
|
|
let lastRequiredIndex = -1;
|
|
let firstRestIndex = -1;
|
|
let lastOptionalOrRestIndex = -1;
|
|
for (let i = 0; i < elementTypes.length; i++) {
|
|
const type = elementTypes[i];
|
|
const flags = target.elementFlags[i];
|
|
if (flags & 8 /* Variadic */) {
|
|
if (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type)) {
|
|
addElement(type, 8 /* Variadic */, (_a2 = target.labeledElementDeclarations) == null ? void 0 : _a2[i]);
|
|
} else if (isTupleType(type)) {
|
|
const elements = getTypeArguments(type);
|
|
if (elements.length + expandedTypes.length >= 1e4) {
|
|
error(currentNode, isPartOfTypeNode(currentNode) ? Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent : Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent);
|
|
return errorType;
|
|
}
|
|
forEach(elements, (t, n) => {
|
|
var _a3;
|
|
return addElement(t, type.target.elementFlags[n], (_a3 = type.target.labeledElementDeclarations) == null ? void 0 : _a3[n]);
|
|
});
|
|
} else {
|
|
addElement(isArrayLikeType(type) && getIndexTypeOfType(type, numberType) || errorType, 4 /* Rest */, (_b = target.labeledElementDeclarations) == null ? void 0 : _b[i]);
|
|
}
|
|
} else {
|
|
addElement(type, flags, (_c = target.labeledElementDeclarations) == null ? void 0 : _c[i]);
|
|
}
|
|
}
|
|
for (let i = 0; i < lastRequiredIndex; i++) {
|
|
if (expandedFlags[i] & 2 /* Optional */)
|
|
expandedFlags[i] = 1 /* Required */;
|
|
}
|
|
if (firstRestIndex >= 0 && firstRestIndex < lastOptionalOrRestIndex) {
|
|
expandedTypes[firstRestIndex] = getUnionType(sameMap(
|
|
expandedTypes.slice(firstRestIndex, lastOptionalOrRestIndex + 1),
|
|
(t, i) => expandedFlags[firstRestIndex + i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t
|
|
));
|
|
expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
expandedDeclarations == null ? void 0 : expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex);
|
|
}
|
|
const tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations);
|
|
return tupleTarget === emptyGenericType ? emptyObjectType : expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) : tupleTarget;
|
|
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(flags & 2 /* Optional */ ? addOptionality(type, true) : type);
|
|
expandedFlags.push(flags);
|
|
if (expandedDeclarations && declaration) {
|
|
expandedDeclarations.push(declaration);
|
|
} else {
|
|
expandedDeclarations = void 0;
|
|
}
|
|
}
|
|
}
|
|
function sliceTupleType(type, index, endSkipCount = 0) {
|
|
const target = type.target;
|
|
const endIndex = getTypeReferenceArity(type) - endSkipCount;
|
|
return index > target.fixedLength ? getRestArrayTypeOfTupleType(type) || createTupleType(emptyArray) : createTupleType(
|
|
getTypeArguments(type).slice(index, endIndex),
|
|
target.elementFlags.slice(index, endIndex),
|
|
false,
|
|
target.labeledElementDeclarations && target.labeledElementDeclarations.slice(index, endIndex)
|
|
);
|
|
}
|
|
function getKnownKeysOfTupleType(type) {
|
|
return getUnionType(append(
|
|
arrayOf(type.target.fixedLength, (i) => getStringLiteralType("" + i)),
|
|
getIndexType(type.target.readonly ? globalReadonlyArrayType : globalArrayType)
|
|
));
|
|
}
|
|
function getStartElementCount(type, flags) {
|
|
const index = findIndex(type.elementFlags, (f) => !(f & flags));
|
|
return index >= 0 ? index : type.elementFlags.length;
|
|
}
|
|
function getEndElementCount(type, flags) {
|
|
return type.elementFlags.length - findLastIndex(type.elementFlags, (f) => !(f & flags)) - 1;
|
|
}
|
|
function getTypeFromOptionalTypeNode(node) {
|
|
return addOptionality(getTypeFromTypeNode(node.type), true);
|
|
}
|
|
function getTypeId(type) {
|
|
return type.id;
|
|
}
|
|
function containsType(types, type) {
|
|
return binarySearch(types, type, getTypeId, compareValues) >= 0;
|
|
}
|
|
function insertType(types, type) {
|
|
const index = binarySearch(types, type, getTypeId, compareValues);
|
|
if (index < 0) {
|
|
types.splice(~index, 0, type);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function addTypeToUnion(typeSet, includes, type) {
|
|
const flags = type.flags;
|
|
if (flags & 1048576 /* Union */) {
|
|
return addTypesToUnion(typeSet, includes | (isNamedUnionType(type) ? 1048576 /* Union */ : 0), type.types);
|
|
}
|
|
if (!(flags & 131072 /* Never */)) {
|
|
includes |= flags & 205258751 /* IncludesMask */;
|
|
if (flags & 465829888 /* Instantiable */)
|
|
includes |= 33554432 /* IncludesInstantiable */;
|
|
if (type === wildcardType)
|
|
includes |= 8388608 /* IncludesWildcard */;
|
|
if (!strictNullChecks && flags & 98304 /* Nullable */) {
|
|
if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */))
|
|
includes |= 4194304 /* IncludesNonWideningType */;
|
|
} else {
|
|
const len = typeSet.length;
|
|
const index = len && type.id > typeSet[len - 1].id ? ~len : binarySearch(typeSet, type, getTypeId, compareValues);
|
|
if (index < 0) {
|
|
typeSet.splice(~index, 0, type);
|
|
}
|
|
}
|
|
}
|
|
return includes;
|
|
}
|
|
function addTypesToUnion(typeSet, includes, types) {
|
|
for (const type of types) {
|
|
includes = addTypeToUnion(typeSet, includes, type);
|
|
}
|
|
return includes;
|
|
}
|
|
function removeSubtypes(types, hasObjectTypes) {
|
|
var _a2;
|
|
if (types.length < 2) {
|
|
return types;
|
|
}
|
|
const id = getTypeListId(types);
|
|
const match = subtypeReductionCache.get(id);
|
|
if (match) {
|
|
return match;
|
|
}
|
|
const hasEmptyObject = hasObjectTypes && some(types, (t) => !!(t.flags & 524288 /* Object */) && !isGenericMappedType(t) && isEmptyResolvedType(resolveStructuredTypeMembers(t)));
|
|
const len = types.length;
|
|
let i = len;
|
|
let count = 0;
|
|
while (i > 0) {
|
|
i--;
|
|
const source = types[i];
|
|
if (hasEmptyObject || source.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
const keyProperty = source.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */) ? find(getPropertiesOfType(source), (p) => isUnitType(getTypeOfSymbol(p))) : void 0;
|
|
const keyPropertyType = keyProperty && getRegularTypeOfLiteralType(getTypeOfSymbol(keyProperty));
|
|
for (const target of types) {
|
|
if (source !== target) {
|
|
if (count === 1e5) {
|
|
const estimatedCount = count / (len - i) * len;
|
|
if (estimatedCount > 1e6) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "removeSubtypes_DepthLimit", { typeIds: types.map((t) => t.id) });
|
|
error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
|
|
return void 0;
|
|
}
|
|
}
|
|
count++;
|
|
if (keyProperty && target.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
const t = getTypeOfPropertyOfType(target, keyProperty.escapedName);
|
|
if (t && isUnitType(t) && getRegularTypeOfLiteralType(t) !== keyPropertyType) {
|
|
continue;
|
|
}
|
|
}
|
|
if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(getObjectFlags(getTargetType(source)) & 1 /* Class */) || !(getObjectFlags(getTargetType(target)) & 1 /* Class */) || isTypeDerivedFrom(source, target))) {
|
|
orderedRemoveItemAt(types, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
subtypeReductionCache.set(id, types);
|
|
return types;
|
|
}
|
|
function removeRedundantLiteralTypes(types, includes, reduceVoidUndefined) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
const flags = t.flags;
|
|
const remove = flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && 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) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
function removeStringLiteralsMatchedByTemplateLiterals(types) {
|
|
const templates = filter(types, isPatternLiteralType);
|
|
if (templates.length) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
if (t.flags & 128 /* StringLiteral */ && some(templates, (template) => isTypeMatchedByTemplateLiteralType(t, template))) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isNamedUnionType(type) {
|
|
return !!(type.flags & 1048576 /* Union */ && (type.aliasSymbol || type.origin));
|
|
}
|
|
function addNamedUnions(namedUnions, types) {
|
|
for (const t of types) {
|
|
if (t.flags & 1048576 /* Union */) {
|
|
const origin = t.origin;
|
|
if (t.aliasSymbol || origin && !(origin.flags & 1048576 /* Union */)) {
|
|
pushIfUnique(namedUnions, t);
|
|
} else if (origin && origin.flags & 1048576 /* Union */) {
|
|
addNamedUnions(namedUnions, origin.types);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createOriginUnionOrIntersectionType(flags, types) {
|
|
const result = createOriginType(flags);
|
|
result.types = types;
|
|
return result;
|
|
}
|
|
function getUnionType(types, unionReduction = 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin) {
|
|
if (types.length === 0) {
|
|
return neverType;
|
|
}
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
let typeSet = [];
|
|
const includes = addTypesToUnion(typeSet, 0, types);
|
|
if (unionReduction !== 0 /* None */) {
|
|
if (includes & 3 /* AnyOrUnknown */) {
|
|
return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType : includes & 65536 /* Null */ || containsType(typeSet, unknownType) ? unknownType : nonNullUnknownType;
|
|
}
|
|
if (exactOptionalPropertyTypes && includes & 32768 /* Undefined */) {
|
|
const missingIndex = binarySearch(typeSet, missingType, getTypeId, compareValues);
|
|
if (missingIndex >= 0 && containsType(typeSet, undefinedType)) {
|
|
orderedRemoveItemAt(typeSet, missingIndex);
|
|
}
|
|
}
|
|
if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || 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 */) {
|
|
typeSet = removeSubtypes(typeSet, !!(includes & 524288 /* Object */));
|
|
if (!typeSet) {
|
|
return errorType;
|
|
}
|
|
}
|
|
if (typeSet.length === 0) {
|
|
return includes & 65536 /* Null */ ? includes & 4194304 /* IncludesNonWideningType */ ? nullType : nullWideningType : includes & 32768 /* Undefined */ ? includes & 4194304 /* IncludesNonWideningType */ ? undefinedType : undefinedWideningType : neverType;
|
|
}
|
|
}
|
|
if (!origin && includes & 1048576 /* Union */) {
|
|
const namedUnions = [];
|
|
addNamedUnions(namedUnions, types);
|
|
const reducedTypes = [];
|
|
for (const t of typeSet) {
|
|
if (!some(namedUnions, (union) => containsType(union.types, t))) {
|
|
reducedTypes.push(t);
|
|
}
|
|
}
|
|
if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) {
|
|
return namedUnions[0];
|
|
}
|
|
const namedTypesCount = reduceLeft(namedUnions, (sum2, union) => sum2 + union.types.length, 0);
|
|
if (namedTypesCount + reducedTypes.length === typeSet.length) {
|
|
for (const t of namedUnions) {
|
|
insertType(reducedTypes, t);
|
|
}
|
|
origin = createOriginUnionOrIntersectionType(1048576 /* Union */, reducedTypes);
|
|
}
|
|
}
|
|
const objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 32768 /* PrimitiveUnion */) | (includes & 2097152 /* Intersection */ ? 16777216 /* ContainsIntersections */ : 0);
|
|
return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
|
|
}
|
|
function getUnionOrIntersectionTypePredicate(signatures, kind) {
|
|
let first2;
|
|
const types = [];
|
|
for (const sig of signatures) {
|
|
const pred = getTypePredicateOfSignature(sig);
|
|
if (!pred || pred.kind === 2 /* AssertsThis */ || pred.kind === 3 /* AssertsIdentifier */) {
|
|
if (kind !== 2097152 /* Intersection */) {
|
|
continue;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (first2) {
|
|
if (!typePredicateKindsMatch(first2, pred)) {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
first2 = pred;
|
|
}
|
|
types.push(pred.type);
|
|
}
|
|
if (!first2) {
|
|
return void 0;
|
|
}
|
|
const compositeType = getUnionOrIntersectionType(types, kind);
|
|
return createTypePredicate(first2.kind, first2.parameterName, first2.parameterIndex, compositeType);
|
|
}
|
|
function typePredicateKindsMatch(a, b) {
|
|
return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
|
|
}
|
|
function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) {
|
|
if (types.length === 0) {
|
|
return neverType;
|
|
}
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
const typeKey = !origin ? getTypeListId(types) : origin.flags & 1048576 /* Union */ ? `|${getTypeListId(origin.types)}` : origin.flags & 2097152 /* Intersection */ ? `&${getTypeListId(origin.types)}` : `#${origin.type.id}|${getTypeListId(types)}`;
|
|
const id = typeKey + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let type = unionTypes.get(id);
|
|
if (!type) {
|
|
type = createType(1048576 /* Union */);
|
|
type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, 98304 /* Nullable */);
|
|
type.types = types;
|
|
type.origin = origin;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
if (types.length === 2 && types[0].flags & 512 /* BooleanLiteral */ && types[1].flags & 512 /* BooleanLiteral */) {
|
|
type.flags |= 16 /* Boolean */;
|
|
type.intrinsicName = "boolean";
|
|
}
|
|
unionTypes.set(id, type);
|
|
}
|
|
return type;
|
|
}
|
|
function getTypeFromUnionTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
links.resolvedType = getUnionType(
|
|
map(node.types, getTypeFromTypeNode),
|
|
1 /* Literal */,
|
|
aliasSymbol,
|
|
getTypeArgumentsForAliasSymbol(aliasSymbol)
|
|
);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function addTypeToIntersection(typeSet, includes, type) {
|
|
const flags = type.flags;
|
|
if (flags & 2097152 /* Intersection */) {
|
|
return addTypesToIntersection(typeSet, includes, type.types);
|
|
}
|
|
if (isEmptyAnonymousObjectType(type)) {
|
|
if (!(includes & 16777216 /* IncludesEmptyObject */)) {
|
|
includes |= 16777216 /* IncludesEmptyObject */;
|
|
typeSet.set(type.id.toString(), type);
|
|
}
|
|
} else {
|
|
if (flags & 3 /* AnyOrUnknown */) {
|
|
if (type === wildcardType)
|
|
includes |= 8388608 /* IncludesWildcard */;
|
|
} else if (strictNullChecks || !(flags & 98304 /* Nullable */)) {
|
|
if (exactOptionalPropertyTypes && type === missingType) {
|
|
includes |= 262144 /* IncludesMissingType */;
|
|
type = undefinedType;
|
|
}
|
|
if (!typeSet.has(type.id.toString())) {
|
|
if (type.flags & 109440 /* Unit */ && includes & 109440 /* Unit */) {
|
|
includes |= 67108864 /* NonPrimitive */;
|
|
}
|
|
typeSet.set(type.id.toString(), type);
|
|
}
|
|
}
|
|
includes |= flags & 205258751 /* IncludesMask */;
|
|
}
|
|
return includes;
|
|
}
|
|
function addTypesToIntersection(typeSet, includes, types) {
|
|
for (const type of types) {
|
|
includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
|
|
}
|
|
return includes;
|
|
}
|
|
function removeRedundantSupertypes(types, includes) {
|
|
let i = types.length;
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
const remove = t.flags & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || t.flags & 8 /* Number */ && includes & 256 /* NumberLiteral */ || t.flags & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || t.flags & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || t.flags & 16384 /* Void */ && includes & 32768 /* Undefined */ || isEmptyAnonymousObjectType(t) && includes & 470302716 /* DefinitelyNonNullable */;
|
|
if (remove) {
|
|
orderedRemoveItemAt(types, i);
|
|
}
|
|
}
|
|
}
|
|
function eachUnionContains(unionTypes2, type) {
|
|
for (const u of unionTypes2) {
|
|
if (!containsType(u.types, type)) {
|
|
const primitive = type.flags & 128 /* StringLiteral */ ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : void 0;
|
|
if (!primitive || !containsType(u.types, primitive)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function extractRedundantTemplateLiterals(types) {
|
|
let i = types.length;
|
|
const literals = filter(types, (t) => !!(t.flags & 128 /* StringLiteral */));
|
|
while (i > 0) {
|
|
i--;
|
|
const t = types[i];
|
|
if (!(t.flags & 134217728 /* TemplateLiteral */))
|
|
continue;
|
|
for (const t2 of literals) {
|
|
if (isTypeSubtypeOf(t2, t)) {
|
|
orderedRemoveItemAt(types, i);
|
|
break;
|
|
} else if (isPatternLiteralType(t)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function eachIsUnionContaining(types, flag) {
|
|
return every(types, (t) => !!(t.flags & 1048576 /* Union */) && some(t.types, (tt) => !!(tt.flags & flag)));
|
|
}
|
|
function removeFromEach(types, flag) {
|
|
for (let i = 0; i < types.length; i++) {
|
|
types[i] = filterType(types[i], (t) => !(t.flags & flag));
|
|
}
|
|
}
|
|
function intersectUnionsOfPrimitiveTypes(types) {
|
|
let unionTypes2;
|
|
const index = findIndex(types, (t) => !!(getObjectFlags(t) & 32768 /* PrimitiveUnion */));
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
let i = index + 1;
|
|
while (i < types.length) {
|
|
const t = types[i];
|
|
if (getObjectFlags(t) & 32768 /* PrimitiveUnion */) {
|
|
(unionTypes2 || (unionTypes2 = [types[index]])).push(t);
|
|
orderedRemoveItemAt(types, i);
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
if (!unionTypes2) {
|
|
return false;
|
|
}
|
|
const checked = [];
|
|
const result = [];
|
|
for (const u of unionTypes2) {
|
|
for (const t of u.types) {
|
|
if (insertType(checked, t)) {
|
|
if (eachUnionContains(unionTypes2, t)) {
|
|
insertType(result, t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
types[index] = getUnionTypeFromSortedList(result, 32768 /* PrimitiveUnion */);
|
|
return true;
|
|
}
|
|
function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
|
|
const result = createType(2097152 /* Intersection */);
|
|
result.objectFlags = getPropagatingFlagsOfTypes(types, 98304 /* Nullable */);
|
|
result.types = types;
|
|
result.aliasSymbol = aliasSymbol;
|
|
result.aliasTypeArguments = aliasTypeArguments;
|
|
return result;
|
|
}
|
|
function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) {
|
|
const typeMembershipMap = /* @__PURE__ */ new Map();
|
|
const includes = addTypesToIntersection(typeMembershipMap, 0, types);
|
|
const typeSet = arrayFrom(typeMembershipMap.values());
|
|
if (includes & 131072 /* Never */) {
|
|
return contains(typeSet, silentNeverType) ? silentNeverType : neverType;
|
|
}
|
|
if (strictNullChecks && includes & 98304 /* Nullable */ && includes & (524288 /* Object */ | 67108864 /* NonPrimitive */ | 16777216 /* IncludesEmptyObject */) || includes & 67108864 /* NonPrimitive */ && includes & (469892092 /* DisjointDomains */ & ~67108864 /* NonPrimitive */) || includes & 402653316 /* StringLike */ && includes & (469892092 /* DisjointDomains */ & ~402653316 /* StringLike */) || includes & 296 /* NumberLike */ && includes & (469892092 /* DisjointDomains */ & ~296 /* NumberLike */) || includes & 2112 /* BigIntLike */ && includes & (469892092 /* DisjointDomains */ & ~2112 /* BigIntLike */) || includes & 12288 /* ESSymbolLike */ && includes & (469892092 /* DisjointDomains */ & ~12288 /* ESSymbolLike */) || includes & 49152 /* VoidLike */ && includes & (469892092 /* DisjointDomains */ & ~49152 /* VoidLike */)) {
|
|
return neverType;
|
|
}
|
|
if (includes & 134217728 /* TemplateLiteral */ && includes & 128 /* StringLiteral */ && extractRedundantTemplateLiterals(typeSet)) {
|
|
return neverType;
|
|
}
|
|
if (includes & 1 /* Any */) {
|
|
return includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType;
|
|
}
|
|
if (!strictNullChecks && includes & 98304 /* Nullable */) {
|
|
return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 32768 /* Undefined */ ? undefinedType : nullType;
|
|
}
|
|
if (includes & 4 /* String */ && includes & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) || includes & 8 /* Number */ && includes & 256 /* NumberLiteral */ || includes & 64 /* BigInt */ && includes & 2048 /* BigIntLiteral */ || includes & 4096 /* ESSymbol */ && includes & 8192 /* UniqueESSymbol */ || includes & 16384 /* Void */ && includes & 32768 /* Undefined */ || includes & 16777216 /* IncludesEmptyObject */ && includes & 470302716 /* DefinitelyNonNullable */) {
|
|
if (!noSupertypeReduction)
|
|
removeRedundantSupertypes(typeSet, includes);
|
|
}
|
|
if (includes & 262144 /* IncludesMissingType */) {
|
|
typeSet[typeSet.indexOf(undefinedType)] = missingType;
|
|
}
|
|
if (typeSet.length === 0) {
|
|
return unknownType;
|
|
}
|
|
if (typeSet.length === 1) {
|
|
return typeSet[0];
|
|
}
|
|
const id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let result = intersectionTypes.get(id);
|
|
if (!result) {
|
|
if (includes & 1048576 /* Union */) {
|
|
if (intersectUnionsOfPrimitiveTypes(typeSet)) {
|
|
result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
|
|
} else if (eachIsUnionContaining(typeSet, 32768 /* Undefined */)) {
|
|
const undefinedOrMissingType = exactOptionalPropertyTypes && some(typeSet, (t) => containsType(t.types, missingType)) ? missingType : undefinedType;
|
|
removeFromEach(typeSet, 32768 /* Undefined */);
|
|
result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
} else if (eachIsUnionContaining(typeSet, 65536 /* Null */)) {
|
|
removeFromEach(typeSet, 65536 /* Null */);
|
|
result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
} else {
|
|
if (!checkCrossProductUnion(typeSet)) {
|
|
return errorType;
|
|
}
|
|
const constituents = getCrossProductIntersections(typeSet);
|
|
const origin = some(constituents, (t) => !!(t.flags & 2097152 /* Intersection */)) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : void 0;
|
|
result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
|
|
}
|
|
} else {
|
|
result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
intersectionTypes.set(id, result);
|
|
}
|
|
return result;
|
|
}
|
|
function getCrossProductUnionSize(types) {
|
|
return reduceLeft(types, (n, t) => t.flags & 1048576 /* Union */ ? n * t.types.length : t.flags & 131072 /* Never */ ? 0 : n, 1);
|
|
}
|
|
function checkCrossProductUnion(types) {
|
|
var _a2;
|
|
const size = getCrossProductUnionSize(types);
|
|
if (size >= 1e5) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "checkCrossProductUnion_DepthLimit", { typeIds: types.map((t) => t.id), size });
|
|
error(currentNode, Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getCrossProductIntersections(types) {
|
|
const count = getCrossProductUnionSize(types);
|
|
const intersections = [];
|
|
for (let i = 0; i < count; i++) {
|
|
const constituents = types.slice();
|
|
let n = i;
|
|
for (let j = types.length - 1; j >= 0; j--) {
|
|
if (types[j].flags & 1048576 /* Union */) {
|
|
const sourceTypes = types[j].types;
|
|
const length2 = sourceTypes.length;
|
|
constituents[j] = sourceTypes[n % length2];
|
|
n = Math.floor(n / length2);
|
|
}
|
|
}
|
|
const t = getIntersectionType(constituents);
|
|
if (!(t.flags & 131072 /* Never */))
|
|
intersections.push(t);
|
|
}
|
|
return intersections;
|
|
}
|
|
function getConstituentCount(type) {
|
|
return !(type.flags & 3145728 /* UnionOrIntersection */) || type.aliasSymbol ? 1 : type.flags & 1048576 /* Union */ && type.origin ? getConstituentCount(type.origin) : getConstituentCountOfTypes(type.types);
|
|
}
|
|
function getConstituentCountOfTypes(types) {
|
|
return reduceLeft(types, (n, t) => n + getConstituentCount(t), 0);
|
|
}
|
|
function getTypeFromIntersectionTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
const types = map(node.types, getTypeFromTypeNode);
|
|
const noSupertypeReduction = types.length === 2 && !!(types[0].flags & (4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) && types[1] === emptyTypeLiteralType;
|
|
links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function createIndexType(type, stringsOnly) {
|
|
const result = createType(4194304 /* Index */);
|
|
result.type = type;
|
|
result.stringsOnly = stringsOnly;
|
|
return result;
|
|
}
|
|
function createOriginIndexType(type) {
|
|
const result = createOriginType(4194304 /* Index */);
|
|
result.type = type;
|
|
return result;
|
|
}
|
|
function getIndexTypeForGenericType(type, stringsOnly) {
|
|
return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, true)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, false));
|
|
}
|
|
function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
|
|
const typeParameter = getTypeParameterFromMappedType(type);
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
const nameType = getNameTypeFromMappedType(type.target || type);
|
|
if (!nameType && !noIndexSignatures) {
|
|
return constraintType;
|
|
}
|
|
const keyTypes = [];
|
|
if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
|
|
if (!isGenericIndexType(constraintType)) {
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
|
|
} else {
|
|
return getIndexTypeForGenericType(type, stringsOnly);
|
|
}
|
|
} else {
|
|
forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
|
|
}
|
|
if (isGenericIndexType(constraintType)) {
|
|
forEachType(constraintType, addMemberForKeyType);
|
|
}
|
|
const result = noIndexSignatures ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
|
|
if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
|
|
return constraintType;
|
|
}
|
|
return result;
|
|
function addMemberForKeyType(keyType) {
|
|
const propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType;
|
|
keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType);
|
|
}
|
|
}
|
|
function hasDistributiveNameType(mappedType) {
|
|
const typeVariable = getTypeParameterFromMappedType(mappedType);
|
|
return isDistributive(getNameTypeFromMappedType(mappedType) || typeVariable);
|
|
function isDistributive(type) {
|
|
return type.flags & (3 /* AnyOrUnknown */ | 131068 /* Primitive */ | 131072 /* Never */ | 262144 /* TypeParameter */ | 524288 /* Object */ | 67108864 /* NonPrimitive */) ? true : type.flags & 16777216 /* Conditional */ ? type.root.isDistributive && type.checkType === typeVariable : type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) ? every(type.types, isDistributive) : type.flags & 8388608 /* IndexedAccess */ ? isDistributive(type.objectType) && isDistributive(type.indexType) : type.flags & 33554432 /* Substitution */ ? isDistributive(type.baseType) && isDistributive(type.constraint) : type.flags & 268435456 /* StringMapping */ ? isDistributive(type.type) : false;
|
|
}
|
|
}
|
|
function getLiteralTypeFromPropertyName(name) {
|
|
if (isPrivateIdentifier(name)) {
|
|
return neverType;
|
|
}
|
|
return isIdentifier(name) ? getStringLiteralType(unescapeLeadingUnderscores(name.escapedText)) : getRegularTypeOfLiteralType(isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name));
|
|
}
|
|
function getLiteralTypeFromProperty(prop, include, includeNonPublic) {
|
|
if (includeNonPublic || !(getDeclarationModifierFlagsFromSymbol(prop) & 24 /* NonPublicAccessibilityModifier */)) {
|
|
let type = getSymbolLinks(getLateBoundSymbol(prop)).nameType;
|
|
if (!type) {
|
|
const name = getNameOfDeclaration(prop.valueDeclaration);
|
|
type = prop.escapedName === "default" /* Default */ ? getStringLiteralType("default") : name && getLiteralTypeFromPropertyName(name) || (!isKnownSymbol(prop) ? getStringLiteralType(symbolName(prop)) : void 0);
|
|
}
|
|
if (type && type.flags & include) {
|
|
return type;
|
|
}
|
|
}
|
|
return neverType;
|
|
}
|
|
function isKeyTypeIncluded(keyType, include) {
|
|
return !!(keyType.flags & include || keyType.flags & 2097152 /* Intersection */ && some(keyType.types, (t) => isKeyTypeIncluded(t, include)));
|
|
}
|
|
function getLiteralTypeFromProperties(type, include, includeOrigin) {
|
|
const origin = includeOrigin && (getObjectFlags(type) & (3 /* ClassOrInterface */ | 4 /* Reference */) || type.aliasSymbol) ? createOriginIndexType(type) : void 0;
|
|
const propertyTypes = map(getPropertiesOfType(type), (prop) => getLiteralTypeFromProperty(prop, include));
|
|
const indexKeyTypes = map(getIndexInfosOfType(type), (info) => info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ? info.keyType === stringType && include & 8 /* Number */ ? stringOrNumberType : info.keyType : neverType);
|
|
return getUnionType(
|
|
concatenate(propertyTypes, indexKeyTypes),
|
|
1 /* Literal */,
|
|
void 0,
|
|
void 0,
|
|
origin
|
|
);
|
|
}
|
|
function isPossiblyReducibleByInstantiation(type) {
|
|
const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
|
|
return getReducedType(uniqueFilled) !== uniqueFilled;
|
|
}
|
|
function shouldDeferIndexType(type) {
|
|
return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && some(type.types, isPossiblyReducibleByInstantiation) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
|
|
}
|
|
function getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
|
|
type = getReducedType(type);
|
|
return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
|
|
type,
|
|
(noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
|
|
stringsOnly === keyofStringsOnly && !noIndexSignatures
|
|
);
|
|
}
|
|
function getExtractStringType(type) {
|
|
if (keyofStringsOnly) {
|
|
return type;
|
|
}
|
|
const extractTypeAlias = getGlobalExtractSymbol();
|
|
return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
|
|
}
|
|
function getIndexTypeOrString(type) {
|
|
const indexType = getExtractStringType(getIndexType(type));
|
|
return indexType.flags & 131072 /* Never */ ? stringType : indexType;
|
|
}
|
|
function getTypeFromTypeOperatorNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
switch (node.operator) {
|
|
case 141 /* KeyOfKeyword */:
|
|
links.resolvedType = getIndexType(getTypeFromTypeNode(node.type));
|
|
break;
|
|
case 156 /* UniqueKeyword */:
|
|
links.resolvedType = node.type.kind === 153 /* SymbolKeyword */ ? getESSymbolLikeTypeForNode(walkUpParenthesizedTypes(node.parent)) : errorType;
|
|
break;
|
|
case 146 /* ReadonlyKeyword */:
|
|
links.resolvedType = getTypeFromTypeNode(node.type);
|
|
break;
|
|
default:
|
|
throw Debug.assertNever(node.operator);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromTemplateTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getTemplateLiteralType(
|
|
[node.head.text, ...map(node.templateSpans, (span) => span.literal.text)],
|
|
map(node.templateSpans, (span) => getTypeFromTypeNode(span.type))
|
|
);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTemplateLiteralType(texts, types) {
|
|
const unionIndex = findIndex(types, (t) => !!(t.flags & (131072 /* Never */ | 1048576 /* Union */)));
|
|
if (unionIndex >= 0) {
|
|
return checkCrossProductUnion(types) ? mapType(types[unionIndex], (t) => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType;
|
|
}
|
|
if (contains(types, wildcardType)) {
|
|
return wildcardType;
|
|
}
|
|
const newTypes = [];
|
|
const newTexts = [];
|
|
let text = texts[0];
|
|
if (!addSpans(texts, types)) {
|
|
return stringType;
|
|
}
|
|
if (newTypes.length === 0) {
|
|
return getStringLiteralType(text);
|
|
}
|
|
newTexts.push(text);
|
|
if (every(newTexts, (t) => t === "")) {
|
|
if (every(newTypes, (t) => !!(t.flags & 4 /* String */))) {
|
|
return stringType;
|
|
}
|
|
if (newTypes.length === 1 && isPatternLiteralType(newTypes[0])) {
|
|
return newTypes[0];
|
|
}
|
|
}
|
|
const id = `${getTypeListId(newTypes)}|${map(newTexts, (t) => t.length).join(",")}|${newTexts.join("")}`;
|
|
let type = templateLiteralTypes.get(id);
|
|
if (!type) {
|
|
templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes));
|
|
}
|
|
return type;
|
|
function addSpans(texts2, types2) {
|
|
const isTextsArray = isArray(texts2);
|
|
for (let i = 0; i < types2.length; i++) {
|
|
const t = types2[i];
|
|
const addText = isTextsArray ? texts2[i + 1] : texts2;
|
|
if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
|
|
text += getTemplateStringForType(t) || "";
|
|
text += addText;
|
|
if (!isTextsArray)
|
|
return true;
|
|
} else if (t.flags & 134217728 /* TemplateLiteral */) {
|
|
text += t.texts[0];
|
|
if (!addSpans(t.texts, t.types))
|
|
return false;
|
|
text += addText;
|
|
if (!isTextsArray)
|
|
return true;
|
|
} else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
|
|
newTypes.push(t);
|
|
newTexts.push(text);
|
|
text = addText;
|
|
} else if (t.flags & 2097152 /* Intersection */) {
|
|
const added = addSpans(texts2[i + 1], t.types);
|
|
if (!added)
|
|
return false;
|
|
} else if (isTextsArray) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function getTemplateStringForType(type) {
|
|
return type.flags & 128 /* StringLiteral */ ? type.value : type.flags & 256 /* NumberLiteral */ ? "" + type.value : type.flags & 2048 /* BigIntLiteral */ ? pseudoBigIntToString(type.value) : type.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) ? type.intrinsicName : void 0;
|
|
}
|
|
function createTemplateLiteralType(texts, types) {
|
|
const type = createType(134217728 /* TemplateLiteral */);
|
|
type.texts = texts;
|
|
type.types = types;
|
|
return type;
|
|
}
|
|
function getStringMappingType(symbol, type) {
|
|
return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type : type.flags & (1 /* Any */ | 4 /* String */ | 268435456 /* StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) : type;
|
|
}
|
|
function applyStringMapping(symbol, str) {
|
|
switch (intrinsicTypeKinds.get(symbol.escapedName)) {
|
|
case 0 /* Uppercase */:
|
|
return str.toUpperCase();
|
|
case 1 /* Lowercase */:
|
|
return str.toLowerCase();
|
|
case 2 /* Capitalize */:
|
|
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
case 3 /* Uncapitalize */:
|
|
return str.charAt(0).toLowerCase() + str.slice(1);
|
|
}
|
|
return str;
|
|
}
|
|
function applyTemplateStringMapping(symbol, texts, types) {
|
|
switch (intrinsicTypeKinds.get(symbol.escapedName)) {
|
|
case 0 /* Uppercase */:
|
|
return [texts.map((t) => t.toUpperCase()), types.map((t) => getStringMappingType(symbol, t))];
|
|
case 1 /* Lowercase */:
|
|
return [texts.map((t) => t.toLowerCase()), types.map((t) => getStringMappingType(symbol, t))];
|
|
case 2 /* Capitalize */:
|
|
return [texts[0] === "" ? texts : [texts[0].charAt(0).toUpperCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
|
|
case 3 /* Uncapitalize */:
|
|
return [texts[0] === "" ? texts : [texts[0].charAt(0).toLowerCase() + texts[0].slice(1), ...texts.slice(1)], texts[0] === "" ? [getStringMappingType(symbol, types[0]), ...types.slice(1)] : types];
|
|
}
|
|
return [texts, types];
|
|
}
|
|
function getStringMappingTypeForGenericType(symbol, type) {
|
|
const id = `${getSymbolId(symbol)},${getTypeId(type)}`;
|
|
let result = stringMappingTypes.get(id);
|
|
if (!result) {
|
|
stringMappingTypes.set(id, result = createStringMappingType(symbol, type));
|
|
}
|
|
return result;
|
|
}
|
|
function createStringMappingType(symbol, type) {
|
|
const result = createTypeWithSymbol(268435456 /* StringMapping */, symbol);
|
|
result.type = type;
|
|
return result;
|
|
}
|
|
function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments) {
|
|
const type = createType(8388608 /* IndexedAccess */);
|
|
type.objectType = objectType;
|
|
type.indexType = indexType;
|
|
type.accessFlags = accessFlags;
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = aliasTypeArguments;
|
|
return type;
|
|
}
|
|
function isJSLiteralType(type) {
|
|
if (noImplicitAny) {
|
|
return false;
|
|
}
|
|
if (getObjectFlags(type) & 4096 /* JSLiteral */) {
|
|
return true;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return every(type.types, isJSLiteralType);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return some(type.types, isJSLiteralType);
|
|
}
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
const constraint = getResolvedBaseConstraint(type);
|
|
return constraint !== type && isJSLiteralType(constraint);
|
|
}
|
|
return false;
|
|
}
|
|
function getPropertyNameFromIndex(indexType, accessNode) {
|
|
return isTypeUsableAsPropertyName(indexType) ? getPropertyNameFromType(indexType) : accessNode && isPropertyName(accessNode) ? getPropertyNameForPropertyNameNode(accessNode) : void 0;
|
|
}
|
|
function isUncalledFunctionReference(node, symbol) {
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
|
|
const parent2 = findAncestor(node.parent, (n) => !isAccessExpression(n)) || node.parent;
|
|
if (isCallLikeExpression(parent2)) {
|
|
return isCallOrNewExpression(parent2) && isIdentifier(node) && hasMatchingArgument(parent2, node);
|
|
}
|
|
return every(symbol.declarations, (d) => !isFunctionLike(d) || !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
|
|
}
|
|
return true;
|
|
}
|
|
function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, accessNode, accessFlags) {
|
|
var _a2;
|
|
const accessExpression = accessNode && accessNode.kind === 209 /* ElementAccessExpression */ ? accessNode : void 0;
|
|
const propName = accessNode && isPrivateIdentifier(accessNode) ? void 0 : getPropertyNameFromIndex(indexType, accessNode);
|
|
if (propName !== void 0) {
|
|
if (accessFlags & 256 /* Contextual */) {
|
|
return getTypeOfPropertyOfContextualType(objectType, propName) || anyType;
|
|
}
|
|
const prop = getPropertyOfType(objectType, propName);
|
|
if (prop) {
|
|
if (accessFlags & 64 /* ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) {
|
|
const deprecatedNode = (_a2 = accessExpression == null ? void 0 : accessExpression.argumentExpression) != null ? _a2 : isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode;
|
|
addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName);
|
|
}
|
|
if (accessExpression) {
|
|
markPropertyAsReferenced(prop, accessExpression, isSelfTypeAccess(accessExpression.expression, objectType.symbol));
|
|
if (isAssignmentToReadonlyEntity(accessExpression, prop, getAssignmentTargetKind(accessExpression))) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop));
|
|
return void 0;
|
|
}
|
|
if (accessFlags & 8 /* CacheSymbol */) {
|
|
getNodeLinks(accessNode).resolvedSymbol = prop;
|
|
}
|
|
if (isThisPropertyAccessInConstructor(accessExpression, prop)) {
|
|
return autoType;
|
|
}
|
|
}
|
|
const propType = getTypeOfSymbol(prop);
|
|
return accessExpression && getAssignmentTargetKind(accessExpression) !== 1 /* Definite */ ? getFlowTypeOfReference(accessExpression, propType) : propType;
|
|
}
|
|
if (everyType(objectType, isTupleType) && isNumericLiteralName(propName)) {
|
|
const index = +propName;
|
|
if (accessNode && everyType(objectType, (t) => !t.target.hasRestElement) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
if (isTupleType(objectType)) {
|
|
if (index < 0) {
|
|
error(indexNode, Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value);
|
|
return undefinedType;
|
|
}
|
|
error(
|
|
indexNode,
|
|
Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2,
|
|
typeToString(objectType),
|
|
getTypeReferenceArity(objectType),
|
|
unescapeLeadingUnderscores(propName)
|
|
);
|
|
} else {
|
|
error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(propName), typeToString(objectType));
|
|
}
|
|
}
|
|
if (index >= 0) {
|
|
errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, numberType));
|
|
return mapType(objectType, (t) => {
|
|
const restType = getRestTypeOfTupleType(t) || undefinedType;
|
|
return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([restType, undefinedType]) : restType;
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (!(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */)) {
|
|
if (objectType.flags & (1 /* Any */ | 131072 /* Never */)) {
|
|
return objectType;
|
|
}
|
|
const indexInfo = getApplicableIndexInfo(objectType, indexType) || getIndexInfoOfType(objectType, stringType);
|
|
if (indexInfo) {
|
|
if (accessFlags & 2 /* NoIndexSignatures */ && indexInfo.keyType !== numberType) {
|
|
if (accessExpression) {
|
|
error(accessExpression, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType));
|
|
}
|
|
return void 0;
|
|
}
|
|
if (accessNode && indexInfo.keyType === stringType && !isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
|
|
return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
|
|
}
|
|
errorIfWritingToReadonlyIndex(indexInfo);
|
|
if (accessFlags & 1 /* IncludeUndefined */ && !(objectType.symbol && objectType.symbol.flags & (256 /* RegularEnum */ | 128 /* ConstEnum */) && (indexType.symbol && indexType.flags & 1024 /* EnumLiteral */ && getParentOfSymbol(indexType.symbol) === objectType.symbol))) {
|
|
return getUnionType([indexInfo.type, undefinedType]);
|
|
}
|
|
return indexInfo.type;
|
|
}
|
|
if (indexType.flags & 131072 /* Never */) {
|
|
return neverType;
|
|
}
|
|
if (isJSLiteralType(objectType)) {
|
|
return anyType;
|
|
}
|
|
if (accessExpression && !isConstEnumObjectType(objectType)) {
|
|
if (isObjectLiteralType2(objectType)) {
|
|
if (noImplicitAny && indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
diagnostics.add(createDiagnosticForNode(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)));
|
|
return undefinedType;
|
|
} else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
|
|
const types = map(objectType.properties, (property) => {
|
|
return getTypeOfSymbol(property);
|
|
});
|
|
return getUnionType(append(types, undefinedType));
|
|
}
|
|
}
|
|
if (objectType.symbol === globalThisSymbol && propName !== void 0 && globalThisSymbol.exports.has(propName) && globalThisSymbol.exports.get(propName).flags & 418 /* BlockScoped */) {
|
|
error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(propName), typeToString(objectType));
|
|
} else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !(accessFlags & 128 /* SuppressNoImplicitAnyError */)) {
|
|
if (propName !== void 0 && typeHasStaticProperty(propName, objectType)) {
|
|
const typeName = typeToString(objectType);
|
|
error(accessExpression, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "[" + getTextOfNode(accessExpression.argumentExpression) + "]");
|
|
} else if (getIndexTypeOfType(objectType, numberType)) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number);
|
|
} else {
|
|
let suggestion;
|
|
if (propName !== void 0 && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) {
|
|
if (suggestion !== void 0) {
|
|
error(accessExpression.argumentExpression, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion);
|
|
}
|
|
} else {
|
|
const suggestion2 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType);
|
|
if (suggestion2 !== void 0) {
|
|
error(accessExpression, Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion2);
|
|
} else {
|
|
let errorInfo;
|
|
if (indexType.flags & 1024 /* EnumLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType));
|
|
} else if (indexType.flags & 8192 /* UniqueESSymbol */) {
|
|
const symbolName2 = getFullyQualifiedName(indexType.symbol, accessExpression);
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName2 + "]", typeToString(objectType));
|
|
} else if (indexType.flags & 128 /* StringLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & 256 /* NumberLiteral */) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & (8 /* Number */ | 4 /* String */)) {
|
|
errorInfo = chainDiagnosticMessages(void 0, Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType));
|
|
}
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1,
|
|
typeToString(fullIndexType),
|
|
typeToString(objectType)
|
|
);
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
if (isJSLiteralType(objectType)) {
|
|
return anyType;
|
|
}
|
|
if (accessNode) {
|
|
const indexNode = getIndexNodeForAccessExpression(accessNode);
|
|
if (indexType.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
|
|
error(indexNode, Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType));
|
|
} else if (indexType.flags & (4 /* String */ | 8 /* Number */)) {
|
|
error(indexNode, Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType));
|
|
} else {
|
|
error(indexNode, Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType));
|
|
}
|
|
}
|
|
if (isTypeAny(indexType)) {
|
|
return indexType;
|
|
}
|
|
return void 0;
|
|
function errorIfWritingToReadonlyIndex(indexInfo) {
|
|
if (indexInfo && indexInfo.isReadonly && accessExpression && (isAssignmentTarget(accessExpression) || isDeleteTarget(accessExpression))) {
|
|
error(accessExpression, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
|
|
}
|
|
}
|
|
}
|
|
function getIndexNodeForAccessExpression(accessNode) {
|
|
return accessNode.kind === 209 /* ElementAccessExpression */ ? accessNode.argumentExpression : accessNode.kind === 196 /* IndexedAccessType */ ? accessNode.indexType : accessNode.kind === 164 /* ComputedPropertyName */ ? accessNode.expression : accessNode;
|
|
}
|
|
function isPatternLiteralPlaceholderType(type) {
|
|
return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
|
|
}
|
|
function isPatternLiteralType(type) {
|
|
return !!(type.flags & 134217728 /* TemplateLiteral */) && every(type.types, isPatternLiteralPlaceholderType) || !!(type.flags & 268435456 /* StringMapping */) && isPatternLiteralPlaceholderType(type.type);
|
|
}
|
|
function isGenericType(type) {
|
|
return !!getGenericObjectFlags(type);
|
|
}
|
|
function isGenericObjectType(type) {
|
|
return !!(getGenericObjectFlags(type) & 4194304 /* IsGenericObjectType */);
|
|
}
|
|
function isGenericIndexType(type) {
|
|
return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
|
|
}
|
|
function getGenericObjectFlags(type) {
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
|
|
type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
|
|
}
|
|
return type.objectFlags & 12582912 /* IsGenericType */;
|
|
}
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
|
|
type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | getGenericObjectFlags(type.baseType) | getGenericObjectFlags(type.constraint);
|
|
}
|
|
return type.objectFlags & 12582912 /* IsGenericType */;
|
|
}
|
|
return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
|
|
}
|
|
function getSimplifiedType(type, writing) {
|
|
return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
|
|
}
|
|
function distributeIndexOverObjectType(objectType, indexType, writing) {
|
|
if (objectType.flags & 1048576 /* Union */ || objectType.flags & 2097152 /* Intersection */ && !shouldDeferIndexType(objectType)) {
|
|
const types = map(objectType.types, (t) => getSimplifiedType(getIndexedAccessType(t, indexType), writing));
|
|
return objectType.flags & 2097152 /* Intersection */ || writing ? getIntersectionType(types) : getUnionType(types);
|
|
}
|
|
}
|
|
function distributeObjectOverIndexType(objectType, indexType, writing) {
|
|
if (indexType.flags & 1048576 /* Union */) {
|
|
const types = map(indexType.types, (t) => getSimplifiedType(getIndexedAccessType(objectType, t), writing));
|
|
return writing ? getIntersectionType(types) : getUnionType(types);
|
|
}
|
|
}
|
|
function getSimplifiedIndexedAccessType(type, writing) {
|
|
const cache = writing ? "simplifiedForWriting" : "simplifiedForReading";
|
|
if (type[cache]) {
|
|
return type[cache] === circularConstraintType ? type : type[cache];
|
|
}
|
|
type[cache] = circularConstraintType;
|
|
const objectType = getSimplifiedType(type.objectType, writing);
|
|
const indexType = getSimplifiedType(type.indexType, writing);
|
|
const distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing);
|
|
if (distributedOverIndex) {
|
|
return type[cache] = distributedOverIndex;
|
|
}
|
|
if (!(indexType.flags & 465829888 /* Instantiable */)) {
|
|
const distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing);
|
|
if (distributedOverObject) {
|
|
return type[cache] = distributedOverObject;
|
|
}
|
|
}
|
|
if (isGenericTupleType(objectType) && indexType.flags & 296 /* NumberLike */) {
|
|
const elementType = getElementTypeOfSliceOfTupleType(objectType, indexType.flags & 8 /* Number */ ? 0 : objectType.target.fixedLength, 0, writing);
|
|
if (elementType) {
|
|
return type[cache] = elementType;
|
|
}
|
|
}
|
|
if (isGenericMappedType(objectType)) {
|
|
const nameType = getNameTypeFromMappedType(objectType);
|
|
if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) {
|
|
return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), (t) => getSimplifiedType(t, writing));
|
|
}
|
|
}
|
|
return type[cache] = type;
|
|
}
|
|
function getSimplifiedConditionalType(type, writing) {
|
|
const checkType = type.checkType;
|
|
const extendsType = type.extendsType;
|
|
const trueType2 = getTrueTypeFromConditionalType(type);
|
|
const falseType2 = getFalseTypeFromConditionalType(type);
|
|
if (falseType2.flags & 131072 /* Never */ && getActualTypeVariable(trueType2) === getActualTypeVariable(checkType)) {
|
|
if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
|
|
return getSimplifiedType(trueType2, writing);
|
|
} else if (isIntersectionEmpty(checkType, extendsType)) {
|
|
return neverType;
|
|
}
|
|
} else if (trueType2.flags & 131072 /* Never */ && getActualTypeVariable(falseType2) === getActualTypeVariable(checkType)) {
|
|
if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {
|
|
return neverType;
|
|
} else if (checkType.flags & 1 /* Any */ || isIntersectionEmpty(checkType, extendsType)) {
|
|
return getSimplifiedType(falseType2, writing);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function isIntersectionEmpty(type1, type2) {
|
|
return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072 /* Never */);
|
|
}
|
|
function substituteIndexedMappedType(objectType, index) {
|
|
const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
|
|
const templateMapper = combineTypeMappers(objectType.mapper, mapper);
|
|
return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
|
|
}
|
|
function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
|
|
return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
|
|
}
|
|
function indexTypeLessThan(indexType, limit) {
|
|
return everyType(indexType, (t) => {
|
|
if (t.flags & 384 /* StringOrNumberLiteral */) {
|
|
const propName = getPropertyNameFromType(t);
|
|
if (isNumericLiteralName(propName)) {
|
|
const index = +propName;
|
|
return index >= 0 && index < limit;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
|
|
if (objectType === wildcardType || indexType === wildcardType) {
|
|
return wildcardType;
|
|
}
|
|
if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
|
|
indexType = stringType;
|
|
}
|
|
if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
|
|
accessFlags |= 1 /* IncludeUndefined */;
|
|
if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 196 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
|
|
if (objectType.flags & 3 /* AnyOrUnknown */) {
|
|
return objectType;
|
|
}
|
|
const persistentAccessFlags = accessFlags & 1 /* Persistent */;
|
|
const id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let type = indexedAccessTypes.get(id);
|
|
if (!type) {
|
|
indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments));
|
|
}
|
|
return type;
|
|
}
|
|
const apparentObjectType = getReducedApparentType(objectType);
|
|
if (indexType.flags & 1048576 /* Union */ && !(indexType.flags & 16 /* Boolean */)) {
|
|
const propTypes = [];
|
|
let wasMissingProp = false;
|
|
for (const t of indexType.types) {
|
|
const propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, accessNode, accessFlags | (wasMissingProp ? 128 /* SuppressNoImplicitAnyError */ : 0));
|
|
if (propType) {
|
|
propTypes.push(propType);
|
|
} else if (!accessNode) {
|
|
return void 0;
|
|
} else {
|
|
wasMissingProp = true;
|
|
}
|
|
}
|
|
if (wasMissingProp) {
|
|
return void 0;
|
|
}
|
|
return accessFlags & 4 /* Writing */ ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments) : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* CacheSymbol */ | 64 /* ReportDeprecated */);
|
|
}
|
|
function getTypeFromIndexedAccessTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const objectType = getTypeFromTypeNode(node.objectType);
|
|
const indexType = getTypeFromTypeNode(node.indexType);
|
|
const potentialAlias = getAliasSymbolForTypeNode(node);
|
|
links.resolvedType = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromMappedTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const type = createObjectType(32 /* Mapped */, node.symbol);
|
|
type.declaration = node;
|
|
type.aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol);
|
|
links.resolvedType = type;
|
|
getConstraintTypeFromMappedType(type);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getActualTypeVariable(type) {
|
|
if (type.flags & 33554432 /* Substitution */) {
|
|
return type.baseType;
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */ && (type.objectType.flags & 33554432 /* Substitution */ || type.indexType.flags & 33554432 /* Substitution */)) {
|
|
return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType));
|
|
}
|
|
return type;
|
|
}
|
|
function maybeCloneTypeParameter(p) {
|
|
const constraint = getConstraintOfTypeParameter(p);
|
|
return constraint && (isGenericObjectType(constraint) || isGenericIndexType(constraint)) ? cloneTypeParameter(p) : p;
|
|
}
|
|
function isTypicalNondistributiveConditional(root) {
|
|
return !root.isDistributive && isSingletonTupleType(root.node.checkType) && isSingletonTupleType(root.node.extendsType);
|
|
}
|
|
function isSingletonTupleType(node) {
|
|
return isTupleTypeNode(node) && length(node.elements) === 1 && !isOptionalTypeNode(node.elements[0]) && !isRestTypeNode(node.elements[0]) && !(isNamedTupleMember(node.elements[0]) && (node.elements[0].questionToken || node.elements[0].dotDotDotToken));
|
|
}
|
|
function unwrapNondistributiveConditionalTuple(root, type) {
|
|
return isTypicalNondistributiveConditional(root) && isTupleType(type) ? getTypeArguments(type)[0] : type;
|
|
}
|
|
function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) {
|
|
let result;
|
|
let extraTypes;
|
|
let tailCount = 0;
|
|
while (true) {
|
|
if (tailCount === 1e3) {
|
|
error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
|
|
result = errorType;
|
|
break;
|
|
}
|
|
const isUnwrapped = isTypicalNondistributiveConditional(root);
|
|
const checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
|
|
const checkTypeInstantiable = isGenericType(checkType);
|
|
const extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
|
|
if (checkType === wildcardType || extendsType === wildcardType) {
|
|
return wildcardType;
|
|
}
|
|
let combinedMapper;
|
|
if (root.inferTypeParameters) {
|
|
const freshParams = sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
|
|
const freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : void 0;
|
|
const context = createInferenceContext(freshParams, void 0, 0 /* None */);
|
|
if (freshMapper) {
|
|
const freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
|
|
for (const p of freshParams) {
|
|
if (root.inferTypeParameters.indexOf(p) === -1) {
|
|
p.mapper = freshCombinedMapper;
|
|
}
|
|
}
|
|
}
|
|
if (!checkTypeInstantiable) {
|
|
inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
|
|
}
|
|
const innerMapper = combineTypeMappers(freshMapper, context.mapper);
|
|
combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
|
|
}
|
|
const inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType;
|
|
if (!checkTypeInstantiable && !isGenericType(inferredExtendsType)) {
|
|
if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ && !isUnwrapped || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
|
|
if (checkType.flags & 1 /* Any */ && !isUnwrapped) {
|
|
(extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper));
|
|
}
|
|
const falseType2 = getTypeFromTypeNode(root.node.falseType);
|
|
if (falseType2.flags & 16777216 /* Conditional */) {
|
|
const newRoot = falseType2.root;
|
|
if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
|
|
root = newRoot;
|
|
continue;
|
|
}
|
|
if (canTailRecurse(falseType2, mapper)) {
|
|
continue;
|
|
}
|
|
}
|
|
result = instantiateType(falseType2, mapper);
|
|
break;
|
|
}
|
|
if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
|
|
const trueType2 = getTypeFromTypeNode(root.node.trueType);
|
|
const trueMapper = combinedMapper || mapper;
|
|
if (canTailRecurse(trueType2, trueMapper)) {
|
|
continue;
|
|
}
|
|
result = instantiateType(trueType2, trueMapper);
|
|
break;
|
|
}
|
|
}
|
|
result = createType(16777216 /* Conditional */);
|
|
result.root = root;
|
|
result.checkType = instantiateType(root.checkType, mapper);
|
|
result.extendsType = instantiateType(root.extendsType, mapper);
|
|
result.mapper = mapper;
|
|
result.combinedMapper = combinedMapper;
|
|
result.aliasSymbol = aliasSymbol || root.aliasSymbol;
|
|
result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper);
|
|
break;
|
|
}
|
|
return extraTypes ? getUnionType(append(extraTypes, result)) : result;
|
|
function canTailRecurse(newType, newMapper) {
|
|
if (newType.flags & 16777216 /* Conditional */ && newMapper) {
|
|
const newRoot = newType.root;
|
|
if (newRoot.outerTypeParameters) {
|
|
const typeParamMapper = combineTypeMappers(newType.mapper, newMapper);
|
|
const typeArguments = map(newRoot.outerTypeParameters, (t) => getMappedType(t, typeParamMapper));
|
|
const newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments);
|
|
const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : void 0;
|
|
if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 /* Union */ | 131072 /* Never */))) {
|
|
root = newRoot;
|
|
mapper = newRootMapper;
|
|
aliasSymbol = void 0;
|
|
aliasTypeArguments = void 0;
|
|
if (newRoot.aliasSymbol) {
|
|
tailCount++;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getTrueTypeFromConditionalType(type) {
|
|
return type.resolvedTrueType || (type.resolvedTrueType = instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.mapper));
|
|
}
|
|
function getFalseTypeFromConditionalType(type) {
|
|
return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(getTypeFromTypeNode(type.root.node.falseType), type.mapper));
|
|
}
|
|
function getInferredTrueTypeFromConditionalType(type) {
|
|
return type.resolvedInferredTrueType || (type.resolvedInferredTrueType = type.combinedMapper ? instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.combinedMapper) : getTrueTypeFromConditionalType(type));
|
|
}
|
|
function getInferTypeParameters(node) {
|
|
let result;
|
|
if (node.locals) {
|
|
node.locals.forEach((symbol) => {
|
|
if (symbol.flags & 262144 /* TypeParameter */) {
|
|
result = append(result, getDeclaredTypeOfSymbol(symbol));
|
|
}
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function isDistributionDependent(root) {
|
|
return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) || isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
|
|
}
|
|
function getTypeFromConditionalTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const checkType = getTypeFromTypeNode(node.checkType);
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
const aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
const allOuterTypeParameters = getOuterTypeParameters(node, true);
|
|
const outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : filter(allOuterTypeParameters, (tp) => isTypeParameterPossiblyReferenced(tp, node));
|
|
const root = {
|
|
node,
|
|
checkType,
|
|
extendsType: getTypeFromTypeNode(node.extendsType),
|
|
isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
|
|
inferTypeParameters: getInferTypeParameters(node),
|
|
outerTypeParameters,
|
|
instantiations: void 0,
|
|
aliasSymbol,
|
|
aliasTypeArguments
|
|
};
|
|
links.resolvedType = getConditionalType(root, void 0);
|
|
if (outerTypeParameters) {
|
|
root.instantiations = /* @__PURE__ */ new Map();
|
|
root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromInferTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getIdentifierChain(node) {
|
|
if (isIdentifier(node)) {
|
|
return [node];
|
|
} else {
|
|
return append(getIdentifierChain(node.left), node.right);
|
|
}
|
|
}
|
|
function getTypeFromImportTypeNode(node) {
|
|
var _a2;
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
if (node.isTypeOf && node.typeArguments) {
|
|
error(node, Diagnostics.Type_arguments_cannot_be_used_here);
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
if (!isLiteralImportTypeNode(node)) {
|
|
error(node.argument, Diagnostics.String_literal_expected);
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
const targetMeaning = node.isTypeOf ? 111551 /* Value */ : node.flags & 8388608 /* JSDoc */ ? 111551 /* Value */ | 788968 /* Type */ : 788968 /* Type */;
|
|
const innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal);
|
|
if (!innerModuleSymbol) {
|
|
links.resolvedSymbol = unknownSymbol;
|
|
return links.resolvedType = errorType;
|
|
}
|
|
const isExportEquals = !!((_a2 = innerModuleSymbol.exports) == null ? void 0 : _a2.get("export=" /* ExportEquals */));
|
|
const moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, false);
|
|
if (!nodeIsMissing(node.qualifier)) {
|
|
const nameStack = getIdentifierChain(node.qualifier);
|
|
let currentNamespace = moduleSymbol;
|
|
let current;
|
|
while (current = nameStack.shift()) {
|
|
const meaning = nameStack.length ? 1920 /* Namespace */ : targetMeaning;
|
|
const mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace));
|
|
const symbolFromVariable = node.isTypeOf || isInJSFile(node) && isExportEquals ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText, false, true) : void 0;
|
|
const symbolFromModule = node.isTypeOf ? void 0 : getSymbol2(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning);
|
|
const next = symbolFromModule != null ? symbolFromModule : symbolFromVariable;
|
|
if (!next) {
|
|
error(current, Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), declarationNameToString(current));
|
|
return links.resolvedType = errorType;
|
|
}
|
|
getNodeLinks(current).resolvedSymbol = next;
|
|
getNodeLinks(current.parent).resolvedSymbol = next;
|
|
currentNamespace = next;
|
|
}
|
|
links.resolvedType = resolveImportSymbolType(node, links, currentNamespace, targetMeaning);
|
|
} else {
|
|
if (moduleSymbol.flags & targetMeaning) {
|
|
links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning);
|
|
} else {
|
|
const errorMessage = targetMeaning === 111551 /* Value */ ? Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here : Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0;
|
|
error(node, errorMessage, node.argument.literal.text);
|
|
links.resolvedSymbol = unknownSymbol;
|
|
links.resolvedType = errorType;
|
|
}
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function resolveImportSymbolType(node, links, symbol, meaning) {
|
|
const resolvedSymbol = resolveSymbol(symbol);
|
|
links.resolvedSymbol = resolvedSymbol;
|
|
if (meaning === 111551 /* Value */) {
|
|
return getTypeOfSymbol(symbol);
|
|
} else {
|
|
return getTypeReferenceType(node, resolvedSymbol);
|
|
}
|
|
}
|
|
function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const aliasSymbol = getAliasSymbolForTypeNode(node);
|
|
if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) {
|
|
links.resolvedType = emptyTypeLiteralType;
|
|
} else {
|
|
let type = createObjectType(16 /* Anonymous */, node.symbol);
|
|
type.aliasSymbol = aliasSymbol;
|
|
type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
|
|
if (isJSDocTypeLiteral(node) && node.isArrayType) {
|
|
type = createArrayType(type);
|
|
}
|
|
links.resolvedType = type;
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getAliasSymbolForTypeNode(node) {
|
|
let host2 = node.parent;
|
|
while (isParenthesizedTypeNode(host2) || isJSDocTypeExpression(host2) || isTypeOperatorNode(host2) && host2.operator === 146 /* ReadonlyKeyword */) {
|
|
host2 = host2.parent;
|
|
}
|
|
return isTypeAlias(host2) ? getSymbolOfNode(host2) : void 0;
|
|
}
|
|
function getTypeArgumentsForAliasSymbol(symbol) {
|
|
return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : void 0;
|
|
}
|
|
function isNonGenericObjectType(type) {
|
|
return !!(type.flags & 524288 /* Object */) && !isGenericMappedType(type);
|
|
}
|
|
function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) {
|
|
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.flags & 1048576 /* Union */)) {
|
|
return type;
|
|
}
|
|
if (every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) {
|
|
return find(type.types, isEmptyObjectType) || emptyObjectType;
|
|
}
|
|
const firstType = find(type.types, (t) => !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t));
|
|
if (!firstType) {
|
|
return type;
|
|
}
|
|
const secondType = find(type.types, (t) => t !== firstType && !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t));
|
|
if (secondType) {
|
|
return type;
|
|
}
|
|
return getAnonymousPartialType(firstType);
|
|
function getAnonymousPartialType(type2) {
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfType(type2)) {
|
|
if (getDeclarationModifierFlagsFromSymbol(prop) & (8 /* Private */ | 16 /* Protected */)) {
|
|
} else if (isSpreadableProperty(prop)) {
|
|
const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
const flags = 4 /* Property */ | 16777216 /* Optional */;
|
|
const result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* Readonly */ : 0));
|
|
result.type = isSetonlyAccessor ? undefinedType : addOptionality(getTypeOfSymbol(prop), true);
|
|
result.declarations = prop.declarations;
|
|
result.nameType = getSymbolLinks(prop).nameType;
|
|
result.syntheticOrigin = prop;
|
|
members.set(prop.escapedName, result);
|
|
}
|
|
}
|
|
const spread = createAnonymousType(type2.symbol, members, emptyArray, emptyArray, getIndexInfosOfType(type2));
|
|
spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
return spread;
|
|
}
|
|
}
|
|
function getSpreadType(left, right, symbol, objectFlags, readonly) {
|
|
if (left.flags & 1 /* Any */ || right.flags & 1 /* Any */) {
|
|
return anyType;
|
|
}
|
|
if (left.flags & 2 /* Unknown */ || right.flags & 2 /* Unknown */) {
|
|
return unknownType;
|
|
}
|
|
if (left.flags & 131072 /* Never */) {
|
|
return right;
|
|
}
|
|
if (right.flags & 131072 /* Never */) {
|
|
return left;
|
|
}
|
|
left = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly);
|
|
if (left.flags & 1048576 /* Union */) {
|
|
return checkCrossProductUnion([left, right]) ? mapType(left, (t) => getSpreadType(t, right, symbol, objectFlags, readonly)) : errorType;
|
|
}
|
|
right = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly);
|
|
if (right.flags & 1048576 /* Union */) {
|
|
return checkCrossProductUnion([left, right]) ? mapType(right, (t) => getSpreadType(left, t, symbol, objectFlags, readonly)) : errorType;
|
|
}
|
|
if (right.flags & (528 /* BooleanLike */ | 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 1056 /* EnumLike */ | 67108864 /* NonPrimitive */ | 4194304 /* Index */)) {
|
|
return left;
|
|
}
|
|
if (isGenericObjectType(left) || isGenericObjectType(right)) {
|
|
if (isEmptyObjectType(left)) {
|
|
return right;
|
|
}
|
|
if (left.flags & 2097152 /* Intersection */) {
|
|
const types = left.types;
|
|
const lastLeft = types[types.length - 1];
|
|
if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) {
|
|
return getIntersectionType(concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)]));
|
|
}
|
|
}
|
|
return getIntersectionType([left, right]);
|
|
}
|
|
const members = createSymbolTable();
|
|
const skippedPrivateMembers = /* @__PURE__ */ new Set();
|
|
const indexInfos = left === emptyObjectType ? getIndexInfosOfType(right) : getUnionIndexInfos([left, right]);
|
|
for (const rightProp of getPropertiesOfType(right)) {
|
|
if (getDeclarationModifierFlagsFromSymbol(rightProp) & (8 /* Private */ | 16 /* Protected */)) {
|
|
skippedPrivateMembers.add(rightProp.escapedName);
|
|
} else if (isSpreadableProperty(rightProp)) {
|
|
members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly));
|
|
}
|
|
}
|
|
for (const leftProp of getPropertiesOfType(left)) {
|
|
if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) {
|
|
continue;
|
|
}
|
|
if (members.has(leftProp.escapedName)) {
|
|
const rightProp = members.get(leftProp.escapedName);
|
|
const rightType = getTypeOfSymbol(rightProp);
|
|
if (rightProp.flags & 16777216 /* Optional */) {
|
|
const declarations = concatenate(leftProp.declarations, rightProp.declarations);
|
|
const flags = 4 /* Property */ | leftProp.flags & 16777216 /* Optional */;
|
|
const result = createSymbol(flags, leftProp.escapedName);
|
|
result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* Subtype */);
|
|
result.leftSpread = leftProp;
|
|
result.rightSpread = rightProp;
|
|
result.declarations = declarations;
|
|
result.nameType = getSymbolLinks(leftProp).nameType;
|
|
members.set(leftProp.escapedName, result);
|
|
}
|
|
} else {
|
|
members.set(leftProp.escapedName, getSpreadSymbol(leftProp, readonly));
|
|
}
|
|
}
|
|
const spread = createAnonymousType(symbol, members, emptyArray, emptyArray, sameMap(indexInfos, (info) => getIndexInfoWithReadonly(info, readonly)));
|
|
spread.objectFlags |= 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */ | 2097152 /* ContainsSpread */ | objectFlags;
|
|
return spread;
|
|
}
|
|
function isSpreadableProperty(prop) {
|
|
var _a2;
|
|
return !some(prop.declarations, isPrivateIdentifierClassElementDeclaration) && (!(prop.flags & (8192 /* Method */ | 32768 /* GetAccessor */ | 65536 /* SetAccessor */)) || !((_a2 = prop.declarations) == null ? void 0 : _a2.some((decl) => isClassLike(decl.parent))));
|
|
}
|
|
function getSpreadSymbol(prop, readonly) {
|
|
const isSetonlyAccessor = prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) {
|
|
return prop;
|
|
}
|
|
const flags = 4 /* Property */ | prop.flags & 16777216 /* Optional */;
|
|
const 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;
|
|
result.syntheticOrigin = prop;
|
|
return result;
|
|
}
|
|
function getIndexInfoWithReadonly(info, readonly) {
|
|
return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info;
|
|
}
|
|
function createLiteralType(flags, value, symbol, regularType) {
|
|
const type = createTypeWithSymbol(flags, symbol);
|
|
type.value = value;
|
|
type.regularType = regularType || type;
|
|
return type;
|
|
}
|
|
function getFreshTypeOfLiteralType(type) {
|
|
if (type.flags & 2944 /* Literal */) {
|
|
if (!type.freshType) {
|
|
const freshType = createLiteralType(type.flags, type.value, type.symbol, type);
|
|
freshType.freshType = freshType;
|
|
type.freshType = freshType;
|
|
}
|
|
return type.freshType;
|
|
}
|
|
return type;
|
|
}
|
|
function getRegularTypeOfLiteralType(type) {
|
|
return type.flags & 2944 /* Literal */ ? type.regularType : type.flags & 1048576 /* Union */ ? type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType)) : type;
|
|
}
|
|
function isFreshLiteralType(type) {
|
|
return !!(type.flags & 2944 /* Literal */) && type.freshType === type;
|
|
}
|
|
function getStringLiteralType(value) {
|
|
let type;
|
|
return stringLiteralTypes.get(value) || (stringLiteralTypes.set(value, type = createLiteralType(128 /* StringLiteral */, value)), type);
|
|
}
|
|
function getNumberLiteralType(value) {
|
|
let type;
|
|
return numberLiteralTypes.get(value) || (numberLiteralTypes.set(value, type = createLiteralType(256 /* NumberLiteral */, value)), type);
|
|
}
|
|
function getBigIntLiteralType(value) {
|
|
let type;
|
|
const key = pseudoBigIntToString(value);
|
|
return bigIntLiteralTypes.get(key) || (bigIntLiteralTypes.set(key, type = createLiteralType(2048 /* BigIntLiteral */, value)), type);
|
|
}
|
|
function getEnumLiteralType(value, enumId, symbol) {
|
|
let type;
|
|
const key = `${enumId}${typeof value === "string" ? "@" : "#"}${value}`;
|
|
const flags = 1024 /* EnumLiteral */ | (typeof value === "string" ? 128 /* StringLiteral */ : 256 /* NumberLiteral */);
|
|
return enumLiteralTypes.get(key) || (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type);
|
|
}
|
|
function getTypeFromLiteralTypeNode(node) {
|
|
if (node.literal.kind === 104 /* NullKeyword */) {
|
|
return nullType;
|
|
}
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal));
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function createUniqueESSymbolType(symbol) {
|
|
const type = createTypeWithSymbol(8192 /* UniqueESSymbol */, symbol);
|
|
type.escapedName = `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}`;
|
|
return type;
|
|
}
|
|
function getESSymbolLikeTypeForNode(node) {
|
|
if (isValidESSymbolDeclaration(node)) {
|
|
const symbol = isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node);
|
|
if (symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol));
|
|
}
|
|
}
|
|
return esSymbolType;
|
|
}
|
|
function getThisType(node) {
|
|
const container = getThisContainer(node, false);
|
|
const parent2 = container && container.parent;
|
|
if (parent2 && (isClassLike(parent2) || parent2.kind === 261 /* InterfaceDeclaration */)) {
|
|
if (!isStatic(container) && (!isConstructorDeclaration(container) || isNodeDescendantOf(node, container.body))) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent2)).thisType;
|
|
}
|
|
}
|
|
if (parent2 && isObjectLiteralExpression(parent2) && isBinaryExpression(parent2.parent) && getAssignmentDeclarationKind(parent2.parent) === 6 /* Prototype */) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent2.parent.left).parent).thisType;
|
|
}
|
|
const host2 = node.flags & 8388608 /* JSDoc */ ? getHostSignatureFromJSDoc(node) : void 0;
|
|
if (host2 && isFunctionExpression(host2) && isBinaryExpression(host2.parent) && getAssignmentDeclarationKind(host2.parent) === 3 /* PrototypeProperty */) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host2.parent.left).parent).thisType;
|
|
}
|
|
if (isJSConstructor(container) && isNodeDescendantOf(node, container.body)) {
|
|
return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType;
|
|
}
|
|
error(node, Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface);
|
|
return errorType;
|
|
}
|
|
function getTypeFromThisTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
links.resolvedType = getThisType(node);
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function getTypeFromRestTypeNode(node) {
|
|
return getTypeFromTypeNode(getArrayElementTypeNode(node.type) || node.type);
|
|
}
|
|
function getArrayElementTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 193 /* ParenthesizedType */:
|
|
return getArrayElementTypeNode(node.type);
|
|
case 186 /* TupleType */:
|
|
if (node.elements.length === 1) {
|
|
node = node.elements[0];
|
|
if (node.kind === 188 /* RestType */ || node.kind === 199 /* NamedTupleMember */ && node.dotDotDotToken) {
|
|
return getArrayElementTypeNode(node.type);
|
|
}
|
|
}
|
|
break;
|
|
case 185 /* ArrayType */:
|
|
return node.elementType;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeFromNamedTupleTypeNode(node) {
|
|
const links = getNodeLinks(node);
|
|
return links.resolvedType || (links.resolvedType = node.dotDotDotToken ? getTypeFromRestTypeNode(node) : addOptionality(getTypeFromTypeNode(node.type), true, !!node.questionToken));
|
|
}
|
|
function getTypeFromTypeNode(node) {
|
|
return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node);
|
|
}
|
|
function getTypeFromTypeNodeWorker(node) {
|
|
switch (node.kind) {
|
|
case 131 /* AnyKeyword */:
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
return anyType;
|
|
case 157 /* UnknownKeyword */:
|
|
return unknownType;
|
|
case 152 /* StringKeyword */:
|
|
return stringType;
|
|
case 148 /* NumberKeyword */:
|
|
return numberType;
|
|
case 160 /* BigIntKeyword */:
|
|
return bigintType;
|
|
case 134 /* BooleanKeyword */:
|
|
return booleanType;
|
|
case 153 /* SymbolKeyword */:
|
|
return esSymbolType;
|
|
case 114 /* VoidKeyword */:
|
|
return voidType;
|
|
case 155 /* UndefinedKeyword */:
|
|
return undefinedType;
|
|
case 104 /* NullKeyword */:
|
|
return nullType;
|
|
case 144 /* NeverKeyword */:
|
|
return neverType;
|
|
case 149 /* ObjectKeyword */:
|
|
return node.flags & 262144 /* JavaScriptFile */ && !noImplicitAny ? anyType : nonPrimitiveType;
|
|
case 139 /* IntrinsicKeyword */:
|
|
return intrinsicMarkerType;
|
|
case 194 /* ThisType */:
|
|
case 108 /* ThisKeyword */:
|
|
return getTypeFromThisTypeNode(node);
|
|
case 198 /* LiteralType */:
|
|
return getTypeFromLiteralTypeNode(node);
|
|
case 180 /* TypeReference */:
|
|
return getTypeFromTypeReference(node);
|
|
case 179 /* TypePredicate */:
|
|
return node.assertsModifier ? voidType : booleanType;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return getTypeFromTypeReference(node);
|
|
case 183 /* TypeQuery */:
|
|
return getTypeFromTypeQueryNode(node);
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return getTypeFromArrayOrTupleTypeNode(node);
|
|
case 187 /* OptionalType */:
|
|
return getTypeFromOptionalTypeNode(node);
|
|
case 189 /* UnionType */:
|
|
return getTypeFromUnionTypeNode(node);
|
|
case 190 /* IntersectionType */:
|
|
return getTypeFromIntersectionTypeNode(node);
|
|
case 317 /* JSDocNullableType */:
|
|
return getTypeFromJSDocNullableTypeNode(node);
|
|
case 319 /* JSDocOptionalType */:
|
|
return addOptionality(getTypeFromTypeNode(node.type));
|
|
case 199 /* NamedTupleMember */:
|
|
return getTypeFromNamedTupleTypeNode(node);
|
|
case 193 /* ParenthesizedType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 312 /* JSDocTypeExpression */:
|
|
return getTypeFromTypeNode(node.type);
|
|
case 188 /* RestType */:
|
|
return getTypeFromRestTypeNode(node);
|
|
case 321 /* JSDocVariadicType */:
|
|
return getTypeFromJSDocVariadicType(node);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 326 /* JSDocSignature */:
|
|
return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
|
|
case 195 /* TypeOperator */:
|
|
return getTypeFromTypeOperatorNode(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return getTypeFromIndexedAccessTypeNode(node);
|
|
case 197 /* MappedType */:
|
|
return getTypeFromMappedTypeNode(node);
|
|
case 191 /* ConditionalType */:
|
|
return getTypeFromConditionalTypeNode(node);
|
|
case 192 /* InferType */:
|
|
return getTypeFromInferTypeNode(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return getTypeFromTemplateTypeNode(node);
|
|
case 202 /* ImportType */:
|
|
return getTypeFromImportTypeNode(node);
|
|
case 79 /* Identifier */:
|
|
case 163 /* QualifiedName */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
const symbol = getSymbolAtLocation(node);
|
|
return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
|
|
default:
|
|
return errorType;
|
|
}
|
|
}
|
|
function instantiateList(items, mapper, instantiator) {
|
|
if (items && items.length) {
|
|
for (let i = 0; i < items.length; i++) {
|
|
const item = items[i];
|
|
const mapped = instantiator(item, mapper);
|
|
if (item !== mapped) {
|
|
const result = i === 0 ? [] : items.slice(0, i);
|
|
result.push(mapped);
|
|
for (i++; i < items.length; i++) {
|
|
result.push(instantiator(items[i], mapper));
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
function instantiateTypes(types, mapper) {
|
|
return instantiateList(types, mapper, instantiateType);
|
|
}
|
|
function instantiateSignatures(signatures, mapper) {
|
|
return instantiateList(signatures, mapper, instantiateSignature);
|
|
}
|
|
function instantiateIndexInfos(indexInfos, mapper) {
|
|
return instantiateList(indexInfos, mapper, instantiateIndexInfo);
|
|
}
|
|
function createTypeMapper(sources, targets) {
|
|
return sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) : makeArrayTypeMapper(sources, targets);
|
|
}
|
|
function getMappedType(type, mapper) {
|
|
switch (mapper.kind) {
|
|
case 0 /* Simple */:
|
|
return type === mapper.source ? mapper.target : type;
|
|
case 1 /* Array */: {
|
|
const sources = mapper.sources;
|
|
const targets = mapper.targets;
|
|
for (let i = 0; i < sources.length; i++) {
|
|
if (type === sources[i]) {
|
|
return targets ? targets[i] : anyType;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
case 2 /* Deferred */: {
|
|
const sources = mapper.sources;
|
|
const targets = mapper.targets;
|
|
for (let i = 0; i < sources.length; i++) {
|
|
if (type === sources[i]) {
|
|
return targets[i]();
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
case 3 /* Function */:
|
|
return mapper.func(type);
|
|
case 4 /* Composite */:
|
|
case 5 /* Merged */:
|
|
const t1 = getMappedType(type, mapper.mapper1);
|
|
return t1 !== type && mapper.kind === 4 /* Composite */ ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2);
|
|
}
|
|
}
|
|
function makeUnaryTypeMapper(source, target) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 0 /* Simple */, source, target });
|
|
}
|
|
function makeArrayTypeMapper(sources, targets) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 1 /* Array */, sources, targets });
|
|
}
|
|
function makeFunctionTypeMapper(func, debugInfo) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 3 /* Function */, func, debugInfo: Debug.isDebugging ? debugInfo : void 0 });
|
|
}
|
|
function makeDeferredTypeMapper(sources, targets) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind: 2 /* Deferred */, sources, targets });
|
|
}
|
|
function makeCompositeTypeMapper(kind, mapper1, mapper2) {
|
|
return Debug.attachDebugPrototypeIfDebug({ kind, mapper1, mapper2 });
|
|
}
|
|
function createTypeEraser(sources) {
|
|
return createTypeMapper(sources, void 0);
|
|
}
|
|
function createBackreferenceMapper(context, index) {
|
|
const forwardInferences = context.inferences.slice(index);
|
|
return createTypeMapper(map(forwardInferences, (i) => i.typeParameter), map(forwardInferences, () => unknownType));
|
|
}
|
|
function combineTypeMappers(mapper1, mapper2) {
|
|
return mapper1 ? makeCompositeTypeMapper(4 /* Composite */, mapper1, mapper2) : mapper2;
|
|
}
|
|
function mergeTypeMappers(mapper1, mapper2) {
|
|
return mapper1 ? makeCompositeTypeMapper(5 /* Merged */, mapper1, mapper2) : mapper2;
|
|
}
|
|
function prependTypeMapping(source, target, mapper) {
|
|
return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* Merged */, makeUnaryTypeMapper(source, target), mapper);
|
|
}
|
|
function appendTypeMapping(mapper, source, target) {
|
|
return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* Merged */, mapper, makeUnaryTypeMapper(source, target));
|
|
}
|
|
function getRestrictiveTypeParameter(tp) {
|
|
return !tp.constraint && !getConstraintDeclaration(tp) || tp.constraint === noConstraintType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol), tp.restrictiveInstantiation.constraint = noConstraintType, tp.restrictiveInstantiation);
|
|
}
|
|
function cloneTypeParameter(typeParameter) {
|
|
const result = createTypeParameter(typeParameter.symbol);
|
|
result.target = typeParameter;
|
|
return result;
|
|
}
|
|
function instantiateTypePredicate(predicate, mapper) {
|
|
return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper));
|
|
}
|
|
function instantiateSignature(signature, mapper, eraseTypeParameters) {
|
|
let freshTypeParameters;
|
|
if (signature.typeParameters && !eraseTypeParameters) {
|
|
freshTypeParameters = map(signature.typeParameters, cloneTypeParameter);
|
|
mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper);
|
|
for (const tp of freshTypeParameters) {
|
|
tp.mapper = mapper;
|
|
}
|
|
}
|
|
const result = createSignature(
|
|
signature.declaration,
|
|
freshTypeParameters,
|
|
signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper),
|
|
instantiateList(signature.parameters, mapper, instantiateSymbol),
|
|
void 0,
|
|
void 0,
|
|
signature.minArgumentCount,
|
|
signature.flags & 39 /* PropagatingFlags */
|
|
);
|
|
result.target = signature;
|
|
result.mapper = mapper;
|
|
return result;
|
|
}
|
|
function instantiateSymbol(symbol, mapper) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.type && !couldContainTypeVariables(links.type)) {
|
|
return symbol;
|
|
}
|
|
if (getCheckFlags(symbol) & 1 /* Instantiated */) {
|
|
symbol = links.target;
|
|
mapper = combineTypeMappers(links.mapper, mapper);
|
|
}
|
|
const result = createSymbol(symbol.flags, symbol.escapedName, 1 /* Instantiated */ | getCheckFlags(symbol) & (8 /* Readonly */ | 4096 /* Late */ | 16384 /* OptionalParameter */ | 32768 /* RestParameter */));
|
|
result.declarations = symbol.declarations;
|
|
result.parent = symbol.parent;
|
|
result.target = symbol;
|
|
result.mapper = mapper;
|
|
if (symbol.valueDeclaration) {
|
|
result.valueDeclaration = symbol.valueDeclaration;
|
|
}
|
|
if (links.nameType) {
|
|
result.nameType = links.nameType;
|
|
}
|
|
return result;
|
|
}
|
|
function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
|
|
const links = getNodeLinks(declaration);
|
|
const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
|
|
let typeParameters = links.outerTypeParameters;
|
|
if (!typeParameters) {
|
|
let outerTypeParameters = getOuterTypeParameters(declaration, true);
|
|
if (isJSConstructor(declaration)) {
|
|
const templateTagParameters = getTypeParametersFromDeclaration(declaration);
|
|
outerTypeParameters = addRange(outerTypeParameters, templateTagParameters);
|
|
}
|
|
typeParameters = outerTypeParameters || emptyArray;
|
|
const allDeclarations = type.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
|
|
typeParameters = (target.objectFlags & (4 /* Reference */ | 8388608 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ? filter(typeParameters, (tp) => some(allDeclarations, (d) => isTypeParameterPossiblyReferenced(tp, d))) : typeParameters;
|
|
links.outerTypeParameters = typeParameters;
|
|
}
|
|
if (typeParameters.length) {
|
|
const combinedMapper = combineTypeMappers(type.mapper, mapper);
|
|
const typeArguments = map(typeParameters, (t) => getMappedType(t, combinedMapper));
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
const id = getTypeListId(typeArguments) + getAliasId(newAliasSymbol, newAliasTypeArguments);
|
|
if (!target.instantiations) {
|
|
target.instantiations = /* @__PURE__ */ new Map();
|
|
target.instantiations.set(getTypeListId(typeParameters) + getAliasId(target.aliasSymbol, target.aliasTypeArguments), target);
|
|
}
|
|
let result = target.instantiations.get(id);
|
|
if (!result) {
|
|
const newMapper = createTypeMapper(typeParameters, typeArguments);
|
|
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;
|
|
}
|
|
return type;
|
|
}
|
|
function maybeTypeParameterReference(node) {
|
|
return !(node.parent.kind === 180 /* TypeReference */ && node.parent.typeArguments && node === node.parent.typeName || node.parent.kind === 202 /* ImportType */ && node.parent.typeArguments && node === node.parent.qualifier);
|
|
}
|
|
function isTypeParameterPossiblyReferenced(tp, node) {
|
|
if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) {
|
|
const container = tp.symbol.declarations[0].parent;
|
|
for (let n = node; n !== container; n = n.parent) {
|
|
if (!n || n.kind === 238 /* Block */ || n.kind === 191 /* ConditionalType */ && forEachChild(n.extendsType, containsReference)) {
|
|
return true;
|
|
}
|
|
}
|
|
return containsReference(node);
|
|
}
|
|
return true;
|
|
function containsReference(node2) {
|
|
switch (node2.kind) {
|
|
case 194 /* ThisType */:
|
|
return !!tp.isThisType;
|
|
case 79 /* Identifier */:
|
|
return !tp.isThisType && isPartOfTypeNode(node2) && maybeTypeParameterReference(node2) && getTypeFromTypeNodeWorker(node2) === tp;
|
|
case 183 /* TypeQuery */:
|
|
const entityName = node2.exprName;
|
|
const firstIdentifier = getFirstIdentifier(entityName);
|
|
const firstIdentifierSymbol = getResolvedSymbol(firstIdentifier);
|
|
const tpDeclaration = tp.symbol.declarations[0];
|
|
let tpScope;
|
|
if (tpDeclaration.kind === 165 /* TypeParameter */) {
|
|
tpScope = tpDeclaration.parent;
|
|
} else if (tp.isThisType) {
|
|
tpScope = tpDeclaration;
|
|
} else {
|
|
return true;
|
|
}
|
|
if (firstIdentifierSymbol.declarations) {
|
|
return some(firstIdentifierSymbol.declarations, (idDecl) => isNodeDescendantOf(idDecl, tpScope)) || some(node2.typeArguments, containsReference);
|
|
}
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return !node2.type && !!node2.body || some(node2.typeParameters, containsReference) || some(node2.parameters, containsReference) || !!node2.type && containsReference(node2.type);
|
|
}
|
|
return !!forEachChild(node2, containsReference);
|
|
}
|
|
}
|
|
function getHomomorphicTypeVariable(type) {
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
if (constraintType.flags & 4194304 /* Index */) {
|
|
const typeVariable = getActualTypeVariable(constraintType.type);
|
|
if (typeVariable.flags & 262144 /* TypeParameter */) {
|
|
return typeVariable;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function instantiateMappedType(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const typeVariable = getHomomorphicTypeVariable(type);
|
|
if (typeVariable) {
|
|
const mappedTypeVariable = instantiateType(typeVariable, mapper);
|
|
if (typeVariable !== mappedTypeVariable) {
|
|
return mapTypeWithAlias(getReducedType(mappedTypeVariable), (t) => {
|
|
if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
|
|
if (!type.declaration.nameType) {
|
|
let constraint;
|
|
if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
|
|
return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
|
|
}
|
|
if (isGenericTupleType(t)) {
|
|
return instantiateMappedGenericTupleType(t, type, typeVariable, mapper);
|
|
}
|
|
if (isTupleType(t)) {
|
|
return instantiateMappedTupleType(t, type, prependTypeMapping(typeVariable, t, mapper));
|
|
}
|
|
}
|
|
return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
|
|
}
|
|
return t;
|
|
}, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
}
|
|
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;
|
|
}
|
|
function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) {
|
|
const elementFlags = tupleType.target.elementFlags;
|
|
const elementTypes = map(getTypeArguments(tupleType), (t, i) => {
|
|
const singleton = elementFlags[i] & 8 /* Variadic */ ? t : elementFlags[i] & 4 /* Rest */ ? createArrayType(t) : createTupleType([t], [elementFlags[i]]);
|
|
return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
|
|
});
|
|
const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType));
|
|
return createTupleType(elementTypes, map(elementTypes, (_) => 8 /* Variadic */), newReadonly);
|
|
}
|
|
function instantiateMappedArrayType(arrayType, mappedType, mapper) {
|
|
const elementType = instantiateMappedTypeTemplate(mappedType, numberType, true, mapper);
|
|
return isErrorType(elementType) ? errorType : createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType)));
|
|
}
|
|
function instantiateMappedTupleType(tupleType, mappedType, mapper) {
|
|
const elementFlags = tupleType.target.elementFlags;
|
|
const elementTypes = map(getTypeArguments(tupleType), (_, i) => instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* Optional */), mapper));
|
|
const modifiers = getMappedTypeModifiers(mappedType);
|
|
const newTupleModifiers = modifiers & 4 /* IncludeOptional */ ? map(elementFlags, (f) => f & 1 /* Required */ ? 2 /* Optional */ : f) : modifiers & 8 /* ExcludeOptional */ ? map(elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : elementFlags;
|
|
const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers);
|
|
return contains(elementTypes, errorType) ? errorType : createTupleType(elementTypes, newTupleModifiers, newReadonly, tupleType.target.labeledElementDeclarations);
|
|
}
|
|
function instantiateMappedTypeTemplate(type, key, isOptional, mapper) {
|
|
const templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key);
|
|
const propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper);
|
|
const modifiers = getMappedTypeModifiers(type);
|
|
return strictNullChecks && modifiers & 4 /* IncludeOptional */ && !maybeTypeOfKind(propType, 32768 /* Undefined */ | 16384 /* Void */) ? getOptionalType(propType, true) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
|
|
}
|
|
function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const result = createObjectType(type.objectFlags | 64 /* Instantiated */, type.symbol);
|
|
if (type.objectFlags & 32 /* Mapped */) {
|
|
result.declaration = type.declaration;
|
|
const origTypeParameter = getTypeParameterFromMappedType(type);
|
|
const freshTypeParameter = cloneTypeParameter(origTypeParameter);
|
|
result.typeParameter = freshTypeParameter;
|
|
mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
|
|
freshTypeParameter.mapper = mapper;
|
|
}
|
|
if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
|
|
result.node = type.node;
|
|
}
|
|
result.target = type;
|
|
result.mapper = mapper;
|
|
result.aliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0;
|
|
return result;
|
|
}
|
|
function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const root = type.root;
|
|
if (root.outerTypeParameters) {
|
|
const typeArguments = map(root.outerTypeParameters, (t) => getMappedType(t, mapper));
|
|
const id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments);
|
|
let result = root.instantiations.get(id);
|
|
if (!result) {
|
|
const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
|
|
const checkType = root.checkType;
|
|
const distributionType = root.isDistributive ? getMappedType(checkType, newMapper) : void 0;
|
|
result = distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapTypeWithAlias(getReducedType(distributionType), (t) => getConditionalType(root, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments) : getConditionalType(root, newMapper, aliasSymbol, aliasTypeArguments);
|
|
root.instantiations.set(id, result);
|
|
}
|
|
return result;
|
|
}
|
|
return type;
|
|
}
|
|
function instantiateType(type, mapper) {
|
|
return type && mapper ? instantiateTypeWithAlias(type, mapper, void 0, void 0) : type;
|
|
}
|
|
function instantiateTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
var _a2;
|
|
if (!couldContainTypeVariables(type)) {
|
|
return type;
|
|
}
|
|
if (instantiationDepth === 100 || instantiationCount >= 5e6) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth, instantiationCount });
|
|
error(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
|
|
return errorType;
|
|
}
|
|
totalInstantiationCount++;
|
|
instantiationCount++;
|
|
instantiationDepth++;
|
|
const result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments);
|
|
instantiationDepth--;
|
|
return result;
|
|
}
|
|
function instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
const flags = type.flags;
|
|
if (flags & 262144 /* TypeParameter */) {
|
|
return getMappedType(type, mapper);
|
|
}
|
|
if (flags & 524288 /* Object */) {
|
|
const objectFlags = type.objectFlags;
|
|
if (objectFlags & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */)) {
|
|
if (objectFlags & 4 /* Reference */ && !type.node) {
|
|
const resolvedTypeArguments = type.resolvedTypeArguments;
|
|
const newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper);
|
|
return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type;
|
|
}
|
|
if (objectFlags & 1024 /* ReverseMapped */) {
|
|
return instantiateReverseMappedType(type, mapper);
|
|
}
|
|
return getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments);
|
|
}
|
|
return type;
|
|
}
|
|
if (flags & 3145728 /* UnionOrIntersection */) {
|
|
const origin = type.flags & 1048576 /* Union */ ? type.origin : void 0;
|
|
const types = origin && origin.flags & 3145728 /* UnionOrIntersection */ ? origin.types : type.types;
|
|
const newTypes = instantiateTypes(types, mapper);
|
|
if (newTypes === types && aliasSymbol === type.aliasSymbol) {
|
|
return type;
|
|
}
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const 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));
|
|
}
|
|
if (flags & 134217728 /* TemplateLiteral */) {
|
|
return getTemplateLiteralType(type.texts, instantiateTypes(type.types, mapper));
|
|
}
|
|
if (flags & 268435456 /* StringMapping */) {
|
|
return getStringMappingType(type.symbol, instantiateType(type.type, mapper));
|
|
}
|
|
if (flags & 8388608 /* IndexedAccess */) {
|
|
const newAliasSymbol = aliasSymbol || type.aliasSymbol;
|
|
const newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
|
|
return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, void 0, newAliasSymbol, newAliasTypeArguments);
|
|
}
|
|
if (flags & 16777216 /* Conditional */) {
|
|
return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
|
|
}
|
|
if (flags & 33554432 /* Substitution */) {
|
|
const newBaseType = instantiateType(type.baseType, mapper);
|
|
const newConstraint = instantiateType(type.constraint, mapper);
|
|
if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
|
|
return getSubstitutionType(newBaseType, newConstraint);
|
|
}
|
|
if (newConstraint.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(newBaseType), getRestrictiveInstantiation(newConstraint))) {
|
|
return newBaseType;
|
|
}
|
|
return newBaseType.flags & 8650752 /* TypeVariable */ ? getSubstitutionType(newBaseType, newConstraint) : getIntersectionType([newConstraint, newBaseType]);
|
|
}
|
|
return type;
|
|
}
|
|
function instantiateReverseMappedType(type, mapper) {
|
|
const innerMappedType = instantiateType(type.mappedType, mapper);
|
|
if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
|
|
return type;
|
|
}
|
|
const innerIndexType = instantiateType(type.constraintType, mapper);
|
|
if (!(innerIndexType.flags & 4194304 /* Index */)) {
|
|
return type;
|
|
}
|
|
const instantiated = inferTypeForHomomorphicMappedType(
|
|
instantiateType(type.source, mapper),
|
|
innerMappedType,
|
|
innerIndexType
|
|
);
|
|
if (instantiated) {
|
|
return instantiated;
|
|
}
|
|
return type;
|
|
}
|
|
function getUniqueLiteralFilledInstantiation(type) {
|
|
return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
|
|
}
|
|
function getPermissiveInstantiation(type) {
|
|
return type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
|
|
}
|
|
function getRestrictiveInstantiation(type) {
|
|
if (type.flags & (131068 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */)) {
|
|
return type;
|
|
}
|
|
if (type.restrictiveInstantiation) {
|
|
return type.restrictiveInstantiation;
|
|
}
|
|
type.restrictiveInstantiation = instantiateType(type, restrictiveMapper);
|
|
type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation;
|
|
return type.restrictiveInstantiation;
|
|
}
|
|
function instantiateIndexInfo(info, mapper) {
|
|
return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration);
|
|
}
|
|
function isContextSensitive(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
switch (node.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return isContextSensitiveFunctionLikeDeclaration(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return some(node.properties, isContextSensitive);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return some(node.elements, isContextSensitive);
|
|
case 224 /* ConditionalExpression */:
|
|
return isContextSensitive(node.whenTrue) || isContextSensitive(node.whenFalse);
|
|
case 223 /* BinaryExpression */:
|
|
return (node.operatorToken.kind === 56 /* BarBarToken */ || node.operatorToken.kind === 60 /* QuestionQuestionToken */) && (isContextSensitive(node.left) || isContextSensitive(node.right));
|
|
case 299 /* PropertyAssignment */:
|
|
return isContextSensitive(node.initializer);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isContextSensitive(node.expression);
|
|
case 289 /* JsxAttributes */:
|
|
return some(node.properties, isContextSensitive) || isJsxOpeningElement(node.parent) && some(node.parent.parent.children, isContextSensitive);
|
|
case 288 /* JsxAttribute */: {
|
|
const { initializer } = node;
|
|
return !!initializer && isContextSensitive(initializer);
|
|
}
|
|
case 291 /* JsxExpression */: {
|
|
const { expression } = node;
|
|
return !!expression && isContextSensitive(expression);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isContextSensitiveFunctionLikeDeclaration(node) {
|
|
return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
|
|
}
|
|
function hasContextSensitiveReturnExpression(node) {
|
|
return !node.typeParameters && !getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 238 /* Block */ && isContextSensitive(node.body);
|
|
}
|
|
function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
|
|
return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);
|
|
}
|
|
function getTypeWithoutSignatures(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
if (resolved.constructSignatures.length || resolved.callSignatures.length) {
|
|
const result = createObjectType(16 /* Anonymous */, type.symbol);
|
|
result.members = resolved.members;
|
|
result.properties = resolved.properties;
|
|
result.callSignatures = emptyArray;
|
|
result.constructSignatures = emptyArray;
|
|
result.indexInfos = emptyArray;
|
|
return result;
|
|
}
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(map(type.types, getTypeWithoutSignatures));
|
|
}
|
|
return type;
|
|
}
|
|
function isTypeIdenticalTo(source, target) {
|
|
return isTypeRelatedTo(source, target, identityRelation);
|
|
}
|
|
function compareTypesIdentical(source, target) {
|
|
return isTypeRelatedTo(source, target, identityRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function compareTypesAssignable(source, target) {
|
|
return isTypeRelatedTo(source, target, assignableRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function compareTypesSubtypeOf(source, target) {
|
|
return isTypeRelatedTo(source, target, subtypeRelation) ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
function isTypeSubtypeOf(source, target) {
|
|
return isTypeRelatedTo(source, target, subtypeRelation);
|
|
}
|
|
function isTypeAssignableTo(source, target) {
|
|
return isTypeRelatedTo(source, target, assignableRelation);
|
|
}
|
|
function isTypeDerivedFrom(source, target) {
|
|
return source.flags & 1048576 /* Union */ ? every(source.types, (t) => isTypeDerivedFrom(t, target)) : target.flags & 1048576 /* Union */ ? some(target.types, (t) => isTypeDerivedFrom(source, t)) : source.flags & 2097152 /* Intersection */ ? some(source.types, (t) => isTypeDerivedFrom(t, target)) : source.flags & 58982400 /* InstantiableNonPrimitive */ ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) : isEmptyAnonymousObjectType(target) ? !!(source.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */)) : target === globalObjectType ? !!(source.flags & (524288 /* Object */ | 67108864 /* NonPrimitive */)) && !isEmptyAnonymousObjectType(source) : target === globalFunctionType ? !!(source.flags & 524288 /* Object */) && isFunctionObjectType(source) : hasBaseType(source, getTargetType(target)) || isArrayType(target) && !isReadonlyArrayType(target) && isTypeDerivedFrom(source, globalReadonlyArrayType);
|
|
}
|
|
function isTypeComparableTo(source, target) {
|
|
return isTypeRelatedTo(source, target, comparableRelation);
|
|
}
|
|
function areTypesComparable(type1, type2) {
|
|
return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1);
|
|
}
|
|
function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain, errorOutputObject) {
|
|
return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain, errorOutputObject);
|
|
}
|
|
function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) {
|
|
return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, void 0);
|
|
}
|
|
function checkTypeRelatedToAndOptionallyElaborate(source, target, relation, errorNode, expr, headMessage, containingMessageChain, errorOutputContainer) {
|
|
if (isTypeRelatedTo(source, target, relation))
|
|
return true;
|
|
if (!errorNode || !elaborateError(expr, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) {
|
|
return checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer);
|
|
}
|
|
return false;
|
|
}
|
|
function isOrHasGenericConditional(type) {
|
|
return !!(type.flags & 16777216 /* Conditional */ || type.flags & 2097152 /* Intersection */ && some(type.types, isOrHasGenericConditional));
|
|
}
|
|
function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
|
|
if (!node || isOrHasGenericConditional(target))
|
|
return false;
|
|
if (!checkTypeRelatedTo(source, target, relation, void 0) && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) {
|
|
return true;
|
|
}
|
|
switch (node.kind) {
|
|
case 291 /* JsxExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
|
|
case 223 /* BinaryExpression */:
|
|
switch (node.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 27 /* CommaToken */:
|
|
return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
|
|
}
|
|
break;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 289 /* JsxAttributes */:
|
|
return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
case 216 /* ArrowFunction */:
|
|
return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
return false;
|
|
}
|
|
function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) {
|
|
const callSignatures = getSignaturesOfType(source, 0 /* Call */);
|
|
const constructSignatures = getSignaturesOfType(source, 1 /* Construct */);
|
|
for (const signatures of [constructSignatures, callSignatures]) {
|
|
if (some(signatures, (s) => {
|
|
const returnType = getReturnTypeOfSignature(s);
|
|
return !(returnType.flags & (1 /* Any */ | 131072 /* Never */)) && checkTypeRelatedTo(returnType, target, relation, void 0);
|
|
})) {
|
|
const resultObj = errorOutputContainer || {};
|
|
checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj);
|
|
const diagnostic = resultObj.errors[resultObj.errors.length - 1];
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(
|
|
node,
|
|
signatures === constructSignatures ? Diagnostics.Did_you_mean_to_use_new_with_this_expression : Diagnostics.Did_you_mean_to_call_this_expression
|
|
));
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (isBlock(node.body)) {
|
|
return false;
|
|
}
|
|
if (some(node.parameters, hasType)) {
|
|
return false;
|
|
}
|
|
const sourceSig = getSingleCallSignature(source);
|
|
if (!sourceSig) {
|
|
return false;
|
|
}
|
|
const targetSignatures = getSignaturesOfType(target, 0 /* Call */);
|
|
if (!length(targetSignatures)) {
|
|
return false;
|
|
}
|
|
const returnExpression = node.body;
|
|
const sourceReturn = getReturnTypeOfSignature(sourceSig);
|
|
const targetReturn = getUnionType(map(targetSignatures, getReturnTypeOfSignature));
|
|
if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, void 0)) {
|
|
const elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, void 0, containingMessageChain, errorOutputContainer);
|
|
if (elaborated) {
|
|
return elaborated;
|
|
}
|
|
const resultObj = errorOutputContainer || {};
|
|
checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, void 0, containingMessageChain, resultObj);
|
|
if (resultObj.errors) {
|
|
if (target.symbol && length(target.symbol.declarations)) {
|
|
addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], createDiagnosticForNode(
|
|
target.symbol.declarations[0],
|
|
Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature
|
|
));
|
|
}
|
|
if ((getFunctionFlags(node) & 2 /* Async */) === 0 && !getTypeOfPropertyOfType(sourceReturn, "then") && checkTypeRelatedTo(createPromiseType(sourceReturn), targetReturn, relation, void 0)) {
|
|
addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], createDiagnosticForNode(
|
|
node,
|
|
Diagnostics.Did_you_mean_to_mark_this_function_as_async
|
|
));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) {
|
|
const idx = getIndexedAccessTypeOrUndefined(target, nameType);
|
|
if (idx) {
|
|
return idx;
|
|
}
|
|
if (target.flags & 1048576 /* Union */) {
|
|
const best = getBestMatchingType(source, target);
|
|
if (best) {
|
|
return getIndexedAccessTypeOrUndefined(best, nameType);
|
|
}
|
|
}
|
|
}
|
|
function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
|
|
next.contextualType = sourcePropType;
|
|
try {
|
|
return checkExpressionForMutableLocation(next, 1 /* Contextual */, sourcePropType);
|
|
} finally {
|
|
next.contextualType = void 0;
|
|
}
|
|
}
|
|
function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
let reportedError = false;
|
|
for (let status = iterator.next(); !status.done; status = iterator.next()) {
|
|
const { errorNode: prop, innerExpression: next, nameType, errorMessage } = status.value;
|
|
let targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType);
|
|
if (!targetPropType || targetPropType.flags & 8388608 /* IndexedAccess */)
|
|
continue;
|
|
let sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType);
|
|
if (!sourcePropType)
|
|
continue;
|
|
const propName = getPropertyNameFromIndex(nameType, void 0);
|
|
if (!checkTypeRelatedTo(sourcePropType, targetPropType, relation, void 0)) {
|
|
const elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, void 0, containingMessageChain, errorOutputContainer);
|
|
reportedError = true;
|
|
if (!elaborated) {
|
|
const resultObj = errorOutputContainer || {};
|
|
const specificSource = next ? checkExpressionForMutableLocationWithContextualType(next, sourcePropType) : sourcePropType;
|
|
if (exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(specificSource, targetPropType)) {
|
|
const diag2 = createDiagnosticForNode(prop, Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, typeToString(specificSource), typeToString(targetPropType));
|
|
diagnostics.add(diag2);
|
|
resultObj.errors = [diag2];
|
|
} else {
|
|
const targetIsOptional = !!(propName && (getPropertyOfType(target, propName) || unknownSymbol).flags & 16777216 /* Optional */);
|
|
const sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & 16777216 /* Optional */);
|
|
targetPropType = removeMissingType(targetPropType, targetIsOptional);
|
|
sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional);
|
|
const result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
|
|
if (result && specificSource !== sourcePropType) {
|
|
checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj);
|
|
}
|
|
}
|
|
if (resultObj.errors) {
|
|
const reportedDiag = resultObj.errors[resultObj.errors.length - 1];
|
|
const propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : void 0;
|
|
const targetProp = propertyName !== void 0 ? getPropertyOfType(target, propertyName) : void 0;
|
|
let issuedElaboration = false;
|
|
if (!targetProp) {
|
|
const indexInfo = getApplicableIndexInfo(target, nameType);
|
|
if (indexInfo && indexInfo.declaration && !getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) {
|
|
issuedElaboration = true;
|
|
addRelatedInfo(reportedDiag, createDiagnosticForNode(indexInfo.declaration, Diagnostics.The_expected_type_comes_from_this_index_signature));
|
|
}
|
|
}
|
|
if (!issuedElaboration && (targetProp && length(targetProp.declarations) || target.symbol && length(target.symbol.declarations))) {
|
|
const targetNode = targetProp && length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0];
|
|
if (!getSourceFileOfNode(targetNode).hasNoDefaultLib) {
|
|
addRelatedInfo(reportedDiag, createDiagnosticForNode(
|
|
targetNode,
|
|
Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1,
|
|
propertyName && !(nameType.flags & 8192 /* UniqueESSymbol */) ? unescapeLeadingUnderscores(propertyName) : typeToString(nameType),
|
|
typeToString(target)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return reportedError;
|
|
}
|
|
function* generateJsxAttributes(node) {
|
|
if (!length(node.properties))
|
|
return;
|
|
for (const prop of node.properties) {
|
|
if (isJsxSpreadAttribute(prop) || isHyphenatedJsxName(idText(prop.name)))
|
|
continue;
|
|
yield { errorNode: prop.name, innerExpression: prop.initializer, nameType: getStringLiteralType(idText(prop.name)) };
|
|
}
|
|
}
|
|
function* generateJsxChildren(node, getInvalidTextDiagnostic) {
|
|
if (!length(node.children))
|
|
return;
|
|
let memberOffset = 0;
|
|
for (let i = 0; i < node.children.length; i++) {
|
|
const child = node.children[i];
|
|
const nameType = getNumberLiteralType(i - memberOffset);
|
|
const elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic);
|
|
if (elem) {
|
|
yield elem;
|
|
} else {
|
|
memberOffset++;
|
|
}
|
|
}
|
|
}
|
|
function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) {
|
|
switch (child.kind) {
|
|
case 291 /* JsxExpression */:
|
|
return { errorNode: child, innerExpression: child.expression, nameType };
|
|
case 11 /* JsxText */:
|
|
if (child.containsOnlyTriviaWhiteSpaces) {
|
|
break;
|
|
}
|
|
return { errorNode: child, innerExpression: void 0, nameType, errorMessage: getInvalidTextDiagnostic() };
|
|
case 281 /* JsxElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 285 /* JsxFragment */:
|
|
return { errorNode: child, innerExpression: child, nameType };
|
|
default:
|
|
return Debug.assertNever(child, "Found invalid jsx child");
|
|
}
|
|
}
|
|
function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
let result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
let invalidTextDiagnostic;
|
|
if (isJsxOpeningElement(node.parent) && isJsxElement(node.parent.parent)) {
|
|
const containingElement = node.parent.parent;
|
|
const childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
const childrenPropName = childPropName === void 0 ? "children" : unescapeLeadingUnderscores(childPropName);
|
|
const childrenNameType = getStringLiteralType(childrenPropName);
|
|
const childrenTargetType = getIndexedAccessType(target, childrenNameType);
|
|
const validChildren = getSemanticJsxChildren(containingElement.children);
|
|
if (!length(validChildren)) {
|
|
return result;
|
|
}
|
|
const moreThanOneRealChildren = length(validChildren) > 1;
|
|
const arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
|
|
const nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isArrayOrTupleLikeType(t));
|
|
if (moreThanOneRealChildren) {
|
|
if (arrayLikeTargetParts !== neverType) {
|
|
const realSource = createTupleType(checkJsxChildren(containingElement, 0 /* Normal */));
|
|
const children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic);
|
|
result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result;
|
|
} else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
|
|
result = true;
|
|
const diag2 = error(
|
|
containingElement.openingElement.tagName,
|
|
Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided,
|
|
childrenPropName,
|
|
typeToString(childrenTargetType)
|
|
);
|
|
if (errorOutputContainer && errorOutputContainer.skipLogging) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
}
|
|
} else {
|
|
if (nonArrayLikeTargetParts !== neverType) {
|
|
const child = validChildren[0];
|
|
const elem = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic);
|
|
if (elem) {
|
|
result = elaborateElementwise(
|
|
function* () {
|
|
yield elem;
|
|
}(),
|
|
source,
|
|
target,
|
|
relation,
|
|
containingMessageChain,
|
|
errorOutputContainer
|
|
) || result;
|
|
}
|
|
} else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) {
|
|
result = true;
|
|
const diag2 = error(
|
|
containingElement.openingElement.tagName,
|
|
Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided,
|
|
childrenPropName,
|
|
typeToString(childrenTargetType)
|
|
);
|
|
if (errorOutputContainer && errorOutputContainer.skipLogging) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
function getInvalidTextualChildDiagnostic() {
|
|
if (!invalidTextDiagnostic) {
|
|
const tagNameText = getTextOfNode(node.parent.tagName);
|
|
const childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
const childrenPropName = childPropName === void 0 ? "children" : unescapeLeadingUnderscores(childPropName);
|
|
const childrenTargetType = getIndexedAccessType(target, getStringLiteralType(childrenPropName));
|
|
const diagnostic = Diagnostics._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2;
|
|
invalidTextDiagnostic = { ...diagnostic, key: "!!ALREADY FORMATTED!!", message: formatMessage(void 0, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) };
|
|
}
|
|
return invalidTextDiagnostic;
|
|
}
|
|
}
|
|
function* generateLimitedTupleElements(node, target) {
|
|
const len = length(node.elements);
|
|
if (!len)
|
|
return;
|
|
for (let i = 0; i < len; i++) {
|
|
if (isTupleLikeType(target) && !getPropertyOfType(target, "" + i))
|
|
continue;
|
|
const elem = node.elements[i];
|
|
if (isOmittedExpression(elem))
|
|
continue;
|
|
const nameType = getNumberLiteralType(i);
|
|
yield { errorNode: elem, innerExpression: elem, nameType };
|
|
}
|
|
}
|
|
function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
|
|
return false;
|
|
if (isTupleLikeType(source)) {
|
|
return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
const oldContext = node.contextualType;
|
|
node.contextualType = target;
|
|
try {
|
|
const tupleizedType = checkArrayLiteral(node, 1 /* Contextual */, true);
|
|
node.contextualType = oldContext;
|
|
if (isTupleLikeType(tupleizedType)) {
|
|
return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
return false;
|
|
} finally {
|
|
node.contextualType = oldContext;
|
|
}
|
|
}
|
|
function* generateObjectLiteralElements(node) {
|
|
if (!length(node.properties))
|
|
return;
|
|
for (const prop of node.properties) {
|
|
if (isSpreadAssignment(prop))
|
|
continue;
|
|
const type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576 /* StringOrNumberLiteralOrUnique */);
|
|
if (!type || type.flags & 131072 /* Never */) {
|
|
continue;
|
|
}
|
|
switch (prop.kind) {
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
yield { errorNode: prop.name, innerExpression: void 0, nameType: type };
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
yield { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: isComputedNonLiteralName(prop.name) ? Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : void 0 };
|
|
break;
|
|
default:
|
|
Debug.assertNever(prop);
|
|
}
|
|
}
|
|
}
|
|
function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) {
|
|
if (target.flags & (131068 /* Primitive */ | 131072 /* Never */))
|
|
return false;
|
|
return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer);
|
|
}
|
|
function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) {
|
|
return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain);
|
|
}
|
|
function isSignatureAssignableTo(source, target, ignoreReturnTypes) {
|
|
return compareSignaturesRelated(
|
|
source,
|
|
target,
|
|
ignoreReturnTypes ? 4 /* IgnoreReturnTypes */ : 0 /* None */,
|
|
false,
|
|
void 0,
|
|
void 0,
|
|
compareTypesAssignable,
|
|
void 0
|
|
) !== 0 /* False */;
|
|
}
|
|
function isAnySignature(s) {
|
|
return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && isTypeAny(getReturnTypeOfSignature(s));
|
|
}
|
|
function compareSignaturesRelated(source, target, checkMode, reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) {
|
|
if (source === target) {
|
|
return -1 /* True */;
|
|
}
|
|
if (isAnySignature(target)) {
|
|
return -1 /* True */;
|
|
}
|
|
const targetCount = getParameterCount(target);
|
|
const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
|
|
if (sourceHasMoreParameters) {
|
|
return 0 /* False */;
|
|
}
|
|
if (source.typeParameters && source.typeParameters !== target.typeParameters) {
|
|
target = getCanonicalSignature(target);
|
|
source = instantiateSignatureInContextOf(source, target, void 0, compareTypes);
|
|
}
|
|
const sourceCount = getParameterCount(source);
|
|
const sourceRestType = getNonArrayRestType(source);
|
|
const targetRestType = getNonArrayRestType(target);
|
|
if (sourceRestType || targetRestType) {
|
|
void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers);
|
|
}
|
|
const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
|
|
const strictVariance = !(checkMode & 3 /* Callback */) && strictFunctionTypes && kind !== 171 /* MethodDeclaration */ && kind !== 170 /* MethodSignature */ && kind !== 173 /* Constructor */;
|
|
let result = -1 /* True */;
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType && sourceThisType !== voidType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
const related = !strictVariance && compareTypes(sourceThisType, targetThisType, false) || compareTypes(targetThisType, sourceThisType, reportErrors2);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.The_this_types_of_each_signature_are_incompatible);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
|
|
const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
|
|
for (let i = 0; i < paramCount; i++) {
|
|
const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
|
|
const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
|
|
if (sourceType && targetType) {
|
|
const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
|
|
const targetSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
|
|
const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
|
|
let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(sourceType, targetType, false) || compareTypes(targetType, sourceType, reportErrors2);
|
|
if (related && checkMode & 8 /* StrictArity */ && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, false)) {
|
|
related = 0 /* False */;
|
|
}
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
errorReporter(
|
|
Diagnostics.Types_of_parameters_0_and_1_are_incompatible,
|
|
unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)),
|
|
unescapeLeadingUnderscores(getParameterNameAtPosition(target, i))
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
if (!(checkMode & 4 /* IgnoreReturnTypes */)) {
|
|
const targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol)) : getReturnTypeOfSignature(target);
|
|
if (targetReturnType === voidType || targetReturnType === anyType) {
|
|
return result;
|
|
}
|
|
const sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol)) : getReturnTypeOfSignature(source);
|
|
const targetTypePredicate = getTypePredicateOfSignature(target);
|
|
if (targetTypePredicate) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
if (sourceTypePredicate) {
|
|
result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors2, errorReporter, compareTypes);
|
|
} else if (isIdentifierTypePredicate(targetTypePredicate)) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else {
|
|
result &= checkMode & 1 /* BivariantCallback */ && compareTypes(targetReturnType, sourceReturnType, false) || compareTypes(sourceReturnType, targetReturnType, reportErrors2);
|
|
if (!result && reportErrors2 && incompatibleErrorReporter) {
|
|
incompatibleErrorReporter(sourceReturnType, targetReturnType);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function compareTypePredicateRelatedTo(source, target, reportErrors2, errorReporter, compareTypes) {
|
|
if (source.kind !== target.kind) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard);
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (source.kind === 1 /* Identifier */ || source.kind === 3 /* AssertsIdentifier */) {
|
|
if (source.parameterIndex !== target.parameterIndex) {
|
|
if (reportErrors2) {
|
|
errorReporter(Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName);
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const related = source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type, reportErrors2) : 0 /* False */;
|
|
if (related === 0 /* False */ && reportErrors2) {
|
|
errorReporter(Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target));
|
|
}
|
|
return related;
|
|
}
|
|
function isImplementationCompatibleWithOverload(implementation, overload) {
|
|
const erasedSource = getErasedSignature(implementation);
|
|
const erasedTarget = getErasedSignature(overload);
|
|
const sourceReturnType = getReturnTypeOfSignature(erasedSource);
|
|
const targetReturnType = getReturnTypeOfSignature(erasedTarget);
|
|
if (targetReturnType === voidType || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation) || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) {
|
|
return isSignatureAssignableTo(erasedSource, erasedTarget, true);
|
|
}
|
|
return false;
|
|
}
|
|
function isEmptyResolvedType(t) {
|
|
return t !== anyFunctionType && t.properties.length === 0 && t.callSignatures.length === 0 && t.constructSignatures.length === 0 && t.indexInfos.length === 0;
|
|
}
|
|
function isEmptyObjectType(type) {
|
|
return type.flags & 524288 /* Object */ ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) : type.flags & 67108864 /* NonPrimitive */ ? true : type.flags & 1048576 /* Union */ ? some(type.types, isEmptyObjectType) : type.flags & 2097152 /* Intersection */ ? every(type.types, isEmptyObjectType) : false;
|
|
}
|
|
function isEmptyAnonymousObjectType(type) {
|
|
return !!(getObjectFlags(type) & 16 /* Anonymous */ && (type.members && isEmptyResolvedType(type) || type.symbol && type.symbol.flags & 2048 /* TypeLiteral */ && getMembersOfSymbol(type.symbol).size === 0));
|
|
}
|
|
function isUnknownLikeUnionType(type) {
|
|
if (strictNullChecks && type.flags & 1048576 /* Union */) {
|
|
if (!(type.objectFlags & 33554432 /* IsUnknownLikeUnionComputed */)) {
|
|
const types = type.types;
|
|
type.objectFlags |= 33554432 /* IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* Undefined */ && types[1].flags & 65536 /* Null */ && some(types, isEmptyAnonymousObjectType) ? 67108864 /* IsUnknownLikeUnion */ : 0);
|
|
}
|
|
return !!(type.objectFlags & 67108864 /* IsUnknownLikeUnion */);
|
|
}
|
|
return false;
|
|
}
|
|
function containsUndefinedType(type) {
|
|
return !!((type.flags & 1048576 /* Union */ ? type.types[0] : type).flags & 32768 /* Undefined */);
|
|
}
|
|
function isStringIndexSignatureOnlyType(type) {
|
|
return type.flags & 524288 /* Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || type.flags & 3145728 /* UnionOrIntersection */ && every(type.types, isStringIndexSignatureOnlyType) || false;
|
|
}
|
|
function isEnumTypeRelatedTo(source, target, errorReporter) {
|
|
const sourceSymbol = source.flags & 8 /* EnumMember */ ? getParentOfSymbol(source) : source;
|
|
const targetSymbol = target.flags & 8 /* EnumMember */ ? getParentOfSymbol(target) : target;
|
|
if (sourceSymbol === targetSymbol) {
|
|
return true;
|
|
}
|
|
if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* RegularEnum */) || !(targetSymbol.flags & 256 /* RegularEnum */)) {
|
|
return false;
|
|
}
|
|
const id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol);
|
|
const entry = enumRelation.get(id);
|
|
if (entry !== void 0 && !(!(entry & 4 /* Reported */) && entry & 2 /* Failed */ && errorReporter)) {
|
|
return !!(entry & 1 /* Succeeded */);
|
|
}
|
|
const targetEnumType = getTypeOfSymbol(targetSymbol);
|
|
for (const property of getPropertiesOfType(getTypeOfSymbol(sourceSymbol))) {
|
|
if (property.flags & 8 /* EnumMember */) {
|
|
const targetProperty = getPropertyOfType(targetEnumType, property.escapedName);
|
|
if (!targetProperty || !(targetProperty.flags & 8 /* EnumMember */)) {
|
|
if (errorReporter) {
|
|
errorReporter(
|
|
Diagnostics.Property_0_is_missing_in_type_1,
|
|
symbolName(property),
|
|
typeToString(getDeclaredTypeOfSymbol(targetSymbol), void 0, 64 /* UseFullyQualifiedType */)
|
|
);
|
|
enumRelation.set(id, 2 /* Failed */ | 4 /* Reported */);
|
|
} else {
|
|
enumRelation.set(id, 2 /* Failed */);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
enumRelation.set(id, 1 /* Succeeded */);
|
|
return true;
|
|
}
|
|
function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {
|
|
const s = source.flags;
|
|
const t = target.flags;
|
|
if (t & 3 /* AnyOrUnknown */ || s & 131072 /* Never */ || source === wildcardType)
|
|
return true;
|
|
if (t & 131072 /* Never */)
|
|
return false;
|
|
if (s & 402653316 /* StringLike */ && t & 4 /* String */)
|
|
return true;
|
|
if (s & 128 /* StringLiteral */ && s & 1024 /* EnumLiteral */ && t & 128 /* StringLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value)
|
|
return true;
|
|
if (s & 296 /* NumberLike */ && t & 8 /* Number */)
|
|
return true;
|
|
if (s & 256 /* NumberLiteral */ && s & 1024 /* EnumLiteral */ && t & 256 /* NumberLiteral */ && !(t & 1024 /* EnumLiteral */) && source.value === target.value)
|
|
return true;
|
|
if (s & 2112 /* BigIntLike */ && t & 64 /* BigInt */)
|
|
return true;
|
|
if (s & 528 /* BooleanLike */ && t & 16 /* Boolean */)
|
|
return true;
|
|
if (s & 12288 /* ESSymbolLike */ && t & 4096 /* ESSymbol */)
|
|
return true;
|
|
if (s & 32 /* Enum */ && t & 32 /* Enum */ && source.symbol.escapedName === target.symbol.escapedName && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
if (s & 1024 /* EnumLiteral */ && t & 1024 /* EnumLiteral */) {
|
|
if (s & 1048576 /* Union */ && t & 1048576 /* Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
if (s & 2944 /* Literal */ && t & 2944 /* Literal */ && source.value === target.value && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter))
|
|
return true;
|
|
}
|
|
if (s & 32768 /* Undefined */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & (32768 /* Undefined */ | 16384 /* Void */)))
|
|
return true;
|
|
if (s & 65536 /* Null */ && (!strictNullChecks && !(t & 3145728 /* UnionOrIntersection */) || t & 65536 /* Null */))
|
|
return true;
|
|
if (s & 524288 /* Object */ && t & 67108864 /* NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(getObjectFlags(source) & 8192 /* FreshLiteral */)))
|
|
return true;
|
|
if (relation === assignableRelation || relation === comparableRelation) {
|
|
if (s & 1 /* Any */)
|
|
return true;
|
|
if (s & 8 /* Number */ && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */))
|
|
return true;
|
|
if (s & 256 /* NumberLiteral */ && !(s & 1024 /* EnumLiteral */) && (t & 32 /* Enum */ || t & 256 /* NumberLiteral */ && t & 1024 /* EnumLiteral */ && source.value === target.value))
|
|
return true;
|
|
if (isUnknownLikeUnionType(target))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeRelatedTo(source, target, relation) {
|
|
if (isFreshLiteralType(source)) {
|
|
source = source.regularType;
|
|
}
|
|
if (isFreshLiteralType(target)) {
|
|
target = target.regularType;
|
|
}
|
|
if (source === target) {
|
|
return true;
|
|
}
|
|
if (relation !== identityRelation) {
|
|
if (relation === comparableRelation && !(target.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target, source, relation) || isSimpleTypeRelatedTo(source, target, relation)) {
|
|
return true;
|
|
}
|
|
} else if (!((source.flags | target.flags) & (3145728 /* UnionOrIntersection */ | 8388608 /* IndexedAccess */ | 16777216 /* Conditional */ | 33554432 /* Substitution */))) {
|
|
if (source.flags !== target.flags)
|
|
return false;
|
|
if (source.flags & 67358815 /* Singleton */)
|
|
return true;
|
|
}
|
|
if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
|
|
const related = relation.get(getRelationKey(source, target, 0 /* None */, relation, false));
|
|
if (related !== void 0) {
|
|
return !!(related & 1 /* Succeeded */);
|
|
}
|
|
}
|
|
if (source.flags & 469499904 /* StructuredOrInstantiable */ || target.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
return checkTypeRelatedTo(source, target, relation, void 0);
|
|
}
|
|
return false;
|
|
}
|
|
function isIgnoredJsxProperty(source, sourceProp) {
|
|
return getObjectFlags(source) & 2048 /* JsxAttributes */ && isHyphenatedJsxName(sourceProp.escapedName);
|
|
}
|
|
function getNormalizedType(type, writing) {
|
|
while (true) {
|
|
const t = isFreshLiteralType(type) ? type.regularType : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
|
|
if (t === type)
|
|
return t;
|
|
type = t;
|
|
}
|
|
}
|
|
function getNormalizedUnionOrIntersectionType(type, writing) {
|
|
const reduced = getReducedType(type);
|
|
if (reduced !== type) {
|
|
return reduced;
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */ && some(type.types, isEmptyAnonymousObjectType)) {
|
|
const normalizedTypes = sameMap(type.types, (t) => getNormalizedType(t, writing));
|
|
if (normalizedTypes !== type.types) {
|
|
return getIntersectionType(normalizedTypes);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
|
|
var _a2;
|
|
let errorInfo;
|
|
let relatedInfo;
|
|
let maybeKeys;
|
|
let sourceStack;
|
|
let targetStack;
|
|
let maybeCount = 0;
|
|
let sourceDepth = 0;
|
|
let targetDepth = 0;
|
|
let expandingFlags = 0 /* None */;
|
|
let overflow = false;
|
|
let overrideNextErrorInfo = 0;
|
|
let lastSkippedInfo;
|
|
let incompatibleStack;
|
|
let inPropertyCheck = false;
|
|
Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
|
|
const result = isRelatedTo(source, target, 3 /* Both */, !!errorNode, headMessage);
|
|
if (incompatibleStack) {
|
|
reportIncompatibleStack();
|
|
}
|
|
if (overflow) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: sourceDepth, targetDepth });
|
|
const diag2 = error(errorNode || currentNode, Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
|
|
if (errorOutputContainer) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
} else if (errorInfo) {
|
|
if (containingMessageChain) {
|
|
const chain = containingMessageChain();
|
|
if (chain) {
|
|
concatenateDiagnosticMessageChains(chain, errorInfo);
|
|
errorInfo = chain;
|
|
}
|
|
}
|
|
let relatedInformation;
|
|
if (headMessage && errorNode && !result && source.symbol) {
|
|
const links = getSymbolLinks(source.symbol);
|
|
if (links.originatingImport && !isImportCall(links.originatingImport)) {
|
|
const helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, void 0);
|
|
if (helpfulRetry) {
|
|
const diag3 = createDiagnosticForNode(links.originatingImport, Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead);
|
|
relatedInformation = append(relatedInformation, diag3);
|
|
}
|
|
}
|
|
}
|
|
const diag2 = createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(diag2, ...relatedInfo);
|
|
}
|
|
if (errorOutputContainer) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
if (!errorOutputContainer || !errorOutputContainer.skipLogging) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0 /* False */) {
|
|
Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error.");
|
|
}
|
|
return result !== 0 /* False */;
|
|
function resetErrorInfo(saved) {
|
|
errorInfo = saved.errorInfo;
|
|
lastSkippedInfo = saved.lastSkippedInfo;
|
|
incompatibleStack = saved.incompatibleStack;
|
|
overrideNextErrorInfo = saved.overrideNextErrorInfo;
|
|
relatedInfo = saved.relatedInfo;
|
|
}
|
|
function captureErrorCalculationState() {
|
|
return {
|
|
errorInfo,
|
|
lastSkippedInfo,
|
|
incompatibleStack: incompatibleStack == null ? void 0 : incompatibleStack.slice(),
|
|
overrideNextErrorInfo,
|
|
relatedInfo: relatedInfo == null ? void 0 : relatedInfo.slice()
|
|
};
|
|
}
|
|
function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
|
|
overrideNextErrorInfo++;
|
|
lastSkippedInfo = void 0;
|
|
(incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
|
|
}
|
|
function reportIncompatibleStack() {
|
|
const stack = incompatibleStack || [];
|
|
incompatibleStack = void 0;
|
|
const info = lastSkippedInfo;
|
|
lastSkippedInfo = void 0;
|
|
if (stack.length === 1) {
|
|
reportError(...stack[0]);
|
|
if (info) {
|
|
reportRelationError(void 0, ...info);
|
|
}
|
|
return;
|
|
}
|
|
let path = "";
|
|
const secondaryRootErrors = [];
|
|
while (stack.length) {
|
|
const [msg, ...args] = stack.pop();
|
|
switch (msg.code) {
|
|
case Diagnostics.Types_of_property_0_are_incompatible.code: {
|
|
if (path.indexOf("new ") === 0) {
|
|
path = `(${path})`;
|
|
}
|
|
const str = "" + args[0];
|
|
if (path.length === 0) {
|
|
path = `${str}`;
|
|
} else if (isIdentifierText(str, getEmitScriptTarget(compilerOptions))) {
|
|
path = `${path}.${str}`;
|
|
} else if (str[0] === "[" && str[str.length - 1] === "]") {
|
|
path = `${path}${str}`;
|
|
} else {
|
|
path = `${path}[${str}]`;
|
|
}
|
|
break;
|
|
}
|
|
case Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code:
|
|
case Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code:
|
|
case Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code:
|
|
case Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: {
|
|
if (path.length === 0) {
|
|
let mappedMsg = msg;
|
|
if (msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
|
|
mappedMsg = Diagnostics.Call_signature_return_types_0_and_1_are_incompatible;
|
|
} else if (msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) {
|
|
mappedMsg = Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible;
|
|
}
|
|
secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]);
|
|
} else {
|
|
const prefix = msg.code === Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "new " : "";
|
|
const params = msg.code === Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || msg.code === Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code ? "" : "...";
|
|
path = `${prefix}${path}(${params})`;
|
|
}
|
|
break;
|
|
}
|
|
case Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target.code: {
|
|
secondaryRootErrors.unshift([Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, args[0], args[1]]);
|
|
break;
|
|
}
|
|
case Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target.code: {
|
|
secondaryRootErrors.unshift([Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, args[0], args[1], args[2]]);
|
|
break;
|
|
}
|
|
default:
|
|
return Debug.fail(`Unhandled Diagnostic: ${msg.code}`);
|
|
}
|
|
}
|
|
if (path) {
|
|
reportError(
|
|
path[path.length - 1] === ")" ? Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types : Diagnostics.The_types_of_0_are_incompatible_between_these_types,
|
|
path
|
|
);
|
|
} else {
|
|
secondaryRootErrors.shift();
|
|
}
|
|
for (const [msg, ...args] of secondaryRootErrors) {
|
|
const originalValue = msg.elidedInCompatabilityPyramid;
|
|
msg.elidedInCompatabilityPyramid = false;
|
|
reportError(msg, ...args);
|
|
msg.elidedInCompatabilityPyramid = originalValue;
|
|
}
|
|
if (info) {
|
|
reportRelationError(void 0, ...info);
|
|
}
|
|
}
|
|
function reportError(message, arg0, arg1, arg2, arg3) {
|
|
Debug.assert(!!errorNode);
|
|
if (incompatibleStack)
|
|
reportIncompatibleStack();
|
|
if (message.elidedInCompatabilityPyramid)
|
|
return;
|
|
errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
function associateRelatedInfo(info) {
|
|
Debug.assert(!!errorInfo);
|
|
if (!relatedInfo) {
|
|
relatedInfo = [info];
|
|
} else {
|
|
relatedInfo.push(info);
|
|
}
|
|
}
|
|
function reportRelationError(message, source2, target2) {
|
|
if (incompatibleStack)
|
|
reportIncompatibleStack();
|
|
const [sourceType, targetType] = getTypeNamesForErrorDisplay(source2, target2);
|
|
let generalizedSource = source2;
|
|
let generalizedSourceType = sourceType;
|
|
if (isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) {
|
|
generalizedSource = getBaseTypeOfLiteralType(source2);
|
|
Debug.assert(!isTypeAssignableTo(generalizedSource, target2), "generalized source shouldn't be assignable");
|
|
generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource);
|
|
}
|
|
if (target2.flags & 262144 /* TypeParameter */ && target2 !== markerSuperTypeForCheck && target2 !== markerSubTypeForCheck) {
|
|
const constraint = getBaseConstraintOfType(target2);
|
|
let needsOriginalSource;
|
|
if (constraint && (isTypeAssignableTo(generalizedSource, constraint) || (needsOriginalSource = isTypeAssignableTo(source2, constraint)))) {
|
|
reportError(
|
|
Diagnostics._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2,
|
|
needsOriginalSource ? sourceType : generalizedSourceType,
|
|
targetType,
|
|
typeToString(constraint)
|
|
);
|
|
} else {
|
|
errorInfo = void 0;
|
|
reportError(
|
|
Diagnostics._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1,
|
|
targetType,
|
|
generalizedSourceType
|
|
);
|
|
}
|
|
}
|
|
if (!message) {
|
|
if (relation === comparableRelation) {
|
|
message = Diagnostics.Type_0_is_not_comparable_to_type_1;
|
|
} else if (sourceType === targetType) {
|
|
message = Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated;
|
|
} else if (exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source2, target2).length) {
|
|
message = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties;
|
|
} else {
|
|
if (source2.flags & 128 /* StringLiteral */ && target2.flags & 1048576 /* Union */) {
|
|
const suggestedType = getSuggestedTypeForNonexistentStringLiteralType(source2, target2);
|
|
if (suggestedType) {
|
|
reportError(Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2, generalizedSourceType, targetType, typeToString(suggestedType));
|
|
return;
|
|
}
|
|
}
|
|
message = Diagnostics.Type_0_is_not_assignable_to_type_1;
|
|
}
|
|
} else if (message === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 && exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source2, target2).length) {
|
|
message = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties;
|
|
}
|
|
reportError(message, generalizedSourceType, targetType);
|
|
}
|
|
function tryElaborateErrorsForPrimitivesAndObjects(source2, target2) {
|
|
const sourceType = symbolValueDeclarationIsContextSensitive(source2.symbol) ? typeToString(source2, source2.symbol.valueDeclaration) : typeToString(source2);
|
|
const targetType = symbolValueDeclarationIsContextSensitive(target2.symbol) ? typeToString(target2, target2.symbol.valueDeclaration) : typeToString(target2);
|
|
if (globalStringType === source2 && stringType === target2 || globalNumberType === source2 && numberType === target2 || globalBooleanType === source2 && booleanType === target2 || getGlobalESSymbolType() === source2 && esSymbolType === target2) {
|
|
reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
|
|
}
|
|
}
|
|
function tryElaborateArrayLikeErrors(source2, target2, reportErrors2) {
|
|
if (isTupleType(source2)) {
|
|
if (source2.target.readonly && isMutableArrayOrTuple(target2)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return false;
|
|
}
|
|
return isArrayOrTupleType(target2);
|
|
}
|
|
if (isReadonlyArrayType(source2) && isMutableArrayOrTuple(target2)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return false;
|
|
}
|
|
if (isTupleType(target2)) {
|
|
return isArrayType(source2);
|
|
}
|
|
return true;
|
|
}
|
|
function isRelatedToWorker(source2, target2, reportErrors2) {
|
|
return isRelatedTo(source2, target2, 3 /* Both */, reportErrors2);
|
|
}
|
|
function isRelatedTo(originalSource, originalTarget, recursionFlags = 3 /* Both */, reportErrors2 = false, headMessage2, intersectionState = 0 /* None */) {
|
|
if (originalSource.flags & 524288 /* Object */ && originalTarget.flags & 131068 /* Primitive */) {
|
|
if (relation === comparableRelation && !(originalTarget.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(originalTarget, originalSource, relation) || isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors2 ? reportError : void 0)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const source2 = getNormalizedType(originalSource, false);
|
|
let target2 = getNormalizedType(originalTarget, true);
|
|
if (source2 === target2)
|
|
return -1 /* True */;
|
|
if (relation === identityRelation) {
|
|
if (source2.flags !== target2.flags)
|
|
return 0 /* False */;
|
|
if (source2.flags & 67358815 /* Singleton */)
|
|
return -1 /* True */;
|
|
traceUnionsOrIntersectionsTooLarge(source2, target2);
|
|
return recursiveTypeRelatedTo(source2, target2, false, 0 /* None */, recursionFlags);
|
|
}
|
|
if (source2.flags & 262144 /* TypeParameter */ && getConstraintOfType(source2) === target2) {
|
|
return -1 /* True */;
|
|
}
|
|
if (source2.flags & 470302716 /* DefinitelyNonNullable */ && target2.flags & 1048576 /* Union */) {
|
|
const types = target2.types;
|
|
const candidate = types.length === 2 && types[0].flags & 98304 /* Nullable */ ? types[1] : types.length === 3 && types[0].flags & 98304 /* Nullable */ && types[1].flags & 98304 /* Nullable */ ? types[2] : void 0;
|
|
if (candidate && !(candidate.flags & 98304 /* Nullable */)) {
|
|
target2 = getNormalizedType(candidate, true);
|
|
if (source2 === target2)
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
if (relation === comparableRelation && !(target2.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target2, source2, relation) || isSimpleTypeRelatedTo(source2, target2, relation, reportErrors2 ? reportError : void 0))
|
|
return -1 /* True */;
|
|
if (source2.flags & 469499904 /* StructuredOrInstantiable */ || target2.flags & 469499904 /* StructuredOrInstantiable */) {
|
|
const isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType2(source2) && getObjectFlags(source2) & 8192 /* FreshLiteral */);
|
|
if (isPerformingExcessPropertyChecks) {
|
|
if (hasExcessProperties(source2, target2, reportErrors2)) {
|
|
if (reportErrors2) {
|
|
reportRelationError(headMessage2, source2, originalTarget.aliasSymbol ? originalTarget : target2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source2)) && !(intersectionState & 2 /* Target */) && source2.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source2 !== globalObjectType && target2.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target2) && (getPropertiesOfType(source2).length > 0 || typeHasCallOrConstructSignatures2(source2));
|
|
const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
|
|
if (isPerformingCommonPropertyChecks && !hasCommonProperties(source2, target2, isComparingJsxAttributes)) {
|
|
if (reportErrors2) {
|
|
const sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source2);
|
|
const targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target2);
|
|
const calls = getSignaturesOfType(source2, 0 /* Call */);
|
|
const constructs = getSignaturesOfType(source2, 1 /* Construct */);
|
|
if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target2, 1 /* Source */, false) || constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target2, 1 /* Source */, false)) {
|
|
reportError(Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
|
|
} else {
|
|
reportError(Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
traceUnionsOrIntersectionsTooLarge(source2, target2);
|
|
const skipCaching = source2.flags & 1048576 /* Union */ && source2.types.length < 4 && !(target2.flags & 1048576 /* Union */) || target2.flags & 1048576 /* Union */ && target2.types.length < 4 && !(source2.flags & 469499904 /* StructuredOrInstantiable */);
|
|
const result2 = skipCaching ? unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState) : recursiveTypeRelatedTo(source2, target2, reportErrors2, intersectionState, recursionFlags);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
reportErrorResults(originalSource, originalTarget, source2, target2, headMessage2);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function reportErrorResults(originalSource, originalTarget, source2, target2, headMessage2) {
|
|
var _a3, _b;
|
|
const sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
|
|
const targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
|
|
source2 = originalSource.aliasSymbol || sourceHasBase ? originalSource : source2;
|
|
target2 = originalTarget.aliasSymbol || targetHasBase ? originalTarget : target2;
|
|
let maybeSuppress = overrideNextErrorInfo > 0;
|
|
if (maybeSuppress) {
|
|
overrideNextErrorInfo--;
|
|
}
|
|
if (source2.flags & 524288 /* Object */ && target2.flags & 524288 /* Object */) {
|
|
const currentError = errorInfo;
|
|
tryElaborateArrayLikeErrors(source2, target2, true);
|
|
if (errorInfo !== currentError) {
|
|
maybeSuppress = !!errorInfo;
|
|
}
|
|
}
|
|
if (source2.flags & 524288 /* Object */ && target2.flags & 131068 /* Primitive */) {
|
|
tryElaborateErrorsForPrimitivesAndObjects(source2, target2);
|
|
} else if (source2.symbol && source2.flags & 524288 /* Object */ && globalObjectType === source2) {
|
|
reportError(Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
|
|
} else if (getObjectFlags(source2) & 2048 /* JsxAttributes */ && target2.flags & 2097152 /* Intersection */) {
|
|
const targetTypes = target2.types;
|
|
const intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
|
|
const intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
|
|
if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) && (contains(targetTypes, intrinsicAttributes) || contains(targetTypes, intrinsicClassAttributes))) {
|
|
return;
|
|
}
|
|
} else {
|
|
errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
|
|
}
|
|
if (!headMessage2 && maybeSuppress) {
|
|
lastSkippedInfo = [source2, target2];
|
|
return;
|
|
}
|
|
reportRelationError(headMessage2, source2, target2);
|
|
if (source2.flags & 262144 /* TypeParameter */ && ((_b = (_a3 = source2.symbol) == null ? void 0 : _a3.declarations) == null ? void 0 : _b[0]) && !getConstraintOfType(source2)) {
|
|
const syntheticParam = cloneTypeParameter(source2);
|
|
syntheticParam.constraint = instantiateType(target2, makeUnaryTypeMapper(source2, syntheticParam));
|
|
if (hasNonCircularBaseConstraint(syntheticParam)) {
|
|
const targetConstraintString = typeToString(target2, source2.symbol.declarations[0]);
|
|
associateRelatedInfo(createDiagnosticForNode(source2.symbol.declarations[0], Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
|
|
}
|
|
}
|
|
}
|
|
function traceUnionsOrIntersectionsTooLarge(source2, target2) {
|
|
if (!tracing) {
|
|
return;
|
|
}
|
|
if (source2.flags & 3145728 /* UnionOrIntersection */ && target2.flags & 3145728 /* UnionOrIntersection */) {
|
|
const sourceUnionOrIntersection = source2;
|
|
const targetUnionOrIntersection = target2;
|
|
if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 32768 /* PrimitiveUnion */) {
|
|
return;
|
|
}
|
|
const sourceSize = sourceUnionOrIntersection.types.length;
|
|
const targetSize = targetUnionOrIntersection.types.length;
|
|
if (sourceSize * targetSize > 1e6) {
|
|
tracing.instant(tracing.Phase.CheckTypes, "traceUnionsOrIntersectionsTooLarge_DepthLimit", {
|
|
sourceId: source2.id,
|
|
sourceSize,
|
|
targetId: target2.id,
|
|
targetSize,
|
|
pos: errorNode == null ? void 0 : errorNode.pos,
|
|
end: errorNode == null ? void 0 : errorNode.end
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfPropertyInTypes(types, name) {
|
|
const appendPropType = (propTypes, type) => {
|
|
var _a3;
|
|
type = getApparentType(type);
|
|
const prop = type.flags & 3145728 /* UnionOrIntersection */ ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name);
|
|
const propType = prop && getTypeOfSymbol(prop) || ((_a3 = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a3.type) || undefinedType;
|
|
return append(propTypes, propType);
|
|
};
|
|
return getUnionType(reduceLeft(types, appendPropType, void 0) || emptyArray);
|
|
}
|
|
function hasExcessProperties(source2, target2, reportErrors2) {
|
|
var _a3;
|
|
if (!isExcessPropertyCheckTarget(target2) || !noImplicitAny && getObjectFlags(target2) & 4096 /* JSLiteral */) {
|
|
return false;
|
|
}
|
|
const isComparingJsxAttributes = !!(getObjectFlags(source2) & 2048 /* JsxAttributes */);
|
|
if ((relation === assignableRelation || relation === comparableRelation) && (isTypeSubsetOf(globalObjectType, target2) || !isComparingJsxAttributes && isEmptyObjectType(target2))) {
|
|
return false;
|
|
}
|
|
let reducedTarget = target2;
|
|
let checkTypes;
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
reducedTarget = findMatchingDiscriminantType(source2, target2, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target2);
|
|
checkTypes = reducedTarget.flags & 1048576 /* Union */ ? reducedTarget.types : [reducedTarget];
|
|
}
|
|
for (const prop of getPropertiesOfType(source2)) {
|
|
if (shouldCheckAsExcessProperty(prop, source2.symbol) && !isIgnoredJsxProperty(source2, prop)) {
|
|
if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
|
|
if (reportErrors2) {
|
|
const errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget);
|
|
if (!errorNode)
|
|
return Debug.fail();
|
|
if (isJsxAttributes(errorNode) || isJsxOpeningLikeElement(errorNode) || isJsxOpeningLikeElement(errorNode.parent)) {
|
|
if (prop.valueDeclaration && isJsxAttribute(prop.valueDeclaration) && getSourceFileOfNode(errorNode) === getSourceFileOfNode(prop.valueDeclaration.name)) {
|
|
errorNode = prop.valueDeclaration.name;
|
|
}
|
|
const propName = symbolToString(prop);
|
|
const suggestionSymbol = getSuggestedSymbolForNonexistentJSXAttribute(propName, errorTarget);
|
|
const suggestion = suggestionSymbol ? symbolToString(suggestionSymbol) : void 0;
|
|
if (suggestion) {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(errorTarget), suggestion);
|
|
} else {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, propName, typeToString(errorTarget));
|
|
}
|
|
} else {
|
|
const objectLiteralDeclaration = ((_a3 = source2.symbol) == null ? void 0 : _a3.declarations) && firstOrUndefined(source2.symbol.declarations);
|
|
let suggestion;
|
|
if (prop.valueDeclaration && findAncestor(prop.valueDeclaration, (d) => d === objectLiteralDeclaration) && getSourceFileOfNode(objectLiteralDeclaration) === getSourceFileOfNode(errorNode)) {
|
|
const propDeclaration = prop.valueDeclaration;
|
|
Debug.assertNode(propDeclaration, isObjectLiteralElementLike);
|
|
errorNode = propDeclaration;
|
|
const name = propDeclaration.name;
|
|
if (isIdentifier(name)) {
|
|
suggestion = getSuggestionForNonexistentProperty(name, errorTarget);
|
|
}
|
|
}
|
|
if (suggestion !== void 0) {
|
|
reportError(
|
|
Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2,
|
|
symbolToString(prop),
|
|
typeToString(errorTarget),
|
|
suggestion
|
|
);
|
|
} else {
|
|
reportError(
|
|
Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
|
|
symbolToString(prop),
|
|
typeToString(errorTarget)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), 3 /* Both */, reportErrors2)) {
|
|
if (reportErrors2) {
|
|
reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function shouldCheckAsExcessProperty(prop, container) {
|
|
return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
|
|
}
|
|
function unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState) {
|
|
if (source2.flags & 1048576 /* Union */) {
|
|
return relation === comparableRelation ? someTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState) : eachTypeRelatedToType(source2, target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */), intersectionState);
|
|
}
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source2), target2, reportErrors2 && !(source2.flags & 131068 /* Primitive */) && !(target2.flags & 131068 /* Primitive */));
|
|
}
|
|
if (target2.flags & 2097152 /* Intersection */) {
|
|
return typeRelatedToEachType(source2, target2, reportErrors2, 2 /* Target */);
|
|
}
|
|
if (relation === comparableRelation && target2.flags & 131068 /* Primitive */) {
|
|
const constraints = sameMap(source2.types, (t) => t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(t) || unknownType : t);
|
|
if (constraints !== source2.types) {
|
|
source2 = getIntersectionType(constraints);
|
|
if (source2.flags & 131072 /* Never */) {
|
|
return 0 /* False */;
|
|
}
|
|
if (!(source2.flags & 2097152 /* Intersection */)) {
|
|
return isRelatedTo(source2, target2, 1 /* Source */, false) || isRelatedTo(target2, source2, 1 /* Source */, false);
|
|
}
|
|
}
|
|
}
|
|
return someTypeRelatedToType(source2, target2, false, 1 /* Source */);
|
|
}
|
|
function eachTypeRelatedToSomeType(source2, target2) {
|
|
let result2 = -1 /* True */;
|
|
const sourceTypes = source2.types;
|
|
for (const sourceType of sourceTypes) {
|
|
const related = typeRelatedToSomeType(sourceType, target2, false);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeRelatedToSomeType(source2, target2, reportErrors2) {
|
|
const targetTypes = target2.types;
|
|
if (target2.flags & 1048576 /* Union */) {
|
|
if (containsType(targetTypes, source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const match = getMatchingUnionConstituentForType(target2, source2);
|
|
if (match) {
|
|
const related = isRelatedTo(source2, match, 2 /* Target */, false);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
}
|
|
for (const type of targetTypes) {
|
|
const related = isRelatedTo(source2, type, 2 /* Target */, false);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
const bestMatchingType = getBestMatchingType(source2, target2, isRelatedTo);
|
|
if (bestMatchingType) {
|
|
isRelatedTo(source2, bestMatchingType, 2 /* Target */, true);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function typeRelatedToEachType(source2, target2, reportErrors2, intersectionState) {
|
|
let result2 = -1 /* True */;
|
|
const targetTypes = target2.types;
|
|
for (const targetType of targetTypes) {
|
|
const related = isRelatedTo(source2, targetType, 2 /* Target */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function someTypeRelatedToType(source2, target2, reportErrors2, intersectionState) {
|
|
const sourceTypes = source2.types;
|
|
if (source2.flags & 1048576 /* Union */ && containsType(sourceTypes, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const len = sourceTypes.length;
|
|
for (let i = 0; i < len; i++) {
|
|
const related = isRelatedTo(sourceTypes[i], target2, 1 /* Source */, reportErrors2 && i === len - 1, void 0, intersectionState);
|
|
if (related) {
|
|
return related;
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function getUndefinedStrippedTargetIfNeeded(source2, target2) {
|
|
if (source2.flags & 1048576 /* Union */ && target2.flags & 1048576 /* Union */ && !(source2.types[0].flags & 32768 /* Undefined */) && target2.types[0].flags & 32768 /* Undefined */) {
|
|
return extractTypesOfKind(target2, ~32768 /* Undefined */);
|
|
}
|
|
return target2;
|
|
}
|
|
function eachTypeRelatedToType(source2, target2, reportErrors2, intersectionState) {
|
|
let result2 = -1 /* True */;
|
|
const sourceTypes = source2.types;
|
|
const undefinedStrippedTarget = getUndefinedStrippedTargetIfNeeded(source2, target2);
|
|
for (let i = 0; i < sourceTypes.length; i++) {
|
|
const sourceType = sourceTypes[i];
|
|
if (undefinedStrippedTarget.flags & 1048576 /* Union */ && sourceTypes.length >= undefinedStrippedTarget.types.length && sourceTypes.length % undefinedStrippedTarget.types.length === 0) {
|
|
const related2 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], 3 /* Both */, false, void 0, intersectionState);
|
|
if (related2) {
|
|
result2 &= related2;
|
|
continue;
|
|
}
|
|
}
|
|
const related = isRelatedTo(sourceType, target2, 1 /* Source */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeArgumentsRelatedTo(sources = emptyArray, targets = emptyArray, variances = emptyArray, reportErrors2, intersectionState) {
|
|
if (sources.length !== targets.length && relation === identityRelation) {
|
|
return 0 /* False */;
|
|
}
|
|
const length2 = sources.length <= targets.length ? sources.length : targets.length;
|
|
let result2 = -1 /* True */;
|
|
for (let i = 0; i < length2; i++) {
|
|
const varianceFlags = i < variances.length ? variances[i] : 1 /* Covariant */;
|
|
const variance = varianceFlags & 7 /* VarianceMask */;
|
|
if (variance !== 4 /* Independent */) {
|
|
const s = sources[i];
|
|
const t = targets[i];
|
|
let related = -1 /* True */;
|
|
if (varianceFlags & 8 /* Unmeasurable */) {
|
|
related = relation === identityRelation ? isRelatedTo(s, t, 3 /* Both */, false) : compareTypesIdentical(s, t);
|
|
} else if (variance === 1 /* Covariant */) {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
} else if (variance === 2 /* Contravariant */) {
|
|
related = isRelatedTo(t, s, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
} else if (variance === 3 /* Bivariant */) {
|
|
related = isRelatedTo(t, s, 3 /* Both */, false);
|
|
if (!related) {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
} else {
|
|
related = isRelatedTo(s, t, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
if (related) {
|
|
related &= isRelatedTo(t, s, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
}
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function recursiveTypeRelatedTo(source2, target2, reportErrors2, intersectionState, recursionFlags) {
|
|
var _a3, _b, _c;
|
|
if (overflow) {
|
|
return 0 /* False */;
|
|
}
|
|
const id = getRelationKey(source2, target2, intersectionState, relation, false);
|
|
const entry = relation.get(id);
|
|
if (entry !== void 0) {
|
|
if (reportErrors2 && entry & 2 /* Failed */ && !(entry & 4 /* Reported */)) {
|
|
} else {
|
|
if (outofbandVarianceMarkerHandler) {
|
|
const saved = entry & 24 /* ReportsMask */;
|
|
if (saved & 8 /* ReportsUnmeasurable */) {
|
|
instantiateType(source2, reportUnmeasurableMapper);
|
|
}
|
|
if (saved & 16 /* ReportsUnreliable */) {
|
|
instantiateType(source2, reportUnreliableMapper);
|
|
}
|
|
}
|
|
return entry & 1 /* Succeeded */ ? -1 /* True */ : 0 /* False */;
|
|
}
|
|
}
|
|
if (!maybeKeys) {
|
|
maybeKeys = [];
|
|
sourceStack = [];
|
|
targetStack = [];
|
|
} else {
|
|
const broadestEquivalentId = id.startsWith("*") ? getRelationKey(source2, target2, intersectionState, relation, true) : void 0;
|
|
for (let i = 0; i < maybeCount; i++) {
|
|
if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
}
|
|
if (sourceDepth === 100 || targetDepth === 100) {
|
|
overflow = true;
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const maybeStart = maybeCount;
|
|
maybeKeys[maybeCount] = id;
|
|
maybeCount++;
|
|
const saveExpandingFlags = expandingFlags;
|
|
if (recursionFlags & 1 /* Source */) {
|
|
sourceStack[sourceDepth] = source2;
|
|
sourceDepth++;
|
|
if (!(expandingFlags & 1 /* Source */) && isDeeplyNestedType(source2, sourceStack, sourceDepth))
|
|
expandingFlags |= 1 /* Source */;
|
|
}
|
|
if (recursionFlags & 2 /* Target */) {
|
|
targetStack[targetDepth] = target2;
|
|
targetDepth++;
|
|
if (!(expandingFlags & 2 /* Target */) && isDeeplyNestedType(target2, targetStack, targetDepth))
|
|
expandingFlags |= 2 /* Target */;
|
|
}
|
|
let originalHandler;
|
|
let propagatingVarianceFlags = 0;
|
|
if (outofbandVarianceMarkerHandler) {
|
|
originalHandler = outofbandVarianceMarkerHandler;
|
|
outofbandVarianceMarkerHandler = (onlyUnreliable) => {
|
|
propagatingVarianceFlags |= onlyUnreliable ? 16 /* ReportsUnreliable */ : 8 /* ReportsUnmeasurable */;
|
|
return originalHandler(onlyUnreliable);
|
|
};
|
|
}
|
|
let result2;
|
|
if (expandingFlags === 3 /* Both */) {
|
|
(_a3 = tracing) == null ? void 0 : _a3.instant(tracing.Phase.CheckTypes, "recursiveTypeRelatedTo_DepthLimit", {
|
|
sourceId: source2.id,
|
|
sourceIdStack: sourceStack.map((t) => t.id),
|
|
targetId: target2.id,
|
|
targetIdStack: targetStack.map((t) => t.id),
|
|
depth: sourceDepth,
|
|
targetDepth
|
|
});
|
|
result2 = 3 /* Maybe */;
|
|
} else {
|
|
(_b = tracing) == null ? void 0 : _b.push(tracing.Phase.CheckTypes, "structuredTypeRelatedTo", { sourceId: source2.id, targetId: target2.id });
|
|
result2 = structuredTypeRelatedTo(source2, target2, reportErrors2, intersectionState);
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
}
|
|
if (outofbandVarianceMarkerHandler) {
|
|
outofbandVarianceMarkerHandler = originalHandler;
|
|
}
|
|
if (recursionFlags & 1 /* Source */) {
|
|
sourceDepth--;
|
|
}
|
|
if (recursionFlags & 2 /* Target */) {
|
|
targetDepth--;
|
|
}
|
|
expandingFlags = saveExpandingFlags;
|
|
if (result2) {
|
|
if (result2 === -1 /* True */ || sourceDepth === 0 && targetDepth === 0) {
|
|
if (result2 === -1 /* True */ || result2 === 3 /* Maybe */) {
|
|
for (let i = maybeStart; i < maybeCount; i++) {
|
|
relation.set(maybeKeys[i], 1 /* Succeeded */ | propagatingVarianceFlags);
|
|
}
|
|
}
|
|
maybeCount = maybeStart;
|
|
}
|
|
} else {
|
|
relation.set(id, (reportErrors2 ? 4 /* Reported */ : 0) | 2 /* Failed */ | propagatingVarianceFlags);
|
|
maybeCount = maybeStart;
|
|
}
|
|
return result2;
|
|
}
|
|
function structuredTypeRelatedTo(source2, target2, reportErrors2, intersectionState) {
|
|
const saveErrorInfo = captureErrorCalculationState();
|
|
let result2 = structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo);
|
|
if (relation !== identityRelation) {
|
|
if (!result2 && (source2.flags & 2097152 /* Intersection */ || source2.flags & 262144 /* TypeParameter */ && target2.flags & 1048576 /* Union */)) {
|
|
const constraint = getEffectiveConstraintOfIntersection(source2.flags & 2097152 /* Intersection */ ? source2.types : [source2], !!(target2.flags & 1048576 /* Union */));
|
|
if (constraint && everyType(constraint, (c) => c !== source2)) {
|
|
result2 = isRelatedTo(constraint, target2, 1 /* Source */, false, void 0, intersectionState);
|
|
}
|
|
}
|
|
if (result2 && !inPropertyCheck && (target2.flags & 2097152 /* Intersection */ && !isGenericObjectType(target2) && source2.flags & (524288 /* Object */ | 2097152 /* Intersection */) || isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */)))) {
|
|
inPropertyCheck = true;
|
|
result2 &= propertiesRelatedTo(source2, target2, reportErrors2, void 0, 0 /* None */);
|
|
inPropertyCheck = false;
|
|
}
|
|
}
|
|
if (result2) {
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
return result2;
|
|
}
|
|
function structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo) {
|
|
let result2;
|
|
let originalErrorInfo;
|
|
let varianceCheckFailed = false;
|
|
let sourceFlags = source2.flags;
|
|
const targetFlags = target2.flags;
|
|
if (relation === identityRelation) {
|
|
if (sourceFlags & 3145728 /* UnionOrIntersection */) {
|
|
let result3 = eachTypeRelatedToSomeType(source2, target2);
|
|
if (result3) {
|
|
result3 &= eachTypeRelatedToSomeType(target2, source2);
|
|
}
|
|
return result3;
|
|
}
|
|
if (sourceFlags & 4194304 /* Index */) {
|
|
return isRelatedTo(source2.type, target2.type, 3 /* Both */, false);
|
|
}
|
|
if (sourceFlags & 8388608 /* IndexedAccess */) {
|
|
if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 16777216 /* Conditional */) {
|
|
if (source2.root.isDistributive === target2.root.isDistributive) {
|
|
if (result2 = isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.extendsType, target2.extendsType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(getTrueTypeFromConditionalType(source2), getTrueTypeFromConditionalType(target2), 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 33554432 /* Substitution */) {
|
|
if (result2 = isRelatedTo(source2.baseType, target2.baseType, 3 /* Both */, false)) {
|
|
if (result2 &= isRelatedTo(source2.constraint, target2.constraint, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (!(sourceFlags & 524288 /* Object */)) {
|
|
return 0 /* False */;
|
|
}
|
|
} else if (sourceFlags & 3145728 /* UnionOrIntersection */ || targetFlags & 3145728 /* UnionOrIntersection */) {
|
|
if (result2 = unionOrIntersectionRelatedTo(source2, target2, reportErrors2, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (!(sourceFlags & 465829888 /* Instantiable */ || sourceFlags & 524288 /* Object */ && targetFlags & 1048576 /* Union */ || sourceFlags & 2097152 /* Intersection */ && targetFlags & (524288 /* Object */ | 1048576 /* Union */ | 465829888 /* Instantiable */))) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 16777216 /* Conditional */) && source2.aliasSymbol && source2.aliasTypeArguments && source2.aliasSymbol === target2.aliasSymbol && !(isMarkerType(source2) || isMarkerType(target2))) {
|
|
const variances = getAliasVariances(source2.aliasSymbol);
|
|
if (variances === emptyArray) {
|
|
return 1 /* Unknown */;
|
|
}
|
|
const varianceResult = relateVariances(source2.aliasTypeArguments, target2.aliasTypeArguments, variances, intersectionState);
|
|
if (varianceResult !== void 0) {
|
|
return varianceResult;
|
|
}
|
|
}
|
|
if (isSingleElementGenericTupleType(source2) && !source2.target.readonly && (result2 = isRelatedTo(getTypeArguments(source2)[0], target2, 1 /* Source */)) || isSingleElementGenericTupleType(target2) && (target2.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source2) || source2)) && (result2 = isRelatedTo(source2, getTypeArguments(target2)[0], 2 /* Target */))) {
|
|
return result2;
|
|
}
|
|
if (targetFlags & 262144 /* TypeParameter */) {
|
|
if (getObjectFlags(source2) & 32 /* Mapped */ && !source2.declaration.nameType && isRelatedTo(getIndexType(target2), getConstraintTypeFromMappedType(source2), 3 /* Both */)) {
|
|
if (!(getMappedTypeModifiers(source2) & 4 /* IncludeOptional */)) {
|
|
const templateType = getTemplateTypeFromMappedType(source2);
|
|
const indexedAccessType = getIndexedAccessType(target2, getTypeParameterFromMappedType(source2));
|
|
if (result2 = isRelatedTo(templateType, indexedAccessType, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
if (relation === comparableRelation && sourceFlags & 262144 /* TypeParameter */) {
|
|
let constraint = getConstraintOfTypeParameter(source2);
|
|
if (constraint && hasNonCircularBaseConstraint(source2)) {
|
|
while (constraint && someType(constraint, (c) => !!(c.flags & 262144 /* TypeParameter */))) {
|
|
if (result2 = isRelatedTo(constraint, target2, 1 /* Source */, false)) {
|
|
return result2;
|
|
}
|
|
constraint = getConstraintOfTypeParameter(constraint);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (targetFlags & 4194304 /* Index */) {
|
|
const targetType = target2.type;
|
|
if (sourceFlags & 4194304 /* Index */) {
|
|
if (result2 = isRelatedTo(targetType, source2.type, 3 /* Both */, false)) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (isTupleType(targetType)) {
|
|
if (result2 = isRelatedTo(source2, getKnownKeysOfTupleType(targetType), 2 /* Target */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const constraint = getSimplifiedTypeOrConstraint(targetType);
|
|
if (constraint) {
|
|
if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
|
|
return -1 /* True */;
|
|
}
|
|
} else if (isGenericMappedType(targetType)) {
|
|
const nameType = getNameTypeFromMappedType(targetType);
|
|
const constraintType = getConstraintTypeFromMappedType(targetType);
|
|
let targetKeys;
|
|
if (nameType && isMappedTypeWithKeyofConstraintDeclaration(targetType)) {
|
|
const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
|
|
const mappedKeys = [];
|
|
forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
|
|
modifiersType,
|
|
8576 /* StringOrNumberLiteralOrUnique */,
|
|
false,
|
|
(t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
|
|
);
|
|
targetKeys = getUnionType([...mappedKeys, nameType]);
|
|
} else {
|
|
targetKeys = nameType || constraintType;
|
|
}
|
|
if (isRelatedTo(source2, targetKeys, 2 /* Target */, reportErrors2) === -1 /* True */) {
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
}
|
|
} else if (targetFlags & 8388608 /* IndexedAccess */) {
|
|
if (sourceFlags & 8388608 /* IndexedAccess */) {
|
|
if (result2 = isRelatedTo(source2.objectType, target2.objectType, 3 /* Both */, reportErrors2)) {
|
|
result2 &= isRelatedTo(source2.indexType, target2.indexType, 3 /* Both */, reportErrors2);
|
|
}
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
if (reportErrors2) {
|
|
originalErrorInfo = errorInfo;
|
|
}
|
|
}
|
|
if (relation === assignableRelation || relation === comparableRelation) {
|
|
const objectType = target2.objectType;
|
|
const indexType = target2.indexType;
|
|
const baseObjectType = getBaseConstraintOfType(objectType) || objectType;
|
|
const baseIndexType = getBaseConstraintOfType(indexType) || indexType;
|
|
if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) {
|
|
const accessFlags = 4 /* Writing */ | (baseObjectType !== objectType ? 2 /* NoIndexSignatures */ : 0);
|
|
const constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, accessFlags);
|
|
if (constraint) {
|
|
if (reportErrors2 && originalErrorInfo) {
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
if (result2 = isRelatedTo(source2, constraint, 2 /* Target */, reportErrors2, void 0, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (reportErrors2 && originalErrorInfo && errorInfo) {
|
|
errorInfo = countMessageChainBreadth([originalErrorInfo]) <= countMessageChainBreadth([errorInfo]) ? originalErrorInfo : errorInfo;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (reportErrors2) {
|
|
originalErrorInfo = void 0;
|
|
}
|
|
} else if (isGenericMappedType(target2) && relation !== identityRelation) {
|
|
const keysRemapped = !!target2.declaration.nameType;
|
|
const templateType = getTemplateTypeFromMappedType(target2);
|
|
const modifiers = getMappedTypeModifiers(target2);
|
|
if (!(modifiers & 8 /* ExcludeOptional */)) {
|
|
if (!keysRemapped && templateType.flags & 8388608 /* IndexedAccess */ && templateType.objectType === source2 && templateType.indexType === getTypeParameterFromMappedType(target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (!isGenericMappedType(source2)) {
|
|
const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
|
|
const sourceKeys = getIndexType(source2, void 0, true);
|
|
const includeOptional = modifiers & 4 /* IncludeOptional */;
|
|
const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
|
|
if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
|
|
const templateType2 = getTemplateTypeFromMappedType(target2);
|
|
const typeParameter = getTypeParameterFromMappedType(target2);
|
|
const nonNullComponent = extractTypesOfKind(templateType2, ~98304 /* Nullable */);
|
|
if (!keysRemapped && nonNullComponent.flags & 8388608 /* IndexedAccess */ && nonNullComponent.indexType === typeParameter) {
|
|
if (result2 = isRelatedTo(source2, nonNullComponent.objectType, 2 /* Target */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const indexingType = keysRemapped ? filteredByApplicability || targetKeys : filteredByApplicability ? getIntersectionType([filteredByApplicability, typeParameter]) : typeParameter;
|
|
const indexedAccessType = getIndexedAccessType(source2, indexingType);
|
|
if (result2 = isRelatedTo(indexedAccessType, templateType2, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
originalErrorInfo = errorInfo;
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
}
|
|
} else if (targetFlags & 16777216 /* Conditional */) {
|
|
if (isDeeplyNestedType(target2, targetStack, targetDepth, 10)) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
const c = target2;
|
|
if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
|
|
const skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
|
|
const skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
|
|
if (result2 = skipTrue ? -1 /* True */ : isRelatedTo(source2, getTrueTypeFromConditionalType(c), 2 /* Target */, false, void 0, intersectionState)) {
|
|
result2 &= skipFalse ? -1 /* True */ : isRelatedTo(source2, getFalseTypeFromConditionalType(c), 2 /* Target */, false, void 0, intersectionState);
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
} else if (targetFlags & 134217728 /* TemplateLiteral */) {
|
|
if (sourceFlags & 134217728 /* TemplateLiteral */) {
|
|
if (relation === comparableRelation) {
|
|
return templateLiteralTypesDefinitelyUnrelated(source2, target2) ? 0 /* False */ : -1 /* True */;
|
|
}
|
|
instantiateType(source2, reportUnreliableMapper);
|
|
}
|
|
if (isTypeMatchedByTemplateLiteralType(source2, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
} else if (target2.flags & 268435456 /* StringMapping */) {
|
|
if (!(source2.flags & 268435456 /* StringMapping */)) {
|
|
if (isMemberOfStringMapping(source2, target2)) {
|
|
return -1 /* True */;
|
|
}
|
|
}
|
|
}
|
|
if (sourceFlags & 8650752 /* TypeVariable */) {
|
|
if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
|
|
const constraint = getConstraintOfType(source2) || unknownType;
|
|
if (result2 = isRelatedTo(constraint, target2, 1 /* Source */, false, void 0, intersectionState)) {
|
|
return result2;
|
|
} else if (result2 = isRelatedTo(getTypeWithThisArgument(constraint, source2), target2, 1 /* Source */, reportErrors2 && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), void 0, intersectionState)) {
|
|
return result2;
|
|
}
|
|
if (isMappedTypeGenericIndexedAccess(source2)) {
|
|
const indexConstraint = getConstraintOfType(source2.indexType);
|
|
if (indexConstraint) {
|
|
if (result2 = isRelatedTo(getIndexedAccessType(source2.objectType, indexConstraint), target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (sourceFlags & 4194304 /* Index */) {
|
|
if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
|
|
if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
|
|
const constraint = getBaseConstraintOfType(source2);
|
|
if (constraint && constraint !== source2 && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else if (sourceFlags & 268435456 /* StringMapping */) {
|
|
if (targetFlags & 268435456 /* StringMapping */) {
|
|
if (source2.symbol !== target2.symbol) {
|
|
return 0 /* False */;
|
|
}
|
|
if (result2 = isRelatedTo(source2.type, target2.type, 3 /* Both */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
} else {
|
|
const constraint = getBaseConstraintOfType(source2);
|
|
if (constraint && (result2 = isRelatedTo(constraint, target2, 1 /* Source */, reportErrors2))) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else if (sourceFlags & 16777216 /* Conditional */) {
|
|
if (isDeeplyNestedType(source2, sourceStack, sourceDepth, 10)) {
|
|
return 3 /* Maybe */;
|
|
}
|
|
if (targetFlags & 16777216 /* Conditional */) {
|
|
const sourceParams = source2.root.inferTypeParameters;
|
|
let sourceExtends = source2.extendsType;
|
|
let mapper;
|
|
if (sourceParams) {
|
|
const ctx = createInferenceContext(sourceParams, void 0, 0 /* None */, isRelatedToWorker);
|
|
inferTypes(ctx.inferences, target2.extendsType, sourceExtends, 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
|
|
sourceExtends = instantiateType(sourceExtends, ctx.mapper);
|
|
mapper = ctx.mapper;
|
|
}
|
|
if (isTypeIdenticalTo(sourceExtends, target2.extendsType) && (isRelatedTo(source2.checkType, target2.checkType, 3 /* Both */) || isRelatedTo(target2.checkType, source2.checkType, 3 /* Both */))) {
|
|
if (result2 = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source2), mapper), getTrueTypeFromConditionalType(target2), 3 /* Both */, reportErrors2)) {
|
|
result2 &= isRelatedTo(getFalseTypeFromConditionalType(source2), getFalseTypeFromConditionalType(target2), 3 /* Both */, reportErrors2);
|
|
}
|
|
if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else {
|
|
const distributiveConstraint = hasNonCircularBaseConstraint(source2) ? getConstraintOfDistributiveConditionalType(source2) : void 0;
|
|
if (distributiveConstraint) {
|
|
if (result2 = isRelatedTo(distributiveConstraint, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
}
|
|
const defaultConstraint = getDefaultConstraintOfConditionalType(source2);
|
|
if (defaultConstraint) {
|
|
if (result2 = isRelatedTo(defaultConstraint, target2, 1 /* Source */, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
} else {
|
|
if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target2) && isEmptyObjectType(source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
if (isGenericMappedType(target2)) {
|
|
if (isGenericMappedType(source2)) {
|
|
if (result2 = mappedTypeRelatedTo(source2, target2, reportErrors2)) {
|
|
return result2;
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
|
|
if (relation !== identityRelation) {
|
|
source2 = getApparentType(source2);
|
|
sourceFlags = source2.flags;
|
|
} else if (isGenericMappedType(source2)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (getObjectFlags(source2) & 4 /* Reference */ && getObjectFlags(target2) & 4 /* Reference */ && source2.target === target2.target && !isTupleType(source2) && !(isMarkerType(source2) || isMarkerType(target2))) {
|
|
if (isEmptyArrayLiteralType(source2)) {
|
|
return -1 /* True */;
|
|
}
|
|
const variances = getVariances(source2.target);
|
|
if (variances === emptyArray) {
|
|
return 1 /* Unknown */;
|
|
}
|
|
const varianceResult = relateVariances(getTypeArguments(source2), getTypeArguments(target2), variances, intersectionState);
|
|
if (varianceResult !== void 0) {
|
|
return varianceResult;
|
|
}
|
|
} else if (isReadonlyArrayType(target2) ? isArrayOrTupleType(source2) : isArrayType(target2) && isTupleType(source2) && !source2.target.readonly) {
|
|
if (relation !== identityRelation) {
|
|
return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, 3 /* Both */, reportErrors2);
|
|
} else {
|
|
return 0 /* False */;
|
|
}
|
|
} else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target2) && getObjectFlags(target2) & 8192 /* FreshLiteral */ && !isEmptyObjectType(source2)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 524288 /* Object */) {
|
|
const reportStructuralErrors = reportErrors2 && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
|
|
result2 = propertiesRelatedTo(source2, target2, reportStructuralErrors, void 0, intersectionState);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, target2, 0 /* Call */, reportStructuralErrors);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, target2, 1 /* Construct */, reportStructuralErrors);
|
|
if (result2) {
|
|
result2 &= indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportStructuralErrors, intersectionState);
|
|
}
|
|
}
|
|
}
|
|
if (varianceCheckFailed && result2) {
|
|
errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo;
|
|
} else if (result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 1048576 /* Union */) {
|
|
const objectOnlyTarget = extractTypesOfKind(target2, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
|
|
if (objectOnlyTarget.flags & 1048576 /* Union */) {
|
|
const result3 = typeRelatedToDiscriminatedType(source2, objectOnlyTarget);
|
|
if (result3) {
|
|
return result3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
function countMessageChainBreadth(info) {
|
|
if (!info)
|
|
return 0;
|
|
return reduceLeft(info, (value, chain) => value + 1 + countMessageChainBreadth(chain.next), 0);
|
|
}
|
|
function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState2) {
|
|
if (result2 = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors2, intersectionState2)) {
|
|
return result2;
|
|
}
|
|
if (some(variances, (v) => !!(v & 24 /* AllowsStructuralFallback */))) {
|
|
originalErrorInfo = void 0;
|
|
resetErrorInfo(saveErrorInfo);
|
|
return void 0;
|
|
}
|
|
const allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances);
|
|
varianceCheckFailed = !allowStructuralFallback;
|
|
if (variances !== emptyArray && !allowStructuralFallback) {
|
|
if (varianceCheckFailed && !(reportErrors2 && some(variances, (v) => (v & 7 /* VarianceMask */) === 0 /* Invariant */))) {
|
|
return 0 /* False */;
|
|
}
|
|
originalErrorInfo = errorInfo;
|
|
resetErrorInfo(saveErrorInfo);
|
|
}
|
|
}
|
|
}
|
|
function mappedTypeRelatedTo(source2, target2, reportErrors2) {
|
|
const modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source2) === getMappedTypeModifiers(target2) : getCombinedMappedTypeOptionality(source2) <= getCombinedMappedTypeOptionality(target2));
|
|
if (modifiersRelated) {
|
|
let result2;
|
|
const targetConstraint = getConstraintTypeFromMappedType(target2);
|
|
const sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source2), getCombinedMappedTypeOptionality(source2) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper);
|
|
if (result2 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* Both */, reportErrors2)) {
|
|
const mapper = createTypeMapper([getTypeParameterFromMappedType(source2)], [getTypeParameterFromMappedType(target2)]);
|
|
if (instantiateType(getNameTypeFromMappedType(source2), mapper) === instantiateType(getNameTypeFromMappedType(target2), mapper)) {
|
|
return result2 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source2), mapper), getTemplateTypeFromMappedType(target2), 3 /* Both */, reportErrors2);
|
|
}
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function typeRelatedToDiscriminatedType(source2, target2) {
|
|
var _a3;
|
|
const sourceProperties = getPropertiesOfType(source2);
|
|
const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target2);
|
|
if (!sourcePropertiesFiltered)
|
|
return 0 /* False */;
|
|
let numCombinations = 1;
|
|
for (const sourceProperty of sourcePropertiesFiltered) {
|
|
numCombinations *= countTypes(getNonMissingTypeOfSymbol(sourceProperty));
|
|
if (numCombinations > 25) {
|
|
(_a3 = tracing) == null ? void 0 : _a3.instant(tracing.Phase.CheckTypes, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source2.id, targetId: target2.id, numCombinations });
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length);
|
|
const excludedProperties = /* @__PURE__ */ new Set();
|
|
for (let i = 0; i < sourcePropertiesFiltered.length; i++) {
|
|
const sourceProperty = sourcePropertiesFiltered[i];
|
|
const sourcePropertyType = getNonMissingTypeOfSymbol(sourceProperty);
|
|
sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576 /* Union */ ? sourcePropertyType.types : [sourcePropertyType];
|
|
excludedProperties.add(sourceProperty.escapedName);
|
|
}
|
|
const discriminantCombinations = cartesianProduct(sourceDiscriminantTypes);
|
|
const matchingTypes = [];
|
|
for (const combination of discriminantCombinations) {
|
|
let hasMatch = false;
|
|
outer:
|
|
for (const type of target2.types) {
|
|
for (let i = 0; i < sourcePropertiesFiltered.length; i++) {
|
|
const sourceProperty = sourcePropertiesFiltered[i];
|
|
const targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
|
|
if (!targetProperty)
|
|
continue outer;
|
|
if (sourceProperty === targetProperty)
|
|
continue;
|
|
const related = propertyRelatedTo(source2, target2, sourceProperty, targetProperty, (_) => combination[i], false, 0 /* None */, strictNullChecks || relation === comparableRelation);
|
|
if (!related) {
|
|
continue outer;
|
|
}
|
|
}
|
|
pushIfUnique(matchingTypes, type, equateValues);
|
|
hasMatch = true;
|
|
}
|
|
if (!hasMatch) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (const type of matchingTypes) {
|
|
result2 &= propertiesRelatedTo(source2, type, false, excludedProperties, 0 /* None */);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, type, 0 /* Call */, false);
|
|
if (result2) {
|
|
result2 &= signaturesRelatedTo(source2, type, 1 /* Construct */, false);
|
|
if (result2 && !(isTupleType(source2) && isTupleType(type))) {
|
|
result2 &= indexSignaturesRelatedTo(source2, type, false, false, 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
if (!result2) {
|
|
return result2;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function excludeProperties(properties, excludedProperties) {
|
|
if (!excludedProperties || properties.length === 0)
|
|
return properties;
|
|
let result2;
|
|
for (let i = 0; i < properties.length; i++) {
|
|
if (!excludedProperties.has(properties[i].escapedName)) {
|
|
if (result2) {
|
|
result2.push(properties[i]);
|
|
}
|
|
} else if (!result2) {
|
|
result2 = properties.slice(0, i);
|
|
}
|
|
}
|
|
return result2 || properties;
|
|
}
|
|
function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState) {
|
|
const targetIsOptional = strictNullChecks && !!(getCheckFlags(targetProp) & 48 /* Partial */);
|
|
const effectiveTarget = addOptionality(getNonMissingTypeOfSymbol(targetProp), false, targetIsOptional);
|
|
const effectiveSource = getTypeOfSourceProperty(sourceProp);
|
|
return isRelatedTo(effectiveSource, effectiveTarget, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
}
|
|
function propertyRelatedTo(source2, target2, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState, skipOptional) {
|
|
const sourcePropFlags = getDeclarationModifierFlagsFromSymbol(sourceProp);
|
|
const targetPropFlags = getDeclarationModifierFlagsFromSymbol(targetProp);
|
|
if (sourcePropFlags & 8 /* Private */ || targetPropFlags & 8 /* Private */) {
|
|
if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) {
|
|
if (reportErrors2) {
|
|
if (sourcePropFlags & 8 /* Private */ && targetPropFlags & 8 /* Private */) {
|
|
reportError(Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp));
|
|
} else {
|
|
reportError(
|
|
Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(sourcePropFlags & 8 /* Private */ ? source2 : target2),
|
|
typeToString(sourcePropFlags & 8 /* Private */ ? target2 : source2)
|
|
);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (targetPropFlags & 16 /* Protected */) {
|
|
if (!isValidOverrideOf(sourceProp, targetProp)) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2,
|
|
symbolToString(targetProp),
|
|
typeToString(getDeclaringClass(sourceProp) || source2),
|
|
typeToString(getDeclaringClass(targetProp) || target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
} else if (sourcePropFlags & 16 /* Protected */) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(source2),
|
|
typeToString(target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (relation === strictSubtypeRelation && isReadonlySymbol(sourceProp) && !isReadonlySymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
const related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors2, intersectionState);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
reportIncompatibleError(Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!skipOptional && sourceProp.flags & 16777216 /* Optional */ && targetProp.flags & 106500 /* ClassMember */ && !(targetProp.flags & 16777216 /* Optional */)) {
|
|
if (reportErrors2) {
|
|
reportError(
|
|
Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2,
|
|
symbolToString(targetProp),
|
|
typeToString(source2),
|
|
typeToString(target2)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
return related;
|
|
}
|
|
function reportUnmatchedProperty(source2, target2, unmatchedProperty, requireOptionalProperties) {
|
|
let shouldSkipElaboration = false;
|
|
if (unmatchedProperty.valueDeclaration && isNamedDeclaration(unmatchedProperty.valueDeclaration) && isPrivateIdentifier(unmatchedProperty.valueDeclaration.name) && source2.symbol && source2.symbol.flags & 32 /* Class */) {
|
|
const privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText;
|
|
const symbolTableKey = getSymbolNameForPrivateIdentifier(source2.symbol, privateIdentifierDescription);
|
|
if (symbolTableKey && getPropertyOfType(source2, symbolTableKey)) {
|
|
const sourceName = factory.getDeclarationName(source2.symbol.valueDeclaration);
|
|
const targetName = factory.getDeclarationName(target2.symbol.valueDeclaration);
|
|
reportError(
|
|
Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2,
|
|
diagnosticName(privateIdentifierDescription),
|
|
diagnosticName(sourceName.escapedText === "" ? anon : sourceName),
|
|
diagnosticName(targetName.escapedText === "" ? anon : targetName)
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
const props = arrayFrom(getUnmatchedProperties(source2, target2, requireOptionalProperties, false));
|
|
if (!headMessage || headMessage.code !== Diagnostics.Class_0_incorrectly_implements_interface_1.code && headMessage.code !== Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code) {
|
|
shouldSkipElaboration = true;
|
|
}
|
|
if (props.length === 1) {
|
|
const propName = symbolToString(unmatchedProperty, void 0, 0 /* None */, 4 /* AllowAnyNodeKind */ | 16 /* WriteComputedProps */);
|
|
reportError(Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName, ...getTypeNamesForErrorDisplay(source2, target2));
|
|
if (length(unmatchedProperty.declarations)) {
|
|
associateRelatedInfo(createDiagnosticForNode(unmatchedProperty.declarations[0], Diagnostics._0_is_declared_here, propName));
|
|
}
|
|
if (shouldSkipElaboration && errorInfo) {
|
|
overrideNextErrorInfo++;
|
|
}
|
|
} else if (tryElaborateArrayLikeErrors(source2, target2, false)) {
|
|
if (props.length > 5) {
|
|
reportError(Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source2), typeToString(target2), map(props.slice(0, 4), (p) => symbolToString(p)).join(", "), props.length - 4);
|
|
} else {
|
|
reportError(Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source2), typeToString(target2), map(props, (p) => symbolToString(p)).join(", "));
|
|
}
|
|
if (shouldSkipElaboration && errorInfo) {
|
|
overrideNextErrorInfo++;
|
|
}
|
|
}
|
|
}
|
|
function propertiesRelatedTo(source2, target2, reportErrors2, excludedProperties, intersectionState) {
|
|
if (relation === identityRelation) {
|
|
return propertiesIdenticalTo(source2, target2, excludedProperties);
|
|
}
|
|
let result2 = -1 /* True */;
|
|
if (isTupleType(target2)) {
|
|
if (isArrayOrTupleType(source2)) {
|
|
if (!target2.target.readonly && (isReadonlyArrayType(source2) || isTupleType(source2) && source2.target.readonly)) {
|
|
return 0 /* False */;
|
|
}
|
|
const sourceArity = getTypeReferenceArity(source2);
|
|
const targetArity = getTypeReferenceArity(target2);
|
|
const sourceRestFlag = isTupleType(source2) ? source2.target.combinedFlags & 4 /* Rest */ : 4 /* Rest */;
|
|
const targetRestFlag = target2.target.combinedFlags & 4 /* Rest */;
|
|
const sourceMinLength = isTupleType(source2) ? source2.target.minLength : 0;
|
|
const targetMinLength = target2.target.minLength;
|
|
if (!sourceRestFlag && sourceArity < targetMinLength) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_has_0_element_s_but_target_requires_1, sourceArity, targetMinLength);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!targetRestFlag && targetArity < sourceMinLength) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_has_0_element_s_but_target_allows_only_1, sourceMinLength, targetArity);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!targetRestFlag && (sourceRestFlag || targetArity < sourceArity)) {
|
|
if (reportErrors2) {
|
|
if (sourceMinLength < targetMinLength) {
|
|
reportError(Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer, targetMinLength);
|
|
} else {
|
|
reportError(Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more, targetArity);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
const sourceTypeArguments = getTypeArguments(source2);
|
|
const targetTypeArguments = getTypeArguments(target2);
|
|
const targetStartCount = getStartElementCount(target2.target, 11 /* NonRest */);
|
|
const targetEndCount = getEndElementCount(target2.target, 11 /* NonRest */);
|
|
const targetHasRestElement = target2.target.hasRestElement;
|
|
let canExcludeDiscriminants = !!excludedProperties;
|
|
for (let sourcePosition = 0; sourcePosition < sourceArity; sourcePosition++) {
|
|
const sourceFlags = isTupleType(source2) ? source2.target.elementFlags[sourcePosition] : 4 /* Rest */;
|
|
const sourcePositionFromEnd = sourceArity - 1 - sourcePosition;
|
|
const targetPosition = targetHasRestElement && sourcePosition >= targetStartCount ? targetArity - 1 - Math.min(sourcePositionFromEnd, targetEndCount) : sourcePosition;
|
|
const targetFlags = target2.target.elementFlags[targetPosition];
|
|
if (targetFlags & 8 /* Variadic */ && !(sourceFlags & 8 /* Variadic */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (sourceFlags & 8 /* Variadic */ && !(targetFlags & 12 /* Variable */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourcePosition, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (targetFlags & 1 /* Required */ && !(sourceFlags & 1 /* Required */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, targetPosition);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (canExcludeDiscriminants) {
|
|
if (sourceFlags & 12 /* Variable */ || targetFlags & 12 /* Variable */) {
|
|
canExcludeDiscriminants = false;
|
|
}
|
|
if (canExcludeDiscriminants && (excludedProperties == null ? void 0 : excludedProperties.has("" + sourcePosition))) {
|
|
continue;
|
|
}
|
|
}
|
|
const sourceType = removeMissingType(sourceTypeArguments[sourcePosition], !!(sourceFlags & targetFlags & 2 /* Optional */));
|
|
const targetType = targetTypeArguments[targetPosition];
|
|
const targetCheckType = sourceFlags & 8 /* Variadic */ && targetFlags & 4 /* Rest */ ? createArrayType(targetType) : removeMissingType(targetType, !!(targetFlags & 2 /* Optional */));
|
|
const related = isRelatedTo(sourceType, targetCheckType, 3 /* Both */, reportErrors2, void 0, intersectionState);
|
|
if (!related) {
|
|
if (reportErrors2 && (targetArity > 1 || sourceArity > 1)) {
|
|
if (targetHasRestElement && sourcePosition >= targetStartCount && sourcePositionFromEnd >= targetEndCount && targetStartCount !== sourceArity - targetEndCount - 1) {
|
|
reportIncompatibleError(Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, targetStartCount, sourceArity - targetEndCount - 1, targetPosition);
|
|
} else {
|
|
reportIncompatibleError(Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourcePosition, targetPosition);
|
|
}
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
if (target2.target.combinedFlags & 12 /* Variable */) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
const requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType2(source2) && !isEmptyArrayLiteralType(source2) && !isTupleType(source2);
|
|
const unmatchedProperty = getUnmatchedProperty(source2, target2, requireOptionalProperties, false);
|
|
if (unmatchedProperty) {
|
|
if (reportErrors2 && shouldReportUnmatchedPropertyError(source2, target2)) {
|
|
reportUnmatchedProperty(source2, target2, unmatchedProperty, requireOptionalProperties);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (isObjectLiteralType2(target2)) {
|
|
for (const sourceProp of excludeProperties(getPropertiesOfType(source2), excludedProperties)) {
|
|
if (!getPropertyOfObjectType(target2, sourceProp.escapedName)) {
|
|
const sourceType = getTypeOfSymbol(sourceProp);
|
|
if (!(sourceType.flags & 32768 /* Undefined */)) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target2));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const properties = getPropertiesOfType(target2);
|
|
const numericNamesOnly = isTupleType(source2) && isTupleType(target2);
|
|
for (const targetProp of excludeProperties(properties, excludedProperties)) {
|
|
const name = targetProp.escapedName;
|
|
if (!(targetProp.flags & 4194304 /* Prototype */) && (!numericNamesOnly || isNumericLiteralName(name) || name === "length")) {
|
|
const sourceProp = getPropertyOfType(source2, name);
|
|
if (sourceProp && sourceProp !== targetProp) {
|
|
const related = propertyRelatedTo(source2, target2, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors2, intersectionState, relation === comparableRelation);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function propertiesIdenticalTo(source2, target2, excludedProperties) {
|
|
if (!(source2.flags & 524288 /* Object */ && target2.flags & 524288 /* Object */)) {
|
|
return 0 /* False */;
|
|
}
|
|
const sourceProperties = excludeProperties(getPropertiesOfObjectType(source2), excludedProperties);
|
|
const targetProperties = excludeProperties(getPropertiesOfObjectType(target2), excludedProperties);
|
|
if (sourceProperties.length !== targetProperties.length) {
|
|
return 0 /* False */;
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (const sourceProp of sourceProperties) {
|
|
const targetProp = getPropertyOfObjectType(target2, sourceProp.escapedName);
|
|
if (!targetProp) {
|
|
return 0 /* False */;
|
|
}
|
|
const related = compareProperties2(sourceProp, targetProp, isRelatedTo);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function signaturesRelatedTo(source2, target2, kind, reportErrors2) {
|
|
var _a3, _b;
|
|
if (relation === identityRelation) {
|
|
return signaturesIdenticalTo(source2, target2, kind);
|
|
}
|
|
if (target2 === anyFunctionType || source2 === anyFunctionType) {
|
|
return -1 /* True */;
|
|
}
|
|
const sourceIsJSConstructor = source2.symbol && isJSConstructor(source2.symbol.valueDeclaration);
|
|
const targetIsJSConstructor = target2.symbol && isJSConstructor(target2.symbol.valueDeclaration);
|
|
const sourceSignatures = getSignaturesOfType(source2, sourceIsJSConstructor && kind === 1 /* Construct */ ? 0 /* Call */ : kind);
|
|
const targetSignatures = getSignaturesOfType(target2, targetIsJSConstructor && kind === 1 /* Construct */ ? 0 /* Call */ : kind);
|
|
if (kind === 1 /* Construct */ && sourceSignatures.length && targetSignatures.length) {
|
|
const sourceIsAbstract = !!(sourceSignatures[0].flags & 4 /* Abstract */);
|
|
const targetIsAbstract = !!(targetSignatures[0].flags & 4 /* Abstract */);
|
|
if (sourceIsAbstract && !targetIsAbstract) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors2)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
let result2 = -1 /* True */;
|
|
const incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
|
|
const sourceObjectFlags = getObjectFlags(source2);
|
|
const targetObjectFlags = getObjectFlags(target2);
|
|
if (sourceObjectFlags & 64 /* Instantiated */ && targetObjectFlags & 64 /* Instantiated */ && source2.symbol === target2.symbol || sourceObjectFlags & 4 /* Reference */ && targetObjectFlags & 4 /* Reference */ && source2.target === target2.target) {
|
|
for (let i = 0; i < targetSignatures.length; i++) {
|
|
const related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], true, reportErrors2, incompatibleReporter(sourceSignatures[i], targetSignatures[i]));
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
} else if (sourceSignatures.length === 1 && targetSignatures.length === 1) {
|
|
const eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks;
|
|
const sourceSignature = first(sourceSignatures);
|
|
const targetSignature = first(targetSignatures);
|
|
result2 = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors2, incompatibleReporter(sourceSignature, targetSignature));
|
|
if (!result2 && reportErrors2 && kind === 1 /* Construct */ && sourceObjectFlags & targetObjectFlags && (((_a3 = targetSignature.declaration) == null ? void 0 : _a3.kind) === 173 /* Constructor */ || ((_b = sourceSignature.declaration) == null ? void 0 : _b.kind) === 173 /* Constructor */)) {
|
|
const constructSignatureToString = (signature) => signatureToString(signature, void 0, 262144 /* WriteArrowStyleSignature */, kind);
|
|
reportError(Diagnostics.Type_0_is_not_assignable_to_type_1, constructSignatureToString(sourceSignature), constructSignatureToString(targetSignature));
|
|
reportError(Diagnostics.Types_of_construct_signatures_are_incompatible);
|
|
return result2;
|
|
}
|
|
} else {
|
|
outer:
|
|
for (const t of targetSignatures) {
|
|
const saveErrorInfo = captureErrorCalculationState();
|
|
let shouldElaborateErrors = reportErrors2;
|
|
for (const s of sourceSignatures) {
|
|
const related = signatureRelatedTo(s, t, true, shouldElaborateErrors, incompatibleReporter(s, t));
|
|
if (related) {
|
|
result2 &= related;
|
|
resetErrorInfo(saveErrorInfo);
|
|
continue outer;
|
|
}
|
|
shouldElaborateErrors = false;
|
|
}
|
|
if (shouldElaborateErrors) {
|
|
reportError(
|
|
Diagnostics.Type_0_provides_no_match_for_the_signature_1,
|
|
typeToString(source2),
|
|
signatureToString(t, void 0, void 0, kind)
|
|
);
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function shouldReportUnmatchedPropertyError(source2, target2) {
|
|
const typeCallSignatures = getSignaturesOfStructuredType(source2, 0 /* Call */);
|
|
const typeConstructSignatures = getSignaturesOfStructuredType(source2, 1 /* Construct */);
|
|
const typeProperties = getPropertiesOfObjectType(source2);
|
|
if ((typeCallSignatures.length || typeConstructSignatures.length) && !typeProperties.length) {
|
|
if (getSignaturesOfType(target2, 0 /* Call */).length && typeCallSignatures.length || getSignaturesOfType(target2, 1 /* Construct */).length && typeConstructSignatures.length) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function reportIncompatibleCallSignatureReturn(siga, sigb) {
|
|
if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
|
|
}
|
|
function reportIncompatibleConstructSignatureReturn(siga, sigb) {
|
|
if (siga.parameters.length === 0 && sigb.parameters.length === 0) {
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source2), typeToString(target2));
|
|
}
|
|
return (source2, target2) => reportIncompatibleError(Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source2), typeToString(target2));
|
|
}
|
|
function signatureRelatedTo(source2, target2, erase, reportErrors2, incompatibleReporter) {
|
|
return compareSignaturesRelated(
|
|
erase ? getErasedSignature(source2) : source2,
|
|
erase ? getErasedSignature(target2) : target2,
|
|
relation === strictSubtypeRelation ? 8 /* StrictArity */ : 0,
|
|
reportErrors2,
|
|
reportError,
|
|
incompatibleReporter,
|
|
isRelatedToWorker,
|
|
reportUnreliableMapper
|
|
);
|
|
}
|
|
function signaturesIdenticalTo(source2, target2, kind) {
|
|
const sourceSignatures = getSignaturesOfType(source2, kind);
|
|
const targetSignatures = getSignaturesOfType(target2, kind);
|
|
if (sourceSignatures.length !== targetSignatures.length) {
|
|
return 0 /* False */;
|
|
}
|
|
let result2 = -1 /* True */;
|
|
for (let i = 0; i < sourceSignatures.length; i++) {
|
|
const related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], false, false, false, isRelatedTo);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function membersRelatedToIndexInfo(source2, targetInfo, reportErrors2) {
|
|
let result2 = -1 /* True */;
|
|
const keyType = targetInfo.keyType;
|
|
const props = source2.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(source2) : getPropertiesOfObjectType(source2);
|
|
for (const prop of props) {
|
|
if (isIgnoredJsxProperty(source2, prop)) {
|
|
continue;
|
|
}
|
|
if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), keyType)) {
|
|
const propType = getNonMissingTypeOfSymbol(prop);
|
|
const type = exactOptionalPropertyTypes || propType.flags & 32768 /* Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* Optional */) ? propType : getTypeWithFacts(propType, 524288 /* NEUndefined */);
|
|
const related = isRelatedTo(type, targetInfo.type, 3 /* Both */, reportErrors2);
|
|
if (!related) {
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
for (const info of getIndexInfosOfType(source2)) {
|
|
if (isApplicableIndexType(info.keyType, keyType)) {
|
|
const related = indexInfoRelatedTo(info, targetInfo, reportErrors2);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
}
|
|
return result2;
|
|
}
|
|
function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2) {
|
|
const related = isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */, reportErrors2);
|
|
if (!related && reportErrors2) {
|
|
if (sourceInfo.keyType === targetInfo.keyType) {
|
|
reportError(Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType));
|
|
} else {
|
|
reportError(Diagnostics._0_and_1_index_signatures_are_incompatible, typeToString(sourceInfo.keyType), typeToString(targetInfo.keyType));
|
|
}
|
|
}
|
|
return related;
|
|
}
|
|
function indexSignaturesRelatedTo(source2, target2, sourceIsPrimitive, reportErrors2, intersectionState) {
|
|
if (relation === identityRelation) {
|
|
return indexSignaturesIdenticalTo(source2, target2);
|
|
}
|
|
const indexInfos = getIndexInfosOfType(target2);
|
|
const targetHasStringIndex = some(indexInfos, (info) => info.keyType === stringType);
|
|
let result2 = -1 /* True */;
|
|
for (const targetInfo of indexInfos) {
|
|
const related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ : isGenericMappedType(source2) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source2), targetInfo.type, 3 /* Both */, reportErrors2) : typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result2 &= related;
|
|
}
|
|
return result2;
|
|
}
|
|
function typeRelatedToIndexInfo(source2, targetInfo, reportErrors2, intersectionState) {
|
|
const sourceInfo = getApplicableIndexInfo(source2, targetInfo.keyType);
|
|
if (sourceInfo) {
|
|
return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors2);
|
|
}
|
|
if (!(intersectionState & 1 /* Source */) && isObjectTypeWithInferableIndex(source2)) {
|
|
return membersRelatedToIndexInfo(source2, targetInfo, reportErrors2);
|
|
}
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Index_signature_for_type_0_is_missing_in_type_1, typeToString(targetInfo.keyType), typeToString(source2));
|
|
}
|
|
return 0 /* False */;
|
|
}
|
|
function indexSignaturesIdenticalTo(source2, target2) {
|
|
const sourceInfos = getIndexInfosOfType(source2);
|
|
const targetInfos = getIndexInfosOfType(target2);
|
|
if (sourceInfos.length !== targetInfos.length) {
|
|
return 0 /* False */;
|
|
}
|
|
for (const targetInfo of targetInfos) {
|
|
const sourceInfo = getIndexInfoOfType(source2, targetInfo.keyType);
|
|
if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
return -1 /* True */;
|
|
}
|
|
function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors2) {
|
|
if (!sourceSignature.declaration || !targetSignature.declaration) {
|
|
return true;
|
|
}
|
|
const sourceAccessibility = getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
const targetAccessibility = getSelectedEffectiveModifierFlags(targetSignature.declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
if (targetAccessibility === 8 /* Private */) {
|
|
return true;
|
|
}
|
|
if (targetAccessibility === 16 /* Protected */ && sourceAccessibility !== 8 /* Private */) {
|
|
return true;
|
|
}
|
|
if (targetAccessibility !== 16 /* Protected */ && !sourceAccessibility) {
|
|
return true;
|
|
}
|
|
if (reportErrors2) {
|
|
reportError(Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility));
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function typeCouldHaveTopLevelSingletonTypes(type) {
|
|
if (type.flags & 16 /* Boolean */) {
|
|
return false;
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
return !!forEach(type.types, typeCouldHaveTopLevelSingletonTypes);
|
|
}
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
const constraint = getConstraintOfType(type);
|
|
if (constraint && constraint !== type) {
|
|
return typeCouldHaveTopLevelSingletonTypes(constraint);
|
|
}
|
|
}
|
|
return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */) || !!(type.flags & 268435456 /* StringMapping */);
|
|
}
|
|
function getExactOptionalUnassignableProperties(source, target) {
|
|
if (isTupleType(source) && isTupleType(target))
|
|
return emptyArray;
|
|
return getPropertiesOfType(target).filter((targetProp) => isExactOptionalPropertyMismatch(getTypeOfPropertyOfType(source, targetProp.escapedName), getTypeOfSymbol(targetProp)));
|
|
}
|
|
function isExactOptionalPropertyMismatch(source, target) {
|
|
return !!source && !!target && maybeTypeOfKind(source, 32768 /* Undefined */) && !!containsMissingType(target);
|
|
}
|
|
function getExactOptionalProperties(type) {
|
|
return getPropertiesOfType(type).filter((targetProp) => containsMissingType(getTypeOfSymbol(targetProp)));
|
|
}
|
|
function getBestMatchingType(source, target, isRelatedTo = compareTypesAssignable) {
|
|
return findMatchingDiscriminantType(source, target, isRelatedTo, true) || findMatchingTypeReferenceOrTypeAliasReference(source, target) || findBestTypeForObjectLiteral(source, target) || findBestTypeForInvokable(source, target) || findMostOverlappyType(source, target);
|
|
}
|
|
function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) {
|
|
const discriminable = target.types.map((_) => void 0);
|
|
for (const [getDiscriminatingType, propertyName] of discriminators) {
|
|
const targetProp = getUnionOrIntersectionProperty(target, propertyName);
|
|
if (skipPartial && targetProp && getCheckFlags(targetProp) & 16 /* ReadPartial */) {
|
|
continue;
|
|
}
|
|
let i = 0;
|
|
for (const type of target.types) {
|
|
const targetType = getTypeOfPropertyOfType(type, propertyName);
|
|
if (targetType && related(getDiscriminatingType(), targetType)) {
|
|
discriminable[i] = discriminable[i] === void 0 ? true : discriminable[i];
|
|
} else {
|
|
discriminable[i] = false;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
const match = discriminable.indexOf(true);
|
|
if (match === -1) {
|
|
return defaultValue;
|
|
}
|
|
let nextMatch = discriminable.indexOf(true, match + 1);
|
|
while (nextMatch !== -1) {
|
|
if (!isTypeIdenticalTo(target.types[match], target.types[nextMatch])) {
|
|
return defaultValue;
|
|
}
|
|
nextMatch = discriminable.indexOf(true, nextMatch + 1);
|
|
}
|
|
return target.types[match];
|
|
}
|
|
function isWeakType(type) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return every(type.types, isWeakType);
|
|
}
|
|
return false;
|
|
}
|
|
function hasCommonProperties(source, target, isComparingJsxAttributes) {
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getVariances(type) {
|
|
return type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8 /* Tuple */ ? arrayVariances : getVariancesWorker(type.symbol, type.typeParameters);
|
|
}
|
|
function getAliasVariances(symbol) {
|
|
return getVariancesWorker(symbol, getSymbolLinks(symbol).typeParameters);
|
|
}
|
|
function getVariancesWorker(symbol, typeParameters = emptyArray) {
|
|
var _a2, _b;
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.variances) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.CheckTypes, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
|
|
links.variances = emptyArray;
|
|
const variances = [];
|
|
for (const tp of typeParameters) {
|
|
const modifiers = getVarianceModifiers(tp);
|
|
let variance = modifiers & 65536 /* Out */ ? modifiers & 32768 /* In */ ? 0 /* Invariant */ : 1 /* Covariant */ : modifiers & 32768 /* In */ ? 2 /* Contravariant */ : void 0;
|
|
if (variance === void 0) {
|
|
let unmeasurable = false;
|
|
let unreliable = false;
|
|
const oldHandler = outofbandVarianceMarkerHandler;
|
|
outofbandVarianceMarkerHandler = (onlyUnreliable) => onlyUnreliable ? unreliable = true : unmeasurable = true;
|
|
const typeWithSuper = createMarkerType(symbol, tp, markerSuperType);
|
|
const typeWithSub = createMarkerType(symbol, tp, markerSubType);
|
|
variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 /* Covariant */ : 0) | (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 /* Contravariant */ : 0);
|
|
if (variance === 3 /* Bivariant */ && isTypeAssignableTo(createMarkerType(symbol, tp, markerOtherType), typeWithSuper)) {
|
|
variance = 4 /* Independent */;
|
|
}
|
|
outofbandVarianceMarkerHandler = oldHandler;
|
|
if (unmeasurable || unreliable) {
|
|
if (unmeasurable) {
|
|
variance |= 8 /* Unmeasurable */;
|
|
}
|
|
if (unreliable) {
|
|
variance |= 16 /* Unreliable */;
|
|
}
|
|
}
|
|
}
|
|
variances.push(variance);
|
|
}
|
|
links.variances = variances;
|
|
(_b = tracing) == null ? void 0 : _b.pop({ variances: variances.map(Debug.formatVariance) });
|
|
}
|
|
return links.variances;
|
|
}
|
|
function createMarkerType(symbol, source, target) {
|
|
const mapper = makeUnaryTypeMapper(source, target);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (isErrorType(type)) {
|
|
return type;
|
|
}
|
|
const result = symbol.flags & 524288 /* TypeAlias */ ? getTypeAliasInstantiation(symbol, instantiateTypes(getSymbolLinks(symbol).typeParameters, mapper)) : createTypeReference(type, instantiateTypes(type.typeParameters, mapper));
|
|
markerTypes.add(getTypeId(result));
|
|
return result;
|
|
}
|
|
function isMarkerType(type) {
|
|
return markerTypes.has(getTypeId(type));
|
|
}
|
|
function getVarianceModifiers(tp) {
|
|
var _a2, _b;
|
|
return (some((_a2 = tp.symbol) == null ? void 0 : _a2.declarations, (d) => hasSyntacticModifier(d, 32768 /* In */)) ? 32768 /* In */ : 0) | (some((_b = tp.symbol) == null ? void 0 : _b.declarations, (d) => hasSyntacticModifier(d, 65536 /* Out */)) ? 65536 /* Out */ : 0);
|
|
}
|
|
function hasCovariantVoidArgument(typeArguments, variances) {
|
|
for (let i = 0; i < variances.length; i++) {
|
|
if ((variances[i] & 7 /* VarianceMask */) === 1 /* Covariant */ && typeArguments[i].flags & 16384 /* Void */) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isUnconstrainedTypeParameter(type) {
|
|
return type.flags & 262144 /* TypeParameter */ && !getConstraintOfTypeParameter(type);
|
|
}
|
|
function isNonDeferredTypeReference(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */) && !type.node;
|
|
}
|
|
function isTypeReferenceWithGenericArguments(type) {
|
|
return isNonDeferredTypeReference(type) && some(getTypeArguments(type), (t) => !!(t.flags & 262144 /* TypeParameter */) || isTypeReferenceWithGenericArguments(t));
|
|
}
|
|
function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) {
|
|
const typeParameters = [];
|
|
let constraintMarker = "";
|
|
const sourceId = getTypeReferenceId(source, 0);
|
|
const targetId = getTypeReferenceId(target, 0);
|
|
return `${constraintMarker}${sourceId},${targetId}${postFix}`;
|
|
function getTypeReferenceId(type, depth = 0) {
|
|
let result = "" + type.target.id;
|
|
for (const t of getTypeArguments(type)) {
|
|
if (t.flags & 262144 /* TypeParameter */) {
|
|
if (ignoreConstraints || isUnconstrainedTypeParameter(t)) {
|
|
let index = typeParameters.indexOf(t);
|
|
if (index < 0) {
|
|
index = typeParameters.length;
|
|
typeParameters.push(t);
|
|
}
|
|
result += "=" + index;
|
|
continue;
|
|
}
|
|
constraintMarker = "*";
|
|
} else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) {
|
|
result += "<" + getTypeReferenceId(t, depth + 1) + ">";
|
|
continue;
|
|
}
|
|
result += "-" + t.id;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) {
|
|
if (relation === identityRelation && source.id > target.id) {
|
|
const temp = source;
|
|
source = target;
|
|
target = temp;
|
|
}
|
|
const postFix = intersectionState ? ":" + intersectionState : "";
|
|
return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ? getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) : `${source.id},${target.id}${postFix}`;
|
|
}
|
|
function forEachProperty2(prop, callback) {
|
|
if (getCheckFlags(prop) & 6 /* Synthetic */) {
|
|
for (const t of prop.containingType.types) {
|
|
const p = getPropertyOfType(t, prop.escapedName);
|
|
const result = p && forEachProperty2(p, callback);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
return callback(prop);
|
|
}
|
|
function getDeclaringClass(prop) {
|
|
return prop.parent && prop.parent.flags & 32 /* Class */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : void 0;
|
|
}
|
|
function getTypeOfPropertyInBaseClass(property) {
|
|
const classType = getDeclaringClass(property);
|
|
const baseClassType = classType && getBaseTypes(classType)[0];
|
|
return baseClassType && getTypeOfPropertyOfType(baseClassType, property.escapedName);
|
|
}
|
|
function isPropertyInClassDerivedFrom(prop, baseClass) {
|
|
return forEachProperty2(prop, (sp) => {
|
|
const sourceClass = getDeclaringClass(sp);
|
|
return sourceClass ? hasBaseType(sourceClass, baseClass) : false;
|
|
});
|
|
}
|
|
function isValidOverrideOf(sourceProp, targetProp) {
|
|
return !forEachProperty2(targetProp, (tp) => getDeclarationModifierFlagsFromSymbol(tp) & 16 /* Protected */ ? !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false);
|
|
}
|
|
function isClassDerivedFromDeclaringClasses(checkClass, prop, writing) {
|
|
return forEachProperty2(prop, (p) => getDeclarationModifierFlagsFromSymbol(p, writing) & 16 /* Protected */ ? !hasBaseType(checkClass, getDeclaringClass(p)) : false) ? void 0 : checkClass;
|
|
}
|
|
function isDeeplyNestedType(type, stack, depth, maxDepth = 3) {
|
|
if (depth >= maxDepth) {
|
|
const identity2 = getRecursionIdentity(type);
|
|
let count = 0;
|
|
let lastTypeId = 0;
|
|
for (let i = 0; i < depth; i++) {
|
|
const t = stack[i];
|
|
if (getRecursionIdentity(t) === identity2) {
|
|
if (t.id >= lastTypeId) {
|
|
count++;
|
|
if (count >= maxDepth) {
|
|
return true;
|
|
}
|
|
}
|
|
lastTypeId = t.id;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getRecursionIdentity(type) {
|
|
if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
|
|
if (getObjectFlags(type) && 4 /* Reference */ && type.node) {
|
|
return type.node;
|
|
}
|
|
if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
|
|
return type.symbol;
|
|
}
|
|
if (isTupleType(type)) {
|
|
return type.target;
|
|
}
|
|
}
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
return type.symbol;
|
|
}
|
|
if (type.flags & 8388608 /* IndexedAccess */) {
|
|
do {
|
|
type = type.objectType;
|
|
} while (type.flags & 8388608 /* IndexedAccess */);
|
|
return type;
|
|
}
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
return type.root;
|
|
}
|
|
return type;
|
|
}
|
|
function isPropertyIdenticalTo(sourceProp, targetProp) {
|
|
return compareProperties2(sourceProp, targetProp, compareTypesIdentical) !== 0 /* False */;
|
|
}
|
|
function compareProperties2(sourceProp, targetProp, compareTypes) {
|
|
if (sourceProp === targetProp) {
|
|
return -1 /* True */;
|
|
}
|
|
const sourcePropAccessibility = getDeclarationModifierFlagsFromSymbol(sourceProp) & 24 /* NonPublicAccessibilityModifier */;
|
|
const targetPropAccessibility = getDeclarationModifierFlagsFromSymbol(targetProp) & 24 /* NonPublicAccessibilityModifier */;
|
|
if (sourcePropAccessibility !== targetPropAccessibility) {
|
|
return 0 /* False */;
|
|
}
|
|
if (sourcePropAccessibility) {
|
|
if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
} else {
|
|
if ((sourceProp.flags & 16777216 /* Optional */) !== (targetProp.flags & 16777216 /* Optional */)) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) {
|
|
return 0 /* False */;
|
|
}
|
|
return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
|
|
}
|
|
function isMatchingSignature(source, target, partialMatch) {
|
|
const sourceParameterCount = getParameterCount(source);
|
|
const targetParameterCount = getParameterCount(target);
|
|
const sourceMinArgumentCount = getMinArgumentCount(source);
|
|
const targetMinArgumentCount = getMinArgumentCount(target);
|
|
const sourceHasRestParameter = hasEffectiveRestParameter(source);
|
|
const targetHasRestParameter = hasEffectiveRestParameter(target);
|
|
if (sourceParameterCount === targetParameterCount && sourceMinArgumentCount === targetMinArgumentCount && sourceHasRestParameter === targetHasRestParameter) {
|
|
return true;
|
|
}
|
|
if (partialMatch && sourceMinArgumentCount <= targetMinArgumentCount) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) {
|
|
if (source === target) {
|
|
return -1 /* True */;
|
|
}
|
|
if (!isMatchingSignature(source, target, partialMatch)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (length(source.typeParameters) !== length(target.typeParameters)) {
|
|
return 0 /* False */;
|
|
}
|
|
if (target.typeParameters) {
|
|
const mapper = createTypeMapper(source.typeParameters, target.typeParameters);
|
|
for (let i = 0; i < target.typeParameters.length; i++) {
|
|
const s = source.typeParameters[i];
|
|
const t = target.typeParameters[i];
|
|
if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) && compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) {
|
|
return 0 /* False */;
|
|
}
|
|
}
|
|
source = instantiateSignature(source, mapper, true);
|
|
}
|
|
let result = -1 /* True */;
|
|
if (!ignoreThisTypes) {
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
const related = compareTypes(sourceThisType, targetThisType);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
}
|
|
}
|
|
const targetLen = getParameterCount(target);
|
|
for (let i = 0; i < targetLen; i++) {
|
|
const s = getTypeAtPosition(source, i);
|
|
const t = getTypeAtPosition(target, i);
|
|
const related = compareTypes(t, s);
|
|
if (!related) {
|
|
return 0 /* False */;
|
|
}
|
|
result &= related;
|
|
}
|
|
if (!ignoreReturnTypes) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
const targetTypePredicate = getTypePredicateOfSignature(target);
|
|
result &= sourceTypePredicate || targetTypePredicate ? compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) : compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
|
|
}
|
|
return result;
|
|
}
|
|
function compareTypePredicatesIdentical(source, target, compareTypes) {
|
|
return !(source && target && typePredicateKindsMatch(source, target)) ? 0 /* False */ : source.type === target.type ? -1 /* True */ : source.type && target.type ? compareTypes(source.type, target.type) : 0 /* False */;
|
|
}
|
|
function literalTypesWithSameBaseType(types) {
|
|
let commonBaseType;
|
|
for (const t of types) {
|
|
if (!(t.flags & 131072 /* Never */)) {
|
|
const baseType = getBaseTypeOfLiteralType(t);
|
|
commonBaseType != null ? commonBaseType : commonBaseType = baseType;
|
|
if (baseType === t || baseType !== commonBaseType) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getCombinedTypeFlags(types) {
|
|
return reduceLeft(types, (flags, t) => flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags), 0);
|
|
}
|
|
function getCommonSupertype(types) {
|
|
if (types.length === 1) {
|
|
return types[0];
|
|
}
|
|
const primaryTypes = strictNullChecks ? sameMap(types, (t) => filterType(t, (u) => !(u.flags & 98304 /* Nullable */))) : types;
|
|
const superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ? getUnionType(primaryTypes) : reduceLeft(primaryTypes, (s, t) => isTypeSubtypeOf(s, t) ? t : s);
|
|
return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
|
|
}
|
|
function getCommonSubtype(types) {
|
|
return reduceLeft(types, (s, t) => isTypeSubtypeOf(t, s) ? t : s);
|
|
}
|
|
function isArrayType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */) && (type.target === globalArrayType || type.target === globalReadonlyArrayType);
|
|
}
|
|
function isReadonlyArrayType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */) && type.target === globalReadonlyArrayType;
|
|
}
|
|
function isArrayOrTupleType(type) {
|
|
return isArrayType(type) || isTupleType(type);
|
|
}
|
|
function isMutableArrayOrTuple(type) {
|
|
return isArrayType(type) && !isReadonlyArrayType(type) || isTupleType(type) && !type.target.readonly;
|
|
}
|
|
function getElementTypeOfArrayType(type) {
|
|
return isArrayType(type) ? getTypeArguments(type)[0] : void 0;
|
|
}
|
|
function isArrayLikeType(type) {
|
|
return isArrayType(type) || !(type.flags & 98304 /* Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType);
|
|
}
|
|
function getSingleBaseForNonAugmentingSubtype(type) {
|
|
if (!(getObjectFlags(type) & 4 /* Reference */) || !(getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
|
|
return void 0;
|
|
}
|
|
if (getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
|
|
return getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : void 0;
|
|
}
|
|
type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
|
|
const target = type.target;
|
|
if (getObjectFlags(target) & 1 /* Class */) {
|
|
const baseTypeNode = getBaseTypeNodeOfClass(target);
|
|
if (baseTypeNode && baseTypeNode.expression.kind !== 79 /* Identifier */ && baseTypeNode.expression.kind !== 208 /* PropertyAccessExpression */) {
|
|
return void 0;
|
|
}
|
|
}
|
|
const bases = getBaseTypes(target);
|
|
if (bases.length !== 1) {
|
|
return void 0;
|
|
}
|
|
if (getMembersOfSymbol(type.symbol).size) {
|
|
return void 0;
|
|
}
|
|
let instantiatedBase = !length(target.typeParameters) ? bases[0] : instantiateType(bases[0], createTypeMapper(target.typeParameters, getTypeArguments(type).slice(0, target.typeParameters.length)));
|
|
if (length(getTypeArguments(type)) > length(target.typeParameters)) {
|
|
instantiatedBase = getTypeWithThisArgument(instantiatedBase, last(getTypeArguments(type)));
|
|
}
|
|
type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
|
|
return type.cachedEquivalentBaseType = instantiatedBase;
|
|
}
|
|
function isEmptyLiteralType(type) {
|
|
return strictNullChecks ? type === implicitNeverType : type === undefinedWideningType;
|
|
}
|
|
function isEmptyArrayLiteralType(type) {
|
|
const elementType = getElementTypeOfArrayType(type);
|
|
return !!elementType && isEmptyLiteralType(elementType);
|
|
}
|
|
function isTupleLikeType(type) {
|
|
return isTupleType(type) || !!getPropertyOfType(type, "0");
|
|
}
|
|
function isArrayOrTupleLikeType(type) {
|
|
return isArrayLikeType(type) || isTupleLikeType(type);
|
|
}
|
|
function getTupleElementType(type, index) {
|
|
const propType = getTypeOfPropertyOfType(type, "" + index);
|
|
if (propType) {
|
|
return propType;
|
|
}
|
|
if (everyType(type, isTupleType)) {
|
|
return mapType(type, (t) => getRestTypeOfTupleType(t) || undefinedType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isNeitherUnitTypeNorNever(type) {
|
|
return !(type.flags & (109440 /* Unit */ | 131072 /* Never */));
|
|
}
|
|
function isUnitType(type) {
|
|
return !!(type.flags & 109440 /* Unit */);
|
|
}
|
|
function isUnitLikeType(type) {
|
|
return isUnitType(getBaseConstraintOrType(type));
|
|
}
|
|
function extractUnitType(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? find(type.types, isUnitType) || type : type;
|
|
}
|
|
function isLiteralType(type) {
|
|
return type.flags & 16 /* Boolean */ ? true : type.flags & 1048576 /* Union */ ? type.flags & 1024 /* EnumLiteral */ ? true : every(type.types, isUnitType) : isUnitType(type);
|
|
}
|
|
function getBaseTypeOfLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ ? getBaseTypeOfEnumLiteralType(type) : type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? stringType : type.flags & 256 /* NumberLiteral */ ? numberType : type.flags & 2048 /* BigIntLiteral */ ? bigintType : type.flags & 512 /* BooleanLiteral */ ? booleanType : type.flags & 1048576 /* Union */ ? getBaseTypeOfLiteralTypeUnion(type) : type;
|
|
}
|
|
function getBaseTypeOfLiteralTypeUnion(type) {
|
|
var _a2;
|
|
const key = `B${getTypeId(type)}`;
|
|
return (_a2 = getCachedType(key)) != null ? _a2 : setCachedType(key, mapType(type, getBaseTypeOfLiteralType));
|
|
}
|
|
function getWidenedLiteralType(type) {
|
|
return type.flags & 1024 /* EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) : type.flags & 128 /* StringLiteral */ && isFreshLiteralType(type) ? stringType : 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 */ ? mapType(type, getWidenedLiteralType) : type;
|
|
}
|
|
function getWidenedUniqueESSymbolType(type) {
|
|
return type.flags & 8192 /* UniqueESSymbol */ ? esSymbolType : type.flags & 1048576 /* Union */ ? mapType(type, getWidenedUniqueESSymbolType) : type;
|
|
}
|
|
function getWidenedLiteralLikeTypeForContextualType(type, contextualType) {
|
|
if (!isLiteralOfContextualType(type, contextualType)) {
|
|
type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
|
|
}
|
|
return getRegularTypeOfLiteralType(type);
|
|
}
|
|
function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
|
|
if (type && isUnitType(type)) {
|
|
const contextualType = !contextualSignatureReturnType ? void 0 : isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) : contextualSignatureReturnType;
|
|
type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
|
|
}
|
|
return type;
|
|
}
|
|
function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) {
|
|
if (type && isUnitType(type)) {
|
|
const contextualType = !contextualSignatureReturnType ? void 0 : getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator);
|
|
type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
|
|
}
|
|
return type;
|
|
}
|
|
function isTupleType(type) {
|
|
return !!(getObjectFlags(type) & 4 /* Reference */ && type.target.objectFlags & 8 /* Tuple */);
|
|
}
|
|
function isGenericTupleType(type) {
|
|
return isTupleType(type) && !!(type.target.combinedFlags & 8 /* Variadic */);
|
|
}
|
|
function isSingleElementGenericTupleType(type) {
|
|
return isGenericTupleType(type) && type.target.elementFlags.length === 1;
|
|
}
|
|
function getRestTypeOfTupleType(type) {
|
|
return getElementTypeOfSliceOfTupleType(type, type.target.fixedLength);
|
|
}
|
|
function getRestArrayTypeOfTupleType(type) {
|
|
const restType = getRestTypeOfTupleType(type);
|
|
return restType && createArrayType(restType);
|
|
}
|
|
function getElementTypeOfSliceOfTupleType(type, index, endSkipCount = 0, writing = false) {
|
|
const length2 = getTypeReferenceArity(type) - endSkipCount;
|
|
if (index < length2) {
|
|
const typeArguments = getTypeArguments(type);
|
|
const elementTypes = [];
|
|
for (let i = index; i < length2; i++) {
|
|
const t = typeArguments[i];
|
|
elementTypes.push(type.target.elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessType(t, numberType) : t);
|
|
}
|
|
return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isTupleTypeStructureMatching(t1, t2) {
|
|
return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
|
|
}
|
|
function isZeroBigInt({ value }) {
|
|
return value.base10Value === "0";
|
|
}
|
|
function removeDefinitelyFalsyTypes(type) {
|
|
return filterType(type, (t) => !!(getTypeFacts(t) & 4194304 /* Truthy */));
|
|
}
|
|
function extractDefinitelyFalsyTypes(type) {
|
|
return mapType(type, getDefinitelyFalsyPartOfType);
|
|
}
|
|
function getDefinitelyFalsyPartOfType(type) {
|
|
return type.flags & 4 /* String */ ? emptyStringType : type.flags & 8 /* Number */ ? zeroType : type.flags & 64 /* BigInt */ ? zeroBigIntType : type === regularFalseType || type === falseType || type.flags & (16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */ | 3 /* AnyOrUnknown */) || type.flags & 128 /* StringLiteral */ && type.value === "" || type.flags & 256 /* NumberLiteral */ && type.value === 0 || type.flags & 2048 /* BigIntLiteral */ && isZeroBigInt(type) ? type : neverType;
|
|
}
|
|
function getNullableType(type, flags) {
|
|
const missing = flags & ~type.flags & (32768 /* Undefined */ | 65536 /* Null */);
|
|
return missing === 0 ? type : missing === 32768 /* Undefined */ ? getUnionType([type, undefinedType]) : missing === 65536 /* Null */ ? getUnionType([type, nullType]) : getUnionType([type, undefinedType, nullType]);
|
|
}
|
|
function getOptionalType(type, isProperty = false) {
|
|
Debug.assert(strictNullChecks);
|
|
const missingOrUndefined = isProperty ? missingType : undefinedType;
|
|
return type.flags & 32768 /* Undefined */ || type.flags & 1048576 /* Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]);
|
|
}
|
|
function getGlobalNonNullableTypeInstantiation(type) {
|
|
if (!deferredGlobalNonNullableTypeAlias) {
|
|
deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* TypeAlias */, void 0) || unknownSymbol;
|
|
}
|
|
return deferredGlobalNonNullableTypeAlias !== unknownSymbol ? getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) : getIntersectionType([type, emptyObjectType]);
|
|
}
|
|
function getNonNullableType(type) {
|
|
return strictNullChecks ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
|
|
}
|
|
function addOptionalTypeMarker(type) {
|
|
return strictNullChecks ? getUnionType([type, optionalType]) : type;
|
|
}
|
|
function removeOptionalTypeMarker(type) {
|
|
return strictNullChecks ? removeType(type, optionalType) : type;
|
|
}
|
|
function propagateOptionalTypeMarker(type, node, wasOptional) {
|
|
return wasOptional ? isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type;
|
|
}
|
|
function getOptionalExpressionType(exprType, expression) {
|
|
return isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) : isOptionalChain(expression) ? removeOptionalTypeMarker(exprType) : exprType;
|
|
}
|
|
function removeMissingType(type, isOptional) {
|
|
return exactOptionalPropertyTypes && isOptional ? removeType(type, missingType) : type;
|
|
}
|
|
function containsMissingType(type) {
|
|
return exactOptionalPropertyTypes && (type === missingType || type.flags & 1048576 /* Union */ && containsType(type.types, missingType));
|
|
}
|
|
function removeMissingOrUndefinedType(type) {
|
|
return exactOptionalPropertyTypes ? removeType(type, missingType) : getTypeWithFacts(type, 524288 /* NEUndefined */);
|
|
}
|
|
function isCoercibleUnderDoubleEquals(source, target) {
|
|
return (source.flags & (8 /* Number */ | 4 /* String */ | 512 /* BooleanLiteral */)) !== 0 && (target.flags & (8 /* Number */ | 4 /* String */ | 16 /* Boolean */)) !== 0;
|
|
}
|
|
function isObjectTypeWithInferableIndex(type) {
|
|
const objectFlags = getObjectFlags(type);
|
|
return type.flags & 2097152 /* Intersection */ ? every(type.types, isObjectTypeWithInferableIndex) : !!(type.symbol && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0 && !(type.symbol.flags & 32 /* Class */) && !typeHasCallOrConstructSignatures2(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
|
|
}
|
|
function createSymbolWithType(source, type) {
|
|
const symbol = createSymbol(source.flags, source.escapedName, getCheckFlags(source) & 8 /* Readonly */);
|
|
symbol.declarations = source.declarations;
|
|
symbol.parent = source.parent;
|
|
symbol.type = type;
|
|
symbol.target = source;
|
|
if (source.valueDeclaration) {
|
|
symbol.valueDeclaration = source.valueDeclaration;
|
|
}
|
|
const nameType = getSymbolLinks(source).nameType;
|
|
if (nameType) {
|
|
symbol.nameType = nameType;
|
|
}
|
|
return symbol;
|
|
}
|
|
function transformTypeOfMembers(type, f) {
|
|
const members = createSymbolTable();
|
|
for (const property of getPropertiesOfObjectType(type)) {
|
|
const original = getTypeOfSymbol(property);
|
|
const updated = f(original);
|
|
members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated));
|
|
}
|
|
return members;
|
|
}
|
|
function getRegularTypeOfObjectLiteral(type) {
|
|
if (!(isObjectLiteralType2(type) && getObjectFlags(type) & 8192 /* FreshLiteral */)) {
|
|
return type;
|
|
}
|
|
const regularType = type.regularType;
|
|
if (regularType) {
|
|
return regularType;
|
|
}
|
|
const resolved = type;
|
|
const members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral);
|
|
const regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.indexInfos);
|
|
regularNew.flags = resolved.flags;
|
|
regularNew.objectFlags |= resolved.objectFlags & ~8192 /* FreshLiteral */;
|
|
type.regularType = regularNew;
|
|
return regularNew;
|
|
}
|
|
function createWideningContext(parent2, propertyName, siblings) {
|
|
return { parent: parent2, propertyName, siblings, resolvedProperties: void 0 };
|
|
}
|
|
function getSiblingsOfContext(context) {
|
|
if (!context.siblings) {
|
|
const siblings = [];
|
|
for (const type of getSiblingsOfContext(context.parent)) {
|
|
if (isObjectLiteralType2(type)) {
|
|
const prop = getPropertyOfObjectType(type, context.propertyName);
|
|
if (prop) {
|
|
forEachType(getTypeOfSymbol(prop), (t) => {
|
|
siblings.push(t);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
context.siblings = siblings;
|
|
}
|
|
return context.siblings;
|
|
}
|
|
function getPropertiesOfContext(context) {
|
|
if (!context.resolvedProperties) {
|
|
const names = /* @__PURE__ */ new Map();
|
|
for (const t of getSiblingsOfContext(context)) {
|
|
if (isObjectLiteralType2(t) && !(getObjectFlags(t) & 2097152 /* ContainsSpread */)) {
|
|
for (const prop of getPropertiesOfType(t)) {
|
|
names.set(prop.escapedName, prop);
|
|
}
|
|
}
|
|
}
|
|
context.resolvedProperties = arrayFrom(names.values());
|
|
}
|
|
return context.resolvedProperties;
|
|
}
|
|
function getWidenedProperty(prop, context) {
|
|
if (!(prop.flags & 4 /* Property */)) {
|
|
return prop;
|
|
}
|
|
const original = getTypeOfSymbol(prop);
|
|
const propContext = context && createWideningContext(context, prop.escapedName, void 0);
|
|
const widened = getWidenedTypeWithContext(original, propContext);
|
|
return widened === original ? prop : createSymbolWithType(prop, widened);
|
|
}
|
|
function getUndefinedProperty(prop) {
|
|
const cached = undefinedProperties.get(prop.escapedName);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
const result = createSymbolWithType(prop, missingType);
|
|
result.flags |= 16777216 /* Optional */;
|
|
undefinedProperties.set(prop.escapedName, result);
|
|
return result;
|
|
}
|
|
function getWidenedTypeOfObjectLiteral(type, context) {
|
|
const members = createSymbolTable();
|
|
for (const prop of getPropertiesOfObjectType(type)) {
|
|
members.set(prop.escapedName, getWidenedProperty(prop, context));
|
|
}
|
|
if (context) {
|
|
for (const prop of getPropertiesOfContext(context)) {
|
|
if (!members.has(prop.escapedName)) {
|
|
members.set(prop.escapedName, getUndefinedProperty(prop));
|
|
}
|
|
}
|
|
}
|
|
const result = createAnonymousType(
|
|
type.symbol,
|
|
members,
|
|
emptyArray,
|
|
emptyArray,
|
|
sameMap(getIndexInfosOfType(type), (info) => createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly))
|
|
);
|
|
result.objectFlags |= getObjectFlags(type) & (4096 /* JSLiteral */ | 262144 /* NonInferrableType */);
|
|
return result;
|
|
}
|
|
function getWidenedType(type) {
|
|
return getWidenedTypeWithContext(type, void 0);
|
|
}
|
|
function getWidenedTypeWithContext(type, context) {
|
|
if (getObjectFlags(type) & 196608 /* RequiresWidening */) {
|
|
if (context === void 0 && type.widened) {
|
|
return type.widened;
|
|
}
|
|
let result;
|
|
if (type.flags & (1 /* Any */ | 98304 /* Nullable */)) {
|
|
result = anyType;
|
|
} else if (isObjectLiteralType2(type)) {
|
|
result = getWidenedTypeOfObjectLiteral(type, context);
|
|
} else if (type.flags & 1048576 /* Union */) {
|
|
const unionContext = context || createWideningContext(void 0, void 0, type.types);
|
|
const widenedTypes = sameMap(type.types, (t) => t.flags & 98304 /* Nullable */ ? t : getWidenedTypeWithContext(t, unionContext));
|
|
result = getUnionType(widenedTypes, some(widenedTypes, isEmptyObjectType) ? 2 /* Subtype */ : 1 /* Literal */);
|
|
} else if (type.flags & 2097152 /* Intersection */) {
|
|
result = getIntersectionType(sameMap(type.types, getWidenedType));
|
|
} else if (isArrayOrTupleType(type)) {
|
|
result = createTypeReference(type.target, sameMap(getTypeArguments(type), getWidenedType));
|
|
}
|
|
if (result && context === void 0) {
|
|
type.widened = result;
|
|
}
|
|
return result || type;
|
|
}
|
|
return type;
|
|
}
|
|
function reportWideningErrorsInType(type) {
|
|
let errorReported = false;
|
|
if (getObjectFlags(type) & 65536 /* ContainsWideningType */) {
|
|
if (type.flags & 1048576 /* Union */) {
|
|
if (some(type.types, isEmptyObjectType)) {
|
|
errorReported = true;
|
|
} else {
|
|
for (const t of type.types) {
|
|
if (reportWideningErrorsInType(t)) {
|
|
errorReported = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isArrayOrTupleType(type)) {
|
|
for (const t of getTypeArguments(type)) {
|
|
if (reportWideningErrorsInType(t)) {
|
|
errorReported = true;
|
|
}
|
|
}
|
|
}
|
|
if (isObjectLiteralType2(type)) {
|
|
for (const p of getPropertiesOfObjectType(type)) {
|
|
const t = getTypeOfSymbol(p);
|
|
if (getObjectFlags(t) & 65536 /* ContainsWideningType */) {
|
|
if (!reportWideningErrorsInType(t)) {
|
|
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t)));
|
|
}
|
|
errorReported = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return errorReported;
|
|
}
|
|
function reportImplicitAny(declaration, type, wideningKind) {
|
|
const typeAsString = typeToString(getWidenedType(type));
|
|
if (isInJSFile(declaration) && !isCheckJsEnabledForFile(getSourceFileOfNode(declaration), compilerOptions)) {
|
|
return;
|
|
}
|
|
let diagnostic;
|
|
switch (declaration.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
diagnostic = noImplicitAny ? Diagnostics.Member_0_implicitly_has_an_1_type : Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
break;
|
|
case 166 /* Parameter */:
|
|
const param = declaration;
|
|
if (isIdentifier(param.name) && (isCallSignatureDeclaration(param.parent) || isMethodSignature(param.parent) || isFunctionTypeNode(param.parent)) && param.parent.parameters.indexOf(param) > -1 && (resolveName(param, param.name.escapedText, 788968 /* Type */, void 0, param.name.escapedText, true) || param.name.originalKeywordKind && isTypeNodeKind(param.name.originalKeywordKind))) {
|
|
const newName = "arg" + param.parent.parameters.indexOf(param);
|
|
const typeName = declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : "");
|
|
errorOrSuggestion(noImplicitAny, declaration, Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName);
|
|
return;
|
|
}
|
|
diagnostic = declaration.dotDotDotToken ? noImplicitAny ? Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage : noImplicitAny ? Diagnostics.Parameter_0_implicitly_has_an_1_type : Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
diagnostic = Diagnostics.Binding_element_0_implicitly_has_an_1_type;
|
|
if (!noImplicitAny) {
|
|
return;
|
|
}
|
|
break;
|
|
case 320 /* JSDocFunctionType */:
|
|
error(declaration, Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
|
|
return;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
if (noImplicitAny && !declaration.name) {
|
|
if (wideningKind === 3 /* GeneratorYield */) {
|
|
error(declaration, Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString);
|
|
} else {
|
|
error(declaration, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
|
|
}
|
|
return;
|
|
}
|
|
diagnostic = !noImplicitAny ? Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage : wideningKind === 3 /* GeneratorYield */ ? Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type : Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
|
|
break;
|
|
case 197 /* MappedType */:
|
|
if (noImplicitAny) {
|
|
error(declaration, Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type);
|
|
}
|
|
return;
|
|
default:
|
|
diagnostic = noImplicitAny ? Diagnostics.Variable_0_implicitly_has_an_1_type : Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage;
|
|
}
|
|
errorOrSuggestion(noImplicitAny, declaration, diagnostic, declarationNameToString(getNameOfDeclaration(declaration)), typeAsString);
|
|
}
|
|
function reportErrorsFromWidening(declaration, type, wideningKind) {
|
|
addLazyDiagnostic(() => {
|
|
if (noImplicitAny && getObjectFlags(type) & 65536 /* ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) {
|
|
if (!reportWideningErrorsInType(type)) {
|
|
reportImplicitAny(declaration, type, wideningKind);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function applyToParameterTypes(source, target, callback) {
|
|
const sourceCount = getParameterCount(source);
|
|
const targetCount = getParameterCount(target);
|
|
const sourceRestType = getEffectiveRestType(source);
|
|
const targetRestType = getEffectiveRestType(target);
|
|
const targetNonRestCount = targetRestType ? targetCount - 1 : targetCount;
|
|
const paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount);
|
|
const sourceThisType = getThisTypeOfSignature(source);
|
|
if (sourceThisType) {
|
|
const targetThisType = getThisTypeOfSignature(target);
|
|
if (targetThisType) {
|
|
callback(sourceThisType, targetThisType);
|
|
}
|
|
}
|
|
for (let i = 0; i < paramCount; i++) {
|
|
callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i));
|
|
}
|
|
if (targetRestType) {
|
|
callback(getRestTypeAtPosition(source, paramCount), targetRestType);
|
|
}
|
|
}
|
|
function applyToReturnTypes(source, target, callback) {
|
|
const sourceTypePredicate = getTypePredicateOfSignature(source);
|
|
const targetTypePredicate = getTypePredicateOfSignature(target);
|
|
if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) {
|
|
callback(sourceTypePredicate.type, targetTypePredicate.type);
|
|
} else {
|
|
callback(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
|
|
}
|
|
}
|
|
function createInferenceContext(typeParameters, signature, flags, compareTypes) {
|
|
return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable);
|
|
}
|
|
function cloneInferenceContext(context, extraFlags = 0) {
|
|
return context && createInferenceContextWorker(map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes);
|
|
}
|
|
function createInferenceContextWorker(inferences, signature, flags, compareTypes) {
|
|
const context = {
|
|
inferences,
|
|
signature,
|
|
flags,
|
|
compareTypes,
|
|
mapper: reportUnmeasurableMapper,
|
|
nonFixingMapper: reportUnmeasurableMapper
|
|
};
|
|
context.mapper = makeFixingMapperForContext(context);
|
|
context.nonFixingMapper = makeNonFixingMapperForContext(context);
|
|
return context;
|
|
}
|
|
function makeFixingMapperForContext(context) {
|
|
return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (inference, i) => () => {
|
|
if (!inference.isFixed) {
|
|
inferFromIntraExpressionSites(context);
|
|
clearCachedInferences(context.inferences);
|
|
inference.isFixed = true;
|
|
}
|
|
return getInferredType(context, i);
|
|
}));
|
|
}
|
|
function makeNonFixingMapperForContext(context) {
|
|
return makeDeferredTypeMapper(map(context.inferences, (i) => i.typeParameter), map(context.inferences, (_, i) => () => {
|
|
return getInferredType(context, i);
|
|
}));
|
|
}
|
|
function clearCachedInferences(inferences) {
|
|
for (const inference of inferences) {
|
|
if (!inference.isFixed) {
|
|
inference.inferredType = void 0;
|
|
}
|
|
}
|
|
}
|
|
function addIntraExpressionInferenceSite(context, node, type) {
|
|
var _a2;
|
|
((_a2 = context.intraExpressionInferenceSites) != null ? _a2 : context.intraExpressionInferenceSites = []).push({ node, type });
|
|
}
|
|
function inferFromIntraExpressionSites(context) {
|
|
if (context.intraExpressionInferenceSites) {
|
|
for (const { node, type } of context.intraExpressionInferenceSites) {
|
|
const contextualType = node.kind === 171 /* MethodDeclaration */ ? getContextualTypeForObjectLiteralMethod(node, 2 /* NoConstraints */) : getContextualType2(node, 2 /* NoConstraints */);
|
|
if (contextualType) {
|
|
inferTypes(context.inferences, type, contextualType);
|
|
}
|
|
}
|
|
context.intraExpressionInferenceSites = void 0;
|
|
}
|
|
}
|
|
function createInferenceInfo(typeParameter) {
|
|
return {
|
|
typeParameter,
|
|
candidates: void 0,
|
|
contraCandidates: void 0,
|
|
inferredType: void 0,
|
|
priority: void 0,
|
|
topLevel: true,
|
|
isFixed: false,
|
|
impliedArity: void 0
|
|
};
|
|
}
|
|
function cloneInferenceInfo(inference) {
|
|
return {
|
|
typeParameter: inference.typeParameter,
|
|
candidates: inference.candidates && inference.candidates.slice(),
|
|
contraCandidates: inference.contraCandidates && inference.contraCandidates.slice(),
|
|
inferredType: inference.inferredType,
|
|
priority: inference.priority,
|
|
topLevel: inference.topLevel,
|
|
isFixed: inference.isFixed,
|
|
impliedArity: inference.impliedArity
|
|
};
|
|
}
|
|
function cloneInferredPartOfContext(context) {
|
|
const inferences = filter(context.inferences, hasInferenceCandidates);
|
|
return inferences.length ? createInferenceContextWorker(map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : void 0;
|
|
}
|
|
function getMapperFromContext(context) {
|
|
return context && context.mapper;
|
|
}
|
|
function couldContainTypeVariables(type) {
|
|
const objectFlags = getObjectFlags(type);
|
|
if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
|
|
return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
|
|
}
|
|
const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || forEach(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
|
|
if (type.flags & 3899393 /* ObjectFlagsType */) {
|
|
type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
|
|
}
|
|
return result;
|
|
}
|
|
function isNonGenericTopLevelType(type) {
|
|
if (type.aliasSymbol && !type.aliasTypeArguments) {
|
|
const declaration = getDeclarationOfKind(type.aliasSymbol, 262 /* TypeAliasDeclaration */);
|
|
return !!(declaration && findAncestor(declaration.parent, (n) => n.kind === 308 /* SourceFile */ ? true : n.kind === 264 /* ModuleDeclaration */ ? false : "quit"));
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeParameterAtTopLevel(type, typeParameter) {
|
|
return !!(type === typeParameter || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isTypeParameterAtTopLevel(t, typeParameter)) || type.flags & 16777216 /* Conditional */ && (getTrueTypeFromConditionalType(type) === typeParameter || getFalseTypeFromConditionalType(type) === typeParameter));
|
|
}
|
|
function createEmptyObjectTypeFromStringLiteral(type) {
|
|
const members = createSymbolTable();
|
|
forEachType(type, (t) => {
|
|
if (!(t.flags & 128 /* StringLiteral */)) {
|
|
return;
|
|
}
|
|
const name = escapeLeadingUnderscores(t.value);
|
|
const literalProp = createSymbol(4 /* Property */, name);
|
|
literalProp.type = anyType;
|
|
if (t.symbol) {
|
|
literalProp.declarations = t.symbol.declarations;
|
|
literalProp.valueDeclaration = t.symbol.valueDeclaration;
|
|
}
|
|
members.set(name, literalProp);
|
|
});
|
|
const indexInfos = type.flags & 4 /* String */ ? [createIndexInfo(stringType, emptyObjectType, false)] : emptyArray;
|
|
return createAnonymousType(void 0, members, emptyArray, emptyArray, indexInfos);
|
|
}
|
|
function inferTypeForHomomorphicMappedType(source, target, constraint) {
|
|
if (inInferTypeForHomomorphicMappedType) {
|
|
return void 0;
|
|
}
|
|
const key = source.id + "," + target.id + "," + constraint.id;
|
|
if (reverseMappedCache.has(key)) {
|
|
return reverseMappedCache.get(key);
|
|
}
|
|
inInferTypeForHomomorphicMappedType = true;
|
|
const type = createReverseMappedType(source, target, constraint);
|
|
inInferTypeForHomomorphicMappedType = false;
|
|
reverseMappedCache.set(key, type);
|
|
return type;
|
|
}
|
|
function isPartiallyInferableType(type) {
|
|
return !(getObjectFlags(type) & 262144 /* NonInferrableType */) || isObjectLiteralType2(type) && some(getPropertiesOfType(type), (prop) => isPartiallyInferableType(getTypeOfSymbol(prop))) || isTupleType(type) && some(getTypeArguments(type), isPartiallyInferableType);
|
|
}
|
|
function createReverseMappedType(source, target, constraint) {
|
|
if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) {
|
|
return void 0;
|
|
}
|
|
if (isArrayType(source)) {
|
|
return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source));
|
|
}
|
|
if (isTupleType(source)) {
|
|
const elementTypes = map(getTypeArguments(source), (t) => inferReverseMappedType(t, target, constraint));
|
|
const elementFlags = getMappedTypeModifiers(target) & 4 /* IncludeOptional */ ? sameMap(source.target.elementFlags, (f) => f & 2 /* Optional */ ? 1 /* Required */ : f) : source.target.elementFlags;
|
|
return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations);
|
|
}
|
|
const reversed = createObjectType(1024 /* ReverseMapped */ | 16 /* Anonymous */, void 0);
|
|
reversed.source = source;
|
|
reversed.mappedType = target;
|
|
reversed.constraintType = constraint;
|
|
return reversed;
|
|
}
|
|
function getTypeOfReverseMappedSymbol(symbol) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.type) {
|
|
links.type = inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType);
|
|
}
|
|
return links.type;
|
|
}
|
|
function inferReverseMappedType(sourceType, target, constraint) {
|
|
const typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target));
|
|
const templateType = getTemplateTypeFromMappedType(target);
|
|
const inference = createInferenceInfo(typeParameter);
|
|
inferTypes([inference], sourceType, templateType);
|
|
return getTypeFromInference(inference) || unknownType;
|
|
}
|
|
function* getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {
|
|
const properties = getPropertiesOfType(target);
|
|
for (const targetProp of properties) {
|
|
if (isStaticPrivateIdentifierProperty(targetProp)) {
|
|
continue;
|
|
}
|
|
if (requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */ || getCheckFlags(targetProp) & 48 /* Partial */)) {
|
|
const sourceProp = getPropertyOfType(source, targetProp.escapedName);
|
|
if (!sourceProp) {
|
|
yield targetProp;
|
|
} else if (matchDiscriminantProperties) {
|
|
const targetType = getTypeOfSymbol(targetProp);
|
|
if (targetType.flags & 109440 /* Unit */) {
|
|
const sourceType = getTypeOfSymbol(sourceProp);
|
|
if (!(sourceType.flags & 1 /* Any */ || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) {
|
|
yield targetProp;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) {
|
|
const result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next();
|
|
if (!result.done)
|
|
return result.value;
|
|
}
|
|
function tupleTypesDefinitelyUnrelated(source, target) {
|
|
return !(target.target.combinedFlags & 8 /* Variadic */) && target.target.minLength > source.target.minLength || !target.target.hasRestElement && (source.target.hasRestElement || target.target.fixedLength < source.target.fixedLength);
|
|
}
|
|
function typesDefinitelyUnrelated(source, target) {
|
|
return isTupleType(source) && isTupleType(target) ? tupleTypesDefinitelyUnrelated(source, target) : !!getUnmatchedProperty(source, target, false, true) && !!getUnmatchedProperty(target, source, false, false);
|
|
}
|
|
function getTypeFromInference(inference) {
|
|
return inference.candidates ? getUnionType(inference.candidates, 2 /* Subtype */) : inference.contraCandidates ? getIntersectionType(inference.contraCandidates) : void 0;
|
|
}
|
|
function hasSkipDirectInferenceFlag(node) {
|
|
return !!getNodeLinks(node).skipDirectInference;
|
|
}
|
|
function isFromInferenceBlockedSource(type) {
|
|
return !!(type.symbol && some(type.symbol.declarations, hasSkipDirectInferenceFlag));
|
|
}
|
|
function templateLiteralTypesDefinitelyUnrelated(source, target) {
|
|
const sourceStart = source.texts[0];
|
|
const targetStart = target.texts[0];
|
|
const sourceEnd = source.texts[source.texts.length - 1];
|
|
const targetEnd = target.texts[target.texts.length - 1];
|
|
const startLen = Math.min(sourceStart.length, targetStart.length);
|
|
const endLen = Math.min(sourceEnd.length, targetEnd.length);
|
|
return sourceStart.slice(0, startLen) !== targetStart.slice(0, startLen) || sourceEnd.slice(sourceEnd.length - endLen) !== targetEnd.slice(targetEnd.length - endLen);
|
|
}
|
|
function isValidNumberString(s, roundTripOnly) {
|
|
if (s === "")
|
|
return false;
|
|
const n = +s;
|
|
return isFinite(n) && (!roundTripOnly || "" + n === s);
|
|
}
|
|
function parseBigIntLiteralType(text) {
|
|
const negative = text.startsWith("-");
|
|
const base10Value = parsePseudoBigInt(`${negative ? text.slice(1) : text}n`);
|
|
return getBigIntLiteralType({ negative, base10Value });
|
|
}
|
|
function isValidBigIntString(s, roundTripOnly) {
|
|
if (s === "")
|
|
return false;
|
|
const scanner2 = createScanner(99 /* ESNext */, false);
|
|
let success = true;
|
|
scanner2.setOnError(() => success = false);
|
|
scanner2.setText(s + "n");
|
|
let result = scanner2.scan();
|
|
const negative = result === 40 /* MinusToken */;
|
|
if (negative) {
|
|
result = scanner2.scan();
|
|
}
|
|
const flags = scanner2.getTokenFlags();
|
|
return success && result === 9 /* BigIntLiteral */ && scanner2.getTextPos() === s.length + 1 && !(flags & 512 /* ContainsSeparator */) && (!roundTripOnly || s === pseudoBigIntToString({ negative, base10Value: parsePseudoBigInt(scanner2.getTokenValue()) }));
|
|
}
|
|
function isMemberOfStringMapping(source, target) {
|
|
if (target.flags & (4 /* String */ | 1 /* Any */)) {
|
|
return true;
|
|
}
|
|
if (target.flags & 134217728 /* TemplateLiteral */) {
|
|
return isTypeAssignableTo(source, target);
|
|
}
|
|
if (target.flags & 268435456 /* StringMapping */) {
|
|
const mappingStack = [];
|
|
while (target.flags & 268435456 /* StringMapping */) {
|
|
mappingStack.unshift(target.symbol);
|
|
target = target.type;
|
|
}
|
|
const mappedSource = reduceLeft(mappingStack, (memo, value) => getStringMappingType(value, memo), source);
|
|
return mappedSource === source && isMemberOfStringMapping(source, target);
|
|
}
|
|
return false;
|
|
}
|
|
function isValidTypeForTemplateLiteralPlaceholder(source, target) {
|
|
if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
|
|
return true;
|
|
}
|
|
if (source.flags & 128 /* StringLiteral */) {
|
|
const value = source.value;
|
|
return !!(target.flags & 8 /* Number */ && isValidNumberString(value, false) || target.flags & 64 /* BigInt */ && isValidBigIntString(value, false) || target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName || target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target));
|
|
}
|
|
if (source.flags & 134217728 /* TemplateLiteral */) {
|
|
const texts = source.texts;
|
|
return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo(source.types[0], target);
|
|
}
|
|
return isTypeAssignableTo(source, target);
|
|
}
|
|
function inferTypesFromTemplateLiteralType(source, target) {
|
|
return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
|
|
}
|
|
function isTypeMatchedByTemplateLiteralType(source, target) {
|
|
const inferences = inferTypesFromTemplateLiteralType(source, target);
|
|
return !!inferences && every(inferences, (r, i) => isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]));
|
|
}
|
|
function getStringLikeTypeForType(type) {
|
|
return type.flags & (1 /* Any */ | 402653316 /* StringLike */) ? type : getTemplateLiteralType(["", ""], [type]);
|
|
}
|
|
function inferFromLiteralPartsToTemplateLiteral(sourceTexts, sourceTypes, target) {
|
|
const lastSourceIndex = sourceTexts.length - 1;
|
|
const sourceStartText = sourceTexts[0];
|
|
const sourceEndText = sourceTexts[lastSourceIndex];
|
|
const targetTexts = target.texts;
|
|
const lastTargetIndex = targetTexts.length - 1;
|
|
const targetStartText = targetTexts[0];
|
|
const targetEndText = targetTexts[lastTargetIndex];
|
|
if (lastSourceIndex === 0 && sourceStartText.length < targetStartText.length + targetEndText.length || !sourceStartText.startsWith(targetStartText) || !sourceEndText.endsWith(targetEndText))
|
|
return void 0;
|
|
const remainingEndText = sourceEndText.slice(0, sourceEndText.length - targetEndText.length);
|
|
const matches = [];
|
|
let seg = 0;
|
|
let pos = targetStartText.length;
|
|
for (let i = 1; i < lastTargetIndex; i++) {
|
|
const delim = targetTexts[i];
|
|
if (delim.length > 0) {
|
|
let s = seg;
|
|
let p = pos;
|
|
while (true) {
|
|
p = getSourceText(s).indexOf(delim, p);
|
|
if (p >= 0)
|
|
break;
|
|
s++;
|
|
if (s === sourceTexts.length)
|
|
return void 0;
|
|
p = 0;
|
|
}
|
|
addMatch(s, p);
|
|
pos += delim.length;
|
|
} else if (pos < getSourceText(seg).length) {
|
|
addMatch(seg, pos + 1);
|
|
} else if (seg < lastSourceIndex) {
|
|
addMatch(seg + 1, 0);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
addMatch(lastSourceIndex, getSourceText(lastSourceIndex).length);
|
|
return matches;
|
|
function getSourceText(index) {
|
|
return index < lastSourceIndex ? sourceTexts[index] : remainingEndText;
|
|
}
|
|
function addMatch(s, p) {
|
|
const matchType = s === seg ? getStringLiteralType(getSourceText(s).slice(pos, p)) : getTemplateLiteralType(
|
|
[sourceTexts[seg].slice(pos), ...sourceTexts.slice(seg + 1, s), getSourceText(s).slice(0, p)],
|
|
sourceTypes.slice(seg, s)
|
|
);
|
|
matches.push(matchType);
|
|
seg = s;
|
|
pos = p;
|
|
}
|
|
}
|
|
function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
|
|
let bivariant = false;
|
|
let propagationType;
|
|
let inferencePriority = 2048 /* MaxValue */;
|
|
let allowComplexConstraintInference = true;
|
|
let visited;
|
|
let sourceStack;
|
|
let targetStack;
|
|
let expandingFlags = 0 /* None */;
|
|
inferFromTypes(originalSource, originalTarget);
|
|
function inferFromTypes(source, target) {
|
|
if (!couldContainTypeVariables(target)) {
|
|
return;
|
|
}
|
|
if (source === wildcardType) {
|
|
const savePropagationType = propagationType;
|
|
propagationType = source;
|
|
inferFromTypes(target, target);
|
|
propagationType = savePropagationType;
|
|
return;
|
|
}
|
|
if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) {
|
|
if (source.aliasTypeArguments) {
|
|
inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol));
|
|
}
|
|
return;
|
|
}
|
|
if (source === target && source.flags & 3145728 /* UnionOrIntersection */) {
|
|
for (const t of source.types) {
|
|
inferFromTypes(t, t);
|
|
}
|
|
return;
|
|
}
|
|
if (target.flags & 1048576 /* Union */) {
|
|
const [tempSources, tempTargets] = inferFromMatchingTypes(source.flags & 1048576 /* Union */ ? source.types : [source], target.types, isTypeOrBaseIdenticalTo);
|
|
const [sources, targets] = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy);
|
|
if (targets.length === 0) {
|
|
return;
|
|
}
|
|
target = getUnionType(targets);
|
|
if (sources.length === 0) {
|
|
inferWithPriority(source, target, 1 /* NakedTypeVariable */);
|
|
return;
|
|
}
|
|
source = getUnionType(sources);
|
|
} else if (target.flags & 2097152 /* Intersection */ && !every(target.types, isNonGenericObjectType)) {
|
|
if (!(source.flags & 1048576 /* Union */)) {
|
|
const [sources, targets] = inferFromMatchingTypes(source.flags & 2097152 /* Intersection */ ? source.types : [source], target.types, isTypeIdenticalTo);
|
|
if (sources.length === 0 || targets.length === 0) {
|
|
return;
|
|
}
|
|
source = getIntersectionType(sources);
|
|
target = getIntersectionType(targets);
|
|
}
|
|
} else if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
|
|
target = getActualTypeVariable(target);
|
|
}
|
|
if (target.flags & 8650752 /* TypeVariable */) {
|
|
if (isFromInferenceBlockedSource(source)) {
|
|
return;
|
|
}
|
|
const inference = getInferenceInfoForType(target);
|
|
if (inference) {
|
|
if (getObjectFlags(source) & 262144 /* NonInferrableType */ || source === nonInferrableAnyType) {
|
|
return;
|
|
}
|
|
if (!inference.isFixed) {
|
|
if (inference.priority === void 0 || priority < inference.priority) {
|
|
inference.candidates = void 0;
|
|
inference.contraCandidates = void 0;
|
|
inference.topLevel = true;
|
|
inference.priority = priority;
|
|
}
|
|
if (priority === inference.priority) {
|
|
const candidate = propagationType || source;
|
|
if (contravariant && !bivariant) {
|
|
if (!contains(inference.contraCandidates, candidate)) {
|
|
inference.contraCandidates = append(inference.contraCandidates, candidate);
|
|
clearCachedInferences(inferences);
|
|
}
|
|
} else if (!contains(inference.candidates, candidate)) {
|
|
inference.candidates = append(inference.candidates, candidate);
|
|
clearCachedInferences(inferences);
|
|
}
|
|
}
|
|
if (!(priority & 128 /* ReturnType */) && target.flags & 262144 /* TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) {
|
|
inference.topLevel = false;
|
|
clearCachedInferences(inferences);
|
|
}
|
|
}
|
|
inferencePriority = Math.min(inferencePriority, priority);
|
|
return;
|
|
}
|
|
const simplified = getSimplifiedType(target, false);
|
|
if (simplified !== target) {
|
|
inferFromTypes(source, simplified);
|
|
} else if (target.flags & 8388608 /* IndexedAccess */) {
|
|
const indexType = getSimplifiedType(target.indexType, false);
|
|
if (indexType.flags & 465829888 /* Instantiable */) {
|
|
const simplified2 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, false), indexType, false);
|
|
if (simplified2 && simplified2 !== target) {
|
|
inferFromTypes(source, simplified2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target)) && !(source.node && target.node)) {
|
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
} else if (source.flags & 4194304 /* Index */ && target.flags & 4194304 /* Index */) {
|
|
inferFromContravariantTypes(source.type, target.type);
|
|
} else if ((isLiteralType(source) || source.flags & 4 /* String */) && target.flags & 4194304 /* Index */) {
|
|
const empty = createEmptyObjectTypeFromStringLiteral(source);
|
|
inferFromContravariantTypesWithPriority(empty, target.type, 256 /* LiteralKeyof */);
|
|
} else if (source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */) {
|
|
inferFromTypes(source.objectType, target.objectType);
|
|
inferFromTypes(source.indexType, target.indexType);
|
|
} else if (source.flags & 268435456 /* StringMapping */ && target.flags & 268435456 /* StringMapping */) {
|
|
if (source.symbol === target.symbol) {
|
|
inferFromTypes(source.type, target.type);
|
|
}
|
|
} else if (source.flags & 33554432 /* Substitution */) {
|
|
inferFromTypes(source.baseType, target);
|
|
inferWithPriority(getSubstitutionIntersection(source), target, 4 /* SubstituteSource */);
|
|
} else if (target.flags & 16777216 /* Conditional */) {
|
|
invokeOnce(source, target, inferToConditionalType);
|
|
} else if (target.flags & 3145728 /* UnionOrIntersection */) {
|
|
inferToMultipleTypes(source, target.types, target.flags);
|
|
} else if (source.flags & 1048576 /* Union */) {
|
|
const sourceTypes = source.types;
|
|
for (const sourceType of sourceTypes) {
|
|
inferFromTypes(sourceType, target);
|
|
}
|
|
} else if (target.flags & 134217728 /* TemplateLiteral */) {
|
|
inferToTemplateLiteralType(source, target);
|
|
} else {
|
|
source = getReducedType(source);
|
|
if (!(priority & 512 /* NoConstraints */ && source.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */))) {
|
|
const apparentSource = getApparentType(source);
|
|
if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 /* Object */ | 2097152 /* Intersection */))) {
|
|
allowComplexConstraintInference = false;
|
|
return inferFromTypes(apparentSource, target);
|
|
}
|
|
source = apparentSource;
|
|
}
|
|
if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */)) {
|
|
invokeOnce(source, target, inferFromObjectTypes);
|
|
}
|
|
}
|
|
}
|
|
function inferWithPriority(source, target, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferFromTypes(source, target);
|
|
priority = savePriority;
|
|
}
|
|
function inferFromContravariantTypesWithPriority(source, target, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferFromContravariantTypes(source, target);
|
|
priority = savePriority;
|
|
}
|
|
function inferToMultipleTypesWithPriority(source, targets, targetFlags, newPriority) {
|
|
const savePriority = priority;
|
|
priority |= newPriority;
|
|
inferToMultipleTypes(source, targets, targetFlags);
|
|
priority = savePriority;
|
|
}
|
|
function invokeOnce(source, target, action) {
|
|
const key = source.id + "," + target.id;
|
|
const status = visited && visited.get(key);
|
|
if (status !== void 0) {
|
|
inferencePriority = Math.min(inferencePriority, status);
|
|
return;
|
|
}
|
|
(visited || (visited = /* @__PURE__ */ new Map())).set(key, -1 /* Circularity */);
|
|
const saveInferencePriority = inferencePriority;
|
|
inferencePriority = 2048 /* MaxValue */;
|
|
const saveExpandingFlags = expandingFlags;
|
|
const sourceIdentity = getRecursionIdentity(source);
|
|
const targetIdentity = getRecursionIdentity(target);
|
|
if (contains(sourceStack, sourceIdentity))
|
|
expandingFlags |= 1 /* Source */;
|
|
if (contains(targetStack, targetIdentity))
|
|
expandingFlags |= 2 /* Target */;
|
|
if (expandingFlags !== 3 /* Both */) {
|
|
(sourceStack || (sourceStack = [])).push(sourceIdentity);
|
|
(targetStack || (targetStack = [])).push(targetIdentity);
|
|
action(source, target);
|
|
targetStack.pop();
|
|
sourceStack.pop();
|
|
} else {
|
|
inferencePriority = -1 /* Circularity */;
|
|
}
|
|
expandingFlags = saveExpandingFlags;
|
|
visited.set(key, inferencePriority);
|
|
inferencePriority = Math.min(inferencePriority, saveInferencePriority);
|
|
}
|
|
function inferFromMatchingTypes(sources, targets, matches) {
|
|
let matchedSources;
|
|
let matchedTargets;
|
|
for (const t of targets) {
|
|
for (const s of sources) {
|
|
if (matches(s, t)) {
|
|
inferFromTypes(s, t);
|
|
matchedSources = appendIfUnique(matchedSources, s);
|
|
matchedTargets = appendIfUnique(matchedTargets, t);
|
|
}
|
|
}
|
|
}
|
|
return [
|
|
matchedSources ? filter(sources, (t) => !contains(matchedSources, t)) : sources,
|
|
matchedTargets ? filter(targets, (t) => !contains(matchedTargets, t)) : targets
|
|
];
|
|
}
|
|
function inferFromTypeArguments(sourceTypes, targetTypes, variances) {
|
|
const count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length;
|
|
for (let i = 0; i < count; i++) {
|
|
if (i < variances.length && (variances[i] & 7 /* VarianceMask */) === 2 /* Contravariant */) {
|
|
inferFromContravariantTypes(sourceTypes[i], targetTypes[i]);
|
|
} else {
|
|
inferFromTypes(sourceTypes[i], targetTypes[i]);
|
|
}
|
|
}
|
|
}
|
|
function inferFromContravariantTypes(source, target) {
|
|
contravariant = !contravariant;
|
|
inferFromTypes(source, target);
|
|
contravariant = !contravariant;
|
|
}
|
|
function inferFromContravariantTypesIfStrictFunctionTypes(source, target) {
|
|
if (strictFunctionTypes || priority & 1024 /* AlwaysStrict */) {
|
|
inferFromContravariantTypes(source, target);
|
|
} else {
|
|
inferFromTypes(source, target);
|
|
}
|
|
}
|
|
function getInferenceInfoForType(type) {
|
|
if (type.flags & 8650752 /* TypeVariable */) {
|
|
for (const inference of inferences) {
|
|
if (type === inference.typeParameter) {
|
|
return inference;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSingleTypeVariableFromIntersectionTypes(types) {
|
|
let typeVariable;
|
|
for (const type of types) {
|
|
const t = type.flags & 2097152 /* Intersection */ && find(type.types, (t2) => !!getInferenceInfoForType(t2));
|
|
if (!t || typeVariable && t !== typeVariable) {
|
|
return void 0;
|
|
}
|
|
typeVariable = t;
|
|
}
|
|
return typeVariable;
|
|
}
|
|
function inferToMultipleTypes(source, targets, targetFlags) {
|
|
let typeVariableCount = 0;
|
|
if (targetFlags & 1048576 /* Union */) {
|
|
let nakedTypeVariable;
|
|
const sources = source.flags & 1048576 /* Union */ ? source.types : [source];
|
|
const matched = new Array(sources.length);
|
|
let inferenceCircularity = false;
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
nakedTypeVariable = t;
|
|
typeVariableCount++;
|
|
} else {
|
|
for (let i = 0; i < sources.length; i++) {
|
|
const saveInferencePriority = inferencePriority;
|
|
inferencePriority = 2048 /* MaxValue */;
|
|
inferFromTypes(sources[i], t);
|
|
if (inferencePriority === priority)
|
|
matched[i] = true;
|
|
inferenceCircularity = inferenceCircularity || inferencePriority === -1 /* Circularity */;
|
|
inferencePriority = Math.min(inferencePriority, saveInferencePriority);
|
|
}
|
|
}
|
|
}
|
|
if (typeVariableCount === 0) {
|
|
const intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets);
|
|
if (intersectionTypeVariable) {
|
|
inferWithPriority(source, intersectionTypeVariable, 1 /* NakedTypeVariable */);
|
|
}
|
|
return;
|
|
}
|
|
if (typeVariableCount === 1 && !inferenceCircularity) {
|
|
const unmatched = flatMap(sources, (s, i) => matched[i] ? void 0 : s);
|
|
if (unmatched.length) {
|
|
inferFromTypes(getUnionType(unmatched), nakedTypeVariable);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
typeVariableCount++;
|
|
} else {
|
|
inferFromTypes(source, t);
|
|
}
|
|
}
|
|
}
|
|
if (targetFlags & 2097152 /* Intersection */ ? typeVariableCount === 1 : typeVariableCount > 0) {
|
|
for (const t of targets) {
|
|
if (getInferenceInfoForType(t)) {
|
|
inferWithPriority(source, t, 1 /* NakedTypeVariable */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function inferToMappedType(source, target, constraintType) {
|
|
if (constraintType.flags & 1048576 /* Union */) {
|
|
let result = false;
|
|
for (const type of constraintType.types) {
|
|
result = inferToMappedType(source, target, type) || result;
|
|
}
|
|
return result;
|
|
}
|
|
if (constraintType.flags & 4194304 /* Index */) {
|
|
const inference = getInferenceInfoForType(constraintType.type);
|
|
if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) {
|
|
const inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType);
|
|
if (inferredType) {
|
|
inferWithPriority(
|
|
inferredType,
|
|
inference.typeParameter,
|
|
getObjectFlags(source) & 262144 /* NonInferrableType */ ? 16 /* PartialHomomorphicMappedType */ : 8 /* HomomorphicMappedType */
|
|
);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (constraintType.flags & 262144 /* TypeParameter */) {
|
|
inferWithPriority(getIndexType(source), constraintType, 32 /* MappedTypeConstraint */);
|
|
const extendedConstraint = getConstraintOfType(constraintType);
|
|
if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
|
|
return true;
|
|
}
|
|
const propTypes = map(getPropertiesOfType(source), getTypeOfSymbol);
|
|
const indexTypes = map(getIndexInfosOfType(source), (info) => info !== enumNumberIndexInfo ? info.type : neverType);
|
|
inferFromTypes(getUnionType(concatenate(propTypes, indexTypes)), getTemplateTypeFromMappedType(target));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function inferToConditionalType(source, target) {
|
|
if (source.flags & 16777216 /* Conditional */) {
|
|
inferFromTypes(source.checkType, target.checkType);
|
|
inferFromTypes(source.extendsType, target.extendsType);
|
|
inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target));
|
|
inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target));
|
|
} else {
|
|
const targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)];
|
|
inferToMultipleTypesWithPriority(source, targetTypes, target.flags, contravariant ? 64 /* ContravariantConditional */ : 0);
|
|
}
|
|
}
|
|
function inferToTemplateLiteralType(source, target) {
|
|
const matches = inferTypesFromTemplateLiteralType(source, target);
|
|
const types = target.types;
|
|
if (matches || every(target.texts, (s) => s.length === 0)) {
|
|
for (let i = 0; i < types.length; i++) {
|
|
const source2 = matches ? matches[i] : neverType;
|
|
const target2 = types[i];
|
|
if (source2.flags & 128 /* StringLiteral */ && target2.flags & 8650752 /* TypeVariable */) {
|
|
const inferenceContext = getInferenceInfoForType(target2);
|
|
const constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : void 0;
|
|
if (constraint && !isTypeAny(constraint)) {
|
|
const constraintTypes = constraint.flags & 1048576 /* Union */ ? constraint.types : [constraint];
|
|
let allTypeFlags = reduceLeft(constraintTypes, (flags, t) => flags | t.flags, 0);
|
|
if (!(allTypeFlags & 4 /* String */)) {
|
|
const str = source2.value;
|
|
if (allTypeFlags & 296 /* NumberLike */ && !isValidNumberString(str, true)) {
|
|
allTypeFlags &= ~296 /* NumberLike */;
|
|
}
|
|
if (allTypeFlags & 2112 /* BigIntLike */ && !isValidBigIntString(str, true)) {
|
|
allTypeFlags &= ~2112 /* BigIntLike */;
|
|
}
|
|
const matchingType = reduceLeft(
|
|
constraintTypes,
|
|
(left, right) => !(right.flags & allTypeFlags) ? left : left.flags & 4 /* String */ ? left : right.flags & 4 /* String */ ? source2 : left.flags & 134217728 /* TemplateLiteral */ ? left : right.flags & 134217728 /* TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source2, right) ? source2 : left.flags & 268435456 /* StringMapping */ ? left : right.flags & 268435456 /* StringMapping */ && str === applyStringMapping(right.symbol, str) ? source2 : left.flags & 128 /* StringLiteral */ ? left : right.flags & 128 /* StringLiteral */ && right.value === str ? right : left.flags & 8 /* Number */ ? left : right.flags & 8 /* Number */ ? getNumberLiteralType(+str) : left.flags & 32 /* Enum */ ? left : right.flags & 32 /* Enum */ ? getNumberLiteralType(+str) : left.flags & 256 /* NumberLiteral */ ? left : right.flags & 256 /* NumberLiteral */ && right.value === +str ? right : left.flags & 64 /* BigInt */ ? left : right.flags & 64 /* BigInt */ ? parseBigIntLiteralType(str) : left.flags & 2048 /* BigIntLiteral */ ? left : right.flags & 2048 /* BigIntLiteral */ && pseudoBigIntToString(right.value) === str ? right : left.flags & 16 /* Boolean */ ? left : right.flags & 16 /* Boolean */ ? str === "true" ? trueType : str === "false" ? falseType : booleanType : left.flags & 512 /* BooleanLiteral */ ? left : right.flags & 512 /* BooleanLiteral */ && right.intrinsicName === str ? right : left.flags & 32768 /* Undefined */ ? left : right.flags & 32768 /* Undefined */ && right.intrinsicName === str ? right : left.flags & 65536 /* Null */ ? left : right.flags & 65536 /* Null */ && right.intrinsicName === str ? right : left,
|
|
neverType
|
|
);
|
|
if (!(matchingType.flags & 131072 /* Never */)) {
|
|
inferFromTypes(matchingType, target2);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
inferFromTypes(source2, target2);
|
|
}
|
|
}
|
|
}
|
|
function inferFromObjectTypes(source, target) {
|
|
if (getObjectFlags(source) & 4 /* Reference */ && getObjectFlags(target) & 4 /* Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) {
|
|
inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target));
|
|
return;
|
|
}
|
|
if (isGenericMappedType(source) && isGenericMappedType(target)) {
|
|
inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target));
|
|
inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target));
|
|
const sourceNameType = getNameTypeFromMappedType(source);
|
|
const targetNameType = getNameTypeFromMappedType(target);
|
|
if (sourceNameType && targetNameType)
|
|
inferFromTypes(sourceNameType, targetNameType);
|
|
}
|
|
if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
|
|
const constraintType = getConstraintTypeFromMappedType(target);
|
|
if (inferToMappedType(source, target, constraintType)) {
|
|
return;
|
|
}
|
|
}
|
|
if (!typesDefinitelyUnrelated(source, target)) {
|
|
if (isArrayOrTupleType(source)) {
|
|
if (isTupleType(target)) {
|
|
const sourceArity = getTypeReferenceArity(source);
|
|
const targetArity = getTypeReferenceArity(target);
|
|
const elementTypes = getTypeArguments(target);
|
|
const elementFlags = target.target.elementFlags;
|
|
if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
|
|
for (let i = 0; i < targetArity; i++) {
|
|
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
|
|
}
|
|
return;
|
|
}
|
|
const startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0;
|
|
const endLength = Math.min(
|
|
isTupleType(source) ? getEndElementCount(source.target, 3 /* Fixed */) : 0,
|
|
target.target.hasRestElement ? getEndElementCount(target.target, 3 /* Fixed */) : 0
|
|
);
|
|
for (let i = 0; i < startLength; i++) {
|
|
inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
|
|
}
|
|
if (!isTupleType(source) || sourceArity - startLength - endLength === 1 && source.target.elementFlags[startLength] & 4 /* Rest */) {
|
|
const restType = getTypeArguments(source)[startLength];
|
|
for (let i = startLength; i < targetArity - endLength; i++) {
|
|
inferFromTypes(elementFlags[i] & 8 /* Variadic */ ? createArrayType(restType) : restType, elementTypes[i]);
|
|
}
|
|
} else {
|
|
const middleLength = targetArity - startLength - endLength;
|
|
if (middleLength === 2 && elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* Variadic */ && isTupleType(source)) {
|
|
const targetInfo = getInferenceInfoForType(elementTypes[startLength]);
|
|
if (targetInfo && targetInfo.impliedArity !== void 0) {
|
|
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 */) {
|
|
const endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* Optional */;
|
|
const 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 */) {
|
|
const restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, endLength) : getTypeArguments(source)[0];
|
|
if (restType) {
|
|
inferFromTypes(restType, elementTypes[startLength]);
|
|
}
|
|
}
|
|
}
|
|
for (let i = 0; i < endLength; i++) {
|
|
inferFromTypes(getTypeArguments(source)[sourceArity - i - 1], elementTypes[targetArity - i - 1]);
|
|
}
|
|
return;
|
|
}
|
|
if (isArrayType(target)) {
|
|
inferFromIndexTypes(source, target);
|
|
return;
|
|
}
|
|
}
|
|
inferFromProperties(source, target);
|
|
inferFromSignatures(source, target, 0 /* Call */);
|
|
inferFromSignatures(source, target, 1 /* Construct */);
|
|
inferFromIndexTypes(source, target);
|
|
}
|
|
}
|
|
function inferFromProperties(source, target) {
|
|
const properties = getPropertiesOfObjectType(target);
|
|
for (const targetProp of properties) {
|
|
const sourceProp = getPropertyOfType(source, targetProp.escapedName);
|
|
if (sourceProp && !some(sourceProp.declarations, hasSkipDirectInferenceFlag)) {
|
|
inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
|
|
}
|
|
}
|
|
}
|
|
function inferFromSignatures(source, target, kind) {
|
|
const sourceSignatures = getSignaturesOfType(source, kind);
|
|
const targetSignatures = getSignaturesOfType(target, kind);
|
|
const sourceLen = sourceSignatures.length;
|
|
const targetLen = targetSignatures.length;
|
|
const len = sourceLen < targetLen ? sourceLen : targetLen;
|
|
for (let i = 0; i < len; i++) {
|
|
inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
|
|
}
|
|
}
|
|
function inferFromSignature(source, target) {
|
|
const saveBivariant = bivariant;
|
|
const kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
|
|
bivariant = bivariant || kind === 171 /* MethodDeclaration */ || kind === 170 /* MethodSignature */ || kind === 173 /* Constructor */;
|
|
applyToParameterTypes(source, target, inferFromContravariantTypesIfStrictFunctionTypes);
|
|
bivariant = saveBivariant;
|
|
applyToReturnTypes(source, target, inferFromTypes);
|
|
}
|
|
function inferFromIndexTypes(source, target) {
|
|
const priority2 = getObjectFlags(source) & getObjectFlags(target) & 32 /* Mapped */ ? 8 /* HomomorphicMappedType */ : 0;
|
|
const indexInfos = getIndexInfosOfType(target);
|
|
if (isObjectTypeWithInferableIndex(source)) {
|
|
for (const targetInfo of indexInfos) {
|
|
const propTypes = [];
|
|
for (const prop of getPropertiesOfType(source)) {
|
|
if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */), targetInfo.keyType)) {
|
|
const propType = getTypeOfSymbol(prop);
|
|
propTypes.push(prop.flags & 16777216 /* Optional */ ? removeMissingOrUndefinedType(propType) : propType);
|
|
}
|
|
}
|
|
for (const info of getIndexInfosOfType(source)) {
|
|
if (isApplicableIndexType(info.keyType, targetInfo.keyType)) {
|
|
propTypes.push(info.type);
|
|
}
|
|
}
|
|
if (propTypes.length) {
|
|
inferWithPriority(getUnionType(propTypes), targetInfo.type, priority2);
|
|
}
|
|
}
|
|
}
|
|
for (const targetInfo of indexInfos) {
|
|
const sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType);
|
|
if (sourceInfo) {
|
|
inferWithPriority(sourceInfo.type, targetInfo.type, priority2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isTypeOrBaseIdenticalTo(s, t) {
|
|
return exactOptionalPropertyTypes && t === missingType ? s === t : isTypeIdenticalTo(s, t) || !!(t.flags & 4 /* String */ && s.flags & 128 /* StringLiteral */ || t.flags & 8 /* Number */ && s.flags & 256 /* NumberLiteral */);
|
|
}
|
|
function isTypeCloselyMatchedBy(s, t) {
|
|
return !!(s.flags & 524288 /* Object */ && t.flags & 524288 /* Object */ && s.symbol && s.symbol === t.symbol || s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol);
|
|
}
|
|
function hasPrimitiveConstraint(type) {
|
|
const constraint = getConstraintOfTypeParameter(type);
|
|
return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
|
|
}
|
|
function isObjectLiteralType2(type) {
|
|
return !!(getObjectFlags(type) & 128 /* ObjectLiteral */);
|
|
}
|
|
function isObjectOrArrayLiteralType(type) {
|
|
return !!(getObjectFlags(type) & (128 /* ObjectLiteral */ | 16384 /* ArrayLiteral */));
|
|
}
|
|
function unionObjectAndArrayLiteralCandidates(candidates) {
|
|
if (candidates.length > 1) {
|
|
const objectLiterals = filter(candidates, isObjectOrArrayLiteralType);
|
|
if (objectLiterals.length) {
|
|
const literalsType = getUnionType(objectLiterals, 2 /* Subtype */);
|
|
return concatenate(filter(candidates, (t) => !isObjectOrArrayLiteralType(t)), [literalsType]);
|
|
}
|
|
}
|
|
return candidates;
|
|
}
|
|
function getContravariantInference(inference) {
|
|
return inference.priority & 416 /* PriorityImpliesCombination */ ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates);
|
|
}
|
|
function getCovariantInference(inference, signature) {
|
|
const candidates = unionObjectAndArrayLiteralCandidates(inference.candidates);
|
|
const primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter);
|
|
const widenLiteralTypes = !primitiveConstraint && inference.topLevel && (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter));
|
|
const baseCandidates = primitiveConstraint ? sameMap(candidates, getRegularTypeOfLiteralType) : widenLiteralTypes ? sameMap(candidates, getWidenedLiteralType) : candidates;
|
|
const unwidenedType = inference.priority & 416 /* PriorityImpliesCombination */ ? getUnionType(baseCandidates, 2 /* Subtype */) : getCommonSupertype(baseCandidates);
|
|
return getWidenedType(unwidenedType);
|
|
}
|
|
function getInferredType(context, index) {
|
|
const inference = context.inferences[index];
|
|
if (!inference.inferredType) {
|
|
let inferredType;
|
|
const signature = context.signature;
|
|
if (signature) {
|
|
const inferredCovariantType = inference.candidates ? getCovariantInference(inference, signature) : void 0;
|
|
if (inference.contraCandidates) {
|
|
inferredType = inferredCovariantType && !(inferredCovariantType.flags & 131072 /* Never */) && some(inference.contraCandidates, (t) => isTypeSubtypeOf(inferredCovariantType, t)) ? inferredCovariantType : getContravariantInference(inference);
|
|
} else if (inferredCovariantType) {
|
|
inferredType = inferredCovariantType;
|
|
} else if (context.flags & 1 /* NoDefault */) {
|
|
inferredType = silentNeverType;
|
|
} else {
|
|
const defaultType = getDefaultFromTypeParameter(inference.typeParameter);
|
|
if (defaultType) {
|
|
inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper));
|
|
}
|
|
}
|
|
} else {
|
|
inferredType = getTypeFromInference(inference);
|
|
}
|
|
inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2 /* AnyDefault */));
|
|
const constraint = getConstraintOfTypeParameter(inference.typeParameter);
|
|
if (constraint) {
|
|
const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
|
|
if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
|
|
inference.inferredType = inferredType = instantiatedConstraint;
|
|
}
|
|
}
|
|
}
|
|
return inference.inferredType;
|
|
}
|
|
function getDefaultTypeArgumentType(isInJavaScriptFile) {
|
|
return isInJavaScriptFile ? anyType : unknownType;
|
|
}
|
|
function getInferredTypes(context) {
|
|
const result = [];
|
|
for (let i = 0; i < context.inferences.length; i++) {
|
|
result.push(getInferredType(context, i));
|
|
}
|
|
return result;
|
|
}
|
|
function getCannotFindNameDiagnosticForName(node) {
|
|
switch (node.escapedText) {
|
|
case "document":
|
|
case "console":
|
|
return Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom;
|
|
case "$":
|
|
return compilerOptions.types ? Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig : Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery;
|
|
case "describe":
|
|
case "suite":
|
|
case "it":
|
|
case "test":
|
|
return compilerOptions.types ? Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig : Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha;
|
|
case "process":
|
|
case "require":
|
|
case "Buffer":
|
|
case "module":
|
|
return compilerOptions.types ? Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig : Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode;
|
|
case "Map":
|
|
case "Set":
|
|
case "Promise":
|
|
case "Symbol":
|
|
case "WeakMap":
|
|
case "WeakSet":
|
|
case "Iterator":
|
|
case "AsyncIterator":
|
|
case "SharedArrayBuffer":
|
|
case "Atomics":
|
|
case "AsyncIterable":
|
|
case "AsyncIterableIterator":
|
|
case "AsyncGenerator":
|
|
case "AsyncGeneratorFunction":
|
|
case "BigInt":
|
|
case "Reflect":
|
|
case "BigInt64Array":
|
|
case "BigUint64Array":
|
|
return Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later;
|
|
case "await":
|
|
if (isCallExpression(node.parent)) {
|
|
return Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function;
|
|
}
|
|
default:
|
|
if (node.parent.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
|
|
} else {
|
|
return Diagnostics.Cannot_find_name_0;
|
|
}
|
|
}
|
|
}
|
|
function getResolvedSymbol(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedSymbol) {
|
|
links.resolvedSymbol = !nodeIsMissing(node) && resolveName(
|
|
node,
|
|
node.escapedText,
|
|
111551 /* Value */ | 1048576 /* ExportValue */,
|
|
getCannotFindNameDiagnosticForName(node),
|
|
node,
|
|
!isWriteOnlyAccess(node),
|
|
false
|
|
) || unknownSymbol;
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function isInTypeQuery(node) {
|
|
return !!findAncestor(
|
|
node,
|
|
(n) => n.kind === 183 /* TypeQuery */ ? true : n.kind === 79 /* Identifier */ || n.kind === 163 /* QualifiedName */ ? false : "quit"
|
|
);
|
|
}
|
|
function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
if (!isThisInTypeQuery(node)) {
|
|
const symbol = getResolvedSymbol(node);
|
|
return symbol !== unknownSymbol ? `${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}|${getSymbolId(symbol)}` : void 0;
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
return `0|${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}`;
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
|
|
case 163 /* QualifiedName */:
|
|
const left = getFlowCacheKey(node.left, declaredType, initialType, flowContainer);
|
|
return left && left + "." + node.right.escapedText;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const propName = getAccessedPropertyName(node);
|
|
if (propName !== void 0) {
|
|
const key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
|
|
return key && key + "." + propName;
|
|
}
|
|
break;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
return `${getNodeId(node)}#${getTypeId(declaredType)}`;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isMatchingReference(source, target) {
|
|
switch (target.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return isMatchingReference(source, target.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isAssignmentExpression(target) && isMatchingReference(source, target.left) || isBinaryExpression(target) && target.operatorToken.kind === 27 /* CommaToken */ && isMatchingReference(source, target.right);
|
|
}
|
|
switch (source.kind) {
|
|
case 233 /* MetaProperty */:
|
|
return target.kind === 233 /* MetaProperty */ && source.keywordToken === target.keywordToken && source.name.escapedText === target.name.escapedText;
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return isThisInTypeQuery(source) ? target.kind === 108 /* ThisKeyword */ : target.kind === 79 /* Identifier */ && getResolvedSymbol(source) === getResolvedSymbol(target) || (target.kind === 257 /* VariableDeclaration */ || target.kind === 205 /* BindingElement */) && getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target);
|
|
case 108 /* ThisKeyword */:
|
|
return target.kind === 108 /* ThisKeyword */;
|
|
case 106 /* SuperKeyword */:
|
|
return target.kind === 106 /* SuperKeyword */;
|
|
case 232 /* NonNullExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isMatchingReference(source.expression, target);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const sourcePropertyName = getAccessedPropertyName(source);
|
|
const targetPropertyName = isAccessExpression(target) ? getAccessedPropertyName(target) : void 0;
|
|
return sourcePropertyName !== void 0 && targetPropertyName !== void 0 && targetPropertyName === sourcePropertyName && isMatchingReference(source.expression, target.expression);
|
|
case 163 /* QualifiedName */:
|
|
return isAccessExpression(target) && source.right.escapedText === getAccessedPropertyName(target) && isMatchingReference(source.left, target.expression);
|
|
case 223 /* BinaryExpression */:
|
|
return isBinaryExpression(source) && source.operatorToken.kind === 27 /* CommaToken */ && isMatchingReference(source.right, target);
|
|
}
|
|
return false;
|
|
}
|
|
function getAccessedPropertyName(access) {
|
|
if (isPropertyAccessExpression(access)) {
|
|
return access.name.escapedText;
|
|
}
|
|
if (isElementAccessExpression(access)) {
|
|
return tryGetElementAccessExpressionName(access);
|
|
}
|
|
if (isBindingElement(access)) {
|
|
const name = getDestructuringPropertyName(access);
|
|
return name ? escapeLeadingUnderscores(name) : void 0;
|
|
}
|
|
if (isParameter(access)) {
|
|
return "" + access.parent.parameters.indexOf(access);
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetNameFromType(type) {
|
|
return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName : type.flags & 384 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
|
|
}
|
|
function tryGetElementAccessExpressionName(node) {
|
|
if (isStringOrNumericLiteralLike(node.argumentExpression)) {
|
|
return escapeLeadingUnderscores(node.argumentExpression.text);
|
|
}
|
|
if (isEntityNameExpression(node.argumentExpression)) {
|
|
const symbol = resolveEntityName(node.argumentExpression, 111551 /* Value */, true);
|
|
if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
|
|
return void 0;
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration === void 0)
|
|
return void 0;
|
|
const type = tryGetTypeFromEffectiveTypeNode(declaration);
|
|
if (type) {
|
|
const name = tryGetNameFromType(type);
|
|
if (name !== void 0) {
|
|
return name;
|
|
}
|
|
}
|
|
if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
|
|
const initializer = getEffectiveInitializer(declaration);
|
|
if (initializer) {
|
|
return tryGetNameFromType(getTypeOfExpression(initializer));
|
|
}
|
|
if (isEnumMember(declaration)) {
|
|
return getTextOfPropertyName(declaration.name);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function containsMatchingReference(source, target) {
|
|
while (isAccessExpression(source)) {
|
|
source = source.expression;
|
|
if (isMatchingReference(source, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function optionalChainContainsReference(source, target) {
|
|
while (isOptionalChain(source)) {
|
|
source = source.expression;
|
|
if (isMatchingReference(source, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isDiscriminantProperty(type, name) {
|
|
if (type && type.flags & 1048576 /* Union */) {
|
|
const prop = getUnionOrIntersectionProperty(type, name);
|
|
if (prop && getCheckFlags(prop) & 2 /* SyntheticProperty */) {
|
|
if (prop.isDiscriminantProperty === void 0) {
|
|
prop.isDiscriminantProperty = (prop.checkFlags & 192 /* Discriminant */) === 192 /* Discriminant */ && !isGenericType(getTypeOfSymbol(prop));
|
|
}
|
|
return !!prop.isDiscriminantProperty;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function findDiscriminantProperties(sourceProperties, target) {
|
|
let result;
|
|
for (const sourceProperty of sourceProperties) {
|
|
if (isDiscriminantProperty(target, sourceProperty.escapedName)) {
|
|
if (result) {
|
|
result.push(sourceProperty);
|
|
continue;
|
|
}
|
|
result = [sourceProperty];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function mapTypesByKeyProperty(types, name) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
let count = 0;
|
|
for (const type of types) {
|
|
if (type.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
const discriminant = getTypeOfPropertyOfType(type, name);
|
|
if (discriminant) {
|
|
if (!isLiteralType(discriminant)) {
|
|
return void 0;
|
|
}
|
|
let duplicate = false;
|
|
forEachType(discriminant, (t) => {
|
|
const id = getTypeId(getRegularTypeOfLiteralType(t));
|
|
const existing = map2.get(id);
|
|
if (!existing) {
|
|
map2.set(id, type);
|
|
} else if (existing !== unknownType) {
|
|
map2.set(id, unknownType);
|
|
duplicate = true;
|
|
}
|
|
});
|
|
if (!duplicate)
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
return count >= 10 && count * 2 >= types.length ? map2 : void 0;
|
|
}
|
|
function getKeyPropertyName(unionType) {
|
|
const types = unionType.types;
|
|
if (types.length < 10 || getObjectFlags(unionType) & 32768 /* PrimitiveUnion */ || countWhere(types, (t) => !!(t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */))) < 10) {
|
|
return void 0;
|
|
}
|
|
if (unionType.keyPropertyName === void 0) {
|
|
const keyPropertyName = forEach(types, (t) => t.flags & (524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) ? forEach(getPropertiesOfType(t), (p) => isUnitType(getTypeOfSymbol(p)) ? p.escapedName : void 0) : void 0);
|
|
const mapByKeyProperty = keyPropertyName && mapTypesByKeyProperty(types, keyPropertyName);
|
|
unionType.keyPropertyName = mapByKeyProperty ? keyPropertyName : "";
|
|
unionType.constituentMap = mapByKeyProperty;
|
|
}
|
|
return unionType.keyPropertyName.length ? unionType.keyPropertyName : void 0;
|
|
}
|
|
function getConstituentTypeForKeyType(unionType, keyType) {
|
|
var _a2;
|
|
const result = (_a2 = unionType.constituentMap) == null ? void 0 : _a2.get(getTypeId(getRegularTypeOfLiteralType(keyType)));
|
|
return result !== unknownType ? result : void 0;
|
|
}
|
|
function getMatchingUnionConstituentForType(unionType, type) {
|
|
const keyPropertyName = getKeyPropertyName(unionType);
|
|
const propType = keyPropertyName && getTypeOfPropertyOfType(type, keyPropertyName);
|
|
return propType && getConstituentTypeForKeyType(unionType, propType);
|
|
}
|
|
function getMatchingUnionConstituentForObjectLiteral(unionType, node) {
|
|
const keyPropertyName = getKeyPropertyName(unionType);
|
|
const propNode = keyPropertyName && find(node.properties, (p) => p.symbol && p.kind === 299 /* PropertyAssignment */ && p.symbol.escapedName === keyPropertyName && isPossiblyDiscriminantValue(p.initializer));
|
|
const propType = propNode && getContextFreeTypeOfExpression(propNode.initializer);
|
|
return propType && getConstituentTypeForKeyType(unionType, propType);
|
|
}
|
|
function isOrContainsMatchingReference(source, target) {
|
|
return isMatchingReference(source, target) || containsMatchingReference(source, target);
|
|
}
|
|
function hasMatchingArgument(expression, reference) {
|
|
if (expression.arguments) {
|
|
for (const argument of expression.arguments) {
|
|
if (isOrContainsMatchingReference(reference, argument)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (expression.expression.kind === 208 /* PropertyAccessExpression */ && isOrContainsMatchingReference(reference, expression.expression.expression)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getFlowNodeId(flow) {
|
|
if (!flow.id || flow.id < 0) {
|
|
flow.id = nextFlowId;
|
|
nextFlowId++;
|
|
}
|
|
return flow.id;
|
|
}
|
|
function typeMaybeAssignableTo(source, target) {
|
|
if (!(source.flags & 1048576 /* Union */)) {
|
|
return isTypeAssignableTo(source, target);
|
|
}
|
|
for (const t of source.types) {
|
|
if (isTypeAssignableTo(t, target)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getAssignmentReducedType(declaredType, assignedType) {
|
|
var _a2;
|
|
if (declaredType === assignedType) {
|
|
return declaredType;
|
|
}
|
|
if (assignedType.flags & 131072 /* Never */) {
|
|
return assignedType;
|
|
}
|
|
const key = `A${getTypeId(declaredType)},${getTypeId(assignedType)}`;
|
|
return (_a2 = getCachedType(key)) != null ? _a2 : setCachedType(key, getAssignmentReducedTypeWorker(declaredType, assignedType));
|
|
}
|
|
function getAssignmentReducedTypeWorker(declaredType, assignedType) {
|
|
const filteredType = filterType(declaredType, (t) => typeMaybeAssignableTo(assignedType, t));
|
|
const reducedType = assignedType.flags & 512 /* BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType;
|
|
return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
|
|
}
|
|
function isFunctionObjectType(type) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
|
|
}
|
|
function getTypeFacts(type) {
|
|
if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
|
|
type = getBaseConstraintOfType(type) || unknownType;
|
|
}
|
|
const flags = type.flags;
|
|
if (flags & (4 /* String */ | 268435456 /* StringMapping */)) {
|
|
return strictNullChecks ? 16317953 /* StringStrictFacts */ : 16776705 /* StringFacts */;
|
|
}
|
|
if (flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */)) {
|
|
const isEmpty = flags & 128 /* StringLiteral */ && type.value === "";
|
|
return strictNullChecks ? isEmpty ? 12123649 /* EmptyStringStrictFacts */ : 7929345 /* NonEmptyStringStrictFacts */ : isEmpty ? 12582401 /* EmptyStringFacts */ : 16776705 /* NonEmptyStringFacts */;
|
|
}
|
|
if (flags & (8 /* Number */ | 32 /* Enum */)) {
|
|
return strictNullChecks ? 16317698 /* NumberStrictFacts */ : 16776450 /* NumberFacts */;
|
|
}
|
|
if (flags & 256 /* NumberLiteral */) {
|
|
const isZero = type.value === 0;
|
|
return strictNullChecks ? isZero ? 12123394 /* ZeroNumberStrictFacts */ : 7929090 /* NonZeroNumberStrictFacts */ : isZero ? 12582146 /* ZeroNumberFacts */ : 16776450 /* NonZeroNumberFacts */;
|
|
}
|
|
if (flags & 64 /* BigInt */) {
|
|
return strictNullChecks ? 16317188 /* BigIntStrictFacts */ : 16775940 /* BigIntFacts */;
|
|
}
|
|
if (flags & 2048 /* BigIntLiteral */) {
|
|
const isZero = isZeroBigInt(type);
|
|
return strictNullChecks ? isZero ? 12122884 /* ZeroBigIntStrictFacts */ : 7928580 /* NonZeroBigIntStrictFacts */ : isZero ? 12581636 /* ZeroBigIntFacts */ : 16775940 /* NonZeroBigIntFacts */;
|
|
}
|
|
if (flags & 16 /* Boolean */) {
|
|
return strictNullChecks ? 16316168 /* BooleanStrictFacts */ : 16774920 /* BooleanFacts */;
|
|
}
|
|
if (flags & 528 /* BooleanLike */) {
|
|
return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
|
|
}
|
|
if (flags & 524288 /* Object */) {
|
|
return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
|
|
}
|
|
if (flags & 16384 /* Void */) {
|
|
return 9830144 /* VoidFacts */;
|
|
}
|
|
if (flags & 32768 /* Undefined */) {
|
|
return 26607360 /* UndefinedFacts */;
|
|
}
|
|
if (flags & 65536 /* Null */) {
|
|
return 42917664 /* NullFacts */;
|
|
}
|
|
if (flags & 12288 /* ESSymbolLike */) {
|
|
return strictNullChecks ? 7925520 /* SymbolStrictFacts */ : 16772880 /* SymbolFacts */;
|
|
}
|
|
if (flags & 67108864 /* NonPrimitive */) {
|
|
return strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
|
|
}
|
|
if (flags & 131072 /* Never */) {
|
|
return 0 /* None */;
|
|
}
|
|
if (flags & 1048576 /* Union */) {
|
|
return reduceLeft(type.types, (facts, t) => facts | getTypeFacts(t), 0 /* None */);
|
|
}
|
|
if (flags & 2097152 /* Intersection */) {
|
|
return getIntersectionTypeFacts(type);
|
|
}
|
|
return 83886079 /* UnknownFacts */;
|
|
}
|
|
function getIntersectionTypeFacts(type) {
|
|
const ignoreObjects = maybeTypeOfKind(type, 131068 /* Primitive */);
|
|
let oredFacts = 0 /* None */;
|
|
let andedFacts = 134217727 /* All */;
|
|
for (const t of type.types) {
|
|
if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
|
|
const f = getTypeFacts(t);
|
|
oredFacts |= f;
|
|
andedFacts &= f;
|
|
}
|
|
}
|
|
return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
|
|
}
|
|
function getTypeWithFacts(type, include) {
|
|
return filterType(type, (t) => (getTypeFacts(t) & include) !== 0);
|
|
}
|
|
function getAdjustedTypeWithFacts(type, facts) {
|
|
const reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
|
|
if (strictNullChecks) {
|
|
switch (facts) {
|
|
case 524288 /* NEUndefined */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
|
|
case 1048576 /* NENull */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
|
|
case 2097152 /* NEUndefinedOrNull */:
|
|
case 4194304 /* Truthy */:
|
|
return mapType(reduced, (t) => getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t);
|
|
}
|
|
}
|
|
return reduced;
|
|
}
|
|
function recombineUnknownType(type) {
|
|
return type === unknownUnionType ? unknownType : type;
|
|
}
|
|
function getTypeWithDefault(type, defaultExpression) {
|
|
return defaultExpression ? getUnionType([getNonUndefinedType(type), getTypeOfExpression(defaultExpression)]) : type;
|
|
}
|
|
function getTypeOfDestructuredProperty(type, name) {
|
|
var _a2;
|
|
const nameType = getLiteralTypeFromPropertyName(name);
|
|
if (!isTypeUsableAsPropertyName(nameType))
|
|
return errorType;
|
|
const text = getPropertyNameFromType(nameType);
|
|
return getTypeOfPropertyOfType(type, text) || includeUndefinedInIndexSignature((_a2 = getApplicableIndexInfoForName(type, text)) == null ? void 0 : _a2.type) || errorType;
|
|
}
|
|
function getTypeOfDestructuredArrayElement(type, index) {
|
|
return everyType(type, isTupleLikeType) && getTupleElementType(type, index) || includeUndefinedInIndexSignature(checkIteratedTypeOrElementType(65 /* Destructuring */, type, undefinedType, void 0)) || errorType;
|
|
}
|
|
function includeUndefinedInIndexSignature(type) {
|
|
if (!type)
|
|
return type;
|
|
return compilerOptions.noUncheckedIndexedAccess ? getUnionType([type, undefinedType]) : type;
|
|
}
|
|
function getTypeOfDestructuredSpreadExpression(type) {
|
|
return createArrayType(checkIteratedTypeOrElementType(65 /* Destructuring */, type, undefinedType, void 0) || errorType);
|
|
}
|
|
function getAssignedTypeOfBinaryExpression(node) {
|
|
const isDestructuringDefaultAssignment = node.parent.kind === 206 /* ArrayLiteralExpression */ && isDestructuringAssignmentTarget(node.parent) || node.parent.kind === 299 /* PropertyAssignment */ && isDestructuringAssignmentTarget(node.parent.parent);
|
|
return isDestructuringDefaultAssignment ? getTypeWithDefault(getAssignedType(node), node.right) : getTypeOfExpression(node.right);
|
|
}
|
|
function isDestructuringAssignmentTarget(parent2) {
|
|
return parent2.parent.kind === 223 /* BinaryExpression */ && parent2.parent.left === parent2 || parent2.parent.kind === 247 /* ForOfStatement */ && parent2.parent.initializer === parent2;
|
|
}
|
|
function getAssignedTypeOfArrayLiteralElement(node, element) {
|
|
return getTypeOfDestructuredArrayElement(getAssignedType(node), node.elements.indexOf(element));
|
|
}
|
|
function getAssignedTypeOfSpreadExpression(node) {
|
|
return getTypeOfDestructuredSpreadExpression(getAssignedType(node.parent));
|
|
}
|
|
function getAssignedTypeOfPropertyAssignment(node) {
|
|
return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name);
|
|
}
|
|
function getAssignedTypeOfShorthandPropertyAssignment(node) {
|
|
return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer);
|
|
}
|
|
function getAssignedType(node) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 246 /* ForInStatement */:
|
|
return stringType;
|
|
case 247 /* ForOfStatement */:
|
|
return checkRightHandSideOfForOf(parent2) || errorType;
|
|
case 223 /* BinaryExpression */:
|
|
return getAssignedTypeOfBinaryExpression(parent2);
|
|
case 217 /* DeleteExpression */:
|
|
return undefinedType;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return getAssignedTypeOfArrayLiteralElement(parent2, node);
|
|
case 227 /* SpreadElement */:
|
|
return getAssignedTypeOfSpreadExpression(parent2);
|
|
case 299 /* PropertyAssignment */:
|
|
return getAssignedTypeOfPropertyAssignment(parent2);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return getAssignedTypeOfShorthandPropertyAssignment(parent2);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getInitialTypeOfBindingElement(node) {
|
|
const pattern = node.parent;
|
|
const parentType = getInitialType(pattern.parent);
|
|
const type = pattern.kind === 203 /* ObjectBindingPattern */ ? getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) : !node.dotDotDotToken ? getTypeOfDestructuredArrayElement(parentType, pattern.elements.indexOf(node)) : getTypeOfDestructuredSpreadExpression(parentType);
|
|
return getTypeWithDefault(type, node.initializer);
|
|
}
|
|
function getTypeOfInitializer(node) {
|
|
const links = getNodeLinks(node);
|
|
return links.resolvedType || getTypeOfExpression(node);
|
|
}
|
|
function getInitialTypeOfVariableDeclaration(node) {
|
|
if (node.initializer) {
|
|
return getTypeOfInitializer(node.initializer);
|
|
}
|
|
if (node.parent.parent.kind === 246 /* ForInStatement */) {
|
|
return stringType;
|
|
}
|
|
if (node.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
return checkRightHandSideOfForOf(node.parent.parent) || errorType;
|
|
}
|
|
return errorType;
|
|
}
|
|
function getInitialType(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ ? getInitialTypeOfVariableDeclaration(node) : getInitialTypeOfBindingElement(node);
|
|
}
|
|
function isEmptyArrayAssignment(node) {
|
|
return node.kind === 257 /* VariableDeclaration */ && node.initializer && isEmptyArrayLiteral2(node.initializer) || node.kind !== 205 /* BindingElement */ && node.parent.kind === 223 /* BinaryExpression */ && isEmptyArrayLiteral2(node.parent.right);
|
|
}
|
|
function getReferenceCandidate(node) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getReferenceCandidate(node.expression);
|
|
case 223 /* BinaryExpression */:
|
|
switch (node.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return getReferenceCandidate(node.left);
|
|
case 27 /* CommaToken */:
|
|
return getReferenceCandidate(node.right);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getReferenceRoot(node) {
|
|
const { parent: parent2 } = node;
|
|
return parent2.kind === 214 /* ParenthesizedExpression */ || parent2.kind === 223 /* BinaryExpression */ && parent2.operatorToken.kind === 63 /* EqualsToken */ && parent2.left === node || parent2.kind === 223 /* BinaryExpression */ && parent2.operatorToken.kind === 27 /* CommaToken */ && parent2.right === node ? getReferenceRoot(parent2) : node;
|
|
}
|
|
function getTypeOfSwitchClause(clause) {
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression));
|
|
}
|
|
return neverType;
|
|
}
|
|
function getSwitchClauseTypes(switchStatement) {
|
|
const links = getNodeLinks(switchStatement);
|
|
if (!links.switchTypes) {
|
|
links.switchTypes = [];
|
|
for (const clause of switchStatement.caseBlock.clauses) {
|
|
links.switchTypes.push(getTypeOfSwitchClause(clause));
|
|
}
|
|
}
|
|
return links.switchTypes;
|
|
}
|
|
function getSwitchClauseTypeOfWitnesses(switchStatement) {
|
|
if (some(switchStatement.caseBlock.clauses, (clause) => clause.kind === 292 /* CaseClause */ && !isStringLiteralLike(clause.expression))) {
|
|
return void 0;
|
|
}
|
|
const witnesses = [];
|
|
for (const clause of switchStatement.caseBlock.clauses) {
|
|
const text = clause.kind === 292 /* CaseClause */ ? clause.expression.text : void 0;
|
|
witnesses.push(text && !contains(witnesses, text) ? text : void 0);
|
|
}
|
|
return witnesses;
|
|
}
|
|
function eachTypeContainedIn(source, types) {
|
|
return source.flags & 1048576 /* Union */ ? !forEach(source.types, (t) => !contains(types, t)) : contains(types, source);
|
|
}
|
|
function isTypeSubsetOf(source, target) {
|
|
return source === target || target.flags & 1048576 /* Union */ && isTypeSubsetOfUnion(source, target);
|
|
}
|
|
function isTypeSubsetOfUnion(source, target) {
|
|
if (source.flags & 1048576 /* Union */) {
|
|
for (const t of source.types) {
|
|
if (!containsType(target.types, t)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (source.flags & 1024 /* EnumLiteral */ && getBaseTypeOfEnumLiteralType(source) === target) {
|
|
return true;
|
|
}
|
|
return containsType(target.types, source);
|
|
}
|
|
function forEachType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? forEach(type.types, f) : f(type);
|
|
}
|
|
function someType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? some(type.types, f) : f(type);
|
|
}
|
|
function everyType(type, f) {
|
|
return type.flags & 1048576 /* Union */ ? every(type.types, f) : f(type);
|
|
}
|
|
function everyContainedType(type, f) {
|
|
return type.flags & 3145728 /* UnionOrIntersection */ ? every(type.types, f) : f(type);
|
|
}
|
|
function filterType(type, f) {
|
|
if (type.flags & 1048576 /* Union */) {
|
|
const types = type.types;
|
|
const filtered = filter(types, f);
|
|
if (filtered === types) {
|
|
return type;
|
|
}
|
|
const origin = type.origin;
|
|
let newOrigin;
|
|
if (origin && origin.flags & 1048576 /* Union */) {
|
|
const originTypes = origin.types;
|
|
const originFiltered = filter(originTypes, (t) => !!(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, void 0, void 0, newOrigin);
|
|
}
|
|
return type.flags & 131072 /* Never */ || f(type) ? type : neverType;
|
|
}
|
|
function removeType(type, targetType) {
|
|
return filterType(type, (t) => t !== targetType);
|
|
}
|
|
function countTypes(type) {
|
|
return type.flags & 1048576 /* Union */ ? type.types.length : 1;
|
|
}
|
|
function mapType(type, mapper, noReductions) {
|
|
if (type.flags & 131072 /* Never */) {
|
|
return type;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
return mapper(type);
|
|
}
|
|
const origin = type.origin;
|
|
const types = origin && origin.flags & 1048576 /* Union */ ? origin.types : type.types;
|
|
let mappedTypes;
|
|
let changed = false;
|
|
for (const t of types) {
|
|
const mapped = t.flags & 1048576 /* Union */ ? mapType(t, mapper, noReductions) : mapper(t);
|
|
changed || (changed = t !== mapped);
|
|
if (mapped) {
|
|
if (!mappedTypes) {
|
|
mappedTypes = [mapped];
|
|
} else {
|
|
mappedTypes.push(mapped);
|
|
}
|
|
}
|
|
}
|
|
return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
|
|
}
|
|
function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
|
|
return type.flags & 1048576 /* Union */ && aliasSymbol ? getUnionType(map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) : mapType(type, mapper);
|
|
}
|
|
function extractTypesOfKind(type, kind) {
|
|
return filterType(type, (t) => (t.flags & kind) !== 0);
|
|
}
|
|
function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) {
|
|
if (maybeTypeOfKind(typeWithPrimitives, 4 /* String */ | 134217728 /* TemplateLiteral */ | 8 /* Number */ | 64 /* BigInt */) && maybeTypeOfKind(typeWithLiterals, 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */)) {
|
|
return mapType(typeWithPrimitives, (t) => t.flags & 4 /* String */ ? extractTypesOfKind(typeWithLiterals, 4 /* String */ | 128 /* StringLiteral */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) : isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 /* String */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) ? extractTypesOfKind(typeWithLiterals, 128 /* StringLiteral */) : t.flags & 8 /* Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* Number */ | 256 /* NumberLiteral */) : t.flags & 64 /* BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* BigInt */ | 2048 /* BigIntLiteral */) : t);
|
|
}
|
|
return typeWithPrimitives;
|
|
}
|
|
function isIncomplete(flowType) {
|
|
return flowType.flags === 0;
|
|
}
|
|
function getTypeFromFlowType(flowType) {
|
|
return flowType.flags === 0 ? flowType.type : flowType;
|
|
}
|
|
function createFlowType(type, incomplete) {
|
|
return incomplete ? { flags: 0, type: type.flags & 131072 /* Never */ ? silentNeverType : type } : type;
|
|
}
|
|
function createEvolvingArrayType(elementType) {
|
|
const result = createObjectType(256 /* EvolvingArray */);
|
|
result.elementType = elementType;
|
|
return result;
|
|
}
|
|
function getEvolvingArrayType(elementType) {
|
|
return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType));
|
|
}
|
|
function addEvolvingArrayElementType(evolvingArrayType, node) {
|
|
const elementType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node)));
|
|
return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType]));
|
|
}
|
|
function createFinalArrayType(elementType) {
|
|
return elementType.flags & 131072 /* Never */ ? autoArrayType : createArrayType(elementType.flags & 1048576 /* Union */ ? getUnionType(elementType.types, 2 /* Subtype */) : elementType);
|
|
}
|
|
function getFinalArrayType(evolvingArrayType) {
|
|
return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType));
|
|
}
|
|
function finalizeEvolvingArrayType(type) {
|
|
return getObjectFlags(type) & 256 /* EvolvingArray */ ? getFinalArrayType(type) : type;
|
|
}
|
|
function getElementTypeOfEvolvingArrayType(type) {
|
|
return getObjectFlags(type) & 256 /* EvolvingArray */ ? type.elementType : neverType;
|
|
}
|
|
function isEvolvingArrayTypeList(types) {
|
|
let hasEvolvingArrayType = false;
|
|
for (const t of types) {
|
|
if (!(t.flags & 131072 /* Never */)) {
|
|
if (!(getObjectFlags(t) & 256 /* EvolvingArray */)) {
|
|
return false;
|
|
}
|
|
hasEvolvingArrayType = true;
|
|
}
|
|
}
|
|
return hasEvolvingArrayType;
|
|
}
|
|
function isEvolvingArrayOperationTarget(node) {
|
|
const root = getReferenceRoot(node);
|
|
const parent2 = root.parent;
|
|
const isLengthPushOrUnshift = isPropertyAccessExpression(parent2) && (parent2.name.escapedText === "length" || parent2.parent.kind === 210 /* CallExpression */ && isIdentifier(parent2.name) && isPushOrUnshiftIdentifier(parent2.name));
|
|
const isElementAssignment = parent2.kind === 209 /* ElementAccessExpression */ && parent2.expression === root && parent2.parent.kind === 223 /* BinaryExpression */ && parent2.parent.operatorToken.kind === 63 /* EqualsToken */ && parent2.parent.left === parent2 && !isAssignmentTarget(parent2.parent) && isTypeAssignableToKind(getTypeOfExpression(parent2.argumentExpression), 296 /* NumberLike */);
|
|
return isLengthPushOrUnshift || isElementAssignment;
|
|
}
|
|
function isDeclarationWithExplicitTypeAnnotation(node) {
|
|
return (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isParameter(node)) && !!(getEffectiveTypeAnnotationNode(node) || isInJSFile(node) && hasInitializer(node) && node.initializer && isFunctionExpressionOrArrowFunction(node.initializer) && getEffectiveReturnTypeNode(node.initializer));
|
|
}
|
|
function getExplicitTypeOfSymbol(symbol, diagnostic) {
|
|
symbol = resolveSymbol(symbol);
|
|
if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 512 /* ValueModule */)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
|
|
if (getCheckFlags(symbol) & 262144 /* Mapped */) {
|
|
const origin = symbol.syntheticOrigin;
|
|
if (origin && getExplicitTypeOfSymbol(origin)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration) {
|
|
if (isDeclarationWithExplicitTypeAnnotation(declaration)) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* ForOfStatement */) {
|
|
const statement = declaration.parent.parent;
|
|
const expressionType = getTypeOfDottedName(statement.expression, void 0);
|
|
if (expressionType) {
|
|
const use = statement.awaitModifier ? 15 /* ForAwaitOf */ : 13 /* ForOf */;
|
|
return checkIteratedTypeOrElementType(use, expressionType, undefinedType, void 0);
|
|
}
|
|
}
|
|
if (diagnostic) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(declaration, Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypeOfDottedName(node, diagnostic) {
|
|
if (!(node.flags & 33554432 /* InWithStatement */)) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
const symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node));
|
|
return getExplicitTypeOfSymbol(symbol, diagnostic);
|
|
case 108 /* ThisKeyword */:
|
|
return getExplicitThisType(node);
|
|
case 106 /* SuperKeyword */:
|
|
return checkSuperExpression(node);
|
|
case 208 /* PropertyAccessExpression */: {
|
|
const type = getTypeOfDottedName(node.expression, diagnostic);
|
|
if (type) {
|
|
const name = node.name;
|
|
let prop;
|
|
if (isPrivateIdentifier(name)) {
|
|
if (!type.symbol) {
|
|
return void 0;
|
|
}
|
|
prop = getPropertyOfType(type, getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText));
|
|
} else {
|
|
prop = getPropertyOfType(type, name.escapedText);
|
|
}
|
|
return prop && getExplicitTypeOfSymbol(prop, diagnostic);
|
|
}
|
|
return void 0;
|
|
}
|
|
case 214 /* ParenthesizedExpression */:
|
|
return getTypeOfDottedName(node.expression, diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function getEffectsSignature(node) {
|
|
const links = getNodeLinks(node);
|
|
let signature = links.effectsSignature;
|
|
if (signature === void 0) {
|
|
let funcType;
|
|
if (node.parent.kind === 241 /* ExpressionStatement */) {
|
|
funcType = getTypeOfDottedName(node.expression, void 0);
|
|
} else if (node.expression.kind !== 106 /* SuperKeyword */) {
|
|
if (isOptionalChain(node)) {
|
|
funcType = checkNonNullType(
|
|
getOptionalExpressionType(checkExpression(node.expression), node.expression),
|
|
node.expression
|
|
);
|
|
} else {
|
|
funcType = checkNonNullExpression(node.expression);
|
|
}
|
|
}
|
|
const signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0 /* Call */);
|
|
const candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] : some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) : void 0;
|
|
signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature;
|
|
}
|
|
return signature === unknownSignature ? void 0 : signature;
|
|
}
|
|
function hasTypePredicateOrNeverReturnType(signature) {
|
|
return !!(getTypePredicateOfSignature(signature) || signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072 /* Never */);
|
|
}
|
|
function getTypePredicateArgument(predicate, callExpression) {
|
|
if (predicate.kind === 1 /* Identifier */ || predicate.kind === 3 /* AssertsIdentifier */) {
|
|
return callExpression.arguments[predicate.parameterIndex];
|
|
}
|
|
const invokedExpression = skipParentheses(callExpression.expression);
|
|
return isAccessExpression(invokedExpression) ? skipParentheses(invokedExpression.expression) : void 0;
|
|
}
|
|
function reportFlowControlError(node) {
|
|
const block = findAncestor(node, isFunctionOrModuleBlock);
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const span = getSpanOfTokenAtPosition(sourceFile, block.statements.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis));
|
|
}
|
|
function isReachableFlowNode(flow) {
|
|
const result = isReachableFlowNodeWorker(flow, false);
|
|
lastFlowNode = flow;
|
|
lastFlowNodeReachable = result;
|
|
return result;
|
|
}
|
|
function isFalseExpression(expr) {
|
|
const node = skipParentheses(expr, true);
|
|
return node.kind === 95 /* FalseKeyword */ || node.kind === 223 /* BinaryExpression */ && (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */ && (isFalseExpression(node.left) || isFalseExpression(node.right)) || node.operatorToken.kind === 56 /* BarBarToken */ && isFalseExpression(node.left) && isFalseExpression(node.right));
|
|
}
|
|
function isReachableFlowNodeWorker(flow, noCacheCheck) {
|
|
while (true) {
|
|
if (flow === lastFlowNode) {
|
|
return lastFlowNodeReachable;
|
|
}
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
if (!noCacheCheck) {
|
|
const id = getFlowNodeId(flow);
|
|
const reachable = flowNodeReachable[id];
|
|
return reachable !== void 0 ? reachable : flowNodeReachable[id] = isReachableFlowNodeWorker(flow, true);
|
|
}
|
|
noCacheCheck = false;
|
|
}
|
|
if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */)) {
|
|
flow = flow.antecedent;
|
|
} else if (flags & 512 /* Call */) {
|
|
const signature = getEffectsSignature(flow.node);
|
|
if (signature) {
|
|
const predicate = getTypePredicateOfSignature(signature);
|
|
if (predicate && predicate.kind === 3 /* AssertsIdentifier */ && !predicate.type) {
|
|
const predicateArgument = flow.node.arguments[predicate.parameterIndex];
|
|
if (predicateArgument && isFalseExpression(predicateArgument)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (getReturnTypeOfSignature(signature).flags & 131072 /* Never */) {
|
|
return false;
|
|
}
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 4 /* BranchLabel */) {
|
|
return some(flow.antecedents, (f) => isReachableFlowNodeWorker(f, false));
|
|
} else if (flags & 8 /* LoopLabel */) {
|
|
const antecedents = flow.antecedents;
|
|
if (antecedents === void 0 || antecedents.length === 0) {
|
|
return false;
|
|
}
|
|
flow = antecedents[0];
|
|
} else if (flags & 128 /* SwitchClause */) {
|
|
if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
|
|
return false;
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
lastFlowNode = void 0;
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
const result = isReachableFlowNodeWorker(flow.antecedent, false);
|
|
target.antecedents = saveAntecedents;
|
|
return result;
|
|
} else {
|
|
return !(flags & 1 /* Unreachable */);
|
|
}
|
|
}
|
|
}
|
|
function isPostSuperFlowNode(flow, noCacheCheck) {
|
|
while (true) {
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
if (!noCacheCheck) {
|
|
const id = getFlowNodeId(flow);
|
|
const postSuper = flowNodePostSuper[id];
|
|
return postSuper !== void 0 ? postSuper : flowNodePostSuper[id] = isPostSuperFlowNode(flow, true);
|
|
}
|
|
noCacheCheck = false;
|
|
}
|
|
if (flags & (16 /* Assignment */ | 96 /* Condition */ | 256 /* ArrayMutation */ | 128 /* SwitchClause */)) {
|
|
flow = flow.antecedent;
|
|
} else if (flags & 512 /* Call */) {
|
|
if (flow.node.expression.kind === 106 /* SuperKeyword */) {
|
|
return true;
|
|
}
|
|
flow = flow.antecedent;
|
|
} else if (flags & 4 /* BranchLabel */) {
|
|
return every(flow.antecedents, (f) => isPostSuperFlowNode(f, false));
|
|
} else if (flags & 8 /* LoopLabel */) {
|
|
flow = flow.antecedents[0];
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
const result = isPostSuperFlowNode(flow.antecedent, false);
|
|
target.antecedents = saveAntecedents;
|
|
return result;
|
|
} else {
|
|
return !!(flags & 1 /* Unreachable */);
|
|
}
|
|
}
|
|
}
|
|
function isConstantReference(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */: {
|
|
const symbol = getResolvedSymbol(node);
|
|
return isConstVariable(symbol) || isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol);
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return isConstantReference(node.expression) && isReadonlySymbol(getNodeLinks(node).resolvedSymbol || unknownSymbol);
|
|
}
|
|
return false;
|
|
}
|
|
function getFlowTypeOfReference(reference, declaredType, initialType = declaredType, flowContainer, flowNode = reference.flowNode) {
|
|
let key;
|
|
let isKeySet = false;
|
|
let flowDepth = 0;
|
|
if (flowAnalysisDisabled) {
|
|
return errorType;
|
|
}
|
|
if (!flowNode) {
|
|
return declaredType;
|
|
}
|
|
flowInvocationCount++;
|
|
const sharedFlowStart = sharedFlowCount;
|
|
const evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode));
|
|
sharedFlowCount = sharedFlowStart;
|
|
const resultType = getObjectFlags(evolvedType) & 256 /* EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType);
|
|
if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 232 /* NonNullExpression */ && !(resultType.flags & 131072 /* Never */) && getTypeWithFacts(resultType, 2097152 /* NEUndefinedOrNull */).flags & 131072 /* Never */) {
|
|
return declaredType;
|
|
}
|
|
return resultType === nonNullUnknownType ? unknownType : resultType;
|
|
function getOrSetCacheKey() {
|
|
if (isKeySet) {
|
|
return key;
|
|
}
|
|
isKeySet = true;
|
|
return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer);
|
|
}
|
|
function getTypeAtFlowNode(flow) {
|
|
var _a2;
|
|
if (flowDepth === 2e3) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.CheckTypes, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id });
|
|
flowAnalysisDisabled = true;
|
|
reportFlowControlError(reference);
|
|
return errorType;
|
|
}
|
|
flowDepth++;
|
|
let sharedFlow;
|
|
while (true) {
|
|
const flags = flow.flags;
|
|
if (flags & 4096 /* Shared */) {
|
|
for (let i = sharedFlowStart; i < sharedFlowCount; i++) {
|
|
if (sharedFlowNodes[i] === flow) {
|
|
flowDepth--;
|
|
return sharedFlowTypes[i];
|
|
}
|
|
}
|
|
sharedFlow = flow;
|
|
}
|
|
let type;
|
|
if (flags & 16 /* Assignment */) {
|
|
type = getTypeAtFlowAssignment(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 512 /* Call */) {
|
|
type = getTypeAtFlowCall(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 96 /* Condition */) {
|
|
type = getTypeAtFlowCondition(flow);
|
|
} else if (flags & 128 /* SwitchClause */) {
|
|
type = getTypeAtSwitchClause(flow);
|
|
} else if (flags & 12 /* Label */) {
|
|
if (flow.antecedents.length === 1) {
|
|
flow = flow.antecedents[0];
|
|
continue;
|
|
}
|
|
type = flags & 4 /* BranchLabel */ ? getTypeAtFlowBranchLabel(flow) : getTypeAtFlowLoopLabel(flow);
|
|
} else if (flags & 256 /* ArrayMutation */) {
|
|
type = getTypeAtFlowArrayMutation(flow);
|
|
if (!type) {
|
|
flow = flow.antecedent;
|
|
continue;
|
|
}
|
|
} else if (flags & 1024 /* ReduceLabel */) {
|
|
const target = flow.target;
|
|
const saveAntecedents = target.antecedents;
|
|
target.antecedents = flow.antecedents;
|
|
type = getTypeAtFlowNode(flow.antecedent);
|
|
target.antecedents = saveAntecedents;
|
|
} else if (flags & 2 /* Start */) {
|
|
const container = flow.node;
|
|
if (container && container !== flowContainer && reference.kind !== 208 /* PropertyAccessExpression */ && reference.kind !== 209 /* ElementAccessExpression */ && reference.kind !== 108 /* ThisKeyword */) {
|
|
flow = container.flowNode;
|
|
continue;
|
|
}
|
|
type = initialType;
|
|
} else {
|
|
type = convertAutoToAny(declaredType);
|
|
}
|
|
if (sharedFlow) {
|
|
sharedFlowNodes[sharedFlowCount] = sharedFlow;
|
|
sharedFlowTypes[sharedFlowCount] = type;
|
|
sharedFlowCount++;
|
|
}
|
|
flowDepth--;
|
|
return type;
|
|
}
|
|
}
|
|
function getInitialOrAssignedType(flow) {
|
|
const node = flow.node;
|
|
return getNarrowableTypeForReference(node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */ ? getInitialType(node) : getAssignedType(node), reference);
|
|
}
|
|
function getTypeAtFlowAssignment(flow) {
|
|
const node = flow.node;
|
|
if (isMatchingReference(reference, node)) {
|
|
if (!isReachableFlowNode(flow)) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (getAssignmentTargetKind(node) === 2 /* Compound */) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType));
|
|
}
|
|
if (declaredType === autoType || declaredType === autoArrayType) {
|
|
if (isEmptyArrayAssignment(node)) {
|
|
return getEvolvingArrayType(neverType);
|
|
}
|
|
const assignedType = getWidenedLiteralType(getInitialOrAssignedType(flow));
|
|
return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType;
|
|
}
|
|
if (declaredType.flags & 1048576 /* Union */) {
|
|
return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow));
|
|
}
|
|
return declaredType;
|
|
}
|
|
if (containsMatchingReference(reference, node)) {
|
|
if (!isReachableFlowNode(flow)) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (isVariableDeclaration(node) && (isInJSFile(node) || isVarConst(node))) {
|
|
const init = getDeclaredExpandoInitializer(node);
|
|
if (init && (init.kind === 215 /* FunctionExpression */ || init.kind === 216 /* ArrowFunction */)) {
|
|
return getTypeAtFlowNode(flow.antecedent);
|
|
}
|
|
}
|
|
return declaredType;
|
|
}
|
|
if (isVariableDeclaration(node) && node.parent.parent.kind === 246 /* ForInStatement */ && isMatchingReference(reference, node.parent.parent.expression)) {
|
|
return getNonNullableTypeIfNeeded(finalizeEvolvingArrayType(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent))));
|
|
}
|
|
return void 0;
|
|
}
|
|
function narrowTypeByAssertion(type, expr) {
|
|
const node = skipParentheses(expr, true);
|
|
if (node.kind === 95 /* FalseKeyword */) {
|
|
return unreachableNeverType;
|
|
}
|
|
if (node.kind === 223 /* BinaryExpression */) {
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right);
|
|
}
|
|
if (node.operatorToken.kind === 56 /* BarBarToken */) {
|
|
return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]);
|
|
}
|
|
}
|
|
return narrowType(type, node, true);
|
|
}
|
|
function getTypeAtFlowCall(flow) {
|
|
const signature = getEffectsSignature(flow.node);
|
|
if (signature) {
|
|
const predicate = getTypePredicateOfSignature(signature);
|
|
if (predicate && (predicate.kind === 2 /* AssertsThis */ || predicate.kind === 3 /* AssertsIdentifier */)) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = finalizeEvolvingArrayType(getTypeFromFlowType(flowType));
|
|
const narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, true) : predicate.kind === 3 /* AssertsIdentifier */ && predicate.parameterIndex >= 0 && predicate.parameterIndex < flow.node.arguments.length ? narrowTypeByAssertion(type, flow.node.arguments[predicate.parameterIndex]) : type;
|
|
return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType));
|
|
}
|
|
if (getReturnTypeOfSignature(signature).flags & 131072 /* Never */) {
|
|
return unreachableNeverType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeAtFlowArrayMutation(flow) {
|
|
if (declaredType === autoType || declaredType === autoArrayType) {
|
|
const node = flow.node;
|
|
const expr = node.kind === 210 /* CallExpression */ ? node.expression.expression : node.left.expression;
|
|
if (isMatchingReference(reference, getReferenceCandidate(expr))) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (getObjectFlags(type) & 256 /* EvolvingArray */) {
|
|
let evolvedType2 = type;
|
|
if (node.kind === 210 /* CallExpression */) {
|
|
for (const arg of node.arguments) {
|
|
evolvedType2 = addEvolvingArrayElementType(evolvedType2, arg);
|
|
}
|
|
} else {
|
|
const indexType = getContextFreeTypeOfExpression(node.left.argumentExpression);
|
|
if (isTypeAssignableToKind(indexType, 296 /* NumberLike */)) {
|
|
evolvedType2 = addEvolvingArrayElementType(evolvedType2, node.right);
|
|
}
|
|
}
|
|
return evolvedType2 === type ? flowType : createFlowType(evolvedType2, isIncomplete(flowType));
|
|
}
|
|
return flowType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeAtFlowCondition(flow) {
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (type.flags & 131072 /* Never */) {
|
|
return flowType;
|
|
}
|
|
const assumeTrue = (flow.flags & 32 /* TrueCondition */) !== 0;
|
|
const nonEvolvingType = finalizeEvolvingArrayType(type);
|
|
const narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue);
|
|
if (narrowedType === nonEvolvingType) {
|
|
return flowType;
|
|
}
|
|
return createFlowType(narrowedType, isIncomplete(flowType));
|
|
}
|
|
function getTypeAtSwitchClause(flow) {
|
|
const expr = flow.switchStatement.expression;
|
|
const flowType = getTypeAtFlowNode(flow.antecedent);
|
|
let type = getTypeFromFlowType(flowType);
|
|
if (isMatchingReference(reference, expr)) {
|
|
type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
|
|
} else if (expr.kind === 218 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
|
|
type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
|
|
} else {
|
|
if (strictNullChecks) {
|
|
if (optionalChainContainsReference(expr, reference)) {
|
|
type = narrowTypeBySwitchOptionalChainContainment(
|
|
type,
|
|
flow.switchStatement,
|
|
flow.clauseStart,
|
|
flow.clauseEnd,
|
|
(t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */))
|
|
);
|
|
} else if (expr.kind === 218 /* TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) {
|
|
type = narrowTypeBySwitchOptionalChainContainment(
|
|
type,
|
|
flow.switchStatement,
|
|
flow.clauseStart,
|
|
flow.clauseEnd,
|
|
(t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined")
|
|
);
|
|
}
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
|
|
}
|
|
}
|
|
return createFlowType(type, isIncomplete(flowType));
|
|
}
|
|
function getTypeAtFlowBranchLabel(flow) {
|
|
const antecedentTypes = [];
|
|
let subtypeReduction = false;
|
|
let seenIncomplete = false;
|
|
let bypassFlow;
|
|
for (const antecedent of flow.antecedents) {
|
|
if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.clauseStart === antecedent.clauseEnd) {
|
|
bypassFlow = antecedent;
|
|
continue;
|
|
}
|
|
const flowType = getTypeAtFlowNode(antecedent);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (type === declaredType && declaredType === initialType) {
|
|
return type;
|
|
}
|
|
pushIfUnique(antecedentTypes, type);
|
|
if (!isTypeSubsetOf(type, declaredType)) {
|
|
subtypeReduction = true;
|
|
}
|
|
if (isIncomplete(flowType)) {
|
|
seenIncomplete = true;
|
|
}
|
|
}
|
|
if (bypassFlow) {
|
|
const flowType = getTypeAtFlowNode(bypassFlow);
|
|
const type = getTypeFromFlowType(flowType);
|
|
if (!contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) {
|
|
if (type === declaredType && declaredType === initialType) {
|
|
return type;
|
|
}
|
|
antecedentTypes.push(type);
|
|
if (!isTypeSubsetOf(type, declaredType)) {
|
|
subtypeReduction = true;
|
|
}
|
|
if (isIncomplete(flowType)) {
|
|
seenIncomplete = true;
|
|
}
|
|
}
|
|
}
|
|
return createFlowType(getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 /* Subtype */ : 1 /* Literal */), seenIncomplete);
|
|
}
|
|
function getTypeAtFlowLoopLabel(flow) {
|
|
const id = getFlowNodeId(flow);
|
|
const cache = flowLoopCaches[id] || (flowLoopCaches[id] = /* @__PURE__ */ new Map());
|
|
const key2 = getOrSetCacheKey();
|
|
if (!key2) {
|
|
return declaredType;
|
|
}
|
|
const cached = cache.get(key2);
|
|
if (cached) {
|
|
return cached;
|
|
}
|
|
for (let i = flowLoopStart; i < flowLoopCount; i++) {
|
|
if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key2 && flowLoopTypes[i].length) {
|
|
return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1 /* Literal */), true);
|
|
}
|
|
}
|
|
const antecedentTypes = [];
|
|
let subtypeReduction = false;
|
|
let firstAntecedentType;
|
|
for (const antecedent of flow.antecedents) {
|
|
let flowType;
|
|
if (!firstAntecedentType) {
|
|
flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
|
|
} else {
|
|
flowLoopNodes[flowLoopCount] = flow;
|
|
flowLoopKeys[flowLoopCount] = key2;
|
|
flowLoopTypes[flowLoopCount] = antecedentTypes;
|
|
flowLoopCount++;
|
|
const saveFlowTypeCache = flowTypeCache;
|
|
flowTypeCache = void 0;
|
|
flowType = getTypeAtFlowNode(antecedent);
|
|
flowTypeCache = saveFlowTypeCache;
|
|
flowLoopCount--;
|
|
const cached2 = cache.get(key2);
|
|
if (cached2) {
|
|
return cached2;
|
|
}
|
|
}
|
|
const type = getTypeFromFlowType(flowType);
|
|
pushIfUnique(antecedentTypes, type);
|
|
if (!isTypeSubsetOf(type, declaredType)) {
|
|
subtypeReduction = true;
|
|
}
|
|
if (type === declaredType) {
|
|
break;
|
|
}
|
|
}
|
|
const result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 /* Subtype */ : 1 /* Literal */);
|
|
if (isIncomplete(firstAntecedentType)) {
|
|
return createFlowType(result, true);
|
|
}
|
|
cache.set(key2, result);
|
|
return result;
|
|
}
|
|
function getUnionOrEvolvingArrayType(types, subtypeReduction) {
|
|
if (isEvolvingArrayTypeList(types)) {
|
|
return getEvolvingArrayType(getUnionType(map(types, getElementTypeOfEvolvingArrayType)));
|
|
}
|
|
const result = recombineUnknownType(getUnionType(sameMap(types, finalizeEvolvingArrayType), subtypeReduction));
|
|
if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* Union */ && arraysEqual(result.types, declaredType.types)) {
|
|
return declaredType;
|
|
}
|
|
return result;
|
|
}
|
|
function getCandidateDiscriminantPropertyAccess(expr) {
|
|
if (isBindingPattern(reference) || isFunctionExpressionOrArrowFunction(reference) || isObjectLiteralMethod(reference)) {
|
|
if (isIdentifier(expr)) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && (isBindingElement(declaration) || isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) {
|
|
return declaration;
|
|
}
|
|
}
|
|
} else if (isAccessExpression(expr)) {
|
|
if (isMatchingReference(reference, expr.expression)) {
|
|
return expr;
|
|
}
|
|
} else if (isIdentifier(expr)) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
|
|
return declaration.initializer;
|
|
}
|
|
if (isBindingElement(declaration) && !declaration.initializer) {
|
|
const parent2 = declaration.parent.parent;
|
|
if (isVariableDeclaration(parent2) && !parent2.type && parent2.initializer && (isIdentifier(parent2.initializer) || isAccessExpression(parent2.initializer)) && isMatchingReference(reference, parent2.initializer)) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDiscriminantPropertyAccess(expr, computedType) {
|
|
const type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
|
|
if (type.flags & 1048576 /* Union */) {
|
|
const access = getCandidateDiscriminantPropertyAccess(expr);
|
|
if (access) {
|
|
const name = getAccessedPropertyName(access);
|
|
if (name && isDiscriminantProperty(type, name)) {
|
|
return access;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function narrowTypeByDiscriminant(type, access, narrowType2) {
|
|
const propName = getAccessedPropertyName(access);
|
|
if (propName === void 0) {
|
|
return type;
|
|
}
|
|
const removeNullable = strictNullChecks && isOptionalChain(access) && maybeTypeOfKind(type, 98304 /* Nullable */);
|
|
let propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type, propName);
|
|
if (!propType) {
|
|
return type;
|
|
}
|
|
propType = removeNullable ? getOptionalType(propType) : propType;
|
|
const narrowedPropType = narrowType2(propType);
|
|
return filterType(type, (t) => {
|
|
const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
|
|
return !(discriminantType.flags & 131072 /* Never */) && !(narrowedPropType.flags & 131072 /* Never */) && areTypesComparable(narrowedPropType, discriminantType);
|
|
});
|
|
}
|
|
function narrowTypeByDiscriminantProperty(type, access, operator, value, assumeTrue) {
|
|
if ((operator === 36 /* EqualsEqualsEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) && type.flags & 1048576 /* Union */) {
|
|
const keyPropertyName = getKeyPropertyName(type);
|
|
if (keyPropertyName && keyPropertyName === getAccessedPropertyName(access)) {
|
|
const candidate = getConstituentTypeForKeyType(type, getTypeOfExpression(value));
|
|
if (candidate) {
|
|
return operator === (assumeTrue ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */) ? candidate : isUnitType(getTypeOfPropertyOfType(candidate, keyPropertyName) || unknownType) ? removeType(type, candidate) : type;
|
|
}
|
|
}
|
|
}
|
|
return narrowTypeByDiscriminant(type, access, (t) => narrowTypeByEquality(t, operator, value, assumeTrue));
|
|
}
|
|
function narrowTypeBySwitchOnDiscriminantProperty(type, access, switchStatement, clauseStart, clauseEnd) {
|
|
if (clauseStart < clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
|
|
const clauseTypes = getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd);
|
|
const candidate = getUnionType(map(clauseTypes, (t) => getConstituentTypeForKeyType(type, t) || unknownType));
|
|
if (candidate !== unknownType) {
|
|
return candidate;
|
|
}
|
|
}
|
|
return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, switchStatement, clauseStart, clauseEnd));
|
|
}
|
|
function narrowTypeByTruthiness(type, expr, assumeTrue) {
|
|
if (isMatchingReference(reference, expr)) {
|
|
return getAdjustedTypeWithFacts(type, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */);
|
|
}
|
|
if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) {
|
|
type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getTypeWithFacts(t, assumeTrue ? 4194304 /* Truthy */ : 8388608 /* Falsy */));
|
|
}
|
|
return type;
|
|
}
|
|
function isTypePresencePossible(type, propName, assumeTrue) {
|
|
const prop = getPropertyOfType(type, propName);
|
|
return prop ? !!(prop.flags & 16777216 /* Optional */) || assumeTrue : !!getApplicableIndexInfoForName(type, propName) || !assumeTrue;
|
|
}
|
|
function narrowTypeByInKeyword(type, nameType, assumeTrue) {
|
|
const name = getPropertyNameFromType(nameType);
|
|
const isKnownProperty2 = someType(type, (t) => isTypePresencePossible(t, name, true));
|
|
if (isKnownProperty2) {
|
|
return filterType(type, (t) => isTypePresencePossible(t, name, assumeTrue));
|
|
}
|
|
if (assumeTrue) {
|
|
const recordSymbol = getGlobalRecordSymbol();
|
|
if (recordSymbol) {
|
|
return getIntersectionType([type, getTypeAliasInstantiation(recordSymbol, [nameType, unknownType])]);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
|
|
switch (expr.operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue);
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
const operator = expr.operatorToken.kind;
|
|
const left = getReferenceCandidate(expr.left);
|
|
const right = getReferenceCandidate(expr.right);
|
|
if (left.kind === 218 /* TypeOfExpression */ && isStringLiteralLike(right)) {
|
|
return narrowTypeByTypeof(type, left, operator, right, assumeTrue);
|
|
}
|
|
if (right.kind === 218 /* TypeOfExpression */ && isStringLiteralLike(left)) {
|
|
return narrowTypeByTypeof(type, right, operator, left, assumeTrue);
|
|
}
|
|
if (isMatchingReference(reference, left)) {
|
|
return narrowTypeByEquality(type, operator, right, assumeTrue);
|
|
}
|
|
if (isMatchingReference(reference, right)) {
|
|
return narrowTypeByEquality(type, operator, left, assumeTrue);
|
|
}
|
|
if (strictNullChecks) {
|
|
if (optionalChainContainsReference(left, reference)) {
|
|
type = narrowTypeByOptionalChainContainment(type, operator, right, assumeTrue);
|
|
} else if (optionalChainContainsReference(right, reference)) {
|
|
type = narrowTypeByOptionalChainContainment(type, operator, left, assumeTrue);
|
|
}
|
|
}
|
|
const leftAccess = getDiscriminantPropertyAccess(left, type);
|
|
if (leftAccess) {
|
|
return narrowTypeByDiscriminantProperty(type, leftAccess, operator, right, assumeTrue);
|
|
}
|
|
const rightAccess = getDiscriminantPropertyAccess(right, type);
|
|
if (rightAccess) {
|
|
return narrowTypeByDiscriminantProperty(type, rightAccess, operator, left, assumeTrue);
|
|
}
|
|
if (isMatchingConstructorReference(left)) {
|
|
return narrowTypeByConstructor(type, operator, right, assumeTrue);
|
|
}
|
|
if (isMatchingConstructorReference(right)) {
|
|
return narrowTypeByConstructor(type, operator, left, assumeTrue);
|
|
}
|
|
break;
|
|
case 102 /* InstanceOfKeyword */:
|
|
return narrowTypeByInstanceof(type, expr, assumeTrue);
|
|
case 101 /* InKeyword */:
|
|
if (isPrivateIdentifier(expr.left)) {
|
|
return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
|
|
}
|
|
const target = getReferenceCandidate(expr.right);
|
|
const leftType = getTypeOfExpression(expr.left);
|
|
if (leftType.flags & 8576 /* StringOrNumberLiteralOrUnique */) {
|
|
if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
|
|
return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
|
|
}
|
|
if (isMatchingReference(reference, target)) {
|
|
return narrowTypeByInKeyword(type, leftType, assumeTrue);
|
|
}
|
|
}
|
|
break;
|
|
case 27 /* CommaToken */:
|
|
return narrowType(type, expr.right, assumeTrue);
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
return assumeTrue ? narrowType(narrowType(type, expr.left, true), expr.right, true) : getUnionType([narrowType(type, expr.left, false), narrowType(type, expr.right, false)]);
|
|
case 56 /* BarBarToken */:
|
|
return assumeTrue ? getUnionType([narrowType(type, expr.left, true), narrowType(type, expr.right, true)]) : narrowType(narrowType(type, expr.left, false), expr.right, false);
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue) {
|
|
const target = getReferenceCandidate(expr.right);
|
|
if (!isMatchingReference(reference, target)) {
|
|
return type;
|
|
}
|
|
Debug.assertNode(expr.left, isPrivateIdentifier);
|
|
const symbol = getSymbolForPrivateIdentifierExpression(expr.left);
|
|
if (symbol === void 0) {
|
|
return type;
|
|
}
|
|
const classSymbol = symbol.parent;
|
|
const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
|
|
return getNarrowedType(type, targetType, assumeTrue, true);
|
|
}
|
|
function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) {
|
|
const equalsOperator = operator === 34 /* EqualsEqualsToken */ || operator === 36 /* EqualsEqualsEqualsToken */;
|
|
const nullableFlags = operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */ ? 98304 /* Nullable */ : 32768 /* Undefined */;
|
|
const valueType = getTypeOfExpression(value);
|
|
const removeNullable = equalsOperator !== assumeTrue && everyType(valueType, (t) => !!(t.flags & nullableFlags)) || equalsOperator === assumeTrue && everyType(valueType, (t) => !(t.flags & (3 /* AnyOrUnknown */ | nullableFlags)));
|
|
return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
|
|
}
|
|
function narrowTypeByEquality(type, operator, value, assumeTrue) {
|
|
if (type.flags & 1 /* Any */) {
|
|
return type;
|
|
}
|
|
if (operator === 35 /* ExclamationEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) {
|
|
assumeTrue = !assumeTrue;
|
|
}
|
|
const valueType = getTypeOfExpression(value);
|
|
const doubleEquals = operator === 34 /* EqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */;
|
|
if (valueType.flags & 98304 /* Nullable */) {
|
|
if (!strictNullChecks) {
|
|
return type;
|
|
}
|
|
const facts = doubleEquals ? assumeTrue ? 262144 /* EQUndefinedOrNull */ : 2097152 /* NEUndefinedOrNull */ : valueType.flags & 65536 /* Null */ ? assumeTrue ? 131072 /* EQNull */ : 1048576 /* NENull */ : assumeTrue ? 65536 /* EQUndefined */ : 524288 /* NEUndefined */;
|
|
return getAdjustedTypeWithFacts(type, facts);
|
|
}
|
|
if (assumeTrue) {
|
|
if (!doubleEquals && (type.flags & 2 /* Unknown */ || someType(type, isEmptyAnonymousObjectType))) {
|
|
if (valueType.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */) || isEmptyAnonymousObjectType(valueType)) {
|
|
return valueType;
|
|
}
|
|
if (valueType.flags & 524288 /* Object */) {
|
|
return nonPrimitiveType;
|
|
}
|
|
}
|
|
const filteredType = filterType(type, (t) => areTypesComparable(t, valueType) || doubleEquals && isCoercibleUnderDoubleEquals(t, valueType));
|
|
return replacePrimitivesWithLiterals(filteredType, valueType);
|
|
}
|
|
if (isUnitType(valueType)) {
|
|
return filterType(type, (t) => !(isUnitLikeType(t) && areTypesComparable(t, valueType)));
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
|
|
if (operator === 35 /* ExclamationEqualsToken */ || operator === 37 /* ExclamationEqualsEqualsToken */) {
|
|
assumeTrue = !assumeTrue;
|
|
}
|
|
const target = getReferenceCandidate(typeOfExpr.expression);
|
|
if (!isMatchingReference(reference, target)) {
|
|
const propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type);
|
|
if (propertyAccess) {
|
|
return narrowTypeByDiscriminant(type, propertyAccess, (t) => narrowTypeByLiteralExpression(t, literal, assumeTrue));
|
|
}
|
|
if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
|
|
return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
return type;
|
|
}
|
|
return narrowTypeByLiteralExpression(type, literal, assumeTrue);
|
|
}
|
|
function narrowTypeByLiteralExpression(type, literal, assumeTrue) {
|
|
return assumeTrue ? narrowTypeByTypeName(type, literal.text) : getTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */);
|
|
}
|
|
function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
|
|
const everyClauseChecks = clauseStart !== clauseEnd && every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
|
|
return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
|
|
}
|
|
function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
|
|
const switchTypes = getSwitchClauseTypes(switchStatement);
|
|
if (!switchTypes.length) {
|
|
return type;
|
|
}
|
|
const clauseTypes = switchTypes.slice(clauseStart, clauseEnd);
|
|
const hasDefaultClause = clauseStart === clauseEnd || contains(clauseTypes, neverType);
|
|
if (type.flags & 2 /* Unknown */ && !hasDefaultClause) {
|
|
let groundClauseTypes;
|
|
for (let i = 0; i < clauseTypes.length; i += 1) {
|
|
const t = clauseTypes[i];
|
|
if (t.flags & (131068 /* Primitive */ | 67108864 /* NonPrimitive */)) {
|
|
if (groundClauseTypes !== void 0) {
|
|
groundClauseTypes.push(t);
|
|
}
|
|
} else if (t.flags & 524288 /* Object */) {
|
|
if (groundClauseTypes === void 0) {
|
|
groundClauseTypes = clauseTypes.slice(0, i);
|
|
}
|
|
groundClauseTypes.push(nonPrimitiveType);
|
|
} else {
|
|
return type;
|
|
}
|
|
}
|
|
return getUnionType(groundClauseTypes === void 0 ? clauseTypes : groundClauseTypes);
|
|
}
|
|
const discriminantType = getUnionType(clauseTypes);
|
|
const caseType = discriminantType.flags & 131072 /* Never */ ? neverType : replacePrimitivesWithLiterals(filterType(type, (t) => areTypesComparable(discriminantType, t)), discriminantType);
|
|
if (!hasDefaultClause) {
|
|
return caseType;
|
|
}
|
|
const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, getRegularTypeOfLiteralType(extractUnitType(t)))));
|
|
return caseType.flags & 131072 /* Never */ ? defaultType : getUnionType([caseType, defaultType]);
|
|
}
|
|
function narrowTypeByTypeName(type, typeName) {
|
|
switch (typeName) {
|
|
case "string":
|
|
return narrowTypeByTypeFacts(type, stringType, 1 /* TypeofEQString */);
|
|
case "number":
|
|
return narrowTypeByTypeFacts(type, numberType, 2 /* TypeofEQNumber */);
|
|
case "bigint":
|
|
return narrowTypeByTypeFacts(type, bigintType, 4 /* TypeofEQBigInt */);
|
|
case "boolean":
|
|
return narrowTypeByTypeFacts(type, booleanType, 8 /* TypeofEQBoolean */);
|
|
case "symbol":
|
|
return narrowTypeByTypeFacts(type, esSymbolType, 16 /* TypeofEQSymbol */);
|
|
case "object":
|
|
return type.flags & 1 /* Any */ ? type : getUnionType([narrowTypeByTypeFacts(type, nonPrimitiveType, 32 /* TypeofEQObject */), narrowTypeByTypeFacts(type, nullType, 131072 /* EQNull */)]);
|
|
case "function":
|
|
return type.flags & 1 /* Any */ ? type : narrowTypeByTypeFacts(type, globalFunctionType, 64 /* TypeofEQFunction */);
|
|
case "undefined":
|
|
return narrowTypeByTypeFacts(type, undefinedType, 65536 /* EQUndefined */);
|
|
}
|
|
return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeofEQHostObject */);
|
|
}
|
|
function narrowTypeByTypeFacts(type, impliedType, facts) {
|
|
return mapType(type, (t) => isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : isTypeSubtypeOf(impliedType, t) ? impliedType : getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType);
|
|
}
|
|
function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
|
|
const witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
|
|
if (!witnesses) {
|
|
return type;
|
|
}
|
|
const defaultIndex = findIndex(switchStatement.caseBlock.clauses, (clause) => clause.kind === 293 /* DefaultClause */);
|
|
const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
|
|
if (hasDefaultClause) {
|
|
const notEqualFacts = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
|
|
return filterType(type, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
|
|
}
|
|
const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
|
|
return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
|
|
}
|
|
function isMatchingConstructorReference(expr) {
|
|
return (isPropertyAccessExpression(expr) && idText(expr.name) === "constructor" || isElementAccessExpression(expr) && isStringLiteralLike(expr.argumentExpression) && expr.argumentExpression.text === "constructor") && isMatchingReference(reference, expr.expression);
|
|
}
|
|
function narrowTypeByConstructor(type, operator, identifier, assumeTrue) {
|
|
if (assumeTrue ? operator !== 34 /* EqualsEqualsToken */ && operator !== 36 /* EqualsEqualsEqualsToken */ : operator !== 35 /* ExclamationEqualsToken */ && operator !== 37 /* ExclamationEqualsEqualsToken */) {
|
|
return type;
|
|
}
|
|
const identifierType = getTypeOfExpression(identifier);
|
|
if (!isFunctionType(identifierType) && !isConstructorType(identifierType)) {
|
|
return type;
|
|
}
|
|
const prototypeProperty = getPropertyOfType(identifierType, "prototype");
|
|
if (!prototypeProperty) {
|
|
return type;
|
|
}
|
|
const prototypeType = getTypeOfSymbol(prototypeProperty);
|
|
const candidate = !isTypeAny(prototypeType) ? prototypeType : void 0;
|
|
if (!candidate || candidate === globalObjectType || candidate === globalFunctionType) {
|
|
return type;
|
|
}
|
|
if (isTypeAny(type)) {
|
|
return candidate;
|
|
}
|
|
return filterType(type, (t) => isConstructedBy(t, candidate));
|
|
function isConstructedBy(source, target) {
|
|
if (source.flags & 524288 /* Object */ && getObjectFlags(source) & 1 /* Class */ || target.flags & 524288 /* Object */ && getObjectFlags(target) & 1 /* Class */) {
|
|
return source.symbol === target.symbol;
|
|
}
|
|
return isTypeSubtypeOf(source, target);
|
|
}
|
|
}
|
|
function narrowTypeByInstanceof(type, expr, assumeTrue) {
|
|
const left = getReferenceCandidate(expr.left);
|
|
if (!isMatchingReference(reference, left)) {
|
|
if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) {
|
|
return getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
return type;
|
|
}
|
|
const rightType = getTypeOfExpression(expr.right);
|
|
if (!isTypeDerivedFrom(rightType, globalFunctionType)) {
|
|
return type;
|
|
}
|
|
let targetType;
|
|
const prototypeProperty = getPropertyOfType(rightType, "prototype");
|
|
if (prototypeProperty) {
|
|
const prototypePropertyType = getTypeOfSymbol(prototypeProperty);
|
|
if (!isTypeAny(prototypePropertyType)) {
|
|
targetType = prototypePropertyType;
|
|
}
|
|
}
|
|
if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) {
|
|
return type;
|
|
}
|
|
if (!targetType) {
|
|
const constructSignatures = getSignaturesOfType(rightType, 1 /* Construct */);
|
|
targetType = constructSignatures.length ? getUnionType(map(constructSignatures, (signature) => getReturnTypeOfSignature(getErasedSignature(signature)))) : emptyObjectType;
|
|
}
|
|
if (!assumeTrue && rightType.flags & 1048576 /* Union */) {
|
|
const nonConstructorTypeInUnion = find(rightType.types, (t) => !isConstructorType(t));
|
|
if (!nonConstructorTypeInUnion)
|
|
return type;
|
|
}
|
|
return getNarrowedType(type, targetType, assumeTrue, true);
|
|
}
|
|
function getNarrowedType(type, candidate, assumeTrue, checkDerived) {
|
|
var _a2;
|
|
const key2 = type.flags & 1048576 /* Union */ ? `N${getTypeId(type)},${getTypeId(candidate)},${(assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)}` : void 0;
|
|
return (_a2 = getCachedType(key2)) != null ? _a2 : setCachedType(key2, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived));
|
|
}
|
|
function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) {
|
|
const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
|
|
if (!assumeTrue) {
|
|
return filterType(type, (t) => !isRelated(t, candidate));
|
|
}
|
|
if (type.flags & 3 /* AnyOrUnknown */) {
|
|
return candidate;
|
|
}
|
|
const keyPropertyName = type.flags & 1048576 /* Union */ ? getKeyPropertyName(type) : void 0;
|
|
const narrowedType = mapType(candidate, (c) => {
|
|
const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
|
|
const matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
|
|
const directlyRelated = mapType(matching || type, checkDerived ? (t) => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType : (t) => isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType);
|
|
return directlyRelated.flags & 131072 /* Never */ ? mapType(type, (t) => maybeTypeOfKind(t, 465829888 /* Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) : directlyRelated;
|
|
});
|
|
return !(narrowedType.flags & 131072 /* Never */) ? narrowedType : isTypeSubtypeOf(candidate, type) ? candidate : isTypeAssignableTo(type, candidate) ? type : isTypeAssignableTo(candidate, type) ? candidate : getIntersectionType([type, candidate]);
|
|
}
|
|
function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
|
|
if (hasMatchingArgument(callExpression, reference)) {
|
|
const signature = assumeTrue || !isCallChain(callExpression) ? getEffectsSignature(callExpression) : void 0;
|
|
const predicate = signature && getTypePredicateOfSignature(signature);
|
|
if (predicate && (predicate.kind === 0 /* This */ || predicate.kind === 1 /* Identifier */)) {
|
|
return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue);
|
|
}
|
|
}
|
|
if (containsMissingType(type) && isAccessExpression(reference) && isPropertyAccessExpression(callExpression.expression)) {
|
|
const callAccess = callExpression.expression;
|
|
if (isMatchingReference(reference.expression, getReferenceCandidate(callAccess.expression)) && isIdentifier(callAccess.name) && callAccess.name.escapedText === "hasOwnProperty" && callExpression.arguments.length === 1) {
|
|
const argument = callExpression.arguments[0];
|
|
if (isStringLiteralLike(argument) && getAccessedPropertyName(reference) === escapeLeadingUnderscores(argument.text)) {
|
|
return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) {
|
|
if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) {
|
|
const predicateArgument = getTypePredicateArgument(predicate, callExpression);
|
|
if (predicateArgument) {
|
|
if (isMatchingReference(reference, predicateArgument)) {
|
|
return getNarrowedType(type, predicate.type, assumeTrue, false);
|
|
}
|
|
if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
|
|
type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(predicateArgument, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getNarrowedType(t, predicate.type, assumeTrue, false));
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function narrowType(type, expr, assumeTrue) {
|
|
if (isExpressionOfOptionalChainRoot(expr) || isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 /* QuestionQuestionToken */ && expr.parent.left === expr) {
|
|
return narrowTypeByOptionality(type, expr, assumeTrue);
|
|
}
|
|
switch (expr.kind) {
|
|
case 79 /* Identifier */:
|
|
if (!isMatchingReference(reference, expr) && inlineLevel < 5) {
|
|
const symbol = getResolvedSymbol(expr);
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) {
|
|
inlineLevel++;
|
|
const result = narrowType(type, declaration.initializer, assumeTrue);
|
|
inlineLevel--;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return narrowTypeByTruthiness(type, expr, assumeTrue);
|
|
case 210 /* CallExpression */:
|
|
return narrowTypeByCallExpression(type, expr, assumeTrue);
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
return narrowType(type, expr.expression, assumeTrue);
|
|
case 223 /* BinaryExpression */:
|
|
return narrowTypeByBinaryExpression(type, expr, assumeTrue);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
if (expr.operator === 53 /* ExclamationToken */) {
|
|
return narrowType(type, expr.operand, !assumeTrue);
|
|
}
|
|
break;
|
|
}
|
|
return type;
|
|
}
|
|
function narrowTypeByOptionality(type, expr, assumePresent) {
|
|
if (isMatchingReference(reference, expr)) {
|
|
return getAdjustedTypeWithFacts(type, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */);
|
|
}
|
|
const access = getDiscriminantPropertyAccess(expr, type);
|
|
if (access) {
|
|
return narrowTypeByDiscriminant(type, access, (t) => getTypeWithFacts(t, assumePresent ? 2097152 /* NEUndefinedOrNull */ : 262144 /* EQUndefinedOrNull */));
|
|
}
|
|
return type;
|
|
}
|
|
}
|
|
function getTypeOfSymbolAtLocation(symbol, location2) {
|
|
symbol = symbol.exportSymbol || symbol;
|
|
if (location2.kind === 79 /* Identifier */ || location2.kind === 80 /* PrivateIdentifier */) {
|
|
if (isRightSideOfQualifiedNameOrPropertyAccess(location2)) {
|
|
location2 = location2.parent;
|
|
}
|
|
if (isExpressionNode(location2) && (!isAssignmentTarget(location2) || isWriteAccess(location2))) {
|
|
const type = getTypeOfExpression(location2);
|
|
if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location2).resolvedSymbol) === symbol) {
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
if (isDeclarationName(location2) && isSetAccessor(location2.parent) && getAnnotatedAccessorTypeNode(location2.parent)) {
|
|
return getWriteTypeOfAccessors(location2.parent.symbol);
|
|
}
|
|
return getNonMissingTypeOfSymbol(symbol);
|
|
}
|
|
function getControlFlowContainer(node) {
|
|
return findAncestor(node.parent, (node2) => isFunctionLike(node2) && !getImmediatelyInvokedFunctionExpression(node2) || node2.kind === 265 /* ModuleBlock */ || node2.kind === 308 /* SourceFile */ || node2.kind === 169 /* PropertyDeclaration */);
|
|
}
|
|
function isSymbolAssigned(symbol) {
|
|
if (!symbol.valueDeclaration) {
|
|
return false;
|
|
}
|
|
const parent2 = getRootDeclaration(symbol.valueDeclaration).parent;
|
|
const links = getNodeLinks(parent2);
|
|
if (!(links.flags & 524288 /* AssignmentsMarked */)) {
|
|
links.flags |= 524288 /* AssignmentsMarked */;
|
|
if (!hasParentWithAssignmentsMarked(parent2)) {
|
|
markNodeAssignments(parent2);
|
|
}
|
|
}
|
|
return symbol.isAssigned || false;
|
|
}
|
|
function hasParentWithAssignmentsMarked(node) {
|
|
return !!findAncestor(node.parent, (node2) => (isFunctionLike(node2) || isCatchClause(node2)) && !!(getNodeLinks(node2).flags & 524288 /* AssignmentsMarked */));
|
|
}
|
|
function markNodeAssignments(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
if (isAssignmentTarget(node)) {
|
|
const symbol = getResolvedSymbol(node);
|
|
if (isParameterOrCatchClauseVariable(symbol)) {
|
|
symbol.isAssigned = true;
|
|
}
|
|
}
|
|
} else {
|
|
forEachChild(node, markNodeAssignments);
|
|
}
|
|
}
|
|
function isConstVariable(symbol) {
|
|
return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */) !== 0;
|
|
}
|
|
function removeOptionalityFromDeclaredType(declaredType, declaration) {
|
|
if (pushTypeResolution(declaration.symbol, 2 /* DeclaredType */)) {
|
|
const annotationIncludesUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
|
|
popTypeResolution();
|
|
return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
|
|
} else {
|
|
reportCircularityError(declaration.symbol);
|
|
return declaredType;
|
|
}
|
|
}
|
|
function isConstraintPosition(type, node) {
|
|
const parent2 = node.parent;
|
|
return parent2.kind === 208 /* PropertyAccessExpression */ || parent2.kind === 163 /* QualifiedName */ || parent2.kind === 210 /* CallExpression */ && parent2.expression === node || parent2.kind === 209 /* ElementAccessExpression */ && parent2.expression === node && !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent2.argumentExpression)));
|
|
}
|
|
function isGenericTypeWithUnionConstraint(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithUnionConstraint) : !!(type.flags & 465829888 /* Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* Nullable */ | 1048576 /* Union */));
|
|
}
|
|
function isGenericTypeWithoutNullableConstraint(type) {
|
|
return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
|
|
}
|
|
function hasContextualTypeWithNoGenericTypes(node, checkMode) {
|
|
const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 64 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(node, void 0));
|
|
return contextualType && !isGenericType(contextualType);
|
|
}
|
|
function getNarrowableTypeForReference(type, reference, checkMode) {
|
|
const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
|
|
return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
|
|
}
|
|
function isExportOrExportExpression(location2) {
|
|
return !!findAncestor(location2, (n) => {
|
|
const parent2 = n.parent;
|
|
if (parent2 === void 0) {
|
|
return "quit";
|
|
}
|
|
if (isExportAssignment(parent2)) {
|
|
return parent2.expression === n && isEntityNameExpression(n);
|
|
}
|
|
if (isExportSpecifier(parent2)) {
|
|
return parent2.name === n || parent2.propertyName === n;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function markAliasReferenced(symbol, location2) {
|
|
if (isNonLocalAlias(symbol, 111551 /* Value */) && !isInTypeQuery(location2) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */)) {
|
|
const target = resolveAlias(symbol);
|
|
if (getAllSymbolFlags(target) & (111551 /* Value */ | 1048576 /* ExportValue */)) {
|
|
if (compilerOptions.isolatedModules || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location2) || !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) {
|
|
markAliasSymbolAsReferenced(symbol);
|
|
} else {
|
|
markConstEnumAliasAsReferenced(symbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getNarrowedTypeOfSymbol(symbol, location2) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration) {
|
|
if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
|
|
const parent2 = declaration.parent.parent;
|
|
if (parent2.kind === 257 /* VariableDeclaration */ && getCombinedNodeFlags(declaration) & 2 /* Const */ || parent2.kind === 166 /* Parameter */) {
|
|
const links = getNodeLinks(parent2);
|
|
if (!(links.flags & 16777216 /* InCheckIdentifier */)) {
|
|
links.flags |= 16777216 /* InCheckIdentifier */;
|
|
const parentType = getTypeForBindingElementParent(parent2, 0 /* Normal */);
|
|
const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
|
|
links.flags &= ~16777216 /* InCheckIdentifier */;
|
|
if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent2.kind === 166 /* Parameter */ && isSymbolAssigned(symbol))) {
|
|
const pattern = declaration.parent;
|
|
const narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, void 0, location2.flowNode);
|
|
if (narrowedType.flags & 131072 /* Never */) {
|
|
return neverType;
|
|
}
|
|
return getBindingElementTypeFromParentType(declaration, narrowedType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isParameter(declaration) && !declaration.type && !declaration.initializer && !declaration.dotDotDotToken) {
|
|
const func = declaration.parent;
|
|
if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) {
|
|
const restType = getReducedApparentType(getTypeOfSymbol(contextualSignature.parameters[0]));
|
|
if (restType.flags & 1048576 /* Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) {
|
|
const narrowedType = getFlowTypeOfReference(func, restType, restType, void 0, location2.flowNode);
|
|
const index = func.parameters.indexOf(declaration) - (getThisParameter(func) ? 1 : 0);
|
|
return getIndexedAccessType(narrowedType, getNumberLiteralType(index));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
function checkIdentifier(node, checkMode) {
|
|
if (isThisInTypeQuery(node)) {
|
|
return checkThisExpression(node);
|
|
}
|
|
const symbol = getResolvedSymbol(node);
|
|
if (symbol === unknownSymbol) {
|
|
return errorType;
|
|
}
|
|
if (symbol === argumentsSymbol) {
|
|
if (isInPropertyInitializerOrClassStaticBlock(node)) {
|
|
error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
|
|
return errorType;
|
|
}
|
|
const container = getContainingFunction(node);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (container.kind === 216 /* ArrowFunction */) {
|
|
error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression);
|
|
} else if (hasSyntacticModifier(container, 512 /* Async */)) {
|
|
error(node, Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method);
|
|
}
|
|
}
|
|
getNodeLinks(container).flags |= 512 /* CaptureArguments */;
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
if (shouldMarkIdentifierAliasReferenced(node)) {
|
|
markAliasReferenced(symbol, node);
|
|
}
|
|
const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
|
|
const targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node);
|
|
if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) {
|
|
addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText);
|
|
}
|
|
let declaration = localOrExportSymbol.valueDeclaration;
|
|
if (declaration && localOrExportSymbol.flags & 32 /* Class */) {
|
|
if (declaration.kind === 260 /* ClassDeclaration */ && nodeIsDecorated(declaration)) {
|
|
let container = getContainingClass(node);
|
|
while (container !== void 0) {
|
|
if (container === declaration && container.name !== node) {
|
|
getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
|
|
getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
|
|
break;
|
|
}
|
|
container = getContainingClass(container);
|
|
}
|
|
} else if (declaration.kind === 228 /* ClassExpression */) {
|
|
let container = getThisContainer(node, false);
|
|
while (container.kind !== 308 /* SourceFile */) {
|
|
if (container.parent === declaration) {
|
|
if (isPropertyDeclaration(container) && isStatic(container) || isClassStaticBlockDeclaration(container)) {
|
|
getNodeLinks(declaration).flags |= 1048576 /* ClassWithConstructorReference */;
|
|
getNodeLinks(node).flags |= 2097152 /* ConstructorReferenceInClass */;
|
|
}
|
|
break;
|
|
}
|
|
container = getThisContainer(container, false);
|
|
}
|
|
}
|
|
}
|
|
checkNestedBlockScopedBinding(node, symbol);
|
|
let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
if (assignmentKind) {
|
|
if (!(localOrExportSymbol.flags & 3 /* Variable */) && !(isInJSFile(node) && localOrExportSymbol.flags & 512 /* ValueModule */)) {
|
|
const assignmentError = localOrExportSymbol.flags & 384 /* Enum */ ? Diagnostics.Cannot_assign_to_0_because_it_is_an_enum : localOrExportSymbol.flags & 32 /* Class */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_class : localOrExportSymbol.flags & 1536 /* Module */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace : localOrExportSymbol.flags & 16 /* Function */ ? Diagnostics.Cannot_assign_to_0_because_it_is_a_function : localOrExportSymbol.flags & 2097152 /* Alias */ ? Diagnostics.Cannot_assign_to_0_because_it_is_an_import : Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable;
|
|
error(node, assignmentError, symbolToString(symbol));
|
|
return errorType;
|
|
}
|
|
if (isReadonlySymbol(localOrExportSymbol)) {
|
|
if (localOrExportSymbol.flags & 3 /* Variable */) {
|
|
error(node, Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol));
|
|
} else {
|
|
error(node, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol));
|
|
}
|
|
return errorType;
|
|
}
|
|
}
|
|
const isAlias = localOrExportSymbol.flags & 2097152 /* Alias */;
|
|
if (localOrExportSymbol.flags & 3 /* Variable */) {
|
|
if (assignmentKind === 1 /* Definite */) {
|
|
return type;
|
|
}
|
|
} else if (isAlias) {
|
|
declaration = getDeclarationOfAliasSymbol(symbol);
|
|
} else {
|
|
return type;
|
|
}
|
|
if (!declaration) {
|
|
return type;
|
|
}
|
|
type = getNarrowableTypeForReference(type, node, checkMode);
|
|
const isParameter2 = getRootDeclaration(declaration).kind === 166 /* Parameter */;
|
|
const declarationContainer = getControlFlowContainer(declaration);
|
|
let flowContainer = getControlFlowContainer(node);
|
|
const isOuterVariable = flowContainer !== declarationContainer;
|
|
const isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent);
|
|
const isModuleExports = symbol.flags & 134217728 /* ModuleExports */;
|
|
while (flowContainer !== declarationContainer && (flowContainer.kind === 215 /* FunctionExpression */ || flowContainer.kind === 216 /* ArrowFunction */ || isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && (isConstVariable(localOrExportSymbol) && type !== autoArrayType || isParameter2 && !isSymbolAssigned(localOrExportSymbol))) {
|
|
flowContainer = getControlFlowContainer(flowContainer);
|
|
}
|
|
const assumeInitialized = isParameter2 || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */)) !== 0 || isInTypeQuery(node) || node.parent.kind === 278 /* ExportSpecifier */) || node.parent.kind === 232 /* NonNullExpression */ || declaration.kind === 257 /* VariableDeclaration */ && declaration.exclamationToken || declaration.flags & 16777216 /* Ambient */;
|
|
const initialType = assumeInitialized ? isParameter2 ? removeOptionalityFromDeclaredType(type, declaration) : type : type === autoType || type === autoArrayType ? undefinedType : getOptionalType(type);
|
|
const flowType = getFlowTypeOfReference(node, type, initialType, flowContainer);
|
|
if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) {
|
|
if (flowType === autoType || flowType === autoArrayType) {
|
|
if (noImplicitAny) {
|
|
error(getNameOfDeclaration(declaration), Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType));
|
|
error(node, Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType));
|
|
}
|
|
return convertAutoToAny(flowType);
|
|
}
|
|
} else if (!assumeInitialized && !containsUndefinedType(type) && containsUndefinedType(flowType)) {
|
|
error(node, Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));
|
|
return type;
|
|
}
|
|
return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
|
|
}
|
|
function isSameScopedBindingElement(node, declaration) {
|
|
if (isBindingElement(declaration)) {
|
|
const bindingElement = findAncestor(node, isBindingElement);
|
|
return bindingElement && getRootDeclaration(bindingElement) === getRootDeclaration(declaration);
|
|
}
|
|
}
|
|
function shouldMarkIdentifierAliasReferenced(node) {
|
|
var _a2;
|
|
const parent2 = node.parent;
|
|
if (parent2) {
|
|
if (isPropertyAccessExpression(parent2) && parent2.expression === node) {
|
|
return false;
|
|
}
|
|
if (isExportSpecifier(parent2) && parent2.isTypeOnly) {
|
|
return false;
|
|
}
|
|
const greatGrandparent = (_a2 = parent2.parent) == null ? void 0 : _a2.parent;
|
|
if (greatGrandparent && isExportDeclaration(greatGrandparent) && greatGrandparent.isTypeOnly) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isInsideFunctionOrInstancePropertyInitializer(node, threshold) {
|
|
return !!findAncestor(node, (n) => n === threshold ? "quit" : isFunctionLike(n) || n.parent && isPropertyDeclaration(n.parent) && !hasStaticModifier(n.parent) && n.parent.initializer === n);
|
|
}
|
|
function getPartOfForStatementContainingNode(node, container) {
|
|
return findAncestor(node, (n) => n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement);
|
|
}
|
|
function getEnclosingIterationStatement(node) {
|
|
return findAncestor(node, (n) => !n || nodeStartsNewLexicalEnvironment(n) ? "quit" : isIterationStatement(n, false));
|
|
}
|
|
function checkNestedBlockScopedBinding(node, symbol) {
|
|
if (languageVersion >= 2 /* ES2015 */ || (symbol.flags & (2 /* BlockScopedVariable */ | 32 /* Class */)) === 0 || !symbol.valueDeclaration || isSourceFile(symbol.valueDeclaration) || symbol.valueDeclaration.parent.kind === 295 /* CatchClause */) {
|
|
return;
|
|
}
|
|
const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
|
|
const isCaptured = isInsideFunctionOrInstancePropertyInitializer(node, container);
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(container);
|
|
if (enclosingIterationStatement) {
|
|
if (isCaptured) {
|
|
let capturesBlockScopeBindingInLoopBody = true;
|
|
if (isForStatement(container)) {
|
|
const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
if (varDeclList && varDeclList.parent === container) {
|
|
const part = getPartOfForStatementContainingNode(node.parent, container);
|
|
if (part) {
|
|
const links = getNodeLinks(part);
|
|
links.flags |= 8192 /* ContainsCapturedBlockScopeBinding */;
|
|
const capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []);
|
|
pushIfUnique(capturedBindings, symbol);
|
|
if (part === container.initializer) {
|
|
capturesBlockScopeBindingInLoopBody = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (capturesBlockScopeBindingInLoopBody) {
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
if (isForStatement(container)) {
|
|
const varDeclList = getAncestor(symbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) {
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NeedsLoopOutParameter */;
|
|
}
|
|
}
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
}
|
|
if (isCaptured) {
|
|
getNodeLinks(symbol.valueDeclaration).flags |= 16384 /* CapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
function isBindingCapturedByNode(node, decl) {
|
|
const links = getNodeLinks(node);
|
|
return !!links && contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl));
|
|
}
|
|
function isAssignedInBodyOfForStatement(node, container) {
|
|
let current = node;
|
|
while (current.parent.kind === 214 /* ParenthesizedExpression */) {
|
|
current = current.parent;
|
|
}
|
|
let isAssigned = false;
|
|
if (isAssignmentTarget(current)) {
|
|
isAssigned = true;
|
|
} else if (current.parent.kind === 221 /* PrefixUnaryExpression */ || current.parent.kind === 222 /* PostfixUnaryExpression */) {
|
|
const expr = current.parent;
|
|
isAssigned = expr.operator === 45 /* PlusPlusToken */ || expr.operator === 46 /* MinusMinusToken */;
|
|
}
|
|
if (!isAssigned) {
|
|
return false;
|
|
}
|
|
return !!findAncestor(current, (n) => n === container ? "quit" : n === container.statement);
|
|
}
|
|
function captureLexicalThis(node, container) {
|
|
getNodeLinks(node).flags |= 2 /* LexicalThis */;
|
|
if (container.kind === 169 /* PropertyDeclaration */ || container.kind === 173 /* Constructor */) {
|
|
const classNode = container.parent;
|
|
getNodeLinks(classNode).flags |= 4 /* CaptureThis */;
|
|
} else {
|
|
getNodeLinks(container).flags |= 4 /* CaptureThis */;
|
|
}
|
|
}
|
|
function findFirstSuperCall(node) {
|
|
return isSuperCall(node) ? node : isFunctionLike(node) ? void 0 : forEachChild(node, findFirstSuperCall);
|
|
}
|
|
function classDeclarationExtendsNull(classDecl) {
|
|
const classSymbol = getSymbolOfNode(classDecl);
|
|
const classInstanceType = getDeclaredTypeOfSymbol(classSymbol);
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType);
|
|
return baseConstructorType === nullWideningType;
|
|
}
|
|
function checkThisBeforeSuper(node, container, diagnosticMessage) {
|
|
const containingClassDecl = container.parent;
|
|
const baseTypeNode = getClassExtendsHeritageElement(containingClassDecl);
|
|
if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) {
|
|
if (node.flowNode && !isPostSuperFlowNode(node.flowNode, false)) {
|
|
error(node, diagnosticMessage);
|
|
}
|
|
}
|
|
}
|
|
function checkThisInStaticClassFieldInitializerInDecoratedClass(thisExpression, container) {
|
|
if (isPropertyDeclaration(container) && hasStaticModifier(container) && container.initializer && textRangeContainsPositionInclusive(container.initializer, thisExpression.pos) && hasDecorators(container.parent)) {
|
|
error(thisExpression, Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class);
|
|
}
|
|
}
|
|
function checkThisExpression(node) {
|
|
const isNodeInTypeQuery = isInTypeQuery(node);
|
|
let container = getThisContainer(node, true);
|
|
let capturedByArrowFunction = false;
|
|
if (container.kind === 173 /* Constructor */) {
|
|
checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class);
|
|
}
|
|
if (container.kind === 216 /* ArrowFunction */) {
|
|
container = getThisContainer(container, false);
|
|
capturedByArrowFunction = true;
|
|
}
|
|
checkThisInStaticClassFieldInitializerInDecoratedClass(node, container);
|
|
switch (container.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body);
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_current_location);
|
|
break;
|
|
case 173 /* Constructor */:
|
|
if (isInConstructorArgumentInitializer(node, container)) {
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_constructor_arguments);
|
|
}
|
|
break;
|
|
case 164 /* ComputedPropertyName */:
|
|
error(node, Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
|
|
break;
|
|
}
|
|
if (!isNodeInTypeQuery && capturedByArrowFunction && languageVersion < 2 /* ES2015 */) {
|
|
captureLexicalThis(node, container);
|
|
}
|
|
const type = tryGetThisTypeAt(node, true, container);
|
|
if (noImplicitThis) {
|
|
const globalThisType2 = getTypeOfSymbol(globalThisSymbol);
|
|
if (type === globalThisType2 && capturedByArrowFunction) {
|
|
error(node, Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this);
|
|
} else if (!type) {
|
|
const diag2 = error(node, Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation);
|
|
if (!isSourceFile(container)) {
|
|
const outsideThis = tryGetThisTypeAt(container);
|
|
if (outsideThis && outsideThis !== globalThisType2) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(container, Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return type || anyType;
|
|
}
|
|
function tryGetThisTypeAt(node, includeGlobalThis = true, container = getThisContainer(node, false)) {
|
|
const isInJS = isInJSFile(node);
|
|
if (isFunctionLike(container) && (!isInParameterInitializerBeforeContainingFunction(node) || getThisParameter(container))) {
|
|
let thisType = getThisTypeOfDeclaration(container) || isInJS && getTypeForThisExpressionFromJSDoc(container);
|
|
if (!thisType) {
|
|
const className = getClassNameFromPrototypeMethod(container);
|
|
if (isInJS && className) {
|
|
const classSymbol = checkExpression(className).symbol;
|
|
if (classSymbol && classSymbol.members && classSymbol.flags & 16 /* Function */) {
|
|
thisType = getDeclaredTypeOfSymbol(classSymbol).thisType;
|
|
}
|
|
} else if (isJSConstructor(container)) {
|
|
thisType = getDeclaredTypeOfSymbol(getMergedSymbol(container.symbol)).thisType;
|
|
}
|
|
thisType || (thisType = getContextualThisParameterType(container));
|
|
}
|
|
if (thisType) {
|
|
return getFlowTypeOfReference(node, thisType);
|
|
}
|
|
}
|
|
if (isClassLike(container.parent)) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
const type = isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
|
|
return getFlowTypeOfReference(node, type);
|
|
}
|
|
if (isSourceFile(container)) {
|
|
if (container.commonJsModuleIndicator) {
|
|
const fileSymbol = getSymbolOfNode(container);
|
|
return fileSymbol && getTypeOfSymbol(fileSymbol);
|
|
} else if (container.externalModuleIndicator) {
|
|
return undefinedType;
|
|
} else if (includeGlobalThis) {
|
|
return getTypeOfSymbol(globalThisSymbol);
|
|
}
|
|
}
|
|
}
|
|
function getExplicitThisType(node) {
|
|
const container = getThisContainer(node, false);
|
|
if (isFunctionLike(container)) {
|
|
const signature = getSignatureFromDeclaration(container);
|
|
if (signature.thisParameter) {
|
|
return getExplicitTypeOfSymbol(signature.thisParameter);
|
|
}
|
|
}
|
|
if (isClassLike(container.parent)) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
return isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType;
|
|
}
|
|
}
|
|
function getClassNameFromPrototypeMethod(container) {
|
|
if (container.kind === 215 /* FunctionExpression */ && isBinaryExpression(container.parent) && getAssignmentDeclarationKind(container.parent) === 3 /* PrototypeProperty */) {
|
|
return container.parent.left.expression.expression;
|
|
} else if (container.kind === 171 /* MethodDeclaration */ && container.parent.kind === 207 /* ObjectLiteralExpression */ && isBinaryExpression(container.parent.parent) && getAssignmentDeclarationKind(container.parent.parent) === 6 /* Prototype */) {
|
|
return container.parent.parent.left.expression;
|
|
} else if (container.kind === 215 /* FunctionExpression */ && container.parent.kind === 299 /* PropertyAssignment */ && container.parent.parent.kind === 207 /* ObjectLiteralExpression */ && isBinaryExpression(container.parent.parent.parent) && getAssignmentDeclarationKind(container.parent.parent.parent) === 6 /* Prototype */) {
|
|
return container.parent.parent.parent.left.expression;
|
|
} else if (container.kind === 215 /* FunctionExpression */ && isPropertyAssignment(container.parent) && isIdentifier(container.parent.name) && (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") && isObjectLiteralExpression(container.parent.parent) && isCallExpression(container.parent.parent.parent) && container.parent.parent.parent.arguments[2] === container.parent.parent && getAssignmentDeclarationKind(container.parent.parent.parent) === 9 /* ObjectDefinePrototypeProperty */) {
|
|
return container.parent.parent.parent.arguments[0].expression;
|
|
} else if (isMethodDeclaration(container) && isIdentifier(container.name) && (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") && isObjectLiteralExpression(container.parent) && isCallExpression(container.parent.parent) && container.parent.parent.arguments[2] === container.parent && getAssignmentDeclarationKind(container.parent.parent) === 9 /* ObjectDefinePrototypeProperty */) {
|
|
return container.parent.parent.arguments[0].expression;
|
|
}
|
|
}
|
|
function getTypeForThisExpressionFromJSDoc(node) {
|
|
const jsdocType = getJSDocType(node);
|
|
if (jsdocType && jsdocType.kind === 320 /* JSDocFunctionType */) {
|
|
const jsDocFunctionType = jsdocType;
|
|
if (jsDocFunctionType.parameters.length > 0 && jsDocFunctionType.parameters[0].name && jsDocFunctionType.parameters[0].name.escapedText === "this" /* This */) {
|
|
return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type);
|
|
}
|
|
}
|
|
const thisTag = getJSDocThisTag(node);
|
|
if (thisTag && thisTag.typeExpression) {
|
|
return getTypeFromTypeNode(thisTag.typeExpression);
|
|
}
|
|
}
|
|
function isInConstructorArgumentInitializer(node, constructorDecl) {
|
|
return !!findAncestor(node, (n) => isFunctionLikeDeclaration(n) ? "quit" : n.kind === 166 /* Parameter */ && n.parent === constructorDecl);
|
|
}
|
|
function checkSuperExpression(node) {
|
|
const isCallExpression2 = node.parent.kind === 210 /* CallExpression */ && node.parent.expression === node;
|
|
const immediateContainer = getSuperContainer(node, true);
|
|
let container = immediateContainer;
|
|
let needToCaptureLexicalThis = false;
|
|
let inAsyncFunction = false;
|
|
if (!isCallExpression2) {
|
|
while (container && container.kind === 216 /* ArrowFunction */) {
|
|
if (hasSyntacticModifier(container, 512 /* Async */))
|
|
inAsyncFunction = true;
|
|
container = getSuperContainer(container, true);
|
|
needToCaptureLexicalThis = languageVersion < 2 /* ES2015 */;
|
|
}
|
|
if (container && hasSyntacticModifier(container, 512 /* Async */))
|
|
inAsyncFunction = true;
|
|
}
|
|
const canUseSuperExpression = isLegalUsageOfSuperExpression(container);
|
|
let nodeCheckFlag = 0;
|
|
if (!canUseSuperExpression) {
|
|
const current = findAncestor(node, (n) => n === container ? "quit" : n.kind === 164 /* ComputedPropertyName */);
|
|
if (current && current.kind === 164 /* ComputedPropertyName */) {
|
|
error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
|
|
} else if (isCallExpression2) {
|
|
error(node, Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
|
|
} else if (!container || !container.parent || !(isClassLike(container.parent) || container.parent.kind === 207 /* ObjectLiteralExpression */)) {
|
|
error(node, Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions);
|
|
} else {
|
|
error(node, Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (!isCallExpression2 && immediateContainer.kind === 173 /* Constructor */) {
|
|
checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class);
|
|
}
|
|
if (isStatic(container) || isCallExpression2) {
|
|
nodeCheckFlag = 32 /* SuperStatic */;
|
|
if (!isCallExpression2 && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && (isPropertyDeclaration(container) || isClassStaticBlockDeclaration(container))) {
|
|
forEachEnclosingBlockScopeContainer(node.parent, (current) => {
|
|
if (!isSourceFile(current) || isExternalOrCommonJsModule(current)) {
|
|
getNodeLinks(current).flags |= 8388608 /* ContainsSuperPropertyInStaticInitializer */;
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
nodeCheckFlag = 16 /* SuperInstance */;
|
|
}
|
|
getNodeLinks(node).flags |= nodeCheckFlag;
|
|
if (container.kind === 171 /* MethodDeclaration */ && inAsyncFunction) {
|
|
if (isSuperProperty(node.parent) && isAssignmentTarget(node.parent)) {
|
|
getNodeLinks(container).flags |= 256 /* MethodWithSuperPropertyAssignmentInAsync */;
|
|
} else {
|
|
getNodeLinks(container).flags |= 128 /* MethodWithSuperPropertyAccessInAsync */;
|
|
}
|
|
}
|
|
if (needToCaptureLexicalThis) {
|
|
captureLexicalThis(node.parent, container);
|
|
}
|
|
if (container.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
error(node, Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher);
|
|
return errorType;
|
|
} else {
|
|
return anyType;
|
|
}
|
|
}
|
|
const classLikeDeclaration = container.parent;
|
|
if (!getClassExtendsHeritageElement(classLikeDeclaration)) {
|
|
error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
|
|
return errorType;
|
|
}
|
|
const classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration));
|
|
const baseClassType = classType && getBaseTypes(classType)[0];
|
|
if (!baseClassType) {
|
|
return errorType;
|
|
}
|
|
if (container.kind === 173 /* Constructor */ && isInConstructorArgumentInitializer(node, container)) {
|
|
error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);
|
|
return errorType;
|
|
}
|
|
return nodeCheckFlag === 32 /* SuperStatic */ ? getBaseConstructorTypeOfClass(classType) : getTypeWithThisArgument(baseClassType, classType.thisType);
|
|
function isLegalUsageOfSuperExpression(container2) {
|
|
if (!container2) {
|
|
return false;
|
|
}
|
|
if (isCallExpression2) {
|
|
return container2.kind === 173 /* Constructor */;
|
|
} else {
|
|
if (isClassLike(container2.parent) || container2.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (isStatic(container2)) {
|
|
return container2.kind === 171 /* MethodDeclaration */ || container2.kind === 170 /* MethodSignature */ || container2.kind === 174 /* GetAccessor */ || container2.kind === 175 /* SetAccessor */ || container2.kind === 169 /* PropertyDeclaration */ || container2.kind === 172 /* ClassStaticBlockDeclaration */;
|
|
} else {
|
|
return container2.kind === 171 /* MethodDeclaration */ || container2.kind === 170 /* MethodSignature */ || container2.kind === 174 /* GetAccessor */ || container2.kind === 175 /* SetAccessor */ || container2.kind === 169 /* PropertyDeclaration */ || container2.kind === 168 /* PropertySignature */ || container2.kind === 173 /* Constructor */;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getContainingObjectLiteral(func) {
|
|
return (func.kind === 171 /* MethodDeclaration */ || func.kind === 174 /* GetAccessor */ || func.kind === 175 /* SetAccessor */) && func.parent.kind === 207 /* ObjectLiteralExpression */ ? func.parent : func.kind === 215 /* FunctionExpression */ && func.parent.kind === 299 /* PropertyAssignment */ ? func.parent.parent : void 0;
|
|
}
|
|
function getThisTypeArgument(type) {
|
|
return getObjectFlags(type) & 4 /* Reference */ && type.target === globalThisType ? getTypeArguments(type)[0] : void 0;
|
|
}
|
|
function getThisTypeFromContextualType(type) {
|
|
return mapType(type, (t) => {
|
|
return t.flags & 2097152 /* Intersection */ ? forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
|
|
});
|
|
}
|
|
function getContextualThisParameterType(func) {
|
|
if (func.kind === 216 /* ArrowFunction */) {
|
|
return void 0;
|
|
}
|
|
if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature) {
|
|
const thisParameter = contextualSignature.thisParameter;
|
|
if (thisParameter) {
|
|
return getTypeOfSymbol(thisParameter);
|
|
}
|
|
}
|
|
}
|
|
const inJs = isInJSFile(func);
|
|
if (noImplicitThis || inJs) {
|
|
const containingLiteral = getContainingObjectLiteral(func);
|
|
if (containingLiteral) {
|
|
const contextualType = getApparentTypeOfContextualType(containingLiteral, void 0);
|
|
let literal = containingLiteral;
|
|
let type = contextualType;
|
|
while (type) {
|
|
const thisType = getThisTypeFromContextualType(type);
|
|
if (thisType) {
|
|
return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
|
|
}
|
|
if (literal.parent.kind !== 299 /* PropertyAssignment */) {
|
|
break;
|
|
}
|
|
literal = literal.parent.parent;
|
|
type = getApparentTypeOfContextualType(literal, void 0);
|
|
}
|
|
return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
|
|
}
|
|
const parent2 = walkUpParenthesizedExpressions(func.parent);
|
|
if (parent2.kind === 223 /* BinaryExpression */ && parent2.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const target = parent2.left;
|
|
if (isAccessExpression(target)) {
|
|
const { expression } = target;
|
|
if (inJs && isIdentifier(expression)) {
|
|
const sourceFile = getSourceFileOfNode(parent2);
|
|
if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return getWidenedType(checkExpressionCached(expression));
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextuallyTypedParameterType(parameter) {
|
|
const func = parameter.parent;
|
|
if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) {
|
|
return void 0;
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(func);
|
|
if (iife && iife.arguments) {
|
|
const args = getEffectiveCallArguments(iife);
|
|
const indexOfParameter = func.parameters.indexOf(parameter);
|
|
if (parameter.dotDotDotToken) {
|
|
return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, void 0, 0 /* Normal */);
|
|
}
|
|
const links = getNodeLinks(iife);
|
|
const cached = links.resolvedSignature;
|
|
links.resolvedSignature = anySignature;
|
|
const type = indexOfParameter < args.length ? getWidenedLiteralType(checkExpression(args[indexOfParameter])) : parameter.initializer ? void 0 : undefinedWideningType;
|
|
links.resolvedSignature = cached;
|
|
return type;
|
|
}
|
|
const contextualSignature = getContextualSignature(func);
|
|
if (contextualSignature) {
|
|
const index = func.parameters.indexOf(parameter) - (getThisParameter(func) ? 1 : 0);
|
|
return parameter.dotDotDotToken && lastOrUndefined(func.parameters) === parameter ? getRestTypeAtPosition(contextualSignature, index) : tryGetTypeAtPosition(contextualSignature, index);
|
|
}
|
|
}
|
|
function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(declaration);
|
|
if (typeNode) {
|
|
return getTypeFromTypeNode(typeNode);
|
|
}
|
|
switch (declaration.kind) {
|
|
case 166 /* Parameter */:
|
|
return getContextuallyTypedParameterType(declaration);
|
|
case 205 /* BindingElement */:
|
|
return getContextualTypeForBindingElement(declaration, contextFlags);
|
|
case 169 /* PropertyDeclaration */:
|
|
if (isStatic(declaration)) {
|
|
return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags);
|
|
}
|
|
}
|
|
}
|
|
function getContextualTypeForBindingElement(declaration, contextFlags) {
|
|
const parent2 = declaration.parent.parent;
|
|
const name = declaration.propertyName || declaration.name;
|
|
const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 205 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
|
|
if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name))
|
|
return void 0;
|
|
if (parent2.name.kind === 204 /* ArrayBindingPattern */) {
|
|
const index = indexOfNode(declaration.parent.elements, declaration);
|
|
if (index < 0)
|
|
return void 0;
|
|
return getContextualTypeForElementExpression(parentType, index);
|
|
}
|
|
const nameType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(nameType)) {
|
|
const text = getPropertyNameFromType(nameType);
|
|
return getTypeOfPropertyOfType(parentType, text);
|
|
}
|
|
}
|
|
function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) {
|
|
const parentType = isExpression(declaration.parent) && getContextualType2(declaration.parent, contextFlags);
|
|
if (!parentType)
|
|
return void 0;
|
|
return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
|
|
}
|
|
function getContextualTypeForInitializerExpression(node, contextFlags) {
|
|
const declaration = node.parent;
|
|
if (hasInitializer(declaration) && node === declaration.initializer) {
|
|
const result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
if (!(contextFlags & 8 /* SkipBindingPatterns */) && isBindingPattern(declaration.name) && declaration.name.elements.length > 0) {
|
|
return getTypeFromBindingPattern(declaration.name, true, false);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForReturnExpression(node, contextFlags) {
|
|
const func = getContainingFunction(node);
|
|
if (func) {
|
|
let contextualReturnType = getContextualReturnType(func, contextFlags);
|
|
if (contextualReturnType) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
if (functionFlags & 1 /* Generator */) {
|
|
const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
|
|
if (contextualReturnType.flags & 1048576 /* Union */) {
|
|
contextualReturnType = filterType(contextualReturnType, (type) => !!getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, type, isAsyncGenerator));
|
|
}
|
|
const iterationReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, contextualReturnType, (functionFlags & 2 /* Async */) !== 0);
|
|
if (!iterationReturnType) {
|
|
return void 0;
|
|
}
|
|
contextualReturnType = iterationReturnType;
|
|
}
|
|
if (functionFlags & 2 /* Async */) {
|
|
const contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeNoAlias);
|
|
return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
|
|
}
|
|
return contextualReturnType;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForAwaitOperand(node, contextFlags) {
|
|
const contextualType = getContextualType2(node, contextFlags);
|
|
if (contextualType) {
|
|
const contextualAwaitedType = getAwaitedTypeNoAlias(contextualType);
|
|
return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForYieldOperand(node, contextFlags) {
|
|
const func = getContainingFunction(node);
|
|
if (func) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
let contextualReturnType = getContextualReturnType(func, contextFlags);
|
|
if (contextualReturnType) {
|
|
const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
|
|
if (!node.asteriskToken && contextualReturnType.flags & 1048576 /* Union */) {
|
|
contextualReturnType = filterType(contextualReturnType, (type) => !!getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, type, isAsyncGenerator));
|
|
}
|
|
return node.asteriskToken ? contextualReturnType : getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, contextualReturnType, isAsyncGenerator);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isInParameterInitializerBeforeContainingFunction(node) {
|
|
let inBindingInitializer = false;
|
|
while (node.parent && !isFunctionLike(node.parent)) {
|
|
if (isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) {
|
|
return true;
|
|
}
|
|
if (isBindingElement(node.parent) && node.parent.initializer === node) {
|
|
inBindingInitializer = true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function getContextualIterationType(kind, functionDecl) {
|
|
const isAsync = !!(getFunctionFlags(functionDecl) & 2 /* Async */);
|
|
const contextualReturnType = getContextualReturnType(functionDecl, void 0);
|
|
if (contextualReturnType) {
|
|
return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync) || void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualReturnType(functionDecl, contextFlags) {
|
|
const returnType = getReturnTypeFromAnnotation(functionDecl);
|
|
if (returnType) {
|
|
return returnType;
|
|
}
|
|
const signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl);
|
|
if (signature && !isResolvingReturnTypeOfSignature(signature)) {
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
const iife = getImmediatelyInvokedFunctionExpression(functionDecl);
|
|
if (iife) {
|
|
return getContextualType2(iife, contextFlags);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForArgument(callTarget, arg) {
|
|
const args = getEffectiveCallArguments(callTarget);
|
|
const argIndex = args.indexOf(arg);
|
|
return argIndex === -1 ? void 0 : getContextualTypeForArgumentAtIndex(callTarget, argIndex);
|
|
}
|
|
function getContextualTypeForArgumentAtIndex(callTarget, argIndex) {
|
|
if (isImportCall(callTarget)) {
|
|
return argIndex === 0 ? stringType : argIndex === 1 ? getGlobalImportCallOptionsType(false) : anyType;
|
|
}
|
|
const signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget);
|
|
if (isJsxOpeningLikeElement(callTarget) && argIndex === 0) {
|
|
return getEffectiveFirstArgumentForJsxSignature(signature, callTarget);
|
|
}
|
|
const restIndex = signature.parameters.length - 1;
|
|
return signatureHasRestParameter(signature) && argIndex >= restIndex ? getIndexedAccessType(getTypeOfSymbol(signature.parameters[restIndex]), getNumberLiteralType(argIndex - restIndex), 256 /* Contextual */) : getTypeAtPosition(signature, argIndex);
|
|
}
|
|
function getContextualTypeForSubstitutionExpression(template, substitutionExpression) {
|
|
if (template.parent.kind === 212 /* TaggedTemplateExpression */) {
|
|
return getContextualTypeForArgument(template.parent, substitutionExpression);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForBinaryOperand(node, contextFlags) {
|
|
const binaryExpression = node.parent;
|
|
const { left, operatorToken, right } = binaryExpression;
|
|
switch (operatorToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return node === right ? getContextualTypeForAssignmentDeclaration(binaryExpression) : void 0;
|
|
case 56 /* BarBarToken */:
|
|
case 60 /* QuestionQuestionToken */:
|
|
const type = getContextualType2(binaryExpression, contextFlags);
|
|
return node === right && (type && type.pattern || !type && !isDefaultedExpandoInitializer(binaryExpression)) ? getTypeOfExpression(left) : type;
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 27 /* CommaToken */:
|
|
return node === right ? getContextualType2(binaryExpression, contextFlags) : void 0;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getSymbolForExpression(e) {
|
|
if (e.symbol) {
|
|
return e.symbol;
|
|
}
|
|
if (isIdentifier(e)) {
|
|
return getResolvedSymbol(e);
|
|
}
|
|
if (isPropertyAccessExpression(e)) {
|
|
const lhsType = getTypeOfExpression(e.expression);
|
|
return isPrivateIdentifier(e.name) ? tryGetPrivateIdentifierPropertyOfType(lhsType, e.name) : getPropertyOfType(lhsType, e.name.escapedText);
|
|
}
|
|
if (isElementAccessExpression(e)) {
|
|
const propType = checkExpressionCached(e.argumentExpression);
|
|
if (!isTypeUsableAsPropertyName(propType)) {
|
|
return void 0;
|
|
}
|
|
const lhsType = getTypeOfExpression(e.expression);
|
|
return getPropertyOfType(lhsType, getPropertyNameFromType(propType));
|
|
}
|
|
return void 0;
|
|
function tryGetPrivateIdentifierPropertyOfType(type, id) {
|
|
const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(id.escapedText, id);
|
|
return lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(type, lexicallyScopedSymbol);
|
|
}
|
|
}
|
|
function getContextualTypeForAssignmentDeclaration(binaryExpression) {
|
|
var _a2, _b;
|
|
const kind = getAssignmentDeclarationKind(binaryExpression);
|
|
switch (kind) {
|
|
case 0 /* None */:
|
|
case 4 /* ThisProperty */:
|
|
const lhsSymbol = getSymbolForExpression(binaryExpression.left);
|
|
const decl = lhsSymbol && lhsSymbol.valueDeclaration;
|
|
if (decl && (isPropertyDeclaration(decl) || isPropertySignature(decl))) {
|
|
const overallAnnotation = getEffectiveTypeAnnotationNode(decl);
|
|
return overallAnnotation && instantiateType(getTypeFromTypeNode(overallAnnotation), getSymbolLinks(lhsSymbol).mapper) || (isPropertyDeclaration(decl) ? decl.initializer && getTypeOfExpression(binaryExpression.left) : void 0);
|
|
}
|
|
if (kind === 0 /* None */) {
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
}
|
|
return getContextualTypeForThisPropertyAssignment(binaryExpression);
|
|
case 5 /* Property */:
|
|
if (isPossiblyAliasedThisProperty(binaryExpression, kind)) {
|
|
return getContextualTypeForThisPropertyAssignment(binaryExpression);
|
|
} else if (!binaryExpression.left.symbol) {
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
} else {
|
|
const decl2 = binaryExpression.left.symbol.valueDeclaration;
|
|
if (!decl2) {
|
|
return void 0;
|
|
}
|
|
const lhs = cast(binaryExpression.left, isAccessExpression);
|
|
const overallAnnotation = getEffectiveTypeAnnotationNode(decl2);
|
|
if (overallAnnotation) {
|
|
return getTypeFromTypeNode(overallAnnotation);
|
|
} else if (isIdentifier(lhs.expression)) {
|
|
const id = lhs.expression;
|
|
const parentSymbol = resolveName(id, id.escapedText, 111551 /* Value */, void 0, id.escapedText, true);
|
|
if (parentSymbol) {
|
|
const annotated2 = parentSymbol.valueDeclaration && getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration);
|
|
if (annotated2) {
|
|
const nameStr = getElementOrPropertyAccessName(lhs);
|
|
if (nameStr !== void 0) {
|
|
return getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated2), nameStr);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
return isInJSFile(decl2) ? void 0 : getTypeOfExpression(binaryExpression.left);
|
|
}
|
|
case 1 /* ExportsProperty */:
|
|
case 6 /* Prototype */:
|
|
case 3 /* PrototypeProperty */:
|
|
case 2 /* ModuleExports */:
|
|
let valueDeclaration;
|
|
if (kind !== 2 /* ModuleExports */) {
|
|
valueDeclaration = (_a2 = binaryExpression.left.symbol) == null ? void 0 : _a2.valueDeclaration;
|
|
}
|
|
valueDeclaration || (valueDeclaration = (_b = binaryExpression.symbol) == null ? void 0 : _b.valueDeclaration);
|
|
const annotated = valueDeclaration && getEffectiveTypeAnnotationNode(valueDeclaration);
|
|
return annotated ? getTypeFromTypeNode(annotated) : void 0;
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
return Debug.fail("Does not apply");
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function isPossiblyAliasedThisProperty(declaration, kind = getAssignmentDeclarationKind(declaration)) {
|
|
if (kind === 4 /* ThisProperty */) {
|
|
return true;
|
|
}
|
|
if (!isInJSFile(declaration) || kind !== 5 /* Property */ || !isIdentifier(declaration.left.expression)) {
|
|
return false;
|
|
}
|
|
const name = declaration.left.expression.escapedText;
|
|
const symbol = resolveName(declaration.left, name, 111551 /* Value */, void 0, void 0, true, true);
|
|
return isThisInitializedDeclaration(symbol == null ? void 0 : symbol.valueDeclaration);
|
|
}
|
|
function getContextualTypeForThisPropertyAssignment(binaryExpression) {
|
|
if (!binaryExpression.symbol)
|
|
return getTypeOfExpression(binaryExpression.left);
|
|
if (binaryExpression.symbol.valueDeclaration) {
|
|
const annotated = getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration);
|
|
if (annotated) {
|
|
const type = getTypeFromTypeNode(annotated);
|
|
if (type) {
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
const thisAccess = cast(binaryExpression.left, isAccessExpression);
|
|
if (!isObjectLiteralMethod(getThisContainer(thisAccess.expression, false))) {
|
|
return void 0;
|
|
}
|
|
const thisType = checkThisExpression(thisAccess.expression);
|
|
const nameStr = getElementOrPropertyAccessName(thisAccess);
|
|
return nameStr !== void 0 && getTypeOfPropertyOfContextualType(thisType, nameStr) || void 0;
|
|
}
|
|
function isCircularMappedProperty(symbol) {
|
|
return !!(getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
|
|
}
|
|
function getTypeOfPropertyOfContextualType(type, name, nameType) {
|
|
return mapType(type, (t) => {
|
|
var _a2;
|
|
if (isGenericMappedType(t) && !t.declaration.nameType) {
|
|
const constraint = getConstraintTypeFromMappedType(t);
|
|
const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
|
|
const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
|
|
if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
|
|
return substituteIndexedMappedType(t, propertyNameType);
|
|
}
|
|
} else if (t.flags & 3670016 /* StructuredType */) {
|
|
const prop = getPropertyOfType(t, name);
|
|
if (prop) {
|
|
return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
|
|
}
|
|
if (isTupleType(t)) {
|
|
const restType = getRestTypeOfTupleType(t);
|
|
if (restType && isNumericLiteralName(name) && +name >= 0) {
|
|
return restType;
|
|
}
|
|
}
|
|
return (_a2 = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a2.type;
|
|
}
|
|
return void 0;
|
|
}, true);
|
|
}
|
|
function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
|
|
Debug.assert(isObjectLiteralMethod(node));
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
return getContextualTypeForObjectLiteralElement(node, contextFlags);
|
|
}
|
|
function getContextualTypeForObjectLiteralElement(element, contextFlags) {
|
|
const objectLiteral = element.parent;
|
|
const propertyAssignmentType = isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags);
|
|
if (propertyAssignmentType) {
|
|
return propertyAssignmentType;
|
|
}
|
|
const type = getApparentTypeOfContextualType(objectLiteral, contextFlags);
|
|
if (type) {
|
|
if (hasBindableName(element)) {
|
|
const symbol = getSymbolOfNode(element);
|
|
return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType);
|
|
}
|
|
if (element.name) {
|
|
const nameType = getLiteralTypeFromPropertyName(element.name);
|
|
return mapType(type, (t) => {
|
|
var _a2;
|
|
return (_a2 = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType)) == null ? void 0 : _a2.type;
|
|
}, true);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextualTypeForElementExpression(arrayContextualType, index) {
|
|
return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
|
|
arrayContextualType,
|
|
(t) => getIteratedTypeOrElementType(1 /* Element */, t, undefinedType, void 0, false),
|
|
true
|
|
));
|
|
}
|
|
function getContextualTypeForConditionalOperand(node, contextFlags) {
|
|
const conditional = node.parent;
|
|
return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType2(conditional, contextFlags) : void 0;
|
|
}
|
|
function getContextualTypeForChildJsxExpression(node, child, contextFlags) {
|
|
const attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags);
|
|
const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node));
|
|
if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) {
|
|
return void 0;
|
|
}
|
|
const realChildren = getSemanticJsxChildren(node.children);
|
|
const childIndex = realChildren.indexOf(child);
|
|
const childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName);
|
|
return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, (t) => {
|
|
if (isArrayLikeType(t)) {
|
|
return getIndexedAccessType(t, getNumberLiteralType(childIndex));
|
|
} else {
|
|
return t;
|
|
}
|
|
}, true));
|
|
}
|
|
function getContextualTypeForJsxExpression(node, contextFlags) {
|
|
const exprParent = node.parent;
|
|
return isJsxAttributeLike(exprParent) ? getContextualType2(node, contextFlags) : isJsxElement(exprParent) ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags) : void 0;
|
|
}
|
|
function getContextualTypeForJsxAttribute(attribute, contextFlags) {
|
|
if (isJsxAttribute(attribute)) {
|
|
const attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags);
|
|
if (!attributesType || isTypeAny(attributesType)) {
|
|
return void 0;
|
|
}
|
|
return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText);
|
|
} else {
|
|
return getContextualType2(attribute.parent, contextFlags);
|
|
}
|
|
}
|
|
function isPossiblyDiscriminantValue(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 79 /* Identifier */:
|
|
case 155 /* UndefinedKeyword */:
|
|
return true;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isPossiblyDiscriminantValue(node.expression);
|
|
case 291 /* JsxExpression */:
|
|
return !node.expression || isPossiblyDiscriminantValue(node.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function discriminateContextualTypeByObjectMembers(node, contextualType) {
|
|
return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(
|
|
contextualType,
|
|
concatenate(
|
|
map(
|
|
filter(node.properties, (p) => !!p.symbol && p.kind === 299 /* PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName)),
|
|
(prop) => [() => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
|
|
),
|
|
map(
|
|
filter(getPropertiesOfType(contextualType), (s) => {
|
|
var _a2;
|
|
return !!(s.flags & 16777216 /* Optional */) && !!((_a2 = node == null ? void 0 : node.symbol) == null ? void 0 : _a2.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
|
|
}),
|
|
(s) => [() => undefinedType, s.escapedName]
|
|
)
|
|
),
|
|
isTypeAssignableTo,
|
|
contextualType
|
|
);
|
|
}
|
|
function discriminateContextualTypeByJSXAttributes(node, contextualType) {
|
|
return discriminateTypeByDiscriminableItems(
|
|
contextualType,
|
|
concatenate(
|
|
map(
|
|
filter(node.properties, (p) => !!p.symbol && p.kind === 288 /* JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer))),
|
|
(prop) => [!prop.initializer ? () => trueType : () => getContextFreeTypeOfExpression(prop.initializer), prop.symbol.escapedName]
|
|
),
|
|
map(
|
|
filter(getPropertiesOfType(contextualType), (s) => {
|
|
var _a2;
|
|
return !!(s.flags & 16777216 /* Optional */) && !!((_a2 = node == null ? void 0 : node.symbol) == null ? void 0 : _a2.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName);
|
|
}),
|
|
(s) => [() => undefinedType, s.escapedName]
|
|
)
|
|
),
|
|
isTypeAssignableTo,
|
|
contextualType
|
|
);
|
|
}
|
|
function getApparentTypeOfContextualType(node, contextFlags) {
|
|
const contextualType = isObjectLiteralMethod(node) ? getContextualTypeForObjectLiteralMethod(node, contextFlags) : getContextualType2(node, contextFlags);
|
|
const instantiatedType = instantiateContextualType(contextualType, node, contextFlags);
|
|
if (instantiatedType && !(contextFlags && contextFlags & 2 /* NoConstraints */ && instantiatedType.flags & 8650752 /* TypeVariable */)) {
|
|
const apparentType = mapType(instantiatedType, getApparentType, true);
|
|
return apparentType.flags & 1048576 /* Union */ && isObjectLiteralExpression(node) ? discriminateContextualTypeByObjectMembers(node, apparentType) : apparentType.flags & 1048576 /* Union */ && isJsxAttributes(node) ? discriminateContextualTypeByJSXAttributes(node, apparentType) : apparentType;
|
|
}
|
|
}
|
|
function instantiateContextualType(contextualType, node, contextFlags) {
|
|
if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* Instantiable */)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
if (inferenceContext && contextFlags & 1 /* Signature */ && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) {
|
|
return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
|
|
}
|
|
if (inferenceContext == null ? void 0 : inferenceContext.returnMapper) {
|
|
const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper);
|
|
return type.flags & 1048576 /* Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ? filterType(type, (t) => t !== regularFalseType && t !== regularTrueType) : type;
|
|
}
|
|
}
|
|
return contextualType;
|
|
}
|
|
function instantiateInstantiableTypes(type, mapper) {
|
|
if (type.flags & 465829888 /* Instantiable */) {
|
|
return instantiateType(type, mapper);
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
return getUnionType(map(type.types, (t) => instantiateInstantiableTypes(t, mapper)), 0 /* None */);
|
|
}
|
|
if (type.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(map(type.types, (t) => instantiateInstantiableTypes(t, mapper)));
|
|
}
|
|
return type;
|
|
}
|
|
function getContextualType2(node, contextFlags) {
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
if (node.contextualType) {
|
|
return node.contextualType;
|
|
}
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 205 /* BindingElement */:
|
|
return getContextualTypeForInitializerExpression(node, contextFlags);
|
|
case 216 /* ArrowFunction */:
|
|
case 250 /* ReturnStatement */:
|
|
return getContextualTypeForReturnExpression(node, contextFlags);
|
|
case 226 /* YieldExpression */:
|
|
return getContextualTypeForYieldOperand(parent2, contextFlags);
|
|
case 220 /* AwaitExpression */:
|
|
return getContextualTypeForAwaitOperand(parent2, contextFlags);
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
return getContextualTypeForArgument(parent2, node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return isConstTypeReference(parent2.type) ? tryFindWhenConstTypeReference(parent2) : getTypeFromTypeNode(parent2.type);
|
|
case 223 /* BinaryExpression */:
|
|
return getContextualTypeForBinaryOperand(node, contextFlags);
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return getContextualTypeForObjectLiteralElement(parent2, contextFlags);
|
|
case 301 /* SpreadAssignment */:
|
|
return getContextualType2(parent2.parent, contextFlags);
|
|
case 206 /* ArrayLiteralExpression */: {
|
|
const arrayLiteral = parent2;
|
|
const type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
|
|
return getContextualTypeForElementExpression(type, indexOfNode(arrayLiteral.elements, node));
|
|
}
|
|
case 224 /* ConditionalExpression */:
|
|
return getContextualTypeForConditionalOperand(node, contextFlags);
|
|
case 236 /* TemplateSpan */:
|
|
Debug.assert(parent2.parent.kind === 225 /* TemplateExpression */);
|
|
return getContextualTypeForSubstitutionExpression(parent2.parent, node);
|
|
case 214 /* ParenthesizedExpression */: {
|
|
const tag = isInJSFile(parent2) ? getJSDocTypeTag(parent2) : void 0;
|
|
return !tag ? getContextualType2(parent2, contextFlags) : isJSDocTypeTag(tag) && isConstTypeReference(tag.typeExpression.type) ? tryFindWhenConstTypeReference(parent2) : getTypeFromTypeNode(tag.typeExpression.type);
|
|
}
|
|
case 232 /* NonNullExpression */:
|
|
return getContextualType2(parent2, contextFlags);
|
|
case 235 /* SatisfiesExpression */:
|
|
return getTypeFromTypeNode(parent2.type);
|
|
case 274 /* ExportAssignment */:
|
|
return tryGetTypeFromEffectiveTypeNode(parent2);
|
|
case 291 /* JsxExpression */:
|
|
return getContextualTypeForJsxExpression(parent2, contextFlags);
|
|
case 288 /* JsxAttribute */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
return getContextualTypeForJsxAttribute(parent2, contextFlags);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return getContextualJsxElementAttributesType(parent2, contextFlags);
|
|
}
|
|
return void 0;
|
|
function tryFindWhenConstTypeReference(node2) {
|
|
return getContextualType2(node2, contextFlags);
|
|
}
|
|
}
|
|
function getInferenceContext(node) {
|
|
const ancestor = findAncestor(node, (n) => !!n.inferenceContext);
|
|
return ancestor && ancestor.inferenceContext;
|
|
}
|
|
function getContextualJsxElementAttributesType(node, contextFlags) {
|
|
if (isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4 /* Completions */) {
|
|
return node.parent.contextualType;
|
|
}
|
|
return getContextualTypeForArgumentAtIndex(node, 0);
|
|
}
|
|
function getEffectiveFirstArgumentForJsxSignature(signature, node) {
|
|
return getJsxReferenceKind(node) !== 0 /* Component */ ? getJsxPropsTypeFromCallSignature(signature, node) : getJsxPropsTypeFromClassType(signature, node);
|
|
}
|
|
function getJsxPropsTypeFromCallSignature(sig, context) {
|
|
let propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType);
|
|
propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType);
|
|
const intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
|
|
if (!isErrorType(intrinsicAttribs)) {
|
|
propsType = intersectTypes(intrinsicAttribs, propsType);
|
|
}
|
|
return propsType;
|
|
}
|
|
function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) {
|
|
if (sig.compositeSignatures) {
|
|
const results = [];
|
|
for (const signature of sig.compositeSignatures) {
|
|
const instance = getReturnTypeOfSignature(signature);
|
|
if (isTypeAny(instance)) {
|
|
return instance;
|
|
}
|
|
const propType = getTypeOfPropertyOfType(instance, forcedLookupLocation);
|
|
if (!propType) {
|
|
return;
|
|
}
|
|
results.push(propType);
|
|
}
|
|
return getIntersectionType(results);
|
|
}
|
|
const instanceType = getReturnTypeOfSignature(sig);
|
|
return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
|
|
}
|
|
function getStaticTypeOfReferencedJsxConstructor(context) {
|
|
if (isJsxIntrinsicIdentifier(context.tagName)) {
|
|
const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context);
|
|
const fakeSignature = createSignatureForJSXIntrinsic(context, result);
|
|
return getOrCreateTypeFromSignature(fakeSignature);
|
|
}
|
|
const tagType = checkExpressionCached(context.tagName);
|
|
if (tagType.flags & 128 /* StringLiteral */) {
|
|
const result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context);
|
|
if (!result) {
|
|
return errorType;
|
|
}
|
|
const fakeSignature = createSignatureForJSXIntrinsic(context, result);
|
|
return getOrCreateTypeFromSignature(fakeSignature);
|
|
}
|
|
return tagType;
|
|
}
|
|
function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) {
|
|
const managedSym = getJsxLibraryManagedAttributes(ns);
|
|
if (managedSym) {
|
|
const declaredManagedType = getDeclaredTypeOfSymbol(managedSym);
|
|
const ctorType = getStaticTypeOfReferencedJsxConstructor(context);
|
|
if (managedSym.flags & 524288 /* TypeAlias */) {
|
|
const params = getSymbolLinks(managedSym).typeParameters;
|
|
if (length(params) >= 2) {
|
|
const args = fillMissingTypeArguments([ctorType, attributesType], params, 2, isInJSFile(context));
|
|
return getTypeAliasInstantiation(managedSym, args);
|
|
}
|
|
}
|
|
if (length(declaredManagedType.typeParameters) >= 2) {
|
|
const args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, isInJSFile(context));
|
|
return createTypeReference(declaredManagedType, args);
|
|
}
|
|
}
|
|
return attributesType;
|
|
}
|
|
function getJsxPropsTypeFromClassType(sig, context) {
|
|
const ns = getJsxNamespaceAt(context);
|
|
const forcedLookupLocation = getJsxElementPropertiesName(ns);
|
|
let attributesType = forcedLookupLocation === void 0 ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType) : forcedLookupLocation === "" ? getReturnTypeOfSignature(sig) : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation);
|
|
if (!attributesType) {
|
|
if (!!forcedLookupLocation && !!length(context.attributes.properties)) {
|
|
error(context, Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, unescapeLeadingUnderscores(forcedLookupLocation));
|
|
}
|
|
return unknownType;
|
|
}
|
|
attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType);
|
|
if (isTypeAny(attributesType)) {
|
|
return attributesType;
|
|
} else {
|
|
let apparentAttributesType = attributesType;
|
|
const intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context);
|
|
if (!isErrorType(intrinsicClassAttribs)) {
|
|
const typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol);
|
|
const hostClassType = getReturnTypeOfSignature(sig);
|
|
let libraryManagedAttributeType;
|
|
if (typeParams) {
|
|
const inferredArgs = fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), isInJSFile(context));
|
|
libraryManagedAttributeType = instantiateType(intrinsicClassAttribs, createTypeMapper(typeParams, inferredArgs));
|
|
} else
|
|
libraryManagedAttributeType = intrinsicClassAttribs;
|
|
apparentAttributesType = intersectTypes(libraryManagedAttributeType, apparentAttributesType);
|
|
}
|
|
const intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context);
|
|
if (!isErrorType(intrinsicAttribs)) {
|
|
apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType);
|
|
}
|
|
return apparentAttributesType;
|
|
}
|
|
}
|
|
function getIntersectedSignatures(signatures) {
|
|
return getStrictOptionValue(compilerOptions, "noImplicitAny") ? reduceLeft(
|
|
signatures,
|
|
(left, right) => left === right || !left ? left : compareTypeParametersIdentical(left.typeParameters, right.typeParameters) ? combineSignaturesOfIntersectionMembers(left, right) : void 0
|
|
) : void 0;
|
|
}
|
|
function combineIntersectionThisParam(left, right, mapper) {
|
|
if (!left || !right) {
|
|
return left || right;
|
|
}
|
|
const thisType = getUnionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]);
|
|
return createSymbolWithType(left, thisType);
|
|
}
|
|
function combineIntersectionParameters(left, right, mapper) {
|
|
const leftCount = getParameterCount(left);
|
|
const rightCount = getParameterCount(right);
|
|
const longest = leftCount >= rightCount ? left : right;
|
|
const shorter = longest === left ? right : left;
|
|
const longestCount = longest === left ? leftCount : rightCount;
|
|
const eitherHasEffectiveRest = hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right);
|
|
const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
|
|
const params = new Array(longestCount + (needsExtraRestElement ? 1 : 0));
|
|
for (let i = 0; i < longestCount; i++) {
|
|
let longestParamType = tryGetTypeAtPosition(longest, i);
|
|
if (longest === right) {
|
|
longestParamType = instantiateType(longestParamType, mapper);
|
|
}
|
|
let shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
|
|
if (shorter === right) {
|
|
shorterParamType = instantiateType(shorterParamType, mapper);
|
|
}
|
|
const unionParamType = getUnionType([longestParamType, shorterParamType]);
|
|
const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === longestCount - 1;
|
|
const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
|
|
const leftName = i >= leftCount ? void 0 : getParameterNameAtPosition(left, i);
|
|
const rightName = i >= rightCount ? void 0 : getParameterNameAtPosition(right, i);
|
|
const paramName = leftName === rightName ? leftName : !leftName ? rightName : !rightName ? leftName : void 0;
|
|
const paramSymbol = createSymbol(
|
|
1 /* FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* Optional */ : 0),
|
|
paramName || `arg${i}`
|
|
);
|
|
paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
|
|
params[i] = paramSymbol;
|
|
}
|
|
if (needsExtraRestElement) {
|
|
const 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 combineSignaturesOfIntersectionMembers(left, right) {
|
|
const typeParams = left.typeParameters || right.typeParameters;
|
|
let paramMapper;
|
|
if (left.typeParameters && right.typeParameters) {
|
|
paramMapper = createTypeMapper(right.typeParameters, left.typeParameters);
|
|
}
|
|
const declaration = left.declaration;
|
|
const params = combineIntersectionParameters(left, right, paramMapper);
|
|
const thisParam = combineIntersectionThisParam(left.thisParameter, right.thisParameter, paramMapper);
|
|
const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
|
|
const result = createSignature(
|
|
declaration,
|
|
typeParams,
|
|
thisParam,
|
|
params,
|
|
void 0,
|
|
void 0,
|
|
minArgCount,
|
|
(left.flags | right.flags) & 39 /* PropagatingFlags */
|
|
);
|
|
result.compositeKind = 2097152 /* Intersection */;
|
|
result.compositeSignatures = concatenate(left.compositeKind === 2097152 /* Intersection */ && left.compositeSignatures || [left], [right]);
|
|
if (paramMapper) {
|
|
result.mapper = left.compositeKind === 2097152 /* Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper;
|
|
}
|
|
return result;
|
|
}
|
|
function getContextualCallSignature(type, node) {
|
|
const signatures = getSignaturesOfType(type, 0 /* Call */);
|
|
const applicableByArity = filter(signatures, (s) => !isAritySmaller(s, node));
|
|
return applicableByArity.length === 1 ? applicableByArity[0] : getIntersectedSignatures(applicableByArity);
|
|
}
|
|
function isAritySmaller(signature, target) {
|
|
let targetParameterCount = 0;
|
|
for (; targetParameterCount < target.parameters.length; targetParameterCount++) {
|
|
const param = target.parameters[targetParameterCount];
|
|
if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) {
|
|
break;
|
|
}
|
|
}
|
|
if (target.parameters.length && parameterIsThisKeyword(target.parameters[0])) {
|
|
targetParameterCount--;
|
|
}
|
|
return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount;
|
|
}
|
|
function getContextualSignatureForFunctionLikeDeclaration(node) {
|
|
return isFunctionExpressionOrArrowFunction(node) || isObjectLiteralMethod(node) ? getContextualSignature(node) : void 0;
|
|
}
|
|
function getContextualSignature(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
const typeTagSignature = getSignatureOfTypeTag(node);
|
|
if (typeTagSignature) {
|
|
return typeTagSignature;
|
|
}
|
|
const type = getApparentTypeOfContextualType(node, 1 /* Signature */);
|
|
if (!type) {
|
|
return void 0;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
return getContextualCallSignature(type, node);
|
|
}
|
|
let signatureList;
|
|
const types = type.types;
|
|
for (const current of types) {
|
|
const signature = getContextualCallSignature(current, node);
|
|
if (signature) {
|
|
if (!signatureList) {
|
|
signatureList = [signature];
|
|
} else if (!compareSignaturesIdentical(signatureList[0], signature, false, true, true, compareTypesIdentical)) {
|
|
return void 0;
|
|
} else {
|
|
signatureList.push(signature);
|
|
}
|
|
}
|
|
}
|
|
if (signatureList) {
|
|
return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
|
|
}
|
|
}
|
|
function checkSpreadExpression(node, checkMode) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
|
|
}
|
|
const arrayOrIterableType = checkExpression(node.expression, checkMode);
|
|
return checkIteratedTypeOrElementType(33 /* Spread */, arrayOrIterableType, undefinedType, node.expression);
|
|
}
|
|
function checkSyntheticExpression(node) {
|
|
return node.isSpread ? getIndexedAccessType(node.type, numberType) : node.type;
|
|
}
|
|
function hasDefaultValue(node) {
|
|
return node.kind === 205 /* BindingElement */ && !!node.initializer || node.kind === 223 /* BinaryExpression */ && node.operatorToken.kind === 63 /* EqualsToken */;
|
|
}
|
|
function checkArrayLiteral(node, checkMode, forceTuple) {
|
|
const elements = node.elements;
|
|
const elementCount = elements.length;
|
|
const elementTypes = [];
|
|
const elementFlags = [];
|
|
const contextualType = getApparentTypeOfContextualType(node, void 0);
|
|
const inDestructuringPattern = isAssignmentTarget(node);
|
|
const inConstContext = isConstContext(node);
|
|
let hasOmittedExpression = false;
|
|
for (let i = 0; i < elementCount; i++) {
|
|
const e = elements[i];
|
|
if (e.kind === 227 /* SpreadElement */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
|
|
}
|
|
const spreadType = checkExpression(e.expression, checkMode, forceTuple);
|
|
if (isArrayLikeType(spreadType)) {
|
|
elementTypes.push(spreadType);
|
|
elementFlags.push(8 /* Variadic */);
|
|
} else if (inDestructuringPattern) {
|
|
const restElementType = getIndexTypeOfType(spreadType, numberType) || getIteratedTypeOrElementType(65 /* Destructuring */, spreadType, undefinedType, void 0, false) || unknownType;
|
|
elementTypes.push(restElementType);
|
|
elementFlags.push(4 /* Rest */);
|
|
} else {
|
|
elementTypes.push(checkIteratedTypeOrElementType(33 /* Spread */, spreadType, undefinedType, e.expression));
|
|
elementFlags.push(4 /* Rest */);
|
|
}
|
|
} else if (exactOptionalPropertyTypes && e.kind === 229 /* OmittedExpression */) {
|
|
hasOmittedExpression = true;
|
|
elementTypes.push(missingType);
|
|
elementFlags.push(2 /* Optional */);
|
|
} else {
|
|
const elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length);
|
|
const type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple);
|
|
elementTypes.push(addOptionality(type, true, hasOmittedExpression));
|
|
elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
|
|
if (contextualType && someType(contextualType, isTupleLikeType) && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
Debug.assert(inferenceContext);
|
|
addIntraExpressionInferenceSite(inferenceContext, e, type);
|
|
}
|
|
}
|
|
}
|
|
if (inDestructuringPattern) {
|
|
return createTupleType(elementTypes, elementFlags);
|
|
}
|
|
if (forceTuple || inConstContext || contextualType && someType(contextualType, isTupleLikeType)) {
|
|
return createArrayLiteralType(createTupleType(elementTypes, elementFlags, inConstContext));
|
|
}
|
|
return createArrayLiteralType(createArrayType(elementTypes.length ? getUnionType(sameMap(elementTypes, (t, i) => elementFlags[i] & 8 /* Variadic */ ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t), 2 /* Subtype */) : strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext));
|
|
}
|
|
function createArrayLiteralType(type) {
|
|
if (!(getObjectFlags(type) & 4 /* Reference */)) {
|
|
return type;
|
|
}
|
|
let literalType = type.literalType;
|
|
if (!literalType) {
|
|
literalType = type.literalType = cloneTypeReference(type);
|
|
literalType.objectFlags |= 16384 /* ArrayLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
}
|
|
return literalType;
|
|
}
|
|
function isNumericName(name) {
|
|
switch (name.kind) {
|
|
case 164 /* ComputedPropertyName */:
|
|
return isNumericComputedName(name);
|
|
case 79 /* Identifier */:
|
|
return isNumericLiteralName(name.escapedText);
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return isNumericLiteralName(name.text);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isNumericComputedName(name) {
|
|
return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* NumberLike */);
|
|
}
|
|
function checkComputedPropertyName(node) {
|
|
const links = getNodeLinks(node.expression);
|
|
if (!links.resolvedType) {
|
|
if ((isTypeLiteralNode(node.parent.parent) || isClassLike(node.parent.parent) || isInterfaceDeclaration(node.parent.parent)) && isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101 /* InKeyword */ && node.parent.kind !== 174 /* GetAccessor */ && node.parent.kind !== 175 /* SetAccessor */) {
|
|
return links.resolvedType = errorType;
|
|
}
|
|
links.resolvedType = checkExpression(node.expression);
|
|
if (isPropertyDeclaration(node.parent) && !hasStaticModifier(node.parent) && isClassExpression(node.parent.parent)) {
|
|
const container = getEnclosingBlockScopeContainer(node.parent.parent);
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(container);
|
|
if (enclosingIterationStatement) {
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
getNodeLinks(node).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
getNodeLinks(node.parent.parent).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
}
|
|
}
|
|
if (links.resolvedType.flags & 98304 /* Nullable */ || !isTypeAssignableToKind(links.resolvedType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */) && !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) {
|
|
error(node, Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any);
|
|
}
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isSymbolWithNumericName(symbol) {
|
|
var _a2;
|
|
const firstDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
|
|
return isNumericLiteralName(symbol.escapedName) || firstDecl && isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name);
|
|
}
|
|
function isSymbolWithSymbolName(symbol) {
|
|
var _a2;
|
|
const firstDecl = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
|
|
return isKnownSymbol(symbol) || firstDecl && isNamedDeclaration(firstDecl) && isComputedPropertyName(firstDecl.name) && isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* ESSymbol */);
|
|
}
|
|
function getObjectLiteralIndexInfo(node, offset, properties, keyType) {
|
|
const propTypes = [];
|
|
for (let i = offset; i < properties.length; i++) {
|
|
const prop = properties[i];
|
|
if (keyType === stringType && !isSymbolWithSymbolName(prop) || keyType === numberType && isSymbolWithNumericName(prop) || keyType === esSymbolType && isSymbolWithSymbolName(prop)) {
|
|
propTypes.push(getTypeOfSymbol(properties[i]));
|
|
}
|
|
}
|
|
const unionType = propTypes.length ? getUnionType(propTypes, 2 /* Subtype */) : undefinedType;
|
|
return createIndexInfo(keyType, unionType, isConstContext(node));
|
|
}
|
|
function getImmediateAliasedSymbol(symbol) {
|
|
Debug.assert((symbol.flags & 2097152 /* Alias */) !== 0, "Should only get Alias here.");
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.immediateTarget) {
|
|
const node = getDeclarationOfAliasSymbol(symbol);
|
|
if (!node)
|
|
return Debug.fail();
|
|
links.immediateTarget = getTargetOfAliasDeclaration(node, true);
|
|
}
|
|
return links.immediateTarget;
|
|
}
|
|
function checkObjectLiteral(node, checkMode) {
|
|
const inDestructuringPattern = isAssignmentTarget(node);
|
|
checkGrammarObjectLiteralExpression(node, inDestructuringPattern);
|
|
const allPropertiesTable = strictNullChecks ? createSymbolTable() : void 0;
|
|
let propertiesTable = createSymbolTable();
|
|
let propertiesArray = [];
|
|
let spread = emptyObjectType;
|
|
const contextualType = getApparentTypeOfContextualType(node, void 0);
|
|
const contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === 203 /* ObjectBindingPattern */ || contextualType.pattern.kind === 207 /* ObjectLiteralExpression */);
|
|
const inConstContext = isConstContext(node);
|
|
const checkFlags = inConstContext ? 8 /* Readonly */ : 0;
|
|
const isInJavascript = isInJSFile(node) && !isInJsonFile(node);
|
|
const enumTag = getJSDocEnumTag(node);
|
|
const isJSObjectLiteral = !contextualType && isInJavascript && !enumTag;
|
|
let objectFlags = freshObjectLiteralFlag;
|
|
let patternWithComputedProperties = false;
|
|
let hasComputedStringProperty = false;
|
|
let hasComputedNumberProperty = false;
|
|
let hasComputedSymbolProperty = false;
|
|
for (const elem of node.properties) {
|
|
if (elem.name && isComputedPropertyName(elem.name)) {
|
|
checkComputedPropertyName(elem.name);
|
|
}
|
|
}
|
|
let offset = 0;
|
|
for (const memberDecl of node.properties) {
|
|
let member = getSymbolOfNode(memberDecl);
|
|
const computedNameType = memberDecl.name && memberDecl.name.kind === 164 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
|
|
if (memberDecl.kind === 299 /* PropertyAssignment */ || memberDecl.kind === 300 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
|
|
let type = memberDecl.kind === 299 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : memberDecl.kind === 300 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode);
|
|
if (isInJavascript) {
|
|
const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
|
|
if (jsDocType) {
|
|
checkTypeAssignableTo(type, jsDocType, memberDecl);
|
|
type = jsDocType;
|
|
} else if (enumTag && enumTag.typeExpression) {
|
|
checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl);
|
|
}
|
|
}
|
|
objectFlags |= getObjectFlags(type) & 458752 /* PropagatingFlags */;
|
|
const nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : void 0;
|
|
const prop = nameType ? createSymbol(4 /* Property */ | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096 /* Late */) : createSymbol(4 /* Property */ | member.flags, member.escapedName, checkFlags);
|
|
if (nameType) {
|
|
prop.nameType = nameType;
|
|
}
|
|
if (inDestructuringPattern) {
|
|
const isOptional = memberDecl.kind === 299 /* PropertyAssignment */ && hasDefaultValue(memberDecl.initializer) || memberDecl.kind === 300 /* ShorthandPropertyAssignment */ && memberDecl.objectAssignmentInitializer;
|
|
if (isOptional) {
|
|
prop.flags |= 16777216 /* Optional */;
|
|
}
|
|
} else if (contextualTypeHasPattern && !(getObjectFlags(contextualType) & 512 /* ObjectLiteralPatternWithComputedProperties */)) {
|
|
const impliedProp = getPropertyOfType(contextualType, member.escapedName);
|
|
if (impliedProp) {
|
|
prop.flags |= impliedProp.flags & 16777216 /* Optional */;
|
|
} else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, stringType)) {
|
|
error(
|
|
memberDecl.name,
|
|
Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
|
|
symbolToString(member),
|
|
typeToString(contextualType)
|
|
);
|
|
}
|
|
}
|
|
prop.declarations = member.declarations;
|
|
prop.parent = member.parent;
|
|
if (member.valueDeclaration) {
|
|
prop.valueDeclaration = member.valueDeclaration;
|
|
}
|
|
prop.type = type;
|
|
prop.target = member;
|
|
member = prop;
|
|
allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
|
|
if (contextualType && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 299 /* PropertyAssignment */ || memberDecl.kind === 171 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
Debug.assert(inferenceContext);
|
|
const inferenceNode = memberDecl.kind === 299 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
|
|
addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
|
|
}
|
|
} else if (memberDecl.kind === 301 /* SpreadAssignment */) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(memberDecl, 2 /* Assign */);
|
|
}
|
|
if (propertiesArray.length > 0) {
|
|
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
|
|
propertiesArray = [];
|
|
propertiesTable = createSymbolTable();
|
|
hasComputedStringProperty = false;
|
|
hasComputedNumberProperty = false;
|
|
hasComputedSymbolProperty = false;
|
|
}
|
|
const type = getReducedType(checkExpression(memberDecl.expression));
|
|
if (isValidSpreadType(type)) {
|
|
const mergedType = tryMergeUnionOfObjectTypeAndEmptyObject(type, inConstContext);
|
|
if (allPropertiesTable) {
|
|
checkSpreadPropOverrides(mergedType, allPropertiesTable, memberDecl);
|
|
}
|
|
offset = propertiesArray.length;
|
|
if (isErrorType(spread)) {
|
|
continue;
|
|
}
|
|
spread = getSpreadType(spread, mergedType, node.symbol, objectFlags, inConstContext);
|
|
} else {
|
|
error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);
|
|
spread = errorType;
|
|
}
|
|
continue;
|
|
} else {
|
|
Debug.assert(memberDecl.kind === 174 /* GetAccessor */ || memberDecl.kind === 175 /* SetAccessor */);
|
|
checkNodeDeferred(memberDecl);
|
|
}
|
|
if (computedNameType && !(computedNameType.flags & 8576 /* StringOrNumberLiteralOrUnique */)) {
|
|
if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) {
|
|
if (isTypeAssignableTo(computedNameType, numberType)) {
|
|
hasComputedNumberProperty = true;
|
|
} else if (isTypeAssignableTo(computedNameType, esSymbolType)) {
|
|
hasComputedSymbolProperty = true;
|
|
} else {
|
|
hasComputedStringProperty = true;
|
|
}
|
|
if (inDestructuringPattern) {
|
|
patternWithComputedProperties = true;
|
|
}
|
|
}
|
|
} else {
|
|
propertiesTable.set(member.escapedName, member);
|
|
}
|
|
propertiesArray.push(member);
|
|
}
|
|
if (contextualTypeHasPattern) {
|
|
const rootPatternParent = findAncestor(
|
|
contextualType.pattern.parent,
|
|
(n) => n.kind === 257 /* VariableDeclaration */ || n.kind === 223 /* BinaryExpression */ || n.kind === 166 /* Parameter */
|
|
);
|
|
const spreadOrOutsideRootObject = findAncestor(
|
|
node,
|
|
(n) => n === rootPatternParent || n.kind === 301 /* SpreadAssignment */
|
|
);
|
|
if (spreadOrOutsideRootObject.kind !== 301 /* SpreadAssignment */) {
|
|
for (const prop of getPropertiesOfType(contextualType)) {
|
|
if (!propertiesTable.get(prop.escapedName) && !getPropertyOfType(spread, prop.escapedName)) {
|
|
if (!(prop.flags & 16777216 /* Optional */)) {
|
|
error(
|
|
prop.valueDeclaration || prop.bindingElement,
|
|
Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value
|
|
);
|
|
}
|
|
propertiesTable.set(prop.escapedName, prop);
|
|
propertiesArray.push(prop);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isErrorType(spread)) {
|
|
return errorType;
|
|
}
|
|
if (spread !== emptyObjectType) {
|
|
if (propertiesArray.length > 0) {
|
|
spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext);
|
|
propertiesArray = [];
|
|
propertiesTable = createSymbolTable();
|
|
hasComputedStringProperty = false;
|
|
hasComputedNumberProperty = false;
|
|
}
|
|
return mapType(spread, (t) => t === emptyObjectType ? createObjectLiteralType() : t);
|
|
}
|
|
return createObjectLiteralType();
|
|
function createObjectLiteralType() {
|
|
const indexInfos = [];
|
|
if (hasComputedStringProperty)
|
|
indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, stringType));
|
|
if (hasComputedNumberProperty)
|
|
indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, numberType));
|
|
if (hasComputedSymbolProperty)
|
|
indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, esSymbolType));
|
|
const result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, indexInfos);
|
|
result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
if (isJSObjectLiteral) {
|
|
result.objectFlags |= 4096 /* JSLiteral */;
|
|
}
|
|
if (patternWithComputedProperties) {
|
|
result.objectFlags |= 512 /* ObjectLiteralPatternWithComputedProperties */;
|
|
}
|
|
if (inDestructuringPattern) {
|
|
result.pattern = node;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function isValidSpreadType(type) {
|
|
const t = removeDefinitelyFalsyTypes(mapType(type, getBaseConstraintOrType));
|
|
return !!(t.flags & (1 /* Any */ | 67108864 /* NonPrimitive */ | 524288 /* Object */ | 58982400 /* InstantiableNonPrimitive */) || t.flags & 3145728 /* UnionOrIntersection */ && every(t.types, isValidSpreadType));
|
|
}
|
|
function checkJsxSelfClosingElementDeferred(node) {
|
|
checkJsxOpeningLikeElementOrOpeningFragment(node);
|
|
}
|
|
function checkJsxSelfClosingElement(node, _checkMode) {
|
|
checkNodeDeferred(node);
|
|
return getJsxElementTypeAt(node) || anyType;
|
|
}
|
|
function checkJsxElementDeferred(node) {
|
|
checkJsxOpeningLikeElementOrOpeningFragment(node.openingElement);
|
|
if (isJsxIntrinsicIdentifier(node.closingElement.tagName)) {
|
|
getIntrinsicTagSymbol(node.closingElement);
|
|
} else {
|
|
checkExpression(node.closingElement.tagName);
|
|
}
|
|
checkJsxChildren(node);
|
|
}
|
|
function checkJsxElement(node, _checkMode) {
|
|
checkNodeDeferred(node);
|
|
return getJsxElementTypeAt(node) || anyType;
|
|
}
|
|
function checkJsxFragment(node) {
|
|
checkJsxOpeningLikeElementOrOpeningFragment(node.openingFragment);
|
|
const nodeSourceFile = getSourceFileOfNode(node);
|
|
if (getJSXTransformEnabled(compilerOptions) && (compilerOptions.jsxFactory || nodeSourceFile.pragmas.has("jsx")) && !compilerOptions.jsxFragmentFactory && !nodeSourceFile.pragmas.has("jsxfrag")) {
|
|
error(node, compilerOptions.jsxFactory ? Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option : Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments);
|
|
}
|
|
checkJsxChildren(node);
|
|
return getJsxElementTypeAt(node) || anyType;
|
|
}
|
|
function isHyphenatedJsxName(name) {
|
|
return stringContains(name, "-");
|
|
}
|
|
function isJsxIntrinsicIdentifier(tagName) {
|
|
return tagName.kind === 79 /* Identifier */ && isIntrinsicJsxName(tagName.escapedText);
|
|
}
|
|
function checkJsxAttribute(node, checkMode) {
|
|
return node.initializer ? checkExpressionForMutableLocation(node.initializer, checkMode) : trueType;
|
|
}
|
|
function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) {
|
|
const attributes = openingLikeElement.attributes;
|
|
const attributesType = getContextualType2(attributes, 0 /* None */);
|
|
const allAttributesTable = strictNullChecks ? createSymbolTable() : void 0;
|
|
let attributesTable = createSymbolTable();
|
|
let spread = emptyJsxObjectType;
|
|
let hasSpreadAnyType = false;
|
|
let typeToIntersect;
|
|
let explicitlySpecifyChildrenAttribute = false;
|
|
let objectFlags = 2048 /* JsxAttributes */;
|
|
const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement));
|
|
for (const attributeDecl of attributes.properties) {
|
|
const member = attributeDecl.symbol;
|
|
if (isJsxAttribute(attributeDecl)) {
|
|
const exprType = checkJsxAttribute(attributeDecl, checkMode);
|
|
objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
|
|
const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
|
|
attributeSymbol.declarations = member.declarations;
|
|
attributeSymbol.parent = member.parent;
|
|
if (member.valueDeclaration) {
|
|
attributeSymbol.valueDeclaration = member.valueDeclaration;
|
|
}
|
|
attributeSymbol.type = exprType;
|
|
attributeSymbol.target = member;
|
|
attributesTable.set(attributeSymbol.escapedName, attributeSymbol);
|
|
allAttributesTable == null ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol);
|
|
if (attributeDecl.name.escapedText === jsxChildrenPropertyName) {
|
|
explicitlySpecifyChildrenAttribute = true;
|
|
}
|
|
if (attributesType) {
|
|
const prop = getPropertyOfType(attributesType, member.escapedName);
|
|
if (prop && prop.declarations && isDeprecatedSymbol(prop)) {
|
|
addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
|
|
}
|
|
}
|
|
} else {
|
|
Debug.assert(attributeDecl.kind === 290 /* JsxSpreadAttribute */);
|
|
if (attributesTable.size > 0) {
|
|
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
|
|
attributesTable = createSymbolTable();
|
|
}
|
|
const exprType = getReducedType(checkExpressionCached(attributeDecl.expression, checkMode));
|
|
if (isTypeAny(exprType)) {
|
|
hasSpreadAnyType = true;
|
|
}
|
|
if (isValidSpreadType(exprType)) {
|
|
spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, false);
|
|
if (allAttributesTable) {
|
|
checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl);
|
|
}
|
|
} else {
|
|
error(attributeDecl.expression, Diagnostics.Spread_types_may_only_be_created_from_object_types);
|
|
typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType;
|
|
}
|
|
}
|
|
}
|
|
if (!hasSpreadAnyType) {
|
|
if (attributesTable.size > 0) {
|
|
spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, false);
|
|
}
|
|
}
|
|
const parent2 = openingLikeElement.parent.kind === 281 /* JsxElement */ ? openingLikeElement.parent : void 0;
|
|
if (parent2 && parent2.openingElement === openingLikeElement && parent2.children.length > 0) {
|
|
const childrenTypes = checkJsxChildren(parent2, checkMode);
|
|
if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") {
|
|
if (explicitlySpecifyChildrenAttribute) {
|
|
error(attributes, Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, unescapeLeadingUnderscores(jsxChildrenPropertyName));
|
|
}
|
|
const contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, void 0);
|
|
const childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
|
|
const childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
|
|
childrenPropSymbol.type = childrenTypes.length === 1 ? childrenTypes[0] : childrenContextualType && someType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) : createArrayType(getUnionType(childrenTypes));
|
|
childrenPropSymbol.valueDeclaration = factory.createPropertySignature(void 0, unescapeLeadingUnderscores(jsxChildrenPropertyName), void 0, void 0);
|
|
setParent(childrenPropSymbol.valueDeclaration, attributes);
|
|
childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol;
|
|
const childPropMap = createSymbolTable();
|
|
childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
|
|
spread = getSpreadType(
|
|
spread,
|
|
createAnonymousType(attributes.symbol, childPropMap, emptyArray, emptyArray, emptyArray),
|
|
attributes.symbol,
|
|
objectFlags,
|
|
false
|
|
);
|
|
}
|
|
}
|
|
if (hasSpreadAnyType) {
|
|
return anyType;
|
|
}
|
|
if (typeToIntersect && spread !== emptyJsxObjectType) {
|
|
return getIntersectionType([typeToIntersect, spread]);
|
|
}
|
|
return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread);
|
|
function createJsxAttributesType() {
|
|
objectFlags |= freshObjectLiteralFlag;
|
|
const result = createAnonymousType(attributes.symbol, attributesTable, emptyArray, emptyArray, emptyArray);
|
|
result.objectFlags |= objectFlags | 128 /* ObjectLiteral */ | 131072 /* ContainsObjectOrArrayLiteral */;
|
|
return result;
|
|
}
|
|
}
|
|
function checkJsxChildren(node, checkMode) {
|
|
const childrenTypes = [];
|
|
for (const child of node.children) {
|
|
if (child.kind === 11 /* JsxText */) {
|
|
if (!child.containsOnlyTriviaWhiteSpaces) {
|
|
childrenTypes.push(stringType);
|
|
}
|
|
} else if (child.kind === 291 /* JsxExpression */ && !child.expression) {
|
|
continue;
|
|
} else {
|
|
childrenTypes.push(checkExpressionForMutableLocation(child, checkMode));
|
|
}
|
|
}
|
|
return childrenTypes;
|
|
}
|
|
function checkSpreadPropOverrides(type, props, spread) {
|
|
for (const right of getPropertiesOfType(type)) {
|
|
if (!(right.flags & 16777216 /* Optional */)) {
|
|
const left = props.get(right.escapedName);
|
|
if (left) {
|
|
const diagnostic = error(left.valueDeclaration, Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, unescapeLeadingUnderscores(left.escapedName));
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(spread, Diagnostics.This_spread_always_overwrites_this_property));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkJsxAttributes(node, checkMode) {
|
|
return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode);
|
|
}
|
|
function getJsxType(name, location2) {
|
|
const namespace = getJsxNamespaceAt(location2);
|
|
const exports = namespace && getExportsOfSymbol(namespace);
|
|
const typeSymbol = exports && getSymbol2(exports, name, 788968 /* Type */);
|
|
return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType;
|
|
}
|
|
function getIntrinsicTagSymbol(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedSymbol) {
|
|
const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node);
|
|
if (!isErrorType(intrinsicElementsType)) {
|
|
if (!isIdentifier(node.tagName))
|
|
return Debug.fail();
|
|
const intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText);
|
|
if (intrinsicProp) {
|
|
links.jsxFlags |= 1 /* IntrinsicNamedElement */;
|
|
return links.resolvedSymbol = intrinsicProp;
|
|
}
|
|
const indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType);
|
|
if (indexSignatureType) {
|
|
links.jsxFlags |= 2 /* IntrinsicIndexedElement */;
|
|
return links.resolvedSymbol = intrinsicElementsType.symbol;
|
|
}
|
|
error(node, Diagnostics.Property_0_does_not_exist_on_type_1, idText(node.tagName), "JSX." + JsxNames.IntrinsicElements);
|
|
return links.resolvedSymbol = unknownSymbol;
|
|
} else {
|
|
if (noImplicitAny) {
|
|
error(node, Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, unescapeLeadingUnderscores(JsxNames.IntrinsicElements));
|
|
}
|
|
return links.resolvedSymbol = unknownSymbol;
|
|
}
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function getJsxNamespaceContainerForImplicitImport(location2) {
|
|
const file = location2 && getSourceFileOfNode(location2);
|
|
const links = file && getNodeLinks(file);
|
|
if (links && links.jsxImplicitImportContainer === false) {
|
|
return void 0;
|
|
}
|
|
if (links && links.jsxImplicitImportContainer) {
|
|
return links.jsxImplicitImportContainer;
|
|
}
|
|
const runtimeImportSpecifier = getJSXRuntimeImport(getJSXImplicitImportBase(compilerOptions, file), compilerOptions);
|
|
if (!runtimeImportSpecifier) {
|
|
return void 0;
|
|
}
|
|
const isClassic = getEmitModuleResolutionKind(compilerOptions) === 1 /* Classic */;
|
|
const errorMessage = isClassic ? Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option : Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations;
|
|
const mod = resolveExternalModule(location2, runtimeImportSpecifier, errorMessage, location2);
|
|
const result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : void 0;
|
|
if (links) {
|
|
links.jsxImplicitImportContainer = result || false;
|
|
}
|
|
return result;
|
|
}
|
|
function getJsxNamespaceAt(location2) {
|
|
const links = location2 && getNodeLinks(location2);
|
|
if (links && links.jsxNamespace) {
|
|
return links.jsxNamespace;
|
|
}
|
|
if (!links || links.jsxNamespace !== false) {
|
|
let resolvedNamespace = getJsxNamespaceContainerForImplicitImport(location2);
|
|
if (!resolvedNamespace || resolvedNamespace === unknownSymbol) {
|
|
const namespaceName = getJsxNamespace(location2);
|
|
resolvedNamespace = resolveName(location2, namespaceName, 1920 /* Namespace */, void 0, namespaceName, false);
|
|
}
|
|
if (resolvedNamespace) {
|
|
const candidate = resolveSymbol(getSymbol2(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920 /* Namespace */));
|
|
if (candidate && candidate !== unknownSymbol) {
|
|
if (links) {
|
|
links.jsxNamespace = candidate;
|
|
}
|
|
return candidate;
|
|
}
|
|
}
|
|
if (links) {
|
|
links.jsxNamespace = false;
|
|
}
|
|
}
|
|
const s = resolveSymbol(getGlobalSymbol(JsxNames.JSX, 1920 /* Namespace */, void 0));
|
|
if (s === unknownSymbol) {
|
|
return void 0;
|
|
}
|
|
return s;
|
|
}
|
|
function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) {
|
|
const jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol2(jsxNamespace.exports, nameOfAttribPropContainer, 788968 /* Type */);
|
|
const jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym);
|
|
const propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType);
|
|
if (propertiesOfJsxElementAttribPropInterface) {
|
|
if (propertiesOfJsxElementAttribPropInterface.length === 0) {
|
|
return "";
|
|
} else if (propertiesOfJsxElementAttribPropInterface.length === 1) {
|
|
return propertiesOfJsxElementAttribPropInterface[0].escapedName;
|
|
} else if (propertiesOfJsxElementAttribPropInterface.length > 1 && jsxElementAttribPropInterfaceSym.declarations) {
|
|
error(jsxElementAttribPropInterfaceSym.declarations[0], Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, unescapeLeadingUnderscores(nameOfAttribPropContainer));
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getJsxLibraryManagedAttributes(jsxNamespace) {
|
|
return jsxNamespace && getSymbol2(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* Type */);
|
|
}
|
|
function getJsxElementPropertiesName(jsxNamespace) {
|
|
return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace);
|
|
}
|
|
function getJsxElementChildrenPropertyName(jsxNamespace) {
|
|
return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace);
|
|
}
|
|
function getUninstantiatedJsxSignaturesOfType(elementType, caller) {
|
|
if (elementType.flags & 4 /* String */) {
|
|
return [anySignature];
|
|
} else if (elementType.flags & 128 /* StringLiteral */) {
|
|
const intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller);
|
|
if (!intrinsicType) {
|
|
error(caller, Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements);
|
|
return emptyArray;
|
|
} else {
|
|
const fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType);
|
|
return [fakeSignature];
|
|
}
|
|
}
|
|
const apparentElemType = getApparentType(elementType);
|
|
let signatures = getSignaturesOfType(apparentElemType, 1 /* Construct */);
|
|
if (signatures.length === 0) {
|
|
signatures = getSignaturesOfType(apparentElemType, 0 /* Call */);
|
|
}
|
|
if (signatures.length === 0 && apparentElemType.flags & 1048576 /* Union */) {
|
|
signatures = getUnionSignatures(map(apparentElemType.types, (t) => getUninstantiatedJsxSignaturesOfType(t, caller)));
|
|
}
|
|
return signatures;
|
|
}
|
|
function getIntrinsicAttributesTypeFromStringLiteralType(type, location2) {
|
|
const intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location2);
|
|
if (!isErrorType(intrinsicElementsType)) {
|
|
const stringLiteralTypeName = type.value;
|
|
const intrinsicProp = getPropertyOfType(intrinsicElementsType, escapeLeadingUnderscores(stringLiteralTypeName));
|
|
if (intrinsicProp) {
|
|
return getTypeOfSymbol(intrinsicProp);
|
|
}
|
|
const indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType);
|
|
if (indexSignatureType) {
|
|
return indexSignatureType;
|
|
}
|
|
return void 0;
|
|
}
|
|
return anyType;
|
|
}
|
|
function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) {
|
|
if (refKind === 1 /* Function */) {
|
|
const sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
|
|
if (sfcReturnConstraint) {
|
|
checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
} else if (refKind === 0 /* Component */) {
|
|
const classConstraint = getJsxElementClassTypeAt(openingLikeElement);
|
|
if (classConstraint) {
|
|
checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
} else {
|
|
const sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement);
|
|
const classConstraint = getJsxElementClassTypeAt(openingLikeElement);
|
|
if (!sfcReturnConstraint || !classConstraint) {
|
|
return;
|
|
}
|
|
const combined = getUnionType([sfcReturnConstraint, classConstraint]);
|
|
checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement.tagName, Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain);
|
|
}
|
|
function generateInitialErrorChain() {
|
|
const componentName = getTextOfNode(openingLikeElement.tagName);
|
|
return chainDiagnosticMessages(void 0, Diagnostics._0_cannot_be_used_as_a_JSX_component, componentName);
|
|
}
|
|
}
|
|
function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) {
|
|
Debug.assert(isJsxIntrinsicIdentifier(node.tagName));
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedJsxElementAttributesType) {
|
|
const symbol = getIntrinsicTagSymbol(node);
|
|
if (links.jsxFlags & 1 /* IntrinsicNamedElement */) {
|
|
return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol) || errorType;
|
|
} else if (links.jsxFlags & 2 /* IntrinsicIndexedElement */) {
|
|
return links.resolvedJsxElementAttributesType = getIndexTypeOfType(getJsxType(JsxNames.IntrinsicElements, node), stringType) || errorType;
|
|
} else {
|
|
return links.resolvedJsxElementAttributesType = errorType;
|
|
}
|
|
}
|
|
return links.resolvedJsxElementAttributesType;
|
|
}
|
|
function getJsxElementClassTypeAt(location2) {
|
|
const type = getJsxType(JsxNames.ElementClass, location2);
|
|
if (isErrorType(type))
|
|
return void 0;
|
|
return type;
|
|
}
|
|
function getJsxElementTypeAt(location2) {
|
|
return getJsxType(JsxNames.Element, location2);
|
|
}
|
|
function getJsxStatelessElementTypeAt(location2) {
|
|
const jsxElementType = getJsxElementTypeAt(location2);
|
|
if (jsxElementType) {
|
|
return getUnionType([jsxElementType, nullType]);
|
|
}
|
|
}
|
|
function getJsxIntrinsicTagNamesAt(location2) {
|
|
const intrinsics = getJsxType(JsxNames.IntrinsicElements, location2);
|
|
return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
|
|
}
|
|
function checkJsxPreconditions(errorNode) {
|
|
if ((compilerOptions.jsx || 0 /* None */) === 0 /* None */) {
|
|
error(errorNode, Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
|
|
}
|
|
if (getJsxElementTypeAt(errorNode) === void 0) {
|
|
if (noImplicitAny) {
|
|
error(errorNode, Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist);
|
|
}
|
|
}
|
|
}
|
|
function checkJsxOpeningLikeElementOrOpeningFragment(node) {
|
|
const isNodeOpeningLikeElement = isJsxOpeningLikeElement(node);
|
|
if (isNodeOpeningLikeElement) {
|
|
checkGrammarJsxElement(node);
|
|
}
|
|
checkJsxPreconditions(node);
|
|
if (!getJsxNamespaceContainerForImplicitImport(node)) {
|
|
const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
|
|
const jsxFactoryNamespace = getJsxNamespace(node);
|
|
const jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
|
|
let jsxFactorySym;
|
|
if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
|
|
jsxFactorySym = resolveName(jsxFactoryLocation, jsxFactoryNamespace, 111551 /* Value */, jsxFactoryRefErr, jsxFactoryNamespace, true);
|
|
}
|
|
if (jsxFactorySym) {
|
|
jsxFactorySym.isReferenced = 67108863 /* All */;
|
|
if (jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
|
|
markAliasSymbolAsReferenced(jsxFactorySym);
|
|
}
|
|
}
|
|
if (isJsxOpeningFragment(node)) {
|
|
const file = getSourceFileOfNode(node);
|
|
const localJsxNamespace = getLocalJsxNamespace(file);
|
|
if (localJsxNamespace) {
|
|
resolveName(jsxFactoryLocation, localJsxNamespace, 111551 /* Value */, jsxFactoryRefErr, localJsxNamespace, true);
|
|
}
|
|
}
|
|
}
|
|
if (isNodeOpeningLikeElement) {
|
|
const jsxOpeningLikeNode = node;
|
|
const sig = getResolvedSignature(jsxOpeningLikeNode);
|
|
checkDeprecatedSignature(sig, node);
|
|
checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode);
|
|
}
|
|
}
|
|
function isKnownProperty(targetType, name, isComparingJsxAttributes) {
|
|
if (targetType.flags & 524288 /* Object */) {
|
|
if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
|
|
return true;
|
|
}
|
|
} else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
|
|
for (const t of targetType.types) {
|
|
if (isKnownProperty(t, name, isComparingJsxAttributes)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isExcessPropertyCheckTarget(type) {
|
|
return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
|
|
}
|
|
function checkJsxExpression(node, checkMode) {
|
|
checkGrammarJsxExpression(node);
|
|
if (node.expression) {
|
|
const type = checkExpression(node.expression, checkMode);
|
|
if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) {
|
|
error(node, Diagnostics.JSX_spread_child_must_be_an_array_type);
|
|
}
|
|
return type;
|
|
} else {
|
|
return errorType;
|
|
}
|
|
}
|
|
function getDeclarationNodeFlagsFromSymbol(s) {
|
|
return s.valueDeclaration ? getCombinedNodeFlags(s.valueDeclaration) : 0;
|
|
}
|
|
function isPrototypeProperty(symbol) {
|
|
if (symbol.flags & 8192 /* Method */ || getCheckFlags(symbol) & 4 /* SyntheticMethod */) {
|
|
return true;
|
|
}
|
|
if (isInJSFile(symbol.valueDeclaration)) {
|
|
const parent2 = symbol.valueDeclaration.parent;
|
|
return parent2 && isBinaryExpression(parent2) && getAssignmentDeclarationKind(parent2) === 3 /* PrototypeProperty */;
|
|
}
|
|
}
|
|
function checkPropertyAccessibility(node, isSuper, writing, type, prop, reportError = true) {
|
|
const errorNode = !reportError ? void 0 : node.kind === 163 /* QualifiedName */ ? node.right : node.kind === 202 /* ImportType */ ? node : node.kind === 205 /* BindingElement */ && node.propertyName ? node.propertyName : node.name;
|
|
return checkPropertyAccessibilityAtLocation(node, isSuper, writing, type, prop, errorNode);
|
|
}
|
|
function checkPropertyAccessibilityAtLocation(location2, isSuper, writing, containingType, prop, errorNode) {
|
|
const flags = getDeclarationModifierFlagsFromSymbol(prop, writing);
|
|
if (isSuper) {
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
if (symbolHasNonMethodDeclaration(prop)) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 256 /* Abstract */) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop))
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 256 /* Abstract */ && symbolHasNonMethodDeclaration(prop) && (isThisProperty(location2) || isThisInitializedObjectBindingExpression(location2) || isObjectBindingPattern(location2.parent) && isThisInitializedDeclaration(location2.parent.parent))) {
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
|
|
if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(location2)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor,
|
|
symbolToString(prop),
|
|
getTextOfIdentifierOrLiteral(declaringClassDeclaration.name)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (!(flags & 24 /* NonPublicAccessibilityModifier */)) {
|
|
return true;
|
|
}
|
|
if (flags & 8 /* Private */) {
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop));
|
|
if (!isNodeWithinClass(location2, declaringClassDeclaration)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Property_0_is_private_and_only_accessible_within_class_1,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop))
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (isSuper) {
|
|
return true;
|
|
}
|
|
let enclosingClass = forEachEnclosingClass(location2, (enclosingDeclaration) => {
|
|
const enclosingClass2 = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration));
|
|
return isClassDerivedFromDeclaringClasses(enclosingClass2, prop, writing);
|
|
});
|
|
if (!enclosingClass) {
|
|
enclosingClass = getEnclosingClassFromThisParameter(location2);
|
|
enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing);
|
|
if (flags & 32 /* Static */ || !enclosingClass) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses,
|
|
symbolToString(prop),
|
|
typeToString(getDeclaringClass(prop) || containingType)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (flags & 32 /* Static */) {
|
|
return true;
|
|
}
|
|
if (containingType.flags & 262144 /* TypeParameter */) {
|
|
containingType = containingType.isThisType ? getConstraintOfTypeParameter(containingType) : getBaseConstraintOfType(containingType);
|
|
}
|
|
if (!containingType || !hasBaseType(containingType, enclosingClass)) {
|
|
if (errorNode) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2,
|
|
symbolToString(prop),
|
|
typeToString(enclosingClass),
|
|
typeToString(containingType)
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getEnclosingClassFromThisParameter(node) {
|
|
const thisParameter = getThisParameterFromNodeContext(node);
|
|
let thisType = (thisParameter == null ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type);
|
|
if (thisType && thisType.flags & 262144 /* TypeParameter */) {
|
|
thisType = getConstraintOfTypeParameter(thisType);
|
|
}
|
|
if (thisType && getObjectFlags(thisType) & (3 /* ClassOrInterface */ | 4 /* Reference */)) {
|
|
return getTargetType(thisType);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getThisParameterFromNodeContext(node) {
|
|
const thisContainer = getThisContainer(node, false);
|
|
return thisContainer && isFunctionLike(thisContainer) ? getThisParameter(thisContainer) : void 0;
|
|
}
|
|
function symbolHasNonMethodDeclaration(symbol) {
|
|
return !!forEachProperty2(symbol, (prop) => !(prop.flags & 8192 /* Method */));
|
|
}
|
|
function checkNonNullExpression(node) {
|
|
return checkNonNullType(checkExpression(node), node);
|
|
}
|
|
function isNullableType(type) {
|
|
return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
|
|
}
|
|
function getNonNullableTypeIfNeeded(type) {
|
|
return isNullableType(type) ? getNonNullableType(type) : type;
|
|
}
|
|
function reportObjectPossiblyNullOrUndefinedError(node, facts) {
|
|
const nodeText2 = isEntityNameExpression(node) ? entityNameToString(node) : void 0;
|
|
if (node.kind === 104 /* NullKeyword */) {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, "null");
|
|
return;
|
|
}
|
|
if (nodeText2 !== void 0 && nodeText2.length < 100) {
|
|
if (isIdentifier(node) && nodeText2 === "undefined") {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, "undefined");
|
|
return;
|
|
}
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics._0_is_possibly_null_or_undefined : Diagnostics._0_is_possibly_undefined : Diagnostics._0_is_possibly_null,
|
|
nodeText2
|
|
);
|
|
} else {
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics.Object_is_possibly_null_or_undefined : Diagnostics.Object_is_possibly_undefined : Diagnostics.Object_is_possibly_null
|
|
);
|
|
}
|
|
}
|
|
function reportCannotInvokePossiblyNullOrUndefinedError(node, facts) {
|
|
error(
|
|
node,
|
|
facts & 16777216 /* IsUndefined */ ? facts & 33554432 /* IsNull */ ? Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined : Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined : Diagnostics.Cannot_invoke_an_object_which_is_possibly_null
|
|
);
|
|
}
|
|
function checkNonNullTypeWithReporter(type, node, reportError) {
|
|
if (strictNullChecks && type.flags & 2 /* Unknown */) {
|
|
if (isEntityNameExpression(node)) {
|
|
const nodeText2 = entityNameToString(node);
|
|
if (nodeText2.length < 100) {
|
|
error(node, Diagnostics._0_is_of_type_unknown, nodeText2);
|
|
return errorType;
|
|
}
|
|
}
|
|
error(node, Diagnostics.Object_is_of_type_unknown);
|
|
return errorType;
|
|
}
|
|
const facts = getTypeFacts(type);
|
|
if (facts & 50331648 /* IsUndefinedOrNull */) {
|
|
reportError(node, facts);
|
|
const t = getNonNullableType(type);
|
|
return t.flags & (98304 /* Nullable */ | 131072 /* Never */) ? errorType : t;
|
|
}
|
|
return type;
|
|
}
|
|
function checkNonNullType(type, node) {
|
|
return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError);
|
|
}
|
|
function checkNonNullNonVoidType(type, node) {
|
|
const nonNullType = checkNonNullType(type, node);
|
|
if (nonNullType.flags & 16384 /* Void */) {
|
|
if (isEntityNameExpression(node)) {
|
|
const nodeText2 = entityNameToString(node);
|
|
if (isIdentifier(node) && nodeText2 === "undefined") {
|
|
error(node, Diagnostics.The_value_0_cannot_be_used_here, nodeText2);
|
|
return nonNullType;
|
|
}
|
|
if (nodeText2.length < 100) {
|
|
error(node, Diagnostics._0_is_possibly_undefined, nodeText2);
|
|
return nonNullType;
|
|
}
|
|
}
|
|
error(node, Diagnostics.Object_is_possibly_undefined);
|
|
}
|
|
return nonNullType;
|
|
}
|
|
function checkPropertyAccessExpression(node, checkMode) {
|
|
return node.flags & 32 /* OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode);
|
|
}
|
|
function checkPropertyAccessChain(node, checkMode) {
|
|
const leftType = checkExpression(node.expression);
|
|
const nonOptionalType = getOptionalExpressionType(leftType, node.expression);
|
|
return propagateOptionalTypeMarker(checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullType(nonOptionalType, node.expression), node.name, checkMode), node, nonOptionalType !== leftType);
|
|
}
|
|
function checkQualifiedName(node, checkMode) {
|
|
const leftType = isPartOfTypeQuery(node) && isThisIdentifier(node.left) ? checkNonNullType(checkThisExpression(node.left), node.left) : checkNonNullExpression(node.left);
|
|
return checkPropertyAccessExpressionOrQualifiedName(node, node.left, leftType, node.right, checkMode);
|
|
}
|
|
function isMethodAccessForCall(node) {
|
|
while (node.parent.kind === 214 /* ParenthesizedExpression */) {
|
|
node = node.parent;
|
|
}
|
|
return isCallOrNewExpression(node.parent) && node.parent.expression === node;
|
|
}
|
|
function lookupSymbolForPrivateIdentifierDeclaration(propName, location2) {
|
|
for (let containingClass = getContainingClass(location2); !!containingClass; containingClass = getContainingClass(containingClass)) {
|
|
const { symbol } = containingClass;
|
|
const name = getSymbolNameForPrivateIdentifier(symbol, propName);
|
|
const prop = symbol.members && symbol.members.get(name) || symbol.exports && symbol.exports.get(name);
|
|
if (prop) {
|
|
return prop;
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarPrivateIdentifierExpression(privId) {
|
|
if (!getContainingClass(privId)) {
|
|
return grammarErrorOnNode(privId, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
if (!isForInStatement(privId.parent)) {
|
|
if (!isExpressionNode(privId)) {
|
|
return grammarErrorOnNode(privId, Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression);
|
|
}
|
|
const isInOperation = isBinaryExpression(privId.parent) && privId.parent.operatorToken.kind === 101 /* InKeyword */;
|
|
if (!getSymbolForPrivateIdentifierExpression(privId) && !isInOperation) {
|
|
return grammarErrorOnNode(privId, Diagnostics.Cannot_find_name_0, idText(privId));
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkPrivateIdentifierExpression(privId) {
|
|
checkGrammarPrivateIdentifierExpression(privId);
|
|
const symbol = getSymbolForPrivateIdentifierExpression(privId);
|
|
if (symbol) {
|
|
markPropertyAsReferenced(symbol, void 0, false);
|
|
}
|
|
return anyType;
|
|
}
|
|
function getSymbolForPrivateIdentifierExpression(privId) {
|
|
if (!isExpressionNode(privId)) {
|
|
return void 0;
|
|
}
|
|
const links = getNodeLinks(privId);
|
|
if (links.resolvedSymbol === void 0) {
|
|
links.resolvedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privId.escapedText, privId);
|
|
}
|
|
return links.resolvedSymbol;
|
|
}
|
|
function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) {
|
|
return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
|
|
}
|
|
function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) {
|
|
let propertyOnType;
|
|
const properties = getPropertiesOfType(leftType);
|
|
if (properties) {
|
|
forEach(properties, (symbol) => {
|
|
const decl = symbol.valueDeclaration;
|
|
if (decl && isNamedDeclaration(decl) && isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) {
|
|
propertyOnType = symbol;
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
const diagName = diagnosticName(right);
|
|
if (propertyOnType) {
|
|
const typeValueDecl = Debug.checkDefined(propertyOnType.valueDeclaration);
|
|
const typeClass = Debug.checkDefined(getContainingClass(typeValueDecl));
|
|
if (lexicallyScopedIdentifier == null ? void 0 : lexicallyScopedIdentifier.valueDeclaration) {
|
|
const lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration;
|
|
const lexicalClass = getContainingClass(lexicalValueDecl);
|
|
Debug.assert(!!lexicalClass);
|
|
if (findAncestor(lexicalClass, (n) => typeClass === n)) {
|
|
const diagnostic = error(
|
|
right,
|
|
Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling,
|
|
diagName,
|
|
typeToString(leftType)
|
|
);
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(
|
|
lexicalValueDecl,
|
|
Diagnostics.The_shadowing_declaration_of_0_is_defined_here,
|
|
diagName
|
|
),
|
|
createDiagnosticForNode(
|
|
typeValueDecl,
|
|
Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here,
|
|
diagName
|
|
)
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
error(
|
|
right,
|
|
Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier,
|
|
diagName,
|
|
diagnosticName(typeClass.name || anon)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isThisPropertyAccessInConstructor(node, prop) {
|
|
return (isConstructorDeclaredProperty(prop) || isThisProperty(node) && isAutoTypedProperty(prop)) && getThisContainer(node, true) === getDeclaringConstructor(prop);
|
|
}
|
|
function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode) {
|
|
const parentSymbol = getNodeLinks(left).resolvedSymbol;
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType);
|
|
const isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
|
|
let prop;
|
|
if (isPrivateIdentifier(right)) {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
if (assignmentKind !== 0 /* None */) {
|
|
checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldSet */);
|
|
}
|
|
if (assignmentKind !== 1 /* Definite */) {
|
|
checkExternalEmitHelpers(node, 524288 /* ClassPrivateFieldGet */);
|
|
}
|
|
}
|
|
const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
|
|
if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
|
|
grammarErrorOnNode(right, Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, idText(right));
|
|
}
|
|
if (isAnyLike) {
|
|
if (lexicallyScopedSymbol) {
|
|
return isErrorType(apparentType) ? errorType : apparentType;
|
|
}
|
|
if (!getContainingClass(right)) {
|
|
grammarErrorOnNode(right, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
return anyType;
|
|
}
|
|
}
|
|
prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : void 0;
|
|
if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) {
|
|
return errorType;
|
|
} else {
|
|
const isSetonlyAccessor = prop && prop.flags & 65536 /* SetAccessor */ && !(prop.flags & 32768 /* GetAccessor */);
|
|
if (isSetonlyAccessor && assignmentKind !== 1 /* Definite */) {
|
|
error(node, Diagnostics.Private_accessor_was_defined_without_a_getter);
|
|
}
|
|
}
|
|
} else {
|
|
if (isAnyLike) {
|
|
if (isIdentifier(left) && parentSymbol) {
|
|
markAliasReferenced(parentSymbol, node);
|
|
}
|
|
return isErrorType(apparentType) ? errorType : apparentType;
|
|
}
|
|
prop = getPropertyOfType(apparentType, right.escapedText, false, node.kind === 163 /* QualifiedName */);
|
|
}
|
|
if (isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 302 /* EnumMember */)) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
|
|
markAliasReferenced(parentSymbol, node);
|
|
}
|
|
let propType;
|
|
if (!prop) {
|
|
const indexInfo = !isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getApplicableIndexInfoForName(apparentType, right.escapedText) : void 0;
|
|
if (!(indexInfo && indexInfo.type)) {
|
|
const isUncheckedJS = isUncheckedJSSuggestion(node, leftType.symbol, true);
|
|
if (!isUncheckedJS && isJSLiteralType(leftType)) {
|
|
return anyType;
|
|
}
|
|
if (leftType.symbol === globalThisSymbol) {
|
|
if (globalThisSymbol.exports.has(right.escapedText) && globalThisSymbol.exports.get(right.escapedText).flags & 418 /* BlockScoped */) {
|
|
error(right, Diagnostics.Property_0_does_not_exist_on_type_1, unescapeLeadingUnderscores(right.escapedText), typeToString(leftType));
|
|
} else if (noImplicitAny) {
|
|
error(right, Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType));
|
|
}
|
|
return anyType;
|
|
}
|
|
if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) {
|
|
reportNonexistentProperty(right, isThisTypeParameter(leftType) ? apparentType : leftType, isUncheckedJS);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
|
|
error(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
|
|
}
|
|
propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type;
|
|
if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
|
|
error(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
|
|
}
|
|
if (indexInfo.declaration && getCombinedNodeFlags(indexInfo.declaration) & 268435456 /* Deprecated */) {
|
|
addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText);
|
|
}
|
|
} else {
|
|
if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) {
|
|
addDeprecatedSuggestion(right, prop.declarations, right.escapedText);
|
|
}
|
|
checkPropertyNotUsedBeforeDeclaration(prop, node, right);
|
|
markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol));
|
|
getNodeLinks(node).resolvedSymbol = prop;
|
|
const writing = isWriteAccess(node);
|
|
checkPropertyAccessibility(node, left.kind === 106 /* SuperKeyword */, writing, apparentType, prop);
|
|
if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) {
|
|
error(right, Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, idText(right));
|
|
return errorType;
|
|
}
|
|
propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop);
|
|
}
|
|
return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode);
|
|
}
|
|
function isUncheckedJSSuggestion(node, suggestion, excludeClasses) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (file) {
|
|
if (compilerOptions.checkJs === void 0 && file.checkJsDirective === void 0 && (file.scriptKind === 1 /* JS */ || file.scriptKind === 2 /* JSX */)) {
|
|
const declarationFile = forEach(suggestion == null ? void 0 : suggestion.declarations, getSourceFileOfNode);
|
|
return !(file !== declarationFile && !!declarationFile && isGlobalSourceFile(declarationFile)) && !(excludeClasses && suggestion && suggestion.flags & 32 /* Class */) && !(!!node && excludeClasses && isPropertyAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getFlowTypeOfAccessExpression(node, prop, propType, errorNode, checkMode) {
|
|
const assignmentKind = getAssignmentTargetKind(node);
|
|
if (assignmentKind === 1 /* Definite */) {
|
|
return removeMissingType(propType, !!(prop && prop.flags & 16777216 /* Optional */));
|
|
}
|
|
if (prop && !(prop.flags & (3 /* Variable */ | 4 /* Property */ | 98304 /* Accessor */)) && !(prop.flags & 8192 /* Method */ && propType.flags & 1048576 /* Union */) && !isDuplicatedCommonJSExport(prop.declarations)) {
|
|
return propType;
|
|
}
|
|
if (propType === autoType) {
|
|
return getFlowTypeOfProperty(node, prop);
|
|
}
|
|
propType = getNarrowableTypeForReference(propType, node, checkMode);
|
|
let assumeUninitialized = false;
|
|
if (strictNullChecks && strictPropertyInitialization && isAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */) {
|
|
const declaration = prop && prop.valueDeclaration;
|
|
if (declaration && isPropertyWithoutInitializer(declaration)) {
|
|
if (!isStatic(declaration)) {
|
|
const flowContainer = getControlFlowContainer(node);
|
|
if (flowContainer.kind === 173 /* Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
assumeUninitialized = true;
|
|
}
|
|
}
|
|
}
|
|
} else if (strictNullChecks && prop && prop.valueDeclaration && isPropertyAccessExpression(prop.valueDeclaration) && getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) && getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) {
|
|
assumeUninitialized = true;
|
|
}
|
|
const flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType);
|
|
if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) {
|
|
error(errorNode, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop));
|
|
return propType;
|
|
}
|
|
return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
|
|
}
|
|
function checkPropertyNotUsedBeforeDeclaration(prop, node, right) {
|
|
const { valueDeclaration } = prop;
|
|
if (!valueDeclaration || getSourceFileOfNode(node).isDeclarationFile) {
|
|
return;
|
|
}
|
|
let diagnosticMessage;
|
|
const declarationName = idText(right);
|
|
if (isInPropertyInitializerOrClassStaticBlock(node) && !isOptionalPropertyDeclaration(valueDeclaration) && !(isAccessExpression(node) && isAccessExpression(node.expression)) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) && !(isMethodDeclaration(valueDeclaration) && getCombinedModifierFlags(valueDeclaration) & 32 /* Static */) && (compilerOptions.useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) {
|
|
diagnosticMessage = error(right, Diagnostics.Property_0_is_used_before_its_initialization, declarationName);
|
|
} else if (valueDeclaration.kind === 260 /* ClassDeclaration */ && node.parent.kind !== 180 /* TypeReference */ && !(valueDeclaration.flags & 16777216 /* Ambient */) && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) {
|
|
diagnosticMessage = error(right, Diagnostics.Class_0_used_before_its_declaration, declarationName);
|
|
}
|
|
if (diagnosticMessage) {
|
|
addRelatedInfo(
|
|
diagnosticMessage,
|
|
createDiagnosticForNode(valueDeclaration, Diagnostics._0_is_declared_here, declarationName)
|
|
);
|
|
}
|
|
}
|
|
function isInPropertyInitializerOrClassStaticBlock(node) {
|
|
return !!findAncestor(node, (node2) => {
|
|
switch (node2.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
case 299 /* PropertyAssignment */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 301 /* SpreadAssignment */:
|
|
case 164 /* ComputedPropertyName */:
|
|
case 236 /* TemplateSpan */:
|
|
case 291 /* JsxExpression */:
|
|
case 288 /* JsxAttribute */:
|
|
case 289 /* JsxAttributes */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 294 /* HeritageClause */:
|
|
return false;
|
|
case 216 /* ArrowFunction */:
|
|
case 241 /* ExpressionStatement */:
|
|
return isBlock(node2.parent) && isClassStaticBlockDeclaration(node2.parent.parent) ? true : "quit";
|
|
default:
|
|
return isExpressionNode(node2) ? false : "quit";
|
|
}
|
|
});
|
|
}
|
|
function isPropertyDeclaredInAncestorClass(prop) {
|
|
if (!(prop.parent.flags & 32 /* Class */)) {
|
|
return false;
|
|
}
|
|
let classType = getTypeOfSymbol(prop.parent);
|
|
while (true) {
|
|
classType = classType.symbol && getSuperClass(classType);
|
|
if (!classType) {
|
|
return false;
|
|
}
|
|
const superProperty = getPropertyOfType(classType, prop.escapedName);
|
|
if (superProperty && superProperty.valueDeclaration) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
function getSuperClass(classType) {
|
|
const x = getBaseTypes(classType);
|
|
if (x.length === 0) {
|
|
return void 0;
|
|
}
|
|
return getIntersectionType(x);
|
|
}
|
|
function reportNonexistentProperty(propNode, containingType, isUncheckedJS) {
|
|
let errorInfo;
|
|
let relatedInfo;
|
|
if (!isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* Union */ && !(containingType.flags & 131068 /* Primitive */)) {
|
|
for (const subtype of containingType.types) {
|
|
if (!getPropertyOfType(subtype, propNode.escapedText) && !getApplicableIndexInfoForName(subtype, propNode.escapedText)) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(subtype));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (typeHasStaticProperty(propNode.escapedText, containingType)) {
|
|
const propName = declarationNameToString(propNode);
|
|
const typeName = typeToString(containingType);
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "." + propName);
|
|
} else {
|
|
const promisedType = getPromisedTypeOfPromise(containingType);
|
|
if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(propNode), typeToString(containingType));
|
|
relatedInfo = createDiagnosticForNode(propNode, Diagnostics.Did_you_forget_to_use_await);
|
|
} else {
|
|
const missingProperty = declarationNameToString(propNode);
|
|
const container = typeToString(containingType);
|
|
const libSuggestion = getSuggestedLibForNonExistentProperty(missingProperty, containingType);
|
|
if (libSuggestion !== void 0) {
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later, missingProperty, container, libSuggestion);
|
|
} else {
|
|
const suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType);
|
|
if (suggestion !== void 0) {
|
|
const suggestedName = symbolName(suggestion);
|
|
const message = isUncheckedJS ? Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2 : Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2;
|
|
errorInfo = chainDiagnosticMessages(errorInfo, message, missingProperty, container, suggestedName);
|
|
relatedInfo = suggestion.valueDeclaration && createDiagnosticForNode(suggestion.valueDeclaration, Diagnostics._0_is_declared_here, suggestedName);
|
|
} else {
|
|
const diagnostic = containerSeemsToBeEmptyDomElement(containingType) ? Diagnostics.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom : Diagnostics.Property_0_does_not_exist_on_type_1;
|
|
errorInfo = chainDiagnosticMessages(elaborateNeverIntersection(errorInfo, containingType), diagnostic, missingProperty, container);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const resultDiagnostic = createDiagnosticForNodeFromMessageChain(propNode, errorInfo);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(resultDiagnostic, relatedInfo);
|
|
}
|
|
addErrorOrSuggestion(!isUncheckedJS || errorInfo.code !== Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, resultDiagnostic);
|
|
}
|
|
function containerSeemsToBeEmptyDomElement(containingType) {
|
|
return compilerOptions.lib && !compilerOptions.lib.includes("dom") && everyContainedType(containingType, (type) => type.symbol && /^(EventTarget|Node|((HTML[a-zA-Z]*)?Element))$/.test(unescapeLeadingUnderscores(type.symbol.escapedName))) && isEmptyObjectType(containingType);
|
|
}
|
|
function typeHasStaticProperty(propName, containingType) {
|
|
const prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName);
|
|
return prop !== void 0 && !!prop.valueDeclaration && isStatic(prop.valueDeclaration);
|
|
}
|
|
function getSuggestedLibForNonExistentName(name) {
|
|
const missingName = diagnosticName(name);
|
|
const allFeatures = getScriptTargetFeatures();
|
|
const libTargets = getOwnKeys(allFeatures);
|
|
for (const libTarget of libTargets) {
|
|
const containingTypes = getOwnKeys(allFeatures[libTarget]);
|
|
if (containingTypes !== void 0 && contains(containingTypes, missingName)) {
|
|
return libTarget;
|
|
}
|
|
}
|
|
}
|
|
function getSuggestedLibForNonExistentProperty(missingProperty, containingType) {
|
|
const container = getApparentType(containingType).symbol;
|
|
if (!container) {
|
|
return void 0;
|
|
}
|
|
const allFeatures = getScriptTargetFeatures();
|
|
const libTargets = getOwnKeys(allFeatures);
|
|
for (const libTarget of libTargets) {
|
|
const featuresOfLib = allFeatures[libTarget];
|
|
const featuresOfContainingType = featuresOfLib[symbolName(container)];
|
|
if (featuresOfContainingType !== void 0 && contains(featuresOfContainingType, missingProperty)) {
|
|
return libTarget;
|
|
}
|
|
}
|
|
}
|
|
function getSuggestedSymbolForNonexistentClassMember(name, baseType) {
|
|
return getSpellingSuggestionForName(name, getPropertiesOfType(baseType), 106500 /* ClassMember */);
|
|
}
|
|
function getSuggestedSymbolForNonexistentProperty(name, containingType) {
|
|
let props = getPropertiesOfType(containingType);
|
|
if (typeof name !== "string") {
|
|
const parent2 = name.parent;
|
|
if (isPropertyAccessExpression(parent2)) {
|
|
props = filter(props, (prop) => isValidPropertyAccessForCompletions(parent2, containingType, prop));
|
|
}
|
|
name = idText(name);
|
|
}
|
|
return getSpellingSuggestionForName(name, props, 111551 /* Value */);
|
|
}
|
|
function getSuggestedSymbolForNonexistentJSXAttribute(name, containingType) {
|
|
const strName = isString(name) ? name : idText(name);
|
|
const properties = getPropertiesOfType(containingType);
|
|
const jsxSpecific = strName === "for" ? find(properties, (x) => symbolName(x) === "htmlFor") : strName === "class" ? find(properties, (x) => symbolName(x) === "className") : void 0;
|
|
return jsxSpecific != null ? jsxSpecific : getSpellingSuggestionForName(strName, properties, 111551 /* Value */);
|
|
}
|
|
function getSuggestionForNonexistentProperty(name, containingType) {
|
|
const suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
|
|
return suggestion && symbolName(suggestion);
|
|
}
|
|
function getSuggestedSymbolForNonexistentSymbol(location2, outerName, meaning) {
|
|
Debug.assert(outerName !== void 0, "outername should always be defined");
|
|
const result = resolveNameHelper(location2, outerName, meaning, void 0, outerName, false, false, true, (symbols, name, meaning2) => {
|
|
Debug.assertEqual(outerName, name, "name should equal outerName");
|
|
const symbol = getSymbol2(symbols, name, meaning2);
|
|
if (symbol)
|
|
return symbol;
|
|
let candidates;
|
|
if (symbols === globals) {
|
|
const primitives = mapDefined(
|
|
["string", "number", "boolean", "object", "bigint", "symbol"],
|
|
(s) => symbols.has(s.charAt(0).toUpperCase() + s.slice(1)) ? createSymbol(524288 /* TypeAlias */, s) : void 0
|
|
);
|
|
candidates = primitives.concat(arrayFrom(symbols.values()));
|
|
} else {
|
|
candidates = arrayFrom(symbols.values());
|
|
}
|
|
return getSpellingSuggestionForName(unescapeLeadingUnderscores(name), candidates, meaning2);
|
|
});
|
|
return result;
|
|
}
|
|
function getSuggestionForNonexistentSymbol(location2, outerName, meaning) {
|
|
const symbolResult = getSuggestedSymbolForNonexistentSymbol(location2, outerName, meaning);
|
|
return symbolResult && symbolName(symbolResult);
|
|
}
|
|
function getSuggestedSymbolForNonexistentModule(name, targetModule) {
|
|
return targetModule.exports && getSpellingSuggestionForName(idText(name), getExportsOfModuleAsArray(targetModule), 2623475 /* ModuleMember */);
|
|
}
|
|
function getSuggestionForNonexistentExport(name, targetModule) {
|
|
const suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule);
|
|
return suggestion && symbolName(suggestion);
|
|
}
|
|
function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) {
|
|
function hasProp(name) {
|
|
const prop = getPropertyOfObjectType(objectType, name);
|
|
if (prop) {
|
|
const s = getSingleCallSignature(getTypeOfSymbol(prop));
|
|
return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0));
|
|
}
|
|
return false;
|
|
}
|
|
const suggestedMethod = isAssignmentTarget(expr) ? "set" : "get";
|
|
if (!hasProp(suggestedMethod)) {
|
|
return void 0;
|
|
}
|
|
let suggestion = tryGetPropertyAccessOrIdentifierToString(expr.expression);
|
|
if (suggestion === void 0) {
|
|
suggestion = suggestedMethod;
|
|
} else {
|
|
suggestion += "." + suggestedMethod;
|
|
}
|
|
return suggestion;
|
|
}
|
|
function getSuggestedTypeForNonexistentStringLiteralType(source, target) {
|
|
const candidates = target.types.filter((type) => !!(type.flags & 128 /* StringLiteral */));
|
|
return getSpellingSuggestion(source.value, candidates, (type) => type.value);
|
|
}
|
|
function getSpellingSuggestionForName(name, symbols, meaning) {
|
|
return getSpellingSuggestion(name, symbols, getCandidateName);
|
|
function getCandidateName(candidate) {
|
|
const candidateName = symbolName(candidate);
|
|
if (startsWith(candidateName, '"')) {
|
|
return void 0;
|
|
}
|
|
if (candidate.flags & meaning) {
|
|
return candidateName;
|
|
}
|
|
if (candidate.flags & 2097152 /* Alias */) {
|
|
const alias = tryResolveAlias(candidate);
|
|
if (alias && alias.flags & meaning) {
|
|
return candidateName;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isSelfTypeAccess2) {
|
|
const valueDeclaration = prop && prop.flags & 106500 /* ClassMember */ && prop.valueDeclaration;
|
|
if (!valueDeclaration) {
|
|
return;
|
|
}
|
|
const hasPrivateModifier = hasEffectiveModifier(valueDeclaration, 8 /* Private */);
|
|
const hasPrivateIdentifier = prop.valueDeclaration && isNamedDeclaration(prop.valueDeclaration) && isPrivateIdentifier(prop.valueDeclaration.name);
|
|
if (!hasPrivateModifier && !hasPrivateIdentifier) {
|
|
return;
|
|
}
|
|
if (nodeForCheckWriteOnly && isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SetAccessor */)) {
|
|
return;
|
|
}
|
|
if (isSelfTypeAccess2) {
|
|
const containingMethod = findAncestor(nodeForCheckWriteOnly, isFunctionLikeDeclaration);
|
|
if (containingMethod && containingMethod.symbol === prop) {
|
|
return;
|
|
}
|
|
}
|
|
(getCheckFlags(prop) & 1 /* Instantiated */ ? getSymbolLinks(prop).target : prop).isReferenced = 67108863 /* All */;
|
|
}
|
|
function isSelfTypeAccess(name, parent2) {
|
|
return name.kind === 108 /* ThisKeyword */ || !!parent2 && isEntityNameExpression(name) && parent2 === getResolvedSymbol(getFirstIdentifier(name));
|
|
}
|
|
function isValidPropertyAccess(node, propertyName) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return isValidPropertyAccessWithType(node, node.expression.kind === 106 /* SuperKeyword */, propertyName, getWidenedType(checkExpression(node.expression)));
|
|
case 163 /* QualifiedName */:
|
|
return isValidPropertyAccessWithType(node, false, propertyName, getWidenedType(checkExpression(node.left)));
|
|
case 202 /* ImportType */:
|
|
return isValidPropertyAccessWithType(node, false, propertyName, getTypeFromTypeNode(node));
|
|
}
|
|
}
|
|
function isValidPropertyAccessForCompletions(node, type, property) {
|
|
return isPropertyAccessible(
|
|
node,
|
|
node.kind === 208 /* PropertyAccessExpression */ && node.expression.kind === 106 /* SuperKeyword */,
|
|
false,
|
|
type,
|
|
property
|
|
);
|
|
}
|
|
function isValidPropertyAccessWithType(node, isSuper, propertyName, type) {
|
|
if (isTypeAny(type)) {
|
|
return true;
|
|
}
|
|
const prop = getPropertyOfType(type, propertyName);
|
|
return !!prop && isPropertyAccessible(node, isSuper, false, type, prop);
|
|
}
|
|
function isPropertyAccessible(node, isSuper, isWrite, containingType, property) {
|
|
if (isTypeAny(containingType)) {
|
|
return true;
|
|
}
|
|
if (property.valueDeclaration && isPrivateIdentifierClassElementDeclaration(property.valueDeclaration)) {
|
|
const declClass = getContainingClass(property.valueDeclaration);
|
|
return !isOptionalChain(node) && !!findAncestor(node, (parent2) => parent2 === declClass);
|
|
}
|
|
return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property);
|
|
}
|
|
function getForInVariableSymbol(node) {
|
|
const initializer = node.initializer;
|
|
if (initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variable = initializer.declarations[0];
|
|
if (variable && !isBindingPattern(variable.name)) {
|
|
return getSymbolOfNode(variable);
|
|
}
|
|
} else if (initializer.kind === 79 /* Identifier */) {
|
|
return getResolvedSymbol(initializer);
|
|
}
|
|
return void 0;
|
|
}
|
|
function hasNumericPropertyNames(type) {
|
|
return getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, numberType);
|
|
}
|
|
function isForInVariableForNumericPropertyNames(expr) {
|
|
const e = skipParentheses(expr);
|
|
if (e.kind === 79 /* Identifier */) {
|
|
const symbol = getResolvedSymbol(e);
|
|
if (symbol.flags & 3 /* Variable */) {
|
|
let child = expr;
|
|
let node = expr.parent;
|
|
while (node) {
|
|
if (node.kind === 246 /* ForInStatement */ && child === node.statement && getForInVariableSymbol(node) === symbol && hasNumericPropertyNames(getTypeOfExpression(node.expression))) {
|
|
return true;
|
|
}
|
|
child = node;
|
|
node = node.parent;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkIndexedAccess(node, checkMode) {
|
|
return node.flags & 32 /* OptionalChain */ ? checkElementAccessChain(node, checkMode) : checkElementAccessExpression(node, checkNonNullExpression(node.expression), checkMode);
|
|
}
|
|
function checkElementAccessChain(node, checkMode) {
|
|
const exprType = checkExpression(node.expression);
|
|
const nonOptionalType = getOptionalExpressionType(exprType, node.expression);
|
|
return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression), checkMode), node, nonOptionalType !== exprType);
|
|
}
|
|
function checkElementAccessExpression(node, exprType, checkMode) {
|
|
const objectType = getAssignmentTargetKind(node) !== 0 /* None */ || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType;
|
|
const indexExpression = node.argumentExpression;
|
|
const indexType = checkExpression(indexExpression);
|
|
if (isErrorType(objectType) || objectType === silentNeverType) {
|
|
return objectType;
|
|
}
|
|
if (isConstEnumObjectType(objectType) && !isStringLiteralLike(indexExpression)) {
|
|
error(indexExpression, Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal);
|
|
return errorType;
|
|
}
|
|
const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
|
|
const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
|
|
const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
|
|
return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
|
|
}
|
|
function callLikeExpressionMayHaveTypeArguments(node) {
|
|
return isCallOrNewExpression(node) || isTaggedTemplateExpression(node) || isJsxOpeningLikeElement(node);
|
|
}
|
|
function resolveUntypedCall(node) {
|
|
if (callLikeExpressionMayHaveTypeArguments(node)) {
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
}
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
checkExpression(node.template);
|
|
} else if (isJsxOpeningLikeElement(node)) {
|
|
checkExpression(node.attributes);
|
|
} else if (node.kind !== 167 /* Decorator */) {
|
|
forEach(node.arguments, (argument) => {
|
|
checkExpression(argument);
|
|
});
|
|
}
|
|
return anySignature;
|
|
}
|
|
function resolveErrorCall(node) {
|
|
resolveUntypedCall(node);
|
|
return unknownSignature;
|
|
}
|
|
function reorderCandidates(signatures, result, callChainFlags) {
|
|
let lastParent;
|
|
let lastSymbol;
|
|
let cutoffIndex = 0;
|
|
let index;
|
|
let specializedIndex = -1;
|
|
let spliceIndex;
|
|
Debug.assert(!result.length);
|
|
for (const signature of signatures) {
|
|
const symbol = signature.declaration && getSymbolOfNode(signature.declaration);
|
|
const parent2 = signature.declaration && signature.declaration.parent;
|
|
if (!lastSymbol || symbol === lastSymbol) {
|
|
if (lastParent && parent2 === lastParent) {
|
|
index = index + 1;
|
|
} else {
|
|
lastParent = parent2;
|
|
index = cutoffIndex;
|
|
}
|
|
} else {
|
|
index = cutoffIndex = result.length;
|
|
lastParent = parent2;
|
|
}
|
|
lastSymbol = symbol;
|
|
if (signatureHasLiteralTypes(signature)) {
|
|
specializedIndex++;
|
|
spliceIndex = specializedIndex;
|
|
cutoffIndex++;
|
|
} else {
|
|
spliceIndex = index;
|
|
}
|
|
result.splice(spliceIndex, 0, callChainFlags ? getOptionalCallSignature(signature, callChainFlags) : signature);
|
|
}
|
|
}
|
|
function isSpreadArgument(arg) {
|
|
return !!arg && (arg.kind === 227 /* SpreadElement */ || arg.kind === 234 /* SyntheticExpression */ && arg.isSpread);
|
|
}
|
|
function getSpreadArgumentIndex(args) {
|
|
return findIndex(args, isSpreadArgument);
|
|
}
|
|
function acceptsVoid(t) {
|
|
return !!(t.flags & 16384 /* Void */);
|
|
}
|
|
function acceptsVoidUndefinedUnknownOrAny(t) {
|
|
return !!(t.flags & (16384 /* Void */ | 32768 /* Undefined */ | 2 /* Unknown */ | 1 /* Any */));
|
|
}
|
|
function hasCorrectArity(node, args, signature, signatureHelpTrailingComma = false) {
|
|
let argCount;
|
|
let callIsIncomplete = false;
|
|
let effectiveParameterCount = getParameterCount(signature);
|
|
let effectiveMinimumArguments = getMinArgumentCount(signature);
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
argCount = args.length;
|
|
if (node.template.kind === 225 /* TemplateExpression */) {
|
|
const lastSpan = last(node.template.templateSpans);
|
|
callIsIncomplete = nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated;
|
|
} else {
|
|
const templateLiteral = node.template;
|
|
Debug.assert(templateLiteral.kind === 14 /* NoSubstitutionTemplateLiteral */);
|
|
callIsIncomplete = !!templateLiteral.isUnterminated;
|
|
}
|
|
} else if (node.kind === 167 /* Decorator */) {
|
|
argCount = getDecoratorArgumentCount(node, signature);
|
|
} else if (isJsxOpeningLikeElement(node)) {
|
|
callIsIncomplete = node.attributes.end === node.end;
|
|
if (callIsIncomplete) {
|
|
return true;
|
|
}
|
|
argCount = effectiveMinimumArguments === 0 ? args.length : 1;
|
|
effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1;
|
|
effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1);
|
|
} else if (!node.arguments) {
|
|
Debug.assert(node.kind === 211 /* NewExpression */);
|
|
return getMinArgumentCount(signature) === 0;
|
|
} else {
|
|
argCount = signatureHelpTrailingComma ? args.length + 1 : args.length;
|
|
callIsIncomplete = node.arguments.end === node.end;
|
|
const spreadArgIndex = getSpreadArgumentIndex(args);
|
|
if (spreadArgIndex >= 0) {
|
|
return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature));
|
|
}
|
|
}
|
|
if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) {
|
|
return false;
|
|
}
|
|
if (callIsIncomplete || argCount >= effectiveMinimumArguments) {
|
|
return true;
|
|
}
|
|
for (let i = argCount; i < effectiveMinimumArguments; i++) {
|
|
const type = getTypeAtPosition(signature, i);
|
|
if (filterType(type, isInJSFile(node) && !strictNullChecks ? acceptsVoidUndefinedUnknownOrAny : acceptsVoid).flags & 131072 /* Never */) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function hasCorrectTypeArgumentArity(signature, typeArguments) {
|
|
const numTypeParameters = length(signature.typeParameters);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters);
|
|
return !some(typeArguments) || typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters;
|
|
}
|
|
function getSingleCallSignature(type) {
|
|
return getSingleSignature(type, 0 /* Call */, false);
|
|
}
|
|
function getSingleCallOrConstructSignature(type) {
|
|
return getSingleSignature(type, 0 /* Call */, false) || getSingleSignature(type, 1 /* Construct */, false);
|
|
}
|
|
function getSingleSignature(type, kind, allowMembers) {
|
|
if (type.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type);
|
|
if (allowMembers || resolved.properties.length === 0 && resolved.indexInfos.length === 0) {
|
|
if (kind === 0 /* Call */ && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) {
|
|
return resolved.callSignatures[0];
|
|
}
|
|
if (kind === 1 /* Construct */ && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) {
|
|
return resolved.constructSignatures[0];
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) {
|
|
const context = createInferenceContext(signature.typeParameters, signature, 0 /* None */, compareTypes);
|
|
const restType = getEffectiveRestType(contextualSignature);
|
|
const mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper);
|
|
const sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature;
|
|
applyToParameterTypes(sourceSignature, signature, (source, target) => {
|
|
inferTypes(context.inferences, source, target);
|
|
});
|
|
if (!inferenceContext) {
|
|
applyToReturnTypes(contextualSignature, signature, (source, target) => {
|
|
inferTypes(context.inferences, source, target, 128 /* ReturnType */);
|
|
});
|
|
}
|
|
return getSignatureInstantiation(signature, getInferredTypes(context), isInJSFile(contextualSignature.declaration));
|
|
}
|
|
function inferJsxTypeArguments(node, signature, checkMode, context) {
|
|
const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
|
|
const checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode);
|
|
inferTypes(context.inferences, checkAttrType, paramType);
|
|
return getInferredTypes(context);
|
|
}
|
|
function getThisArgumentType(thisArgumentNode) {
|
|
if (!thisArgumentNode) {
|
|
return voidType;
|
|
}
|
|
const thisArgumentType = checkExpression(thisArgumentNode);
|
|
return isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : thisArgumentType;
|
|
}
|
|
function inferTypeArguments(node, signature, args, checkMode, context) {
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
return inferJsxTypeArguments(node, signature, checkMode, context);
|
|
}
|
|
if (node.kind !== 167 /* Decorator */) {
|
|
const skipBindingPatterns = every(signature.typeParameters, (p) => !!getDefaultFromTypeParameter(p));
|
|
const contextualType = getContextualType2(node, skipBindingPatterns ? 8 /* SkipBindingPatterns */ : 0 /* None */);
|
|
if (contextualType) {
|
|
const inferenceTargetType = getReturnTypeOfSignature(signature);
|
|
if (couldContainTypeVariables(inferenceTargetType)) {
|
|
const outerContext = getInferenceContext(node);
|
|
const isFromBindingPattern = !skipBindingPatterns && getContextualType2(node, 8 /* SkipBindingPatterns */) !== contextualType;
|
|
if (!isFromBindingPattern) {
|
|
const outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* NoDefault */));
|
|
const instantiatedType = instantiateType(contextualType, outerMapper);
|
|
const contextualSignature = getSingleCallSignature(instantiatedType);
|
|
const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : instantiatedType;
|
|
inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* ReturnType */);
|
|
}
|
|
const returnContext = createInferenceContext(signature.typeParameters, signature, context.flags);
|
|
const returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper);
|
|
inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType);
|
|
context.returnMapper = some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : void 0;
|
|
}
|
|
}
|
|
}
|
|
const restType = getNonArrayRestType(signature);
|
|
const argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
|
|
if (restType && restType.flags & 262144 /* TypeParameter */) {
|
|
const info = find(context.inferences, (info2) => info2.typeParameter === restType);
|
|
if (info) {
|
|
info.impliedArity = findIndex(args, isSpreadArgument, argCount) < 0 ? args.length - argCount : void 0;
|
|
}
|
|
}
|
|
const thisType = getThisTypeOfSignature(signature);
|
|
if (thisType && couldContainTypeVariables(thisType)) {
|
|
const thisArgumentNode = getThisArgumentOfCall(node);
|
|
inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType);
|
|
}
|
|
for (let i = 0; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (arg.kind !== 229 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
|
|
const paramType = getTypeAtPosition(signature, i);
|
|
if (couldContainTypeVariables(paramType)) {
|
|
const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
|
|
inferTypes(context.inferences, argType, paramType);
|
|
}
|
|
}
|
|
}
|
|
if (restType && couldContainTypeVariables(restType)) {
|
|
const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode);
|
|
inferTypes(context.inferences, spreadType, restType);
|
|
}
|
|
return getInferredTypes(context);
|
|
}
|
|
function getMutableArrayOrTupleType(type) {
|
|
return type.flags & 1048576 /* Union */ ? mapType(type, getMutableArrayOrTupleType) : type.flags & 1 /* Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.elementFlags, false, type.target.labeledElementDeclarations) : createTupleType([type], [8 /* Variadic */]);
|
|
}
|
|
function getSpreadArgumentType(args, index, argCount, restType, context, checkMode) {
|
|
if (index >= argCount - 1) {
|
|
const arg = args[argCount - 1];
|
|
if (isSpreadArgument(arg)) {
|
|
return getMutableArrayOrTupleType(arg.kind === 234 /* SyntheticExpression */ ? arg.type : checkExpressionWithContextualType(arg.expression, restType, context, checkMode));
|
|
}
|
|
}
|
|
const types = [];
|
|
const flags = [];
|
|
const names = [];
|
|
for (let i = index; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (isSpreadArgument(arg)) {
|
|
const spreadType = arg.kind === 234 /* SyntheticExpression */ ? arg.type : checkExpression(arg.expression);
|
|
if (isArrayLikeType(spreadType)) {
|
|
types.push(spreadType);
|
|
flags.push(8 /* Variadic */);
|
|
} else {
|
|
types.push(checkIteratedTypeOrElementType(33 /* Spread */, spreadType, undefinedType, arg.kind === 227 /* SpreadElement */ ? arg.expression : arg));
|
|
flags.push(4 /* Rest */);
|
|
}
|
|
} else {
|
|
const contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
|
|
const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
|
|
const hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
|
|
types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
|
|
flags.push(1 /* Required */);
|
|
}
|
|
if (arg.kind === 234 /* SyntheticExpression */ && arg.tupleNameSource) {
|
|
names.push(arg.tupleNameSource);
|
|
}
|
|
}
|
|
return createTupleType(types, flags, false, length(names) === length(types) ? names : void 0);
|
|
}
|
|
function checkTypeArguments(signature, typeArgumentNodes, reportErrors2, headMessage) {
|
|
const isJavascript = isInJSFile(signature.declaration);
|
|
const typeParameters = signature.typeParameters;
|
|
const typeArgumentTypes = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript);
|
|
let mapper;
|
|
for (let i = 0; i < typeArgumentNodes.length; i++) {
|
|
Debug.assert(typeParameters[i] !== void 0, "Should not call checkTypeArguments with too many type arguments");
|
|
const constraint = getConstraintOfTypeParameter(typeParameters[i]);
|
|
if (constraint) {
|
|
const errorInfo = reportErrors2 && headMessage ? () => chainDiagnosticMessages(void 0, Diagnostics.Type_0_does_not_satisfy_the_constraint_1) : void 0;
|
|
const typeArgumentHeadMessage = headMessage || Diagnostics.Type_0_does_not_satisfy_the_constraint_1;
|
|
if (!mapper) {
|
|
mapper = createTypeMapper(typeParameters, typeArgumentTypes);
|
|
}
|
|
const typeArgument = typeArgumentTypes[i];
|
|
if (!checkTypeAssignableTo(
|
|
typeArgument,
|
|
getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
|
|
reportErrors2 ? typeArgumentNodes[i] : void 0,
|
|
typeArgumentHeadMessage,
|
|
errorInfo
|
|
)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return typeArgumentTypes;
|
|
}
|
|
function getJsxReferenceKind(node) {
|
|
if (isJsxIntrinsicIdentifier(node.tagName)) {
|
|
return 2 /* Mixed */;
|
|
}
|
|
const tagType = getApparentType(checkExpression(node.tagName));
|
|
if (length(getSignaturesOfType(tagType, 1 /* Construct */))) {
|
|
return 0 /* Component */;
|
|
}
|
|
if (length(getSignaturesOfType(tagType, 0 /* Call */))) {
|
|
return 1 /* Function */;
|
|
}
|
|
return 2 /* Mixed */;
|
|
}
|
|
function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer) {
|
|
const paramType = getEffectiveFirstArgumentForJsxSignature(signature, node);
|
|
const attributesType = checkExpressionWithContextualType(node.attributes, paramType, void 0, checkMode);
|
|
return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
|
|
attributesType,
|
|
paramType,
|
|
relation,
|
|
reportErrors2 ? node.tagName : void 0,
|
|
node.attributes,
|
|
void 0,
|
|
containingMessageChain,
|
|
errorOutputContainer
|
|
);
|
|
function checkTagNameDoesNotExpectTooManyArguments() {
|
|
var _a2;
|
|
if (getJsxNamespaceContainerForImplicitImport(node)) {
|
|
return true;
|
|
}
|
|
const tagType = isJsxOpeningElement(node) || isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : void 0;
|
|
if (!tagType) {
|
|
return true;
|
|
}
|
|
const tagCallSignatures = getSignaturesOfType(tagType, 0 /* Call */);
|
|
if (!length(tagCallSignatures)) {
|
|
return true;
|
|
}
|
|
const factory2 = getJsxFactoryEntity(node);
|
|
if (!factory2) {
|
|
return true;
|
|
}
|
|
const factorySymbol = resolveEntityName(factory2, 111551 /* Value */, true, false, node);
|
|
if (!factorySymbol) {
|
|
return true;
|
|
}
|
|
const factoryType = getTypeOfSymbol(factorySymbol);
|
|
const callSignatures = getSignaturesOfType(factoryType, 0 /* Call */);
|
|
if (!length(callSignatures)) {
|
|
return true;
|
|
}
|
|
let hasFirstParamSignatures = false;
|
|
let maxParamCount = 0;
|
|
for (const sig of callSignatures) {
|
|
const firstparam = getTypeAtPosition(sig, 0);
|
|
const signaturesOfParam = getSignaturesOfType(firstparam, 0 /* Call */);
|
|
if (!length(signaturesOfParam))
|
|
continue;
|
|
for (const paramSig of signaturesOfParam) {
|
|
hasFirstParamSignatures = true;
|
|
if (hasEffectiveRestParameter(paramSig)) {
|
|
return true;
|
|
}
|
|
const paramCount = getParameterCount(paramSig);
|
|
if (paramCount > maxParamCount) {
|
|
maxParamCount = paramCount;
|
|
}
|
|
}
|
|
}
|
|
if (!hasFirstParamSignatures) {
|
|
return true;
|
|
}
|
|
let absoluteMinArgCount = Infinity;
|
|
for (const tagSig of tagCallSignatures) {
|
|
const tagRequiredArgCount = getMinArgumentCount(tagSig);
|
|
if (tagRequiredArgCount < absoluteMinArgCount) {
|
|
absoluteMinArgCount = tagRequiredArgCount;
|
|
}
|
|
}
|
|
if (absoluteMinArgCount <= maxParamCount) {
|
|
return true;
|
|
}
|
|
if (reportErrors2) {
|
|
const diag2 = createDiagnosticForNode(node.tagName, Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, entityNameToString(node.tagName), absoluteMinArgCount, entityNameToString(factory2), maxParamCount);
|
|
const tagNameDeclaration = (_a2 = getSymbolAtLocation(node.tagName)) == null ? void 0 : _a2.valueDeclaration;
|
|
if (tagNameDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(tagNameDeclaration, Diagnostics._0_is_declared_here, entityNameToString(node.tagName)));
|
|
}
|
|
if (errorOutputContainer && errorOutputContainer.skipLogging) {
|
|
(errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag2);
|
|
}
|
|
if (!errorOutputContainer.skipLogging) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain) {
|
|
const errorOutputContainer = { errors: void 0, skipLogging: true };
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "jsx should have errors when reporting errors");
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
return void 0;
|
|
}
|
|
const thisType = getThisTypeOfSignature(signature);
|
|
if (thisType && thisType !== voidType && node.kind !== 211 /* NewExpression */) {
|
|
const thisArgumentNode = getThisArgumentOfCall(node);
|
|
const thisArgumentType = getThisArgumentType(thisArgumentNode);
|
|
const errorNode = reportErrors2 ? thisArgumentNode || node : void 0;
|
|
const headMessage2 = Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1;
|
|
if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage2, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors");
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
const headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;
|
|
const restType = getNonArrayRestType(signature);
|
|
const argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length;
|
|
for (let i = 0; i < argCount; i++) {
|
|
const arg = args[i];
|
|
if (arg.kind !== 229 /* OmittedExpression */) {
|
|
const paramType = getTypeAtPosition(signature, i);
|
|
const argType = checkExpressionWithContextualType(arg, paramType, void 0, checkMode);
|
|
const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
|
|
if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? arg : void 0, arg, headMessage, containingMessageChain, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
|
|
maybeAddMissingAwaitInfo(arg, checkArgType, paramType);
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
}
|
|
if (restType) {
|
|
const spreadType = getSpreadArgumentType(args, argCount, args.length, restType, void 0, checkMode);
|
|
const restArgCount = args.length - argCount;
|
|
const errorNode = !reportErrors2 ? void 0 : restArgCount === 0 ? node : restArgCount === 1 ? args[argCount] : setTextRangePosEnd(createSyntheticExpression(node, spreadType), args[argCount].pos, args[args.length - 1].end);
|
|
if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, void 0, errorOutputContainer)) {
|
|
Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors");
|
|
maybeAddMissingAwaitInfo(errorNode, spreadType, restType);
|
|
return errorOutputContainer.errors || emptyArray;
|
|
}
|
|
}
|
|
return void 0;
|
|
function maybeAddMissingAwaitInfo(errorNode, source, target) {
|
|
if (errorNode && reportErrors2 && errorOutputContainer.errors && errorOutputContainer.errors.length) {
|
|
if (getAwaitedTypeOfPromise(target)) {
|
|
return;
|
|
}
|
|
const awaitedTypeOfSource = getAwaitedTypeOfPromise(source);
|
|
if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) {
|
|
addRelatedInfo(errorOutputContainer.errors[0], createDiagnosticForNode(errorNode, Diagnostics.Did_you_forget_to_use_await));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getThisArgumentOfCall(node) {
|
|
const expression = node.kind === 210 /* CallExpression */ ? node.expression : node.kind === 212 /* TaggedTemplateExpression */ ? node.tag : void 0;
|
|
if (expression) {
|
|
const callee = skipOuterExpressions(expression);
|
|
if (isAccessExpression(callee)) {
|
|
return callee.expression;
|
|
}
|
|
}
|
|
}
|
|
function createSyntheticExpression(parent2, type, isSpread, tupleNameSource) {
|
|
const result = parseNodeFactory.createSyntheticExpression(type, isSpread, tupleNameSource);
|
|
setTextRange(result, parent2);
|
|
setParent(result, parent2);
|
|
return result;
|
|
}
|
|
function getEffectiveCallArguments(node) {
|
|
if (node.kind === 212 /* TaggedTemplateExpression */) {
|
|
const template = node.template;
|
|
const args2 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())];
|
|
if (template.kind === 225 /* TemplateExpression */) {
|
|
forEach(template.templateSpans, (span) => {
|
|
args2.push(span.expression);
|
|
});
|
|
}
|
|
return args2;
|
|
}
|
|
if (node.kind === 167 /* Decorator */) {
|
|
return getEffectiveDecoratorArguments(node);
|
|
}
|
|
if (isJsxOpeningLikeElement(node)) {
|
|
return node.attributes.properties.length > 0 || isJsxOpeningElement(node) && node.parent.children.length > 0 ? [node.attributes] : emptyArray;
|
|
}
|
|
const args = node.arguments || emptyArray;
|
|
const spreadIndex = getSpreadArgumentIndex(args);
|
|
if (spreadIndex >= 0) {
|
|
const effectiveArgs = args.slice(0, spreadIndex);
|
|
for (let i = spreadIndex; i < args.length; i++) {
|
|
const arg = args[i];
|
|
const spreadType = arg.kind === 227 /* SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
|
|
if (spreadType && isTupleType(spreadType)) {
|
|
forEach(getTypeArguments(spreadType), (t, i2) => {
|
|
var _a2;
|
|
const flags = spreadType.target.elementFlags[i2];
|
|
const syntheticArg = createSyntheticExpression(
|
|
arg,
|
|
flags & 4 /* Rest */ ? createArrayType(t) : t,
|
|
!!(flags & 12 /* Variable */),
|
|
(_a2 = spreadType.target.labeledElementDeclarations) == null ? void 0 : _a2[i2]
|
|
);
|
|
effectiveArgs.push(syntheticArg);
|
|
});
|
|
} else {
|
|
effectiveArgs.push(arg);
|
|
}
|
|
}
|
|
return effectiveArgs;
|
|
}
|
|
return args;
|
|
}
|
|
function getEffectiveDecoratorArguments(node) {
|
|
const parent2 = node.parent;
|
|
const expr = node.expression;
|
|
switch (parent2.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return [
|
|
createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent2)))
|
|
];
|
|
case 166 /* Parameter */:
|
|
const func = parent2.parent;
|
|
return [
|
|
createSyntheticExpression(expr, parent2.parent.kind === 173 /* Constructor */ ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType),
|
|
createSyntheticExpression(expr, anyType),
|
|
createSyntheticExpression(expr, numberType)
|
|
];
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const hasPropDesc = languageVersion !== 0 /* ES3 */ && (!isPropertyDeclaration(parent2) || hasAccessorModifier(parent2));
|
|
return [
|
|
createSyntheticExpression(expr, getParentTypeOfClassElement(parent2)),
|
|
createSyntheticExpression(expr, getClassElementPropertyKeyType(parent2)),
|
|
createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent2)) : anyType)
|
|
];
|
|
}
|
|
return Debug.fail();
|
|
}
|
|
function getDecoratorArgumentCount(node, signature) {
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return 1;
|
|
case 169 /* PropertyDeclaration */:
|
|
return hasAccessorModifier(node.parent) ? 3 : 2;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return languageVersion === 0 /* ES3 */ || signature.parameters.length <= 2 ? 2 : 3;
|
|
case 166 /* Parameter */:
|
|
return 3;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
|
|
let start2;
|
|
let length2;
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (isPropertyAccessExpression(node.expression)) {
|
|
const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
|
|
start2 = nameSpan.start;
|
|
length2 = doNotIncludeArguments ? nameSpan.length : node.end - start2;
|
|
} else {
|
|
const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
|
|
start2 = expressionSpan.start;
|
|
length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start2;
|
|
}
|
|
return { start: start2, length: length2, sourceFile };
|
|
}
|
|
function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
|
|
if (isCallExpression(node)) {
|
|
const { sourceFile, start: start2, length: length2 } = getDiagnosticSpanForCallNode(node);
|
|
return createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2, arg3);
|
|
} else {
|
|
return createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
|
|
}
|
|
}
|
|
function isPromiseResolveArityError(node) {
|
|
if (!isCallExpression(node) || !isIdentifier(node.expression))
|
|
return false;
|
|
const symbol = resolveName(node.expression, node.expression.escapedText, 111551 /* Value */, void 0, void 0, false);
|
|
const decl = symbol == null ? void 0 : symbol.valueDeclaration;
|
|
if (!decl || !isParameter(decl) || !isFunctionExpressionOrArrowFunction(decl.parent) || !isNewExpression(decl.parent.parent) || !isIdentifier(decl.parent.parent.expression)) {
|
|
return false;
|
|
}
|
|
const globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
|
|
if (!globalPromiseSymbol)
|
|
return false;
|
|
const constructorSymbol = getSymbolAtLocation(decl.parent.parent.expression, true);
|
|
return constructorSymbol === globalPromiseSymbol;
|
|
}
|
|
function getArgumentArityError(node, signatures, args) {
|
|
var _a2;
|
|
const spreadIndex = getSpreadArgumentIndex(args);
|
|
if (spreadIndex > -1) {
|
|
return createDiagnosticForNode(args[spreadIndex], Diagnostics.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter);
|
|
}
|
|
let min2 = Number.POSITIVE_INFINITY;
|
|
let max = Number.NEGATIVE_INFINITY;
|
|
let maxBelow = Number.NEGATIVE_INFINITY;
|
|
let minAbove = Number.POSITIVE_INFINITY;
|
|
let closestSignature;
|
|
for (const sig of signatures) {
|
|
const minParameter = getMinArgumentCount(sig);
|
|
const maxParameter = getParameterCount(sig);
|
|
if (minParameter < min2) {
|
|
min2 = minParameter;
|
|
closestSignature = sig;
|
|
}
|
|
max = Math.max(max, maxParameter);
|
|
if (minParameter < args.length && minParameter > maxBelow)
|
|
maxBelow = minParameter;
|
|
if (args.length < maxParameter && maxParameter < minAbove)
|
|
minAbove = maxParameter;
|
|
}
|
|
const hasRestParameter2 = some(signatures, hasEffectiveRestParameter);
|
|
const parameterRange = hasRestParameter2 ? min2 : min2 < max ? min2 + "-" + max : min2;
|
|
const isVoidPromiseError = !hasRestParameter2 && parameterRange === 1 && args.length === 0 && isPromiseResolveArityError(node);
|
|
if (isVoidPromiseError && isInJSFile(node)) {
|
|
return getDiagnosticForCallNode(node, Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments);
|
|
}
|
|
const error2 = hasRestParameter2 ? Diagnostics.Expected_at_least_0_arguments_but_got_1 : isVoidPromiseError ? Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise : Diagnostics.Expected_0_arguments_but_got_1;
|
|
if (min2 < args.length && args.length < max) {
|
|
return getDiagnosticForCallNode(node, Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, args.length, maxBelow, minAbove);
|
|
} else if (args.length < min2) {
|
|
const diagnostic = getDiagnosticForCallNode(node, error2, parameterRange, args.length);
|
|
const parameter = (_a2 = closestSignature == null ? void 0 : closestSignature.declaration) == null ? void 0 : _a2.parameters[closestSignature.thisParameter ? args.length + 1 : args.length];
|
|
if (parameter) {
|
|
const parameterError = createDiagnosticForNode(
|
|
parameter,
|
|
isBindingPattern(parameter.name) ? Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : isRestParameter(parameter) ? Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided : Diagnostics.An_argument_for_0_was_not_provided,
|
|
!parameter.name ? args.length : !isBindingPattern(parameter.name) ? idText(getFirstIdentifier(parameter.name)) : void 0
|
|
);
|
|
return addRelatedInfo(diagnostic, parameterError);
|
|
}
|
|
return diagnostic;
|
|
} else {
|
|
const errorSpan = factory.createNodeArray(args.slice(max));
|
|
const pos = first(errorSpan).pos;
|
|
let end = last(errorSpan).end;
|
|
if (end === pos) {
|
|
end++;
|
|
}
|
|
setTextRangePosEnd(errorSpan, pos, end);
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), errorSpan, error2, parameterRange, args.length);
|
|
}
|
|
}
|
|
function getTypeArgumentArityError(node, signatures, typeArguments) {
|
|
const argCount = typeArguments.length;
|
|
if (signatures.length === 1) {
|
|
const sig = signatures[0];
|
|
const min2 = getMinTypeArgumentCount(sig.typeParameters);
|
|
const max = length(sig.typeParameters);
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, min2 < max ? min2 + "-" + max : min2, argCount);
|
|
}
|
|
let belowArgCount = -Infinity;
|
|
let aboveArgCount = Infinity;
|
|
for (const sig of signatures) {
|
|
const min2 = getMinTypeArgumentCount(sig.typeParameters);
|
|
const max = length(sig.typeParameters);
|
|
if (min2 > argCount) {
|
|
aboveArgCount = Math.min(aboveArgCount, min2);
|
|
} else if (max < argCount) {
|
|
belowArgCount = Math.max(belowArgCount, max);
|
|
}
|
|
}
|
|
if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) {
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount);
|
|
}
|
|
return createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount);
|
|
}
|
|
function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) {
|
|
const isTaggedTemplate = node.kind === 212 /* TaggedTemplateExpression */;
|
|
const isDecorator2 = node.kind === 167 /* Decorator */;
|
|
const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
|
|
const reportErrors2 = !candidatesOutArray;
|
|
let typeArguments;
|
|
if (!isDecorator2 && !isSuperCall(node)) {
|
|
typeArguments = node.typeArguments;
|
|
if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 106 /* SuperKeyword */) {
|
|
forEach(typeArguments, checkSourceElement);
|
|
}
|
|
}
|
|
const candidates = candidatesOutArray || [];
|
|
reorderCandidates(signatures, candidates, callChainFlags);
|
|
if (!candidates.length) {
|
|
if (reportErrors2) {
|
|
diagnostics.add(getDiagnosticForCallNode(node, Diagnostics.Call_target_does_not_contain_any_signatures));
|
|
}
|
|
return resolveErrorCall(node);
|
|
}
|
|
const args = getEffectiveCallArguments(node);
|
|
const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
|
|
let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
|
|
argCheckMode |= checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
|
|
let candidatesForArgumentError;
|
|
let candidateForArgumentArityError;
|
|
let candidateForTypeArgumentError;
|
|
let result;
|
|
const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 210 /* CallExpression */ && node.arguments.hasTrailingComma;
|
|
if (candidates.length > 1) {
|
|
result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
|
|
}
|
|
if (!result) {
|
|
result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
|
|
}
|
|
if (result) {
|
|
return result;
|
|
}
|
|
result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
|
|
getNodeLinks(node).resolvedSignature = result;
|
|
if (reportErrors2) {
|
|
if (candidatesForArgumentError) {
|
|
if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) {
|
|
const last2 = candidatesForArgumentError[candidatesForArgumentError.length - 1];
|
|
let chain;
|
|
if (candidatesForArgumentError.length > 3) {
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.The_last_overload_gave_the_following_error);
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.No_overload_matches_this_call);
|
|
}
|
|
const diags = getSignatureApplicabilityError(node, args, last2, assignableRelation, 0 /* Normal */, true, () => chain);
|
|
if (diags) {
|
|
for (const d of diags) {
|
|
if (last2.declaration && candidatesForArgumentError.length > 3) {
|
|
addRelatedInfo(d, createDiagnosticForNode(last2.declaration, Diagnostics.The_last_overload_is_declared_here));
|
|
}
|
|
addImplementationSuccessElaboration(last2, d);
|
|
diagnostics.add(d);
|
|
}
|
|
} else {
|
|
Debug.fail("No error for last overload signature");
|
|
}
|
|
} else {
|
|
const allDiagnostics = [];
|
|
let max = 0;
|
|
let min2 = Number.MAX_VALUE;
|
|
let minIndex = 0;
|
|
let i = 0;
|
|
for (const c of candidatesForArgumentError) {
|
|
const chain2 = () => chainDiagnosticMessages(void 0, Diagnostics.Overload_0_of_1_2_gave_the_following_error, i + 1, candidates.length, signatureToString(c));
|
|
const diags2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* Normal */, true, chain2);
|
|
if (diags2) {
|
|
if (diags2.length <= min2) {
|
|
min2 = diags2.length;
|
|
minIndex = i;
|
|
}
|
|
max = Math.max(max, diags2.length);
|
|
allDiagnostics.push(diags2);
|
|
} else {
|
|
Debug.fail("No error for 3 or fewer overload signatures");
|
|
}
|
|
i++;
|
|
}
|
|
const diags = max > 1 ? allDiagnostics[minIndex] : flatten(allDiagnostics);
|
|
Debug.assert(diags.length > 0, "No errors reported for 3 or fewer overload signatures");
|
|
const chain = chainDiagnosticMessages(
|
|
map(diags, createDiagnosticMessageChainFromDiagnostic),
|
|
Diagnostics.No_overload_matches_this_call
|
|
);
|
|
const related = [...flatMap(diags, (d) => d.relatedInformation)];
|
|
let diag2;
|
|
if (every(diags, (d) => d.start === diags[0].start && d.length === diags[0].length && d.file === diags[0].file)) {
|
|
const { file, start: start2, length: length2 } = diags[0];
|
|
diag2 = { file, start: start2, length: length2, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
|
|
} else {
|
|
diag2 = createDiagnosticForNodeFromMessageChain(node, chain, related);
|
|
}
|
|
addImplementationSuccessElaboration(candidatesForArgumentError[0], diag2);
|
|
diagnostics.add(diag2);
|
|
}
|
|
} else if (candidateForArgumentArityError) {
|
|
diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args));
|
|
} else if (candidateForTypeArgumentError) {
|
|
checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, true, fallbackError);
|
|
} else {
|
|
const signaturesWithCorrectTypeArgumentArity = filter(signatures, (s) => hasCorrectTypeArgumentArity(s, typeArguments));
|
|
if (signaturesWithCorrectTypeArgumentArity.length === 0) {
|
|
diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments));
|
|
} else if (!isDecorator2) {
|
|
diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args));
|
|
} else if (fallbackError) {
|
|
diagnostics.add(getDiagnosticForCallNode(node, fallbackError));
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
function addImplementationSuccessElaboration(failed, diagnostic) {
|
|
var _a2, _b;
|
|
const oldCandidatesForArgumentError = candidatesForArgumentError;
|
|
const oldCandidateForArgumentArityError = candidateForArgumentArityError;
|
|
const oldCandidateForTypeArgumentError = candidateForTypeArgumentError;
|
|
const failedSignatureDeclarations = ((_b = (_a2 = failed.declaration) == null ? void 0 : _a2.symbol) == null ? void 0 : _b.declarations) || emptyArray;
|
|
const isOverload = failedSignatureDeclarations.length > 1;
|
|
const implDecl = isOverload ? find(failedSignatureDeclarations, (d) => isFunctionLikeDeclaration(d) && nodeIsPresent(d.body)) : void 0;
|
|
if (implDecl) {
|
|
const candidate = getSignatureFromDeclaration(implDecl);
|
|
const isSingleNonGenericCandidate2 = !candidate.typeParameters;
|
|
if (chooseOverload([candidate], assignableRelation, isSingleNonGenericCandidate2)) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(implDecl, Diagnostics.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible));
|
|
}
|
|
}
|
|
candidatesForArgumentError = oldCandidatesForArgumentError;
|
|
candidateForArgumentArityError = oldCandidateForArgumentArityError;
|
|
candidateForTypeArgumentError = oldCandidateForTypeArgumentError;
|
|
}
|
|
function chooseOverload(candidates2, relation, isSingleNonGenericCandidate2, signatureHelpTrailingComma2 = false) {
|
|
candidatesForArgumentError = void 0;
|
|
candidateForArgumentArityError = void 0;
|
|
candidateForTypeArgumentError = void 0;
|
|
if (isSingleNonGenericCandidate2) {
|
|
const candidate = candidates2[0];
|
|
if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
|
|
return void 0;
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, candidate, relation, 0 /* Normal */, false, void 0)) {
|
|
candidatesForArgumentError = [candidate];
|
|
return void 0;
|
|
}
|
|
return candidate;
|
|
}
|
|
for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
|
|
const candidate = candidates2[candidateIndex];
|
|
if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
|
|
continue;
|
|
}
|
|
let checkCandidate;
|
|
let inferenceContext;
|
|
if (candidate.typeParameters) {
|
|
let typeArgumentTypes;
|
|
if (some(typeArguments)) {
|
|
typeArgumentTypes = checkTypeArguments(candidate, typeArguments, false);
|
|
if (!typeArgumentTypes) {
|
|
candidateForTypeArgumentError = candidate;
|
|
continue;
|
|
}
|
|
} else {
|
|
inferenceContext = createInferenceContext(candidate.typeParameters, candidate, isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
|
|
typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
|
|
argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
|
|
}
|
|
checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
|
|
if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
|
|
candidateForArgumentArityError = checkCandidate;
|
|
continue;
|
|
}
|
|
} else {
|
|
checkCandidate = candidate;
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, void 0)) {
|
|
(candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
|
|
continue;
|
|
}
|
|
if (argCheckMode) {
|
|
argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
|
|
if (inferenceContext) {
|
|
const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
|
|
checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
|
|
if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
|
|
candidateForArgumentArityError = checkCandidate;
|
|
continue;
|
|
}
|
|
}
|
|
if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, false, void 0)) {
|
|
(candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
|
|
continue;
|
|
}
|
|
}
|
|
candidates2[candidateIndex] = checkCandidate;
|
|
return checkCandidate;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) {
|
|
Debug.assert(candidates.length > 0);
|
|
checkNodeDeferred(node);
|
|
return hasCandidatesOutArray || candidates.length === 1 || candidates.some((c) => !!c.typeParameters) ? pickLongestCandidateSignature(node, candidates, args, checkMode) : createUnionOfSignaturesForOverloadFailure(candidates);
|
|
}
|
|
function createUnionOfSignaturesForOverloadFailure(candidates) {
|
|
const thisParameters = mapDefined(candidates, (c) => c.thisParameter);
|
|
let thisParameter;
|
|
if (thisParameters.length) {
|
|
thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter));
|
|
}
|
|
const { min: minArgumentCount, max: maxNonRestParam } = minAndMax(candidates, getNumNonRestParameters);
|
|
const parameters = [];
|
|
for (let i = 0; i < maxNonRestParam; i++) {
|
|
const symbols = mapDefined(candidates, (s) => signatureHasRestParameter(s) ? i < s.parameters.length - 1 ? s.parameters[i] : last(s.parameters) : i < s.parameters.length ? s.parameters[i] : void 0);
|
|
Debug.assert(symbols.length !== 0);
|
|
parameters.push(createCombinedSymbolFromTypes(symbols, mapDefined(candidates, (candidate) => tryGetTypeAtPosition(candidate, i))));
|
|
}
|
|
const restParameterSymbols = mapDefined(candidates, (c) => signatureHasRestParameter(c) ? last(c.parameters) : void 0);
|
|
let flags = 0 /* None */;
|
|
if (restParameterSymbols.length !== 0) {
|
|
const type = createArrayType(getUnionType(mapDefined(candidates, tryGetRestTypeOfSignature), 2 /* Subtype */));
|
|
parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type));
|
|
flags |= 1 /* HasRestParameter */;
|
|
}
|
|
if (candidates.some(signatureHasLiteralTypes)) {
|
|
flags |= 2 /* HasLiteralTypes */;
|
|
}
|
|
return createSignature(
|
|
candidates[0].declaration,
|
|
void 0,
|
|
thisParameter,
|
|
parameters,
|
|
getIntersectionType(candidates.map(getReturnTypeOfSignature)),
|
|
void 0,
|
|
minArgumentCount,
|
|
flags
|
|
);
|
|
}
|
|
function getNumNonRestParameters(signature) {
|
|
const numParams = signature.parameters.length;
|
|
return signatureHasRestParameter(signature) ? numParams - 1 : numParams;
|
|
}
|
|
function createCombinedSymbolFromTypes(sources, types) {
|
|
return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2 /* Subtype */));
|
|
}
|
|
function createCombinedSymbolForOverloadFailure(sources, type) {
|
|
return createSymbolWithType(first(sources), type);
|
|
}
|
|
function pickLongestCandidateSignature(node, candidates, args, checkMode) {
|
|
const bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === void 0 ? args.length : apparentArgumentCount);
|
|
const candidate = candidates[bestIndex];
|
|
const { typeParameters } = candidate;
|
|
if (!typeParameters) {
|
|
return candidate;
|
|
}
|
|
const typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : void 0;
|
|
const instantiated = typeArgumentNodes ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isInJSFile(node))) : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
|
|
candidates[bestIndex] = instantiated;
|
|
return instantiated;
|
|
}
|
|
function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) {
|
|
const typeArguments = typeArgumentNodes.map(getTypeOfNode);
|
|
while (typeArguments.length > typeParameters.length) {
|
|
typeArguments.pop();
|
|
}
|
|
while (typeArguments.length < typeParameters.length) {
|
|
typeArguments.push(getDefaultFromTypeParameter(typeParameters[typeArguments.length]) || getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs));
|
|
}
|
|
return typeArguments;
|
|
}
|
|
function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode) {
|
|
const inferenceContext = createInferenceContext(typeParameters, candidate, isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
|
|
const typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
|
|
return createSignatureInstantiation(candidate, typeArgumentTypes);
|
|
}
|
|
function getLongestCandidateIndex(candidates, argsCount) {
|
|
let maxParamsIndex = -1;
|
|
let maxParams = -1;
|
|
for (let i = 0; i < candidates.length; i++) {
|
|
const candidate = candidates[i];
|
|
const paramCount = getParameterCount(candidate);
|
|
if (hasEffectiveRestParameter(candidate) || paramCount >= argsCount) {
|
|
return i;
|
|
}
|
|
if (paramCount > maxParams) {
|
|
maxParams = paramCount;
|
|
maxParamsIndex = i;
|
|
}
|
|
}
|
|
return maxParamsIndex;
|
|
}
|
|
function resolveCallExpression(node, candidatesOutArray, checkMode) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
const superType = checkSuperExpression(node.expression);
|
|
if (isTypeAny(superType)) {
|
|
for (const arg of node.arguments) {
|
|
checkExpression(arg);
|
|
}
|
|
return anySignature;
|
|
}
|
|
if (!isErrorType(superType)) {
|
|
const baseTypeNode = getEffectiveBaseTypeNode(getContainingClass(node));
|
|
if (baseTypeNode) {
|
|
const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
|
|
return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
let callChainFlags;
|
|
let funcType = checkExpression(node.expression);
|
|
if (isCallChain(node)) {
|
|
const nonOptionalType = getOptionalExpressionType(funcType, node.expression);
|
|
callChainFlags = nonOptionalType === funcType ? 0 /* None */ : isOutermostOptionalChain(node) ? 16 /* IsOuterCallChain */ : 8 /* IsInnerCallChain */;
|
|
funcType = nonOptionalType;
|
|
} else {
|
|
callChainFlags = 0 /* None */;
|
|
}
|
|
funcType = checkNonNullTypeWithReporter(
|
|
funcType,
|
|
node.expression,
|
|
reportCannotInvokePossiblyNullOrUndefinedError
|
|
);
|
|
if (funcType === silentNeverType) {
|
|
return silentNeverSignature;
|
|
}
|
|
const apparentType = getApparentType(funcType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
if (!isErrorType(funcType) && node.typeArguments) {
|
|
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (!callSignatures.length) {
|
|
if (numConstructSignatures) {
|
|
error(node, Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
|
|
} else {
|
|
let relatedInformation;
|
|
if (node.arguments.length === 1) {
|
|
const text = getSourceFileOfNode(node).text;
|
|
if (isLineBreak(text.charCodeAt(skipTrivia(text, node.expression.end, true) - 1))) {
|
|
relatedInformation = createDiagnosticForNode(node.expression, Diagnostics.Are_you_missing_a_semicolon);
|
|
}
|
|
}
|
|
invocationError(node.expression, apparentType, 0 /* Call */, relatedInformation);
|
|
}
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
|
|
skippedGenericFunction(node, checkMode);
|
|
return resolvingSignature;
|
|
}
|
|
if (callSignatures.some((sig) => isInJSFile(sig.declaration) && !!getJSDocClassTag(sig.declaration))) {
|
|
error(node, Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType));
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
|
|
}
|
|
function isGenericFunctionReturningFunction(signature) {
|
|
return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
|
|
}
|
|
function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
|
|
return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
|
|
}
|
|
function resolveNewExpression(node, candidatesOutArray, checkMode) {
|
|
if (node.arguments && languageVersion < 1 /* ES5 */) {
|
|
const spreadIndex = getSpreadArgumentIndex(node.arguments);
|
|
if (spreadIndex >= 0) {
|
|
error(node.arguments[spreadIndex], Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher);
|
|
}
|
|
}
|
|
let expressionType = checkNonNullExpression(node.expression);
|
|
if (expressionType === silentNeverType) {
|
|
return silentNeverSignature;
|
|
}
|
|
expressionType = getApparentType(expressionType);
|
|
if (isErrorType(expressionType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (isTypeAny(expressionType)) {
|
|
if (node.typeArguments) {
|
|
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
|
|
}
|
|
return resolveUntypedCall(node);
|
|
}
|
|
const constructSignatures = getSignaturesOfType(expressionType, 1 /* Construct */);
|
|
if (constructSignatures.length) {
|
|
if (!isConstructorAccessible(node, constructSignatures[0])) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
if (someSignature(constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */))) {
|
|
error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
|
|
return resolveErrorCall(node);
|
|
}
|
|
const valueDecl = expressionType.symbol && getClassLikeDeclarationOfSymbol(expressionType.symbol);
|
|
if (valueDecl && hasSyntacticModifier(valueDecl, 256 /* Abstract */)) {
|
|
error(node, Diagnostics.Cannot_create_an_instance_of_an_abstract_class);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
const callSignatures = getSignaturesOfType(expressionType, 0 /* Call */);
|
|
if (callSignatures.length) {
|
|
const signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
if (!noImplicitAny) {
|
|
if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) {
|
|
error(node, Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);
|
|
}
|
|
if (getThisTypeOfSignature(signature) === voidType) {
|
|
error(node, Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void);
|
|
}
|
|
}
|
|
return signature;
|
|
}
|
|
invocationError(node.expression, expressionType, 1 /* Construct */);
|
|
return resolveErrorCall(node);
|
|
}
|
|
function someSignature(signatures, f) {
|
|
if (isArray(signatures)) {
|
|
return some(signatures, (signature) => someSignature(signature, f));
|
|
}
|
|
return signatures.compositeKind === 1048576 /* Union */ ? some(signatures.compositeSignatures, f) : f(signatures);
|
|
}
|
|
function typeHasProtectedAccessibleBase(target, type) {
|
|
const baseTypes = getBaseTypes(type);
|
|
if (!length(baseTypes)) {
|
|
return false;
|
|
}
|
|
const firstBase = baseTypes[0];
|
|
if (firstBase.flags & 2097152 /* Intersection */) {
|
|
const types = firstBase.types;
|
|
const mixinFlags = findMixins(types);
|
|
let i = 0;
|
|
for (const intersectionMember of firstBase.types) {
|
|
if (!mixinFlags[i]) {
|
|
if (getObjectFlags(intersectionMember) & (1 /* Class */ | 2 /* Interface */)) {
|
|
if (intersectionMember.symbol === target) {
|
|
return true;
|
|
}
|
|
if (typeHasProtectedAccessibleBase(target, intersectionMember)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
return false;
|
|
}
|
|
if (firstBase.symbol === target) {
|
|
return true;
|
|
}
|
|
return typeHasProtectedAccessibleBase(target, firstBase);
|
|
}
|
|
function isConstructorAccessible(node, signature) {
|
|
if (!signature || !signature.declaration) {
|
|
return true;
|
|
}
|
|
const declaration = signature.declaration;
|
|
const modifiers = getSelectedEffectiveModifierFlags(declaration, 24 /* NonPublicAccessibilityModifier */);
|
|
if (!modifiers || declaration.kind !== 173 /* Constructor */) {
|
|
return true;
|
|
}
|
|
const declaringClassDeclaration = getClassLikeDeclarationOfSymbol(declaration.parent.symbol);
|
|
const declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol);
|
|
if (!isNodeWithinClass(node, declaringClassDeclaration)) {
|
|
const containingClass = getContainingClass(node);
|
|
if (containingClass && modifiers & 16 /* Protected */) {
|
|
const containingType = getTypeOfNode(containingClass);
|
|
if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (modifiers & 8 /* Private */) {
|
|
error(node, Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
|
|
}
|
|
if (modifiers & 16 /* Protected */) {
|
|
error(node, Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass));
|
|
}
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function invocationErrorDetails(errorTarget, apparentType, kind) {
|
|
let errorInfo;
|
|
const isCall = kind === 0 /* Call */;
|
|
const awaitedType = getAwaitedType(apparentType);
|
|
const maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0;
|
|
if (apparentType.flags & 1048576 /* Union */) {
|
|
const types = apparentType.types;
|
|
let hasSignatures = false;
|
|
for (const constituent of types) {
|
|
const signatures = getSignaturesOfType(constituent, kind);
|
|
if (signatures.length !== 0) {
|
|
hasSignatures = true;
|
|
if (errorInfo) {
|
|
break;
|
|
}
|
|
} else {
|
|
if (!errorInfo) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Type_0_has_no_call_signatures : Diagnostics.Type_0_has_no_construct_signatures,
|
|
typeToString(constituent)
|
|
);
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Not_all_constituents_of_type_0_are_callable : Diagnostics.Not_all_constituents_of_type_0_are_constructable,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
if (hasSignatures) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!hasSignatures) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
void 0,
|
|
isCall ? Diagnostics.No_constituent_of_type_0_is_callable : Diagnostics.No_constituent_of_type_0_is_constructable,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
if (!errorInfo) {
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other : Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
} else {
|
|
errorInfo = chainDiagnosticMessages(
|
|
errorInfo,
|
|
isCall ? Diagnostics.Type_0_has_no_call_signatures : Diagnostics.Type_0_has_no_construct_signatures,
|
|
typeToString(apparentType)
|
|
);
|
|
}
|
|
let headMessage = isCall ? Diagnostics.This_expression_is_not_callable : Diagnostics.This_expression_is_not_constructable;
|
|
if (isCallExpression(errorTarget.parent) && errorTarget.parent.arguments.length === 0) {
|
|
const { resolvedSymbol } = getNodeLinks(errorTarget);
|
|
if (resolvedSymbol && resolvedSymbol.flags & 32768 /* GetAccessor */) {
|
|
headMessage = Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without;
|
|
}
|
|
}
|
|
return {
|
|
messageChain: chainDiagnosticMessages(errorInfo, headMessage),
|
|
relatedMessage: maybeMissingAwait ? Diagnostics.Did_you_forget_to_use_await : void 0
|
|
};
|
|
}
|
|
function invocationError(errorTarget, apparentType, kind, relatedInformation) {
|
|
const { messageChain, relatedMessage: relatedInfo } = invocationErrorDetails(errorTarget, apparentType, kind);
|
|
const diagnostic = createDiagnosticForNodeFromMessageChain(errorTarget, messageChain);
|
|
if (relatedInfo) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
|
|
}
|
|
if (isCallExpression(errorTarget.parent)) {
|
|
const { start: start2, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent, true);
|
|
diagnostic.start = start2;
|
|
diagnostic.length = length2;
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
invocationErrorRecovery(apparentType, kind, relatedInformation ? addRelatedInfo(diagnostic, relatedInformation) : diagnostic);
|
|
}
|
|
function invocationErrorRecovery(apparentType, kind, diagnostic) {
|
|
if (!apparentType.symbol) {
|
|
return;
|
|
}
|
|
const importNode = getSymbolLinks(apparentType.symbol).originatingImport;
|
|
if (importNode && !isImportCall(importNode)) {
|
|
const sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind);
|
|
if (!sigs || !sigs.length)
|
|
return;
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createDiagnosticForNode(importNode, Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead)
|
|
);
|
|
}
|
|
}
|
|
function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) {
|
|
const tagType = checkExpression(node.tag);
|
|
const apparentType = getApparentType(tagType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (!callSignatures.length) {
|
|
if (isArrayLiteralExpression(node.parent)) {
|
|
const diagnostic = createDiagnosticForNode(node.tag, Diagnostics.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);
|
|
diagnostics.add(diagnostic);
|
|
return resolveErrorCall(node);
|
|
}
|
|
invocationError(node.tag, apparentType, 0 /* Call */);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
function getDiagnosticHeadMessageForDecoratorResolution(node) {
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression;
|
|
case 166 /* Parameter */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression;
|
|
case 169 /* PropertyDeclaration */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
}
|
|
function resolveDecorator(node, candidatesOutArray, checkMode) {
|
|
const funcType = checkExpression(node.expression);
|
|
const apparentType = getApparentType(funcType);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const callSignatures = getSignaturesOfType(apparentType, 0 /* Call */);
|
|
const numConstructSignatures = getSignaturesOfType(apparentType, 1 /* Construct */).length;
|
|
if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (isPotentiallyUncalledDecorator(node, callSignatures)) {
|
|
const nodeStr = getTextOfNode(node.expression, false);
|
|
error(node, Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr);
|
|
return resolveErrorCall(node);
|
|
}
|
|
const headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
|
|
if (!callSignatures.length) {
|
|
const errorDetails = invocationErrorDetails(node.expression, apparentType, 0 /* Call */);
|
|
const messageChain = chainDiagnosticMessages(errorDetails.messageChain, headMessage);
|
|
const diag2 = createDiagnosticForNodeFromMessageChain(node.expression, messageChain);
|
|
if (errorDetails.relatedMessage) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(node.expression, errorDetails.relatedMessage));
|
|
}
|
|
diagnostics.add(diag2);
|
|
invocationErrorRecovery(apparentType, 0 /* Call */, diag2);
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* None */, headMessage);
|
|
}
|
|
function createSignatureForJSXIntrinsic(node, result) {
|
|
const namespace = getJsxNamespaceAt(node);
|
|
const exports = namespace && getExportsOfSymbol(namespace);
|
|
const typeSymbol = exports && getSymbol2(exports, JsxNames.Element, 788968 /* Type */);
|
|
const returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968 /* Type */, node);
|
|
const declaration = factory.createFunctionTypeNode(
|
|
void 0,
|
|
[factory.createParameterDeclaration(void 0, void 0, "props", void 0, nodeBuilder.typeToTypeNode(result, node))],
|
|
returnNode ? factory.createTypeReferenceNode(returnNode, void 0) : factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
);
|
|
const parameterSymbol = createSymbol(1 /* FunctionScopedVariable */, "props");
|
|
parameterSymbol.type = result;
|
|
return createSignature(
|
|
declaration,
|
|
void 0,
|
|
void 0,
|
|
[parameterSymbol],
|
|
typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType,
|
|
void 0,
|
|
1,
|
|
0 /* None */
|
|
);
|
|
}
|
|
function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) {
|
|
if (isJsxIntrinsicIdentifier(node.tagName)) {
|
|
const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
|
|
const fakeSignature = createSignatureForJSXIntrinsic(node, result);
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), void 0, 0 /* Normal */), result, node.tagName, node.attributes);
|
|
if (length(node.typeArguments)) {
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments)));
|
|
}
|
|
return fakeSignature;
|
|
}
|
|
const exprTypes = checkExpression(node.tagName);
|
|
const apparentType = getApparentType(exprTypes);
|
|
if (isErrorType(apparentType)) {
|
|
return resolveErrorCall(node);
|
|
}
|
|
const signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node);
|
|
if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, 0)) {
|
|
return resolveUntypedCall(node);
|
|
}
|
|
if (signatures.length === 0) {
|
|
error(node.tagName, Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, getTextOfNode(node.tagName));
|
|
return resolveErrorCall(node);
|
|
}
|
|
return resolveCall(node, signatures, candidatesOutArray, checkMode, 0 /* None */);
|
|
}
|
|
function isPotentiallyUncalledDecorator(decorator, signatures) {
|
|
return signatures.length && every(signatures, (signature) => signature.minArgumentCount === 0 && !signatureHasRestParameter(signature) && signature.parameters.length < getDecoratorArgumentCount(decorator, signature));
|
|
}
|
|
function resolveSignature(node, candidatesOutArray, checkMode) {
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
return resolveCallExpression(node, candidatesOutArray, checkMode);
|
|
case 211 /* NewExpression */:
|
|
return resolveNewExpression(node, candidatesOutArray, checkMode);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode);
|
|
case 167 /* Decorator */:
|
|
return resolveDecorator(node, candidatesOutArray, checkMode);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
|
|
}
|
|
throw Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
|
|
}
|
|
function getResolvedSignature(node, candidatesOutArray, checkMode) {
|
|
const links = getNodeLinks(node);
|
|
const cached = links.resolvedSignature;
|
|
if (cached && cached !== resolvingSignature && !candidatesOutArray) {
|
|
return cached;
|
|
}
|
|
links.resolvedSignature = resolvingSignature;
|
|
const result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* Normal */);
|
|
if (result !== resolvingSignature) {
|
|
links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;
|
|
}
|
|
return result;
|
|
}
|
|
function isJSConstructor(node) {
|
|
var _a2;
|
|
if (!node || !isInJSFile(node)) {
|
|
return false;
|
|
}
|
|
const func = isFunctionDeclaration(node) || isFunctionExpression(node) ? node : (isVariableDeclaration(node) || isPropertyAssignment(node)) && node.initializer && isFunctionExpression(node.initializer) ? node.initializer : void 0;
|
|
if (func) {
|
|
if (getJSDocClassTag(node))
|
|
return true;
|
|
if (isPropertyAssignment(walkUpParenthesizedExpressions(func.parent)))
|
|
return false;
|
|
const symbol = getSymbolOfNode(func);
|
|
return !!((_a2 = symbol == null ? void 0 : symbol.members) == null ? void 0 : _a2.size);
|
|
}
|
|
return false;
|
|
}
|
|
function mergeJSSymbols(target, source) {
|
|
var _a2, _b;
|
|
if (source) {
|
|
const links = getSymbolLinks(source);
|
|
if (!links.inferredClassSymbol || !links.inferredClassSymbol.has(getSymbolId(target))) {
|
|
const inferred = isTransientSymbol(target) ? target : cloneSymbol(target);
|
|
inferred.exports = inferred.exports || createSymbolTable();
|
|
inferred.members = inferred.members || createSymbolTable();
|
|
inferred.flags |= source.flags & 32 /* Class */;
|
|
if ((_a2 = source.exports) == null ? void 0 : _a2.size) {
|
|
mergeSymbolTable(inferred.exports, source.exports);
|
|
}
|
|
if ((_b = source.members) == null ? void 0 : _b.size) {
|
|
mergeSymbolTable(inferred.members, source.members);
|
|
}
|
|
(links.inferredClassSymbol || (links.inferredClassSymbol = /* @__PURE__ */ new Map())).set(getSymbolId(inferred), inferred);
|
|
return inferred;
|
|
}
|
|
return links.inferredClassSymbol.get(getSymbolId(target));
|
|
}
|
|
}
|
|
function getAssignedClassSymbol(decl) {
|
|
var _a2;
|
|
const assignmentSymbol = decl && getSymbolOfExpando(decl, true);
|
|
const prototype = (_a2 = assignmentSymbol == null ? void 0 : assignmentSymbol.exports) == null ? void 0 : _a2.get("prototype");
|
|
const init = (prototype == null ? void 0 : prototype.valueDeclaration) && getAssignedJSPrototype(prototype.valueDeclaration);
|
|
return init ? getSymbolOfNode(init) : void 0;
|
|
}
|
|
function getSymbolOfExpando(node, allowDeclaration) {
|
|
if (!node.parent) {
|
|
return void 0;
|
|
}
|
|
let name;
|
|
let decl;
|
|
if (isVariableDeclaration(node.parent) && node.parent.initializer === node) {
|
|
if (!isInJSFile(node) && !(isVarConst(node.parent) && isFunctionLikeDeclaration(node))) {
|
|
return void 0;
|
|
}
|
|
name = node.parent.name;
|
|
decl = node.parent;
|
|
} else if (isBinaryExpression(node.parent)) {
|
|
const parentNode = node.parent;
|
|
const parentNodeOperator = node.parent.operatorToken.kind;
|
|
if (parentNodeOperator === 63 /* EqualsToken */ && (allowDeclaration || parentNode.right === node)) {
|
|
name = parentNode.left;
|
|
decl = name;
|
|
} else if (parentNodeOperator === 56 /* BarBarToken */ || parentNodeOperator === 60 /* QuestionQuestionToken */) {
|
|
if (isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) {
|
|
name = parentNode.parent.name;
|
|
decl = parentNode.parent;
|
|
} else if (isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 63 /* EqualsToken */ && (allowDeclaration || parentNode.parent.right === parentNode)) {
|
|
name = parentNode.parent.left;
|
|
decl = name;
|
|
}
|
|
if (!name || !isBindableStaticNameExpression(name) || !isSameEntityName(name, parentNode.left)) {
|
|
return void 0;
|
|
}
|
|
}
|
|
} else if (allowDeclaration && isFunctionDeclaration(node)) {
|
|
name = node.name;
|
|
decl = node;
|
|
}
|
|
if (!decl || !name || !allowDeclaration && !getExpandoInitializer(node, isPrototypeAccess(name))) {
|
|
return void 0;
|
|
}
|
|
return getSymbolOfNode(decl);
|
|
}
|
|
function getAssignedJSPrototype(node) {
|
|
if (!node.parent) {
|
|
return false;
|
|
}
|
|
let parent2 = node.parent;
|
|
while (parent2 && parent2.kind === 208 /* PropertyAccessExpression */) {
|
|
parent2 = parent2.parent;
|
|
}
|
|
if (parent2 && isBinaryExpression(parent2) && isPrototypeAccess(parent2.left) && parent2.operatorToken.kind === 63 /* EqualsToken */) {
|
|
const right = getInitializerOfBinaryExpression(parent2);
|
|
return isObjectLiteralExpression(right) && right;
|
|
}
|
|
}
|
|
function checkCallExpression(node, checkMode) {
|
|
var _a2;
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
const signature = getResolvedSignature(node, void 0, checkMode);
|
|
if (signature === resolvingSignature) {
|
|
return silentNeverType;
|
|
}
|
|
checkDeprecatedSignature(signature, node);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return voidType;
|
|
}
|
|
if (node.kind === 211 /* NewExpression */) {
|
|
const declaration = signature.declaration;
|
|
if (declaration && declaration.kind !== 173 /* Constructor */ && declaration.kind !== 177 /* ConstructSignature */ && declaration.kind !== 182 /* ConstructorType */ && !isJSDocConstructSignature(declaration) && !isJSConstructor(declaration)) {
|
|
if (noImplicitAny) {
|
|
error(node, Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type);
|
|
}
|
|
return anyType;
|
|
}
|
|
}
|
|
if (isInJSFile(node) && isCommonJsRequire(node)) {
|
|
return resolveExternalModuleTypeByLiteral(node.arguments[0]);
|
|
}
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType.flags & 12288 /* ESSymbolLike */ && isSymbolOrSymbolForCall(node)) {
|
|
return getESSymbolLikeTypeForNode(walkUpParenthesizedExpressions(node.parent));
|
|
}
|
|
if (node.kind === 210 /* CallExpression */ && !node.questionDotToken && node.parent.kind === 241 /* ExpressionStatement */ && returnType.flags & 16384 /* Void */ && getTypePredicateOfSignature(signature)) {
|
|
if (!isDottedName(node.expression)) {
|
|
error(node.expression, Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name);
|
|
} else if (!getEffectsSignature(node)) {
|
|
const diagnostic = error(node.expression, Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation);
|
|
getTypeOfDottedName(node.expression, diagnostic);
|
|
}
|
|
}
|
|
if (isInJSFile(node)) {
|
|
const jsSymbol = getSymbolOfExpando(node, false);
|
|
if ((_a2 = jsSymbol == null ? void 0 : jsSymbol.exports) == null ? void 0 : _a2.size) {
|
|
const jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, emptyArray, emptyArray, emptyArray);
|
|
jsAssignmentType.objectFlags |= 4096 /* JSLiteral */;
|
|
return getIntersectionType([returnType, jsAssignmentType]);
|
|
}
|
|
}
|
|
return returnType;
|
|
}
|
|
function checkDeprecatedSignature(signature, node) {
|
|
if (signature.declaration && signature.declaration.flags & 268435456 /* Deprecated */) {
|
|
const suggestionNode = getDeprecatedSuggestionNode(node);
|
|
const name = tryGetPropertyAccessOrIdentifierToString(getInvokedExpression(node));
|
|
addDeprecatedSuggestionWithSignature(suggestionNode, signature.declaration, name, signatureToString(signature));
|
|
}
|
|
}
|
|
function getDeprecatedSuggestionNode(node) {
|
|
node = skipParentheses(node);
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
case 167 /* Decorator */:
|
|
case 211 /* NewExpression */:
|
|
return getDeprecatedSuggestionNode(node.expression);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return getDeprecatedSuggestionNode(node.tag);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return getDeprecatedSuggestionNode(node.tagName);
|
|
case 209 /* ElementAccessExpression */:
|
|
return node.argumentExpression;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.name;
|
|
case 180 /* TypeReference */:
|
|
const typeReference = node;
|
|
return isQualifiedName(typeReference.typeName) ? typeReference.typeName.right : typeReference;
|
|
default:
|
|
return node;
|
|
}
|
|
}
|
|
function isSymbolOrSymbolForCall(node) {
|
|
if (!isCallExpression(node))
|
|
return false;
|
|
let left = node.expression;
|
|
if (isPropertyAccessExpression(left) && left.name.escapedText === "for") {
|
|
left = left.expression;
|
|
}
|
|
if (!isIdentifier(left) || left.escapedText !== "Symbol") {
|
|
return false;
|
|
}
|
|
const globalESSymbol = getGlobalESSymbolConstructorSymbol(false);
|
|
if (!globalESSymbol) {
|
|
return false;
|
|
}
|
|
return globalESSymbol === resolveName(left, "Symbol", 111551 /* Value */, void 0, void 0, false);
|
|
}
|
|
function checkImportCallExpression(node) {
|
|
checkGrammarImportCallExpression(node);
|
|
if (node.arguments.length === 0) {
|
|
return createPromiseReturnType(node, anyType);
|
|
}
|
|
const specifier = node.arguments[0];
|
|
const specifierType = checkExpressionCached(specifier);
|
|
const optionsType = node.arguments.length > 1 ? checkExpressionCached(node.arguments[1]) : void 0;
|
|
for (let i = 2; i < node.arguments.length; ++i) {
|
|
checkExpressionCached(node.arguments[i]);
|
|
}
|
|
if (specifierType.flags & 32768 /* Undefined */ || specifierType.flags & 65536 /* Null */ || !isTypeAssignableTo(specifierType, stringType)) {
|
|
error(specifier, Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType));
|
|
}
|
|
if (optionsType) {
|
|
const importCallOptionsType = getGlobalImportCallOptionsType(true);
|
|
if (importCallOptionsType !== emptyObjectType) {
|
|
checkTypeAssignableTo(optionsType, getNullableType(importCallOptionsType, 32768 /* Undefined */), node.arguments[1]);
|
|
}
|
|
}
|
|
const moduleSymbol = resolveExternalModuleName(node, specifier);
|
|
if (moduleSymbol) {
|
|
const esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, true, false);
|
|
if (esModuleSymbol) {
|
|
return createPromiseReturnType(
|
|
node,
|
|
getTypeWithSyntheticDefaultOnly(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) || getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier)
|
|
);
|
|
}
|
|
}
|
|
return createPromiseReturnType(node, anyType);
|
|
}
|
|
function createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol) {
|
|
const memberTable = createSymbolTable();
|
|
const newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
|
|
newSymbol.parent = originalSymbol;
|
|
newSymbol.nameType = getStringLiteralType("default");
|
|
newSymbol.aliasTarget = resolveSymbol(symbol);
|
|
memberTable.set("default" /* Default */, newSymbol);
|
|
return createAnonymousType(anonymousSymbol, memberTable, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) {
|
|
const hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier);
|
|
if (hasDefaultOnly && type && !isErrorType(type)) {
|
|
const synthType = type;
|
|
if (!synthType.defaultOnlyType) {
|
|
const type2 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
|
|
synthType.defaultOnlyType = type2;
|
|
}
|
|
return synthType.defaultOnlyType;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
|
|
var _a2;
|
|
if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
|
|
const synthType = type;
|
|
if (!synthType.syntheticType) {
|
|
const file = (_a2 = originalSymbol.declarations) == null ? void 0 : _a2.find(isSourceFile);
|
|
const hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, false, moduleSpecifier);
|
|
if (hasSyntheticDefault) {
|
|
const anonymousSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
|
|
const defaultContainingObject = createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol);
|
|
anonymousSymbol.type = defaultContainingObject;
|
|
synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, 0, false) : defaultContainingObject;
|
|
} else {
|
|
synthType.syntheticType = type;
|
|
}
|
|
}
|
|
return synthType.syntheticType;
|
|
}
|
|
return type;
|
|
}
|
|
function isCommonJsRequire(node) {
|
|
if (!isRequireCall(node, true)) {
|
|
return false;
|
|
}
|
|
if (!isIdentifier(node.expression))
|
|
return Debug.fail();
|
|
const resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551 /* Value */, void 0, void 0, true);
|
|
if (resolvedRequire === requireSymbol) {
|
|
return true;
|
|
}
|
|
if (resolvedRequire.flags & 2097152 /* Alias */) {
|
|
return false;
|
|
}
|
|
const targetDeclarationKind = resolvedRequire.flags & 16 /* Function */ ? 259 /* FunctionDeclaration */ : resolvedRequire.flags & 3 /* Variable */ ? 257 /* VariableDeclaration */ : 0 /* Unknown */;
|
|
if (targetDeclarationKind !== 0 /* Unknown */) {
|
|
const decl = getDeclarationOfKind(resolvedRequire, targetDeclarationKind);
|
|
return !!decl && !!(decl.flags & 16777216 /* Ambient */);
|
|
}
|
|
return false;
|
|
}
|
|
function checkTaggedTemplateExpression(node) {
|
|
if (!checkGrammarTaggedTemplateChain(node))
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */);
|
|
}
|
|
const signature = getResolvedSignature(node);
|
|
checkDeprecatedSignature(signature, node);
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
function checkAssertion(node) {
|
|
if (node.kind === 213 /* TypeAssertionExpression */) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (file && fileExtensionIsOneOf(file.fileName, [".cts" /* Cts */, ".mts" /* Mts */])) {
|
|
grammarErrorOnNode(node, Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
|
|
}
|
|
}
|
|
return checkAssertionWorker(node, node.type, node.expression);
|
|
}
|
|
function isValidConstAssertionArgument(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 225 /* TemplateExpression */:
|
|
return true;
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isValidConstAssertionArgument(node.expression);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const op = node.operator;
|
|
const arg = node.operand;
|
|
return op === 40 /* MinusToken */ && (arg.kind === 8 /* NumericLiteral */ || arg.kind === 9 /* BigIntLiteral */) || op === 39 /* PlusToken */ && arg.kind === 8 /* NumericLiteral */;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
const expr = node.expression;
|
|
let symbol = getTypeOfNode(expr).symbol;
|
|
if (symbol && symbol.flags & 2097152 /* Alias */) {
|
|
symbol = resolveAlias(symbol);
|
|
}
|
|
return !!(symbol && getAllSymbolFlags(symbol) & 384 /* Enum */);
|
|
}
|
|
return false;
|
|
}
|
|
function checkAssertionWorker(errNode, type, expression, checkMode) {
|
|
let exprType = checkExpression(expression, checkMode);
|
|
if (isConstTypeReference(type)) {
|
|
if (!isValidConstAssertionArgument(expression)) {
|
|
error(expression, Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals);
|
|
}
|
|
return getRegularTypeOfLiteralType(exprType);
|
|
}
|
|
checkSourceElement(type);
|
|
exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType));
|
|
const targetType = getTypeFromTypeNode(type);
|
|
if (!isErrorType(targetType)) {
|
|
addLazyDiagnostic(() => {
|
|
const widenedType = getWidenedType(exprType);
|
|
if (!isTypeComparableTo(targetType, widenedType)) {
|
|
checkTypeComparableTo(
|
|
exprType,
|
|
targetType,
|
|
errNode,
|
|
Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first
|
|
);
|
|
}
|
|
});
|
|
}
|
|
return targetType;
|
|
}
|
|
function checkNonNullChain(node) {
|
|
const leftType = checkExpression(node.expression);
|
|
const nonOptionalType = getOptionalExpressionType(leftType, node.expression);
|
|
return propagateOptionalTypeMarker(getNonNullableType(nonOptionalType), node, nonOptionalType !== leftType);
|
|
}
|
|
function checkNonNullAssertion(node) {
|
|
return node.flags & 32 /* OptionalChain */ ? checkNonNullChain(node) : getNonNullableType(checkExpression(node.expression));
|
|
}
|
|
function checkExpressionWithTypeArguments(node) {
|
|
checkGrammarExpressionWithTypeArguments(node);
|
|
const exprType = node.kind === 230 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) : isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
|
|
const typeArguments = node.typeArguments;
|
|
if (exprType === silentNeverType || isErrorType(exprType) || !some(typeArguments)) {
|
|
return exprType;
|
|
}
|
|
let hasSomeApplicableSignature = false;
|
|
let nonApplicableType;
|
|
const result = getInstantiatedType(exprType);
|
|
const errorType2 = hasSomeApplicableSignature ? nonApplicableType : exprType;
|
|
if (errorType2) {
|
|
diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments, Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType2)));
|
|
}
|
|
return result;
|
|
function getInstantiatedType(type) {
|
|
let hasSignatures = false;
|
|
let hasApplicableSignature = false;
|
|
const result2 = getInstantiatedTypePart(type);
|
|
hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature);
|
|
if (hasSignatures && !hasApplicableSignature) {
|
|
nonApplicableType != null ? nonApplicableType : nonApplicableType = type;
|
|
}
|
|
return result2;
|
|
function getInstantiatedTypePart(type2) {
|
|
if (type2.flags & 524288 /* Object */) {
|
|
const resolved = resolveStructuredTypeMembers(type2);
|
|
const callSignatures = getInstantiatedSignatures(resolved.callSignatures);
|
|
const constructSignatures = getInstantiatedSignatures(resolved.constructSignatures);
|
|
hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
|
|
hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
|
|
if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
|
|
const result3 = createAnonymousType(void 0, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
|
|
result3.objectFlags |= 8388608 /* InstantiationExpressionType */;
|
|
result3.node = node;
|
|
return result3;
|
|
}
|
|
} else if (type2.flags & 58982400 /* InstantiableNonPrimitive */) {
|
|
const constraint = getBaseConstraintOfType(type2);
|
|
if (constraint) {
|
|
const instantiated = getInstantiatedTypePart(constraint);
|
|
if (instantiated !== constraint) {
|
|
return instantiated;
|
|
}
|
|
}
|
|
} else if (type2.flags & 1048576 /* Union */) {
|
|
return mapType(type2, getInstantiatedType);
|
|
} else if (type2.flags & 2097152 /* Intersection */) {
|
|
return getIntersectionType(sameMap(type2.types, getInstantiatedTypePart));
|
|
}
|
|
return type2;
|
|
}
|
|
}
|
|
function getInstantiatedSignatures(signatures) {
|
|
const applicableSignatures = filter(signatures, (sig) => !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments));
|
|
return sameMap(applicableSignatures, (sig) => {
|
|
const typeArgumentTypes = checkTypeArguments(sig, typeArguments, true);
|
|
return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, isInJSFile(sig.declaration)) : sig;
|
|
});
|
|
}
|
|
}
|
|
function checkSatisfiesExpression(node) {
|
|
checkSourceElement(node.type);
|
|
const targetType = getTypeFromTypeNode(node.type);
|
|
if (isErrorType(targetType)) {
|
|
return targetType;
|
|
}
|
|
const exprType = checkExpression(node.expression);
|
|
checkTypeAssignableToAndOptionallyElaborate(exprType, targetType, node.type, node.expression, Diagnostics.Type_0_does_not_satisfy_the_expected_type_1);
|
|
return exprType;
|
|
}
|
|
function checkMetaProperty(node) {
|
|
checkGrammarMetaProperty(node);
|
|
if (node.keywordToken === 103 /* NewKeyword */) {
|
|
return checkNewTargetMetaProperty(node);
|
|
}
|
|
if (node.keywordToken === 100 /* ImportKeyword */) {
|
|
return checkImportMetaProperty(node);
|
|
}
|
|
return Debug.assertNever(node.keywordToken);
|
|
}
|
|
function checkMetaPropertyKeyword(node) {
|
|
switch (node.keywordToken) {
|
|
case 100 /* ImportKeyword */:
|
|
return getGlobalImportMetaExpressionType();
|
|
case 103 /* NewKeyword */:
|
|
const type = checkNewTargetMetaProperty(node);
|
|
return isErrorType(type) ? errorType : createNewTargetExpressionType(type);
|
|
default:
|
|
Debug.assertNever(node.keywordToken);
|
|
}
|
|
}
|
|
function checkNewTargetMetaProperty(node) {
|
|
const container = getNewTargetContainer(node);
|
|
if (!container) {
|
|
error(node, Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target");
|
|
return errorType;
|
|
} else if (container.kind === 173 /* Constructor */) {
|
|
const symbol = getSymbolOfNode(container.parent);
|
|
return getTypeOfSymbol(symbol);
|
|
} else {
|
|
const symbol = getSymbolOfNode(container);
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
function checkImportMetaProperty(node) {
|
|
if (moduleKind === 100 /* Node16 */ || moduleKind === 199 /* NodeNext */) {
|
|
if (getSourceFileOfNode(node).impliedNodeFormat !== 99 /* ESNext */) {
|
|
error(node, Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output);
|
|
}
|
|
} else if (moduleKind < 6 /* ES2020 */ && moduleKind !== 4 /* System */) {
|
|
error(node, Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext);
|
|
}
|
|
const file = getSourceFileOfNode(node);
|
|
Debug.assert(!!(file.flags & 4194304 /* PossiblyContainsImportMeta */), "Containing file is missing import meta node flag.");
|
|
return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType;
|
|
}
|
|
function getTypeOfParameter(symbol) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
if (strictNullChecks) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && hasInitializer(declaration)) {
|
|
return getOptionalType(type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function getTupleElementLabel(d) {
|
|
Debug.assert(isIdentifier(d.name));
|
|
return d.name.escapedText;
|
|
}
|
|
function getParameterNameAtPosition(signature, pos, overrideRestType) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
return signature.parameters[pos].escapedName;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
const restType = overrideRestType || getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index;
|
|
}
|
|
return restParameter.escapedName;
|
|
}
|
|
function getParameterIdentifierNameAtPosition(signature, pos) {
|
|
var _a2;
|
|
if (((_a2 = signature.declaration) == null ? void 0 : _a2.kind) === 320 /* JSDocFunctionType */) {
|
|
return void 0;
|
|
}
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
const param = signature.parameters[pos];
|
|
return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : void 0;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
if (!isParameterDeclarationWithIdentifierName(restParameter)) {
|
|
return void 0;
|
|
}
|
|
const restType = getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
const associatedName = associatedNames == null ? void 0 : associatedNames[index];
|
|
const isRestTupleElement = !!(associatedName == null ? void 0 : associatedName.dotDotDotToken);
|
|
return associatedName ? [
|
|
getTupleElementLabel(associatedName),
|
|
isRestTupleElement
|
|
] : void 0;
|
|
}
|
|
if (pos === paramCount) {
|
|
return [restParameter.escapedName, true];
|
|
}
|
|
return void 0;
|
|
}
|
|
function isParameterDeclarationWithIdentifierName(symbol) {
|
|
return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name);
|
|
}
|
|
function isValidDeclarationForTupleLabel(d) {
|
|
return d.kind === 199 /* NamedTupleMember */ || isParameter(d) && d.name && isIdentifier(d.name);
|
|
}
|
|
function getNameableDeclarationAtPosition(signature, pos) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
const decl = signature.parameters[pos].valueDeclaration;
|
|
return decl && isValidDeclarationForTupleLabel(decl) ? decl : void 0;
|
|
}
|
|
const restParameter = signature.parameters[paramCount] || unknownSymbol;
|
|
const restType = getTypeOfSymbol(restParameter);
|
|
if (isTupleType(restType)) {
|
|
const associatedNames = restType.target.labeledElementDeclarations;
|
|
const index = pos - paramCount;
|
|
return associatedNames && associatedNames[index];
|
|
}
|
|
return restParameter.valueDeclaration && isValidDeclarationForTupleLabel(restParameter.valueDeclaration) ? restParameter.valueDeclaration : void 0;
|
|
}
|
|
function getTypeAtPosition(signature, pos) {
|
|
return tryGetTypeAtPosition(signature, pos) || anyType;
|
|
}
|
|
function tryGetTypeAtPosition(signature, pos) {
|
|
const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
if (pos < paramCount) {
|
|
return getTypeOfParameter(signature.parameters[pos]);
|
|
}
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[paramCount]);
|
|
const index = pos - paramCount;
|
|
if (!isTupleType(restType) || restType.target.hasRestElement || index < restType.target.fixedLength) {
|
|
return getIndexedAccessType(restType, getNumberLiteralType(index));
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getRestTypeAtPosition(source, pos) {
|
|
const parameterCount = getParameterCount(source);
|
|
const minArgumentCount = getMinArgumentCount(source);
|
|
const restType = getEffectiveRestType(source);
|
|
if (restType && pos >= parameterCount - 1) {
|
|
return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
|
|
}
|
|
const types = [];
|
|
const flags = [];
|
|
const names = [];
|
|
for (let i = pos; i < parameterCount; i++) {
|
|
if (!restType || i < parameterCount - 1) {
|
|
types.push(getTypeAtPosition(source, i));
|
|
flags.push(i < minArgumentCount ? 1 /* Required */ : 2 /* Optional */);
|
|
} else {
|
|
types.push(restType);
|
|
flags.push(8 /* Variadic */);
|
|
}
|
|
const name = getNameableDeclarationAtPosition(source, i);
|
|
if (name) {
|
|
names.push(name);
|
|
}
|
|
}
|
|
return createTupleType(types, flags, false, length(names) === length(types) ? names : void 0);
|
|
}
|
|
function getParameterCount(signature) {
|
|
const length2 = signature.parameters.length;
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[length2 - 1]);
|
|
if (isTupleType(restType)) {
|
|
return length2 + restType.target.fixedLength - (restType.target.hasRestElement ? 0 : 1);
|
|
}
|
|
}
|
|
return length2;
|
|
}
|
|
function getMinArgumentCount(signature, flags) {
|
|
const strongArityForUntypedJS = flags & 1 /* StrongArityForUntypedJS */;
|
|
const voidIsNonOptional = flags & 2 /* VoidIsNonOptional */;
|
|
if (voidIsNonOptional || signature.resolvedMinArgumentCount === void 0) {
|
|
let minArgumentCount;
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
if (isTupleType(restType)) {
|
|
const firstOptionalIndex = findIndex(restType.target.elementFlags, (f) => !(f & 1 /* Required */));
|
|
const requiredCount = firstOptionalIndex < 0 ? restType.target.fixedLength : firstOptionalIndex;
|
|
if (requiredCount > 0) {
|
|
minArgumentCount = signature.parameters.length - 1 + requiredCount;
|
|
}
|
|
}
|
|
}
|
|
if (minArgumentCount === void 0) {
|
|
if (!strongArityForUntypedJS && signature.flags & 32 /* IsUntypedSignatureInJSFile */) {
|
|
return 0;
|
|
}
|
|
minArgumentCount = signature.minArgumentCount;
|
|
}
|
|
if (voidIsNonOptional) {
|
|
return minArgumentCount;
|
|
}
|
|
for (let i = minArgumentCount - 1; i >= 0; i--) {
|
|
const type = getTypeAtPosition(signature, i);
|
|
if (filterType(type, acceptsVoid).flags & 131072 /* Never */) {
|
|
break;
|
|
}
|
|
minArgumentCount = i;
|
|
}
|
|
signature.resolvedMinArgumentCount = minArgumentCount;
|
|
}
|
|
return signature.resolvedMinArgumentCount;
|
|
}
|
|
function hasEffectiveRestParameter(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
return !isTupleType(restType) || restType.target.hasRestElement;
|
|
}
|
|
return false;
|
|
}
|
|
function getEffectiveRestType(signature) {
|
|
if (signatureHasRestParameter(signature)) {
|
|
const restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
|
|
if (!isTupleType(restType)) {
|
|
return restType;
|
|
}
|
|
if (restType.target.hasRestElement) {
|
|
return sliceTupleType(restType, restType.target.fixedLength);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getNonArrayRestType(signature) {
|
|
const restType = getEffectiveRestType(signature);
|
|
return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* Never */) === 0 ? restType : void 0;
|
|
}
|
|
function getTypeOfFirstParameterOfSignature(signature) {
|
|
return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType);
|
|
}
|
|
function getTypeOfFirstParameterOfSignatureWithFallback(signature, fallbackType) {
|
|
return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : fallbackType;
|
|
}
|
|
function inferFromAnnotatedParameters(signature, context, inferenceContext) {
|
|
const len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
for (let i = 0; i < len; i++) {
|
|
const declaration = signature.parameters[i].valueDeclaration;
|
|
if (declaration.type) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(declaration);
|
|
if (typeNode) {
|
|
inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function assignContextualParameterTypes(signature, context) {
|
|
if (context.typeParameters) {
|
|
if (!signature.typeParameters) {
|
|
signature.typeParameters = context.typeParameters;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (context.thisParameter) {
|
|
const parameter = signature.thisParameter;
|
|
if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) {
|
|
if (!parameter) {
|
|
signature.thisParameter = createSymbolWithType(context.thisParameter, void 0);
|
|
}
|
|
assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter));
|
|
}
|
|
}
|
|
const len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
|
|
for (let i = 0; i < len; i++) {
|
|
const parameter = signature.parameters[i];
|
|
if (!getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) {
|
|
const contextualParameterType = tryGetTypeAtPosition(context, i);
|
|
assignParameterType(parameter, contextualParameterType);
|
|
}
|
|
}
|
|
if (signatureHasRestParameter(signature)) {
|
|
const parameter = last(signature.parameters);
|
|
if (parameter.valueDeclaration ? !getEffectiveTypeAnnotationNode(parameter.valueDeclaration) : !!(getCheckFlags(parameter) & 65536 /* DeferredType */)) {
|
|
const contextualParameterType = getRestTypeAtPosition(context, len);
|
|
assignParameterType(parameter, contextualParameterType);
|
|
}
|
|
}
|
|
}
|
|
function assignNonContextualParameterTypes(signature) {
|
|
if (signature.thisParameter) {
|
|
assignParameterType(signature.thisParameter);
|
|
}
|
|
for (const parameter of signature.parameters) {
|
|
assignParameterType(parameter);
|
|
}
|
|
}
|
|
function assignParameterType(parameter, type) {
|
|
const links = getSymbolLinks(parameter);
|
|
if (!links.type) {
|
|
const declaration = parameter.valueDeclaration;
|
|
links.type = type || (declaration ? getWidenedTypeForVariableLikeDeclaration(declaration, true) : getTypeOfSymbol(parameter));
|
|
if (declaration && declaration.name.kind !== 79 /* Identifier */) {
|
|
if (links.type === unknownType) {
|
|
links.type = getTypeFromBindingPattern(declaration.name);
|
|
}
|
|
assignBindingElementTypes(declaration.name, links.type);
|
|
}
|
|
} else if (type) {
|
|
Debug.assertEqual(links.type, type, "Parameter symbol already has a cached type which differs from newly assigned type");
|
|
}
|
|
}
|
|
function assignBindingElementTypes(pattern, parentType) {
|
|
for (const element of pattern.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
const type = getBindingElementTypeFromParentType(element, parentType);
|
|
if (element.name.kind === 79 /* Identifier */) {
|
|
getSymbolLinks(getSymbolOfNode(element)).type = type;
|
|
} else {
|
|
assignBindingElementTypes(element.name, type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createPromiseType(promisedType) {
|
|
const globalPromiseType = getGlobalPromiseType(true);
|
|
if (globalPromiseType !== emptyGenericType) {
|
|
promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType;
|
|
return createTypeReference(globalPromiseType, [promisedType]);
|
|
}
|
|
return unknownType;
|
|
}
|
|
function createPromiseLikeType(promisedType) {
|
|
const globalPromiseLikeType = getGlobalPromiseLikeType(true);
|
|
if (globalPromiseLikeType !== emptyGenericType) {
|
|
promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType;
|
|
return createTypeReference(globalPromiseLikeType, [promisedType]);
|
|
}
|
|
return unknownType;
|
|
}
|
|
function createPromiseReturnType(func, promisedType) {
|
|
const promiseType = createPromiseType(promisedType);
|
|
if (promiseType === unknownType) {
|
|
error(func, isImportCall(func) ? Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option : Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
|
|
return errorType;
|
|
} else if (!getGlobalPromiseConstructorSymbol(true)) {
|
|
error(func, isImportCall(func) ? Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option : Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
|
|
}
|
|
return promiseType;
|
|
}
|
|
function createNewTargetExpressionType(targetType) {
|
|
const symbol = createSymbol(0 /* None */, "NewTargetExpression");
|
|
const targetPropertySymbol = createSymbol(4 /* Property */, "target", 8 /* Readonly */);
|
|
targetPropertySymbol.parent = symbol;
|
|
targetPropertySymbol.type = targetType;
|
|
const members = createSymbolTable([targetPropertySymbol]);
|
|
symbol.members = members;
|
|
return createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
function getReturnTypeFromBody(func, checkMode) {
|
|
if (!func.body) {
|
|
return errorType;
|
|
}
|
|
const functionFlags = getFunctionFlags(func);
|
|
const isAsync = (functionFlags & 2 /* Async */) !== 0;
|
|
const isGenerator = (functionFlags & 1 /* Generator */) !== 0;
|
|
let returnType;
|
|
let yieldType;
|
|
let nextType;
|
|
let fallbackReturnType = voidType;
|
|
if (func.body.kind !== 238 /* Block */) {
|
|
returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
|
|
if (isAsync) {
|
|
returnType = unwrapAwaitedType(checkAwaitedType(returnType, false, func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member));
|
|
}
|
|
} else if (isGenerator) {
|
|
const returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode);
|
|
if (!returnTypes) {
|
|
fallbackReturnType = neverType;
|
|
} else if (returnTypes.length > 0) {
|
|
returnType = getUnionType(returnTypes, 2 /* Subtype */);
|
|
}
|
|
const { yieldTypes, nextTypes } = checkAndAggregateYieldOperandTypes(func, checkMode);
|
|
yieldType = some(yieldTypes) ? getUnionType(yieldTypes, 2 /* Subtype */) : void 0;
|
|
nextType = some(nextTypes) ? getIntersectionType(nextTypes) : void 0;
|
|
} else {
|
|
const types = checkAndAggregateReturnExpressionTypes(func, checkMode);
|
|
if (!types) {
|
|
return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, neverType) : neverType;
|
|
}
|
|
if (types.length === 0) {
|
|
return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, voidType) : voidType;
|
|
}
|
|
returnType = getUnionType(types, 2 /* Subtype */);
|
|
}
|
|
if (returnType || yieldType || nextType) {
|
|
if (yieldType)
|
|
reportErrorsFromWidening(func, yieldType, 3 /* GeneratorYield */);
|
|
if (returnType)
|
|
reportErrorsFromWidening(func, returnType, 1 /* FunctionReturn */);
|
|
if (nextType)
|
|
reportErrorsFromWidening(func, nextType, 2 /* GeneratorNext */);
|
|
if (returnType && isUnitType(returnType) || yieldType && isUnitType(yieldType) || nextType && isUnitType(nextType)) {
|
|
const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
|
|
const contextualType = !contextualSignature ? void 0 : contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? void 0 : returnType : instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, void 0);
|
|
if (isGenerator) {
|
|
yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* Yield */, isAsync);
|
|
returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* Return */, isAsync);
|
|
nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2 /* Next */, isAsync);
|
|
} else {
|
|
returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync);
|
|
}
|
|
}
|
|
if (yieldType)
|
|
yieldType = getWidenedType(yieldType);
|
|
if (returnType)
|
|
returnType = getWidenedType(returnType);
|
|
if (nextType)
|
|
nextType = getWidenedType(nextType);
|
|
}
|
|
if (isGenerator) {
|
|
return createGeneratorReturnType(
|
|
yieldType || neverType,
|
|
returnType || fallbackReturnType,
|
|
nextType || getContextualIterationType(2 /* Next */, func) || unknownType,
|
|
isAsync
|
|
);
|
|
} else {
|
|
return isAsync ? createPromiseType(returnType || fallbackReturnType) : returnType || fallbackReturnType;
|
|
}
|
|
}
|
|
function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) {
|
|
const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
|
|
const globalGeneratorType = resolver.getGlobalGeneratorType(false);
|
|
yieldType = resolver.resolveIterationType(yieldType, void 0) || unknownType;
|
|
returnType = resolver.resolveIterationType(returnType, void 0) || unknownType;
|
|
nextType = resolver.resolveIterationType(nextType, void 0) || unknownType;
|
|
if (globalGeneratorType === emptyGenericType) {
|
|
const globalType = resolver.getGlobalIterableIteratorType(false);
|
|
const iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : void 0;
|
|
const iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType;
|
|
const iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType;
|
|
if (isTypeAssignableTo(returnType, iterableIteratorReturnType) && isTypeAssignableTo(iterableIteratorNextType, nextType)) {
|
|
if (globalType !== emptyGenericType) {
|
|
return createTypeFromGenericGlobalType(globalType, [yieldType]);
|
|
}
|
|
resolver.getGlobalIterableIteratorType(true);
|
|
return emptyObjectType;
|
|
}
|
|
resolver.getGlobalGeneratorType(true);
|
|
return emptyObjectType;
|
|
}
|
|
return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]);
|
|
}
|
|
function checkAndAggregateYieldOperandTypes(func, checkMode) {
|
|
const yieldTypes = [];
|
|
const nextTypes = [];
|
|
const isAsync = (getFunctionFlags(func) & 2 /* Async */) !== 0;
|
|
forEachYieldExpression(func.body, (yieldExpression) => {
|
|
const yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
|
|
pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
|
|
let nextType;
|
|
if (yieldExpression.asteriskToken) {
|
|
const iterationTypes = getIterationTypesOfIterable(
|
|
yieldExpressionType,
|
|
isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */,
|
|
yieldExpression.expression
|
|
);
|
|
nextType = iterationTypes && iterationTypes.nextType;
|
|
} else {
|
|
nextType = getContextualType2(yieldExpression, void 0);
|
|
}
|
|
if (nextType)
|
|
pushIfUnique(nextTypes, nextType);
|
|
});
|
|
return { yieldTypes, nextTypes };
|
|
}
|
|
function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) {
|
|
const errorNode = node.expression || node;
|
|
const yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */, expressionType, sentType, errorNode) : expressionType;
|
|
return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken ? Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member : Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
}
|
|
function getNotEqualFactsFromTypeofSwitch(start2, end, witnesses) {
|
|
let facts = 0 /* None */;
|
|
for (let i = 0; i < witnesses.length; i++) {
|
|
const witness = i < start2 || i >= end ? witnesses[i] : void 0;
|
|
facts |= witness !== void 0 ? typeofNEFacts.get(witness) || 32768 /* TypeofNEHostObject */ : 0;
|
|
}
|
|
return facts;
|
|
}
|
|
function isExhaustiveSwitchStatement(node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.isExhaustive === void 0) {
|
|
links.isExhaustive = 0;
|
|
const exhaustive = computeExhaustiveSwitchStatement(node);
|
|
if (links.isExhaustive === 0) {
|
|
links.isExhaustive = exhaustive;
|
|
}
|
|
} else if (links.isExhaustive === 0) {
|
|
links.isExhaustive = false;
|
|
}
|
|
return links.isExhaustive;
|
|
}
|
|
function computeExhaustiveSwitchStatement(node) {
|
|
if (node.expression.kind === 218 /* TypeOfExpression */) {
|
|
const witnesses = getSwitchClauseTypeOfWitnesses(node);
|
|
if (!witnesses) {
|
|
return false;
|
|
}
|
|
const operandConstraint = getBaseConstraintOrType(checkExpressionCached(node.expression.expression));
|
|
const notEqualFacts = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
|
|
if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
|
|
return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
|
|
}
|
|
return !someType(operandConstraint, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
|
|
}
|
|
const type = checkExpressionCached(node.expression);
|
|
if (!isLiteralType(type)) {
|
|
return false;
|
|
}
|
|
const switchTypes = getSwitchClauseTypes(node);
|
|
if (!switchTypes.length || some(switchTypes, isNeitherUnitTypeNorNever)) {
|
|
return false;
|
|
}
|
|
return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes);
|
|
}
|
|
function functionHasImplicitReturn(func) {
|
|
return func.endFlowNode && isReachableFlowNode(func.endFlowNode);
|
|
}
|
|
function checkAndAggregateReturnExpressionTypes(func, checkMode) {
|
|
const functionFlags = getFunctionFlags(func);
|
|
const aggregatedTypes = [];
|
|
let hasReturnWithNoExpression = functionHasImplicitReturn(func);
|
|
let hasReturnOfTypeNever = false;
|
|
forEachReturnStatement(func.body, (returnStatement) => {
|
|
const expr = returnStatement.expression;
|
|
if (expr) {
|
|
let type = checkExpressionCached(expr, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
|
|
if (functionFlags & 2 /* Async */) {
|
|
type = unwrapAwaitedType(checkAwaitedType(type, false, func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member));
|
|
}
|
|
if (type.flags & 131072 /* Never */) {
|
|
hasReturnOfTypeNever = true;
|
|
}
|
|
pushIfUnique(aggregatedTypes, type);
|
|
} else {
|
|
hasReturnWithNoExpression = true;
|
|
}
|
|
});
|
|
if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) {
|
|
return void 0;
|
|
}
|
|
if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression && !(isJSConstructor(func) && aggregatedTypes.some((t) => t.symbol === func.symbol))) {
|
|
pushIfUnique(aggregatedTypes, undefinedType);
|
|
}
|
|
return aggregatedTypes;
|
|
}
|
|
function mayReturnNever(func) {
|
|
switch (func.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
case 171 /* MethodDeclaration */:
|
|
return func.parent.kind === 207 /* ObjectLiteralExpression */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
|
|
addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
|
|
return;
|
|
function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() {
|
|
const functionFlags = getFunctionFlags(func);
|
|
const type = returnType && unwrapReturnType(returnType, functionFlags);
|
|
if (type && maybeTypeOfKind(type, 1 /* Any */ | 16384 /* Void */)) {
|
|
return;
|
|
}
|
|
if (func.kind === 170 /* MethodSignature */ || nodeIsMissing(func.body) || func.body.kind !== 238 /* Block */ || !functionHasImplicitReturn(func)) {
|
|
return;
|
|
}
|
|
const hasExplicitReturn = func.flags & 512 /* HasExplicitReturn */;
|
|
const errorNode = getEffectiveReturnTypeNode(func) || func;
|
|
if (type && type.flags & 131072 /* Never */) {
|
|
error(errorNode, Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
|
|
} else if (type && !hasExplicitReturn) {
|
|
error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
|
|
} else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
|
|
error(errorNode, Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
|
|
} else if (compilerOptions.noImplicitReturns) {
|
|
if (!type) {
|
|
if (!hasExplicitReturn) {
|
|
return;
|
|
}
|
|
const inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
|
|
if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
|
|
return;
|
|
}
|
|
}
|
|
error(errorNode, Diagnostics.Not_all_code_paths_return_a_value);
|
|
}
|
|
}
|
|
}
|
|
function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
checkNodeDeferred(node);
|
|
if (isFunctionExpression(node)) {
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
if (checkMode && checkMode & 4 /* SkipContextSensitive */ && isContextSensitive(node)) {
|
|
if (!getEffectiveReturnTypeNode(node) && !hasContextSensitiveParameters(node)) {
|
|
const contextualSignature = getContextualSignature(node);
|
|
if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) {
|
|
const links = getNodeLinks(node);
|
|
if (links.contextFreeType) {
|
|
return links.contextFreeType;
|
|
}
|
|
const returnType = getReturnTypeFromBody(node, checkMode);
|
|
const returnOnlySignature = createSignature(void 0, void 0, void 0, emptyArray, returnType, void 0, 0, 0 /* None */);
|
|
const returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], emptyArray, emptyArray);
|
|
returnOnlyType.objectFlags |= 262144 /* NonInferrableType */;
|
|
return links.contextFreeType = returnOnlyType;
|
|
}
|
|
}
|
|
return anyFunctionType;
|
|
}
|
|
const hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
|
|
if (!hasGrammarError && node.kind === 215 /* FunctionExpression */) {
|
|
checkGrammarForGenerator(node);
|
|
}
|
|
contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
return getTypeOfSymbol(getSymbolOfNode(node));
|
|
}
|
|
function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) {
|
|
const links = getNodeLinks(node);
|
|
if (!(links.flags & 64 /* ContextChecked */)) {
|
|
const contextualSignature = getContextualSignature(node);
|
|
if (!(links.flags & 64 /* ContextChecked */)) {
|
|
links.flags |= 64 /* ContextChecked */;
|
|
const signature = firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* Call */));
|
|
if (!signature) {
|
|
return;
|
|
}
|
|
if (isContextSensitive(node)) {
|
|
if (contextualSignature) {
|
|
const inferenceContext = getInferenceContext(node);
|
|
let instantiatedContextualSignature;
|
|
if (checkMode && checkMode & 2 /* Inferential */) {
|
|
inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
|
|
const restType = getEffectiveRestType(contextualSignature);
|
|
if (restType && restType.flags & 262144 /* TypeParameter */) {
|
|
instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
|
|
}
|
|
}
|
|
instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
|
|
assignContextualParameterTypes(signature, instantiatedContextualSignature);
|
|
} else {
|
|
assignNonContextualParameterTypes(signature);
|
|
}
|
|
}
|
|
if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) {
|
|
const returnType = getReturnTypeFromBody(node, checkMode);
|
|
if (!signature.resolvedReturnType) {
|
|
signature.resolvedReturnType = returnType;
|
|
}
|
|
}
|
|
checkSignatureDeclaration(node);
|
|
}
|
|
}
|
|
}
|
|
function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) {
|
|
Debug.assert(node.kind !== 171 /* MethodDeclaration */ || isObjectLiteralMethod(node));
|
|
const functionFlags = getFunctionFlags(node);
|
|
const returnType = getReturnTypeFromAnnotation(node);
|
|
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
|
|
if (node.body) {
|
|
if (!getEffectiveReturnTypeNode(node)) {
|
|
getReturnTypeOfSignature(getSignatureFromDeclaration(node));
|
|
}
|
|
if (node.body.kind === 238 /* Block */) {
|
|
checkSourceElement(node.body);
|
|
} else {
|
|
const exprType = checkExpression(node.body);
|
|
const returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags);
|
|
if (returnOrPromisedType) {
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */) {
|
|
const awaitedType = checkAwaitedType(exprType, false, node.body, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, node.body, node.body);
|
|
} else {
|
|
checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid = false) {
|
|
if (!isTypeAssignableTo(type, numberOrBigIntType)) {
|
|
const awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type);
|
|
errorAndMaybeSuggestAwait(
|
|
operand,
|
|
!!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType),
|
|
diagnostic
|
|
);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function isReadonlyAssignmentDeclaration(d) {
|
|
if (!isCallExpression(d)) {
|
|
return false;
|
|
}
|
|
if (!isBindableObjectDefinePropertyCall(d)) {
|
|
return false;
|
|
}
|
|
const objectLitType = checkExpressionCached(d.arguments[2]);
|
|
const valueType = getTypeOfPropertyOfType(objectLitType, "value");
|
|
if (valueType) {
|
|
const writableProp = getPropertyOfType(objectLitType, "writable");
|
|
const writableType = writableProp && getTypeOfSymbol(writableProp);
|
|
if (!writableType || writableType === falseType || writableType === regularFalseType) {
|
|
return true;
|
|
}
|
|
if (writableProp && writableProp.valueDeclaration && isPropertyAssignment(writableProp.valueDeclaration)) {
|
|
const initializer = writableProp.valueDeclaration.initializer;
|
|
const rawOriginalType = checkExpression(initializer);
|
|
if (rawOriginalType === falseType || rawOriginalType === regularFalseType) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
const setProp = getPropertyOfType(objectLitType, "set");
|
|
return !setProp;
|
|
}
|
|
function isReadonlySymbol(symbol) {
|
|
return !!(getCheckFlags(symbol) & 8 /* Readonly */ || symbol.flags & 4 /* Property */ && getDeclarationModifierFlagsFromSymbol(symbol) & 64 /* Readonly */ || symbol.flags & 3 /* Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */ || symbol.flags & 98304 /* Accessor */ && !(symbol.flags & 65536 /* SetAccessor */) || symbol.flags & 8 /* EnumMember */ || some(symbol.declarations, isReadonlyAssignmentDeclaration));
|
|
}
|
|
function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) {
|
|
var _a2, _b;
|
|
if (assignmentKind === 0 /* None */) {
|
|
return false;
|
|
}
|
|
if (isReadonlySymbol(symbol)) {
|
|
if (symbol.flags & 4 /* Property */ && isAccessExpression(expr) && expr.expression.kind === 108 /* ThisKeyword */) {
|
|
const ctor = getContainingFunction(expr);
|
|
if (!(ctor && (ctor.kind === 173 /* Constructor */ || isJSConstructor(ctor)))) {
|
|
return true;
|
|
}
|
|
if (symbol.valueDeclaration) {
|
|
const isAssignmentDeclaration2 = isBinaryExpression(symbol.valueDeclaration);
|
|
const isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent;
|
|
const isLocalParameterProperty = ctor === symbol.valueDeclaration.parent;
|
|
const isLocalThisPropertyAssignment = isAssignmentDeclaration2 && ((_a2 = symbol.parent) == null ? void 0 : _a2.valueDeclaration) === ctor.parent;
|
|
const isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration2 && ((_b = symbol.parent) == null ? void 0 : _b.valueDeclaration) === ctor;
|
|
const isWriteableSymbol = isLocalPropertyDeclaration || isLocalParameterProperty || isLocalThisPropertyAssignment || isLocalThisPropertyAssignmentConstructorFunction;
|
|
return !isWriteableSymbol;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
if (isAccessExpression(expr)) {
|
|
const node = skipParentheses(expr.expression);
|
|
if (node.kind === 79 /* Identifier */) {
|
|
const symbol2 = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol2.flags & 2097152 /* Alias */) {
|
|
const declaration = getDeclarationOfAliasSymbol(symbol2);
|
|
return !!declaration && declaration.kind === 271 /* NamespaceImport */;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) {
|
|
const node = skipOuterExpressions(expr, 6 /* Assertions */ | 1 /* Parentheses */);
|
|
if (node.kind !== 79 /* Identifier */ && !isAccessExpression(node)) {
|
|
error(expr, invalidReferenceMessage);
|
|
return false;
|
|
}
|
|
if (node.flags & 32 /* OptionalChain */) {
|
|
error(expr, invalidOptionalChainMessage);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function checkDeleteExpression(node) {
|
|
checkExpression(node.expression);
|
|
const expr = skipParentheses(node.expression);
|
|
if (!isAccessExpression(expr)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
|
|
return booleanType;
|
|
}
|
|
if (isPropertyAccessExpression(expr) && isPrivateIdentifier(expr.name)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier);
|
|
}
|
|
const links = getNodeLinks(expr);
|
|
const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
|
|
if (symbol) {
|
|
if (isReadonlySymbol(symbol)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
|
|
}
|
|
checkDeleteExpressionMustBeOptional(expr, symbol);
|
|
}
|
|
return booleanType;
|
|
}
|
|
function checkDeleteExpressionMustBeOptional(expr, symbol) {
|
|
const type = getTypeOfSymbol(symbol);
|
|
if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
|
|
error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
|
|
}
|
|
}
|
|
function checkTypeOfExpression(node) {
|
|
checkExpression(node.expression);
|
|
return typeofType;
|
|
}
|
|
function checkVoidExpression(node) {
|
|
checkExpression(node.expression);
|
|
return undefinedWideningType;
|
|
}
|
|
function checkAwaitExpressionGrammar(node) {
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
error(node, Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block);
|
|
} else if (!(node.flags & 32768 /* AwaitContext */)) {
|
|
if (isInTopLevelContext(node)) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
let span;
|
|
if (!isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
const diagnostic = createFileDiagnostic(
|
|
sourceFile,
|
|
span.start,
|
|
span.length,
|
|
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
|
|
);
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
switch (moduleKind) {
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
if (sourceFile.impliedNodeFormat === 1 /* CommonJS */) {
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(
|
|
createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)
|
|
);
|
|
break;
|
|
}
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 4 /* System */:
|
|
if (languageVersion >= 4 /* ES2017 */) {
|
|
break;
|
|
}
|
|
default:
|
|
span != null ? span : span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(
|
|
createFileDiagnostic(
|
|
sourceFile,
|
|
span.start,
|
|
span.length,
|
|
Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
const diagnostic = createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
|
|
if (container && container.kind !== 173 /* Constructor */ && (getFunctionFlags(container) & 2 /* Async */) === 0) {
|
|
const relatedInfo = createDiagnosticForNode(container, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
|
|
addRelatedInfo(diagnostic, relatedInfo);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
if (isInParameterInitializerBeforeContainingFunction(node)) {
|
|
error(node, Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer);
|
|
}
|
|
}
|
|
function checkAwaitExpression(node) {
|
|
addLazyDiagnostic(() => checkAwaitExpressionGrammar(node));
|
|
const operandType = checkExpression(node.expression);
|
|
const awaitedType = checkAwaitedType(operandType, true, node, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
if (awaitedType === operandType && !isErrorType(awaitedType) && !(operandType.flags & 3 /* AnyOrUnknown */)) {
|
|
addErrorOrSuggestion(false, createDiagnosticForNode(node, Diagnostics.await_has_no_effect_on_the_type_of_this_expression));
|
|
}
|
|
return awaitedType;
|
|
}
|
|
function checkPrefixUnaryExpression(node) {
|
|
const operandType = checkExpression(node.operand);
|
|
if (operandType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
switch (node.operand.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
switch (node.operator) {
|
|
case 40 /* MinusToken */:
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(-node.operand.text));
|
|
case 39 /* PlusToken */:
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(+node.operand.text));
|
|
}
|
|
break;
|
|
case 9 /* BigIntLiteral */:
|
|
if (node.operator === 40 /* MinusToken */) {
|
|
return getFreshTypeOfLiteralType(getBigIntLiteralType({
|
|
negative: true,
|
|
base10Value: parsePseudoBigInt(node.operand.text)
|
|
}));
|
|
}
|
|
}
|
|
switch (node.operator) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
checkNonNullType(operandType, node.operand);
|
|
if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* ESSymbolLike */)) {
|
|
error(node.operand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(node.operator));
|
|
}
|
|
if (node.operator === 39 /* PlusToken */) {
|
|
if (maybeTypeOfKindConsideringBaseConstraint(operandType, 2112 /* BigIntLike */)) {
|
|
error(node.operand, Diagnostics.Operator_0_cannot_be_applied_to_type_1, tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType)));
|
|
}
|
|
return numberType;
|
|
}
|
|
return getUnaryResultType(operandType);
|
|
case 53 /* ExclamationToken */:
|
|
checkTruthinessExpression(node.operand);
|
|
const facts = getTypeFacts(operandType) & (4194304 /* Truthy */ | 8388608 /* Falsy */);
|
|
return facts === 4194304 /* Truthy */ ? falseType : facts === 8388608 /* Falsy */ ? trueType : booleanType;
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
const ok = checkArithmeticOperandType(
|
|
node.operand,
|
|
checkNonNullType(operandType, node.operand),
|
|
Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type
|
|
);
|
|
if (ok) {
|
|
checkReferenceExpression(
|
|
node.operand,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access
|
|
);
|
|
}
|
|
return getUnaryResultType(operandType);
|
|
}
|
|
return errorType;
|
|
}
|
|
function checkPostfixUnaryExpression(node) {
|
|
const operandType = checkExpression(node.operand);
|
|
if (operandType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
const ok = checkArithmeticOperandType(
|
|
node.operand,
|
|
checkNonNullType(operandType, node.operand),
|
|
Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type
|
|
);
|
|
if (ok) {
|
|
checkReferenceExpression(
|
|
node.operand,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access
|
|
);
|
|
}
|
|
return getUnaryResultType(operandType);
|
|
}
|
|
function getUnaryResultType(operandType) {
|
|
if (maybeTypeOfKind(operandType, 2112 /* BigIntLike */)) {
|
|
return isTypeAssignableToKind(operandType, 3 /* AnyOrUnknown */) || maybeTypeOfKind(operandType, 296 /* NumberLike */) ? numberOrBigIntType : bigintType;
|
|
}
|
|
return numberType;
|
|
}
|
|
function maybeTypeOfKindConsideringBaseConstraint(type, kind) {
|
|
if (maybeTypeOfKind(type, kind)) {
|
|
return true;
|
|
}
|
|
const baseConstraint = getBaseConstraintOrType(type);
|
|
return !!baseConstraint && maybeTypeOfKind(baseConstraint, kind);
|
|
}
|
|
function maybeTypeOfKind(type, kind) {
|
|
if (type.flags & kind) {
|
|
return true;
|
|
}
|
|
if (type.flags & 3145728 /* UnionOrIntersection */) {
|
|
const types = type.types;
|
|
for (const t of types) {
|
|
if (maybeTypeOfKind(t, kind)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeAssignableToKind(source, kind, strict) {
|
|
if (source.flags & kind) {
|
|
return true;
|
|
}
|
|
if (strict && source.flags & (3 /* AnyOrUnknown */ | 16384 /* Void */ | 32768 /* Undefined */ | 65536 /* Null */)) {
|
|
return false;
|
|
}
|
|
return !!(kind & 296 /* NumberLike */) && isTypeAssignableTo(source, numberType) || !!(kind & 2112 /* BigIntLike */) && isTypeAssignableTo(source, bigintType) || !!(kind & 402653316 /* StringLike */) && isTypeAssignableTo(source, stringType) || !!(kind & 528 /* BooleanLike */) && isTypeAssignableTo(source, booleanType) || !!(kind & 16384 /* Void */) && isTypeAssignableTo(source, voidType) || !!(kind & 131072 /* Never */) && isTypeAssignableTo(source, neverType) || !!(kind & 65536 /* Null */) && isTypeAssignableTo(source, nullType) || !!(kind & 32768 /* Undefined */) && isTypeAssignableTo(source, undefinedType) || !!(kind & 4096 /* ESSymbol */) && isTypeAssignableTo(source, esSymbolType) || !!(kind & 67108864 /* NonPrimitive */) && isTypeAssignableTo(source, nonPrimitiveType);
|
|
}
|
|
function allTypesAssignableToKind(source, kind, strict) {
|
|
return source.flags & 1048576 /* Union */ ? every(source.types, (subType) => allTypesAssignableToKind(subType, kind, strict)) : isTypeAssignableToKind(source, kind, strict);
|
|
}
|
|
function isConstEnumObjectType(type) {
|
|
return !!(getObjectFlags(type) & 16 /* Anonymous */) && !!type.symbol && isConstEnumSymbol(type.symbol);
|
|
}
|
|
function isConstEnumSymbol(symbol) {
|
|
return (symbol.flags & 128 /* ConstEnum */) !== 0;
|
|
}
|
|
function checkInstanceOfExpression(left, right, leftType, rightType) {
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (!isTypeAny(leftType) && allTypesAssignableToKind(leftType, 131068 /* Primitive */)) {
|
|
error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
|
|
}
|
|
if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures2(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) {
|
|
error(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
|
|
}
|
|
return booleanType;
|
|
}
|
|
function hasEmptyObjectIntersection(type) {
|
|
return someType(type, (t) => t === unknownEmptyObjectType || !!(t.flags & 2097152 /* Intersection */) && isEmptyAnonymousObjectType(getBaseConstraintOrType(t)));
|
|
}
|
|
function checkInExpression(left, right, leftType, rightType) {
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (isPrivateIdentifier(left)) {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(left, 2097152 /* ClassPrivateFieldIn */);
|
|
}
|
|
if (!getNodeLinks(left).resolvedSymbol && getContainingClass(left)) {
|
|
const isUncheckedJS = isUncheckedJSSuggestion(left, rightType.symbol, true);
|
|
reportNonexistentProperty(left, rightType, isUncheckedJS);
|
|
}
|
|
} else {
|
|
checkTypeAssignableTo(checkNonNullType(leftType, left), stringNumberSymbolType, left);
|
|
}
|
|
if (checkTypeAssignableTo(checkNonNullType(rightType, right), nonPrimitiveType, right)) {
|
|
if (hasEmptyObjectIntersection(rightType)) {
|
|
error(right, Diagnostics.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator, typeToString(rightType));
|
|
}
|
|
}
|
|
return booleanType;
|
|
}
|
|
function checkObjectLiteralAssignment(node, sourceType, rightIsThis) {
|
|
const properties = node.properties;
|
|
if (strictNullChecks && properties.length === 0) {
|
|
return checkNonNullType(sourceType, node);
|
|
}
|
|
for (let i = 0; i < properties.length; i++) {
|
|
checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis = false) {
|
|
const properties = node.properties;
|
|
const property = properties[propertyIndex];
|
|
if (property.kind === 299 /* PropertyAssignment */ || property.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const name = property.name;
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(exprType)) {
|
|
const text = getPropertyNameFromType(exprType);
|
|
const prop = getPropertyOfType(objectLiteralType, text);
|
|
if (prop) {
|
|
markPropertyAsReferenced(prop, property, rightIsThis);
|
|
checkPropertyAccessibility(property, false, true, objectLiteralType, prop);
|
|
}
|
|
}
|
|
const elementType = getIndexedAccessType(objectLiteralType, exprType, 32 /* ExpressionPosition */, name);
|
|
const type = getFlowTypeOfDestructuring(property, elementType);
|
|
return checkDestructuringAssignment(property.kind === 300 /* ShorthandPropertyAssignment */ ? property : property.initializer, type);
|
|
} else if (property.kind === 301 /* SpreadAssignment */) {
|
|
if (propertyIndex < properties.length - 1) {
|
|
error(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
} else {
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(property, 4 /* Rest */);
|
|
}
|
|
const nonRestNames = [];
|
|
if (allProperties) {
|
|
for (const otherProperty of allProperties) {
|
|
if (!isSpreadAssignment(otherProperty)) {
|
|
nonRestNames.push(otherProperty.name);
|
|
}
|
|
}
|
|
}
|
|
const type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol);
|
|
checkGrammarForDisallowedTrailingComma(allProperties, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
return checkDestructuringAssignment(property.expression, type);
|
|
}
|
|
} else {
|
|
error(property, Diagnostics.Property_assignment_expected);
|
|
}
|
|
}
|
|
function checkArrayLiteralAssignment(node, sourceType, checkMode) {
|
|
const elements = node.elements;
|
|
if (languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 512 /* Read */);
|
|
}
|
|
const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* Destructuring */ | 128 /* PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType;
|
|
let inBoundsType = compilerOptions.noUncheckedIndexedAccess ? void 0 : possiblyOutOfBoundsType;
|
|
for (let i = 0; i < elements.length; i++) {
|
|
let type = possiblyOutOfBoundsType;
|
|
if (node.elements[i].kind === 227 /* SpreadElement */) {
|
|
type = inBoundsType = inBoundsType != null ? inBoundsType : checkIteratedTypeOrElementType(65 /* Destructuring */, sourceType, undefinedType, node) || errorType;
|
|
}
|
|
checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, type, checkMode);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) {
|
|
const elements = node.elements;
|
|
const element = elements[elementIndex];
|
|
if (element.kind !== 229 /* OmittedExpression */) {
|
|
if (element.kind !== 227 /* SpreadElement */) {
|
|
const indexType = getNumberLiteralType(elementIndex);
|
|
if (isArrayLikeType(sourceType)) {
|
|
const accessFlags = 32 /* ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* NoTupleBoundsCheck */ : 0);
|
|
const elementType2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, accessFlags, createSyntheticExpression(element, indexType)) || errorType;
|
|
const assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType2, 524288 /* NEUndefined */) : elementType2;
|
|
const type = getFlowTypeOfDestructuring(element, assignedType);
|
|
return checkDestructuringAssignment(element, type, checkMode);
|
|
}
|
|
return checkDestructuringAssignment(element, elementType, checkMode);
|
|
}
|
|
if (elementIndex < elements.length - 1) {
|
|
error(element, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
} else {
|
|
const restExpression = element.expression;
|
|
if (restExpression.kind === 223 /* BinaryExpression */ && restExpression.operatorToken.kind === 63 /* EqualsToken */) {
|
|
error(restExpression.operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);
|
|
} else {
|
|
checkGrammarForDisallowedTrailingComma(node.elements, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
const type = everyType(sourceType, isTupleType) ? mapType(sourceType, (t) => sliceTupleType(t, elementIndex)) : createArrayType(elementType);
|
|
return checkDestructuringAssignment(restExpression, type, checkMode);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) {
|
|
let target;
|
|
if (exprOrAssignment.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const prop = exprOrAssignment;
|
|
if (prop.objectAssignmentInitializer) {
|
|
if (strictNullChecks && !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
|
|
sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
|
|
}
|
|
checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
|
|
}
|
|
target = exprOrAssignment.name;
|
|
} else {
|
|
target = exprOrAssignment;
|
|
}
|
|
if (target.kind === 223 /* BinaryExpression */ && target.operatorToken.kind === 63 /* EqualsToken */) {
|
|
checkBinaryExpression(target, checkMode);
|
|
target = target.left;
|
|
if (strictNullChecks) {
|
|
sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
|
|
}
|
|
}
|
|
if (target.kind === 207 /* ObjectLiteralExpression */) {
|
|
return checkObjectLiteralAssignment(target, sourceType, rightIsThis);
|
|
}
|
|
if (target.kind === 206 /* ArrayLiteralExpression */) {
|
|
return checkArrayLiteralAssignment(target, sourceType, checkMode);
|
|
}
|
|
return checkReferenceAssignment(target, sourceType, checkMode);
|
|
}
|
|
function checkReferenceAssignment(target, sourceType, checkMode) {
|
|
const targetType = checkExpression(target, checkMode);
|
|
const error2 = target.parent.kind === 301 /* SpreadAssignment */ ? Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access : Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access;
|
|
const optionalError = target.parent.kind === 301 /* SpreadAssignment */ ? Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access : Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access;
|
|
if (checkReferenceExpression(target, error2, optionalError)) {
|
|
checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target);
|
|
}
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
checkExternalEmitHelpers(target.parent, 1048576 /* ClassPrivateFieldSet */);
|
|
}
|
|
return sourceType;
|
|
}
|
|
function isSideEffectFree(node) {
|
|
node = skipParentheses(node);
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 225 /* TemplateExpression */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 218 /* TypeOfExpression */:
|
|
case 232 /* NonNullExpression */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 281 /* JsxElement */:
|
|
return true;
|
|
case 224 /* ConditionalExpression */:
|
|
return isSideEffectFree(node.whenTrue) && isSideEffectFree(node.whenFalse);
|
|
case 223 /* BinaryExpression */:
|
|
if (isAssignmentOperator(node.operatorToken.kind)) {
|
|
return false;
|
|
}
|
|
return isSideEffectFree(node.left) && isSideEffectFree(node.right);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
switch (node.operator) {
|
|
case 53 /* ExclamationToken */:
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
return true;
|
|
}
|
|
return false;
|
|
case 219 /* VoidExpression */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isTypeEqualityComparableTo(source, target) {
|
|
return (target.flags & 98304 /* Nullable */) !== 0 || isTypeComparableTo(source, target);
|
|
}
|
|
function createCheckBinaryExpression() {
|
|
const trampoline = createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState);
|
|
return (node, checkMode) => {
|
|
const result = trampoline(node, checkMode);
|
|
Debug.assertIsDefined(result);
|
|
return result;
|
|
};
|
|
function onEnter(node, state, checkMode) {
|
|
if (state) {
|
|
state.stackIndex++;
|
|
state.skip = false;
|
|
setLeftType(state, void 0);
|
|
setLastResult(state, void 0);
|
|
} else {
|
|
state = {
|
|
checkMode,
|
|
skip: false,
|
|
stackIndex: 0,
|
|
typeStack: [void 0, void 0]
|
|
};
|
|
}
|
|
if (isInJSFile(node) && getAssignedExpandoInitializer(node)) {
|
|
state.skip = true;
|
|
setLastResult(state, checkExpression(node.right, checkMode));
|
|
return state;
|
|
}
|
|
checkGrammarNullishCoalesceWithLogicalExpression(node);
|
|
const operator = node.operatorToken.kind;
|
|
if (operator === 63 /* EqualsToken */ && (node.left.kind === 207 /* ObjectLiteralExpression */ || node.left.kind === 206 /* ArrayLiteralExpression */)) {
|
|
state.skip = true;
|
|
setLastResult(state, checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 108 /* ThisKeyword */));
|
|
return state;
|
|
}
|
|
return state;
|
|
}
|
|
function onLeft(left, state, _node) {
|
|
if (!state.skip) {
|
|
return maybeCheckExpression(state, left);
|
|
}
|
|
}
|
|
function onOperator(operatorToken, state, node) {
|
|
if (!state.skip) {
|
|
const leftType = getLastResult(state);
|
|
Debug.assertIsDefined(leftType);
|
|
setLeftType(state, leftType);
|
|
setLastResult(state, void 0);
|
|
const operator = operatorToken.kind;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
|
|
if (operator === 55 /* AmpersandAmpersandToken */) {
|
|
let parent2 = node.parent;
|
|
while (parent2.kind === 214 /* ParenthesizedExpression */ || isBinaryExpression(parent2) && (parent2.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent2.operatorToken.kind === 56 /* BarBarToken */)) {
|
|
parent2 = parent2.parent;
|
|
}
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.left, leftType, isIfStatement(parent2) ? parent2.thenStatement : void 0);
|
|
}
|
|
checkTruthinessOfType(leftType, node.left);
|
|
}
|
|
}
|
|
}
|
|
function onRight(right, state, _node) {
|
|
if (!state.skip) {
|
|
return maybeCheckExpression(state, right);
|
|
}
|
|
}
|
|
function onExit(node, state) {
|
|
let result;
|
|
if (state.skip) {
|
|
result = getLastResult(state);
|
|
} else {
|
|
const leftType = getLeftType(state);
|
|
Debug.assertIsDefined(leftType);
|
|
const rightType = getLastResult(state);
|
|
Debug.assertIsDefined(rightType);
|
|
result = checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node);
|
|
}
|
|
state.skip = false;
|
|
setLeftType(state, void 0);
|
|
setLastResult(state, void 0);
|
|
state.stackIndex--;
|
|
return result;
|
|
}
|
|
function foldState(state, result, _side) {
|
|
setLastResult(state, result);
|
|
return state;
|
|
}
|
|
function maybeCheckExpression(state, node) {
|
|
if (isBinaryExpression(node)) {
|
|
return node;
|
|
}
|
|
setLastResult(state, checkExpression(node, state.checkMode));
|
|
}
|
|
function getLeftType(state) {
|
|
return state.typeStack[state.stackIndex];
|
|
}
|
|
function setLeftType(state, type) {
|
|
state.typeStack[state.stackIndex] = type;
|
|
}
|
|
function getLastResult(state) {
|
|
return state.typeStack[state.stackIndex + 1];
|
|
}
|
|
function setLastResult(state, type) {
|
|
state.typeStack[state.stackIndex + 1] = type;
|
|
}
|
|
}
|
|
function checkGrammarNullishCoalesceWithLogicalExpression(node) {
|
|
const { left, operatorToken, right } = node;
|
|
if (operatorToken.kind === 60 /* QuestionQuestionToken */) {
|
|
if (isBinaryExpression(left) && (left.operatorToken.kind === 56 /* BarBarToken */ || left.operatorToken.kind === 55 /* AmpersandAmpersandToken */)) {
|
|
grammarErrorOnNode(left, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(left.operatorToken.kind), tokenToString(operatorToken.kind));
|
|
}
|
|
if (isBinaryExpression(right) && (right.operatorToken.kind === 56 /* BarBarToken */ || right.operatorToken.kind === 55 /* AmpersandAmpersandToken */)) {
|
|
grammarErrorOnNode(right, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(right.operatorToken.kind), tokenToString(operatorToken.kind));
|
|
}
|
|
}
|
|
}
|
|
function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) {
|
|
const operator = operatorToken.kind;
|
|
if (operator === 63 /* EqualsToken */ && (left.kind === 207 /* ObjectLiteralExpression */ || left.kind === 206 /* ArrayLiteralExpression */)) {
|
|
return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 108 /* ThisKeyword */);
|
|
}
|
|
let leftType;
|
|
if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
|
|
leftType = checkTruthinessExpression(left, checkMode);
|
|
} else {
|
|
leftType = checkExpression(left, checkMode);
|
|
}
|
|
const rightType = checkExpression(right, checkMode);
|
|
return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode);
|
|
}
|
|
function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) {
|
|
const operator = operatorToken.kind;
|
|
switch (operator) {
|
|
case 41 /* AsteriskToken */:
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 44 /* PercentToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 40 /* MinusToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 51 /* BarToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 52 /* CaretToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
leftType = checkNonNullType(leftType, left);
|
|
rightType = checkNonNullType(rightType, right);
|
|
let suggestedOperator;
|
|
if (leftType.flags & 528 /* BooleanLike */ && rightType.flags & 528 /* BooleanLike */ && (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== void 0) {
|
|
error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator));
|
|
return numberType;
|
|
} else {
|
|
const leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
|
|
const rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, true);
|
|
let resultType2;
|
|
if (isTypeAssignableToKind(leftType, 3 /* AnyOrUnknown */) && isTypeAssignableToKind(rightType, 3 /* AnyOrUnknown */) || !(maybeTypeOfKind(leftType, 2112 /* BigIntLike */) || maybeTypeOfKind(rightType, 2112 /* BigIntLike */))) {
|
|
resultType2 = numberType;
|
|
} else if (bothAreBigIntLike(leftType, rightType)) {
|
|
switch (operator) {
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
reportOperatorError();
|
|
break;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
if (languageVersion < 3 /* ES2016 */) {
|
|
error(errorNode, Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later);
|
|
}
|
|
}
|
|
resultType2 = bigintType;
|
|
} else {
|
|
reportOperatorError(bothAreBigIntLike);
|
|
resultType2 = errorType;
|
|
}
|
|
if (leftOk && rightOk) {
|
|
checkAssignmentOperator(resultType2);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 39 /* PlusToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
if (leftType === silentNeverType || rightType === silentNeverType) {
|
|
return silentNeverType;
|
|
}
|
|
if (!isTypeAssignableToKind(leftType, 402653316 /* StringLike */) && !isTypeAssignableToKind(rightType, 402653316 /* StringLike */)) {
|
|
leftType = checkNonNullType(leftType, left);
|
|
rightType = checkNonNullType(rightType, right);
|
|
}
|
|
let resultType;
|
|
if (isTypeAssignableToKind(leftType, 296 /* NumberLike */, true) && isTypeAssignableToKind(rightType, 296 /* NumberLike */, true)) {
|
|
resultType = numberType;
|
|
} else if (isTypeAssignableToKind(leftType, 2112 /* BigIntLike */, true) && isTypeAssignableToKind(rightType, 2112 /* BigIntLike */, true)) {
|
|
resultType = bigintType;
|
|
} else if (isTypeAssignableToKind(leftType, 402653316 /* StringLike */, true) || isTypeAssignableToKind(rightType, 402653316 /* StringLike */, true)) {
|
|
resultType = stringType;
|
|
} else if (isTypeAny(leftType) || isTypeAny(rightType)) {
|
|
resultType = isErrorType(leftType) || isErrorType(rightType) ? errorType : anyType;
|
|
}
|
|
if (resultType && !checkForDisallowedESSymbolOperand(operator)) {
|
|
return resultType;
|
|
}
|
|
if (!resultType) {
|
|
const closeEnoughKind = 296 /* NumberLike */ | 2112 /* BigIntLike */ | 402653316 /* StringLike */ | 3 /* AnyOrUnknown */;
|
|
reportOperatorError((left2, right2) => isTypeAssignableToKind(left2, closeEnoughKind) && isTypeAssignableToKind(right2, closeEnoughKind));
|
|
return anyType;
|
|
}
|
|
if (operator === 64 /* PlusEqualsToken */) {
|
|
checkAssignmentOperator(resultType);
|
|
}
|
|
return resultType;
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
if (checkForDisallowedESSymbolOperand(operator)) {
|
|
leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left));
|
|
rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right));
|
|
reportOperatorErrorUnless((left2, right2) => isTypeComparableTo(left2, right2) || isTypeComparableTo(right2, left2) || isTypeAssignableTo(left2, numberOrBigIntType) && isTypeAssignableTo(right2, numberOrBigIntType));
|
|
}
|
|
return booleanType;
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
|
|
const eqType = operator === 34 /* EqualsEqualsToken */ || operator === 36 /* EqualsEqualsEqualsToken */;
|
|
error(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
|
|
}
|
|
checkNaNEquality(errorNode, operator, left, right);
|
|
reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
|
|
return booleanType;
|
|
case 102 /* InstanceOfKeyword */:
|
|
return checkInstanceOfExpression(left, right, leftType, rightType);
|
|
case 101 /* InKeyword */:
|
|
return checkInExpression(left, right, leftType, rightType);
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 4194304 /* Truthy */ ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
|
|
if (operator === 76 /* AmpersandAmpersandEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 56 /* BarBarToken */:
|
|
case 75 /* BarBarEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 8388608 /* Falsy */ ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
|
|
if (operator === 75 /* BarBarEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 60 /* QuestionQuestionToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */: {
|
|
const resultType2 = getTypeFacts(leftType) & 262144 /* EQUndefinedOrNull */ ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
|
|
if (operator === 77 /* QuestionQuestionEqualsToken */) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return resultType2;
|
|
}
|
|
case 63 /* EqualsToken */:
|
|
const declKind = isBinaryExpression(left.parent) ? getAssignmentDeclarationKind(left.parent) : 0 /* None */;
|
|
checkAssignmentDeclaration(declKind, rightType);
|
|
if (isAssignmentDeclaration2(declKind)) {
|
|
if (!(rightType.flags & 524288 /* Object */) || declKind !== 2 /* ModuleExports */ && declKind !== 6 /* Prototype */ && !isEmptyObjectType(rightType) && !isFunctionObjectType(rightType) && !(getObjectFlags(rightType) & 1 /* Class */)) {
|
|
checkAssignmentOperator(rightType);
|
|
}
|
|
return leftType;
|
|
} else {
|
|
checkAssignmentOperator(rightType);
|
|
return getRegularTypeOfObjectLiteral(rightType);
|
|
}
|
|
case 27 /* CommaToken */:
|
|
if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) {
|
|
const sf = getSourceFileOfNode(left);
|
|
const sourceText = sf.text;
|
|
const start2 = skipTrivia(sourceText, left.pos);
|
|
const isInDiag2657 = sf.parseDiagnostics.some((diag2) => {
|
|
if (diag2.code !== Diagnostics.JSX_expressions_must_have_one_parent_element.code)
|
|
return false;
|
|
return textSpanContainsPosition(diag2, start2);
|
|
});
|
|
if (!isInDiag2657)
|
|
error(left, Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects);
|
|
}
|
|
return rightType;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
function bothAreBigIntLike(left2, right2) {
|
|
return isTypeAssignableToKind(left2, 2112 /* BigIntLike */) && isTypeAssignableToKind(right2, 2112 /* BigIntLike */);
|
|
}
|
|
function checkAssignmentDeclaration(kind, rightType2) {
|
|
if (kind === 2 /* ModuleExports */) {
|
|
for (const prop of getPropertiesOfObjectType(rightType2)) {
|
|
const propType = getTypeOfSymbol(prop);
|
|
if (propType.symbol && propType.symbol.flags & 32 /* Class */) {
|
|
const name = prop.escapedName;
|
|
const symbol = resolveName(prop.valueDeclaration, name, 788968 /* Type */, void 0, name, false);
|
|
if ((symbol == null ? void 0 : symbol.declarations) && symbol.declarations.some(isJSDocTypedefTag)) {
|
|
addDuplicateDeclarationErrorsForSymbols(symbol, Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(name), prop);
|
|
addDuplicateDeclarationErrorsForSymbols(prop, Diagnostics.Duplicate_identifier_0, unescapeLeadingUnderscores(name), symbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isEvalNode(node) {
|
|
return node.kind === 79 /* Identifier */ && node.escapedText === "eval";
|
|
}
|
|
function checkForDisallowedESSymbolOperand(operator2) {
|
|
const offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* ESSymbolLike */) ? left : maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* ESSymbolLike */) ? right : void 0;
|
|
if (offendingSymbolOperand) {
|
|
error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator2));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getSuggestedBooleanOperator(operator2) {
|
|
switch (operator2) {
|
|
case 51 /* BarToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
return 56 /* BarBarToken */;
|
|
case 52 /* CaretToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
return 37 /* ExclamationEqualsEqualsToken */;
|
|
case 50 /* AmpersandToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
return 55 /* AmpersandAmpersandToken */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkAssignmentOperator(valueType) {
|
|
if (isAssignmentOperator(operator)) {
|
|
addLazyDiagnostic(checkAssignmentOperatorWorker);
|
|
}
|
|
function checkAssignmentOperatorWorker() {
|
|
if (checkReferenceExpression(
|
|
left,
|
|
Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access
|
|
) && (!isIdentifier(left) || unescapeLeadingUnderscores(left.escapedText) !== "exports")) {
|
|
let headMessage;
|
|
if (exactOptionalPropertyTypes && isPropertyAccessExpression(left) && maybeTypeOfKind(valueType, 32768 /* Undefined */)) {
|
|
const target = getTypeOfPropertyOfType(getTypeOfExpression(left.expression), left.name.escapedText);
|
|
if (isExactOptionalPropertyMismatch(valueType, target)) {
|
|
headMessage = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target;
|
|
}
|
|
}
|
|
checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right, headMessage);
|
|
}
|
|
}
|
|
}
|
|
function isAssignmentDeclaration2(kind) {
|
|
var _a2;
|
|
switch (kind) {
|
|
case 2 /* ModuleExports */:
|
|
return true;
|
|
case 1 /* ExportsProperty */:
|
|
case 5 /* Property */:
|
|
case 6 /* Prototype */:
|
|
case 3 /* PrototypeProperty */:
|
|
case 4 /* ThisProperty */:
|
|
const symbol = getSymbolOfNode(left);
|
|
const init = getAssignedExpandoInitializer(right);
|
|
return !!init && isObjectLiteralExpression(init) && !!((_a2 = symbol == null ? void 0 : symbol.exports) == null ? void 0 : _a2.size);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function reportOperatorErrorUnless(typesAreCompatible) {
|
|
if (!typesAreCompatible(leftType, rightType)) {
|
|
reportOperatorError(typesAreCompatible);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function reportOperatorError(isRelated) {
|
|
let wouldWorkWithAwait = false;
|
|
const errNode = errorNode || operatorToken;
|
|
if (isRelated) {
|
|
const awaitedLeftType = getAwaitedTypeNoAlias(leftType);
|
|
const awaitedRightType = getAwaitedTypeNoAlias(rightType);
|
|
wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType) && !!(awaitedLeftType && awaitedRightType) && isRelated(awaitedLeftType, awaitedRightType);
|
|
}
|
|
let effectiveLeft = leftType;
|
|
let effectiveRight = rightType;
|
|
if (!wouldWorkWithAwait && isRelated) {
|
|
[effectiveLeft, effectiveRight] = getBaseTypesIfUnrelated(leftType, rightType, isRelated);
|
|
}
|
|
const [leftStr, rightStr] = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight);
|
|
if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) {
|
|
errorAndMaybeSuggestAwait(
|
|
errNode,
|
|
wouldWorkWithAwait,
|
|
Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2,
|
|
tokenToString(operatorToken.kind),
|
|
leftStr,
|
|
rightStr
|
|
);
|
|
}
|
|
}
|
|
function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) {
|
|
switch (operatorToken.kind) {
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
return errorAndMaybeSuggestAwait(
|
|
errNode,
|
|
maybeMissingAwait,
|
|
Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap,
|
|
leftStr,
|
|
rightStr
|
|
);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkNaNEquality(errorNode2, operator2, left2, right2) {
|
|
const isLeftNaN = isGlobalNaN(skipParentheses(left2));
|
|
const isRightNaN = isGlobalNaN(skipParentheses(right2));
|
|
if (isLeftNaN || isRightNaN) {
|
|
const err = error(
|
|
errorNode2,
|
|
Diagnostics.This_condition_will_always_return_0,
|
|
tokenToString(operator2 === 36 /* EqualsEqualsEqualsToken */ || operator2 === 34 /* EqualsEqualsToken */ ? 95 /* FalseKeyword */ : 110 /* TrueKeyword */)
|
|
);
|
|
if (isLeftNaN && isRightNaN)
|
|
return;
|
|
const operatorString = operator2 === 37 /* ExclamationEqualsEqualsToken */ || operator2 === 35 /* ExclamationEqualsToken */ ? tokenToString(53 /* ExclamationToken */) : "";
|
|
const location2 = isLeftNaN ? right2 : left2;
|
|
const expression = skipParentheses(location2);
|
|
addRelatedInfo(err, createDiagnosticForNode(
|
|
location2,
|
|
Diagnostics.Did_you_mean_0,
|
|
`${operatorString}Number.isNaN(${isEntityNameExpression(expression) ? entityNameToString(expression) : "..."})`
|
|
));
|
|
}
|
|
}
|
|
function isGlobalNaN(expr) {
|
|
if (isIdentifier(expr) && expr.escapedText === "NaN") {
|
|
const globalNaNSymbol = getGlobalNaNSymbol();
|
|
return !!globalNaNSymbol && globalNaNSymbol === getResolvedSymbol(expr);
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function getBaseTypesIfUnrelated(leftType, rightType, isRelated) {
|
|
let effectiveLeft = leftType;
|
|
let effectiveRight = rightType;
|
|
const leftBase = getBaseTypeOfLiteralType(leftType);
|
|
const rightBase = getBaseTypeOfLiteralType(rightType);
|
|
if (!isRelated(leftBase, rightBase)) {
|
|
effectiveLeft = leftBase;
|
|
effectiveRight = rightBase;
|
|
}
|
|
return [effectiveLeft, effectiveRight];
|
|
}
|
|
function checkYieldExpression(node) {
|
|
addLazyDiagnostic(checkYieldExpressionGrammar);
|
|
const func = getContainingFunction(node);
|
|
if (!func)
|
|
return anyType;
|
|
const functionFlags = getFunctionFlags(func);
|
|
if (!(functionFlags & 1 /* Generator */)) {
|
|
return anyType;
|
|
}
|
|
const isAsync = (functionFlags & 2 /* Async */) !== 0;
|
|
if (node.asteriskToken) {
|
|
if (isAsync && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */);
|
|
}
|
|
if (!isAsync && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 256 /* Values */);
|
|
}
|
|
}
|
|
const returnType = getReturnTypeFromAnnotation(func);
|
|
const iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
|
|
const signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
|
|
const signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
|
|
const resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType;
|
|
const yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType;
|
|
const yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync);
|
|
if (returnType && yieldedType) {
|
|
checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression);
|
|
}
|
|
if (node.asteriskToken) {
|
|
const use = isAsync ? 19 /* AsyncYieldStar */ : 17 /* YieldStar */;
|
|
return getIterationTypeOfIterable(use, 1 /* Return */, yieldExpressionType, node.expression) || anyType;
|
|
} else if (returnType) {
|
|
return getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, isAsync) || anyType;
|
|
}
|
|
let type = getContextualIterationType(2 /* Next */, func);
|
|
if (!type) {
|
|
type = anyType;
|
|
addLazyDiagnostic(() => {
|
|
if (noImplicitAny && !expressionResultIsUnused(node)) {
|
|
const contextualType = getContextualType2(node, void 0);
|
|
if (!contextualType || isTypeAny(contextualType)) {
|
|
error(node, Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return type;
|
|
function checkYieldExpressionGrammar() {
|
|
if (!(node.flags & 8192 /* YieldContext */)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body);
|
|
}
|
|
if (isInParameterInitializerBeforeContainingFunction(node)) {
|
|
error(node, Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer);
|
|
}
|
|
}
|
|
}
|
|
function checkConditionalExpression(node, checkMode) {
|
|
const type = checkTruthinessExpression(node.condition);
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.condition, type, node.whenTrue);
|
|
const type1 = checkExpression(node.whenTrue, checkMode);
|
|
const type2 = checkExpression(node.whenFalse, checkMode);
|
|
return getUnionType([type1, type2], 2 /* Subtype */);
|
|
}
|
|
function isTemplateLiteralContext(node) {
|
|
const parent2 = node.parent;
|
|
return isParenthesizedExpression(parent2) && isTemplateLiteralContext(parent2) || isElementAccessExpression(parent2) && parent2.argumentExpression === node;
|
|
}
|
|
function checkTemplateExpression(node) {
|
|
const texts = [node.head.text];
|
|
const types = [];
|
|
for (const span of node.templateSpans) {
|
|
const type = checkExpression(span.expression);
|
|
if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* ESSymbolLike */)) {
|
|
error(span.expression, Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String);
|
|
}
|
|
texts.push(span.literal.text);
|
|
types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
|
|
}
|
|
return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(node, void 0) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
|
|
}
|
|
function isTemplateLiteralContextualType(type) {
|
|
return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
|
|
}
|
|
function getContextNode2(node) {
|
|
if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
|
|
return node.parent.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
|
|
const context = getContextNode2(node);
|
|
const saveContextualType = context.contextualType;
|
|
const saveInferenceContext = context.inferenceContext;
|
|
try {
|
|
context.contextualType = contextualType;
|
|
context.inferenceContext = inferenceContext;
|
|
const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
|
|
if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
|
|
inferenceContext.intraExpressionInferenceSites = void 0;
|
|
}
|
|
const result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, void 0)) ? getRegularTypeOfLiteralType(type) : type;
|
|
return result;
|
|
} finally {
|
|
context.contextualType = saveContextualType;
|
|
context.inferenceContext = saveInferenceContext;
|
|
}
|
|
}
|
|
function checkExpressionCached(node, checkMode) {
|
|
if (checkMode) {
|
|
return checkExpression(node, checkMode);
|
|
}
|
|
const links = getNodeLinks(node);
|
|
if (!links.resolvedType) {
|
|
const saveFlowLoopStart = flowLoopStart;
|
|
const saveFlowTypeCache = flowTypeCache;
|
|
flowLoopStart = flowLoopCount;
|
|
flowTypeCache = void 0;
|
|
links.resolvedType = checkExpression(node, checkMode);
|
|
flowTypeCache = saveFlowTypeCache;
|
|
flowLoopStart = saveFlowLoopStart;
|
|
}
|
|
return links.resolvedType;
|
|
}
|
|
function isTypeAssertion3(node) {
|
|
node = skipParentheses(node, true);
|
|
return node.kind === 213 /* TypeAssertionExpression */ || node.kind === 231 /* AsExpression */ || isJSDocTypeAssertion(node);
|
|
}
|
|
function checkDeclarationInitializer(declaration, checkMode, contextualType) {
|
|
const initializer = getEffectiveInitializer(declaration);
|
|
const type = getQuickTypeOfExpression(initializer) || (contextualType ? checkExpressionWithContextualType(initializer, contextualType, void 0, checkMode || 0 /* Normal */) : checkExpressionCached(initializer, checkMode));
|
|
return isParameter(declaration) && declaration.name.kind === 204 /* ArrayBindingPattern */ && isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ? padTupleType(type, declaration.name) : type;
|
|
}
|
|
function padTupleType(type, pattern) {
|
|
const patternElements = pattern.elements;
|
|
const elementTypes = getTypeArguments(type).slice();
|
|
const elementFlags = type.target.elementFlags.slice();
|
|
for (let i = getTypeReferenceArity(type); i < patternElements.length; i++) {
|
|
const e = patternElements[i];
|
|
if (i < patternElements.length - 1 || !(e.kind === 205 /* BindingElement */ && e.dotDotDotToken)) {
|
|
elementTypes.push(!isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, false, false) : anyType);
|
|
elementFlags.push(2 /* Optional */);
|
|
if (!isOmittedExpression(e) && !hasDefaultValue(e)) {
|
|
reportImplicitAny(e, anyType);
|
|
}
|
|
}
|
|
}
|
|
return createTupleType(elementTypes, elementFlags, type.target.readonly);
|
|
}
|
|
function widenTypeInferredFromInitializer(declaration, type) {
|
|
const widened = getCombinedNodeFlags(declaration) & 2 /* Const */ || isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type);
|
|
if (isInJSFile(declaration)) {
|
|
if (isEmptyLiteralType(widened)) {
|
|
reportImplicitAny(declaration, anyType);
|
|
return anyType;
|
|
} else if (isEmptyArrayLiteralType(widened)) {
|
|
reportImplicitAny(declaration, anyArrayType);
|
|
return anyArrayType;
|
|
}
|
|
}
|
|
return widened;
|
|
}
|
|
function isLiteralOfContextualType(candidateType, contextualType) {
|
|
if (contextualType) {
|
|
if (contextualType.flags & 3145728 /* UnionOrIntersection */) {
|
|
const types = contextualType.types;
|
|
return some(types, (t) => isLiteralOfContextualType(candidateType, t));
|
|
}
|
|
if (contextualType.flags & 58982400 /* InstantiableNonPrimitive */) {
|
|
const constraint = getBaseConstraintOfType(contextualType) || unknownType;
|
|
return maybeTypeOfKind(constraint, 4 /* String */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || maybeTypeOfKind(constraint, 8 /* Number */) && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || maybeTypeOfKind(constraint, 64 /* BigInt */) && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || maybeTypeOfKind(constraint, 4096 /* ESSymbol */) && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */) || isLiteralOfContextualType(candidateType, constraint);
|
|
}
|
|
return !!(contextualType.flags & (128 /* StringLiteral */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && maybeTypeOfKind(candidateType, 128 /* StringLiteral */) || contextualType.flags & 256 /* NumberLiteral */ && maybeTypeOfKind(candidateType, 256 /* NumberLiteral */) || contextualType.flags & 2048 /* BigIntLiteral */ && maybeTypeOfKind(candidateType, 2048 /* BigIntLiteral */) || contextualType.flags & 512 /* BooleanLiteral */ && maybeTypeOfKind(candidateType, 512 /* BooleanLiteral */) || contextualType.flags & 8192 /* UniqueESSymbol */ && maybeTypeOfKind(candidateType, 8192 /* UniqueESSymbol */));
|
|
}
|
|
return false;
|
|
}
|
|
function isConstContext(node) {
|
|
const parent2 = node.parent;
|
|
return isAssertionExpression(parent2) && isConstTypeReference(parent2.type) || isJSDocTypeAssertion(parent2) && isConstTypeReference(getJSDocTypeAssertionType(parent2)) || (isParenthesizedExpression(parent2) || isArrayLiteralExpression(parent2) || isSpreadElement(parent2)) && isConstContext(parent2) || (isPropertyAssignment(parent2) || isShorthandPropertyAssignment(parent2) || isTemplateSpan(parent2)) && isConstContext(parent2.parent);
|
|
}
|
|
function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) {
|
|
const type = checkExpression(node, checkMode, forceTuple);
|
|
return isConstContext(node) || isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : isTypeAssertion3(node) ? type : getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType2(node, void 0) : contextualType, node, void 0));
|
|
}
|
|
function checkPropertyAssignment(node, checkMode) {
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
return checkExpressionForMutableLocation(node.initializer, checkMode);
|
|
}
|
|
function checkObjectLiteralMethod(node, checkMode) {
|
|
checkGrammarMethod(node);
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
const uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
|
|
}
|
|
function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) {
|
|
if (checkMode && checkMode & (2 /* Inferential */ | 8 /* SkipGenericFunctions */)) {
|
|
const callSignature = getSingleSignature(type, 0 /* Call */, true);
|
|
const constructSignature = getSingleSignature(type, 1 /* Construct */, true);
|
|
const signature = callSignature || constructSignature;
|
|
if (signature && signature.typeParameters) {
|
|
const contextualType = getApparentTypeOfContextualType(node, 2 /* NoConstraints */);
|
|
if (contextualType) {
|
|
const contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 /* Call */ : 1 /* Construct */, false);
|
|
if (contextualSignature && !contextualSignature.typeParameters) {
|
|
if (checkMode & 8 /* SkipGenericFunctions */) {
|
|
skippedGenericFunction(node, checkMode);
|
|
return anyFunctionType;
|
|
}
|
|
const context = getInferenceContext(node);
|
|
const returnType = context.signature && getReturnTypeOfSignature(context.signature);
|
|
const returnSignature = returnType && getSingleCallOrConstructSignature(returnType);
|
|
if (returnSignature && !returnSignature.typeParameters && !every(context.inferences, hasInferenceCandidates)) {
|
|
const uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters);
|
|
const instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters);
|
|
const inferences = map(context.inferences, (info) => createInferenceInfo(info.typeParameter));
|
|
applyToParameterTypes(instantiatedSignature, contextualSignature, (source, target) => {
|
|
inferTypes(inferences, source, target, 0, true);
|
|
});
|
|
if (some(inferences, hasInferenceCandidates)) {
|
|
applyToReturnTypes(instantiatedSignature, contextualSignature, (source, target) => {
|
|
inferTypes(inferences, source, target);
|
|
});
|
|
if (!hasOverlappingInferences(context.inferences, inferences)) {
|
|
mergeInferences(context.inferences, inferences);
|
|
context.inferredTypeParameters = concatenate(context.inferredTypeParameters, uniqueTypeParameters);
|
|
return getOrCreateTypeFromSignature(instantiatedSignature);
|
|
}
|
|
}
|
|
}
|
|
return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function skippedGenericFunction(node, checkMode) {
|
|
if (checkMode & 2 /* Inferential */) {
|
|
const context = getInferenceContext(node);
|
|
context.flags |= 4 /* SkippedGenericFunction */;
|
|
}
|
|
}
|
|
function hasInferenceCandidates(info) {
|
|
return !!(info.candidates || info.contraCandidates);
|
|
}
|
|
function hasInferenceCandidatesOrDefault(info) {
|
|
return !!(info.candidates || info.contraCandidates || hasTypeParameterDefault(info.typeParameter));
|
|
}
|
|
function hasOverlappingInferences(a, b) {
|
|
for (let i = 0; i < a.length; i++) {
|
|
if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function mergeInferences(target, source) {
|
|
for (let i = 0; i < target.length; i++) {
|
|
if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) {
|
|
target[i] = source[i];
|
|
}
|
|
}
|
|
}
|
|
function getUniqueTypeParameters(context, typeParameters) {
|
|
const result = [];
|
|
let oldTypeParameters;
|
|
let newTypeParameters;
|
|
for (const tp of typeParameters) {
|
|
const name = tp.symbol.escapedName;
|
|
if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) {
|
|
const newName = getUniqueTypeParameterName(concatenate(context.inferredTypeParameters, result), name);
|
|
const symbol = createSymbol(262144 /* TypeParameter */, newName);
|
|
const newTypeParameter = createTypeParameter(symbol);
|
|
newTypeParameter.target = tp;
|
|
oldTypeParameters = append(oldTypeParameters, tp);
|
|
newTypeParameters = append(newTypeParameters, newTypeParameter);
|
|
result.push(newTypeParameter);
|
|
} else {
|
|
result.push(tp);
|
|
}
|
|
}
|
|
if (newTypeParameters) {
|
|
const mapper = createTypeMapper(oldTypeParameters, newTypeParameters);
|
|
for (const tp of newTypeParameters) {
|
|
tp.mapper = mapper;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function hasTypeParameterByName(typeParameters, name) {
|
|
return some(typeParameters, (tp) => tp.symbol.escapedName === name);
|
|
}
|
|
function getUniqueTypeParameterName(typeParameters, baseName) {
|
|
let len = baseName.length;
|
|
while (len > 1 && baseName.charCodeAt(len - 1) >= 48 /* _0 */ && baseName.charCodeAt(len - 1) <= 57 /* _9 */)
|
|
len--;
|
|
const s = baseName.slice(0, len);
|
|
for (let index = 1; true; index++) {
|
|
const augmentedName = s + index;
|
|
if (!hasTypeParameterByName(typeParameters, augmentedName)) {
|
|
return augmentedName;
|
|
}
|
|
}
|
|
}
|
|
function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
|
|
const signature = getSingleCallSignature(funcType);
|
|
if (signature && !signature.typeParameters) {
|
|
return getReturnTypeOfSignature(signature);
|
|
}
|
|
}
|
|
function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
|
|
const funcType = checkExpression(expr.expression);
|
|
const nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
|
|
const returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
|
|
return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
|
|
}
|
|
function getTypeOfExpression(node) {
|
|
const quickType = getQuickTypeOfExpression(node);
|
|
if (quickType) {
|
|
return quickType;
|
|
}
|
|
if (node.flags & 134217728 /* TypeCached */ && flowTypeCache) {
|
|
const cachedType = flowTypeCache[getNodeId(node)];
|
|
if (cachedType) {
|
|
return cachedType;
|
|
}
|
|
}
|
|
const startInvocationCount = flowInvocationCount;
|
|
const type = checkExpression(node);
|
|
if (flowInvocationCount !== startInvocationCount) {
|
|
const cache = flowTypeCache || (flowTypeCache = []);
|
|
cache[getNodeId(node)] = type;
|
|
setNodeFlags(node, node.flags | 134217728 /* TypeCached */);
|
|
}
|
|
return type;
|
|
}
|
|
function getQuickTypeOfExpression(node) {
|
|
let expr = skipParentheses(node, true);
|
|
if (isJSDocTypeAssertion(expr)) {
|
|
const type = getJSDocTypeAssertionType(expr);
|
|
if (!isConstTypeReference(type)) {
|
|
return getTypeFromTypeNode(type);
|
|
}
|
|
}
|
|
expr = skipParentheses(node);
|
|
if (isCallExpression(expr) && expr.expression.kind !== 106 /* SuperKeyword */ && !isRequireCall(expr, true) && !isSymbolOrSymbolForCall(expr)) {
|
|
const type = isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
|
|
if (type) {
|
|
return type;
|
|
}
|
|
} else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
|
|
return getTypeFromTypeNode(expr.type);
|
|
} else if (node.kind === 8 /* NumericLiteral */ || node.kind === 10 /* StringLiteral */ || node.kind === 110 /* TrueKeyword */ || node.kind === 95 /* FalseKeyword */) {
|
|
return checkExpression(node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextFreeTypeOfExpression(node) {
|
|
const links = getNodeLinks(node);
|
|
if (links.contextFreeType) {
|
|
return links.contextFreeType;
|
|
}
|
|
const saveContextualType = node.contextualType;
|
|
node.contextualType = anyType;
|
|
try {
|
|
const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
|
|
return type;
|
|
} finally {
|
|
node.contextualType = saveContextualType;
|
|
}
|
|
}
|
|
function checkExpression(node, checkMode, forceTuple) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
const uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple);
|
|
const type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode);
|
|
if (isConstEnumObjectType(type)) {
|
|
checkConstEnumAccess(node, type);
|
|
}
|
|
currentNode = saveCurrentNode;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return type;
|
|
}
|
|
function checkConstEnumAccess(node, type) {
|
|
const ok = node.parent.kind === 208 /* PropertyAccessExpression */ && node.parent.expression === node || node.parent.kind === 209 /* ElementAccessExpression */ && node.parent.expression === node || ((node.kind === 79 /* Identifier */ || node.kind === 163 /* QualifiedName */) && isInRightSideOfImportOrExportAssignment(node) || node.parent.kind === 183 /* TypeQuery */ && node.parent.exprName === node) || node.parent.kind === 278 /* ExportSpecifier */;
|
|
if (!ok) {
|
|
error(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
|
|
}
|
|
if (compilerOptions.isolatedModules) {
|
|
Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
|
|
const constEnumDeclaration = type.symbol.valueDeclaration;
|
|
if (constEnumDeclaration.flags & 16777216 /* Ambient */) {
|
|
error(node, Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided);
|
|
}
|
|
}
|
|
}
|
|
function checkParenthesizedExpression(node, checkMode) {
|
|
if (hasJSDocNodes(node) && isJSDocTypeAssertion(node)) {
|
|
const type = getJSDocTypeAssertionType(node);
|
|
return checkAssertionWorker(type, type, node.expression, checkMode);
|
|
}
|
|
return checkExpression(node.expression, checkMode);
|
|
}
|
|
function checkExpressionWorker(node, checkMode, forceTuple) {
|
|
const kind = node.kind;
|
|
if (cancellationToken) {
|
|
switch (kind) {
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
switch (kind) {
|
|
case 79 /* Identifier */:
|
|
return checkIdentifier(node, checkMode);
|
|
case 80 /* PrivateIdentifier */:
|
|
return checkPrivateIdentifierExpression(node);
|
|
case 108 /* ThisKeyword */:
|
|
return checkThisExpression(node);
|
|
case 106 /* SuperKeyword */:
|
|
return checkSuperExpression(node);
|
|
case 104 /* NullKeyword */:
|
|
return nullWideningType;
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return getFreshTypeOfLiteralType(getStringLiteralType(node.text));
|
|
case 8 /* NumericLiteral */:
|
|
checkGrammarNumericLiteral(node);
|
|
return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text));
|
|
case 9 /* BigIntLiteral */:
|
|
checkGrammarBigIntLiteral(node);
|
|
return getFreshTypeOfLiteralType(getBigIntLiteralType({
|
|
negative: false,
|
|
base10Value: parsePseudoBigInt(node.text)
|
|
}));
|
|
case 110 /* TrueKeyword */:
|
|
return trueType;
|
|
case 95 /* FalseKeyword */:
|
|
return falseType;
|
|
case 225 /* TemplateExpression */:
|
|
return checkTemplateExpression(node);
|
|
case 13 /* RegularExpressionLiteral */:
|
|
return globalRegExpType;
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return checkArrayLiteral(node, checkMode, forceTuple);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return checkObjectLiteral(node, checkMode);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return checkPropertyAccessExpression(node, checkMode);
|
|
case 163 /* QualifiedName */:
|
|
return checkQualifiedName(node, checkMode);
|
|
case 209 /* ElementAccessExpression */:
|
|
return checkIndexedAccess(node, checkMode);
|
|
case 210 /* CallExpression */:
|
|
if (node.expression.kind === 100 /* ImportKeyword */) {
|
|
return checkImportCallExpression(node);
|
|
}
|
|
case 211 /* NewExpression */:
|
|
return checkCallExpression(node, checkMode);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return checkTaggedTemplateExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return checkParenthesizedExpression(node, checkMode);
|
|
case 228 /* ClassExpression */:
|
|
return checkClassExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode);
|
|
case 218 /* TypeOfExpression */:
|
|
return checkTypeOfExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return checkAssertion(node);
|
|
case 232 /* NonNullExpression */:
|
|
return checkNonNullAssertion(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return checkExpressionWithTypeArguments(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return checkSatisfiesExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return checkMetaProperty(node);
|
|
case 217 /* DeleteExpression */:
|
|
return checkDeleteExpression(node);
|
|
case 219 /* VoidExpression */:
|
|
return checkVoidExpression(node);
|
|
case 220 /* AwaitExpression */:
|
|
return checkAwaitExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return checkPrefixUnaryExpression(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return checkPostfixUnaryExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return checkBinaryExpression(node, checkMode);
|
|
case 224 /* ConditionalExpression */:
|
|
return checkConditionalExpression(node, checkMode);
|
|
case 227 /* SpreadElement */:
|
|
return checkSpreadExpression(node, checkMode);
|
|
case 229 /* OmittedExpression */:
|
|
return undefinedWideningType;
|
|
case 226 /* YieldExpression */:
|
|
return checkYieldExpression(node);
|
|
case 234 /* SyntheticExpression */:
|
|
return checkSyntheticExpression(node);
|
|
case 291 /* JsxExpression */:
|
|
return checkJsxExpression(node, checkMode);
|
|
case 281 /* JsxElement */:
|
|
return checkJsxElement(node, checkMode);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return checkJsxSelfClosingElement(node, checkMode);
|
|
case 285 /* JsxFragment */:
|
|
return checkJsxFragment(node);
|
|
case 289 /* JsxAttributes */:
|
|
return checkJsxAttributes(node, checkMode);
|
|
case 283 /* JsxOpeningElement */:
|
|
Debug.fail("Shouldn't ever directly check a JsxOpeningElement");
|
|
}
|
|
return errorType;
|
|
}
|
|
function checkTypeParameter(node) {
|
|
checkGrammarModifiers(node);
|
|
if (node.expression) {
|
|
grammarErrorOnFirstToken(node.expression, Diagnostics.Type_expected);
|
|
}
|
|
checkSourceElement(node.constraint);
|
|
checkSourceElement(node.default);
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
|
|
getBaseConstraintOfType(typeParameter);
|
|
if (!hasNonCircularTypeParameterDefault(typeParameter)) {
|
|
error(node.default, Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter));
|
|
}
|
|
const constraintType = getConstraintOfTypeParameter(typeParameter);
|
|
const defaultType = getDefaultFromTypeParameter(typeParameter);
|
|
if (constraintType && defaultType) {
|
|
checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
|
|
}
|
|
checkNodeDeferred(node);
|
|
addLazyDiagnostic(() => checkTypeNameIsReserved(node.name, Diagnostics.Type_parameter_name_cannot_be_0));
|
|
}
|
|
function checkTypeParameterDeferred(node) {
|
|
var _a2, _b;
|
|
if (isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent)) {
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node));
|
|
const modifiers = getVarianceModifiers(typeParameter);
|
|
if (modifiers) {
|
|
const symbol = getSymbolOfNode(node.parent);
|
|
if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
|
|
error(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
|
|
} else if (modifiers === 32768 /* In */ || modifiers === 65536 /* Out */) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) });
|
|
const source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSubTypeForCheck : markerSuperTypeForCheck);
|
|
const target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* Out */ ? markerSuperTypeForCheck : markerSubTypeForCheck);
|
|
const saveVarianceTypeParameter = typeParameter;
|
|
varianceTypeParameter = typeParameter;
|
|
checkTypeAssignableTo(source, target, node, Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation);
|
|
varianceTypeParameter = saveVarianceTypeParameter;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkParameter(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkVariableLikeDeclaration(node);
|
|
const func = getContainingFunction(node);
|
|
if (hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
|
|
if (!(func.kind === 173 /* Constructor */ && nodeIsPresent(func.body))) {
|
|
error(node, Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation);
|
|
}
|
|
if (func.kind === 173 /* Constructor */ && isIdentifier(node.name) && node.name.escapedText === "constructor") {
|
|
error(node.name, Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
|
|
}
|
|
}
|
|
if ((node.questionToken || isJSDocOptionalParameter(node)) && isBindingPattern(node.name) && func.body) {
|
|
error(node, Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
|
|
}
|
|
if (node.name && isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
|
|
if (func.parameters.indexOf(node) !== 0) {
|
|
error(node, Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText);
|
|
}
|
|
if (func.kind === 173 /* Constructor */ || func.kind === 177 /* ConstructSignature */ || func.kind === 182 /* ConstructorType */) {
|
|
error(node, Diagnostics.A_constructor_cannot_have_a_this_parameter);
|
|
}
|
|
if (func.kind === 216 /* ArrowFunction */) {
|
|
error(node, Diagnostics.An_arrow_function_cannot_have_a_this_parameter);
|
|
}
|
|
if (func.kind === 174 /* GetAccessor */ || func.kind === 175 /* SetAccessor */) {
|
|
error(node, Diagnostics.get_and_set_accessors_cannot_declare_this_parameters);
|
|
}
|
|
}
|
|
if (node.dotDotDotToken && !isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_of_an_array_type);
|
|
}
|
|
}
|
|
function checkTypePredicate(node) {
|
|
const parent2 = getTypePredicateParent(node);
|
|
if (!parent2) {
|
|
error(node, Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods);
|
|
return;
|
|
}
|
|
const signature = getSignatureFromDeclaration(parent2);
|
|
const typePredicate = getTypePredicateOfSignature(signature);
|
|
if (!typePredicate) {
|
|
return;
|
|
}
|
|
checkSourceElement(node.type);
|
|
const { parameterName } = node;
|
|
if (typePredicate.kind === 0 /* This */ || typePredicate.kind === 2 /* AssertsThis */) {
|
|
getTypeFromThisTypeNode(parameterName);
|
|
} else {
|
|
if (typePredicate.parameterIndex >= 0) {
|
|
if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) {
|
|
error(parameterName, Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter);
|
|
} else {
|
|
if (typePredicate.type) {
|
|
const leadingError = () => chainDiagnosticMessages(void 0, Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type);
|
|
checkTypeAssignableTo(
|
|
typePredicate.type,
|
|
getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]),
|
|
node.type,
|
|
void 0,
|
|
leadingError
|
|
);
|
|
}
|
|
}
|
|
} else if (parameterName) {
|
|
let hasReportedError = false;
|
|
for (const { name } of parent2.parameters) {
|
|
if (isBindingPattern(name) && checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) {
|
|
hasReportedError = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasReportedError) {
|
|
error(node.parameterName, Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypePredicateParent(node) {
|
|
switch (node.parent.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 176 /* CallSignature */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 181 /* FunctionType */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
const parent2 = node.parent;
|
|
if (node === parent2.type) {
|
|
return parent2;
|
|
}
|
|
}
|
|
}
|
|
function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) {
|
|
for (const element of pattern.elements) {
|
|
if (isOmittedExpression(element)) {
|
|
continue;
|
|
}
|
|
const name = element.name;
|
|
if (name.kind === 79 /* Identifier */ && name.escapedText === predicateVariableName) {
|
|
error(
|
|
predicateVariableNode,
|
|
Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern,
|
|
predicateVariableName
|
|
);
|
|
return true;
|
|
} else if (name.kind === 204 /* ArrayBindingPattern */ || name.kind === 203 /* ObjectBindingPattern */) {
|
|
if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(
|
|
name,
|
|
predicateVariableNode,
|
|
predicateVariableName
|
|
)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkSignatureDeclaration(node) {
|
|
if (node.kind === 178 /* IndexSignature */) {
|
|
checkGrammarIndexSignature(node);
|
|
} else if (node.kind === 181 /* FunctionType */ || node.kind === 259 /* FunctionDeclaration */ || node.kind === 182 /* ConstructorType */ || node.kind === 176 /* CallSignature */ || node.kind === 173 /* Constructor */ || node.kind === 177 /* ConstructSignature */) {
|
|
checkGrammarFunctionLikeDeclaration(node);
|
|
}
|
|
const functionFlags = getFunctionFlags(node);
|
|
if (!(functionFlags & 4 /* Invalid */)) {
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */);
|
|
}
|
|
if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* ES2017 */) {
|
|
checkExternalEmitHelpers(node, 64 /* Awaiter */);
|
|
}
|
|
if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 128 /* Generator */);
|
|
}
|
|
}
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
checkUnmatchedJSDocParameters(node);
|
|
forEach(node.parameters, checkParameter);
|
|
if (node.type) {
|
|
checkSourceElement(node.type);
|
|
}
|
|
addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
|
|
function checkSignatureDeclarationDiagnostics() {
|
|
checkCollisionWithArgumentsInGeneratedCode(node);
|
|
const returnTypeNode = getEffectiveReturnTypeNode(node);
|
|
if (noImplicitAny && !returnTypeNode) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
error(node, Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
error(node, Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type);
|
|
break;
|
|
}
|
|
}
|
|
if (returnTypeNode) {
|
|
const functionFlags2 = getFunctionFlags(node);
|
|
if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
|
|
const returnType = getTypeFromTypeNode(returnTypeNode);
|
|
if (returnType === voidType) {
|
|
error(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
|
|
} else {
|
|
const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
|
|
const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
|
|
const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
|
|
const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
|
|
checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
|
|
}
|
|
} else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
|
|
checkAsyncFunctionReturnType(node, returnTypeNode);
|
|
}
|
|
}
|
|
if (node.kind !== 178 /* IndexSignature */ && node.kind !== 320 /* JSDocFunctionType */) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
}
|
|
function checkClassForDuplicateDeclarations(node) {
|
|
const instanceNames = /* @__PURE__ */ new Map();
|
|
const staticNames = /* @__PURE__ */ new Map();
|
|
const privateIdentifiers = /* @__PURE__ */ new Map();
|
|
for (const member of node.members) {
|
|
if (member.kind === 173 /* Constructor */) {
|
|
for (const param of member.parameters) {
|
|
if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(param.name)) {
|
|
addName(instanceNames, param.name, param.name.escapedText, 3 /* GetOrSetAccessor */);
|
|
}
|
|
}
|
|
} else {
|
|
const isStaticMember = isStatic(member);
|
|
const name = member.name;
|
|
if (!name) {
|
|
continue;
|
|
}
|
|
const isPrivate = isPrivateIdentifier(name);
|
|
const privateStaticFlags = isPrivate && isStaticMember ? 16 /* PrivateStatic */ : 0;
|
|
const names = isPrivate ? privateIdentifiers : isStaticMember ? staticNames : instanceNames;
|
|
const memberName = name && getPropertyNameForPropertyNameNode(name);
|
|
if (memberName) {
|
|
switch (member.kind) {
|
|
case 174 /* GetAccessor */:
|
|
addName(names, name, memberName, 1 /* GetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 175 /* SetAccessor */:
|
|
addName(names, name, memberName, 2 /* SetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
addName(names, name, memberName, 3 /* GetOrSetAccessor */ | privateStaticFlags);
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
addName(names, name, memberName, 8 /* Method */ | privateStaticFlags);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addName(names, location2, name, meaning) {
|
|
const prev = names.get(name);
|
|
if (prev) {
|
|
if ((prev & 16 /* PrivateStatic */) !== (meaning & 16 /* PrivateStatic */)) {
|
|
error(location2, Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name, getTextOfNode(location2));
|
|
} else {
|
|
const prevIsMethod = !!(prev & 8 /* Method */);
|
|
const isMethod = !!(meaning & 8 /* Method */);
|
|
if (prevIsMethod || isMethod) {
|
|
if (prevIsMethod !== isMethod) {
|
|
error(location2, Diagnostics.Duplicate_identifier_0, getTextOfNode(location2));
|
|
}
|
|
} else if (prev & meaning & ~16 /* PrivateStatic */) {
|
|
error(location2, Diagnostics.Duplicate_identifier_0, getTextOfNode(location2));
|
|
} else {
|
|
names.set(name, prev | meaning);
|
|
}
|
|
}
|
|
} else {
|
|
names.set(name, meaning);
|
|
}
|
|
}
|
|
}
|
|
function checkClassForStaticPropertyNameConflicts(node) {
|
|
for (const member of node.members) {
|
|
const memberNameNode = member.name;
|
|
const isStaticMember = isStatic(member);
|
|
if (isStaticMember && memberNameNode) {
|
|
const memberName = getPropertyNameForPropertyNameNode(memberNameNode);
|
|
switch (memberName) {
|
|
case "name":
|
|
case "length":
|
|
case "caller":
|
|
case "arguments":
|
|
case "prototype":
|
|
const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
|
|
const className = getNameOfSymbolAsWritten(getSymbolOfNode(node));
|
|
error(memberNameNode, message, memberName, className);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkObjectTypeForDuplicateDeclarations(node) {
|
|
const names = /* @__PURE__ */ new Map();
|
|
for (const member of node.members) {
|
|
if (member.kind === 168 /* PropertySignature */) {
|
|
let memberName;
|
|
const name = member.name;
|
|
switch (name.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
memberName = name.text;
|
|
break;
|
|
case 79 /* Identifier */:
|
|
memberName = idText(name);
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
if (names.get(memberName)) {
|
|
error(getNameOfDeclaration(member.symbol.valueDeclaration), Diagnostics.Duplicate_identifier_0, memberName);
|
|
error(member.name, Diagnostics.Duplicate_identifier_0, memberName);
|
|
} else {
|
|
names.set(memberName, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkTypeForDuplicateIndexSignatures(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */) {
|
|
const nodeSymbol = getSymbolOfNode(node);
|
|
if (nodeSymbol.declarations && nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) {
|
|
return;
|
|
}
|
|
}
|
|
const indexSymbol = getIndexSymbol(getSymbolOfNode(node));
|
|
if (indexSymbol == null ? void 0 : indexSymbol.declarations) {
|
|
const indexSignatureMap = /* @__PURE__ */ new Map();
|
|
for (const declaration of indexSymbol.declarations) {
|
|
if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
|
|
forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
|
|
const entry = indexSignatureMap.get(getTypeId(type));
|
|
if (entry) {
|
|
entry.declarations.push(declaration);
|
|
} else {
|
|
indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
|
|
}
|
|
});
|
|
}
|
|
}
|
|
indexSignatureMap.forEach((entry) => {
|
|
if (entry.declarations.length > 1) {
|
|
for (const declaration of entry.declarations) {
|
|
error(declaration, Diagnostics.Duplicate_index_signature_for_type_0, typeToString(entry.type));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkPropertyDeclaration(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
checkVariableLikeDeclaration(node);
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 169 /* PropertyDeclaration */ && node.initializer) {
|
|
error(node, Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
function checkPropertySignature(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
error(node, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
return checkPropertyDeclaration(node);
|
|
}
|
|
function checkMethodDeclaration(node) {
|
|
if (!checkGrammarMethod(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
if (isMethodDeclaration(node) && node.asteriskToken && isIdentifier(node.name) && idText(node.name) === "constructor") {
|
|
error(node.name, Diagnostics.Class_constructor_may_not_be_a_generator);
|
|
}
|
|
checkFunctionOrMethodDeclaration(node);
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */) && node.kind === 171 /* MethodDeclaration */ && node.body) {
|
|
error(node, Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, declarationNameToString(node.name));
|
|
}
|
|
if (isPrivateIdentifier(node.name) && !getContainingClass(node)) {
|
|
error(node, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
}
|
|
function setNodeLinksForPrivateIdentifierScope(node) {
|
|
if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
|
|
for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
|
|
getNodeLinks(lexicalScope).flags |= 4194304 /* ContainsClassWithPrivateIdentifiers */;
|
|
}
|
|
if (isClassExpression(node.parent)) {
|
|
const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
|
|
if (enclosingIterationStatement) {
|
|
getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
|
|
getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkClassStaticBlockDeclaration(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
forEachChild(node, checkSourceElement);
|
|
}
|
|
function checkConstructorDeclaration(node) {
|
|
checkSignatureDeclaration(node);
|
|
if (!checkGrammarConstructorTypeParameters(node))
|
|
checkGrammarConstructorTypeAnnotation(node);
|
|
checkSourceElement(node.body);
|
|
const symbol = getSymbolOfNode(node);
|
|
const firstDeclaration = getDeclarationOfKind(symbol, node.kind);
|
|
if (node === firstDeclaration) {
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
}
|
|
if (nodeIsMissing(node.body)) {
|
|
return;
|
|
}
|
|
addLazyDiagnostic(checkConstructorDeclarationDiagnostics);
|
|
return;
|
|
function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) {
|
|
if (isPrivateIdentifierClassElementDeclaration(n)) {
|
|
return true;
|
|
}
|
|
return n.kind === 169 /* PropertyDeclaration */ && !isStatic(n) && !!n.initializer;
|
|
}
|
|
function checkConstructorDeclarationDiagnostics() {
|
|
const containingClassDecl = node.parent;
|
|
if (getClassExtendsHeritageElement(containingClassDecl)) {
|
|
captureLexicalThis(node.parent, containingClassDecl);
|
|
const classExtendsNull = classDeclarationExtendsNull(containingClassDecl);
|
|
const superCall = findFirstSuperCall(node.body);
|
|
if (superCall) {
|
|
if (classExtendsNull) {
|
|
error(superCall, Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null);
|
|
}
|
|
const superCallShouldBeRootLevel = (getEmitScriptTarget(compilerOptions) !== 99 /* ESNext */ || !useDefineForClassFields) && (some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || some(node.parameters, (p) => hasSyntacticModifier(p, 16476 /* ParameterPropertyModifier */)));
|
|
if (superCallShouldBeRootLevel) {
|
|
if (!superCallIsRootLevelInConstructor(superCall, node.body)) {
|
|
error(superCall, Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers);
|
|
} else {
|
|
let superCallStatement;
|
|
for (const statement of node.body.statements) {
|
|
if (isExpressionStatement(statement) && isSuperCall(skipOuterExpressions(statement.expression))) {
|
|
superCallStatement = statement;
|
|
break;
|
|
}
|
|
if (nodeImmediatelyReferencesSuperOrThis(statement)) {
|
|
break;
|
|
}
|
|
}
|
|
if (superCallStatement === void 0) {
|
|
error(node, Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers);
|
|
}
|
|
}
|
|
}
|
|
} else if (!classExtendsNull) {
|
|
error(node, Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function superCallIsRootLevelInConstructor(superCall, body) {
|
|
const superCallParent = walkUpParenthesizedExpressions(superCall.parent);
|
|
return isExpressionStatement(superCallParent) && superCallParent.parent === body;
|
|
}
|
|
function nodeImmediatelyReferencesSuperOrThis(node) {
|
|
if (node.kind === 106 /* SuperKeyword */ || node.kind === 108 /* ThisKeyword */) {
|
|
return true;
|
|
}
|
|
if (isThisContainerOrFunctionBlock(node)) {
|
|
return false;
|
|
}
|
|
return !!forEachChild(node, nodeImmediatelyReferencesSuperOrThis);
|
|
}
|
|
function checkAccessorDeclaration(node) {
|
|
if (isIdentifier(node.name) && idText(node.name) === "constructor") {
|
|
error(node.name, Diagnostics.Class_constructor_may_not_be_an_accessor);
|
|
}
|
|
addLazyDiagnostic(checkAccessorDeclarationDiagnostics);
|
|
checkSourceElement(node.body);
|
|
setNodeLinksForPrivateIdentifierScope(node);
|
|
function checkAccessorDeclarationDiagnostics() {
|
|
if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node))
|
|
checkGrammarComputedPropertyName(node.name);
|
|
checkDecorators(node);
|
|
checkSignatureDeclaration(node);
|
|
if (node.kind === 174 /* GetAccessor */) {
|
|
if (!(node.flags & 16777216 /* Ambient */) && nodeIsPresent(node.body) && node.flags & 256 /* HasImplicitReturn */) {
|
|
if (!(node.flags & 512 /* HasExplicitReturn */)) {
|
|
error(node.name, Diagnostics.A_get_accessor_must_return_a_value);
|
|
}
|
|
}
|
|
}
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
if (hasBindableName(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const getter = getDeclarationOfKind(symbol, 174 /* GetAccessor */);
|
|
const setter = getDeclarationOfKind(symbol, 175 /* SetAccessor */);
|
|
if (getter && setter && !(getNodeCheckFlags(getter) & 1 /* TypeChecked */)) {
|
|
getNodeLinks(getter).flags |= 1 /* TypeChecked */;
|
|
const getterFlags = getEffectiveModifierFlags(getter);
|
|
const setterFlags = getEffectiveModifierFlags(setter);
|
|
if ((getterFlags & 256 /* Abstract */) !== (setterFlags & 256 /* Abstract */)) {
|
|
error(getter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
|
|
error(setter.name, Diagnostics.Accessors_must_both_be_abstract_or_non_abstract);
|
|
}
|
|
if (getterFlags & 16 /* Protected */ && !(setterFlags & (16 /* Protected */ | 8 /* Private */)) || getterFlags & 8 /* Private */ && !(setterFlags & 8 /* Private */)) {
|
|
error(getter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
|
|
error(setter.name, Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter);
|
|
}
|
|
const getterType = getAnnotatedAccessorType(getter);
|
|
const setterType = getAnnotatedAccessorType(setter);
|
|
if (getterType && setterType) {
|
|
checkTypeAssignableTo(getterType, setterType, getter, Diagnostics.The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type);
|
|
}
|
|
}
|
|
}
|
|
const returnType = getTypeOfAccessors(getSymbolOfNode(node));
|
|
if (node.kind === 174 /* GetAccessor */) {
|
|
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
|
|
}
|
|
}
|
|
}
|
|
function checkMissingDeclaration(node) {
|
|
checkDecorators(node);
|
|
}
|
|
function getEffectiveTypeArgumentAtIndex(node, typeParameters, index) {
|
|
if (node.typeArguments && index < node.typeArguments.length) {
|
|
return getTypeFromTypeNode(node.typeArguments[index]);
|
|
}
|
|
return getEffectiveTypeArguments2(node, typeParameters)[index];
|
|
}
|
|
function getEffectiveTypeArguments2(node, typeParameters) {
|
|
return fillMissingTypeArguments(
|
|
map(node.typeArguments, getTypeFromTypeNode),
|
|
typeParameters,
|
|
getMinTypeArgumentCount(typeParameters),
|
|
isInJSFile(node)
|
|
);
|
|
}
|
|
function checkTypeArgumentConstraints(node, typeParameters) {
|
|
let typeArguments;
|
|
let mapper;
|
|
let result = true;
|
|
for (let i = 0; i < typeParameters.length; i++) {
|
|
const constraint = getConstraintOfTypeParameter(typeParameters[i]);
|
|
if (constraint) {
|
|
if (!typeArguments) {
|
|
typeArguments = getEffectiveTypeArguments2(node, typeParameters);
|
|
mapper = createTypeMapper(typeParameters, typeArguments);
|
|
}
|
|
result = result && checkTypeAssignableTo(
|
|
typeArguments[i],
|
|
instantiateType(constraint, mapper),
|
|
node.typeArguments[i],
|
|
Diagnostics.Type_0_does_not_satisfy_the_constraint_1
|
|
);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getTypeParametersForTypeReference(node) {
|
|
const type = getTypeFromTypeReference(node);
|
|
if (!isErrorType(type)) {
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol) {
|
|
return symbol.flags & 524288 /* TypeAlias */ && getSymbolLinks(symbol).typeParameters || (getObjectFlags(type) & 4 /* Reference */ ? type.target.localTypeParameters : void 0);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkTypeReferenceNode(node) {
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
if (node.kind === 180 /* TypeReference */ && node.typeName.jsdocDotPos !== void 0 && !isInJSFile(node) && !isInJSDoc(node)) {
|
|
grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
|
|
}
|
|
forEach(node.typeArguments, checkSourceElement);
|
|
const type = getTypeFromTypeReference(node);
|
|
if (!isErrorType(type)) {
|
|
if (node.typeArguments) {
|
|
addLazyDiagnostic(() => {
|
|
const typeParameters = getTypeParametersForTypeReference(node);
|
|
if (typeParameters) {
|
|
checkTypeArgumentConstraints(node, typeParameters);
|
|
}
|
|
});
|
|
}
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol) {
|
|
if (some(symbol.declarations, (d) => isTypeDeclaration(d) && !!(d.flags & 268435456 /* Deprecated */))) {
|
|
addDeprecatedSuggestion(
|
|
getDeprecatedSuggestionNode(node),
|
|
symbol.declarations,
|
|
symbol.escapedName
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getTypeArgumentConstraint(node) {
|
|
const typeReferenceNode = tryCast(node.parent, isTypeReferenceType);
|
|
if (!typeReferenceNode)
|
|
return void 0;
|
|
const typeParameters = getTypeParametersForTypeReference(typeReferenceNode);
|
|
if (!typeParameters)
|
|
return void 0;
|
|
const constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]);
|
|
return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments2(typeReferenceNode, typeParameters)));
|
|
}
|
|
function checkTypeQuery(node) {
|
|
getTypeFromTypeQueryNode(node);
|
|
}
|
|
function checkTypeLiteral(node) {
|
|
forEach(node.members, checkSourceElement);
|
|
addLazyDiagnostic(checkTypeLiteralDiagnostics);
|
|
function checkTypeLiteralDiagnostics() {
|
|
const type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
|
|
checkIndexConstraints(type, type.symbol);
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
checkObjectTypeForDuplicateDeclarations(node);
|
|
}
|
|
}
|
|
function checkArrayType(node) {
|
|
checkSourceElement(node.elementType);
|
|
}
|
|
function checkTupleType(node) {
|
|
const elementTypes = node.elements;
|
|
let seenOptionalElement = false;
|
|
let seenRestElement = false;
|
|
const hasNamedElement = some(elementTypes, isNamedTupleMember);
|
|
for (const e of elementTypes) {
|
|
if (e.kind !== 199 /* NamedTupleMember */ && hasNamedElement) {
|
|
grammarErrorOnNode(e, Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names);
|
|
break;
|
|
}
|
|
const flags = getTupleElementFlags(e);
|
|
if (flags & 8 /* Variadic */) {
|
|
const type = getTypeFromTypeNode(e.type);
|
|
if (!isArrayLikeType(type)) {
|
|
error(e, Diagnostics.A_rest_element_type_must_be_an_array_type);
|
|
break;
|
|
}
|
|
if (isArrayType(type) || isTupleType(type) && type.target.combinedFlags & 4 /* Rest */) {
|
|
seenRestElement = true;
|
|
}
|
|
} else if (flags & 4 /* Rest */) {
|
|
if (seenRestElement) {
|
|
grammarErrorOnNode(e, Diagnostics.A_rest_element_cannot_follow_another_rest_element);
|
|
break;
|
|
}
|
|
seenRestElement = true;
|
|
} else if (flags & 2 /* Optional */) {
|
|
if (seenRestElement) {
|
|
grammarErrorOnNode(e, Diagnostics.An_optional_element_cannot_follow_a_rest_element);
|
|
break;
|
|
}
|
|
seenOptionalElement = true;
|
|
} else if (seenOptionalElement) {
|
|
grammarErrorOnNode(e, Diagnostics.A_required_element_cannot_follow_an_optional_element);
|
|
break;
|
|
}
|
|
}
|
|
forEach(node.elements, checkSourceElement);
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkUnionOrIntersectionType(node) {
|
|
forEach(node.types, checkSourceElement);
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkIndexedAccessIndexType(type, accessNode) {
|
|
if (!(type.flags & 8388608 /* IndexedAccess */)) {
|
|
return type;
|
|
}
|
|
const objectType = type.objectType;
|
|
const indexType = type.indexType;
|
|
if (isTypeAssignableTo(indexType, getIndexType(objectType, false))) {
|
|
if (accessNode.kind === 209 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
|
|
error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
|
|
}
|
|
return type;
|
|
}
|
|
const apparentObjectType = getApparentType(objectType);
|
|
if (getIndexInfoOfType(apparentObjectType, numberType) && isTypeAssignableToKind(indexType, 296 /* NumberLike */)) {
|
|
return type;
|
|
}
|
|
if (isGenericObjectType(objectType)) {
|
|
const propertyName = getPropertyNameFromIndex(indexType, accessNode);
|
|
if (propertyName) {
|
|
const propertySymbol = forEachType(apparentObjectType, (t) => getPropertyOfType(t, propertyName));
|
|
if (propertySymbol && getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24 /* NonPublicAccessibilityModifier */) {
|
|
error(accessNode, Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, unescapeLeadingUnderscores(propertyName));
|
|
return errorType;
|
|
}
|
|
}
|
|
}
|
|
error(accessNode, Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType));
|
|
return errorType;
|
|
}
|
|
function checkIndexedAccessType(node) {
|
|
checkSourceElement(node.objectType);
|
|
checkSourceElement(node.indexType);
|
|
checkIndexedAccessIndexType(getTypeFromIndexedAccessTypeNode(node), node);
|
|
}
|
|
function checkMappedType(node) {
|
|
checkGrammarMappedType(node);
|
|
checkSourceElement(node.typeParameter);
|
|
checkSourceElement(node.nameType);
|
|
checkSourceElement(node.type);
|
|
if (!node.type) {
|
|
reportImplicitAny(node, anyType);
|
|
}
|
|
const type = getTypeFromMappedTypeNode(node);
|
|
const nameType = getNameTypeFromMappedType(type);
|
|
if (nameType) {
|
|
checkTypeAssignableTo(nameType, keyofConstraintType, node.nameType);
|
|
} else {
|
|
const constraintType = getConstraintTypeFromMappedType(type);
|
|
checkTypeAssignableTo(constraintType, keyofConstraintType, getEffectiveConstraintOfTypeParameter(node.typeParameter));
|
|
}
|
|
}
|
|
function checkGrammarMappedType(node) {
|
|
var _a2;
|
|
if ((_a2 = node.members) == null ? void 0 : _a2.length) {
|
|
return grammarErrorOnNode(node.members[0], Diagnostics.A_mapped_type_may_not_declare_properties_or_methods);
|
|
}
|
|
}
|
|
function checkThisType(node) {
|
|
getTypeFromThisTypeNode(node);
|
|
}
|
|
function checkTypeOperator(node) {
|
|
checkGrammarTypeOperatorNode(node);
|
|
checkSourceElement(node.type);
|
|
}
|
|
function checkConditionalType(node) {
|
|
forEachChild(node, checkSourceElement);
|
|
}
|
|
function checkInferType(node) {
|
|
if (!findAncestor(node, (n) => n.parent && n.parent.kind === 191 /* ConditionalType */ && n.parent.extendsType === n)) {
|
|
grammarErrorOnNode(node, Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type);
|
|
}
|
|
checkSourceElement(node.typeParameter);
|
|
const symbol = getSymbolOfNode(node.typeParameter);
|
|
if (symbol.declarations && symbol.declarations.length > 1) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.typeParametersChecked) {
|
|
links.typeParametersChecked = true;
|
|
const typeParameter = getDeclaredTypeOfTypeParameter(symbol);
|
|
const declarations = getDeclarationsOfKind(symbol, 165 /* TypeParameter */);
|
|
if (!areTypeParametersIdentical(declarations, [typeParameter], (decl) => [decl])) {
|
|
const name = symbolToString(symbol);
|
|
for (const declaration of declarations) {
|
|
error(declaration.name, Diagnostics.All_declarations_of_0_must_have_identical_constraints, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkTemplateLiteralType(node) {
|
|
for (const span of node.templateSpans) {
|
|
checkSourceElement(span.type);
|
|
const type = getTypeFromTypeNode(span.type);
|
|
checkTypeAssignableTo(type, templateConstraintType, span.type);
|
|
}
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkImportType(node) {
|
|
checkSourceElement(node.argument);
|
|
if (node.assertions) {
|
|
const override = getResolutionModeOverrideForClause(node.assertions.assertClause, grammarErrorOnNode);
|
|
if (override) {
|
|
if (!isNightly()) {
|
|
grammarErrorOnNode(node.assertions.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
grammarErrorOnNode(node.assertions.assertClause, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
|
|
}
|
|
}
|
|
}
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function checkNamedTupleMember(node) {
|
|
if (node.dotDotDotToken && node.questionToken) {
|
|
grammarErrorOnNode(node, Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest);
|
|
}
|
|
if (node.type.kind === 187 /* OptionalType */) {
|
|
grammarErrorOnNode(node.type, Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type);
|
|
}
|
|
if (node.type.kind === 188 /* RestType */) {
|
|
grammarErrorOnNode(node.type, Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type);
|
|
}
|
|
checkSourceElement(node.type);
|
|
getTypeFromTypeNode(node);
|
|
}
|
|
function isPrivateWithinAmbient(node) {
|
|
return (hasEffectiveModifier(node, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 16777216 /* Ambient */);
|
|
}
|
|
function getEffectiveDeclarationFlags(n, flagsToCheck) {
|
|
let flags = getCombinedModifierFlags(n);
|
|
if (n.parent.kind !== 261 /* InterfaceDeclaration */ && n.parent.kind !== 260 /* ClassDeclaration */ && n.parent.kind !== 228 /* ClassExpression */ && n.flags & 16777216 /* Ambient */) {
|
|
if (!(flags & 2 /* Ambient */) && !(isModuleBlock(n.parent) && isModuleDeclaration(n.parent.parent) && isGlobalScopeAugmentation(n.parent.parent))) {
|
|
flags |= 1 /* Export */;
|
|
}
|
|
flags |= 2 /* Ambient */;
|
|
}
|
|
return flags & flagsToCheck;
|
|
}
|
|
function checkFunctionOrConstructorSymbol(symbol) {
|
|
addLazyDiagnostic(() => checkFunctionOrConstructorSymbolWorker(symbol));
|
|
}
|
|
function checkFunctionOrConstructorSymbolWorker(symbol) {
|
|
function getCanonicalOverload(overloads, implementation) {
|
|
const implementationSharesContainerWithFirstOverload = implementation !== void 0 && implementation.parent === overloads[0].parent;
|
|
return implementationSharesContainerWithFirstOverload ? implementation : overloads[0];
|
|
}
|
|
function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck2, someOverloadFlags, allOverloadFlags) {
|
|
const someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
|
|
if (someButNotAllOverloadFlags !== 0) {
|
|
const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
|
|
forEach(overloads, (o) => {
|
|
const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
|
|
if (deviation & 1 /* Export */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
|
|
} else if (deviation & 2 /* Ambient */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
|
|
} else if (deviation & (8 /* Private */ | 16 /* Protected */)) {
|
|
error(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
|
|
} else if (deviation & 256 /* Abstract */) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken2, allHaveQuestionToken2) {
|
|
if (someHaveQuestionToken2 !== allHaveQuestionToken2) {
|
|
const canonicalHasQuestionToken = hasQuestionToken(getCanonicalOverload(overloads, implementation));
|
|
forEach(overloads, (o) => {
|
|
const deviation = hasQuestionToken(o) !== canonicalHasQuestionToken;
|
|
if (deviation) {
|
|
error(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_optional_or_required);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
const flagsToCheck = 1 /* Export */ | 2 /* Ambient */ | 8 /* Private */ | 16 /* Protected */ | 256 /* Abstract */;
|
|
let someNodeFlags = 0 /* None */;
|
|
let allNodeFlags = flagsToCheck;
|
|
let someHaveQuestionToken = false;
|
|
let allHaveQuestionToken = true;
|
|
let hasOverloads = false;
|
|
let bodyDeclaration;
|
|
let lastSeenNonAmbientDeclaration;
|
|
let previousDeclaration;
|
|
const declarations = symbol.declarations;
|
|
const isConstructor = (symbol.flags & 16384 /* Constructor */) !== 0;
|
|
function reportImplementationExpectedError(node) {
|
|
if (node.name && nodeIsMissing(node.name)) {
|
|
return;
|
|
}
|
|
let seen = false;
|
|
const subsequentNode = forEachChild(node.parent, (c) => {
|
|
if (seen) {
|
|
return c;
|
|
} else {
|
|
seen = c === node;
|
|
}
|
|
});
|
|
if (subsequentNode && subsequentNode.pos === node.end) {
|
|
if (subsequentNode.kind === node.kind) {
|
|
const errorNode2 = subsequentNode.name || subsequentNode;
|
|
const subsequentName = subsequentNode.name;
|
|
if (node.name && subsequentName && (isPrivateIdentifier(node.name) && isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText || isComputedPropertyName(node.name) && isComputedPropertyName(subsequentName) || isPropertyNameLiteral(node.name) && isPropertyNameLiteral(subsequentName) && getEscapedTextOfIdentifierOrLiteral(node.name) === getEscapedTextOfIdentifierOrLiteral(subsequentName))) {
|
|
const reportError = (node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */) && isStatic(node) !== isStatic(subsequentNode);
|
|
if (reportError) {
|
|
const diagnostic = isStatic(node) ? Diagnostics.Function_overload_must_be_static : Diagnostics.Function_overload_must_not_be_static;
|
|
error(errorNode2, diagnostic);
|
|
}
|
|
return;
|
|
}
|
|
if (nodeIsPresent(subsequentNode.body)) {
|
|
error(errorNode2, Diagnostics.Function_implementation_name_must_be_0, declarationNameToString(node.name));
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
const errorNode = node.name || node;
|
|
if (isConstructor) {
|
|
error(errorNode, Diagnostics.Constructor_implementation_is_missing);
|
|
} else {
|
|
if (hasSyntacticModifier(node, 256 /* Abstract */)) {
|
|
error(errorNode, Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive);
|
|
} else {
|
|
error(errorNode, Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration);
|
|
}
|
|
}
|
|
}
|
|
let duplicateFunctionDeclaration = false;
|
|
let multipleConstructorImplementation = false;
|
|
let hasNonAmbientClass = false;
|
|
const functionDeclarations = [];
|
|
if (declarations) {
|
|
for (const current of declarations) {
|
|
const node = current;
|
|
const inAmbientContext = node.flags & 16777216 /* Ambient */;
|
|
const inAmbientContextOrInterface = node.parent && (node.parent.kind === 261 /* InterfaceDeclaration */ || node.parent.kind === 184 /* TypeLiteral */) || inAmbientContext;
|
|
if (inAmbientContextOrInterface) {
|
|
previousDeclaration = void 0;
|
|
}
|
|
if ((node.kind === 260 /* ClassDeclaration */ || node.kind === 228 /* ClassExpression */) && !inAmbientContext) {
|
|
hasNonAmbientClass = true;
|
|
}
|
|
if (node.kind === 259 /* FunctionDeclaration */ || node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */ || node.kind === 173 /* Constructor */) {
|
|
functionDeclarations.push(node);
|
|
const currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck);
|
|
someNodeFlags |= currentNodeFlags;
|
|
allNodeFlags &= currentNodeFlags;
|
|
someHaveQuestionToken = someHaveQuestionToken || hasQuestionToken(node);
|
|
allHaveQuestionToken = allHaveQuestionToken && hasQuestionToken(node);
|
|
const bodyIsPresent = nodeIsPresent(node.body);
|
|
if (bodyIsPresent && bodyDeclaration) {
|
|
if (isConstructor) {
|
|
multipleConstructorImplementation = true;
|
|
} else {
|
|
duplicateFunctionDeclaration = true;
|
|
}
|
|
} else if ((previousDeclaration == null ? void 0 : previousDeclaration.parent) === node.parent && previousDeclaration.end !== node.pos) {
|
|
reportImplementationExpectedError(previousDeclaration);
|
|
}
|
|
if (bodyIsPresent) {
|
|
if (!bodyDeclaration) {
|
|
bodyDeclaration = node;
|
|
}
|
|
} else {
|
|
hasOverloads = true;
|
|
}
|
|
previousDeclaration = node;
|
|
if (!inAmbientContextOrInterface) {
|
|
lastSeenNonAmbientDeclaration = node;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (multipleConstructorImplementation) {
|
|
forEach(functionDeclarations, (declaration) => {
|
|
error(declaration, Diagnostics.Multiple_constructor_implementations_are_not_allowed);
|
|
});
|
|
}
|
|
if (duplicateFunctionDeclaration) {
|
|
forEach(functionDeclarations, (declaration) => {
|
|
error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Duplicate_function_implementation);
|
|
});
|
|
}
|
|
if (hasNonAmbientClass && !isConstructor && symbol.flags & 16 /* Function */ && declarations) {
|
|
const relatedDiagnostics = filter(declarations, (d) => d.kind === 260 /* ClassDeclaration */).map((d) => createDiagnosticForNode(d, Diagnostics.Consider_adding_a_declare_modifier_to_this_class));
|
|
forEach(declarations, (declaration) => {
|
|
const diagnostic = declaration.kind === 260 /* ClassDeclaration */ ? Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 : declaration.kind === 259 /* FunctionDeclaration */ ? Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient : void 0;
|
|
if (diagnostic) {
|
|
addRelatedInfo(
|
|
error(getNameOfDeclaration(declaration) || declaration, diagnostic, symbolName(symbol)),
|
|
...relatedDiagnostics
|
|
);
|
|
}
|
|
});
|
|
}
|
|
if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && !hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) {
|
|
reportImplementationExpectedError(lastSeenNonAmbientDeclaration);
|
|
}
|
|
if (hasOverloads) {
|
|
if (declarations) {
|
|
checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags);
|
|
checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken);
|
|
}
|
|
if (bodyDeclaration) {
|
|
const signatures = getSignaturesOfSymbol(symbol);
|
|
const bodySignature = getSignatureFromDeclaration(bodyDeclaration);
|
|
for (const signature of signatures) {
|
|
if (!isImplementationCompatibleWithOverload(bodySignature, signature)) {
|
|
addRelatedInfo(
|
|
error(signature.declaration, Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature),
|
|
createDiagnosticForNode(bodyDeclaration, Diagnostics.The_implementation_signature_is_declared_here)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkExportsOnMergedDeclarations(node) {
|
|
addLazyDiagnostic(() => checkExportsOnMergedDeclarationsWorker(node));
|
|
}
|
|
function checkExportsOnMergedDeclarationsWorker(node) {
|
|
let symbol = node.localSymbol;
|
|
if (!symbol) {
|
|
symbol = getSymbolOfNode(node);
|
|
if (!symbol.exportSymbol) {
|
|
return;
|
|
}
|
|
}
|
|
if (getDeclarationOfKind(symbol, node.kind) !== node) {
|
|
return;
|
|
}
|
|
let exportedDeclarationSpaces = 0 /* None */;
|
|
let nonExportedDeclarationSpaces = 0 /* None */;
|
|
let defaultExportedDeclarationSpaces = 0 /* None */;
|
|
for (const d of symbol.declarations) {
|
|
const declarationSpaces = getDeclarationSpaces(d);
|
|
const effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* Export */ | 1024 /* Default */);
|
|
if (effectiveDeclarationFlags & 1 /* Export */) {
|
|
if (effectiveDeclarationFlags & 1024 /* Default */) {
|
|
defaultExportedDeclarationSpaces |= declarationSpaces;
|
|
} else {
|
|
exportedDeclarationSpaces |= declarationSpaces;
|
|
}
|
|
} else {
|
|
nonExportedDeclarationSpaces |= declarationSpaces;
|
|
}
|
|
}
|
|
const nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;
|
|
const commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;
|
|
const commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;
|
|
if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {
|
|
for (const d of symbol.declarations) {
|
|
const declarationSpaces = getDeclarationSpaces(d);
|
|
const name = getNameOfDeclaration(d);
|
|
if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {
|
|
error(name, Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, declarationNameToString(name));
|
|
} else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) {
|
|
error(name, Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, declarationNameToString(name));
|
|
}
|
|
}
|
|
}
|
|
function getDeclarationSpaces(decl) {
|
|
let d = decl;
|
|
switch (d.kind) {
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return 2 /* ExportType */;
|
|
case 264 /* ModuleDeclaration */:
|
|
return isAmbientModule(d) || getModuleInstanceState(d) !== 0 /* NonInstantiated */ ? 4 /* ExportNamespace */ | 1 /* ExportValue */ : 4 /* ExportNamespace */;
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
return 2 /* ExportType */ | 1 /* ExportValue */;
|
|
case 308 /* SourceFile */:
|
|
return 2 /* ExportType */ | 1 /* ExportValue */ | 4 /* ExportNamespace */;
|
|
case 274 /* ExportAssignment */:
|
|
case 223 /* BinaryExpression */:
|
|
const node2 = d;
|
|
const expression = isExportAssignment(node2) ? node2.expression : node2.right;
|
|
if (!isEntityNameExpression(expression)) {
|
|
return 1 /* ExportValue */;
|
|
}
|
|
d = expression;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 271 /* NamespaceImport */:
|
|
case 270 /* ImportClause */:
|
|
let result = 0 /* None */;
|
|
const target = resolveAlias(getSymbolOfNode(d));
|
|
forEach(target.declarations, (d2) => {
|
|
result |= getDeclarationSpaces(d2);
|
|
});
|
|
return result;
|
|
case 257 /* VariableDeclaration */:
|
|
case 205 /* BindingElement */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 79 /* Identifier */:
|
|
return 1 /* ExportValue */;
|
|
default:
|
|
return Debug.failBadSyntaxKind(d);
|
|
}
|
|
}
|
|
}
|
|
function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
|
|
const promisedType = getPromisedTypeOfPromise(type, errorNode);
|
|
return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
|
|
}
|
|
function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) {
|
|
if (isTypeAny(type)) {
|
|
return void 0;
|
|
}
|
|
const typeAsPromise = type;
|
|
if (typeAsPromise.promisedTypeOfPromise) {
|
|
return typeAsPromise.promisedTypeOfPromise;
|
|
}
|
|
if (isReferenceToType2(type, getGlobalPromiseType(false))) {
|
|
return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
|
|
}
|
|
if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
|
|
return void 0;
|
|
}
|
|
const thenFunction = getTypeOfPropertyOfType(type, "then");
|
|
if (isTypeAny(thenFunction)) {
|
|
return void 0;
|
|
}
|
|
const thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0 /* Call */) : emptyArray;
|
|
if (thenSignatures.length === 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.A_promise_must_have_a_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
let thisTypeForError;
|
|
let candidates;
|
|
for (const thenSignature of thenSignatures) {
|
|
const thisType = getThisTypeOfSignature(thenSignature);
|
|
if (thisType && thisType !== voidType && !isTypeRelatedTo(type, thisType, subtypeRelation)) {
|
|
thisTypeForError = thisType;
|
|
} else {
|
|
candidates = append(candidates, thenSignature);
|
|
}
|
|
}
|
|
if (!candidates) {
|
|
Debug.assertIsDefined(thisTypeForError);
|
|
if (thisTypeForErrorOut) {
|
|
thisTypeForErrorOut.value = thisTypeForError;
|
|
}
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForError));
|
|
}
|
|
return void 0;
|
|
}
|
|
const onfulfilledParameterType = getTypeWithFacts(getUnionType(map(candidates, getTypeOfFirstParameterOfSignature)), 2097152 /* NEUndefinedOrNull */);
|
|
if (isTypeAny(onfulfilledParameterType)) {
|
|
return void 0;
|
|
}
|
|
const onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0 /* Call */);
|
|
if (onfulfilledParameterSignatures.length === 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback);
|
|
}
|
|
return void 0;
|
|
}
|
|
return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2 /* Subtype */);
|
|
}
|
|
function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, arg0) {
|
|
const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
|
|
return awaitedType || errorType;
|
|
}
|
|
function isThenableType(type) {
|
|
if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* Primitive */ | 131072 /* Never */)) {
|
|
return false;
|
|
}
|
|
const thenFunction = getTypeOfPropertyOfType(type, "then");
|
|
return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, 2097152 /* NEUndefinedOrNull */), 0 /* Call */).length > 0;
|
|
}
|
|
function isAwaitedTypeInstantiation(type) {
|
|
var _a2;
|
|
if (type.flags & 16777216 /* Conditional */) {
|
|
const awaitedSymbol = getGlobalAwaitedSymbol(false);
|
|
return !!awaitedSymbol && type.aliasSymbol === awaitedSymbol && ((_a2 = type.aliasTypeArguments) == null ? void 0 : _a2.length) === 1;
|
|
}
|
|
return false;
|
|
}
|
|
function unwrapAwaitedType(type) {
|
|
return type.flags & 1048576 /* Union */ ? mapType(type, unwrapAwaitedType) : isAwaitedTypeInstantiation(type) ? type.aliasTypeArguments[0] : type;
|
|
}
|
|
function isAwaitedTypeNeeded(type) {
|
|
if (isTypeAny(type) || isAwaitedTypeInstantiation(type)) {
|
|
return false;
|
|
}
|
|
if (isGenericObjectType(type)) {
|
|
const baseConstraint = getBaseConstraintOfType(type);
|
|
if (baseConstraint ? baseConstraint.flags & 3 /* AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || someType(baseConstraint, isThenableType) : maybeTypeOfKind(type, 8650752 /* TypeVariable */)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function tryCreateAwaitedType(type) {
|
|
const awaitedSymbol = getGlobalAwaitedSymbol(true);
|
|
if (awaitedSymbol) {
|
|
return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
|
|
}
|
|
return void 0;
|
|
}
|
|
function createAwaitedTypeIfNeeded(type) {
|
|
if (isAwaitedTypeNeeded(type)) {
|
|
const awaitedType = tryCreateAwaitedType(type);
|
|
if (awaitedType) {
|
|
return awaitedType;
|
|
}
|
|
}
|
|
Debug.assert(getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
|
|
return type;
|
|
}
|
|
function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
|
|
const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
|
|
return awaitedType && createAwaitedTypeIfNeeded(awaitedType);
|
|
}
|
|
function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0) {
|
|
if (isTypeAny(type)) {
|
|
return type;
|
|
}
|
|
if (isAwaitedTypeInstantiation(type)) {
|
|
return type;
|
|
}
|
|
const typeAsAwaitable = type;
|
|
if (typeAsAwaitable.awaitedTypeOfType) {
|
|
return typeAsAwaitable.awaitedTypeOfType;
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
if (awaitedTypeStack.lastIndexOf(type.id) >= 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias;
|
|
awaitedTypeStack.push(type.id);
|
|
const mapped = mapType(type, mapper);
|
|
awaitedTypeStack.pop();
|
|
return typeAsAwaitable.awaitedTypeOfType = mapped;
|
|
}
|
|
if (isAwaitedTypeNeeded(type)) {
|
|
return typeAsAwaitable.awaitedTypeOfType = type;
|
|
}
|
|
const thisTypeForErrorOut = { value: void 0 };
|
|
const promisedType = getPromisedTypeOfPromise(type, void 0, thisTypeForErrorOut);
|
|
if (promisedType) {
|
|
if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method);
|
|
}
|
|
return void 0;
|
|
}
|
|
awaitedTypeStack.push(type.id);
|
|
const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, arg0);
|
|
awaitedTypeStack.pop();
|
|
if (!awaitedType) {
|
|
return void 0;
|
|
}
|
|
return typeAsAwaitable.awaitedTypeOfType = awaitedType;
|
|
}
|
|
if (isThenableType(type)) {
|
|
if (errorNode) {
|
|
Debug.assertIsDefined(diagnosticMessage);
|
|
let chain;
|
|
if (thisTypeForErrorOut.value) {
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value));
|
|
}
|
|
chain = chainDiagnosticMessages(chain, diagnosticMessage, arg0);
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(errorNode, chain));
|
|
}
|
|
return void 0;
|
|
}
|
|
return typeAsAwaitable.awaitedTypeOfType = type;
|
|
}
|
|
function checkAsyncFunctionReturnType(node, returnTypeNode) {
|
|
const returnType = getTypeFromTypeNode(returnTypeNode);
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
if (isErrorType(returnType)) {
|
|
return;
|
|
}
|
|
const globalPromiseType = getGlobalPromiseType(true);
|
|
if (globalPromiseType !== emptyGenericType && !isReferenceToType2(returnType, globalPromiseType)) {
|
|
error(returnTypeNode, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
|
|
return;
|
|
}
|
|
} else {
|
|
markTypeNodeAsReferenced(returnTypeNode);
|
|
if (isErrorType(returnType)) {
|
|
return;
|
|
}
|
|
const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
|
|
if (promiseConstructorName === void 0) {
|
|
error(returnTypeNode, Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, typeToString(returnType));
|
|
return;
|
|
}
|
|
const promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551 /* Value */, true);
|
|
const promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType;
|
|
if (isErrorType(promiseConstructorType)) {
|
|
if (promiseConstructorName.kind === 79 /* Identifier */ && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(false)) {
|
|
error(returnTypeNode, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
|
|
} else {
|
|
error(returnTypeNode, Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, entityNameToString(promiseConstructorName));
|
|
}
|
|
return;
|
|
}
|
|
const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(true);
|
|
if (globalPromiseConstructorLikeType === emptyObjectType) {
|
|
error(returnTypeNode, Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, entityNameToString(promiseConstructorName));
|
|
return;
|
|
}
|
|
if (!checkTypeAssignableTo(
|
|
promiseConstructorType,
|
|
globalPromiseConstructorLikeType,
|
|
returnTypeNode,
|
|
Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value
|
|
)) {
|
|
return;
|
|
}
|
|
const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
|
|
const collidingSymbol = getSymbol2(node.locals, rootName.escapedText, 111551 /* Value */);
|
|
if (collidingSymbol) {
|
|
error(
|
|
collidingSymbol.valueDeclaration,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions,
|
|
idText(rootName),
|
|
entityNameToString(promiseConstructorName)
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
checkAwaitedType(returnType, false, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
|
|
}
|
|
function checkDecorator(node) {
|
|
const signature = getResolvedSignature(node);
|
|
checkDeprecatedSignature(signature, node);
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
if (returnType.flags & 1 /* Any */) {
|
|
return;
|
|
}
|
|
let headMessage;
|
|
let expectedReturnType;
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
|
|
const classSymbol = getSymbolOfNode(node.parent);
|
|
const classConstructorType = getTypeOfSymbol(classSymbol);
|
|
expectedReturnType = getUnionType([classConstructorType, voidType]);
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 166 /* Parameter */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
|
|
expectedReturnType = voidType;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
|
|
const methodType = getTypeOfNode(node.parent);
|
|
const descriptorType = createTypedPropertyDescriptorType(methodType);
|
|
expectedReturnType = getUnionType([descriptorType, voidType]);
|
|
break;
|
|
default:
|
|
return Debug.fail();
|
|
}
|
|
checkTypeAssignableTo(
|
|
returnType,
|
|
expectedReturnType,
|
|
node,
|
|
headMessage
|
|
);
|
|
}
|
|
function markTypeNodeAsReferenced(node) {
|
|
markEntityNameOrEntityExpressionAsReference(node && getEntityNameFromTypeNode(node), false);
|
|
}
|
|
function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
|
|
if (!typeName)
|
|
return;
|
|
const rootName = getFirstIdentifier(typeName);
|
|
const meaning = (typeName.kind === 79 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
|
|
const rootSymbol = resolveName(rootName, rootName.escapedText, meaning, void 0, void 0, true);
|
|
if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
|
|
if (symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
|
|
markAliasSymbolAsReferenced(rootSymbol);
|
|
} else if (forDecoratorMetadata && compilerOptions.isolatedModules && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
|
|
const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
|
|
const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration2);
|
|
if (aliasDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function markDecoratorMedataDataTypeNodeAsReferenced(node) {
|
|
const entityName = getEntityNameForDecoratorMetadata(node);
|
|
if (entityName && isEntityName(entityName)) {
|
|
markEntityNameOrEntityExpressionAsReference(entityName, true);
|
|
}
|
|
}
|
|
function getEntityNameForDecoratorMetadata(node) {
|
|
if (node) {
|
|
switch (node.kind) {
|
|
case 190 /* IntersectionType */:
|
|
case 189 /* UnionType */:
|
|
return getEntityNameForDecoratorMetadataFromTypeList(node.types);
|
|
case 191 /* ConditionalType */:
|
|
return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]);
|
|
case 193 /* ParenthesizedType */:
|
|
case 199 /* NamedTupleMember */:
|
|
return getEntityNameForDecoratorMetadata(node.type);
|
|
case 180 /* TypeReference */:
|
|
return node.typeName;
|
|
}
|
|
}
|
|
}
|
|
function getEntityNameForDecoratorMetadataFromTypeList(types) {
|
|
let commonEntityName;
|
|
for (let typeNode of types) {
|
|
while (typeNode.kind === 193 /* ParenthesizedType */ || typeNode.kind === 199 /* NamedTupleMember */) {
|
|
typeNode = typeNode.type;
|
|
}
|
|
if (typeNode.kind === 144 /* NeverKeyword */) {
|
|
continue;
|
|
}
|
|
if (!strictNullChecks && (typeNode.kind === 198 /* LiteralType */ && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
|
|
continue;
|
|
}
|
|
const individualEntityName = getEntityNameForDecoratorMetadata(typeNode);
|
|
if (!individualEntityName) {
|
|
return void 0;
|
|
}
|
|
if (commonEntityName) {
|
|
if (!isIdentifier(commonEntityName) || !isIdentifier(individualEntityName) || commonEntityName.escapedText !== individualEntityName.escapedText) {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
commonEntityName = individualEntityName;
|
|
}
|
|
}
|
|
return commonEntityName;
|
|
}
|
|
function getParameterTypeNodeForDecoratorCheck(node) {
|
|
const typeNode = getEffectiveTypeAnnotationNode(node);
|
|
return isRestParameter(node) ? getRestParameterElementType(typeNode) : typeNode;
|
|
}
|
|
function checkDecorators(node) {
|
|
if (!canHaveDecorators(node) || !hasDecorators(node) || !node.modifiers || !nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
|
|
return;
|
|
}
|
|
if (!compilerOptions.experimentalDecorators) {
|
|
error(node, Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning);
|
|
}
|
|
const firstDecorator = find(node.modifiers, isDecorator);
|
|
if (!firstDecorator) {
|
|
return;
|
|
}
|
|
checkExternalEmitHelpers(firstDecorator, 8 /* Decorate */);
|
|
if (node.kind === 166 /* Parameter */) {
|
|
checkExternalEmitHelpers(firstDecorator, 32 /* Param */);
|
|
}
|
|
if (compilerOptions.emitDecoratorMetadata) {
|
|
checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
if (constructor) {
|
|
for (const parameter of constructor.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
}
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const otherKind = node.kind === 174 /* GetAccessor */ ? 175 /* SetAccessor */ : 174 /* GetAccessor */;
|
|
const otherAccessor = getDeclarationOfKind(getSymbolOfNode(node), otherKind);
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
for (const parameter of node.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
|
|
break;
|
|
case 166 /* Parameter */:
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
|
|
const containingSignature = node.parent;
|
|
for (const parameter of containingSignature.parameters) {
|
|
markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
for (const modifier of node.modifiers) {
|
|
if (isDecorator(modifier)) {
|
|
checkDecorator(modifier);
|
|
}
|
|
}
|
|
}
|
|
function checkFunctionDeclaration(node) {
|
|
addLazyDiagnostic(checkFunctionDeclarationDiagnostics);
|
|
function checkFunctionDeclarationDiagnostics() {
|
|
checkFunctionOrMethodDeclaration(node);
|
|
checkGrammarForGenerator(node);
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
}
|
|
function checkJSDocTypeAliasTag(node) {
|
|
if (!node.typeExpression) {
|
|
error(node.name, Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags);
|
|
}
|
|
if (node.name) {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
|
|
}
|
|
checkSourceElement(node.typeExpression);
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
}
|
|
function checkJSDocTemplateTag(node) {
|
|
checkSourceElement(node.constraint);
|
|
for (const tp of node.typeParameters) {
|
|
checkSourceElement(tp);
|
|
}
|
|
}
|
|
function checkJSDocTypeTag(node) {
|
|
checkSourceElement(node.typeExpression);
|
|
}
|
|
function checkJSDocLinkLikeTag(node) {
|
|
if (node.name) {
|
|
resolveJSDocMemberName(node.name, true);
|
|
}
|
|
}
|
|
function checkJSDocParameterTag(node) {
|
|
checkSourceElement(node.typeExpression);
|
|
}
|
|
function checkJSDocPropertyTag(node) {
|
|
checkSourceElement(node.typeExpression);
|
|
}
|
|
function checkJSDocFunctionType(node) {
|
|
addLazyDiagnostic(checkJSDocFunctionTypeImplicitAny);
|
|
checkSignatureDeclaration(node);
|
|
function checkJSDocFunctionTypeImplicitAny() {
|
|
if (!node.type && !isJSDocConstructSignature(node)) {
|
|
reportImplicitAny(node, anyType);
|
|
}
|
|
}
|
|
}
|
|
function checkJSDocImplementsTag(node) {
|
|
const classLike = getEffectiveJSDocHost(node);
|
|
if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
|
|
error(classLike, Diagnostics.JSDoc_0_is_not_attached_to_a_class, idText(node.tagName));
|
|
}
|
|
}
|
|
function checkJSDocAugmentsTag(node) {
|
|
const classLike = getEffectiveJSDocHost(node);
|
|
if (!classLike || !isClassDeclaration(classLike) && !isClassExpression(classLike)) {
|
|
error(classLike, Diagnostics.JSDoc_0_is_not_attached_to_a_class, idText(node.tagName));
|
|
return;
|
|
}
|
|
const augmentsTags = getJSDocTags(classLike).filter(isJSDocAugmentsTag);
|
|
Debug.assert(augmentsTags.length > 0);
|
|
if (augmentsTags.length > 1) {
|
|
error(augmentsTags[1], Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag);
|
|
}
|
|
const name = getIdentifierFromEntityNameExpression(node.class.expression);
|
|
const extend2 = getClassExtendsHeritageElement(classLike);
|
|
if (extend2) {
|
|
const className = getIdentifierFromEntityNameExpression(extend2.expression);
|
|
if (className && name.escapedText !== className.escapedText) {
|
|
error(name, Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, idText(node.tagName), idText(name), idText(className));
|
|
}
|
|
}
|
|
}
|
|
function checkJSDocAccessibilityModifiers(node) {
|
|
const host2 = getJSDocHost(node);
|
|
if (host2 && isPrivateIdentifierClassElementDeclaration(host2)) {
|
|
error(node, Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
|
|
}
|
|
}
|
|
function getIdentifierFromEntityNameExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
return node.name;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function checkFunctionOrMethodDeclaration(node) {
|
|
var _a2;
|
|
checkDecorators(node);
|
|
checkSignatureDeclaration(node);
|
|
const functionFlags = getFunctionFlags(node);
|
|
if (node.name && node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
}
|
|
if (hasBindableName(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const localSymbol = node.localSymbol || symbol;
|
|
const firstDeclaration = (_a2 = localSymbol.declarations) == null ? void 0 : _a2.find(
|
|
(declaration) => declaration.kind === node.kind && !(declaration.flags & 262144 /* JavaScriptFile */)
|
|
);
|
|
if (node === firstDeclaration) {
|
|
checkFunctionOrConstructorSymbol(localSymbol);
|
|
}
|
|
if (symbol.parent) {
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
}
|
|
}
|
|
const body = node.kind === 170 /* MethodSignature */ ? void 0 : node.body;
|
|
checkSourceElement(body);
|
|
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
|
|
addLazyDiagnostic(checkFunctionOrMethodDeclarationDiagnostics);
|
|
if (isInJSFile(node)) {
|
|
const typeTag = getJSDocTypeTag(node);
|
|
if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) {
|
|
error(typeTag.typeExpression.type, Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature);
|
|
}
|
|
}
|
|
function checkFunctionOrMethodDeclarationDiagnostics() {
|
|
if (!getEffectiveReturnTypeNode(node)) {
|
|
if (nodeIsMissing(body) && !isPrivateWithinAmbient(node)) {
|
|
reportImplicitAny(node, anyType);
|
|
}
|
|
if (functionFlags & 1 /* Generator */ && nodeIsPresent(body)) {
|
|
getReturnTypeOfSignature(getSignatureFromDeclaration(node));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function registerForUnusedIdentifiersCheck(node) {
|
|
addLazyDiagnostic(registerForUnusedIdentifiersCheckDiagnostics);
|
|
function registerForUnusedIdentifiersCheckDiagnostics() {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
let potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path);
|
|
if (!potentiallyUnusedIdentifiers) {
|
|
potentiallyUnusedIdentifiers = [];
|
|
allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers);
|
|
}
|
|
potentiallyUnusedIdentifiers.push(node);
|
|
}
|
|
}
|
|
function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) {
|
|
for (const node of potentiallyUnusedIdentifiers) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
checkUnusedClassMembers(node, addDiagnostic);
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 238 /* Block */:
|
|
case 266 /* CaseBlock */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
checkUnusedLocalsAndParameters(node, addDiagnostic);
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
if (node.body) {
|
|
checkUnusedLocalsAndParameters(node, addDiagnostic);
|
|
}
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
checkUnusedTypeParameters(node, addDiagnostic);
|
|
break;
|
|
case 192 /* InferType */:
|
|
checkUnusedInferTypeParameter(node, addDiagnostic);
|
|
break;
|
|
default:
|
|
Debug.assertNever(node, "Node should not have been registered for unused identifiers check");
|
|
}
|
|
}
|
|
}
|
|
function errorUnusedLocal(declaration, name, addDiagnostic) {
|
|
const node = getNameOfDeclaration(declaration) || declaration;
|
|
const message = isTypeDeclaration(declaration) ? Diagnostics._0_is_declared_but_never_used : Diagnostics._0_is_declared_but_its_value_is_never_read;
|
|
addDiagnostic(declaration, 0 /* Local */, createDiagnosticForNode(node, message, name));
|
|
}
|
|
function isIdentifierThatStartsWithUnderscore(node) {
|
|
return isIdentifier(node) && idText(node).charCodeAt(0) === 95 /* _ */;
|
|
}
|
|
function checkUnusedClassMembers(node, addDiagnostic) {
|
|
for (const member of node.members) {
|
|
switch (member.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
if (member.kind === 175 /* SetAccessor */ && member.symbol.flags & 32768 /* GetAccessor */) {
|
|
break;
|
|
}
|
|
const symbol = getSymbolOfNode(member);
|
|
if (!symbol.isReferenced && (hasEffectiveModifier(member, 8 /* Private */) || isNamedDeclaration(member) && isPrivateIdentifier(member.name)) && !(member.flags & 16777216 /* Ambient */)) {
|
|
addDiagnostic(member, 0 /* Local */, createDiagnosticForNode(member.name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol)));
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
for (const parameter of member.parameters) {
|
|
if (!parameter.symbol.isReferenced && hasSyntacticModifier(parameter, 8 /* Private */)) {
|
|
addDiagnostic(parameter, 0 /* Local */, createDiagnosticForNode(parameter.name, Diagnostics.Property_0_is_declared_but_its_value_is_never_read, symbolName(parameter.symbol)));
|
|
}
|
|
}
|
|
break;
|
|
case 178 /* IndexSignature */:
|
|
case 237 /* SemicolonClassElement */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
break;
|
|
default:
|
|
Debug.fail("Unexpected class member");
|
|
}
|
|
}
|
|
}
|
|
function checkUnusedInferTypeParameter(node, addDiagnostic) {
|
|
const { typeParameter } = node;
|
|
if (isTypeParameterUnused(typeParameter)) {
|
|
addDiagnostic(node, 1 /* Parameter */, createDiagnosticForNode(node, Diagnostics._0_is_declared_but_its_value_is_never_read, idText(typeParameter.name)));
|
|
}
|
|
}
|
|
function checkUnusedTypeParameters(node, addDiagnostic) {
|
|
const declarations = getSymbolOfNode(node).declarations;
|
|
if (!declarations || last(declarations) !== node)
|
|
return;
|
|
const typeParameters = getEffectiveTypeParameterDeclarations(node);
|
|
const seenParentsWithEveryUnused = /* @__PURE__ */ new Set();
|
|
for (const typeParameter of typeParameters) {
|
|
if (!isTypeParameterUnused(typeParameter))
|
|
continue;
|
|
const name = idText(typeParameter.name);
|
|
const { parent: parent2 } = typeParameter;
|
|
if (parent2.kind !== 192 /* InferType */ && parent2.typeParameters.every(isTypeParameterUnused)) {
|
|
if (tryAddToSet(seenParentsWithEveryUnused, parent2)) {
|
|
const sourceFile = getSourceFileOfNode(parent2);
|
|
const range = isJSDocTemplateTag(parent2) ? rangeOfNode(parent2) : rangeOfTypeParameters(sourceFile, parent2.typeParameters);
|
|
const only = parent2.typeParameters.length === 1;
|
|
const message = only ? Diagnostics._0_is_declared_but_its_value_is_never_read : Diagnostics.All_type_parameters_are_unused;
|
|
const arg0 = only ? name : void 0;
|
|
addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0));
|
|
}
|
|
} else {
|
|
addDiagnostic(typeParameter, 1 /* Parameter */, createDiagnosticForNode(typeParameter, Diagnostics._0_is_declared_but_its_value_is_never_read, name));
|
|
}
|
|
}
|
|
}
|
|
function isTypeParameterUnused(typeParameter) {
|
|
return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144 /* TypeParameter */) && !isIdentifierThatStartsWithUnderscore(typeParameter.name);
|
|
}
|
|
function addToGroup(map2, key, value, getKey) {
|
|
const keyString = String(getKey(key));
|
|
const group2 = map2.get(keyString);
|
|
if (group2) {
|
|
group2[1].push(value);
|
|
} else {
|
|
map2.set(keyString, [key, [value]]);
|
|
}
|
|
}
|
|
function tryGetRootParameterDeclaration(node) {
|
|
return tryCast(getRootDeclaration(node), isParameter);
|
|
}
|
|
function isValidUnusedLocalDeclaration(declaration) {
|
|
if (isBindingElement(declaration)) {
|
|
if (isObjectBindingPattern(declaration.parent)) {
|
|
return !!(declaration.propertyName && isIdentifierThatStartsWithUnderscore(declaration.name));
|
|
}
|
|
return isIdentifierThatStartsWithUnderscore(declaration.name);
|
|
}
|
|
return isAmbientModule(declaration) || (isVariableDeclaration(declaration) && isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name);
|
|
}
|
|
function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) {
|
|
const unusedImports = /* @__PURE__ */ new Map();
|
|
const unusedDestructures = /* @__PURE__ */ new Map();
|
|
const unusedVariables = /* @__PURE__ */ new Map();
|
|
nodeWithLocals.locals.forEach((local) => {
|
|
if (local.flags & 262144 /* TypeParameter */ ? !(local.flags & 3 /* Variable */ && !(local.isReferenced & 3 /* Variable */)) : local.isReferenced || local.exportSymbol) {
|
|
return;
|
|
}
|
|
if (local.declarations) {
|
|
for (const declaration of local.declarations) {
|
|
if (isValidUnusedLocalDeclaration(declaration)) {
|
|
continue;
|
|
}
|
|
if (isImportedDeclaration(declaration)) {
|
|
addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId);
|
|
} else if (isBindingElement(declaration) && isObjectBindingPattern(declaration.parent)) {
|
|
const lastElement = last(declaration.parent.elements);
|
|
if (declaration === lastElement || !last(declaration.parent.elements).dotDotDotToken) {
|
|
addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
|
|
}
|
|
} else if (isVariableDeclaration(declaration)) {
|
|
addToGroup(unusedVariables, declaration.parent, declaration, getNodeId);
|
|
} else {
|
|
const parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration);
|
|
const name = local.valueDeclaration && getNameOfDeclaration(local.valueDeclaration);
|
|
if (parameter && name) {
|
|
if (!isParameterPropertyDeclaration(parameter, parameter.parent) && !parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) {
|
|
if (isBindingElement(declaration) && isArrayBindingPattern(declaration.parent)) {
|
|
addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);
|
|
} else {
|
|
addDiagnostic(parameter, 1 /* Parameter */, createDiagnosticForNode(name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolName(local)));
|
|
}
|
|
}
|
|
} else {
|
|
errorUnusedLocal(declaration, symbolName(local), addDiagnostic);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
unusedImports.forEach(([importClause, unuseds]) => {
|
|
const importDecl = importClause.parent;
|
|
const nDeclarations = (importClause.name ? 1 : 0) + (importClause.namedBindings ? importClause.namedBindings.kind === 271 /* NamespaceImport */ ? 1 : importClause.namedBindings.elements.length : 0);
|
|
if (nDeclarations === unuseds.length) {
|
|
addDiagnostic(importDecl, 0 /* Local */, unuseds.length === 1 ? createDiagnosticForNode(importDecl, Diagnostics._0_is_declared_but_its_value_is_never_read, idText(first(unuseds).name)) : createDiagnosticForNode(importDecl, Diagnostics.All_imports_in_import_declaration_are_unused));
|
|
} else {
|
|
for (const unused of unuseds)
|
|
errorUnusedLocal(unused, idText(unused.name), addDiagnostic);
|
|
}
|
|
});
|
|
unusedDestructures.forEach(([bindingPattern, bindingElements]) => {
|
|
const kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 /* Parameter */ : 0 /* Local */;
|
|
if (bindingPattern.elements.length === bindingElements.length) {
|
|
if (bindingElements.length === 1 && bindingPattern.parent.kind === 257 /* VariableDeclaration */ && bindingPattern.parent.parent.kind === 258 /* VariableDeclarationList */) {
|
|
addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId);
|
|
} else {
|
|
addDiagnostic(bindingPattern, kind, bindingElements.length === 1 ? createDiagnosticForNode(bindingPattern, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(first(bindingElements).name)) : createDiagnosticForNode(bindingPattern, Diagnostics.All_destructured_elements_are_unused));
|
|
}
|
|
} else {
|
|
for (const e of bindingElements) {
|
|
addDiagnostic(e, kind, createDiagnosticForNode(e, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name)));
|
|
}
|
|
}
|
|
});
|
|
unusedVariables.forEach(([declarationList, declarations]) => {
|
|
if (declarationList.declarations.length === declarations.length) {
|
|
addDiagnostic(declarationList, 0 /* Local */, declarations.length === 1 ? createDiagnosticForNode(first(declarations).name, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(first(declarations).name)) : createDiagnosticForNode(declarationList.parent.kind === 240 /* VariableStatement */ ? declarationList.parent : declarationList, Diagnostics.All_variables_are_unused));
|
|
} else {
|
|
for (const decl of declarations) {
|
|
addDiagnostic(decl, 0 /* Local */, createDiagnosticForNode(decl, Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name)));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function checkPotentialUncheckedRenamedBindingElementsInTypes() {
|
|
var _a2;
|
|
for (const node of potentialUnusedRenamedBindingElementsInTypes) {
|
|
if (!((_a2 = getSymbolOfNode(node)) == null ? void 0 : _a2.isReferenced)) {
|
|
const wrappingDeclaration = walkUpBindingElementsAndPatterns(node);
|
|
Debug.assert(isParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here");
|
|
const diagnostic = createDiagnosticForNode(node.name, Diagnostics._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, declarationNameToString(node.name), declarationNameToString(node.propertyName));
|
|
if (!wrappingDeclaration.type) {
|
|
addRelatedInfo(
|
|
diagnostic,
|
|
createFileDiagnostic(getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, declarationNameToString(node.propertyName))
|
|
);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function bindingNameText(name) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return idText(name);
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
return bindingNameText(cast(first(name.elements), isBindingElement).name);
|
|
default:
|
|
return Debug.assertNever(name);
|
|
}
|
|
}
|
|
function isImportedDeclaration(node) {
|
|
return node.kind === 270 /* ImportClause */ || node.kind === 273 /* ImportSpecifier */ || node.kind === 271 /* NamespaceImport */;
|
|
}
|
|
function importClauseFromImported(decl) {
|
|
return decl.kind === 270 /* ImportClause */ ? decl : decl.kind === 271 /* NamespaceImport */ ? decl.parent : decl.parent.parent;
|
|
}
|
|
function checkBlock(node) {
|
|
if (node.kind === 238 /* Block */) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
}
|
|
if (isFunctionOrModuleBlock(node)) {
|
|
const saveFlowAnalysisDisabled = flowAnalysisDisabled;
|
|
forEach(node.statements, checkSourceElement);
|
|
flowAnalysisDisabled = saveFlowAnalysisDisabled;
|
|
} else {
|
|
forEach(node.statements, checkSourceElement);
|
|
}
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkCollisionWithArgumentsInGeneratedCode(node) {
|
|
if (languageVersion >= 2 /* ES2015 */ || !hasRestParameter(node) || node.flags & 16777216 /* Ambient */ || nodeIsMissing(node.body)) {
|
|
return;
|
|
}
|
|
forEach(node.parameters, (p) => {
|
|
if (p.name && !isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) {
|
|
errorSkippedOn("noEmit", p, Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters);
|
|
}
|
|
});
|
|
}
|
|
function needCollisionCheckForIdentifier(node, identifier, name) {
|
|
if ((identifier == null ? void 0 : identifier.escapedText) !== name) {
|
|
return false;
|
|
}
|
|
if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 168 /* PropertySignature */ || node.kind === 171 /* MethodDeclaration */ || node.kind === 170 /* MethodSignature */ || node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */ || node.kind === 299 /* PropertyAssignment */) {
|
|
return false;
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return false;
|
|
}
|
|
if (isImportClause(node) || isImportEqualsDeclaration(node) || isImportSpecifier(node)) {
|
|
if (isTypeOnlyImportOrExportDeclaration(node)) {
|
|
return false;
|
|
}
|
|
}
|
|
const root = getRootDeclaration(node);
|
|
if (isParameter(root) && nodeIsMissing(root.parent.body)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function checkIfThisIsCapturedInEnclosingScope(node) {
|
|
findAncestor(node, (current) => {
|
|
if (getNodeCheckFlags(current) & 4 /* CaptureThis */) {
|
|
const isDeclaration2 = node.kind !== 79 /* Identifier */;
|
|
if (isDeclaration2) {
|
|
error(getNameOfDeclaration(node), Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference);
|
|
} else {
|
|
error(node, Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function checkIfNewTargetIsCapturedInEnclosingScope(node) {
|
|
findAncestor(node, (current) => {
|
|
if (getNodeCheckFlags(current) & 8 /* CaptureNewTarget */) {
|
|
const isDeclaration2 = node.kind !== 79 /* Identifier */;
|
|
if (isDeclaration2) {
|
|
error(getNameOfDeclaration(node), Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference);
|
|
} else {
|
|
error(node, Diagnostics.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function checkCollisionWithRequireExportsInGeneratedCode(node, name) {
|
|
if (moduleKind >= 5 /* ES2015 */ && !(moduleKind >= 100 /* Node16 */ && getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
return;
|
|
}
|
|
if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) {
|
|
return;
|
|
}
|
|
if (isModuleDeclaration(node) && getModuleInstanceState(node) !== 1 /* Instantiated */) {
|
|
return;
|
|
}
|
|
const parent2 = getDeclarationContainer(node);
|
|
if (parent2.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(parent2)) {
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
name,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module,
|
|
declarationNameToString(name),
|
|
declarationNameToString(name)
|
|
);
|
|
}
|
|
}
|
|
function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) {
|
|
if (!name || languageVersion >= 4 /* ES2017 */ || !needCollisionCheckForIdentifier(node, name, "Promise")) {
|
|
return;
|
|
}
|
|
if (isModuleDeclaration(node) && getModuleInstanceState(node) !== 1 /* Instantiated */) {
|
|
return;
|
|
}
|
|
const parent2 = getDeclarationContainer(node);
|
|
if (parent2.kind === 308 /* SourceFile */ && isExternalOrCommonJsModule(parent2) && parent2.flags & 2048 /* HasAsyncFunctions */) {
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
name,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,
|
|
declarationNameToString(name),
|
|
declarationNameToString(name)
|
|
);
|
|
}
|
|
}
|
|
function recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name) {
|
|
if (languageVersion <= 8 /* ES2021 */ && (needCollisionCheckForIdentifier(node, name, "WeakMap") || needCollisionCheckForIdentifier(node, name, "WeakSet"))) {
|
|
potentialWeakMapSetCollisions.push(node);
|
|
}
|
|
}
|
|
function checkWeakMapSetCollision(node) {
|
|
const enclosingBlockScope = getEnclosingBlockScopeContainer(node);
|
|
if (getNodeCheckFlags(enclosingBlockScope) & 4194304 /* ContainsClassWithPrivateIdentifiers */) {
|
|
Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier");
|
|
errorSkippedOn("noEmit", node, Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText);
|
|
}
|
|
}
|
|
function recordPotentialCollisionWithReflectInGeneratedCode(node, name) {
|
|
if (name && languageVersion >= 2 /* ES2015 */ && languageVersion <= 8 /* ES2021 */ && needCollisionCheckForIdentifier(node, name, "Reflect")) {
|
|
potentialReflectCollisions.push(node);
|
|
}
|
|
}
|
|
function checkReflectCollision(node) {
|
|
let hasCollision = false;
|
|
if (isClassExpression(node)) {
|
|
for (const member of node.members) {
|
|
if (getNodeCheckFlags(member) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
break;
|
|
}
|
|
}
|
|
} else if (isFunctionExpression(node)) {
|
|
if (getNodeCheckFlags(node) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
}
|
|
} else {
|
|
const container = getEnclosingBlockScopeContainer(node);
|
|
if (container && getNodeCheckFlags(container) & 8388608 /* ContainsSuperPropertyInStaticInitializer */) {
|
|
hasCollision = true;
|
|
}
|
|
}
|
|
if (hasCollision) {
|
|
Debug.assert(isNamedDeclaration(node) && isIdentifier(node.name), "The target of a Reflect collision check should be an identifier");
|
|
errorSkippedOn(
|
|
"noEmit",
|
|
node,
|
|
Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers,
|
|
declarationNameToString(node.name),
|
|
"Reflect"
|
|
);
|
|
}
|
|
}
|
|
function checkCollisionsForDeclarationName(node, name) {
|
|
if (!name)
|
|
return;
|
|
checkCollisionWithRequireExportsInGeneratedCode(node, name);
|
|
checkCollisionWithGlobalPromiseInGeneratedCode(node, name);
|
|
recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name);
|
|
recordPotentialCollisionWithReflectInGeneratedCode(node, name);
|
|
if (isClassLike(node)) {
|
|
checkTypeNameIsReserved(name, Diagnostics.Class_name_cannot_be_0);
|
|
if (!(node.flags & 16777216 /* Ambient */)) {
|
|
checkClassNameCollisionWithObject(name);
|
|
}
|
|
} else if (isEnumDeclaration(node)) {
|
|
checkTypeNameIsReserved(name, Diagnostics.Enum_name_cannot_be_0);
|
|
}
|
|
}
|
|
function checkVarDeclaredNamesNotShadowed(node) {
|
|
if ((getCombinedNodeFlags(node) & 3 /* BlockScoped */) !== 0 || isParameterDeclaration(node)) {
|
|
return;
|
|
}
|
|
if (node.kind === 257 /* VariableDeclaration */ && !node.initializer) {
|
|
return;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 1 /* FunctionScopedVariable */) {
|
|
if (!isIdentifier(node.name))
|
|
return Debug.fail();
|
|
const localDeclarationSymbol = resolveName(node, node.name.escapedText, 3 /* Variable */, void 0, void 0, false);
|
|
if (localDeclarationSymbol && localDeclarationSymbol !== symbol && localDeclarationSymbol.flags & 2 /* BlockScopedVariable */) {
|
|
if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3 /* BlockScoped */) {
|
|
const varDeclList = getAncestor(localDeclarationSymbol.valueDeclaration, 258 /* VariableDeclarationList */);
|
|
const container = varDeclList.parent.kind === 240 /* VariableStatement */ && varDeclList.parent.parent ? varDeclList.parent.parent : void 0;
|
|
const namesShareScope = container && (container.kind === 238 /* Block */ && isFunctionLike(container.parent) || container.kind === 265 /* ModuleBlock */ || container.kind === 264 /* ModuleDeclaration */ || container.kind === 308 /* SourceFile */);
|
|
if (!namesShareScope) {
|
|
const name = symbolToString(localDeclarationSymbol);
|
|
error(node, Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function convertAutoToAny(type) {
|
|
return type === autoType ? anyType : type === autoArrayType ? anyArrayType : type;
|
|
}
|
|
function checkVariableLikeDeclaration(node) {
|
|
var _a2;
|
|
checkDecorators(node);
|
|
if (!isBindingElement(node)) {
|
|
checkSourceElement(node.type);
|
|
}
|
|
if (!node.name) {
|
|
return;
|
|
}
|
|
if (node.name.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.name);
|
|
if (hasOnlyExpressionInitializer(node) && node.initializer) {
|
|
checkExpressionCached(node.initializer);
|
|
}
|
|
}
|
|
if (isBindingElement(node)) {
|
|
if (node.propertyName && isIdentifier(node.name) && isParameterDeclaration(node) && nodeIsMissing(getContainingFunction(node).body)) {
|
|
potentialUnusedRenamedBindingElementsInTypes.push(node);
|
|
return;
|
|
}
|
|
if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
|
|
checkExternalEmitHelpers(node, 4 /* Rest */);
|
|
}
|
|
if (node.propertyName && node.propertyName.kind === 164 /* ComputedPropertyName */) {
|
|
checkComputedPropertyName(node.propertyName);
|
|
}
|
|
const parent2 = node.parent.parent;
|
|
const parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
|
|
const parentType = getTypeForBindingElementParent(parent2, parentCheckMode);
|
|
const name = node.propertyName || node.name;
|
|
if (parentType && !isBindingPattern(name)) {
|
|
const exprType = getLiteralTypeFromPropertyName(name);
|
|
if (isTypeUsableAsPropertyName(exprType)) {
|
|
const nameText = getPropertyNameFromType(exprType);
|
|
const property = getPropertyOfType(parentType, nameText);
|
|
if (property) {
|
|
markPropertyAsReferenced(property, void 0, false);
|
|
checkPropertyAccessibility(node, !!parent2.initializer && parent2.initializer.kind === 106 /* SuperKeyword */, false, parentType, property);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
if (node.name.kind === 204 /* ArrayBindingPattern */ && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
|
|
checkExternalEmitHelpers(node, 512 /* Read */);
|
|
}
|
|
forEach(node.name.elements, checkSourceElement);
|
|
}
|
|
if (isParameter(node) && node.initializer && nodeIsMissing(getContainingFunction(node).body)) {
|
|
error(node, Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation);
|
|
return;
|
|
}
|
|
if (isBindingPattern(node.name)) {
|
|
const needCheckInitializer = hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* ForInStatement */;
|
|
const needCheckWidenedType = !some(node.name.elements, not(isOmittedExpression));
|
|
if (needCheckInitializer || needCheckWidenedType) {
|
|
const widenedType = getWidenedTypeForVariableLikeDeclaration(node);
|
|
if (needCheckInitializer) {
|
|
const initializerType = checkExpressionCached(node.initializer);
|
|
if (strictNullChecks && needCheckWidenedType) {
|
|
checkNonNullNonVoidType(initializerType, node);
|
|
} else {
|
|
checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer);
|
|
}
|
|
}
|
|
if (needCheckWidenedType) {
|
|
if (isArrayBindingPattern(node.name)) {
|
|
checkIteratedTypeOrElementType(65 /* Destructuring */, widenedType, undefinedType, node);
|
|
} else if (strictNullChecks) {
|
|
checkNonNullNonVoidType(widenedType, node);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 2097152 /* Alias */ && isVariableDeclarationInitializedToBareOrAccessedRequire(node.kind === 205 /* BindingElement */ ? node.parent.parent : node)) {
|
|
checkAliasSymbol(node);
|
|
return;
|
|
}
|
|
const type = convertAutoToAny(getTypeOfSymbol(symbol));
|
|
if (node === symbol.valueDeclaration) {
|
|
const initializer = hasOnlyExpressionInitializer(node) && getEffectiveInitializer(node);
|
|
if (initializer) {
|
|
const isJSObjectLiteralInitializer = isInJSFile(node) && isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAccess(node.name)) && !!((_a2 = symbol.exports) == null ? void 0 : _a2.size);
|
|
if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 246 /* ForInStatement */) {
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, void 0);
|
|
}
|
|
}
|
|
if (symbol.declarations && symbol.declarations.length > 1) {
|
|
if (some(symbol.declarations, (d) => d !== node && isVariableLike(d) && !areDeclarationFlagsIdentical(d, node))) {
|
|
error(node.name, Diagnostics.All_declarations_of_0_must_have_identical_modifiers, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
} else {
|
|
const declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node));
|
|
if (!isErrorType(type) && !isErrorType(declarationType) && !isTypeIdenticalTo(type, declarationType) && !(symbol.flags & 67108864 /* Assignment */)) {
|
|
errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType);
|
|
}
|
|
if (hasOnlyExpressionInitializer(node) && node.initializer) {
|
|
checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, void 0);
|
|
}
|
|
if (symbol.valueDeclaration && !areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) {
|
|
error(node.name, Diagnostics.All_declarations_of_0_must_have_identical_modifiers, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
if (node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 168 /* PropertySignature */) {
|
|
checkExportsOnMergedDeclarations(node);
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
checkVarDeclaredNamesNotShadowed(node);
|
|
}
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
}
|
|
function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) {
|
|
const nextDeclarationName = getNameOfDeclaration(nextDeclaration);
|
|
const message = nextDeclaration.kind === 169 /* PropertyDeclaration */ || nextDeclaration.kind === 168 /* PropertySignature */ ? Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 : Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2;
|
|
const declName = declarationNameToString(nextDeclarationName);
|
|
const err = error(
|
|
nextDeclarationName,
|
|
message,
|
|
declName,
|
|
typeToString(firstType),
|
|
typeToString(nextType)
|
|
);
|
|
if (firstDeclaration) {
|
|
addRelatedInfo(
|
|
err,
|
|
createDiagnosticForNode(firstDeclaration, Diagnostics._0_was_also_declared_here, declName)
|
|
);
|
|
}
|
|
}
|
|
function areDeclarationFlagsIdentical(left, right) {
|
|
if (left.kind === 166 /* Parameter */ && right.kind === 257 /* VariableDeclaration */ || left.kind === 257 /* VariableDeclaration */ && right.kind === 166 /* Parameter */) {
|
|
return true;
|
|
}
|
|
if (hasQuestionToken(left) !== hasQuestionToken(right)) {
|
|
return false;
|
|
}
|
|
const interestingFlags = 8 /* Private */ | 16 /* Protected */ | 512 /* Async */ | 256 /* Abstract */ | 64 /* Readonly */ | 32 /* Static */;
|
|
return getSelectedEffectiveModifierFlags(left, interestingFlags) === getSelectedEffectiveModifierFlags(right, interestingFlags);
|
|
}
|
|
function checkVariableDeclaration(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
checkGrammarVariableDeclaration(node);
|
|
checkVariableLikeDeclaration(node);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function checkBindingElement(node) {
|
|
checkGrammarBindingElement(node);
|
|
return checkVariableLikeDeclaration(node);
|
|
}
|
|
function checkVariableStatement(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList))
|
|
checkGrammarForDisallowedLetOrConstStatement(node);
|
|
forEach(node.declarationList.declarations, checkSourceElement);
|
|
}
|
|
function checkExpressionStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkExpression(node.expression);
|
|
}
|
|
function checkIfStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
const type = checkTruthinessExpression(node.expression);
|
|
checkTestingKnownTruthyCallableOrAwaitableType(node.expression, type, node.thenStatement);
|
|
checkSourceElement(node.thenStatement);
|
|
if (node.thenStatement.kind === 239 /* EmptyStatement */) {
|
|
error(node.thenStatement, Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
|
|
}
|
|
checkSourceElement(node.elseStatement);
|
|
}
|
|
function checkTestingKnownTruthyCallableOrAwaitableType(condExpr, condType, body) {
|
|
if (!strictNullChecks)
|
|
return;
|
|
helper(condExpr, body);
|
|
while (isBinaryExpression(condExpr) && condExpr.operatorToken.kind === 56 /* BarBarToken */) {
|
|
condExpr = condExpr.left;
|
|
helper(condExpr, body);
|
|
}
|
|
function helper(condExpr2, body2) {
|
|
const location2 = isBinaryExpression(condExpr2) && (condExpr2.operatorToken.kind === 56 /* BarBarToken */ || condExpr2.operatorToken.kind === 55 /* AmpersandAmpersandToken */) ? condExpr2.right : condExpr2;
|
|
if (isModuleExportsAccessExpression(location2))
|
|
return;
|
|
const type = location2 === condExpr2 ? condType : checkTruthinessExpression(location2);
|
|
const isPropertyExpressionCast = isPropertyAccessExpression(location2) && isTypeAssertion3(location2.expression);
|
|
if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
|
|
return;
|
|
const callSignatures = getSignaturesOfType(type, 0 /* Call */);
|
|
const isPromise = !!getAwaitedTypeOfPromise(type);
|
|
if (callSignatures.length === 0 && !isPromise) {
|
|
return;
|
|
}
|
|
const testedNode = isIdentifier(location2) ? location2 : isPropertyAccessExpression(location2) ? location2.name : isBinaryExpression(location2) && isIdentifier(location2.right) ? location2.right : void 0;
|
|
const testedSymbol = testedNode && getSymbolAtLocation(testedNode);
|
|
if (!testedSymbol && !isPromise) {
|
|
return;
|
|
}
|
|
const isUsed = testedSymbol && isBinaryExpression(condExpr2.parent) && isSymbolUsedInBinaryExpressionChain(condExpr2.parent, testedSymbol) || testedSymbol && body2 && isSymbolUsedInConditionBody(condExpr2, body2, testedNode, testedSymbol);
|
|
if (!isUsed) {
|
|
if (isPromise) {
|
|
errorAndMaybeSuggestAwait(
|
|
location2,
|
|
true,
|
|
Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined,
|
|
getTypeNameForErrorDisplay(type)
|
|
);
|
|
} else {
|
|
error(location2, Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isSymbolUsedInConditionBody(expr, body, testedNode, testedSymbol) {
|
|
return !!forEachChild(body, function check(childNode) {
|
|
if (isIdentifier(childNode)) {
|
|
const childSymbol = getSymbolAtLocation(childNode);
|
|
if (childSymbol && childSymbol === testedSymbol) {
|
|
if (isIdentifier(expr) || isIdentifier(testedNode) && isBinaryExpression(testedNode.parent)) {
|
|
return true;
|
|
}
|
|
let testedExpression = testedNode.parent;
|
|
let childExpression = childNode.parent;
|
|
while (testedExpression && childExpression) {
|
|
if (isIdentifier(testedExpression) && isIdentifier(childExpression) || testedExpression.kind === 108 /* ThisKeyword */ && childExpression.kind === 108 /* ThisKeyword */) {
|
|
return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression);
|
|
} else if (isPropertyAccessExpression(testedExpression) && isPropertyAccessExpression(childExpression)) {
|
|
if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) {
|
|
return false;
|
|
}
|
|
childExpression = childExpression.expression;
|
|
testedExpression = testedExpression.expression;
|
|
} else if (isCallExpression(testedExpression) && isCallExpression(childExpression)) {
|
|
childExpression = childExpression.expression;
|
|
testedExpression = testedExpression.expression;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return forEachChild(childNode, check);
|
|
});
|
|
}
|
|
function isSymbolUsedInBinaryExpressionChain(node, testedSymbol) {
|
|
while (isBinaryExpression(node) && node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
const isUsed = forEachChild(node.right, function visit(child) {
|
|
if (isIdentifier(child)) {
|
|
const symbol = getSymbolAtLocation(child);
|
|
if (symbol && symbol === testedSymbol) {
|
|
return true;
|
|
}
|
|
}
|
|
return forEachChild(child, visit);
|
|
});
|
|
if (isUsed) {
|
|
return true;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function checkDoStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkSourceElement(node.statement);
|
|
checkTruthinessExpression(node.expression);
|
|
}
|
|
function checkWhileStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkTruthinessExpression(node.expression);
|
|
checkSourceElement(node.statement);
|
|
}
|
|
function checkTruthinessOfType(type, node) {
|
|
if (type.flags & 16384 /* Void */) {
|
|
error(node, Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness);
|
|
}
|
|
return type;
|
|
}
|
|
function checkTruthinessExpression(node, checkMode) {
|
|
return checkTruthinessOfType(checkExpression(node, checkMode), node);
|
|
}
|
|
function checkForStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (node.initializer && node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
checkGrammarVariableDeclarationList(node.initializer);
|
|
}
|
|
}
|
|
if (node.initializer) {
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
forEach(node.initializer.declarations, checkVariableDeclaration);
|
|
} else {
|
|
checkExpression(node.initializer);
|
|
}
|
|
}
|
|
if (node.condition)
|
|
checkTruthinessExpression(node.condition);
|
|
if (node.incrementor)
|
|
checkExpression(node.incrementor);
|
|
checkSourceElement(node.statement);
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkForOfStatement(node) {
|
|
checkGrammarForInOrForOfStatement(node);
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (node.awaitModifier) {
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
grammarErrorOnNode(node.awaitModifier, Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block);
|
|
} else {
|
|
const functionFlags = getFunctionFlags(container);
|
|
if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 99 /* ESNext */) {
|
|
checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */);
|
|
}
|
|
}
|
|
} else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(node, 256 /* ForOfIncludes */);
|
|
}
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
checkForInOrForOfVariableDeclaration(node);
|
|
} else {
|
|
const varExpr = node.initializer;
|
|
const iteratedType = checkRightHandSideOfForOf(node);
|
|
if (varExpr.kind === 206 /* ArrayLiteralExpression */ || varExpr.kind === 207 /* ObjectLiteralExpression */) {
|
|
checkDestructuringAssignment(varExpr, iteratedType || errorType);
|
|
} else {
|
|
const leftType = checkExpression(varExpr);
|
|
checkReferenceExpression(
|
|
varExpr,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access
|
|
);
|
|
if (iteratedType) {
|
|
checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression);
|
|
}
|
|
}
|
|
}
|
|
checkSourceElement(node.statement);
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkForInStatement(node) {
|
|
checkGrammarForInOrForOfStatement(node);
|
|
const rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression));
|
|
if (node.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variable = node.initializer.declarations[0];
|
|
if (variable && isBindingPattern(variable.name)) {
|
|
error(variable.name, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
|
|
}
|
|
checkForInOrForOfVariableDeclaration(node);
|
|
} else {
|
|
const varExpr = node.initializer;
|
|
const leftType = checkExpression(varExpr);
|
|
if (varExpr.kind === 206 /* ArrayLiteralExpression */ || varExpr.kind === 207 /* ObjectLiteralExpression */) {
|
|
error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
|
|
} else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) {
|
|
error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
|
|
} else {
|
|
checkReferenceExpression(
|
|
varExpr,
|
|
Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access,
|
|
Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access
|
|
);
|
|
}
|
|
}
|
|
if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 /* NonPrimitive */ | 58982400 /* InstantiableNonPrimitive */)) {
|
|
error(node.expression, Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType));
|
|
}
|
|
checkSourceElement(node.statement);
|
|
if (node.locals) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function checkForInOrForOfVariableDeclaration(iterationStatement) {
|
|
const variableDeclarationList = iterationStatement.initializer;
|
|
if (variableDeclarationList.declarations.length >= 1) {
|
|
const decl = variableDeclarationList.declarations[0];
|
|
checkVariableDeclaration(decl);
|
|
}
|
|
}
|
|
function checkRightHandSideOfForOf(statement) {
|
|
const use = statement.awaitModifier ? 15 /* ForAwaitOf */ : 13 /* ForOf */;
|
|
return checkIteratedTypeOrElementType(use, checkNonNullExpression(statement.expression), undefinedType, statement.expression);
|
|
}
|
|
function checkIteratedTypeOrElementType(use, inputType, sentType, errorNode) {
|
|
if (isTypeAny(inputType)) {
|
|
return inputType;
|
|
}
|
|
return getIteratedTypeOrElementType(use, inputType, sentType, errorNode, true) || anyType;
|
|
}
|
|
function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) {
|
|
const allowAsyncIterables = (use & 2 /* AllowsAsyncIterablesFlag */) !== 0;
|
|
if (inputType === neverType) {
|
|
reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables);
|
|
return void 0;
|
|
}
|
|
const uplevelIteration = languageVersion >= 2 /* ES2015 */;
|
|
const downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration;
|
|
const possibleOutOfBounds = compilerOptions.noUncheckedIndexedAccess && !!(use & 128 /* PossiblyOutOfBounds */);
|
|
if (uplevelIteration || downlevelIteration || allowAsyncIterables) {
|
|
const iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : void 0);
|
|
if (checkAssignability) {
|
|
if (iterationTypes) {
|
|
const diagnostic = use & 8 /* ForOfFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 : use & 32 /* SpreadFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 : use & 64 /* DestructuringFlag */ ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 : use & 16 /* YieldStarFlag */ ? Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 : void 0;
|
|
if (diagnostic) {
|
|
checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic);
|
|
}
|
|
}
|
|
}
|
|
if (iterationTypes || uplevelIteration) {
|
|
return possibleOutOfBounds ? includeUndefinedInIndexSignature(iterationTypes && iterationTypes.yieldType) : iterationTypes && iterationTypes.yieldType;
|
|
}
|
|
}
|
|
let arrayType = inputType;
|
|
let reportedError = false;
|
|
let hasStringConstituent = false;
|
|
if (use & 4 /* AllowsStringInputFlag */) {
|
|
if (arrayType.flags & 1048576 /* Union */) {
|
|
const arrayTypes = inputType.types;
|
|
const filteredTypes = filter(arrayTypes, (t) => !(t.flags & 402653316 /* StringLike */));
|
|
if (filteredTypes !== arrayTypes) {
|
|
arrayType = getUnionType(filteredTypes, 2 /* Subtype */);
|
|
}
|
|
} else if (arrayType.flags & 402653316 /* StringLike */) {
|
|
arrayType = neverType;
|
|
}
|
|
hasStringConstituent = arrayType !== inputType;
|
|
if (hasStringConstituent) {
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher);
|
|
reportedError = true;
|
|
}
|
|
}
|
|
if (arrayType.flags & 131072 /* Never */) {
|
|
return possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType;
|
|
}
|
|
}
|
|
}
|
|
if (!isArrayLikeType(arrayType)) {
|
|
if (errorNode && !reportedError) {
|
|
const allowsStrings = !!(use & 4 /* AllowsStringInputFlag */) && !hasStringConstituent;
|
|
const [defaultDiagnostic, maybeMissingAwait] = getIterationDiagnosticDetails(allowsStrings, downlevelIteration);
|
|
errorAndMaybeSuggestAwait(
|
|
errorNode,
|
|
maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType),
|
|
defaultDiagnostic,
|
|
typeToString(arrayType)
|
|
);
|
|
}
|
|
return hasStringConstituent ? possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType : void 0;
|
|
}
|
|
const arrayElementType = getIndexTypeOfType(arrayType, numberType);
|
|
if (hasStringConstituent && arrayElementType) {
|
|
if (arrayElementType.flags & 402653316 /* StringLike */ && !compilerOptions.noUncheckedIndexedAccess) {
|
|
return stringType;
|
|
}
|
|
return getUnionType(possibleOutOfBounds ? [arrayElementType, stringType, undefinedType] : [arrayElementType, stringType], 2 /* Subtype */);
|
|
}
|
|
return use & 128 /* PossiblyOutOfBounds */ ? includeUndefinedInIndexSignature(arrayElementType) : arrayElementType;
|
|
function getIterationDiagnosticDetails(allowsStrings, downlevelIteration2) {
|
|
var _a2;
|
|
if (downlevelIteration2) {
|
|
return allowsStrings ? [Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true] : [Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true];
|
|
}
|
|
const yieldType = getIterationTypeOfIterable(use, 0 /* Yield */, inputType, void 0);
|
|
if (yieldType) {
|
|
return [Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false];
|
|
}
|
|
if (isES2015OrLaterIterable((_a2 = inputType.symbol) == null ? void 0 : _a2.escapedName)) {
|
|
return [Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true];
|
|
}
|
|
return allowsStrings ? [Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true] : [Diagnostics.Type_0_is_not_an_array_type, true];
|
|
}
|
|
}
|
|
function isES2015OrLaterIterable(n) {
|
|
switch (n) {
|
|
case "Float32Array":
|
|
case "Float64Array":
|
|
case "Int16Array":
|
|
case "Int32Array":
|
|
case "Int8Array":
|
|
case "NodeList":
|
|
case "Uint16Array":
|
|
case "Uint32Array":
|
|
case "Uint8Array":
|
|
case "Uint8ClampedArray":
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) {
|
|
if (isTypeAny(inputType)) {
|
|
return void 0;
|
|
}
|
|
const iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode);
|
|
return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
|
|
}
|
|
function createIterationTypes(yieldType = neverType, returnType = neverType, nextType = unknownType) {
|
|
if (yieldType.flags & 67359327 /* Intrinsic */ && returnType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */) && nextType.flags & (1 /* Any */ | 131072 /* Never */ | 2 /* Unknown */ | 16384 /* Void */ | 32768 /* Undefined */)) {
|
|
const id = getTypeListId([yieldType, returnType, nextType]);
|
|
let iterationTypes = iterationTypesCache.get(id);
|
|
if (!iterationTypes) {
|
|
iterationTypes = { yieldType, returnType, nextType };
|
|
iterationTypesCache.set(id, iterationTypes);
|
|
}
|
|
return iterationTypes;
|
|
}
|
|
return { yieldType, returnType, nextType };
|
|
}
|
|
function combineIterationTypes(array) {
|
|
let yieldTypes;
|
|
let returnTypes;
|
|
let nextTypes;
|
|
for (const iterationTypes of array) {
|
|
if (iterationTypes === void 0 || iterationTypes === noIterationTypes) {
|
|
continue;
|
|
}
|
|
if (iterationTypes === anyIterationTypes) {
|
|
return anyIterationTypes;
|
|
}
|
|
yieldTypes = append(yieldTypes, iterationTypes.yieldType);
|
|
returnTypes = append(returnTypes, iterationTypes.returnType);
|
|
nextTypes = append(nextTypes, iterationTypes.nextType);
|
|
}
|
|
if (yieldTypes || returnTypes || nextTypes) {
|
|
return createIterationTypes(
|
|
yieldTypes && getUnionType(yieldTypes),
|
|
returnTypes && getUnionType(returnTypes),
|
|
nextTypes && getIntersectionType(nextTypes)
|
|
);
|
|
}
|
|
return noIterationTypes;
|
|
}
|
|
function getCachedIterationTypes(type, cacheKey) {
|
|
return type[cacheKey];
|
|
}
|
|
function setCachedIterationTypes(type, cacheKey, cachedTypes2) {
|
|
return type[cacheKey] = cachedTypes2;
|
|
}
|
|
function getIterationTypesOfIterable(type, use, errorNode) {
|
|
var _a2, _b;
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
if (!(type.flags & 1048576 /* Union */)) {
|
|
const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
|
|
const iterationTypes2 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer);
|
|
if (iterationTypes2 === noIterationTypes) {
|
|
if (errorNode) {
|
|
const rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
|
|
if (errorOutputContainer == null ? void 0 : errorOutputContainer.errors) {
|
|
addRelatedInfo(rootDiag, ...errorOutputContainer.errors);
|
|
}
|
|
}
|
|
return void 0;
|
|
} else if ((_a2 = errorOutputContainer == null ? void 0 : errorOutputContainer.errors) == null ? void 0 : _a2.length) {
|
|
for (const diag2 of errorOutputContainer.errors) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
return iterationTypes2;
|
|
}
|
|
const cacheKey = use & 2 /* AllowsAsyncIterablesFlag */ ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
|
|
const cachedTypes2 = getCachedIterationTypes(type, cacheKey);
|
|
if (cachedTypes2)
|
|
return cachedTypes2 === noIterationTypes ? void 0 : cachedTypes2;
|
|
let allIterationTypes;
|
|
for (const constituent of type.types) {
|
|
const errorOutputContainer = errorNode ? { errors: void 0 } : void 0;
|
|
const iterationTypes2 = getIterationTypesOfIterableWorker(constituent, use, errorNode, errorOutputContainer);
|
|
if (iterationTypes2 === noIterationTypes) {
|
|
if (errorNode) {
|
|
const rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* AllowsAsyncIterablesFlag */));
|
|
if (errorOutputContainer == null ? void 0 : errorOutputContainer.errors) {
|
|
addRelatedInfo(rootDiag, ...errorOutputContainer.errors);
|
|
}
|
|
}
|
|
setCachedIterationTypes(type, cacheKey, noIterationTypes);
|
|
return void 0;
|
|
} else if ((_b = errorOutputContainer == null ? void 0 : errorOutputContainer.errors) == null ? void 0 : _b.length) {
|
|
for (const diag2 of errorOutputContainer.errors) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
}
|
|
allIterationTypes = append(allIterationTypes, iterationTypes2);
|
|
}
|
|
const iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
|
|
setCachedIterationTypes(type, cacheKey, iterationTypes);
|
|
return iterationTypes === noIterationTypes ? void 0 : iterationTypes;
|
|
}
|
|
function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) {
|
|
if (iterationTypes === noIterationTypes)
|
|
return noIterationTypes;
|
|
if (iterationTypes === anyIterationTypes)
|
|
return anyIterationTypes;
|
|
const { yieldType, returnType, nextType } = iterationTypes;
|
|
if (errorNode) {
|
|
getGlobalAwaitedSymbol(true);
|
|
}
|
|
return createIterationTypes(
|
|
getAwaitedType(yieldType, errorNode) || anyType,
|
|
getAwaitedType(returnType, errorNode) || anyType,
|
|
nextType
|
|
);
|
|
}
|
|
function getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
let noCache = false;
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
const iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
|
|
if (iterationTypes) {
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
noCache = true;
|
|
} else {
|
|
return use & 8 /* ForOfFlag */ ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode) : iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
if (use & 1 /* AllowsSyncIterablesFlag */) {
|
|
let iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) || getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
|
|
if (iterationTypes) {
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
noCache = true;
|
|
} else {
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
if (iterationTypes !== noIterationTypes) {
|
|
iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
|
|
}
|
|
} else {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
const iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
|
|
if (iterationTypes !== noIterationTypes) {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
if (use & 1 /* AllowsSyncIterablesFlag */) {
|
|
let iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
|
|
if (iterationTypes !== noIterationTypes) {
|
|
if (use & 2 /* AllowsAsyncIterablesFlag */) {
|
|
iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes);
|
|
} else {
|
|
return iterationTypes;
|
|
}
|
|
}
|
|
}
|
|
return noIterationTypes;
|
|
}
|
|
function getIterationTypesOfIterableCached(type, resolver) {
|
|
return getCachedIterationTypes(type, resolver.iterableCacheKey);
|
|
}
|
|
function getIterationTypesOfGlobalIterableType(globalType, resolver) {
|
|
const globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || getIterationTypesOfIterableSlow(globalType, resolver, void 0, void 0, false);
|
|
return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
|
|
}
|
|
function getIterationTypesOfIterableFast(type, resolver) {
|
|
let globalType;
|
|
if (isReferenceToType2(type, globalType = resolver.getGlobalIterableType(false)) || isReferenceToType2(type, globalType = resolver.getGlobalIterableIteratorType(false))) {
|
|
const [yieldType] = getTypeArguments(type);
|
|
const { returnType, nextType } = getIterationTypesOfGlobalIterableType(globalType, resolver);
|
|
return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, void 0) || yieldType, resolver.resolveIterationType(returnType, void 0) || returnType, nextType));
|
|
}
|
|
if (isReferenceToType2(type, resolver.getGlobalGeneratorType(false))) {
|
|
const [yieldType, returnType, nextType] = getTypeArguments(type);
|
|
return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, void 0) || yieldType, resolver.resolveIterationType(returnType, void 0) || returnType, nextType));
|
|
}
|
|
}
|
|
function getPropertyNameForKnownSymbolName(symbolName2) {
|
|
const ctorType = getGlobalESSymbolConstructorSymbol(false);
|
|
const uniqueType = ctorType && getTypeOfPropertyOfType(getTypeOfSymbol(ctorType), escapeLeadingUnderscores(symbolName2));
|
|
return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : `__@${symbolName2}`;
|
|
}
|
|
function getIterationTypesOfIterableSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
var _a2;
|
|
const method = getPropertyOfType(type, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
|
|
const methodType = method && !(method.flags & 16777216 /* Optional */) ? getTypeOfSymbol(method) : void 0;
|
|
if (isTypeAny(methodType)) {
|
|
return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes);
|
|
}
|
|
const signatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : void 0;
|
|
if (!some(signatures)) {
|
|
return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes);
|
|
}
|
|
const iteratorType = getIntersectionType(map(signatures, getReturnTypeOfSignature));
|
|
const iterationTypes = (_a2 = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache)) != null ? _a2 : noIterationTypes;
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes);
|
|
}
|
|
function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) {
|
|
const message = allowAsyncIterables ? Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator : Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator;
|
|
const suggestAwait = !!getAwaitedTypeOfPromise(type) || !allowAsyncIterables && isForOfStatement(errorNode.parent) && errorNode.parent.expression === errorNode && getGlobalAsyncIterableType(false) !== emptyGenericType && isTypeAssignableTo(
|
|
type,
|
|
getGlobalAsyncIterableType(false)
|
|
);
|
|
return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type));
|
|
}
|
|
function getIterationTypesOfIterator(type, resolver, errorNode, errorOutputContainer) {
|
|
return getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, false);
|
|
}
|
|
function getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
let iterationTypes = getIterationTypesOfIteratorCached(type, resolver) || getIterationTypesOfIteratorFast(type, resolver);
|
|
if (iterationTypes === noIterationTypes && errorNode) {
|
|
iterationTypes = void 0;
|
|
noCache = true;
|
|
}
|
|
iterationTypes != null ? iterationTypes : iterationTypes = getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache);
|
|
return iterationTypes === noIterationTypes ? void 0 : iterationTypes;
|
|
}
|
|
function getIterationTypesOfIteratorCached(type, resolver) {
|
|
return getCachedIterationTypes(type, resolver.iteratorCacheKey);
|
|
}
|
|
function getIterationTypesOfIteratorFast(type, resolver) {
|
|
const globalType = resolver.getGlobalIterableIteratorType(false);
|
|
if (isReferenceToType2(type, globalType)) {
|
|
const [yieldType] = getTypeArguments(type);
|
|
const globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || getIterationTypesOfIteratorSlow(globalType, resolver, void 0, void 0, false);
|
|
const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
|
|
return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
|
|
}
|
|
if (isReferenceToType2(type, resolver.getGlobalIteratorType(false)) || isReferenceToType2(type, resolver.getGlobalGeneratorType(false))) {
|
|
const [yieldType, returnType, nextType] = getTypeArguments(type);
|
|
return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
|
|
}
|
|
}
|
|
function isIteratorResult(type, kind) {
|
|
const doneType = getTypeOfPropertyOfType(type, "done") || falseType;
|
|
return isTypeAssignableTo(kind === 0 /* Yield */ ? falseType : trueType, doneType);
|
|
}
|
|
function isYieldIteratorResult(type) {
|
|
return isIteratorResult(type, 0 /* Yield */);
|
|
}
|
|
function isReturnIteratorResult(type) {
|
|
return isIteratorResult(type, 1 /* Return */);
|
|
}
|
|
function getIterationTypesOfIteratorResult(type) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
const cachedTypes2 = getCachedIterationTypes(type, "iterationTypesOfIteratorResult");
|
|
if (cachedTypes2) {
|
|
return cachedTypes2;
|
|
}
|
|
if (isReferenceToType2(type, getGlobalIteratorYieldResultType(false))) {
|
|
const yieldType2 = getTypeArguments(type)[0];
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType2, void 0, void 0));
|
|
}
|
|
if (isReferenceToType2(type, getGlobalIteratorReturnResultType(false))) {
|
|
const returnType2 = getTypeArguments(type)[0];
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(void 0, returnType2, void 0));
|
|
}
|
|
const yieldIteratorResult = filterType(type, isYieldIteratorResult);
|
|
const yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : void 0;
|
|
const returnIteratorResult = filterType(type, isReturnIteratorResult);
|
|
const returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : void 0;
|
|
if (!yieldType && !returnType) {
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes);
|
|
}
|
|
return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, void 0));
|
|
}
|
|
function getIterationTypesOfMethod(type, resolver, methodName, errorNode, errorOutputContainer) {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
const method = getPropertyOfType(type, methodName);
|
|
if (!method && methodName !== "next") {
|
|
return void 0;
|
|
}
|
|
const methodType = method && !(methodName === "next" && method.flags & 16777216 /* Optional */) ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152 /* NEUndefinedOrNull */) : void 0;
|
|
if (isTypeAny(methodType)) {
|
|
return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
|
|
}
|
|
const methodSignatures = methodType ? getSignaturesOfType(methodType, 0 /* Call */) : emptyArray;
|
|
if (methodSignatures.length === 0) {
|
|
if (errorNode) {
|
|
const diagnostic = methodName === "next" ? resolver.mustHaveANextMethodDiagnostic : resolver.mustBeAMethodDiagnostic;
|
|
if (errorOutputContainer) {
|
|
(_a2 = errorOutputContainer.errors) != null ? _a2 : errorOutputContainer.errors = [];
|
|
errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, diagnostic, methodName));
|
|
} else {
|
|
error(errorNode, diagnostic, methodName);
|
|
}
|
|
}
|
|
return methodName === "next" ? noIterationTypes : void 0;
|
|
}
|
|
if ((methodType == null ? void 0 : methodType.symbol) && methodSignatures.length === 1) {
|
|
const globalGeneratorType = resolver.getGlobalGeneratorType(false);
|
|
const globalIteratorType = resolver.getGlobalIteratorType(false);
|
|
const isGeneratorMethod = ((_c = (_b = globalGeneratorType.symbol) == null ? void 0 : _b.members) == null ? void 0 : _c.get(methodName)) === methodType.symbol;
|
|
const isIteratorMethod = !isGeneratorMethod && ((_e = (_d = globalIteratorType.symbol) == null ? void 0 : _d.members) == null ? void 0 : _e.get(methodName)) === methodType.symbol;
|
|
if (isGeneratorMethod || isIteratorMethod) {
|
|
const globalType = isGeneratorMethod ? globalGeneratorType : globalIteratorType;
|
|
const { mapper } = methodType;
|
|
return createIterationTypes(
|
|
getMappedType(globalType.typeParameters[0], mapper),
|
|
getMappedType(globalType.typeParameters[1], mapper),
|
|
methodName === "next" ? getMappedType(globalType.typeParameters[2], mapper) : void 0
|
|
);
|
|
}
|
|
}
|
|
let methodParameterTypes;
|
|
let methodReturnTypes;
|
|
for (const signature of methodSignatures) {
|
|
if (methodName !== "throw" && some(signature.parameters)) {
|
|
methodParameterTypes = append(methodParameterTypes, getTypeAtPosition(signature, 0));
|
|
}
|
|
methodReturnTypes = append(methodReturnTypes, getReturnTypeOfSignature(signature));
|
|
}
|
|
let returnTypes;
|
|
let nextType;
|
|
if (methodName !== "throw") {
|
|
const methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType;
|
|
if (methodName === "next") {
|
|
nextType = methodParameterType;
|
|
} else if (methodName === "return") {
|
|
const resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
|
|
returnTypes = append(returnTypes, resolvedMethodParameterType);
|
|
}
|
|
}
|
|
let yieldType;
|
|
const methodReturnType = methodReturnTypes ? getIntersectionType(methodReturnTypes) : neverType;
|
|
const resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
|
|
const iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
|
|
if (iterationTypes === noIterationTypes) {
|
|
if (errorNode) {
|
|
if (errorOutputContainer) {
|
|
(_f = errorOutputContainer.errors) != null ? _f : errorOutputContainer.errors = [];
|
|
errorOutputContainer.errors.push(createDiagnosticForNode(errorNode, resolver.mustHaveAValueDiagnostic, methodName));
|
|
} else {
|
|
error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
|
|
}
|
|
}
|
|
yieldType = anyType;
|
|
returnTypes = append(returnTypes, anyType);
|
|
} else {
|
|
yieldType = iterationTypes.yieldType;
|
|
returnTypes = append(returnTypes, iterationTypes.returnType);
|
|
}
|
|
return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
|
|
}
|
|
function getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache) {
|
|
const iterationTypes = combineIterationTypes([
|
|
getIterationTypesOfMethod(type, resolver, "next", errorNode, errorOutputContainer),
|
|
getIterationTypesOfMethod(type, resolver, "return", errorNode, errorOutputContainer),
|
|
getIterationTypesOfMethod(type, resolver, "throw", errorNode, errorOutputContainer)
|
|
]);
|
|
return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes);
|
|
}
|
|
function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) {
|
|
if (isTypeAny(returnType)) {
|
|
return void 0;
|
|
}
|
|
const iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator);
|
|
return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)];
|
|
}
|
|
function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) {
|
|
if (isTypeAny(type)) {
|
|
return anyIterationTypes;
|
|
}
|
|
const use = isAsyncGenerator ? 2 /* AsyncGeneratorReturnType */ : 1 /* GeneratorReturnType */;
|
|
const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
|
|
return getIterationTypesOfIterable(type, use, void 0) || getIterationTypesOfIterator(type, resolver, void 0, void 0);
|
|
}
|
|
function checkBreakOrContinueStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node))
|
|
checkGrammarBreakOrContinueStatement(node);
|
|
}
|
|
function unwrapReturnType(returnType, functionFlags) {
|
|
const isGenerator = !!(functionFlags & 1 /* Generator */);
|
|
const isAsync = !!(functionFlags & 2 /* Async */);
|
|
if (isGenerator) {
|
|
const returnIterationType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, isAsync);
|
|
if (!returnIterationType) {
|
|
return errorType;
|
|
}
|
|
return isAsync ? getAwaitedTypeNoAlias(unwrapAwaitedType(returnIterationType)) : returnIterationType;
|
|
}
|
|
return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType;
|
|
}
|
|
function isUnwrappedReturnTypeVoidOrAny(func, returnType) {
|
|
const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(func));
|
|
return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 /* Void */ | 3 /* AnyOrUnknown */);
|
|
}
|
|
function checkReturnStatement(node) {
|
|
var _a2;
|
|
if (checkGrammarStatementInAmbientContext(node)) {
|
|
return;
|
|
}
|
|
const container = getContainingFunctionOrClassStaticBlock(node);
|
|
if (container && isClassStaticBlockDeclaration(container)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block);
|
|
return;
|
|
}
|
|
if (!container) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
|
|
return;
|
|
}
|
|
const signature = getSignatureFromDeclaration(container);
|
|
const returnType = getReturnTypeOfSignature(signature);
|
|
const functionFlags = getFunctionFlags(container);
|
|
if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
|
|
const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
|
|
if (container.kind === 175 /* SetAccessor */) {
|
|
if (node.expression) {
|
|
error(node, Diagnostics.Setters_cannot_return_a_value);
|
|
}
|
|
} else if (container.kind === 173 /* Constructor */) {
|
|
if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
|
|
error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
|
|
}
|
|
} else if (getReturnTypeFromAnnotation(container)) {
|
|
const unwrappedReturnType = (_a2 = unwrapReturnType(returnType, functionFlags)) != null ? _a2 : returnType;
|
|
const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(exprType, false, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member) : exprType;
|
|
if (unwrappedReturnType) {
|
|
checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
|
|
}
|
|
}
|
|
} else if (container.kind !== 173 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) {
|
|
error(node, Diagnostics.Not_all_code_paths_return_a_value);
|
|
}
|
|
}
|
|
function checkWithStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (node.flags & 32768 /* AwaitContext */) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_an_async_function_block);
|
|
}
|
|
}
|
|
checkExpression(node.expression);
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const start2 = getSpanOfTokenAtPosition(sourceFile, node.pos).start;
|
|
const end = node.statement.pos;
|
|
grammarErrorAtPos(sourceFile, start2, end - start2, Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any);
|
|
}
|
|
}
|
|
function checkSwitchStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
let firstDefaultClause;
|
|
let hasDuplicateDefaultClause = false;
|
|
const expressionType = checkExpression(node.expression);
|
|
const expressionIsLiteral = isLiteralType(expressionType);
|
|
forEach(node.caseBlock.clauses, (clause) => {
|
|
if (clause.kind === 293 /* DefaultClause */ && !hasDuplicateDefaultClause) {
|
|
if (firstDefaultClause === void 0) {
|
|
firstDefaultClause = clause;
|
|
} else {
|
|
grammarErrorOnNode(clause, Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement);
|
|
hasDuplicateDefaultClause = true;
|
|
}
|
|
}
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
addLazyDiagnostic(createLazyCaseClauseDiagnostics(clause));
|
|
}
|
|
forEach(clause.statements, checkSourceElement);
|
|
if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) {
|
|
error(clause, Diagnostics.Fallthrough_case_in_switch);
|
|
}
|
|
function createLazyCaseClauseDiagnostics(clause2) {
|
|
return () => {
|
|
let caseType = checkExpression(clause2.expression);
|
|
const caseIsLiteral = isLiteralType(caseType);
|
|
let comparedExpressionType = expressionType;
|
|
if (!caseIsLiteral || !expressionIsLiteral) {
|
|
caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType;
|
|
comparedExpressionType = getBaseTypeOfLiteralType(expressionType);
|
|
}
|
|
if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) {
|
|
checkTypeComparableTo(caseType, comparedExpressionType, clause2.expression, void 0);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
if (node.caseBlock.locals) {
|
|
registerForUnusedIdentifiersCheck(node.caseBlock);
|
|
}
|
|
}
|
|
function checkLabeledStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
findAncestor(node.parent, (current) => {
|
|
if (isFunctionLike(current)) {
|
|
return "quit";
|
|
}
|
|
if (current.kind === 253 /* LabeledStatement */ && current.label.escapedText === node.label.escapedText) {
|
|
grammarErrorOnNode(node.label, Diagnostics.Duplicate_label_0, getTextOfNode(node.label));
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
checkSourceElement(node.statement);
|
|
}
|
|
function checkThrowStatement(node) {
|
|
if (!checkGrammarStatementInAmbientContext(node)) {
|
|
if (isIdentifier(node.expression) && !node.expression.escapedText) {
|
|
grammarErrorAfterFirstToken(node, Diagnostics.Line_break_not_permitted_here);
|
|
}
|
|
}
|
|
if (node.expression) {
|
|
checkExpression(node.expression);
|
|
}
|
|
}
|
|
function checkTryStatement(node) {
|
|
checkGrammarStatementInAmbientContext(node);
|
|
checkBlock(node.tryBlock);
|
|
const catchClause = node.catchClause;
|
|
if (catchClause) {
|
|
if (catchClause.variableDeclaration) {
|
|
const declaration = catchClause.variableDeclaration;
|
|
const typeNode = getEffectiveTypeAnnotationNode(getRootDeclaration(declaration));
|
|
if (typeNode) {
|
|
const type = getTypeForVariableLikeDeclaration(declaration, false, 0 /* Normal */);
|
|
if (type && !(type.flags & 3 /* AnyOrUnknown */)) {
|
|
grammarErrorOnFirstToken(typeNode, Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified);
|
|
}
|
|
} else if (declaration.initializer) {
|
|
grammarErrorOnFirstToken(declaration.initializer, Diagnostics.Catch_clause_variable_cannot_have_an_initializer);
|
|
} else {
|
|
const blockLocals = catchClause.block.locals;
|
|
if (blockLocals) {
|
|
forEachKey(catchClause.locals, (caughtName) => {
|
|
const blockLocal = blockLocals.get(caughtName);
|
|
if ((blockLocal == null ? void 0 : blockLocal.valueDeclaration) && (blockLocal.flags & 2 /* BlockScopedVariable */) !== 0) {
|
|
grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
checkBlock(catchClause.block);
|
|
}
|
|
if (node.finallyBlock) {
|
|
checkBlock(node.finallyBlock);
|
|
}
|
|
}
|
|
function checkIndexConstraints(type, symbol, isStaticIndex) {
|
|
const indexInfos = getIndexInfosOfType(type);
|
|
if (indexInfos.length === 0) {
|
|
return;
|
|
}
|
|
for (const prop of getPropertiesOfObjectType(type)) {
|
|
if (!(isStaticIndex && prop.flags & 4194304 /* Prototype */)) {
|
|
checkIndexConstraintForProperty(type, prop, getLiteralTypeFromProperty(prop, 8576 /* StringOrNumberLiteralOrUnique */, true), getNonMissingTypeOfSymbol(prop));
|
|
}
|
|
}
|
|
const typeDeclaration = symbol.valueDeclaration;
|
|
if (typeDeclaration && isClassLike(typeDeclaration)) {
|
|
for (const member of typeDeclaration.members) {
|
|
if (!isStatic(member) && !hasBindableName(member)) {
|
|
const symbol2 = getSymbolOfNode(member);
|
|
checkIndexConstraintForProperty(type, symbol2, getTypeOfExpression(member.name.expression), getNonMissingTypeOfSymbol(symbol2));
|
|
}
|
|
}
|
|
}
|
|
if (indexInfos.length > 1) {
|
|
for (const info of indexInfos) {
|
|
checkIndexConstraintForIndexSignature(type, info);
|
|
}
|
|
}
|
|
}
|
|
function checkIndexConstraintForProperty(type, prop, propNameType, propType) {
|
|
const declaration = prop.valueDeclaration;
|
|
const name = getNameOfDeclaration(declaration);
|
|
if (name && isPrivateIdentifier(name)) {
|
|
return;
|
|
}
|
|
const indexInfos = getApplicableIndexInfos(type, propNameType);
|
|
const interfaceDeclaration = getObjectFlags(type) & 2 /* Interface */ ? getDeclarationOfKind(type.symbol, 261 /* InterfaceDeclaration */) : void 0;
|
|
const propDeclaration = declaration && declaration.kind === 223 /* BinaryExpression */ || name && name.kind === 164 /* ComputedPropertyName */ ? declaration : void 0;
|
|
const localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : void 0;
|
|
for (const info of indexInfos) {
|
|
const localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : void 0;
|
|
const errorNode = localPropDeclaration || localIndexDeclaration || (interfaceDeclaration && !some(getBaseTypes(type), (base) => !!getPropertyOfObjectType(base, prop.escapedName) && !!getIndexTypeOfType(base, info.keyType)) ? interfaceDeclaration : void 0);
|
|
if (errorNode && !isTypeAssignableTo(propType, info.type)) {
|
|
const diagnostic = createError(
|
|
errorNode,
|
|
Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3,
|
|
symbolToString(prop),
|
|
typeToString(propType),
|
|
typeToString(info.keyType),
|
|
typeToString(info.type)
|
|
);
|
|
if (propDeclaration && errorNode !== propDeclaration) {
|
|
addRelatedInfo(diagnostic, createDiagnosticForNode(propDeclaration, Diagnostics._0_is_declared_here, symbolToString(prop)));
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
}
|
|
function checkIndexConstraintForIndexSignature(type, checkInfo) {
|
|
const declaration = checkInfo.declaration;
|
|
const indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
|
|
const interfaceDeclaration = getObjectFlags(type) & 2 /* Interface */ ? getDeclarationOfKind(type.symbol, 261 /* InterfaceDeclaration */) : void 0;
|
|
const localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : void 0;
|
|
for (const info of indexInfos) {
|
|
if (info === checkInfo)
|
|
continue;
|
|
const localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : void 0;
|
|
const errorNode = localCheckDeclaration || localIndexDeclaration || (interfaceDeclaration && !some(getBaseTypes(type), (base) => !!getIndexInfoOfType(base, checkInfo.keyType) && !!getIndexTypeOfType(base, info.keyType)) ? interfaceDeclaration : void 0);
|
|
if (errorNode && !isTypeAssignableTo(checkInfo.type, info.type)) {
|
|
error(
|
|
errorNode,
|
|
Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3,
|
|
typeToString(checkInfo.keyType),
|
|
typeToString(checkInfo.type),
|
|
typeToString(info.keyType),
|
|
typeToString(info.type)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function checkTypeNameIsReserved(name, message) {
|
|
switch (name.escapedText) {
|
|
case "any":
|
|
case "unknown":
|
|
case "never":
|
|
case "number":
|
|
case "bigint":
|
|
case "boolean":
|
|
case "string":
|
|
case "symbol":
|
|
case "void":
|
|
case "object":
|
|
error(name, message, name.escapedText);
|
|
}
|
|
}
|
|
function checkClassNameCollisionWithObject(name) {
|
|
if (languageVersion >= 1 /* ES5 */ && name.escapedText === "Object" && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(name).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
error(name, Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ModuleKind[moduleKind]);
|
|
}
|
|
}
|
|
function checkUnmatchedJSDocParameters(node) {
|
|
const jsdocParameters = filter(getJSDocTags(node), isJSDocParameterTag);
|
|
if (!length(jsdocParameters))
|
|
return;
|
|
const isJs = isInJSFile(node);
|
|
const parameters = /* @__PURE__ */ new Set();
|
|
const excludedParameters = /* @__PURE__ */ new Set();
|
|
forEach(node.parameters, ({ name }, index) => {
|
|
if (isIdentifier(name)) {
|
|
parameters.add(name.escapedText);
|
|
}
|
|
if (isBindingPattern(name)) {
|
|
excludedParameters.add(index);
|
|
}
|
|
});
|
|
const containsArguments = containsArgumentsReference(node);
|
|
if (containsArguments) {
|
|
const lastJSDocParamIndex = jsdocParameters.length - 1;
|
|
const lastJSDocParam = jsdocParameters[lastJSDocParamIndex];
|
|
if (isJs && lastJSDocParam && isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !excludedParameters.has(lastJSDocParamIndex) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
|
|
error(lastJSDocParam.name, Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, idText(lastJSDocParam.name));
|
|
}
|
|
} else {
|
|
forEach(jsdocParameters, ({ name, isNameFirst }, index) => {
|
|
if (excludedParameters.has(index) || isIdentifier(name) && parameters.has(name.escapedText)) {
|
|
return;
|
|
}
|
|
if (isQualifiedName(name)) {
|
|
if (isJs) {
|
|
error(name, Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, entityNameToString(name), entityNameToString(name.left));
|
|
}
|
|
} else {
|
|
if (!isNameFirst) {
|
|
errorOrSuggestion(isJs, name, Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, idText(name));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkTypeParameters(typeParameterDeclarations) {
|
|
let seenDefault = false;
|
|
if (typeParameterDeclarations) {
|
|
for (let i = 0; i < typeParameterDeclarations.length; i++) {
|
|
const node = typeParameterDeclarations[i];
|
|
checkTypeParameter(node);
|
|
addLazyDiagnostic(createCheckTypeParameterDiagnostic(node, i));
|
|
}
|
|
}
|
|
function createCheckTypeParameterDiagnostic(node, i) {
|
|
return () => {
|
|
if (node.default) {
|
|
seenDefault = true;
|
|
checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i);
|
|
} else if (seenDefault) {
|
|
error(node, Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters);
|
|
}
|
|
for (let j = 0; j < i; j++) {
|
|
if (typeParameterDeclarations[j].symbol === node.symbol) {
|
|
error(node.name, Diagnostics.Duplicate_identifier_0, declarationNameToString(node.name));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function checkTypeParametersNotReferenced(root, typeParameters, index) {
|
|
visit(root);
|
|
function visit(node) {
|
|
if (node.kind === 180 /* TypeReference */) {
|
|
const type = getTypeFromTypeReference(node);
|
|
if (type.flags & 262144 /* TypeParameter */) {
|
|
for (let i = index; i < typeParameters.length; i++) {
|
|
if (type.symbol === getSymbolOfNode(typeParameters[i])) {
|
|
error(node, Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
forEachChild(node, visit);
|
|
}
|
|
}
|
|
function checkTypeParameterListsIdentical(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length === 1) {
|
|
return;
|
|
}
|
|
const links = getSymbolLinks(symbol);
|
|
if (!links.typeParametersChecked) {
|
|
links.typeParametersChecked = true;
|
|
const declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol);
|
|
if (!declarations || declarations.length <= 1) {
|
|
return;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
if (!areTypeParametersIdentical(declarations, type.localTypeParameters, getEffectiveTypeParameterDeclarations)) {
|
|
const name = symbolToString(symbol);
|
|
for (const declaration of declarations) {
|
|
error(declaration.name, Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function areTypeParametersIdentical(declarations, targetParameters, getTypeParameterDeclarations) {
|
|
const maxTypeArgumentCount = length(targetParameters);
|
|
const minTypeArgumentCount = getMinTypeArgumentCount(targetParameters);
|
|
for (const declaration of declarations) {
|
|
const sourceParameters = getTypeParameterDeclarations(declaration);
|
|
const numTypeParameters = sourceParameters.length;
|
|
if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < numTypeParameters; i++) {
|
|
const source = sourceParameters[i];
|
|
const target = targetParameters[i];
|
|
if (source.name.escapedText !== target.symbol.escapedName) {
|
|
return false;
|
|
}
|
|
const constraint = getEffectiveConstraintOfTypeParameter(source);
|
|
const sourceConstraint = constraint && getTypeFromTypeNode(constraint);
|
|
const targetConstraint = getConstraintOfTypeParameter(target);
|
|
if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) {
|
|
return false;
|
|
}
|
|
const sourceDefault = source.default && getTypeFromTypeNode(source.default);
|
|
const targetDefault = getDefaultFromTypeParameter(target);
|
|
if (sourceDefault && targetDefault && !isTypeIdenticalTo(sourceDefault, targetDefault)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function checkClassExpression(node) {
|
|
checkClassLikeDeclaration(node);
|
|
checkNodeDeferred(node);
|
|
return getTypeOfSymbol(getSymbolOfNode(node));
|
|
}
|
|
function checkClassExpressionDeferred(node) {
|
|
forEach(node.members, checkSourceElement);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkClassDeclaration(node) {
|
|
const firstDecorator = find(node.modifiers, isDecorator);
|
|
if (firstDecorator && some(node.members, (p) => hasStaticModifier(p) && isPrivateIdentifierClassElementDeclaration(p))) {
|
|
grammarErrorOnNode(firstDecorator, Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator);
|
|
}
|
|
if (!node.name && !hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
|
|
}
|
|
checkClassLikeDeclaration(node);
|
|
forEach(node.members, checkSourceElement);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
function checkClassLikeDeclaration(node) {
|
|
checkGrammarClassLikeDeclaration(node);
|
|
checkDecorators(node);
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
checkTypeParameters(getEffectiveTypeParameterDeclarations(node));
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
checkTypeParameterListsIdentical(symbol);
|
|
checkFunctionOrConstructorSymbol(symbol);
|
|
checkClassForDuplicateDeclarations(node);
|
|
const nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
|
|
if (!nodeInAmbientContext) {
|
|
checkClassForStaticPropertyNameConflicts(node);
|
|
}
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
if (baseTypeNode) {
|
|
forEach(baseTypeNode.typeArguments, checkSourceElement);
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
checkExternalEmitHelpers(baseTypeNode.parent, 1 /* Extends */);
|
|
}
|
|
const extendsNode = getClassExtendsHeritageElement(node);
|
|
if (extendsNode && extendsNode !== baseTypeNode) {
|
|
checkExpression(extendsNode.expression);
|
|
}
|
|
const baseTypes = getBaseTypes(type);
|
|
if (baseTypes.length) {
|
|
addLazyDiagnostic(() => {
|
|
const baseType = baseTypes[0];
|
|
const baseConstructorType = getBaseConstructorTypeOfClass(type);
|
|
const staticBaseType = getApparentType(baseConstructorType);
|
|
checkBaseTypeAccessibility(staticBaseType, baseTypeNode);
|
|
checkSourceElement(baseTypeNode.expression);
|
|
if (some(baseTypeNode.typeArguments)) {
|
|
forEach(baseTypeNode.typeArguments, checkSourceElement);
|
|
for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode)) {
|
|
if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const baseWithThis = getTypeWithThisArgument(baseType, type.thisType);
|
|
if (!checkTypeAssignableTo(typeWithThis, baseWithThis, void 0)) {
|
|
issueMemberSpecificError(node, typeWithThis, baseWithThis, Diagnostics.Class_0_incorrectly_extends_base_class_1);
|
|
} else {
|
|
checkTypeAssignableTo(
|
|
staticType,
|
|
getTypeWithoutSignatures(staticBaseType),
|
|
node.name || node,
|
|
Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1
|
|
);
|
|
}
|
|
if (baseConstructorType.flags & 8650752 /* TypeVariable */) {
|
|
if (!isMixinConstructorType(staticType)) {
|
|
error(node.name || node, Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any);
|
|
} else {
|
|
const constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* Construct */);
|
|
if (constructSignatures.some((signature) => signature.flags & 4 /* Abstract */) && !hasSyntacticModifier(node, 256 /* Abstract */)) {
|
|
error(node.name || node, 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 */)) {
|
|
const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);
|
|
if (forEach(constructors, (sig) => !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType))) {
|
|
error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type);
|
|
}
|
|
}
|
|
checkKindsOfPropertyMemberOverrides(type, baseType);
|
|
});
|
|
}
|
|
}
|
|
checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
|
|
const implementedTypeNodes = getEffectiveImplementsTypeNodes(node);
|
|
if (implementedTypeNodes) {
|
|
for (const typeRefNode of implementedTypeNodes) {
|
|
if (!isEntityNameExpression(typeRefNode.expression) || isOptionalChain(typeRefNode.expression)) {
|
|
error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
|
}
|
|
checkTypeReferenceNode(typeRefNode);
|
|
addLazyDiagnostic(createImplementsDiagnostics(typeRefNode));
|
|
}
|
|
}
|
|
addLazyDiagnostic(() => {
|
|
checkIndexConstraints(type, symbol);
|
|
checkIndexConstraints(staticType, symbol, true);
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
checkPropertyInitialization(node);
|
|
});
|
|
function createImplementsDiagnostics(typeRefNode) {
|
|
return () => {
|
|
const t = getReducedType(getTypeFromTypeNode(typeRefNode));
|
|
if (!isErrorType(t)) {
|
|
if (isValidBaseType(t)) {
|
|
const genericDiag = t.symbol && t.symbol.flags & 32 /* Class */ ? Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass : Diagnostics.Class_0_incorrectly_implements_interface_1;
|
|
const baseWithThis = getTypeWithThisArgument(t, type.thisType);
|
|
if (!checkTypeAssignableTo(typeWithThis, baseWithThis, void 0)) {
|
|
issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag);
|
|
}
|
|
} else {
|
|
error(typeRefNode, Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
const baseTypes = baseTypeNode && getBaseTypes(type);
|
|
const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
|
|
const baseStaticType = getBaseConstructorTypeOfClass(type);
|
|
for (const member of node.members) {
|
|
if (hasAmbientModifier(member)) {
|
|
continue;
|
|
}
|
|
if (isConstructorDeclaration(member)) {
|
|
forEach(member.parameters, (param) => {
|
|
if (isParameterPropertyDeclaration(param, member)) {
|
|
checkExistingMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
param,
|
|
true
|
|
);
|
|
}
|
|
});
|
|
}
|
|
checkExistingMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
member,
|
|
false
|
|
);
|
|
}
|
|
}
|
|
function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors2 = true) {
|
|
const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
|
|
if (!declaredProp) {
|
|
return 0 /* Ok */;
|
|
}
|
|
return checkMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
hasOverrideModifier(member),
|
|
hasAbstractModifier(member),
|
|
isStatic(member),
|
|
memberIsParameterProperty,
|
|
symbolName(declaredProp),
|
|
reportErrors2 ? member : void 0
|
|
);
|
|
}
|
|
function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
|
|
const isJs = isInJSFile(node);
|
|
const nodeInAmbientContext = !!(node.flags & 16777216 /* Ambient */);
|
|
if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
|
|
const memberEscapedName = escapeLeadingUnderscores(memberName);
|
|
const thisType = memberIsStatic ? staticType : typeWithThis;
|
|
const baseType = memberIsStatic ? baseStaticType : baseWithThis;
|
|
const prop = getPropertyOfType(thisType, memberEscapedName);
|
|
const baseProp = getPropertyOfType(baseType, memberEscapedName);
|
|
const baseClassName = typeToString(baseWithThis);
|
|
if (prop && !baseProp && memberHasOverrideModifier) {
|
|
if (errorNode) {
|
|
const suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType);
|
|
suggestion ? error(
|
|
errorNode,
|
|
isJs ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 : Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1,
|
|
baseClassName,
|
|
symbolToString(suggestion)
|
|
) : error(
|
|
errorNode,
|
|
isJs ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 : Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0,
|
|
baseClassName
|
|
);
|
|
}
|
|
return 2 /* HasInvalidOverride */;
|
|
} else if (prop && (baseProp == null ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
|
|
const baseHasAbstract = some(baseProp.declarations, hasAbstractModifier);
|
|
if (memberHasOverrideModifier) {
|
|
return 0 /* Ok */;
|
|
}
|
|
if (!baseHasAbstract) {
|
|
if (errorNode) {
|
|
const diag2 = memberIsParameterProperty ? isJs ? Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 : isJs ? Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0;
|
|
error(errorNode, diag2, baseClassName);
|
|
}
|
|
return 1 /* NeedsOverride */;
|
|
} else if (memberHasAbstractModifier && baseHasAbstract) {
|
|
if (errorNode) {
|
|
error(errorNode, Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
|
|
}
|
|
return 1 /* NeedsOverride */;
|
|
}
|
|
}
|
|
} else if (memberHasOverrideModifier) {
|
|
if (errorNode) {
|
|
const className = typeToString(type);
|
|
error(
|
|
errorNode,
|
|
isJs ? Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class : Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class,
|
|
className
|
|
);
|
|
}
|
|
return 2 /* HasInvalidOverride */;
|
|
}
|
|
return 0 /* Ok */;
|
|
}
|
|
function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
|
|
let issuedMemberError = false;
|
|
for (const member of node.members) {
|
|
if (isStatic(member)) {
|
|
continue;
|
|
}
|
|
const declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
|
|
if (declaredProp) {
|
|
const prop = getPropertyOfType(typeWithThis, declaredProp.escapedName);
|
|
const baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName);
|
|
if (prop && baseProp) {
|
|
const rootChain = () => chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2,
|
|
symbolToString(declaredProp),
|
|
typeToString(typeWithThis),
|
|
typeToString(baseWithThis)
|
|
);
|
|
if (!checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(baseProp), member.name || member, void 0, rootChain)) {
|
|
issuedMemberError = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!issuedMemberError) {
|
|
checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag);
|
|
}
|
|
}
|
|
function checkBaseTypeAccessibility(type, node) {
|
|
const signatures = getSignaturesOfType(type, 1 /* Construct */);
|
|
if (signatures.length) {
|
|
const declaration = signatures[0].declaration;
|
|
if (declaration && hasEffectiveModifier(declaration, 8 /* Private */)) {
|
|
const typeClassDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (!isNodeWithinClass(node, typeClassDeclaration)) {
|
|
error(node, Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getMemberOverrideModifierStatus(node, member) {
|
|
if (!member.name) {
|
|
return 0 /* Ok */;
|
|
}
|
|
const symbol = getSymbolOfNode(node);
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
const staticType = getTypeOfSymbol(symbol);
|
|
const baseTypeNode = getEffectiveBaseTypeNode(node);
|
|
const baseTypes = baseTypeNode && getBaseTypes(type);
|
|
const baseWithThis = (baseTypes == null ? void 0 : baseTypes.length) ? getTypeWithThisArgument(first(baseTypes), type.thisType) : void 0;
|
|
const baseStaticType = getBaseConstructorTypeOfClass(type);
|
|
const memberHasOverrideModifier = member.parent ? hasOverrideModifier(member) : hasSyntacticModifier(member, 16384 /* Override */);
|
|
const memberName = unescapeLeadingUnderscores(getTextOfPropertyName(member.name));
|
|
return checkMemberForOverrideModifier(
|
|
node,
|
|
staticType,
|
|
baseStaticType,
|
|
baseWithThis,
|
|
type,
|
|
typeWithThis,
|
|
memberHasOverrideModifier,
|
|
hasAbstractModifier(member),
|
|
isStatic(member),
|
|
false,
|
|
memberName
|
|
);
|
|
}
|
|
function getTargetSymbol(s) {
|
|
return getCheckFlags(s) & 1 /* Instantiated */ ? s.target : s;
|
|
}
|
|
function getClassOrInterfaceDeclarationsOfSymbol(symbol) {
|
|
return filter(symbol.declarations, (d) => d.kind === 260 /* ClassDeclaration */ || d.kind === 261 /* InterfaceDeclaration */);
|
|
}
|
|
function checkKindsOfPropertyMemberOverrides(type, baseType) {
|
|
var _a2, _b, _c, _d;
|
|
const baseProperties = getPropertiesOfType(baseType);
|
|
basePropertyCheck:
|
|
for (const baseProperty of baseProperties) {
|
|
const base = getTargetSymbol(baseProperty);
|
|
if (base.flags & 4194304 /* Prototype */) {
|
|
continue;
|
|
}
|
|
const baseSymbol = getPropertyOfObjectType(type, base.escapedName);
|
|
if (!baseSymbol) {
|
|
continue;
|
|
}
|
|
const derived = getTargetSymbol(baseSymbol);
|
|
const baseDeclarationFlags = getDeclarationModifierFlagsFromSymbol(base);
|
|
Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration.");
|
|
if (derived === base) {
|
|
const derivedClassDecl = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (baseDeclarationFlags & 256 /* Abstract */ && (!derivedClassDecl || !hasSyntacticModifier(derivedClassDecl, 256 /* Abstract */))) {
|
|
for (const otherBaseType of getBaseTypes(type)) {
|
|
if (otherBaseType === baseType)
|
|
continue;
|
|
const baseSymbol2 = getPropertyOfObjectType(otherBaseType, base.escapedName);
|
|
const derivedElsewhere = baseSymbol2 && getTargetSymbol(baseSymbol2);
|
|
if (derivedElsewhere && derivedElsewhere !== base) {
|
|
continue basePropertyCheck;
|
|
}
|
|
}
|
|
if (derivedClassDecl.kind === 228 /* ClassExpression */) {
|
|
error(
|
|
derivedClassDecl,
|
|
Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1,
|
|
symbolToString(baseProperty),
|
|
typeToString(baseType)
|
|
);
|
|
} else {
|
|
error(
|
|
derivedClassDecl,
|
|
Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2,
|
|
typeToString(type),
|
|
symbolToString(baseProperty),
|
|
typeToString(baseType)
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
const derivedDeclarationFlags = getDeclarationModifierFlagsFromSymbol(derived);
|
|
if (baseDeclarationFlags & 8 /* Private */ || derivedDeclarationFlags & 8 /* Private */) {
|
|
continue;
|
|
}
|
|
let errorMessage;
|
|
const basePropertyFlags = base.flags & 98308 /* PropertyOrAccessor */;
|
|
const derivedPropertyFlags = derived.flags & 98308 /* PropertyOrAccessor */;
|
|
if (basePropertyFlags && derivedPropertyFlags) {
|
|
if ((getCheckFlags(base) & 6 /* Synthetic */ ? (_a2 = base.declarations) == null ? void 0 : _a2.some((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags)) : (_b = base.declarations) == null ? void 0 : _b.every((d) => isPropertyAbstractOrInterface(d, baseDeclarationFlags))) || getCheckFlags(base) & 262144 /* Mapped */ || derived.valueDeclaration && isBinaryExpression(derived.valueDeclaration)) {
|
|
continue;
|
|
}
|
|
const overriddenInstanceProperty = basePropertyFlags !== 4 /* Property */ && derivedPropertyFlags === 4 /* Property */;
|
|
const overriddenInstanceAccessor = basePropertyFlags === 4 /* Property */ && derivedPropertyFlags !== 4 /* Property */;
|
|
if (overriddenInstanceProperty || overriddenInstanceAccessor) {
|
|
const errorMessage2 = overriddenInstanceProperty ? Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
|
|
error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType), typeToString(type));
|
|
} else if (useDefineForClassFields) {
|
|
const uninitialized = (_c = derived.declarations) == null ? void 0 : _c.find((d) => d.kind === 169 /* PropertyDeclaration */ && !d.initializer);
|
|
if (uninitialized && !(derived.flags & 33554432 /* Transient */) && !(baseDeclarationFlags & 256 /* Abstract */) && !(derivedDeclarationFlags & 256 /* Abstract */) && !((_d = derived.declarations) == null ? void 0 : _d.some((d) => !!(d.flags & 16777216 /* Ambient */)))) {
|
|
const constructor = findConstructorDeclaration(getClassLikeDeclarationOfSymbol(type.symbol));
|
|
const propName = uninitialized.name;
|
|
if (uninitialized.exclamationToken || !constructor || !isIdentifier(propName) || !strictNullChecks || !isPropertyInitializedInConstructor(propName, type, constructor)) {
|
|
const errorMessage2 = Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration;
|
|
error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage2, symbolToString(base), typeToString(baseType));
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
} else if (isPrototypeProperty(base)) {
|
|
if (isPrototypeProperty(derived) || derived.flags & 4 /* Property */) {
|
|
continue;
|
|
} else {
|
|
Debug.assert(!!(derived.flags & 98304 /* Accessor */));
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor;
|
|
}
|
|
} else if (base.flags & 98304 /* Accessor */) {
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function;
|
|
} else {
|
|
errorMessage = Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function;
|
|
}
|
|
error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type));
|
|
}
|
|
}
|
|
}
|
|
function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
|
|
return baseDeclarationFlags & 256 /* Abstract */ && (!isPropertyDeclaration(declaration) || !declaration.initializer) || isInterfaceDeclaration(declaration.parent);
|
|
}
|
|
function getNonInheritedProperties(type, baseTypes, properties) {
|
|
if (!length(baseTypes)) {
|
|
return properties;
|
|
}
|
|
const seen = /* @__PURE__ */ new Map();
|
|
forEach(properties, (p) => {
|
|
seen.set(p.escapedName, p);
|
|
});
|
|
for (const base of baseTypes) {
|
|
const properties2 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
|
|
for (const prop of properties2) {
|
|
const existing = seen.get(prop.escapedName);
|
|
if (existing && prop.parent === existing.parent) {
|
|
seen.delete(prop.escapedName);
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(seen.values());
|
|
}
|
|
function checkInheritedPropertiesAreIdentical(type, typeNode) {
|
|
const baseTypes = getBaseTypes(type);
|
|
if (baseTypes.length < 2) {
|
|
return true;
|
|
}
|
|
const seen = /* @__PURE__ */ new Map();
|
|
forEach(resolveDeclaredMembers(type).declaredProperties, (p) => {
|
|
seen.set(p.escapedName, { prop: p, containingType: type });
|
|
});
|
|
let ok = true;
|
|
for (const base of baseTypes) {
|
|
const properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));
|
|
for (const prop of properties) {
|
|
const existing = seen.get(prop.escapedName);
|
|
if (!existing) {
|
|
seen.set(prop.escapedName, { prop, containingType: base });
|
|
} else {
|
|
const isInheritedProperty = existing.containingType !== type;
|
|
if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) {
|
|
ok = false;
|
|
const typeName1 = typeToString(existing.containingType);
|
|
const typeName2 = typeToString(base);
|
|
let errorInfo = chainDiagnosticMessages(void 0, Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2);
|
|
errorInfo = chainDiagnosticMessages(errorInfo, Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2);
|
|
diagnostics.add(createDiagnosticForNodeFromMessageChain(typeNode, errorInfo));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
function checkPropertyInitialization(node) {
|
|
if (!strictNullChecks || !strictPropertyInitialization || node.flags & 16777216 /* Ambient */) {
|
|
return;
|
|
}
|
|
const constructor = findConstructorDeclaration(node);
|
|
for (const member of node.members) {
|
|
if (getEffectiveModifierFlags(member) & 2 /* Ambient */) {
|
|
continue;
|
|
}
|
|
if (!isStatic(member) && isPropertyWithoutInitializer(member)) {
|
|
const propName = member.name;
|
|
if (isIdentifier(propName) || isPrivateIdentifier(propName) || isComputedPropertyName(propName)) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(member));
|
|
if (!(type.flags & 3 /* AnyOrUnknown */ || containsUndefinedType(type))) {
|
|
if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) {
|
|
error(member.name, Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, declarationNameToString(propName));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isPropertyWithoutInitializer(node) {
|
|
return node.kind === 169 /* PropertyDeclaration */ && !hasAbstractModifier(node) && !node.exclamationToken && !node.initializer;
|
|
}
|
|
function isPropertyInitializedInStaticBlocks(propName, propType, staticBlocks, startPos, endPos) {
|
|
for (const staticBlock of staticBlocks) {
|
|
if (staticBlock.pos >= startPos && staticBlock.pos <= endPos) {
|
|
const reference = factory.createPropertyAccessExpression(factory.createThis(), propName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, staticBlock);
|
|
reference.flowNode = staticBlock.returnFlowNode;
|
|
const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
|
|
if (!containsUndefinedType(flowType)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isPropertyInitializedInConstructor(propName, propType, constructor) {
|
|
const reference = isComputedPropertyName(propName) ? factory.createElementAccessExpression(factory.createThis(), propName.expression) : factory.createPropertyAccessExpression(factory.createThis(), propName);
|
|
setParent(reference.expression, reference);
|
|
setParent(reference, constructor);
|
|
reference.flowNode = constructor.returnFlowNode;
|
|
const flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType));
|
|
return !containsUndefinedType(flowType);
|
|
}
|
|
function checkInterfaceDeclaration(node) {
|
|
if (!checkGrammarDecoratorsAndModifiers(node))
|
|
checkGrammarInterfaceDeclaration(node);
|
|
checkTypeParameters(node.typeParameters);
|
|
addLazyDiagnostic(() => {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
checkTypeParameterListsIdentical(symbol);
|
|
const firstInterfaceDecl = getDeclarationOfKind(symbol, 261 /* InterfaceDeclaration */);
|
|
if (node === firstInterfaceDecl) {
|
|
const type = getDeclaredTypeOfSymbol(symbol);
|
|
const typeWithThis = getTypeWithThisArgument(type);
|
|
if (checkInheritedPropertiesAreIdentical(type, node.name)) {
|
|
for (const baseType of getBaseTypes(type)) {
|
|
checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1);
|
|
}
|
|
checkIndexConstraints(type, symbol);
|
|
}
|
|
}
|
|
checkObjectTypeForDuplicateDeclarations(node);
|
|
});
|
|
forEach(getInterfaceBaseTypeNodes(node), (heritageElement) => {
|
|
if (!isEntityNameExpression(heritageElement.expression) || isOptionalChain(heritageElement.expression)) {
|
|
error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
|
|
}
|
|
checkTypeReferenceNode(heritageElement);
|
|
});
|
|
forEach(node.members, checkSourceElement);
|
|
addLazyDiagnostic(() => {
|
|
checkTypeForDuplicateIndexSignatures(node);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
});
|
|
}
|
|
function checkTypeAliasDeclaration(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Type_alias_name_cannot_be_0);
|
|
checkExportsOnMergedDeclarations(node);
|
|
checkTypeParameters(node.typeParameters);
|
|
if (node.type.kind === 139 /* IntrinsicKeyword */) {
|
|
if (!intrinsicTypeKinds.has(node.name.escapedText) || length(node.typeParameters) !== 1) {
|
|
error(node.type, Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types);
|
|
}
|
|
} else {
|
|
checkSourceElement(node.type);
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
function computeEnumMemberValues(node) {
|
|
const nodeLinks2 = getNodeLinks(node);
|
|
if (!(nodeLinks2.flags & 1024 /* EnumValuesComputed */)) {
|
|
nodeLinks2.flags |= 1024 /* EnumValuesComputed */;
|
|
let autoValue = 0;
|
|
for (const member of node.members) {
|
|
const value = computeMemberValue(member, autoValue);
|
|
getNodeLinks(member).enumMemberValue = value;
|
|
autoValue = typeof value === "number" ? value + 1 : void 0;
|
|
}
|
|
}
|
|
}
|
|
function computeMemberValue(member, autoValue) {
|
|
if (isComputedNonLiteralName(member.name)) {
|
|
error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
|
|
} else {
|
|
const text = getTextOfPropertyName(member.name);
|
|
if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
|
|
error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
|
|
}
|
|
}
|
|
if (member.initializer) {
|
|
return computeConstantValue(member);
|
|
}
|
|
if (member.parent.flags & 16777216 /* Ambient */ && !isEnumConst(member.parent)) {
|
|
return void 0;
|
|
}
|
|
if (autoValue !== void 0) {
|
|
return autoValue;
|
|
}
|
|
error(member.name, Diagnostics.Enum_member_must_have_initializer);
|
|
return void 0;
|
|
}
|
|
function computeConstantValue(member) {
|
|
const isConstEnum = isEnumConst(member.parent);
|
|
const initializer = member.initializer;
|
|
const value = evaluate(initializer, member);
|
|
if (value !== void 0) {
|
|
if (isConstEnum && typeof value === "number" && !isFinite(value)) {
|
|
error(initializer, isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value);
|
|
}
|
|
} else if (isConstEnum) {
|
|
error(initializer, Diagnostics.const_enum_member_initializers_must_be_constant_expressions);
|
|
} else if (member.parent.flags & 16777216 /* Ambient */) {
|
|
error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
|
|
} else {
|
|
checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
|
|
}
|
|
return value;
|
|
}
|
|
function evaluate(expr, location2) {
|
|
switch (expr.kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
const value = evaluate(expr.operand, location2);
|
|
if (typeof value === "number") {
|
|
switch (expr.operator) {
|
|
case 39 /* PlusToken */:
|
|
return value;
|
|
case 40 /* MinusToken */:
|
|
return -value;
|
|
case 54 /* TildeToken */:
|
|
return ~value;
|
|
}
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
const left = evaluate(expr.left, location2);
|
|
const right = evaluate(expr.right, location2);
|
|
if (typeof left === "number" && typeof right === "number") {
|
|
switch (expr.operatorToken.kind) {
|
|
case 51 /* BarToken */:
|
|
return left | right;
|
|
case 50 /* AmpersandToken */:
|
|
return left & right;
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
return left >> right;
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
return left >>> right;
|
|
case 47 /* LessThanLessThanToken */:
|
|
return left << right;
|
|
case 52 /* CaretToken */:
|
|
return left ^ right;
|
|
case 41 /* AsteriskToken */:
|
|
return left * right;
|
|
case 43 /* SlashToken */:
|
|
return left / right;
|
|
case 39 /* PlusToken */:
|
|
return left + right;
|
|
case 40 /* MinusToken */:
|
|
return left - right;
|
|
case 44 /* PercentToken */:
|
|
return left % right;
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return left ** right;
|
|
}
|
|
} else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 39 /* PlusToken */) {
|
|
return "" + left + right;
|
|
}
|
|
break;
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return expr.text;
|
|
case 225 /* TemplateExpression */:
|
|
return evaluateTemplateExpression(expr, location2);
|
|
case 8 /* NumericLiteral */:
|
|
checkGrammarNumericLiteral(expr);
|
|
return +expr.text;
|
|
case 214 /* ParenthesizedExpression */:
|
|
return evaluate(expr.expression, location2);
|
|
case 79 /* Identifier */:
|
|
if (isInfinityOrNaNString(expr.escapedText)) {
|
|
return +expr.escapedText;
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (isEntityNameExpression(expr)) {
|
|
const symbol = resolveEntityName(expr, 111551 /* Value */, true);
|
|
if (symbol) {
|
|
if (symbol.flags & 8 /* EnumMember */) {
|
|
return evaluateEnumMember(expr, symbol, location2);
|
|
}
|
|
if (isConstVariable(symbol)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (declaration && !declaration.type && declaration.initializer && declaration !== location2 && isBlockScopedNameDeclaredBeforeUse(declaration, location2)) {
|
|
return evaluate(declaration.initializer, declaration);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
const root = expr.expression;
|
|
if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
|
|
const rootSymbol = resolveEntityName(root, 111551 /* Value */, true);
|
|
if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
|
|
const name = escapeLeadingUnderscores(expr.argumentExpression.text);
|
|
const member = rootSymbol.exports.get(name);
|
|
if (member) {
|
|
return evaluateEnumMember(expr, member, location2);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return void 0;
|
|
}
|
|
function evaluateEnumMember(expr, symbol, location2) {
|
|
const declaration = symbol.valueDeclaration;
|
|
if (!declaration || declaration === location2) {
|
|
error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
|
|
return void 0;
|
|
}
|
|
if (!isBlockScopedNameDeclaredBeforeUse(declaration, location2)) {
|
|
error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
|
|
return 0;
|
|
}
|
|
return getEnumMemberValue(declaration);
|
|
}
|
|
function evaluateTemplateExpression(expr, location2) {
|
|
let result = expr.head.text;
|
|
for (const span of expr.templateSpans) {
|
|
const value = evaluate(span.expression, location2);
|
|
if (value === void 0) {
|
|
return void 0;
|
|
}
|
|
result += value;
|
|
result += span.literal.text;
|
|
}
|
|
return result;
|
|
}
|
|
function checkEnumDeclaration(node) {
|
|
addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
|
|
}
|
|
function checkEnumDeclarationWorker(node) {
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
checkExportsOnMergedDeclarations(node);
|
|
node.members.forEach(checkEnumMember);
|
|
computeEnumMemberValues(node);
|
|
const enumSymbol = getSymbolOfNode(node);
|
|
const firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
|
|
if (node === firstDeclaration) {
|
|
if (enumSymbol.declarations && enumSymbol.declarations.length > 1) {
|
|
const enumIsConst = isEnumConst(node);
|
|
forEach(enumSymbol.declarations, (decl) => {
|
|
if (isEnumDeclaration(decl) && isEnumConst(decl) !== enumIsConst) {
|
|
error(getNameOfDeclaration(decl), Diagnostics.Enum_declarations_must_all_be_const_or_non_const);
|
|
}
|
|
});
|
|
}
|
|
let seenEnumMissingInitialInitializer = false;
|
|
forEach(enumSymbol.declarations, (declaration) => {
|
|
if (declaration.kind !== 263 /* EnumDeclaration */) {
|
|
return false;
|
|
}
|
|
const enumDeclaration = declaration;
|
|
if (!enumDeclaration.members.length) {
|
|
return false;
|
|
}
|
|
const firstEnumMember = enumDeclaration.members[0];
|
|
if (!firstEnumMember.initializer) {
|
|
if (seenEnumMissingInitialInitializer) {
|
|
error(firstEnumMember.name, Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
|
|
} else {
|
|
seenEnumMissingInitialInitializer = true;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkEnumMember(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
error(node, Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier);
|
|
}
|
|
if (node.initializer) {
|
|
checkExpression(node.initializer);
|
|
}
|
|
}
|
|
function getFirstNonAmbientClassOrFunctionDeclaration(symbol) {
|
|
const declarations = symbol.declarations;
|
|
if (declarations) {
|
|
for (const declaration of declarations) {
|
|
if ((declaration.kind === 260 /* ClassDeclaration */ || declaration.kind === 259 /* FunctionDeclaration */ && nodeIsPresent(declaration.body)) && !(declaration.flags & 16777216 /* Ambient */)) {
|
|
return declaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function inSameLexicalScope(node1, node2) {
|
|
const container1 = getEnclosingBlockScopeContainer(node1);
|
|
const container2 = getEnclosingBlockScopeContainer(node2);
|
|
if (isGlobalSourceFile(container1)) {
|
|
return isGlobalSourceFile(container2);
|
|
} else if (isGlobalSourceFile(container2)) {
|
|
return false;
|
|
} else {
|
|
return container1 === container2;
|
|
}
|
|
}
|
|
function checkModuleDeclaration(node) {
|
|
if (node.body) {
|
|
checkSourceElement(node.body);
|
|
if (!isGlobalScopeAugmentation(node)) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
}
|
|
addLazyDiagnostic(checkModuleDeclarationDiagnostics);
|
|
function checkModuleDeclarationDiagnostics() {
|
|
const isGlobalAugmentation = isGlobalScopeAugmentation(node);
|
|
const inAmbientContext = node.flags & 16777216 /* Ambient */;
|
|
if (isGlobalAugmentation && !inAmbientContext) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context);
|
|
}
|
|
const isAmbientExternalModule = isAmbientModule(node);
|
|
const contextErrorMessage = isAmbientExternalModule ? Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file : Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module;
|
|
if (checkGrammarModuleElementContext(node, contextErrorMessage)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node)) {
|
|
if (!inAmbientContext && node.name.kind === 10 /* StringLiteral */) {
|
|
grammarErrorOnNode(node.name, Diagnostics.Only_ambient_modules_can_use_quoted_names);
|
|
}
|
|
}
|
|
if (isIdentifier(node.name)) {
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
}
|
|
checkExportsOnMergedDeclarations(node);
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol.flags & 512 /* ValueModule */ && !inAmbientContext && symbol.declarations && symbol.declarations.length > 1 && isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions))) {
|
|
const firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol);
|
|
if (firstNonAmbientClassOrFunc) {
|
|
if (getSourceFileOfNode(node) !== getSourceFileOfNode(firstNonAmbientClassOrFunc)) {
|
|
error(node.name, Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged);
|
|
} else if (node.pos < firstNonAmbientClassOrFunc.pos) {
|
|
error(node.name, Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged);
|
|
}
|
|
}
|
|
const mergedClass = getDeclarationOfKind(symbol, 260 /* ClassDeclaration */);
|
|
if (mergedClass && inSameLexicalScope(node, mergedClass)) {
|
|
getNodeLinks(node).flags |= 2048 /* LexicalModuleMergesWithClass */;
|
|
}
|
|
}
|
|
if (isAmbientExternalModule) {
|
|
if (isExternalModuleAugmentation(node)) {
|
|
const checkBody = isGlobalAugmentation || getSymbolOfNode(node).flags & 33554432 /* Transient */;
|
|
if (checkBody && node.body) {
|
|
for (const statement of node.body.statements) {
|
|
checkModuleAugmentationElement(statement, isGlobalAugmentation);
|
|
}
|
|
}
|
|
} else if (isGlobalSourceFile(node.parent)) {
|
|
if (isGlobalAugmentation) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
|
|
} else if (isExternalModuleNameRelative(getTextOfIdentifierOrLiteral(node.name))) {
|
|
error(node.name, Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name);
|
|
}
|
|
} else {
|
|
if (isGlobalAugmentation) {
|
|
error(node.name, Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations);
|
|
} else {
|
|
error(node.name, Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkModuleAugmentationElement(node, isGlobalAugmentation) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
for (const decl of node.declarationList.declarations) {
|
|
checkModuleAugmentationElement(decl, isGlobalAugmentation);
|
|
}
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
case 275 /* ExportDeclaration */:
|
|
grammarErrorOnFirstToken(node, Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations);
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
grammarErrorOnFirstToken(node, Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
case 257 /* VariableDeclaration */:
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
for (const el of name.elements) {
|
|
checkModuleAugmentationElement(el, isGlobalAugmentation);
|
|
}
|
|
break;
|
|
}
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
if (isGlobalAugmentation) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function getFirstNonModuleExportsIdentifier(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return node;
|
|
case 163 /* QualifiedName */:
|
|
do {
|
|
node = node.left;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
case 208 /* PropertyAccessExpression */:
|
|
do {
|
|
if (isModuleExportsAccessExpression(node.expression) && !isPrivateIdentifier(node.name)) {
|
|
return node.name;
|
|
}
|
|
node = node.expression;
|
|
} while (node.kind !== 79 /* Identifier */);
|
|
return node;
|
|
}
|
|
}
|
|
function checkExternalImportOrExportDeclaration(node) {
|
|
const moduleName = getExternalModuleName(node);
|
|
if (!moduleName || nodeIsMissing(moduleName)) {
|
|
return false;
|
|
}
|
|
if (!isStringLiteral(moduleName)) {
|
|
error(moduleName, Diagnostics.String_literal_expected);
|
|
return false;
|
|
}
|
|
const inAmbientExternalModule = node.parent.kind === 265 /* ModuleBlock */ && isAmbientModule(node.parent.parent);
|
|
if (node.parent.kind !== 308 /* SourceFile */ && !inAmbientExternalModule) {
|
|
error(moduleName, node.kind === 275 /* ExportDeclaration */ ? Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module);
|
|
return false;
|
|
}
|
|
if (inAmbientExternalModule && isExternalModuleNameRelative(moduleName.text)) {
|
|
if (!isTopLevelInExternalModuleAugmentation(node)) {
|
|
error(node, Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name);
|
|
return false;
|
|
}
|
|
}
|
|
if (!isImportEqualsDeclaration(node) && node.assertClause) {
|
|
let hasError = false;
|
|
for (const clause of node.assertClause.elements) {
|
|
if (!isStringLiteral(clause.value)) {
|
|
hasError = true;
|
|
error(clause.value, Diagnostics.Import_assertion_values_must_be_string_literal_expressions);
|
|
}
|
|
}
|
|
return !hasError;
|
|
}
|
|
return true;
|
|
}
|
|
function checkAliasSymbol(node) {
|
|
var _a2, _b, _c, _d, _e;
|
|
let symbol = getSymbolOfNode(node);
|
|
const target = resolveAlias(symbol);
|
|
if (target !== unknownSymbol) {
|
|
symbol = getMergedSymbol(symbol.exportSymbol || symbol);
|
|
if (isInJSFile(node) && !(target.flags & 111551 /* Value */) && !isTypeOnlyImportOrExportDeclaration(node)) {
|
|
const errorNode = isImportOrExportSpecifier(node) ? node.propertyName || node.name : isNamedDeclaration(node) ? node.name : node;
|
|
Debug.assert(node.kind !== 277 /* NamespaceExport */);
|
|
if (node.kind === 278 /* ExportSpecifier */) {
|
|
const diag2 = error(errorNode, Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files);
|
|
const alreadyExportedSymbol = (_b = (_a2 = getSourceFileOfNode(node).symbol) == null ? void 0 : _a2.exports) == null ? void 0 : _b.get((node.propertyName || node.name).escapedText);
|
|
if (alreadyExportedSymbol === target) {
|
|
const exportingDeclaration = (_c = alreadyExportedSymbol.declarations) == null ? void 0 : _c.find(isJSDocNode);
|
|
if (exportingDeclaration) {
|
|
addRelatedInfo(diag2, createDiagnosticForNode(
|
|
exportingDeclaration,
|
|
Diagnostics._0_is_automatically_exported_here,
|
|
unescapeLeadingUnderscores(alreadyExportedSymbol.escapedName)
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
Debug.assert(node.kind !== 257 /* VariableDeclaration */);
|
|
const importDeclaration = findAncestor(node, or(isImportDeclaration, isImportEqualsDeclaration));
|
|
const moduleSpecifier = (_e = importDeclaration && ((_d = tryGetModuleSpecifierFromDeclaration(importDeclaration)) == null ? void 0 : _d.text)) != null ? _e : "...";
|
|
const importedIdentifier = unescapeLeadingUnderscores(isIdentifier(errorNode) ? errorNode.escapedText : symbol.escapedName);
|
|
error(
|
|
errorNode,
|
|
Diagnostics._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation,
|
|
importedIdentifier,
|
|
`import("${moduleSpecifier}").${importedIdentifier}`
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
const targetFlags = getAllSymbolFlags(target);
|
|
const excludedMeanings = (symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */) ? 111551 /* Value */ : 0) | (symbol.flags & 788968 /* Type */ ? 788968 /* Type */ : 0) | (symbol.flags & 1920 /* Namespace */ ? 1920 /* Namespace */ : 0);
|
|
if (targetFlags & excludedMeanings) {
|
|
const message = node.kind === 278 /* ExportSpecifier */ ? Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0;
|
|
error(node, message, symbolToString(symbol));
|
|
}
|
|
if (compilerOptions.isolatedModules && !isTypeOnlyImportOrExportDeclaration(node) && !(node.flags & 16777216 /* Ambient */)) {
|
|
const typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol);
|
|
const isType = !(targetFlags & 111551 /* Value */);
|
|
if (isType || typeOnlyAlias) {
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 268 /* ImportEqualsDeclaration */: {
|
|
if (compilerOptions.preserveValueImports) {
|
|
Debug.assertIsDefined(node.name, "An ImportClause with a symbol should have a name");
|
|
const message = isType ? Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled;
|
|
const name = idText(node.kind === 273 /* ImportSpecifier */ ? node.propertyName || node.name : node.name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(node, message, name),
|
|
isType ? void 0 : typeOnlyAlias,
|
|
name
|
|
);
|
|
}
|
|
if (isType && node.kind === 268 /* ImportEqualsDeclaration */ && hasEffectiveModifier(node, 1 /* Export */)) {
|
|
error(node, Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided);
|
|
}
|
|
break;
|
|
}
|
|
case 278 /* ExportSpecifier */: {
|
|
if (getSourceFileOfNode(typeOnlyAlias) !== getSourceFileOfNode(node)) {
|
|
const message = isType ? Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type : Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled;
|
|
const name = idText(node.propertyName || node.name);
|
|
addTypeOnlyDeclarationRelatedInfo(
|
|
error(node, message, name),
|
|
isType ? void 0 : typeOnlyAlias,
|
|
name
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isImportSpecifier(node)) {
|
|
const targetSymbol = checkDeprecatedAliasedSymbol(symbol, node);
|
|
if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) {
|
|
addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isDeprecatedAliasedSymbol(symbol) {
|
|
return !!symbol.declarations && every(symbol.declarations, (d) => !!(getCombinedNodeFlags(d) & 268435456 /* Deprecated */));
|
|
}
|
|
function checkDeprecatedAliasedSymbol(symbol, location2) {
|
|
if (!(symbol.flags & 2097152 /* Alias */))
|
|
return symbol;
|
|
const targetSymbol = resolveAlias(symbol);
|
|
if (targetSymbol === unknownSymbol)
|
|
return targetSymbol;
|
|
while (symbol.flags & 2097152 /* Alias */) {
|
|
const target = getImmediateAliasedSymbol(symbol);
|
|
if (target) {
|
|
if (target === targetSymbol)
|
|
break;
|
|
if (target.declarations && length(target.declarations)) {
|
|
if (isDeprecatedAliasedSymbol(target)) {
|
|
addDeprecatedSuggestion(location2, target.declarations, target.escapedName);
|
|
break;
|
|
} else {
|
|
if (symbol === targetSymbol)
|
|
break;
|
|
symbol = target;
|
|
}
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return targetSymbol;
|
|
}
|
|
function checkImportBinding(node) {
|
|
checkCollisionsForDeclarationName(node, node.name);
|
|
checkAliasSymbol(node);
|
|
if (node.kind === 273 /* ImportSpecifier */ && idText(node.propertyName || node.name) === "default" && getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
|
|
}
|
|
}
|
|
function checkAssertClause(declaration) {
|
|
var _a2;
|
|
if (declaration.assertClause) {
|
|
const validForTypeAssertions = isExclusivelyTypeOnlyImportOrExport(declaration);
|
|
const override = getResolutionModeOverrideForClause(declaration.assertClause, validForTypeAssertions ? grammarErrorOnNode : void 0);
|
|
if (validForTypeAssertions && override) {
|
|
if (!isNightly()) {
|
|
grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next);
|
|
}
|
|
if (getEmitModuleResolutionKind(compilerOptions) !== 3 /* Node16 */ && getEmitModuleResolutionKind(compilerOptions) !== 99 /* NodeNext */) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext);
|
|
}
|
|
return;
|
|
}
|
|
const mode = moduleKind === 199 /* NodeNext */ && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier);
|
|
if (mode !== 99 /* ESNext */ && moduleKind !== 99 /* ESNext */) {
|
|
return grammarErrorOnNode(
|
|
declaration.assertClause,
|
|
moduleKind === 199 /* NodeNext */ ? Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls : Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext
|
|
);
|
|
}
|
|
if (isImportDeclaration(declaration) ? (_a2 = declaration.importClause) == null ? void 0 : _a2.isTypeOnly : declaration.isTypeOnly) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports);
|
|
}
|
|
if (override) {
|
|
return grammarErrorOnNode(declaration.assertClause, Diagnostics.resolution_mode_can_only_be_set_for_type_only_imports);
|
|
}
|
|
}
|
|
}
|
|
function checkImportDeclaration(node) {
|
|
if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_import_declaration_cannot_have_modifiers);
|
|
}
|
|
if (checkExternalImportOrExportDeclaration(node)) {
|
|
const importClause = node.importClause;
|
|
if (importClause && !checkGrammarImportClause(importClause)) {
|
|
if (importClause.name) {
|
|
checkImportBinding(importClause);
|
|
}
|
|
if (importClause.namedBindings) {
|
|
if (importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
checkImportBinding(importClause.namedBindings);
|
|
if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && getESModuleInterop(compilerOptions)) {
|
|
checkExternalEmitHelpers(node, 65536 /* ImportStar */);
|
|
}
|
|
} else {
|
|
const moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (moduleExisted) {
|
|
forEach(importClause.namedBindings.elements, checkImportBinding);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkAssertClause(node);
|
|
}
|
|
function checkImportEqualsDeclaration(node) {
|
|
if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
checkGrammarDecoratorsAndModifiers(node);
|
|
if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
|
|
checkImportBinding(node);
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
markExportAsReferenced(node);
|
|
}
|
|
if (node.moduleReference.kind !== 280 /* ExternalModuleReference */) {
|
|
const target = resolveAlias(getSymbolOfNode(node));
|
|
if (target !== unknownSymbol) {
|
|
const targetFlags = getAllSymbolFlags(target);
|
|
if (targetFlags & 111551 /* Value */) {
|
|
const moduleName = getFirstIdentifier(node.moduleReference);
|
|
if (!(resolveEntityName(moduleName, 111551 /* Value */ | 1920 /* Namespace */).flags & 1920 /* Namespace */)) {
|
|
error(moduleName, Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, declarationNameToString(moduleName));
|
|
}
|
|
}
|
|
if (targetFlags & 788968 /* Type */) {
|
|
checkTypeNameIsReserved(node.name, Diagnostics.Import_name_cannot_be_0);
|
|
}
|
|
}
|
|
if (node.isTypeOnly) {
|
|
grammarErrorOnNode(node, Diagnostics.An_import_alias_cannot_use_import_type);
|
|
}
|
|
} else {
|
|
if (moduleKind >= 5 /* ES2015 */ && getSourceFileOfNode(node).impliedNodeFormat === void 0 && !node.isTypeOnly && !(node.flags & 16777216 /* Ambient */)) {
|
|
grammarErrorOnNode(node, 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkExportDeclaration(node) {
|
|
if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasSyntacticModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_export_declaration_cannot_have_modifiers);
|
|
}
|
|
if (node.moduleSpecifier && node.exportClause && isNamedExports(node.exportClause) && length(node.exportClause.elements) && languageVersion === 0 /* ES3 */) {
|
|
checkExternalEmitHelpers(node, 4194304 /* CreateBinding */);
|
|
}
|
|
checkGrammarExportDeclaration(node);
|
|
if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) {
|
|
if (node.exportClause && !isNamespaceExport(node.exportClause)) {
|
|
forEach(node.exportClause.elements, checkExportSpecifier);
|
|
const inAmbientExternalModule = node.parent.kind === 265 /* ModuleBlock */ && isAmbientModule(node.parent.parent);
|
|
const inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 265 /* ModuleBlock */ && !node.moduleSpecifier && node.flags & 16777216 /* Ambient */;
|
|
if (node.parent.kind !== 308 /* SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) {
|
|
error(node, Diagnostics.Export_declarations_are_not_permitted_in_a_namespace);
|
|
}
|
|
} else {
|
|
const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);
|
|
if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) {
|
|
error(node.moduleSpecifier, Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol));
|
|
} else if (node.exportClause) {
|
|
checkAliasSymbol(node.exportClause);
|
|
}
|
|
if (moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */)) {
|
|
if (node.exportClause) {
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
checkExternalEmitHelpers(node, 65536 /* ImportStar */);
|
|
}
|
|
} else {
|
|
checkExternalEmitHelpers(node, 32768 /* ExportStar */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
checkAssertClause(node);
|
|
}
|
|
function checkGrammarExportDeclaration(node) {
|
|
var _a2;
|
|
if (node.isTypeOnly) {
|
|
if (((_a2 = node.exportClause) == null ? void 0 : _a2.kind) === 276 /* NamedExports */) {
|
|
return checkGrammarNamedImportsOrExports(node.exportClause);
|
|
} else {
|
|
return grammarErrorOnNode(node, Diagnostics.Only_named_exports_may_use_export_type);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarModuleElementContext(node, errorMessage) {
|
|
const isInAppropriateContext = node.parent.kind === 308 /* SourceFile */ || node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 264 /* ModuleDeclaration */;
|
|
if (!isInAppropriateContext) {
|
|
grammarErrorOnFirstToken(node, errorMessage);
|
|
}
|
|
return !isInAppropriateContext;
|
|
}
|
|
function importClauseContainsReferencedImport(importClause) {
|
|
return forEachImportClauseDeclaration(importClause, (declaration) => {
|
|
return !!getSymbolOfNode(declaration).isReferenced;
|
|
});
|
|
}
|
|
function importClauseContainsConstEnumUsedAsValue(importClause) {
|
|
return forEachImportClauseDeclaration(importClause, (declaration) => {
|
|
return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced;
|
|
});
|
|
}
|
|
function canConvertImportDeclarationToTypeOnly(statement) {
|
|
return isImportDeclaration(statement) && statement.importClause && !statement.importClause.isTypeOnly && importClauseContainsReferencedImport(statement.importClause) && !isReferencedAliasDeclaration(statement.importClause, true) && !importClauseContainsConstEnumUsedAsValue(statement.importClause);
|
|
}
|
|
function canConvertImportEqualsDeclarationToTypeOnly(statement) {
|
|
return isImportEqualsDeclaration(statement) && isExternalModuleReference(statement.moduleReference) && !statement.isTypeOnly && getSymbolOfNode(statement).isReferenced && !isReferencedAliasDeclaration(statement, false) && !getSymbolLinks(getSymbolOfNode(statement)).constEnumReferenced;
|
|
}
|
|
function checkImportsForTypeOnlyConversion(sourceFile) {
|
|
for (const statement of sourceFile.statements) {
|
|
if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) {
|
|
error(
|
|
statement,
|
|
Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function checkExportSpecifier(node) {
|
|
checkAliasSymbol(node);
|
|
if (getEmitDeclarations(compilerOptions)) {
|
|
collectLinkedAliases(node.propertyName || node.name, true);
|
|
}
|
|
if (!node.parent.parent.moduleSpecifier) {
|
|
const exportedName = node.propertyName || node.name;
|
|
const symbol = resolveName(
|
|
exportedName,
|
|
exportedName.escapedText,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
|
|
void 0,
|
|
void 0,
|
|
true
|
|
);
|
|
if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
|
|
error(exportedName, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, idText(exportedName));
|
|
} else {
|
|
if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
|
|
markExportAsReferenced(node);
|
|
}
|
|
const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
|
|
if (!target || getAllSymbolFlags(target) & 111551 /* Value */) {
|
|
checkExpressionCached(node.propertyName || node.name);
|
|
}
|
|
}
|
|
} else {
|
|
if (getESModuleInterop(compilerOptions) && moduleKind !== 4 /* System */ && (moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && idText(node.propertyName || node.name) === "default") {
|
|
checkExternalEmitHelpers(node, 131072 /* ImportDefault */);
|
|
}
|
|
}
|
|
}
|
|
function checkExportAssignment(node) {
|
|
const illegalContextMessage = node.isExportEquals ? Diagnostics.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration : Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration;
|
|
if (checkGrammarModuleElementContext(node, illegalContextMessage)) {
|
|
return;
|
|
}
|
|
const container = node.parent.kind === 308 /* SourceFile */ ? node.parent : node.parent.parent;
|
|
if (container.kind === 264 /* ModuleDeclaration */ && !isAmbientModule(container)) {
|
|
if (node.isExportEquals) {
|
|
error(node, Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace);
|
|
} else {
|
|
error(node, Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
|
|
}
|
|
return;
|
|
}
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && hasEffectiveModifiers(node)) {
|
|
grammarErrorOnFirstToken(node, Diagnostics.An_export_assignment_cannot_have_modifiers);
|
|
}
|
|
const typeAnnotationNode = getEffectiveTypeAnnotationNode(node);
|
|
if (typeAnnotationNode) {
|
|
checkTypeAssignableTo(checkExpressionCached(node.expression), getTypeFromTypeNode(typeAnnotationNode), node.expression);
|
|
}
|
|
if (node.expression.kind === 79 /* Identifier */) {
|
|
const id = node.expression;
|
|
const sym = resolveEntityName(id, 67108863 /* All */, true, true, node);
|
|
if (sym) {
|
|
markAliasReferenced(sym, id);
|
|
const target = sym.flags & 2097152 /* Alias */ ? resolveAlias(sym) : sym;
|
|
if (getAllSymbolFlags(target) & 111551 /* Value */) {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
} else {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
if (getEmitDeclarations(compilerOptions)) {
|
|
collectLinkedAliases(node.expression, true);
|
|
}
|
|
} else {
|
|
checkExpressionCached(node.expression);
|
|
}
|
|
checkExternalModuleExports(container);
|
|
if (node.flags & 16777216 /* Ambient */ && !isEntityNameExpression(node.expression)) {
|
|
grammarErrorOnNode(node.expression, Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context);
|
|
}
|
|
if (node.isExportEquals && !(node.flags & 16777216 /* Ambient */)) {
|
|
if (moduleKind >= 5 /* ES2015 */ && getSourceFileOfNode(node).impliedNodeFormat !== 1 /* CommonJS */) {
|
|
grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead);
|
|
} else if (moduleKind === 4 /* System */) {
|
|
grammarErrorOnNode(node, Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system);
|
|
}
|
|
}
|
|
}
|
|
function hasExportedMembers(moduleSymbol) {
|
|
return forEachEntry(moduleSymbol.exports, (_, id) => id !== "export=");
|
|
}
|
|
function checkExternalModuleExports(node) {
|
|
const moduleSymbol = getSymbolOfNode(node);
|
|
const links = getSymbolLinks(moduleSymbol);
|
|
if (!links.exportsChecked) {
|
|
const exportEqualsSymbol = moduleSymbol.exports.get("export=");
|
|
if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) {
|
|
const declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration;
|
|
if (declaration && !isTopLevelInExternalModuleAugmentation(declaration) && !isInJSFile(declaration)) {
|
|
error(declaration, Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
|
|
}
|
|
}
|
|
const exports = getExportsOfModule(moduleSymbol);
|
|
if (exports) {
|
|
exports.forEach(({ declarations, flags }, id) => {
|
|
if (id === "__export") {
|
|
return;
|
|
}
|
|
if (flags & (1920 /* Namespace */ | 384 /* Enum */)) {
|
|
return;
|
|
}
|
|
const exportedDeclarationsCount = countWhere(declarations, and(isNotOverloadAndNotAccessor, not(isInterfaceDeclaration)));
|
|
if (flags & 524288 /* TypeAlias */ && exportedDeclarationsCount <= 2) {
|
|
return;
|
|
}
|
|
if (exportedDeclarationsCount > 1) {
|
|
if (!isDuplicatedCommonJSExport(declarations)) {
|
|
for (const declaration of declarations) {
|
|
if (isNotOverload(declaration)) {
|
|
diagnostics.add(createDiagnosticForNode(declaration, Diagnostics.Cannot_redeclare_exported_variable_0, unescapeLeadingUnderscores(id)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
links.exportsChecked = true;
|
|
}
|
|
}
|
|
function isDuplicatedCommonJSExport(declarations) {
|
|
return declarations && declarations.length > 1 && declarations.every((d) => isInJSFile(d) && isAccessExpression(d) && (isExportsIdentifier(d.expression) || isModuleExportsAccessExpression(d.expression)));
|
|
}
|
|
function checkSourceElement(node) {
|
|
if (node) {
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
checkSourceElementWorker(node);
|
|
currentNode = saveCurrentNode;
|
|
}
|
|
}
|
|
function checkSourceElementWorker(node) {
|
|
forEach(node.jsDoc, ({ comment, tags }) => {
|
|
checkJSDocCommentWorker(comment);
|
|
forEach(tags, (tag) => {
|
|
checkJSDocCommentWorker(tag.comment);
|
|
if (isInJSFile(node)) {
|
|
checkSourceElement(tag);
|
|
}
|
|
});
|
|
});
|
|
const kind = node.kind;
|
|
if (cancellationToken) {
|
|
switch (kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
if (kind >= 240 /* FirstStatement */ && kind <= 256 /* LastStatement */ && node.flowNode && !isReachableFlowNode(node.flowNode)) {
|
|
errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, Diagnostics.Unreachable_code_detected);
|
|
}
|
|
switch (kind) {
|
|
case 165 /* TypeParameter */:
|
|
return checkTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return checkParameter(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return checkPropertyDeclaration(node);
|
|
case 168 /* PropertySignature */:
|
|
return checkPropertySignature(node);
|
|
case 182 /* ConstructorType */:
|
|
case 181 /* FunctionType */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 178 /* IndexSignature */:
|
|
return checkSignatureDeclaration(node);
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return checkMethodDeclaration(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return checkClassStaticBlockDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return checkConstructorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return checkAccessorDeclaration(node);
|
|
case 180 /* TypeReference */:
|
|
return checkTypeReferenceNode(node);
|
|
case 179 /* TypePredicate */:
|
|
return checkTypePredicate(node);
|
|
case 183 /* TypeQuery */:
|
|
return checkTypeQuery(node);
|
|
case 184 /* TypeLiteral */:
|
|
return checkTypeLiteral(node);
|
|
case 185 /* ArrayType */:
|
|
return checkArrayType(node);
|
|
case 186 /* TupleType */:
|
|
return checkTupleType(node);
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
return checkUnionOrIntersectionType(node);
|
|
case 193 /* ParenthesizedType */:
|
|
case 187 /* OptionalType */:
|
|
case 188 /* RestType */:
|
|
return checkSourceElement(node.type);
|
|
case 194 /* ThisType */:
|
|
return checkThisType(node);
|
|
case 195 /* TypeOperator */:
|
|
return checkTypeOperator(node);
|
|
case 191 /* ConditionalType */:
|
|
return checkConditionalType(node);
|
|
case 192 /* InferType */:
|
|
return checkInferType(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return checkTemplateLiteralType(node);
|
|
case 202 /* ImportType */:
|
|
return checkImportType(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return checkNamedTupleMember(node);
|
|
case 331 /* JSDocAugmentsTag */:
|
|
return checkJSDocAugmentsTag(node);
|
|
case 332 /* JSDocImplementsTag */:
|
|
return checkJSDocImplementsTag(node);
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
return checkJSDocTypeAliasTag(node);
|
|
case 347 /* JSDocTemplateTag */:
|
|
return checkJSDocTemplateTag(node);
|
|
case 346 /* JSDocTypeTag */:
|
|
return checkJSDocTypeTag(node);
|
|
case 327 /* JSDocLink */:
|
|
case 328 /* JSDocLinkCode */:
|
|
case 329 /* JSDocLinkPlain */:
|
|
return checkJSDocLinkLikeTag(node);
|
|
case 343 /* JSDocParameterTag */:
|
|
return checkJSDocParameterTag(node);
|
|
case 350 /* JSDocPropertyTag */:
|
|
return checkJSDocPropertyTag(node);
|
|
case 320 /* JSDocFunctionType */:
|
|
checkJSDocFunctionType(node);
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 317 /* JSDocNullableType */:
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
case 325 /* JSDocTypeLiteral */:
|
|
checkJSDocTypeIsInJsFile(node);
|
|
forEachChild(node, checkSourceElement);
|
|
return;
|
|
case 321 /* JSDocVariadicType */:
|
|
checkJSDocVariadicType(node);
|
|
return;
|
|
case 312 /* JSDocTypeExpression */:
|
|
return checkSourceElement(node.type);
|
|
case 336 /* JSDocPublicTag */:
|
|
case 338 /* JSDocProtectedTag */:
|
|
case 337 /* JSDocPrivateTag */:
|
|
return checkJSDocAccessibilityModifiers(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return checkIndexedAccessType(node);
|
|
case 197 /* MappedType */:
|
|
return checkMappedType(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return checkFunctionDeclaration(node);
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
return checkBlock(node);
|
|
case 240 /* VariableStatement */:
|
|
return checkVariableStatement(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return checkExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return checkIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return checkDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return checkWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return checkForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return checkForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return checkForOfStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
case 249 /* BreakStatement */:
|
|
return checkBreakOrContinueStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return checkReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return checkWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return checkSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return checkLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return checkThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return checkTryStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return checkVariableDeclaration(node);
|
|
case 205 /* BindingElement */:
|
|
return checkBindingElement(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return checkClassDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return checkInterfaceDeclaration(node);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return checkTypeAliasDeclaration(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return checkEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return checkModuleDeclaration(node);
|
|
case 269 /* ImportDeclaration */:
|
|
return checkImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return checkImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return checkExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return checkExportAssignment(node);
|
|
case 239 /* EmptyStatement */:
|
|
case 256 /* DebuggerStatement */:
|
|
checkGrammarStatementInAmbientContext(node);
|
|
return;
|
|
case 279 /* MissingDeclaration */:
|
|
return checkMissingDeclaration(node);
|
|
}
|
|
}
|
|
function checkJSDocCommentWorker(node) {
|
|
if (isArray(node)) {
|
|
forEach(node, (tag) => {
|
|
if (isJSDocLinkLike(tag)) {
|
|
checkSourceElement(tag);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function checkJSDocTypeIsInJsFile(node) {
|
|
if (!isInJSFile(node)) {
|
|
grammarErrorOnNode(node, Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
|
|
}
|
|
}
|
|
function checkJSDocVariadicType(node) {
|
|
checkJSDocTypeIsInJsFile(node);
|
|
checkSourceElement(node.type);
|
|
const { parent: parent2 } = node;
|
|
if (isParameter(parent2) && isJSDocFunctionType(parent2.parent)) {
|
|
if (last(parent2.parent.parameters) !== parent2) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
return;
|
|
}
|
|
if (!isJSDocTypeExpression(parent2)) {
|
|
error(node, Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
|
|
}
|
|
const paramTag = node.parent.parent;
|
|
if (!isJSDocParameterTag(paramTag)) {
|
|
error(node, Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature);
|
|
return;
|
|
}
|
|
const param = getParameterSymbolFromJSDoc(paramTag);
|
|
if (!param) {
|
|
return;
|
|
}
|
|
const host2 = getHostSignatureFromJSDoc(paramTag);
|
|
if (!host2 || last(host2.parameters).symbol !== param) {
|
|
error(node, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
}
|
|
function getTypeFromJSDocVariadicType(node) {
|
|
const type = getTypeFromTypeNode(node.type);
|
|
const { parent: parent2 } = node;
|
|
const paramTag = node.parent.parent;
|
|
if (isJSDocTypeExpression(node.parent) && isJSDocParameterTag(paramTag)) {
|
|
const host2 = getHostSignatureFromJSDoc(paramTag);
|
|
const isCallbackTag = isJSDocCallbackTag(paramTag.parent.parent);
|
|
if (host2 || isCallbackTag) {
|
|
const lastParamDeclaration = isCallbackTag ? lastOrUndefined(paramTag.parent.parent.typeExpression.parameters) : lastOrUndefined(host2.parameters);
|
|
const symbol = getParameterSymbolFromJSDoc(paramTag);
|
|
if (!lastParamDeclaration || symbol && lastParamDeclaration.symbol === symbol && isRestParameter(lastParamDeclaration)) {
|
|
return createArrayType(type);
|
|
}
|
|
}
|
|
}
|
|
if (isParameter(parent2) && isJSDocFunctionType(parent2.parent)) {
|
|
return createArrayType(type);
|
|
}
|
|
return addOptionality(type);
|
|
}
|
|
function checkNodeDeferred(node) {
|
|
const enclosingFile = getSourceFileOfNode(node);
|
|
const links = getNodeLinks(enclosingFile);
|
|
if (!(links.flags & 1 /* TypeChecked */)) {
|
|
links.deferredNodes || (links.deferredNodes = /* @__PURE__ */ new Set());
|
|
links.deferredNodes.add(node);
|
|
}
|
|
}
|
|
function checkDeferredNodes(context) {
|
|
const links = getNodeLinks(context);
|
|
if (links.deferredNodes) {
|
|
links.deferredNodes.forEach(checkDeferredNode);
|
|
}
|
|
}
|
|
function checkDeferredNode(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath });
|
|
const saveCurrentNode = currentNode;
|
|
currentNode = node;
|
|
instantiationCount = 0;
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 167 /* Decorator */:
|
|
case 283 /* JsxOpeningElement */:
|
|
resolveUntypedCall(node);
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
checkFunctionExpressionOrObjectLiteralMethodDeferred(node);
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
checkAccessorDeclaration(node);
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
checkClassExpressionDeferred(node);
|
|
break;
|
|
case 165 /* TypeParameter */:
|
|
checkTypeParameterDeferred(node);
|
|
break;
|
|
case 282 /* JsxSelfClosingElement */:
|
|
checkJsxSelfClosingElementDeferred(node);
|
|
break;
|
|
case 281 /* JsxElement */:
|
|
checkJsxElementDeferred(node);
|
|
break;
|
|
}
|
|
currentNode = saveCurrentNode;
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function checkSourceFile(node) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Check, "checkSourceFile", { path: node.path }, true);
|
|
mark("beforeCheck");
|
|
checkSourceFileWorker(node);
|
|
mark("afterCheck");
|
|
measure("Check", "beforeCheck", "afterCheck");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
function unusedIsError(kind, isAmbient) {
|
|
if (isAmbient) {
|
|
return false;
|
|
}
|
|
switch (kind) {
|
|
case 0 /* Local */:
|
|
return !!compilerOptions.noUnusedLocals;
|
|
case 1 /* Parameter */:
|
|
return !!compilerOptions.noUnusedParameters;
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function getPotentiallyUnusedIdentifiers(sourceFile) {
|
|
return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || emptyArray;
|
|
}
|
|
function checkSourceFileWorker(node) {
|
|
const links = getNodeLinks(node);
|
|
if (!(links.flags & 1 /* TypeChecked */)) {
|
|
if (skipTypeChecking(node, compilerOptions, host)) {
|
|
return;
|
|
}
|
|
checkGrammarSourceFile(node);
|
|
clear(potentialThisCollisions);
|
|
clear(potentialNewTargetCollisions);
|
|
clear(potentialWeakMapSetCollisions);
|
|
clear(potentialReflectCollisions);
|
|
clear(potentialUnusedRenamedBindingElementsInTypes);
|
|
forEach(node.statements, checkSourceElement);
|
|
checkSourceElement(node.endOfFileToken);
|
|
checkDeferredNodes(node);
|
|
if (isExternalOrCommonJsModule(node)) {
|
|
registerForUnusedIdentifiersCheck(node);
|
|
}
|
|
addLazyDiagnostic(() => {
|
|
if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) {
|
|
checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), (containingNode, kind, diag2) => {
|
|
if (!containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 16777216 /* Ambient */))) {
|
|
diagnostics.add(diag2);
|
|
}
|
|
});
|
|
}
|
|
if (!node.isDeclarationFile) {
|
|
checkPotentialUncheckedRenamedBindingElementsInTypes();
|
|
}
|
|
});
|
|
if (compilerOptions.importsNotUsedAsValues === 2 /* Error */ && !node.isDeclarationFile && isExternalModule(node)) {
|
|
checkImportsForTypeOnlyConversion(node);
|
|
}
|
|
if (isExternalOrCommonJsModule(node)) {
|
|
checkExternalModuleExports(node);
|
|
}
|
|
if (potentialThisCollisions.length) {
|
|
forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope);
|
|
clear(potentialThisCollisions);
|
|
}
|
|
if (potentialNewTargetCollisions.length) {
|
|
forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope);
|
|
clear(potentialNewTargetCollisions);
|
|
}
|
|
if (potentialWeakMapSetCollisions.length) {
|
|
forEach(potentialWeakMapSetCollisions, checkWeakMapSetCollision);
|
|
clear(potentialWeakMapSetCollisions);
|
|
}
|
|
if (potentialReflectCollisions.length) {
|
|
forEach(potentialReflectCollisions, checkReflectCollision);
|
|
clear(potentialReflectCollisions);
|
|
}
|
|
links.flags |= 1 /* TypeChecked */;
|
|
}
|
|
}
|
|
function getDiagnostics2(sourceFile, ct) {
|
|
try {
|
|
cancellationToken = ct;
|
|
return getDiagnosticsWorker(sourceFile);
|
|
} finally {
|
|
cancellationToken = void 0;
|
|
}
|
|
}
|
|
function ensurePendingDiagnosticWorkComplete() {
|
|
for (const cb of deferredDiagnosticsCallbacks) {
|
|
cb();
|
|
}
|
|
deferredDiagnosticsCallbacks = [];
|
|
}
|
|
function checkSourceFileWithEagerDiagnostics(sourceFile) {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
const oldAddLazyDiagnostics = addLazyDiagnostic;
|
|
addLazyDiagnostic = (cb) => cb();
|
|
checkSourceFile(sourceFile);
|
|
addLazyDiagnostic = oldAddLazyDiagnostics;
|
|
}
|
|
function getDiagnosticsWorker(sourceFile) {
|
|
if (sourceFile) {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
const previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
|
|
const previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length;
|
|
checkSourceFileWithEagerDiagnostics(sourceFile);
|
|
const semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName);
|
|
const currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics();
|
|
if (currentGlobalDiagnostics !== previousGlobalDiagnostics) {
|
|
const deferredGlobalDiagnostics = relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, compareDiagnostics);
|
|
return concatenate(deferredGlobalDiagnostics, semanticDiagnostics);
|
|
} else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) {
|
|
return concatenate(currentGlobalDiagnostics, semanticDiagnostics);
|
|
}
|
|
return semanticDiagnostics;
|
|
}
|
|
forEach(host.getSourceFiles(), checkSourceFileWithEagerDiagnostics);
|
|
return diagnostics.getDiagnostics();
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
ensurePendingDiagnosticWorkComplete();
|
|
return diagnostics.getGlobalDiagnostics();
|
|
}
|
|
function getSymbolsInScope(location2, meaning) {
|
|
if (location2.flags & 33554432 /* InWithStatement */) {
|
|
return [];
|
|
}
|
|
const symbols = createSymbolTable();
|
|
let isStaticSymbol = false;
|
|
populateSymbols();
|
|
symbols.delete("this" /* This */);
|
|
return symbolsToArray(symbols);
|
|
function populateSymbols() {
|
|
while (location2) {
|
|
if (location2.locals && !isGlobalSourceFile(location2)) {
|
|
copySymbols(location2.locals, meaning);
|
|
}
|
|
switch (location2.kind) {
|
|
case 308 /* SourceFile */:
|
|
if (!isExternalModule(location2))
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
copyLocallyVisibleExportSymbols(getSymbolOfNode(location2).exports, meaning & 2623475 /* ModuleMember */);
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
copySymbols(getSymbolOfNode(location2).exports, meaning & 8 /* EnumMember */);
|
|
break;
|
|
case 228 /* ClassExpression */:
|
|
const className = location2.name;
|
|
if (className) {
|
|
copySymbol(location2.symbol, meaning);
|
|
}
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
if (!isStaticSymbol) {
|
|
copySymbols(getMembersOfSymbol(getSymbolOfNode(location2)), meaning & 788968 /* Type */);
|
|
}
|
|
break;
|
|
case 215 /* FunctionExpression */:
|
|
const funcName = location2.name;
|
|
if (funcName) {
|
|
copySymbol(location2.symbol, meaning);
|
|
}
|
|
break;
|
|
}
|
|
if (introducesArgumentsExoticObject(location2)) {
|
|
copySymbol(argumentsSymbol, meaning);
|
|
}
|
|
isStaticSymbol = isStatic(location2);
|
|
location2 = location2.parent;
|
|
}
|
|
copySymbols(globals, meaning);
|
|
}
|
|
function copySymbol(symbol, meaning2) {
|
|
if (getCombinedLocalAndExportSymbolFlags(symbol) & meaning2) {
|
|
const id = symbol.escapedName;
|
|
if (!symbols.has(id)) {
|
|
symbols.set(id, symbol);
|
|
}
|
|
}
|
|
}
|
|
function copySymbols(source, meaning2) {
|
|
if (meaning2) {
|
|
source.forEach((symbol) => {
|
|
copySymbol(symbol, meaning2);
|
|
});
|
|
}
|
|
}
|
|
function copyLocallyVisibleExportSymbols(source, meaning2) {
|
|
if (meaning2) {
|
|
source.forEach((symbol) => {
|
|
if (!getDeclarationOfKind(symbol, 278 /* ExportSpecifier */) && !getDeclarationOfKind(symbol, 277 /* NamespaceExport */)) {
|
|
copySymbol(symbol, meaning2);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function isTypeDeclarationName(name) {
|
|
return name.kind === 79 /* Identifier */ && isTypeDeclaration(name.parent) && getNameOfDeclaration(name.parent) === name;
|
|
}
|
|
function isTypeReferenceIdentifier(node) {
|
|
while (node.parent.kind === 163 /* QualifiedName */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 180 /* TypeReference */;
|
|
}
|
|
function isHeritageClauseElementIdentifier(node) {
|
|
while (node.parent.kind === 208 /* PropertyAccessExpression */) {
|
|
node = node.parent;
|
|
}
|
|
return node.parent.kind === 230 /* ExpressionWithTypeArguments */;
|
|
}
|
|
function forEachEnclosingClass(node, callback) {
|
|
let result;
|
|
while (true) {
|
|
node = getContainingClass(node);
|
|
if (!node)
|
|
break;
|
|
if (result = callback(node))
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
function isNodeUsedDuringClassInitialization(node) {
|
|
return !!findAncestor(node, (element) => {
|
|
if (isConstructorDeclaration(element) && nodeIsPresent(element.body) || isPropertyDeclaration(element)) {
|
|
return true;
|
|
} else if (isClassLike(element) || isFunctionLikeDeclaration(element)) {
|
|
return "quit";
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
function isNodeWithinClass(node, classDeclaration) {
|
|
return !!forEachEnclosingClass(node, (n) => n === classDeclaration);
|
|
}
|
|
function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) {
|
|
while (nodeOnRightSide.parent.kind === 163 /* QualifiedName */) {
|
|
nodeOnRightSide = nodeOnRightSide.parent;
|
|
}
|
|
if (nodeOnRightSide.parent.kind === 268 /* ImportEqualsDeclaration */) {
|
|
return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : void 0;
|
|
}
|
|
if (nodeOnRightSide.parent.kind === 274 /* ExportAssignment */) {
|
|
return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isInRightSideOfImportOrExportAssignment(node) {
|
|
return getLeftSideOfImportEqualsOrExportAssignment(node) !== void 0;
|
|
}
|
|
function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) {
|
|
const specialPropertyAssignmentKind = getAssignmentDeclarationKind(entityName.parent.parent);
|
|
switch (specialPropertyAssignmentKind) {
|
|
case 1 /* ExportsProperty */:
|
|
case 3 /* PrototypeProperty */:
|
|
return getSymbolOfNode(entityName.parent);
|
|
case 4 /* ThisProperty */:
|
|
case 2 /* ModuleExports */:
|
|
case 5 /* Property */:
|
|
return getSymbolOfNode(entityName.parent.parent);
|
|
}
|
|
}
|
|
function isImportTypeQualifierPart(node) {
|
|
let parent2 = node.parent;
|
|
while (isQualifiedName(parent2)) {
|
|
node = parent2;
|
|
parent2 = parent2.parent;
|
|
}
|
|
if (parent2 && parent2.kind === 202 /* ImportType */ && parent2.qualifier === node) {
|
|
return parent2;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSymbolOfNameOrPropertyAccessExpression(name) {
|
|
if (isDeclarationName(name)) {
|
|
return getSymbolOfNode(name.parent);
|
|
}
|
|
if (isInJSFile(name) && name.parent.kind === 208 /* PropertyAccessExpression */ && name.parent === name.parent.parent.left) {
|
|
if (!isPrivateIdentifier(name) && !isJSDocMemberName(name)) {
|
|
const specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name);
|
|
if (specialPropertyAssignmentSymbol) {
|
|
return specialPropertyAssignmentSymbol;
|
|
}
|
|
}
|
|
}
|
|
if (name.parent.kind === 274 /* ExportAssignment */ && isEntityNameExpression(name)) {
|
|
const success = resolveEntityName(
|
|
name,
|
|
111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
|
|
true
|
|
);
|
|
if (success && success !== unknownSymbol) {
|
|
return success;
|
|
}
|
|
} else if (isEntityName(name) && isInRightSideOfImportOrExportAssignment(name)) {
|
|
const importEqualsDeclaration = getAncestor(name, 268 /* ImportEqualsDeclaration */);
|
|
Debug.assert(importEqualsDeclaration !== void 0);
|
|
return getSymbolOfPartOfRightHandSideOfImportEquals(name, true);
|
|
}
|
|
if (isEntityName(name)) {
|
|
const possibleImportNode = isImportTypeQualifierPart(name);
|
|
if (possibleImportNode) {
|
|
getTypeFromTypeNode(possibleImportNode);
|
|
const sym = getNodeLinks(name).resolvedSymbol;
|
|
return sym === unknownSymbol ? void 0 : sym;
|
|
}
|
|
}
|
|
while (isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(name)) {
|
|
name = name.parent;
|
|
}
|
|
if (isHeritageClauseElementIdentifier(name)) {
|
|
let meaning = 0 /* None */;
|
|
if (name.parent.kind === 230 /* ExpressionWithTypeArguments */) {
|
|
meaning = 788968 /* Type */;
|
|
if (isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) {
|
|
meaning |= 111551 /* Value */;
|
|
}
|
|
} else {
|
|
meaning = 1920 /* Namespace */;
|
|
}
|
|
meaning |= 2097152 /* Alias */;
|
|
const entityNameSymbol = isEntityNameExpression(name) ? resolveEntityName(name, meaning) : void 0;
|
|
if (entityNameSymbol) {
|
|
return entityNameSymbol;
|
|
}
|
|
}
|
|
if (name.parent.kind === 343 /* JSDocParameterTag */) {
|
|
return getParameterSymbolFromJSDoc(name.parent);
|
|
}
|
|
if (name.parent.kind === 165 /* TypeParameter */ && name.parent.parent.kind === 347 /* JSDocTemplateTag */) {
|
|
Debug.assert(!isInJSFile(name));
|
|
const typeParameter = getTypeParameterFromJsDoc(name.parent);
|
|
return typeParameter && typeParameter.symbol;
|
|
}
|
|
if (isExpressionNode(name)) {
|
|
if (nodeIsMissing(name)) {
|
|
return void 0;
|
|
}
|
|
const isJSDoc2 = findAncestor(name, or(isJSDocLinkLike, isJSDocNameReference, isJSDocMemberName));
|
|
const meaning = isJSDoc2 ? 788968 /* Type */ | 1920 /* Namespace */ | 111551 /* Value */ : 111551 /* Value */;
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) {
|
|
const symbol = getIntrinsicTagSymbol(name.parent);
|
|
return symbol === unknownSymbol ? void 0 : symbol;
|
|
}
|
|
const result = resolveEntityName(name, meaning, false, true, getHostSignatureFromJSDoc(name));
|
|
if (!result && isJSDoc2) {
|
|
const container = findAncestor(name, or(isClassLike, isInterfaceDeclaration));
|
|
if (container) {
|
|
return resolveJSDocMemberName(name, false, getSymbolOfNode(container));
|
|
}
|
|
}
|
|
if (result && isJSDoc2) {
|
|
const container = getJSDocHost(name);
|
|
if (container && isEnumMember(container) && container === result.valueDeclaration) {
|
|
return resolveEntityName(name, meaning, true, true, getSourceFileOfNode(container)) || result;
|
|
}
|
|
}
|
|
return result;
|
|
} else if (isPrivateIdentifier(name)) {
|
|
return getSymbolForPrivateIdentifierExpression(name);
|
|
} else if (name.kind === 208 /* PropertyAccessExpression */ || name.kind === 163 /* QualifiedName */) {
|
|
const links = getNodeLinks(name);
|
|
if (links.resolvedSymbol) {
|
|
return links.resolvedSymbol;
|
|
}
|
|
if (name.kind === 208 /* PropertyAccessExpression */) {
|
|
checkPropertyAccessExpression(name, 0 /* Normal */);
|
|
if (!links.resolvedSymbol) {
|
|
const expressionType = checkExpressionCached(name.expression);
|
|
const infos = getApplicableIndexInfos(expressionType, getLiteralTypeFromPropertyName(name.name));
|
|
if (infos.length && expressionType.members) {
|
|
const resolved = resolveStructuredTypeMembers(expressionType);
|
|
const symbol = resolved.members.get("__index" /* Index */);
|
|
if (infos === getIndexInfosOfType(expressionType)) {
|
|
links.resolvedSymbol = symbol;
|
|
} else if (symbol) {
|
|
const symbolLinks2 = getSymbolLinks(symbol);
|
|
const declarationList = mapDefined(infos, (i) => i.declaration);
|
|
const nodeListId = map(declarationList, getNodeId).join(",");
|
|
if (!symbolLinks2.filteredIndexSymbolCache) {
|
|
symbolLinks2.filteredIndexSymbolCache = /* @__PURE__ */ new Map();
|
|
}
|
|
if (symbolLinks2.filteredIndexSymbolCache.has(nodeListId)) {
|
|
links.resolvedSymbol = symbolLinks2.filteredIndexSymbolCache.get(nodeListId);
|
|
} else {
|
|
const copy = createSymbol(131072 /* Signature */, "__index" /* Index */);
|
|
copy.declarations = mapDefined(infos, (i) => i.declaration);
|
|
copy.parent = expressionType.aliasSymbol ? expressionType.aliasSymbol : expressionType.symbol ? expressionType.symbol : getSymbolAtLocation(copy.declarations[0].parent);
|
|
symbolLinks2.filteredIndexSymbolCache.set(nodeListId, copy);
|
|
links.resolvedSymbol = symbolLinks2.filteredIndexSymbolCache.get(nodeListId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
checkQualifiedName(name, 0 /* Normal */);
|
|
}
|
|
if (!links.resolvedSymbol && isJSDoc2 && isQualifiedName(name)) {
|
|
return resolveJSDocMemberName(name);
|
|
}
|
|
return links.resolvedSymbol;
|
|
} else if (isJSDocMemberName(name)) {
|
|
return resolveJSDocMemberName(name);
|
|
}
|
|
} else if (isTypeReferenceIdentifier(name)) {
|
|
const meaning = name.parent.kind === 180 /* TypeReference */ ? 788968 /* Type */ : 1920 /* Namespace */;
|
|
const symbol = resolveEntityName(name, meaning, false, true);
|
|
return symbol && symbol !== unknownSymbol ? symbol : getUnresolvedSymbolForEntityName(name);
|
|
}
|
|
if (name.parent.kind === 179 /* TypePredicate */) {
|
|
return resolveEntityName(name, 1 /* FunctionScopedVariable */);
|
|
}
|
|
return void 0;
|
|
}
|
|
function resolveJSDocMemberName(name, ignoreErrors, container) {
|
|
if (isEntityName(name)) {
|
|
const meaning = 788968 /* Type */ | 1920 /* Namespace */ | 111551 /* Value */;
|
|
let symbol = resolveEntityName(name, meaning, ignoreErrors, true, getHostSignatureFromJSDoc(name));
|
|
if (!symbol && isIdentifier(name) && container) {
|
|
symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(container), name.escapedText, meaning));
|
|
}
|
|
if (symbol) {
|
|
return symbol;
|
|
}
|
|
}
|
|
const left = isIdentifier(name) ? container : resolveJSDocMemberName(name.left, ignoreErrors, container);
|
|
const right = isIdentifier(name) ? name.escapedText : name.right.escapedText;
|
|
if (left) {
|
|
const proto = left.flags & 111551 /* Value */ && getPropertyOfType(getTypeOfSymbol(left), "prototype");
|
|
const t = proto ? getTypeOfSymbol(proto) : getDeclaredTypeOfSymbol(left);
|
|
return getPropertyOfType(t, right);
|
|
}
|
|
}
|
|
function getSymbolAtLocation(node, ignoreErrors) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return isExternalModule(node) ? getMergedSymbol(node.symbol) : void 0;
|
|
}
|
|
const { parent: parent2 } = node;
|
|
const grandParent = parent2.parent;
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return void 0;
|
|
}
|
|
if (isDeclarationNameOrImportPropertyName(node)) {
|
|
const parentSymbol = getSymbolOfNode(parent2);
|
|
return isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node ? getImmediateAliasedSymbol(parentSymbol) : parentSymbol;
|
|
} else if (isLiteralComputedPropertyDeclarationName(node)) {
|
|
return getSymbolOfNode(parent2.parent);
|
|
}
|
|
if (node.kind === 79 /* Identifier */) {
|
|
if (isInRightSideOfImportOrExportAssignment(node)) {
|
|
return getSymbolOfNameOrPropertyAccessExpression(node);
|
|
} else if (parent2.kind === 205 /* BindingElement */ && grandParent.kind === 203 /* ObjectBindingPattern */ && node === parent2.propertyName) {
|
|
const typeOfPattern = getTypeOfNode(grandParent);
|
|
const propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText);
|
|
if (propertyDeclaration) {
|
|
return propertyDeclaration;
|
|
}
|
|
} else if (isMetaProperty(parent2) && parent2.name === node) {
|
|
if (parent2.keywordToken === 103 /* NewKeyword */ && idText(node) === "target") {
|
|
return checkNewTargetMetaProperty(parent2).symbol;
|
|
}
|
|
if (parent2.keywordToken === 100 /* ImportKeyword */ && idText(node) === "meta") {
|
|
return getGlobalImportMetaExpressionType().members.get("meta");
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 163 /* QualifiedName */:
|
|
if (!isThisInTypeQuery(node)) {
|
|
return getSymbolOfNameOrPropertyAccessExpression(node);
|
|
}
|
|
case 108 /* ThisKeyword */:
|
|
const container = getThisContainer(node, false);
|
|
if (isFunctionLike(container)) {
|
|
const sig = getSignatureFromDeclaration(container);
|
|
if (sig.thisParameter) {
|
|
return sig.thisParameter;
|
|
}
|
|
}
|
|
if (isInExpressionContext(node)) {
|
|
return checkExpression(node).symbol;
|
|
}
|
|
case 194 /* ThisType */:
|
|
return getTypeFromThisTypeNode(node).symbol;
|
|
case 106 /* SuperKeyword */:
|
|
return checkExpression(node).symbol;
|
|
case 135 /* ConstructorKeyword */:
|
|
const constructorDeclaration = node.parent;
|
|
if (constructorDeclaration && constructorDeclaration.kind === 173 /* Constructor */) {
|
|
return constructorDeclaration.parent.symbol;
|
|
}
|
|
return void 0;
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
if (isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node || (node.parent.kind === 269 /* ImportDeclaration */ || node.parent.kind === 275 /* ExportDeclaration */) && node.parent.moduleSpecifier === node || (isInJSFile(node) && isRequireCall(node.parent, false) || isImportCall(node.parent)) || isLiteralTypeNode(node.parent) && isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent) {
|
|
return resolveExternalModuleName(node, node, ignoreErrors);
|
|
}
|
|
if (isCallExpression(parent2) && isBindableObjectDefinePropertyCall(parent2) && parent2.arguments[1] === node) {
|
|
return getSymbolOfNode(parent2);
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
const objectType = isElementAccessExpression(parent2) ? parent2.argumentExpression === node ? getTypeOfExpression(parent2.expression) : void 0 : isLiteralTypeNode(parent2) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0;
|
|
return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text));
|
|
case 88 /* DefaultKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 38 /* EqualsGreaterThanToken */:
|
|
case 84 /* ClassKeyword */:
|
|
return getSymbolOfNode(node.parent);
|
|
case 202 /* ImportType */:
|
|
return isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : void 0;
|
|
case 93 /* ExportKeyword */:
|
|
return isExportAssignment(node.parent) ? Debug.checkDefined(node.parent.symbol) : void 0;
|
|
case 100 /* ImportKeyword */:
|
|
case 103 /* NewKeyword */:
|
|
return isMetaProperty(node.parent) ? checkMetaPropertyKeyword(node.parent).symbol : void 0;
|
|
case 233 /* MetaProperty */:
|
|
return checkExpression(node).symbol;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getIndexInfosAtLocation(node) {
|
|
if (isIdentifier(node) && isPropertyAccessExpression(node.parent) && node.parent.name === node) {
|
|
const keyType = getLiteralTypeFromPropertyName(node);
|
|
const objectType = getTypeOfExpression(node.parent.expression);
|
|
const objectTypes = objectType.flags & 1048576 /* Union */ ? objectType.types : [objectType];
|
|
return flatMap(objectTypes, (t) => filter(getIndexInfosOfType(t), (info) => isApplicableIndexType(keyType, info.keyType)));
|
|
}
|
|
return void 0;
|
|
}
|
|
function getShorthandAssignmentValueSymbol(location2) {
|
|
if (location2 && location2.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
return resolveEntityName(location2.name, 111551 /* Value */ | 2097152 /* Alias */);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExportSpecifierLocalTargetSymbol(node) {
|
|
if (isExportSpecifier(node)) {
|
|
return node.parent.parent.moduleSpecifier ? getExternalModuleMember(node.parent.parent, node) : resolveEntityName(node.propertyName || node.name, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
} else {
|
|
return resolveEntityName(node, 111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */);
|
|
}
|
|
}
|
|
function getTypeOfNode(node) {
|
|
if (isSourceFile(node) && !isExternalModule(node)) {
|
|
return errorType;
|
|
}
|
|
if (node.flags & 33554432 /* InWithStatement */) {
|
|
return errorType;
|
|
}
|
|
const classDecl = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node);
|
|
const classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class));
|
|
if (isPartOfTypeNode(node)) {
|
|
const typeFromTypeNode = getTypeFromTypeNode(node);
|
|
return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode;
|
|
}
|
|
if (isExpressionNode(node)) {
|
|
return getRegularTypeOfExpression(node);
|
|
}
|
|
if (classType && !classDecl.isImplements) {
|
|
const baseType = firstOrUndefined(getBaseTypes(classType));
|
|
return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
|
|
}
|
|
if (isTypeDeclaration(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
return getDeclaredTypeOfSymbol(symbol);
|
|
}
|
|
if (isTypeDeclarationName(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType;
|
|
}
|
|
if (isDeclaration(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
return symbol ? getTypeOfSymbol(symbol) : errorType;
|
|
}
|
|
if (isDeclarationNameOrImportPropertyName(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
return getTypeOfSymbol(symbol);
|
|
}
|
|
return errorType;
|
|
}
|
|
if (isBindingPattern(node)) {
|
|
return getTypeForVariableLikeDeclaration(node.parent, true, 0 /* Normal */) || errorType;
|
|
}
|
|
if (isInRightSideOfImportOrExportAssignment(node)) {
|
|
const symbol = getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
const declaredType = getDeclaredTypeOfSymbol(symbol);
|
|
return !isErrorType(declaredType) ? declaredType : getTypeOfSymbol(symbol);
|
|
}
|
|
}
|
|
if (isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
|
|
return checkMetaPropertyKeyword(node.parent);
|
|
}
|
|
return errorType;
|
|
}
|
|
function getTypeOfAssignmentPattern(expr) {
|
|
Debug.assert(expr.kind === 207 /* ObjectLiteralExpression */ || expr.kind === 206 /* ArrayLiteralExpression */);
|
|
if (expr.parent.kind === 247 /* ForOfStatement */) {
|
|
const iteratedType = checkRightHandSideOfForOf(expr.parent);
|
|
return checkDestructuringAssignment(expr, iteratedType || errorType);
|
|
}
|
|
if (expr.parent.kind === 223 /* BinaryExpression */) {
|
|
const iteratedType = getTypeOfExpression(expr.parent.right);
|
|
return checkDestructuringAssignment(expr, iteratedType || errorType);
|
|
}
|
|
if (expr.parent.kind === 299 /* PropertyAssignment */) {
|
|
const node2 = cast(expr.parent.parent, isObjectLiteralExpression);
|
|
const typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node2) || errorType;
|
|
const propertyIndex = indexOfNode(node2.properties, expr.parent);
|
|
return checkObjectLiteralDestructuringPropertyAssignment(node2, typeOfParentObjectLiteral, propertyIndex);
|
|
}
|
|
const node = cast(expr.parent, isArrayLiteralExpression);
|
|
const typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType;
|
|
const elementType = checkIteratedTypeOrElementType(65 /* Destructuring */, typeOfArrayLiteral, undefinedType, expr.parent) || errorType;
|
|
return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType);
|
|
}
|
|
function getPropertySymbolOfDestructuringAssignment(location2) {
|
|
const typeOfObjectLiteral = getTypeOfAssignmentPattern(cast(location2.parent.parent, isAssignmentPattern));
|
|
return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location2.escapedText);
|
|
}
|
|
function getRegularTypeOfExpression(expr) {
|
|
if (isRightSideOfQualifiedNameOrPropertyAccess(expr)) {
|
|
expr = expr.parent;
|
|
}
|
|
return getRegularTypeOfLiteralType(getTypeOfExpression(expr));
|
|
}
|
|
function getParentTypeOfClassElement(node) {
|
|
const classSymbol = getSymbolOfNode(node.parent);
|
|
return isStatic(node) ? getTypeOfSymbol(classSymbol) : getDeclaredTypeOfSymbol(classSymbol);
|
|
}
|
|
function getClassElementPropertyKeyType(element) {
|
|
const name = element.name;
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return getStringLiteralType(idText(name));
|
|
case 8 /* NumericLiteral */:
|
|
case 10 /* StringLiteral */:
|
|
return getStringLiteralType(name.text);
|
|
case 164 /* ComputedPropertyName */:
|
|
const nameType = checkComputedPropertyName(name);
|
|
return isTypeAssignableToKind(nameType, 12288 /* ESSymbolLike */) ? nameType : stringType;
|
|
default:
|
|
return Debug.fail("Unsupported property name.");
|
|
}
|
|
}
|
|
function getAugmentedPropertiesOfType(type) {
|
|
type = getApparentType(type);
|
|
const propsByName = createSymbolTable(getPropertiesOfType(type));
|
|
const functionType = getSignaturesOfType(type, 0 /* Call */).length ? globalCallableFunctionType : getSignaturesOfType(type, 1 /* Construct */).length ? globalNewableFunctionType : void 0;
|
|
if (functionType) {
|
|
forEach(getPropertiesOfType(functionType), (p) => {
|
|
if (!propsByName.has(p.escapedName)) {
|
|
propsByName.set(p.escapedName, p);
|
|
}
|
|
});
|
|
}
|
|
return getNamedMembers(propsByName);
|
|
}
|
|
function typeHasCallOrConstructSignatures2(type) {
|
|
return typeHasCallOrConstructSignatures(type, checker);
|
|
}
|
|
function getRootSymbols(symbol) {
|
|
const roots = getImmediateRootSymbols(symbol);
|
|
return roots ? flatMap(roots, getRootSymbols) : [symbol];
|
|
}
|
|
function getImmediateRootSymbols(symbol) {
|
|
if (getCheckFlags(symbol) & 6 /* Synthetic */) {
|
|
return mapDefined(getSymbolLinks(symbol).containingType.types, (type) => getPropertyOfType(type, symbol.escapedName));
|
|
} else if (symbol.flags & 33554432 /* Transient */) {
|
|
const { leftSpread, rightSpread, syntheticOrigin } = symbol;
|
|
return leftSpread ? [leftSpread, rightSpread] : syntheticOrigin ? [syntheticOrigin] : singleElementArray(tryGetTarget(symbol));
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetTarget(symbol) {
|
|
let target;
|
|
let next = symbol;
|
|
while (next = getSymbolLinks(next).target) {
|
|
target = next;
|
|
}
|
|
return target;
|
|
}
|
|
function isArgumentsLocalBinding(nodeIn) {
|
|
if (isGeneratedIdentifier(nodeIn))
|
|
return false;
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (!node)
|
|
return false;
|
|
const parent2 = node.parent;
|
|
if (!parent2)
|
|
return false;
|
|
const isPropertyName2 = (isPropertyAccessExpression(parent2) || isPropertyAssignment(parent2)) && parent2.name === node;
|
|
return !isPropertyName2 && getReferencedValueSymbol(node) === argumentsSymbol;
|
|
}
|
|
function moduleExportsSomeValue(moduleReferenceExpression) {
|
|
let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
|
|
if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) {
|
|
return true;
|
|
}
|
|
const hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);
|
|
moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
|
|
const symbolLinks2 = getSymbolLinks(moduleSymbol);
|
|
if (symbolLinks2.exportsSomeValue === void 0) {
|
|
symbolLinks2.exportsSomeValue = hasExportAssignment ? !!(moduleSymbol.flags & 111551 /* Value */) : forEachEntry(getExportsOfModule(moduleSymbol), isValue);
|
|
}
|
|
return symbolLinks2.exportsSomeValue;
|
|
function isValue(s) {
|
|
s = resolveSymbol(s);
|
|
return s && !!(getAllSymbolFlags(s) & 111551 /* Value */);
|
|
}
|
|
}
|
|
function isNameOfModuleOrEnumDeclaration(node) {
|
|
return isModuleOrEnumDeclaration(node.parent) && node === node.parent.name;
|
|
}
|
|
function getReferencedExportContainer(nodeIn, prefixLocals) {
|
|
var _a2;
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
let symbol = getReferencedValueSymbol(node, isNameOfModuleOrEnumDeclaration(node));
|
|
if (symbol) {
|
|
if (symbol.flags & 1048576 /* ExportValue */) {
|
|
const exportSymbol = getMergedSymbol(symbol.exportSymbol);
|
|
if (!prefixLocals && exportSymbol.flags & 944 /* ExportHasLocal */ && !(exportSymbol.flags & 3 /* Variable */)) {
|
|
return void 0;
|
|
}
|
|
symbol = exportSymbol;
|
|
}
|
|
const parentSymbol = getParentOfSymbol(symbol);
|
|
if (parentSymbol) {
|
|
if (parentSymbol.flags & 512 /* ValueModule */ && ((_a2 = parentSymbol.valueDeclaration) == null ? void 0 : _a2.kind) === 308 /* SourceFile */) {
|
|
const symbolFile = parentSymbol.valueDeclaration;
|
|
const referenceFile = getSourceFileOfNode(node);
|
|
const symbolIsUmdExport = symbolFile !== referenceFile;
|
|
return symbolIsUmdExport ? void 0 : symbolFile;
|
|
}
|
|
return findAncestor(node.parent, (n) => isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getReferencedImportDeclaration(nodeIn) {
|
|
if (nodeIn.generatedImportReference) {
|
|
return nodeIn.generatedImportReference;
|
|
}
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
const symbol = getReferencedValueOrAliasSymbol(node);
|
|
if (isNonLocalAlias(symbol, 111551 /* Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */)) {
|
|
return getDeclarationOfAliasSymbol(symbol);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isSymbolOfDestructuredElementOfCatchBinding(symbol) {
|
|
return symbol.valueDeclaration && isBindingElement(symbol.valueDeclaration) && walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 295 /* CatchClause */;
|
|
}
|
|
function isSymbolOfDeclarationWithCollidingName(symbol) {
|
|
if (symbol.flags & 418 /* BlockScoped */ && symbol.valueDeclaration && !isSourceFile(symbol.valueDeclaration)) {
|
|
const links = getSymbolLinks(symbol);
|
|
if (links.isDeclarationWithCollidingName === void 0) {
|
|
const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
|
|
if (isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) {
|
|
const nodeLinks2 = getNodeLinks(symbol.valueDeclaration);
|
|
if (resolveName(container.parent, symbol.escapedName, 111551 /* Value */, void 0, void 0, false)) {
|
|
links.isDeclarationWithCollidingName = true;
|
|
} else if (nodeLinks2.flags & 16384 /* CapturedBlockScopedBinding */) {
|
|
const isDeclaredInLoop = nodeLinks2.flags & 32768 /* BlockScopedBindingInLoop */;
|
|
const inLoopInitializer = isIterationStatement(container, false);
|
|
const inLoopBodyBlock = container.kind === 238 /* Block */ && isIterationStatement(container.parent, false);
|
|
links.isDeclarationWithCollidingName = !isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || !inLoopInitializer && !inLoopBodyBlock);
|
|
} else {
|
|
links.isDeclarationWithCollidingName = false;
|
|
}
|
|
}
|
|
}
|
|
return links.isDeclarationWithCollidingName;
|
|
}
|
|
return false;
|
|
}
|
|
function getReferencedDeclarationWithCollidingName(nodeIn) {
|
|
if (!isGeneratedIdentifier(nodeIn)) {
|
|
const node = getParseTreeNode(nodeIn, isIdentifier);
|
|
if (node) {
|
|
const symbol = getReferencedValueSymbol(node);
|
|
if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) {
|
|
return symbol.valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isDeclarationWithCollidingName(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isDeclaration);
|
|
if (node) {
|
|
const symbol = getSymbolOfNode(node);
|
|
if (symbol) {
|
|
return isSymbolOfDeclarationWithCollidingName(symbol);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isValueAliasDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return isAliasResolvedToValue(getSymbolOfNode(node));
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
const symbol = getSymbolOfNode(node);
|
|
return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* Value */);
|
|
case 275 /* ExportDeclaration */:
|
|
const exportClause = node.exportClause;
|
|
return !!exportClause && (isNamespaceExport(exportClause) || some(exportClause.elements, isValueAliasDeclaration));
|
|
case 274 /* ExportAssignment */:
|
|
return node.expression && node.expression.kind === 79 /* Identifier */ ? isAliasResolvedToValue(getSymbolOfNode(node)) : true;
|
|
}
|
|
return false;
|
|
}
|
|
function isTopLevelValueImportEqualsWithEntityName(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isImportEqualsDeclaration);
|
|
if (node === void 0 || node.parent.kind !== 308 /* SourceFile */ || !isInternalModuleImportEqualsDeclaration(node)) {
|
|
return false;
|
|
}
|
|
const isValue = isAliasResolvedToValue(getSymbolOfNode(node));
|
|
return isValue && node.moduleReference && !nodeIsMissing(node.moduleReference);
|
|
}
|
|
function isAliasResolvedToValue(symbol) {
|
|
var _a2;
|
|
if (!symbol) {
|
|
return false;
|
|
}
|
|
const target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol));
|
|
if (target === unknownSymbol) {
|
|
return true;
|
|
}
|
|
return !!(((_a2 = getAllSymbolFlags(target)) != null ? _a2 : -1) & 111551 /* Value */) && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target));
|
|
}
|
|
function isConstEnumOrConstEnumOnlyModule(s) {
|
|
return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
|
|
}
|
|
function isReferencedAliasDeclaration(node, checkChildren) {
|
|
if (isAliasSymbolDeclaration2(node)) {
|
|
const symbol = getSymbolOfNode(node);
|
|
const links = symbol && getSymbolLinks(symbol);
|
|
if (links == null ? void 0 : links.referenced) {
|
|
return true;
|
|
}
|
|
const target = getSymbolLinks(symbol).aliasTarget;
|
|
if (target && getEffectiveModifierFlags(node) & 1 /* Export */ && getAllSymbolFlags(target) & 111551 /* Value */ && (shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) {
|
|
return true;
|
|
}
|
|
}
|
|
if (checkChildren) {
|
|
return !!forEachChild(node, (node2) => isReferencedAliasDeclaration(node2, checkChildren));
|
|
}
|
|
return false;
|
|
}
|
|
function isImplementationOfOverload(node) {
|
|
if (nodeIsPresent(node.body)) {
|
|
if (isGetAccessor(node) || isSetAccessor(node))
|
|
return false;
|
|
const symbol = getSymbolOfNode(node);
|
|
const signaturesOfSymbol = getSignaturesOfSymbol(symbol);
|
|
return signaturesOfSymbol.length > 1 || signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node;
|
|
}
|
|
return false;
|
|
}
|
|
function isRequiredInitializedParameter(parameter) {
|
|
return !!strictNullChecks && !isOptionalParameter(parameter) && !isJSDocParameterTag(parameter) && !!parameter.initializer && !hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isOptionalUninitializedParameterProperty(parameter) {
|
|
return strictNullChecks && isOptionalParameter(parameter) && !parameter.initializer && hasSyntacticModifier(parameter, 16476 /* ParameterPropertyModifier */);
|
|
}
|
|
function isExpandoFunctionDeclaration(node) {
|
|
const declaration = getParseTreeNode(node, isFunctionDeclaration);
|
|
if (!declaration) {
|
|
return false;
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
if (!symbol || !(symbol.flags & 16 /* Function */)) {
|
|
return false;
|
|
}
|
|
return !!forEachEntry(getExportsOfSymbol(symbol), (p) => p.flags & 111551 /* Value */ && p.valueDeclaration && isPropertyAccessExpression(p.valueDeclaration));
|
|
}
|
|
function getPropertiesOfContainerFunction(node) {
|
|
const declaration = getParseTreeNode(node, isFunctionDeclaration);
|
|
if (!declaration) {
|
|
return emptyArray;
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || emptyArray;
|
|
}
|
|
function getNodeCheckFlags(node) {
|
|
var _a2;
|
|
const nodeId = node.id || 0;
|
|
if (nodeId < 0 || nodeId >= nodeLinks.length)
|
|
return 0;
|
|
return ((_a2 = nodeLinks[nodeId]) == null ? void 0 : _a2.flags) || 0;
|
|
}
|
|
function getEnumMemberValue(node) {
|
|
computeEnumMemberValues(node.parent);
|
|
return getNodeLinks(node).enumMemberValue;
|
|
}
|
|
function canHaveConstantValue(node) {
|
|
switch (node.kind) {
|
|
case 302 /* EnumMember */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getConstantValue2(node) {
|
|
if (node.kind === 302 /* EnumMember */) {
|
|
return getEnumMemberValue(node);
|
|
}
|
|
const symbol = getNodeLinks(node).resolvedSymbol;
|
|
if (symbol && symbol.flags & 8 /* EnumMember */) {
|
|
const member = symbol.valueDeclaration;
|
|
if (isEnumConst(member.parent)) {
|
|
return getEnumMemberValue(member);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isFunctionType(type) {
|
|
return !!(type.flags & 524288 /* Object */) && getSignaturesOfType(type, 0 /* Call */).length > 0;
|
|
}
|
|
function getTypeReferenceSerializationKind(typeNameIn, location2) {
|
|
var _a2, _b;
|
|
const typeName = getParseTreeNode(typeNameIn, isEntityName);
|
|
if (!typeName)
|
|
return 0 /* Unknown */;
|
|
if (location2) {
|
|
location2 = getParseTreeNode(location2);
|
|
if (!location2)
|
|
return 0 /* Unknown */;
|
|
}
|
|
let isTypeOnly = false;
|
|
if (isQualifiedName(typeName)) {
|
|
const rootValueSymbol = resolveEntityName(getFirstIdentifier(typeName), 111551 /* Value */, true, true, location2);
|
|
isTypeOnly = !!((_a2 = rootValueSymbol == null ? void 0 : rootValueSymbol.declarations) == null ? void 0 : _a2.every(isTypeOnlyImportOrExportDeclaration));
|
|
}
|
|
const valueSymbol = resolveEntityName(typeName, 111551 /* Value */, true, true, location2);
|
|
const resolvedSymbol = valueSymbol && valueSymbol.flags & 2097152 /* Alias */ ? resolveAlias(valueSymbol) : valueSymbol;
|
|
isTypeOnly || (isTypeOnly = !!((_b = valueSymbol == null ? void 0 : valueSymbol.declarations) == null ? void 0 : _b.every(isTypeOnlyImportOrExportDeclaration)));
|
|
const typeSymbol = resolveEntityName(typeName, 788968 /* Type */, true, false, location2);
|
|
if (resolvedSymbol && resolvedSymbol === typeSymbol) {
|
|
const globalPromiseSymbol = getGlobalPromiseConstructorSymbol(false);
|
|
if (globalPromiseSymbol && resolvedSymbol === globalPromiseSymbol) {
|
|
return 9 /* Promise */;
|
|
}
|
|
const constructorType = getTypeOfSymbol(resolvedSymbol);
|
|
if (constructorType && isConstructorType(constructorType)) {
|
|
return isTypeOnly ? 10 /* TypeWithCallSignature */ : 1 /* TypeWithConstructSignatureAndValue */;
|
|
}
|
|
}
|
|
if (!typeSymbol) {
|
|
return isTypeOnly ? 11 /* ObjectType */ : 0 /* Unknown */;
|
|
}
|
|
const type = getDeclaredTypeOfSymbol(typeSymbol);
|
|
if (isErrorType(type)) {
|
|
return isTypeOnly ? 11 /* ObjectType */ : 0 /* Unknown */;
|
|
} else if (type.flags & 3 /* AnyOrUnknown */) {
|
|
return 11 /* ObjectType */;
|
|
} else if (isTypeAssignableToKind(type, 16384 /* Void */ | 98304 /* Nullable */ | 131072 /* Never */)) {
|
|
return 2 /* VoidNullableOrNeverType */;
|
|
} else if (isTypeAssignableToKind(type, 528 /* BooleanLike */)) {
|
|
return 6 /* BooleanType */;
|
|
} else if (isTypeAssignableToKind(type, 296 /* NumberLike */)) {
|
|
return 3 /* NumberLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 2112 /* BigIntLike */)) {
|
|
return 4 /* BigIntLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 402653316 /* StringLike */)) {
|
|
return 5 /* StringLikeType */;
|
|
} else if (isTupleType(type)) {
|
|
return 7 /* ArrayLikeType */;
|
|
} else if (isTypeAssignableToKind(type, 12288 /* ESSymbolLike */)) {
|
|
return 8 /* ESSymbolType */;
|
|
} else if (isFunctionType(type)) {
|
|
return 10 /* TypeWithCallSignature */;
|
|
} else if (isArrayType(type)) {
|
|
return 7 /* ArrayLikeType */;
|
|
} else {
|
|
return 11 /* ObjectType */;
|
|
}
|
|
}
|
|
function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) {
|
|
const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
|
|
if (!declaration) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const symbol = getSymbolOfNode(declaration);
|
|
let type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
|
|
if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol) {
|
|
flags |= 1048576 /* AllowUniqueESSymbolType */;
|
|
}
|
|
if (addUndefined) {
|
|
type = getOptionalType(type);
|
|
}
|
|
return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
|
|
const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
|
|
if (!signatureDeclaration) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const signature = getSignatureFromDeclaration(signatureDeclaration);
|
|
return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
|
|
const expr = getParseTreeNode(exprIn, isExpression);
|
|
if (!expr) {
|
|
return factory.createToken(131 /* AnyKeyword */);
|
|
}
|
|
const type = getWidenedType(getRegularTypeOfExpression(expr));
|
|
return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
|
|
}
|
|
function hasGlobalName(name) {
|
|
return globals.has(escapeLeadingUnderscores(name));
|
|
}
|
|
function getReferencedValueSymbol(reference, startInDeclarationContainer) {
|
|
const resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
|
|
if (resolvedSymbol) {
|
|
return resolvedSymbol;
|
|
}
|
|
let location2 = reference;
|
|
if (startInDeclarationContainer) {
|
|
const parent2 = reference.parent;
|
|
if (isDeclaration(parent2) && reference === parent2.name) {
|
|
location2 = getDeclarationContainer(parent2);
|
|
}
|
|
}
|
|
return resolveName(location2, reference.escapedText, 111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */, void 0, void 0, true);
|
|
}
|
|
function getReferencedValueOrAliasSymbol(reference) {
|
|
const resolvedSymbol = getNodeLinks(reference).resolvedSymbol;
|
|
if (resolvedSymbol && resolvedSymbol !== unknownSymbol) {
|
|
return resolvedSymbol;
|
|
}
|
|
return resolveName(
|
|
reference,
|
|
reference.escapedText,
|
|
111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */,
|
|
void 0,
|
|
void 0,
|
|
true,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
function getReferencedValueDeclaration(referenceIn) {
|
|
if (!isGeneratedIdentifier(referenceIn)) {
|
|
const reference = getParseTreeNode(referenceIn, isIdentifier);
|
|
if (reference) {
|
|
const symbol = getReferencedValueSymbol(reference);
|
|
if (symbol) {
|
|
return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isLiteralConstDeclaration(node) {
|
|
if (isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node)) {
|
|
return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node)));
|
|
}
|
|
return false;
|
|
}
|
|
function literalTypeToNode(type, enclosing, tracker) {
|
|
const enumResult = type.flags & 1024 /* EnumLiteral */ ? nodeBuilder.symbolToExpression(type.symbol, 111551 /* Value */, enclosing, void 0, tracker) : type === trueType ? factory.createTrue() : type === falseType && factory.createFalse();
|
|
if (enumResult)
|
|
return enumResult;
|
|
const literalValue = type.value;
|
|
return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
|
|
}
|
|
function createLiteralConstValue(node, tracker) {
|
|
const type = getTypeOfSymbol(getSymbolOfNode(node));
|
|
return literalTypeToNode(type, node, tracker);
|
|
}
|
|
function getJsxFactoryEntity(location2) {
|
|
return location2 ? (getJsxNamespace(location2), getSourceFileOfNode(location2).localJsxFactory || _jsxFactoryEntity) : _jsxFactoryEntity;
|
|
}
|
|
function getJsxFragmentFactoryEntity(location2) {
|
|
if (location2) {
|
|
const file = getSourceFileOfNode(location2);
|
|
if (file) {
|
|
if (file.localJsxFragmentFactory) {
|
|
return file.localJsxFragmentFactory;
|
|
}
|
|
const jsxFragPragmas = file.pragmas.get("jsxfrag");
|
|
const jsxFragPragma = isArray(jsxFragPragmas) ? jsxFragPragmas[0] : jsxFragPragmas;
|
|
if (jsxFragPragma) {
|
|
file.localJsxFragmentFactory = parseIsolatedEntityName(jsxFragPragma.arguments.factory, languageVersion);
|
|
return file.localJsxFragmentFactory;
|
|
}
|
|
}
|
|
}
|
|
if (compilerOptions.jsxFragmentFactory) {
|
|
return parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
|
|
}
|
|
}
|
|
function createResolver() {
|
|
const resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
|
|
let fileToDirective;
|
|
if (resolvedTypeReferenceDirectives) {
|
|
fileToDirective = /* @__PURE__ */ new Map();
|
|
resolvedTypeReferenceDirectives.forEach((resolvedDirective, key, mode) => {
|
|
if (!resolvedDirective || !resolvedDirective.resolvedFileName) {
|
|
return;
|
|
}
|
|
const file = host.getSourceFile(resolvedDirective.resolvedFileName);
|
|
if (file) {
|
|
addReferencedFilesToTypeDirective(file, key, mode);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
getReferencedExportContainer,
|
|
getReferencedImportDeclaration,
|
|
getReferencedDeclarationWithCollidingName,
|
|
isDeclarationWithCollidingName,
|
|
isValueAliasDeclaration: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? isValueAliasDeclaration(node) : true;
|
|
},
|
|
hasGlobalName,
|
|
isReferencedAliasDeclaration: (nodeIn, checkChildren) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
|
|
},
|
|
getNodeCheckFlags: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn);
|
|
return node ? getNodeCheckFlags(node) : 0;
|
|
},
|
|
isTopLevelValueImportEqualsWithEntityName,
|
|
isDeclarationVisible,
|
|
isImplementationOfOverload,
|
|
isRequiredInitializedParameter,
|
|
isOptionalUninitializedParameterProperty,
|
|
isExpandoFunctionDeclaration,
|
|
getPropertiesOfContainerFunction,
|
|
createTypeOfDeclaration,
|
|
createReturnTypeOfSignatureDeclaration,
|
|
createTypeOfExpression,
|
|
createLiteralConstValue,
|
|
isSymbolAccessible,
|
|
isEntityNameVisible,
|
|
getConstantValue: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, canHaveConstantValue);
|
|
return node ? getConstantValue2(node) : void 0;
|
|
},
|
|
collectLinkedAliases,
|
|
getReferencedValueDeclaration,
|
|
getTypeReferenceSerializationKind,
|
|
isOptionalParameter,
|
|
moduleExportsSomeValue,
|
|
isArgumentsLocalBinding,
|
|
getExternalModuleFileFromDeclaration: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, hasPossibleExternalModuleReference);
|
|
return node && getExternalModuleFileFromDeclaration(node);
|
|
},
|
|
getTypeReferenceDirectivesForEntityName,
|
|
getTypeReferenceDirectivesForSymbol,
|
|
isLiteralConstDeclaration,
|
|
isLateBound: (nodeIn) => {
|
|
const node = getParseTreeNode(nodeIn, isDeclaration);
|
|
const symbol = node && getSymbolOfNode(node);
|
|
return !!(symbol && getCheckFlags(symbol) & 4096 /* Late */);
|
|
},
|
|
getJsxFactoryEntity,
|
|
getJsxFragmentFactoryEntity,
|
|
getAllAccessorDeclarations(accessor) {
|
|
accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
|
|
const otherKind = accessor.kind === 175 /* SetAccessor */ ? 174 /* GetAccessor */ : 175 /* SetAccessor */;
|
|
const otherAccessor = getDeclarationOfKind(getSymbolOfNode(accessor), otherKind);
|
|
const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
|
|
const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
|
|
const setAccessor = accessor.kind === 175 /* SetAccessor */ ? accessor : otherAccessor;
|
|
const getAccessor = accessor.kind === 174 /* GetAccessor */ ? accessor : otherAccessor;
|
|
return {
|
|
firstAccessor,
|
|
secondAccessor,
|
|
setAccessor,
|
|
getAccessor
|
|
};
|
|
},
|
|
getSymbolOfExternalModuleSpecifier: (moduleName) => resolveExternalModuleNameWorker(moduleName, moduleName, void 0),
|
|
isBindingCapturedByNode: (node, decl) => {
|
|
const parseNode = getParseTreeNode(node);
|
|
const parseDecl = getParseTreeNode(decl);
|
|
return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
|
|
},
|
|
getDeclarationStatementsForSourceFile: (node, flags, tracker, bundled) => {
|
|
const n = getParseTreeNode(node);
|
|
Debug.assert(n && n.kind === 308 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
|
|
const sym = getSymbolOfNode(node);
|
|
if (!sym) {
|
|
return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
|
|
}
|
|
return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
|
|
},
|
|
isImportRequiredByAugmentation
|
|
};
|
|
function isImportRequiredByAugmentation(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
if (!file.symbol)
|
|
return false;
|
|
const importTarget = getExternalModuleFileFromDeclaration(node);
|
|
if (!importTarget)
|
|
return false;
|
|
if (importTarget === file)
|
|
return false;
|
|
const exports = getExportsOfModule(file.symbol);
|
|
for (const s of arrayFrom(exports.values())) {
|
|
if (s.mergeId) {
|
|
const merged = getMergedSymbol(s);
|
|
if (merged.declarations) {
|
|
for (const d of merged.declarations) {
|
|
const declFile = getSourceFileOfNode(d);
|
|
if (declFile === importTarget) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInHeritageClause(node) {
|
|
return node.parent && node.parent.kind === 230 /* ExpressionWithTypeArguments */ && node.parent.parent && node.parent.parent.kind === 294 /* HeritageClause */;
|
|
}
|
|
function getTypeReferenceDirectivesForEntityName(node) {
|
|
if (!fileToDirective) {
|
|
return void 0;
|
|
}
|
|
let meaning;
|
|
if (node.parent.kind === 164 /* ComputedPropertyName */) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
} else {
|
|
meaning = 788968 /* Type */ | 1920 /* Namespace */;
|
|
if (node.kind === 79 /* Identifier */ && isInTypeQuery(node) || node.kind === 208 /* PropertyAccessExpression */ && !isInHeritageClause(node)) {
|
|
meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
|
|
}
|
|
}
|
|
const symbol = resolveEntityName(node, meaning, true);
|
|
return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : void 0;
|
|
}
|
|
function getTypeReferenceDirectivesForSymbol(symbol, meaning) {
|
|
if (!fileToDirective || !isSymbolFromTypeDeclarationFile(symbol)) {
|
|
return void 0;
|
|
}
|
|
let typeReferenceDirectives;
|
|
for (const decl of symbol.declarations) {
|
|
if (decl.symbol && decl.symbol.flags & meaning) {
|
|
const file = getSourceFileOfNode(decl);
|
|
const typeReferenceDirective = fileToDirective.get(file.path);
|
|
if (typeReferenceDirective) {
|
|
(typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return typeReferenceDirectives;
|
|
}
|
|
function isSymbolFromTypeDeclarationFile(symbol) {
|
|
if (!symbol.declarations) {
|
|
return false;
|
|
}
|
|
let current = symbol;
|
|
while (true) {
|
|
const parent2 = getParentOfSymbol(current);
|
|
if (parent2) {
|
|
current = parent2;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (current.valueDeclaration && current.valueDeclaration.kind === 308 /* SourceFile */ && current.flags & 512 /* ValueModule */) {
|
|
return false;
|
|
}
|
|
for (const decl of symbol.declarations) {
|
|
const file = getSourceFileOfNode(decl);
|
|
if (fileToDirective.has(file.path)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function addReferencedFilesToTypeDirective(file, key, mode) {
|
|
if (fileToDirective.has(file.path))
|
|
return;
|
|
fileToDirective.set(file.path, [key, mode]);
|
|
for (const { fileName, resolutionMode } of file.referencedFiles) {
|
|
const resolvedFile = resolveTripleslashReference(fileName, file.fileName);
|
|
const referencedFile = host.getSourceFile(resolvedFile);
|
|
if (referencedFile) {
|
|
addReferencedFilesToTypeDirective(referencedFile, key, resolutionMode || file.impliedNodeFormat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getExternalModuleFileFromDeclaration(declaration) {
|
|
const specifier = declaration.kind === 264 /* ModuleDeclaration */ ? tryCast(declaration.name, isStringLiteral) : getExternalModuleName(declaration);
|
|
const moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, void 0);
|
|
if (!moduleSymbol) {
|
|
return void 0;
|
|
}
|
|
return getDeclarationOfKind(moduleSymbol, 308 /* SourceFile */);
|
|
}
|
|
function initializeTypeChecker() {
|
|
for (const file of host.getSourceFiles()) {
|
|
bindSourceFile(file, compilerOptions);
|
|
}
|
|
amalgamatedDuplicates = /* @__PURE__ */ new Map();
|
|
let augmentations;
|
|
for (const file of host.getSourceFiles()) {
|
|
if (file.redirectInfo) {
|
|
continue;
|
|
}
|
|
if (!isExternalOrCommonJsModule(file)) {
|
|
const fileGlobalThisSymbol = file.locals.get("globalThis");
|
|
if (fileGlobalThisSymbol == null ? void 0 : fileGlobalThisSymbol.declarations) {
|
|
for (const declaration of fileGlobalThisSymbol.declarations) {
|
|
diagnostics.add(createDiagnosticForNode(declaration, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis"));
|
|
}
|
|
}
|
|
mergeSymbolTable(globals, file.locals);
|
|
}
|
|
if (file.jsGlobalAugmentations) {
|
|
mergeSymbolTable(globals, file.jsGlobalAugmentations);
|
|
}
|
|
if (file.patternAmbientModules && file.patternAmbientModules.length) {
|
|
patternAmbientModules = concatenate(patternAmbientModules, file.patternAmbientModules);
|
|
}
|
|
if (file.moduleAugmentations.length) {
|
|
(augmentations || (augmentations = [])).push(file.moduleAugmentations);
|
|
}
|
|
if (file.symbol && file.symbol.globalExports) {
|
|
const source = file.symbol.globalExports;
|
|
source.forEach((sourceSymbol, id) => {
|
|
if (!globals.has(id)) {
|
|
globals.set(id, sourceSymbol);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (augmentations) {
|
|
for (const list of augmentations) {
|
|
for (const augmentation of list) {
|
|
if (!isGlobalScopeAugmentation(augmentation.parent))
|
|
continue;
|
|
mergeModuleAugmentation(augmentation);
|
|
}
|
|
}
|
|
}
|
|
addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
|
|
getSymbolLinks(undefinedSymbol).type = undefinedWideningType;
|
|
getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments", 0, true);
|
|
getSymbolLinks(unknownSymbol).type = errorType;
|
|
getSymbolLinks(globalThisSymbol).type = createObjectType(16 /* Anonymous */, globalThisSymbol);
|
|
globalArrayType = getGlobalType("Array", 1, true);
|
|
globalObjectType = getGlobalType("Object", 0, true);
|
|
globalFunctionType = getGlobalType("Function", 0, true);
|
|
globalCallableFunctionType = strictBindCallApply && getGlobalType("CallableFunction", 0, true) || globalFunctionType;
|
|
globalNewableFunctionType = strictBindCallApply && getGlobalType("NewableFunction", 0, true) || globalFunctionType;
|
|
globalStringType = getGlobalType("String", 0, true);
|
|
globalNumberType = getGlobalType("Number", 0, true);
|
|
globalBooleanType = getGlobalType("Boolean", 0, true);
|
|
globalRegExpType = getGlobalType("RegExp", 0, true);
|
|
anyArrayType = createArrayType(anyType);
|
|
autoArrayType = createArrayType(autoType);
|
|
if (autoArrayType === emptyObjectType) {
|
|
autoArrayType = createAnonymousType(void 0, emptySymbols, emptyArray, emptyArray, emptyArray);
|
|
}
|
|
globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", 1) || globalArrayType;
|
|
anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;
|
|
globalThisType = getGlobalTypeOrUndefined("ThisType", 1);
|
|
if (augmentations) {
|
|
for (const list of augmentations) {
|
|
for (const augmentation of list) {
|
|
if (isGlobalScopeAugmentation(augmentation.parent))
|
|
continue;
|
|
mergeModuleAugmentation(augmentation);
|
|
}
|
|
}
|
|
}
|
|
amalgamatedDuplicates.forEach(({ firstFile, secondFile, conflictingSymbols }) => {
|
|
if (conflictingSymbols.size < 8) {
|
|
conflictingSymbols.forEach(({ isBlockScoped, firstFileLocations, secondFileLocations }, symbolName2) => {
|
|
const message = isBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
|
|
for (const node of firstFileLocations) {
|
|
addDuplicateDeclarationError(node, message, symbolName2, secondFileLocations);
|
|
}
|
|
for (const node of secondFileLocations) {
|
|
addDuplicateDeclarationError(node, message, symbolName2, firstFileLocations);
|
|
}
|
|
});
|
|
} else {
|
|
const list = arrayFrom(conflictingSymbols.keys()).join(", ");
|
|
diagnostics.add(addRelatedInfo(
|
|
createDiagnosticForNode(firstFile, Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list),
|
|
createDiagnosticForNode(secondFile, Diagnostics.Conflicts_are_in_this_file)
|
|
));
|
|
diagnostics.add(addRelatedInfo(
|
|
createDiagnosticForNode(secondFile, Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list),
|
|
createDiagnosticForNode(firstFile, Diagnostics.Conflicts_are_in_this_file)
|
|
));
|
|
}
|
|
});
|
|
amalgamatedDuplicates = void 0;
|
|
}
|
|
function checkExternalEmitHelpers(location2, helpers) {
|
|
if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) {
|
|
const sourceFile = getSourceFileOfNode(location2);
|
|
if (isEffectiveExternalModule(sourceFile, compilerOptions) && !(location2.flags & 16777216 /* Ambient */)) {
|
|
const helpersModule = resolveHelpersModule(sourceFile, location2);
|
|
if (helpersModule !== unknownSymbol) {
|
|
const uncheckedHelpers = helpers & ~requestedExternalEmitHelpers;
|
|
for (let helper = 1 /* FirstEmitHelper */; helper <= 4194304 /* LastEmitHelper */; helper <<= 1) {
|
|
if (uncheckedHelpers & helper) {
|
|
const name = getHelperName(helper);
|
|
const symbol = getSymbol2(helpersModule.exports, escapeLeadingUnderscores(name), 111551 /* Value */);
|
|
if (!symbol) {
|
|
error(location2, Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name);
|
|
} else if (helper & 524288 /* ClassPrivateFieldGet */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 3)) {
|
|
error(location2, Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name, 4);
|
|
}
|
|
} else if (helper & 1048576 /* ClassPrivateFieldSet */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 4)) {
|
|
error(location2, Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name, 5);
|
|
}
|
|
} else if (helper & 1024 /* SpreadArray */) {
|
|
if (!some(getSignaturesOfSymbol(symbol), (signature) => getParameterCount(signature) > 2)) {
|
|
error(location2, Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name, 3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
requestedExternalEmitHelpers |= helpers;
|
|
}
|
|
}
|
|
}
|
|
function getHelperName(helper) {
|
|
switch (helper) {
|
|
case 1 /* Extends */:
|
|
return "__extends";
|
|
case 2 /* Assign */:
|
|
return "__assign";
|
|
case 4 /* Rest */:
|
|
return "__rest";
|
|
case 8 /* Decorate */:
|
|
return "__decorate";
|
|
case 16 /* Metadata */:
|
|
return "__metadata";
|
|
case 32 /* Param */:
|
|
return "__param";
|
|
case 64 /* Awaiter */:
|
|
return "__awaiter";
|
|
case 128 /* Generator */:
|
|
return "__generator";
|
|
case 256 /* Values */:
|
|
return "__values";
|
|
case 512 /* Read */:
|
|
return "__read";
|
|
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 /* ClassPrivateFieldIn */:
|
|
return "__classPrivateFieldIn";
|
|
case 4194304 /* CreateBinding */:
|
|
return "__createBinding";
|
|
default:
|
|
return Debug.fail("Unrecognized helper");
|
|
}
|
|
}
|
|
function resolveHelpersModule(node, errorNode) {
|
|
if (!externalHelpersModule) {
|
|
externalHelpersModule = resolveExternalModule(node, externalHelpersModuleNameText, Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol;
|
|
}
|
|
return externalHelpersModule;
|
|
}
|
|
function checkGrammarDecoratorsAndModifiers(node) {
|
|
return checkGrammarDecorators(node) || checkGrammarModifiers(node);
|
|
}
|
|
function checkGrammarDecorators(node) {
|
|
if (canHaveIllegalDecorators(node) && some(node.illegalDecorators)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
|
|
}
|
|
if (!canHaveDecorators(node) || !hasDecorators(node)) {
|
|
return false;
|
|
}
|
|
if (!nodeCanBeDecorated(node, node.parent, node.parent.parent)) {
|
|
if (node.kind === 171 /* MethodDeclaration */ && !nodeIsPresent(node.body)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload);
|
|
} else {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
|
|
}
|
|
} else if (node.kind === 174 /* GetAccessor */ || node.kind === 175 /* SetAccessor */) {
|
|
const accessors = getAllAccessorDeclarations(node.parent.members, node);
|
|
if (hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarModifiers(node) {
|
|
const quickResult = reportObviousModifierErrors(node);
|
|
if (quickResult !== void 0) {
|
|
return quickResult;
|
|
}
|
|
let lastStatic, lastDeclare, lastAsync, lastOverride;
|
|
let flags = 0 /* None */;
|
|
for (const modifier of node.modifiers) {
|
|
if (isDecorator(modifier))
|
|
continue;
|
|
if (modifier.kind !== 146 /* ReadonlyKeyword */) {
|
|
if (node.kind === 168 /* PropertySignature */ || node.kind === 170 /* MethodSignature */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_type_member, tokenToString(modifier.kind));
|
|
}
|
|
if (node.kind === 178 /* IndexSignature */ && (modifier.kind !== 124 /* StaticKeyword */ || !isClassLike(node.parent))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_an_index_signature, tokenToString(modifier.kind));
|
|
}
|
|
}
|
|
if (modifier.kind !== 101 /* InKeyword */ && modifier.kind !== 145 /* OutKeyword */) {
|
|
if (node.kind === 165 /* TypeParameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_type_parameter, tokenToString(modifier.kind));
|
|
}
|
|
}
|
|
switch (modifier.kind) {
|
|
case 85 /* ConstKeyword */:
|
|
if (node.kind !== 263 /* EnumDeclaration */) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_class_member_cannot_have_the_0_keyword, tokenToString(85 /* ConstKeyword */));
|
|
}
|
|
break;
|
|
case 161 /* OverrideKeyword */:
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "override");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "override", "declare");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "override", "async");
|
|
}
|
|
flags |= 16384 /* Override */;
|
|
lastOverride = modifier;
|
|
break;
|
|
case 123 /* PublicKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
const text = visibilityToString(modifierToFlag(modifier.kind));
|
|
if (flags & 28 /* AccessibilityModifier */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.Accessibility_modifier_already_seen);
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "override");
|
|
} else if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "static");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "async");
|
|
} else if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text);
|
|
} else if (flags & 256 /* Abstract */) {
|
|
if (modifier.kind === 121 /* PrivateKeyword */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract");
|
|
} else {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract");
|
|
}
|
|
} else if (isPrivateIdentifierClassElementDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier);
|
|
}
|
|
flags |= modifierToFlag(modifier.kind);
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "static");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "async");
|
|
} else if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor");
|
|
} else if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static");
|
|
} else if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "static", "override");
|
|
}
|
|
flags |= 32 /* Static */;
|
|
lastStatic = modifier;
|
|
break;
|
|
case 127 /* AccessorKeyword */:
|
|
if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "accessor");
|
|
} else if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare");
|
|
} else if (node.kind !== 169 /* PropertyDeclaration */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration);
|
|
}
|
|
flags |= 128 /* Accessor */;
|
|
break;
|
|
case 146 /* ReadonlyKeyword */:
|
|
if (flags & 64 /* Readonly */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "readonly");
|
|
} else if (node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 168 /* PropertySignature */ && node.kind !== 178 /* IndexSignature */ && node.kind !== 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature);
|
|
}
|
|
flags |= 64 /* Readonly */;
|
|
break;
|
|
case 93 /* ExportKeyword */:
|
|
if (flags & 1 /* Export */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "export");
|
|
} else if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare");
|
|
} else if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "async");
|
|
} else if (isClassLike(node.parent)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export");
|
|
}
|
|
flags |= 1 /* Export */;
|
|
break;
|
|
case 88 /* DefaultKeyword */:
|
|
const container = node.parent.kind === 308 /* SourceFile */ ? node.parent : node.parent.parent;
|
|
if (container.kind === 264 /* ModuleDeclaration */ && !isAmbientModule(container)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module);
|
|
} else if (!(flags & 1 /* Export */)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "export", "default");
|
|
}
|
|
flags |= 1024 /* Default */;
|
|
break;
|
|
case 136 /* DeclareKeyword */:
|
|
if (flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "declare");
|
|
} else if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
|
|
} else if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "override");
|
|
} else if (isClassLike(node.parent) && !isPropertyDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare");
|
|
} else if (node.parent.flags & 16777216 /* Ambient */ && node.parent.kind === 265 /* ModuleBlock */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context);
|
|
} else if (isPrivateIdentifierClassElementDeclaration(node)) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare");
|
|
}
|
|
flags |= 2 /* Ambient */;
|
|
lastDeclare = modifier;
|
|
break;
|
|
case 126 /* AbstractKeyword */:
|
|
if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "abstract");
|
|
}
|
|
if (node.kind !== 260 /* ClassDeclaration */ && node.kind !== 182 /* ConstructorType */) {
|
|
if (node.kind !== 171 /* MethodDeclaration */ && node.kind !== 169 /* PropertyDeclaration */ && node.kind !== 174 /* GetAccessor */ && node.kind !== 175 /* SetAccessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
|
|
}
|
|
if (!(node.parent.kind === 260 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
|
|
}
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
|
|
}
|
|
if (flags & 8 /* Private */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract");
|
|
}
|
|
if (flags & 512 /* Async */ && lastAsync) {
|
|
return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
|
|
}
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override");
|
|
}
|
|
if (flags & 128 /* Accessor */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor");
|
|
}
|
|
}
|
|
if (isNamedDeclaration(node) && node.name.kind === 80 /* PrivateIdentifier */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract");
|
|
}
|
|
flags |= 256 /* Abstract */;
|
|
break;
|
|
case 132 /* AsyncKeyword */:
|
|
if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, "async");
|
|
} else if (flags & 2 /* Ambient */ || node.parent.flags & 16777216 /* Ambient */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async");
|
|
} else if (node.kind === 166 /* Parameter */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async");
|
|
}
|
|
if (flags & 256 /* Abstract */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract");
|
|
}
|
|
flags |= 512 /* Async */;
|
|
lastAsync = modifier;
|
|
break;
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
const inOutFlag = modifier.kind === 101 /* InKeyword */ ? 32768 /* In */ : 65536 /* Out */;
|
|
const inOutText = modifier.kind === 101 /* InKeyword */ ? "in" : "out";
|
|
if (node.kind !== 165 /* TypeParameter */ || !(isInterfaceDeclaration(node.parent) || isClassLike(node.parent) || isTypeAliasDeclaration(node.parent))) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText);
|
|
}
|
|
if (flags & inOutFlag) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_already_seen, inOutText);
|
|
}
|
|
if (inOutFlag & 32768 /* In */ && flags & 65536 /* Out */) {
|
|
return grammarErrorOnNode(modifier, Diagnostics._0_modifier_must_precede_1_modifier, "in", "out");
|
|
}
|
|
flags |= inOutFlag;
|
|
break;
|
|
}
|
|
}
|
|
if (node.kind === 173 /* Constructor */) {
|
|
if (flags & 32 /* Static */) {
|
|
return grammarErrorOnNode(lastStatic, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static");
|
|
}
|
|
if (flags & 16384 /* Override */) {
|
|
return grammarErrorOnNode(lastOverride, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "override");
|
|
}
|
|
if (flags & 512 /* Async */) {
|
|
return grammarErrorOnNode(lastAsync, Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async");
|
|
}
|
|
return false;
|
|
} else if ((node.kind === 269 /* ImportDeclaration */ || node.kind === 268 /* ImportEqualsDeclaration */) && flags & 2 /* Ambient */) {
|
|
return grammarErrorOnNode(lastDeclare, Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare");
|
|
} else if (node.kind === 166 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && isBindingPattern(node.name)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern);
|
|
} else if (node.kind === 166 /* Parameter */ && flags & 16476 /* ParameterPropertyModifier */ && node.dotDotDotToken) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
|
|
}
|
|
if (flags & 512 /* Async */) {
|
|
return checkGrammarAsyncModifier(node, lastAsync);
|
|
}
|
|
return false;
|
|
}
|
|
function reportObviousModifierErrors(node) {
|
|
return !node.modifiers ? false : shouldReportBadModifier(node) ? grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here) : void 0;
|
|
}
|
|
function shouldReportBadModifier(node) {
|
|
switch (node.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 166 /* Parameter */:
|
|
case 165 /* TypeParameter */:
|
|
return false;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
case 181 /* FunctionType */:
|
|
case 279 /* MissingDeclaration */:
|
|
return true;
|
|
default:
|
|
if (node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
return false;
|
|
}
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return nodeHasAnyModifiersExcept(node, 132 /* AsyncKeyword */);
|
|
case 260 /* ClassDeclaration */:
|
|
case 182 /* ConstructorType */:
|
|
return nodeHasAnyModifiersExcept(node, 126 /* AbstractKeyword */);
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return true;
|
|
case 263 /* EnumDeclaration */:
|
|
return nodeHasAnyModifiersExcept(node, 85 /* ConstKeyword */);
|
|
default:
|
|
Debug.assertNever(node);
|
|
}
|
|
}
|
|
}
|
|
function nodeHasAnyModifiersExcept(node, allowedModifier) {
|
|
for (const modifier of node.modifiers) {
|
|
if (isDecorator(modifier))
|
|
continue;
|
|
return modifier.kind !== allowedModifier;
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarAsyncModifier(node, asyncModifier) {
|
|
switch (node.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return false;
|
|
}
|
|
return grammarErrorOnNode(asyncModifier, Diagnostics._0_modifier_cannot_be_used_here, "async");
|
|
}
|
|
function checkGrammarForDisallowedTrailingComma(list, diag2 = Diagnostics.Trailing_comma_not_allowed) {
|
|
if (list && list.hasTrailingComma) {
|
|
return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag2);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarTypeParameterList(typeParameters, file) {
|
|
if (typeParameters && typeParameters.length === 0) {
|
|
const start2 = typeParameters.pos - "<".length;
|
|
const end = skipTrivia(file.text, typeParameters.end) + ">".length;
|
|
return grammarErrorAtPos(file, start2, end - start2, Diagnostics.Type_parameter_list_cannot_be_empty);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarParameterList(parameters) {
|
|
let seenOptionalParameter = false;
|
|
const parameterCount = parameters.length;
|
|
for (let i = 0; i < parameterCount; i++) {
|
|
const parameter = parameters[i];
|
|
if (parameter.dotDotDotToken) {
|
|
if (i !== parameterCount - 1) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list);
|
|
}
|
|
if (!(parameter.flags & 16777216 /* Ambient */)) {
|
|
checkGrammarForDisallowedTrailingComma(parameters, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_rest_parameter_cannot_be_optional);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
|
|
}
|
|
} else if (isOptionalParameter(parameter)) {
|
|
seenOptionalParameter = true;
|
|
if (parameter.questionToken && parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
|
|
}
|
|
} else if (seenOptionalParameter && !parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter);
|
|
}
|
|
}
|
|
}
|
|
function getNonSimpleParameters(parameters) {
|
|
return filter(parameters, (parameter) => !!parameter.initializer || isBindingPattern(parameter.name) || isRestParameter(parameter));
|
|
}
|
|
function checkGrammarForUseStrictSimpleParameterList(node) {
|
|
if (languageVersion >= 3 /* ES2016 */) {
|
|
const useStrictDirective = node.body && isBlock(node.body) && findUseStrictPrologue(node.body.statements);
|
|
if (useStrictDirective) {
|
|
const nonSimpleParameters = getNonSimpleParameters(node.parameters);
|
|
if (length(nonSimpleParameters)) {
|
|
forEach(nonSimpleParameters, (parameter) => {
|
|
addRelatedInfo(
|
|
error(parameter, Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive),
|
|
createDiagnosticForNode(useStrictDirective, Diagnostics.use_strict_directive_used_here)
|
|
);
|
|
});
|
|
const diagnostics2 = nonSimpleParameters.map((parameter, index) => index === 0 ? createDiagnosticForNode(parameter, Diagnostics.Non_simple_parameter_declared_here) : createDiagnosticForNode(parameter, Diagnostics.and_here));
|
|
addRelatedInfo(error(useStrictDirective, Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list), ...diagnostics2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarFunctionLikeDeclaration(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) || checkGrammarParameterList(node.parameters) || checkGrammarArrowFunction(node, file) || isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node);
|
|
}
|
|
function checkGrammarClassLikeDeclaration(node) {
|
|
const file = getSourceFileOfNode(node);
|
|
return checkGrammarClassDeclarationHeritageClauses(node) || checkGrammarTypeParameterList(node.typeParameters, file);
|
|
}
|
|
function checkGrammarArrowFunction(node, file) {
|
|
if (!isArrowFunction(node)) {
|
|
return false;
|
|
}
|
|
if (node.typeParameters && !(length(node.typeParameters) > 1 || node.typeParameters.hasTrailingComma || node.typeParameters[0].constraint)) {
|
|
if (file && fileExtensionIsOneOf(file.fileName, [".mts" /* Mts */, ".cts" /* Cts */])) {
|
|
grammarErrorOnNode(node.typeParameters[0], Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint);
|
|
}
|
|
}
|
|
const { equalsGreaterThanToken } = node;
|
|
const startLine = getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line;
|
|
const endLine = getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line;
|
|
return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, Diagnostics.Line_terminator_not_permitted_before_arrow);
|
|
}
|
|
function checkGrammarIndexSignatureParameters(node) {
|
|
const parameter = node.parameters[0];
|
|
if (node.parameters.length !== 1) {
|
|
if (parameter) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
|
|
} else {
|
|
return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_exactly_one_parameter);
|
|
}
|
|
}
|
|
checkGrammarForDisallowedTrailingComma(node.parameters, Diagnostics.An_index_signature_cannot_have_a_trailing_comma);
|
|
if (parameter.dotDotDotToken) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.An_index_signature_cannot_have_a_rest_parameter);
|
|
}
|
|
if (hasEffectiveModifiers(parameter)) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_cannot_have_an_initializer);
|
|
}
|
|
if (!parameter.type) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_must_have_a_type_annotation);
|
|
}
|
|
const type = getTypeFromTypeNode(parameter.type);
|
|
if (someType(type, (t) => !!(t.flags & 8576 /* StringOrNumberLiteralOrUnique */)) || isGenericType(type)) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead);
|
|
}
|
|
if (!everyType(type, isValidIndexKeyType)) {
|
|
return grammarErrorOnNode(parameter.name, Diagnostics.An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type);
|
|
}
|
|
if (!node.type) {
|
|
return grammarErrorOnNode(node, Diagnostics.An_index_signature_must_have_a_type_annotation);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarIndexSignature(node) {
|
|
return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node);
|
|
}
|
|
function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) {
|
|
if (typeArguments && typeArguments.length === 0) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const start2 = typeArguments.pos - "<".length;
|
|
const end = skipTrivia(sourceFile.text, typeArguments.end) + ">".length;
|
|
return grammarErrorAtPos(sourceFile, start2, end - start2, Diagnostics.Type_argument_list_cannot_be_empty);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarTypeArguments(node, typeArguments) {
|
|
return checkGrammarForDisallowedTrailingComma(typeArguments) || checkGrammarForAtLeastOneTypeArgument(node, typeArguments);
|
|
}
|
|
function checkGrammarTaggedTemplateChain(node) {
|
|
if (node.questionDotToken || node.flags & 32 /* OptionalChain */) {
|
|
return grammarErrorOnNode(node.template, Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarHeritageClause(node) {
|
|
const types = node.types;
|
|
if (checkGrammarForDisallowedTrailingComma(types)) {
|
|
return true;
|
|
}
|
|
if (types && types.length === 0) {
|
|
const listType = tokenToString(node.token);
|
|
return grammarErrorAtPos(node, types.pos, 0, Diagnostics._0_list_cannot_be_empty, listType);
|
|
}
|
|
return some(types, checkGrammarExpressionWithTypeArguments);
|
|
}
|
|
function checkGrammarExpressionWithTypeArguments(node) {
|
|
if (isExpressionWithTypeArguments(node) && isImportKeyword(node.expression) && node.typeArguments) {
|
|
return grammarErrorOnNode(node, Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
|
|
}
|
|
return checkGrammarTypeArguments(node, node.typeArguments);
|
|
}
|
|
function checkGrammarClassDeclarationHeritageClauses(node) {
|
|
let seenExtendsClause = false;
|
|
let seenImplementsClause = false;
|
|
if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) {
|
|
for (const heritageClause of node.heritageClauses) {
|
|
if (heritageClause.token === 94 /* ExtendsKeyword */) {
|
|
if (seenExtendsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
|
|
}
|
|
if (seenImplementsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_must_precede_implements_clause);
|
|
}
|
|
if (heritageClause.types.length > 1) {
|
|
return grammarErrorOnFirstToken(heritageClause.types[1], Diagnostics.Classes_can_only_extend_a_single_class);
|
|
}
|
|
seenExtendsClause = true;
|
|
} else {
|
|
Debug.assert(heritageClause.token === 117 /* ImplementsKeyword */);
|
|
if (seenImplementsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.implements_clause_already_seen);
|
|
}
|
|
seenImplementsClause = true;
|
|
}
|
|
checkGrammarHeritageClause(heritageClause);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarInterfaceDeclaration(node) {
|
|
let seenExtendsClause = false;
|
|
if (node.heritageClauses) {
|
|
for (const heritageClause of node.heritageClauses) {
|
|
if (heritageClause.token === 94 /* ExtendsKeyword */) {
|
|
if (seenExtendsClause) {
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.extends_clause_already_seen);
|
|
}
|
|
seenExtendsClause = true;
|
|
} else {
|
|
Debug.assert(heritageClause.token === 117 /* ImplementsKeyword */);
|
|
return grammarErrorOnFirstToken(heritageClause, Diagnostics.Interface_declaration_cannot_have_implements_clause);
|
|
}
|
|
checkGrammarHeritageClause(heritageClause);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarComputedPropertyName(node) {
|
|
if (node.kind !== 164 /* ComputedPropertyName */) {
|
|
return false;
|
|
}
|
|
const computedPropertyName = node;
|
|
if (computedPropertyName.expression.kind === 223 /* BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 27 /* CommaToken */) {
|
|
return grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarForGenerator(node) {
|
|
if (node.asteriskToken) {
|
|
Debug.assert(
|
|
node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */ || node.kind === 171 /* MethodDeclaration */
|
|
);
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return grammarErrorOnNode(node.asteriskToken, Diagnostics.Generators_are_not_allowed_in_an_ambient_context);
|
|
}
|
|
if (!node.body) {
|
|
return grammarErrorOnNode(node.asteriskToken, Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarForInvalidQuestionMark(questionToken, message) {
|
|
return !!questionToken && grammarErrorOnNode(questionToken, message);
|
|
}
|
|
function checkGrammarForInvalidExclamationToken(exclamationToken, message) {
|
|
return !!exclamationToken && grammarErrorOnNode(exclamationToken, message);
|
|
}
|
|
function checkGrammarObjectLiteralExpression(node, inDestructuring) {
|
|
const seen = /* @__PURE__ */ new Map();
|
|
for (const prop of node.properties) {
|
|
if (prop.kind === 301 /* SpreadAssignment */) {
|
|
if (inDestructuring) {
|
|
const expression = skipParentheses(prop.expression);
|
|
if (isArrayLiteralExpression(expression) || isObjectLiteralExpression(expression)) {
|
|
return grammarErrorOnNode(prop.expression, Diagnostics.A_rest_element_cannot_contain_a_binding_pattern);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
const name = prop.name;
|
|
if (name.kind === 164 /* ComputedPropertyName */) {
|
|
checkGrammarComputedPropertyName(name);
|
|
}
|
|
if (prop.kind === 300 /* ShorthandPropertyAssignment */ && !inDestructuring && prop.objectAssignmentInitializer) {
|
|
grammarErrorOnNode(prop.equalsToken, Diagnostics.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);
|
|
}
|
|
if (name.kind === 80 /* PrivateIdentifier */) {
|
|
grammarErrorOnNode(name, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
|
|
}
|
|
if (canHaveModifiers(prop) && prop.modifiers) {
|
|
for (const mod of prop.modifiers) {
|
|
if (isModifier(mod) && (mod.kind !== 132 /* AsyncKeyword */ || prop.kind !== 171 /* MethodDeclaration */)) {
|
|
grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
|
|
}
|
|
}
|
|
} else if (canHaveIllegalModifiers(prop) && prop.modifiers) {
|
|
for (const mod of prop.modifiers) {
|
|
grammarErrorOnNode(mod, Diagnostics._0_modifier_cannot_be_used_here, getTextOfNode(mod));
|
|
}
|
|
}
|
|
let currentKind;
|
|
switch (prop.kind) {
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 299 /* PropertyAssignment */:
|
|
checkGrammarForInvalidExclamationToken(prop.exclamationToken, Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context);
|
|
checkGrammarForInvalidQuestionMark(prop.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional);
|
|
if (name.kind === 8 /* NumericLiteral */) {
|
|
checkGrammarNumericLiteral(name);
|
|
}
|
|
currentKind = 4 /* PropertyAssignment */;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
currentKind = 8 /* Method */;
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
currentKind = 1 /* GetAccessor */;
|
|
break;
|
|
case 175 /* SetAccessor */:
|
|
currentKind = 2 /* SetAccessor */;
|
|
break;
|
|
default:
|
|
throw Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
|
|
}
|
|
if (!inDestructuring) {
|
|
const effectiveName = getPropertyNameForPropertyNameNode(name);
|
|
if (effectiveName === void 0) {
|
|
continue;
|
|
}
|
|
const existingKind = seen.get(effectiveName);
|
|
if (!existingKind) {
|
|
seen.set(effectiveName, currentKind);
|
|
} else {
|
|
if (currentKind & 8 /* Method */ && existingKind & 8 /* Method */) {
|
|
grammarErrorOnNode(name, Diagnostics.Duplicate_identifier_0, getTextOfNode(name));
|
|
} else if (currentKind & 4 /* PropertyAssignment */ && existingKind & 4 /* PropertyAssignment */) {
|
|
grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name, getTextOfNode(name));
|
|
} else if (currentKind & 3 /* GetOrSetAccessor */ && existingKind & 3 /* GetOrSetAccessor */) {
|
|
if (existingKind !== 3 /* GetOrSetAccessor */ && currentKind !== existingKind) {
|
|
seen.set(effectiveName, currentKind | existingKind);
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name);
|
|
}
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxElement(node) {
|
|
checkGrammarJsxName(node.tagName);
|
|
checkGrammarTypeArguments(node, node.typeArguments);
|
|
const seen = /* @__PURE__ */ new Map();
|
|
for (const attr of node.attributes.properties) {
|
|
if (attr.kind === 290 /* JsxSpreadAttribute */) {
|
|
continue;
|
|
}
|
|
const { name, initializer } = attr;
|
|
if (!seen.get(name.escapedText)) {
|
|
seen.set(name.escapedText, true);
|
|
} else {
|
|
return grammarErrorOnNode(name, Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name);
|
|
}
|
|
if (initializer && initializer.kind === 291 /* JsxExpression */ && !initializer.expression) {
|
|
return grammarErrorOnNode(initializer, Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxName(node) {
|
|
if (isPropertyAccessExpression(node)) {
|
|
let propName = node;
|
|
do {
|
|
const check2 = checkGrammarJsxNestedIdentifier(propName.name);
|
|
if (check2) {
|
|
return check2;
|
|
}
|
|
propName = propName.expression;
|
|
} while (isPropertyAccessExpression(propName));
|
|
const check = checkGrammarJsxNestedIdentifier(propName);
|
|
if (check) {
|
|
return check;
|
|
}
|
|
}
|
|
function checkGrammarJsxNestedIdentifier(name) {
|
|
if (isIdentifier(name) && idText(name).indexOf(":") !== -1) {
|
|
return grammarErrorOnNode(name, Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarJsxExpression(node) {
|
|
if (node.expression && isCommaSequence(node.expression)) {
|
|
return grammarErrorOnNode(node.expression, Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array);
|
|
}
|
|
}
|
|
function checkGrammarForInOrForOfStatement(forInOrOfStatement) {
|
|
if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) {
|
|
return true;
|
|
}
|
|
if (forInOrOfStatement.kind === 247 /* ForOfStatement */ && forInOrOfStatement.awaitModifier) {
|
|
if (!(forInOrOfStatement.flags & 32768 /* AwaitContext */)) {
|
|
const sourceFile = getSourceFileOfNode(forInOrOfStatement);
|
|
if (isInTopLevelContext(forInOrOfStatement)) {
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
if (!isEffectiveExternalModule(sourceFile, compilerOptions)) {
|
|
diagnostics.add(createDiagnosticForNode(
|
|
forInOrOfStatement.awaitModifier,
|
|
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
|
|
));
|
|
}
|
|
switch (moduleKind) {
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
if (sourceFile.impliedNodeFormat === 1 /* CommonJS */) {
|
|
diagnostics.add(
|
|
createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)
|
|
);
|
|
break;
|
|
}
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 4 /* System */:
|
|
if (languageVersion >= 4 /* ES2017 */) {
|
|
break;
|
|
}
|
|
default:
|
|
diagnostics.add(
|
|
createDiagnosticForNode(
|
|
forInOrOfStatement.awaitModifier,
|
|
Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher
|
|
)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const diagnostic = createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
|
|
const func = getContainingFunction(forInOrOfStatement);
|
|
if (func && func.kind !== 173 /* Constructor */) {
|
|
Debug.assert((getFunctionFlags(func) & 2 /* Async */) === 0, "Enclosing function should never be an async function.");
|
|
const relatedInfo = createDiagnosticForNode(func, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
|
|
addRelatedInfo(diagnostic, relatedInfo);
|
|
}
|
|
diagnostics.add(diagnostic);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
if (isForOfStatement(forInOrOfStatement) && !(forInOrOfStatement.flags & 32768 /* AwaitContext */) && isIdentifier(forInOrOfStatement.initializer) && forInOrOfStatement.initializer.escapedText === "async") {
|
|
grammarErrorOnNode(forInOrOfStatement.initializer, Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async);
|
|
return false;
|
|
}
|
|
if (forInOrOfStatement.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variableList = forInOrOfStatement.initializer;
|
|
if (!checkGrammarVariableDeclarationList(variableList)) {
|
|
const declarations = variableList.declarations;
|
|
if (!declarations.length) {
|
|
return false;
|
|
}
|
|
if (declarations.length > 1) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement : Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement;
|
|
return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic);
|
|
}
|
|
const firstDeclaration = declarations[0];
|
|
if (firstDeclaration.initializer) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer : Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer;
|
|
return grammarErrorOnNode(firstDeclaration.name, diagnostic);
|
|
}
|
|
if (firstDeclaration.type) {
|
|
const diagnostic = forInOrOfStatement.kind === 246 /* ForInStatement */ ? Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation : Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation;
|
|
return grammarErrorOnNode(firstDeclaration, diagnostic);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarAccessor(accessor) {
|
|
if (!(accessor.flags & 16777216 /* Ambient */) && accessor.parent.kind !== 184 /* TypeLiteral */ && accessor.parent.kind !== 261 /* InterfaceDeclaration */) {
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(accessor.name)) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (accessor.body === void 0 && !hasSyntacticModifier(accessor, 256 /* Abstract */)) {
|
|
return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
|
|
}
|
|
}
|
|
if (accessor.body) {
|
|
if (hasSyntacticModifier(accessor, 256 /* Abstract */)) {
|
|
return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
|
|
}
|
|
if (accessor.parent.kind === 184 /* TypeLiteral */ || accessor.parent.kind === 261 /* InterfaceDeclaration */) {
|
|
return grammarErrorOnNode(accessor.body, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
|
|
}
|
|
}
|
|
if (accessor.typeParameters) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_have_type_parameters);
|
|
}
|
|
if (!doesAccessorHaveCorrectParameterCount(accessor)) {
|
|
return grammarErrorOnNode(
|
|
accessor.name,
|
|
accessor.kind === 174 /* GetAccessor */ ? Diagnostics.A_get_accessor_cannot_have_parameters : Diagnostics.A_set_accessor_must_have_exactly_one_parameter
|
|
);
|
|
}
|
|
if (accessor.kind === 175 /* SetAccessor */) {
|
|
if (accessor.type) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
|
|
}
|
|
const parameter = Debug.checkDefined(getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion.");
|
|
if (parameter.dotDotDotToken) {
|
|
return grammarErrorOnNode(parameter.dotDotDotToken, Diagnostics.A_set_accessor_cannot_have_rest_parameter);
|
|
}
|
|
if (parameter.questionToken) {
|
|
return grammarErrorOnNode(parameter.questionToken, Diagnostics.A_set_accessor_cannot_have_an_optional_parameter);
|
|
}
|
|
if (parameter.initializer) {
|
|
return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function doesAccessorHaveCorrectParameterCount(accessor) {
|
|
return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 174 /* GetAccessor */ ? 0 : 1);
|
|
}
|
|
function getAccessorThisParameter(accessor) {
|
|
if (accessor.parameters.length === (accessor.kind === 174 /* GetAccessor */ ? 1 : 2)) {
|
|
return getThisParameter(accessor);
|
|
}
|
|
}
|
|
function checkGrammarTypeOperatorNode(node) {
|
|
if (node.operator === 156 /* UniqueKeyword */) {
|
|
if (node.type.kind !== 153 /* SymbolKeyword */) {
|
|
return grammarErrorOnNode(node.type, Diagnostics._0_expected, tokenToString(153 /* SymbolKeyword */));
|
|
}
|
|
let parent2 = walkUpParenthesizedTypes(node.parent);
|
|
if (isInJSFile(parent2) && isJSDocTypeExpression(parent2)) {
|
|
const host2 = getJSDocHost(parent2);
|
|
if (host2) {
|
|
parent2 = getSingleVariableOfVariableStatement(host2) || host2;
|
|
}
|
|
}
|
|
switch (parent2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
const decl = parent2;
|
|
if (decl.name.kind !== 79 /* Identifier */) {
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name);
|
|
}
|
|
if (!isVariableDeclarationInVariableStatement(decl)) {
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement);
|
|
}
|
|
if (!(decl.parent.flags & 2 /* Const */)) {
|
|
return grammarErrorOnNode(parent2.name, Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const);
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (!isStatic(parent2) || !hasEffectiveReadonlyModifier(parent2)) {
|
|
return grammarErrorOnNode(parent2.name, Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly);
|
|
}
|
|
break;
|
|
case 168 /* PropertySignature */:
|
|
if (!hasSyntacticModifier(parent2, 64 /* Readonly */)) {
|
|
return grammarErrorOnNode(parent2.name, Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly);
|
|
}
|
|
break;
|
|
default:
|
|
return grammarErrorOnNode(node, Diagnostics.unique_symbol_types_are_not_allowed_here);
|
|
}
|
|
} else if (node.operator === 146 /* ReadonlyKeyword */) {
|
|
if (node.type.kind !== 185 /* ArrayType */ && node.type.kind !== 186 /* TupleType */) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, tokenToString(153 /* SymbolKeyword */));
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarForInvalidDynamicName(node, message) {
|
|
if (isNonBindableDynamicName(node)) {
|
|
return grammarErrorOnNode(node, message);
|
|
}
|
|
}
|
|
function checkGrammarMethod(node) {
|
|
if (checkGrammarFunctionLikeDeclaration(node)) {
|
|
return true;
|
|
}
|
|
if (node.kind === 171 /* MethodDeclaration */) {
|
|
if (node.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (node.modifiers && !(node.modifiers.length === 1 && first(node.modifiers).kind === 132 /* AsyncKeyword */)) {
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here);
|
|
} else if (checkGrammarForInvalidQuestionMark(node.questionToken, Diagnostics.An_object_member_cannot_be_declared_optional)) {
|
|
return true;
|
|
} else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) {
|
|
return true;
|
|
} else if (node.body === void 0) {
|
|
return grammarErrorAtPos(node, node.end - 1, ";".length, Diagnostics._0_expected, "{");
|
|
}
|
|
}
|
|
if (checkGrammarForGenerator(node)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (isClassLike(node.parent)) {
|
|
if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(node.name)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
|
|
} else if (node.kind === 171 /* MethodDeclaration */ && !node.body) {
|
|
return checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
|
|
}
|
|
} else if (node.parent.kind === 261 /* InterfaceDeclaration */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
|
|
} else if (node.parent.kind === 184 /* TypeLiteral */) {
|
|
return checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type);
|
|
}
|
|
}
|
|
function checkGrammarBreakOrContinueStatement(node) {
|
|
let current = node;
|
|
while (current) {
|
|
if (isFunctionLikeOrClassStaticBlockDeclaration(current)) {
|
|
return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);
|
|
}
|
|
switch (current.kind) {
|
|
case 253 /* LabeledStatement */:
|
|
if (node.label && current.label.escapedText === node.label.escapedText) {
|
|
const isMisplacedContinueLabel = node.kind === 248 /* ContinueStatement */ && !isIterationStatement(current.statement, true);
|
|
if (isMisplacedContinueLabel) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement);
|
|
}
|
|
return false;
|
|
}
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
if (node.kind === 249 /* BreakStatement */ && !node.label) {
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
if (isIterationStatement(current, false) && !node.label) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
current = current.parent;
|
|
}
|
|
if (node.label) {
|
|
const message = node.kind === 249 /* BreakStatement */ ? Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement : Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement;
|
|
return grammarErrorOnNode(node, message);
|
|
} else {
|
|
const message = node.kind === 249 /* BreakStatement */ ? Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement : Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement;
|
|
return grammarErrorOnNode(node, message);
|
|
}
|
|
}
|
|
function checkGrammarBindingElement(node) {
|
|
if (node.dotDotDotToken) {
|
|
const elements = node.parent.elements;
|
|
if (node !== last(elements)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
|
|
}
|
|
checkGrammarForDisallowedTrailingComma(elements, Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma);
|
|
if (node.propertyName) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.A_rest_element_cannot_have_a_property_name);
|
|
}
|
|
}
|
|
if (node.dotDotDotToken && node.initializer) {
|
|
return grammarErrorAtPos(node, node.initializer.pos - 1, 1, Diagnostics.A_rest_element_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
function isStringOrNumberLiteralExpression(expr) {
|
|
return isStringOrNumericLiteralLike(expr) || expr.kind === 221 /* PrefixUnaryExpression */ && expr.operator === 40 /* MinusToken */ && expr.operand.kind === 8 /* NumericLiteral */;
|
|
}
|
|
function isBigIntLiteralExpression(expr) {
|
|
return expr.kind === 9 /* BigIntLiteral */ || expr.kind === 221 /* PrefixUnaryExpression */ && expr.operator === 40 /* MinusToken */ && expr.operand.kind === 9 /* BigIntLiteral */;
|
|
}
|
|
function isSimpleLiteralEnumReference(expr) {
|
|
if ((isPropertyAccessExpression(expr) || isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression)) && isEntityNameExpression(expr.expression)) {
|
|
return !!(checkExpressionCached(expr).flags & 1024 /* EnumLiteral */);
|
|
}
|
|
}
|
|
function checkAmbientInitializer(node) {
|
|
const initializer = node.initializer;
|
|
if (initializer) {
|
|
const isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) || isSimpleLiteralEnumReference(initializer) || initializer.kind === 110 /* TrueKeyword */ || initializer.kind === 95 /* FalseKeyword */ || isBigIntLiteralExpression(initializer));
|
|
const isConstOrReadonly = isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node);
|
|
if (isConstOrReadonly && !node.type) {
|
|
if (isInvalidInitializer) {
|
|
return grammarErrorOnNode(initializer, Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference);
|
|
}
|
|
} else {
|
|
return grammarErrorOnNode(initializer, Diagnostics.Initializers_are_not_allowed_in_ambient_contexts);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarVariableDeclaration(node) {
|
|
if (node.parent.parent.kind !== 246 /* ForInStatement */ && node.parent.parent.kind !== 247 /* ForOfStatement */) {
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
checkAmbientInitializer(node);
|
|
} else if (!node.initializer) {
|
|
if (isBindingPattern(node.name) && !isBindingPattern(node.parent)) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_destructuring_declaration_must_have_an_initializer);
|
|
}
|
|
if (isVarConst(node)) {
|
|
return grammarErrorOnNode(node, Diagnostics.const_declarations_must_be_initialized);
|
|
}
|
|
}
|
|
}
|
|
if (node.exclamationToken && (node.parent.parent.kind !== 240 /* VariableStatement */ || !node.type || node.initializer || node.flags & 16777216 /* Ambient */)) {
|
|
const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
|
|
return grammarErrorOnNode(node.exclamationToken, message);
|
|
}
|
|
if ((moduleKind < 5 /* ES2015 */ || getSourceFileOfNode(node).impliedNodeFormat === 1 /* CommonJS */) && moduleKind !== 4 /* System */ && !(node.parent.parent.flags & 16777216 /* Ambient */) && hasSyntacticModifier(node.parent.parent, 1 /* Export */)) {
|
|
checkESModuleMarker(node.name);
|
|
}
|
|
const checkLetConstNames = isLet(node) || isVarConst(node);
|
|
return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name);
|
|
}
|
|
function checkESModuleMarker(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (idText(name) === "__esModule") {
|
|
return grammarErrorOnNodeSkippedOn("noEmit", name, Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules);
|
|
}
|
|
} else {
|
|
const elements = name.elements;
|
|
for (const element of elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
return checkESModuleMarker(element.name);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNameInLetOrConstDeclarations(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
if (name.originalKeywordKind === 119 /* LetKeyword */) {
|
|
return grammarErrorOnNode(name, Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations);
|
|
}
|
|
} else {
|
|
const elements = name.elements;
|
|
for (const element of elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
checkGrammarNameInLetOrConstDeclarations(element.name);
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarVariableDeclarationList(declarationList) {
|
|
const declarations = declarationList.declarations;
|
|
if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) {
|
|
return true;
|
|
}
|
|
if (!declarationList.declarations.length) {
|
|
return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, Diagnostics.Variable_declaration_list_cannot_be_empty);
|
|
}
|
|
return false;
|
|
}
|
|
function allowLetAndConstDeclarations(parent2) {
|
|
switch (parent2.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return false;
|
|
case 253 /* LabeledStatement */:
|
|
return allowLetAndConstDeclarations(parent2.parent);
|
|
}
|
|
return true;
|
|
}
|
|
function checkGrammarForDisallowedLetOrConstStatement(node) {
|
|
if (!allowLetAndConstDeclarations(node.parent)) {
|
|
if (isLet(node.declarationList)) {
|
|
return grammarErrorOnNode(node, Diagnostics.let_declarations_can_only_be_declared_inside_a_block);
|
|
} else if (isVarConst(node.declarationList)) {
|
|
return grammarErrorOnNode(node, Diagnostics.const_declarations_can_only_be_declared_inside_a_block);
|
|
}
|
|
}
|
|
}
|
|
function checkGrammarMetaProperty(node) {
|
|
const escapedText = node.name.escapedText;
|
|
switch (node.keywordToken) {
|
|
case 103 /* NewKeyword */:
|
|
if (escapedText !== "target") {
|
|
return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "target");
|
|
}
|
|
break;
|
|
case 100 /* ImportKeyword */:
|
|
if (escapedText !== "meta") {
|
|
return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "meta");
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function hasParseDiagnostics(sourceFile) {
|
|
return sourceFile.parseDiagnostics.length > 0;
|
|
}
|
|
function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorAtPos(nodeForSourceFile, start2, length2, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(nodeForSourceFile);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
diagnostics.add(createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
errorSkippedOn(key, node, message, arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarConstructorTypeParameters(node) {
|
|
const jsdocTypeParameters = isInJSFile(node) ? getJSDocTypeParameterDeclarations(node) : void 0;
|
|
const range = node.typeParameters || jsdocTypeParameters && firstOrUndefined(jsdocTypeParameters);
|
|
if (range) {
|
|
const pos = range.pos === range.end ? range.pos : skipTrivia(getSourceFileOfNode(node).text, range.pos);
|
|
return grammarErrorAtPos(node, pos, range.end - pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
|
|
}
|
|
}
|
|
function checkGrammarConstructorTypeAnnotation(node) {
|
|
const type = node.type || getEffectiveReturnTypeNode(node);
|
|
if (type) {
|
|
return grammarErrorOnNode(type, Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration);
|
|
}
|
|
}
|
|
function checkGrammarProperty(node) {
|
|
if (isComputedPropertyName(node.name) && isBinaryExpression(node.name.expression) && node.name.expression.operatorToken.kind === 101 /* InKeyword */) {
|
|
return grammarErrorOnNode(
|
|
node.parent.members[0],
|
|
Diagnostics.A_mapped_type_may_not_declare_properties_or_methods
|
|
);
|
|
}
|
|
if (isClassLike(node.parent)) {
|
|
if (isStringLiteral(node.name) && node.name.text === "constructor") {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Classes_may_not_have_a_field_named_constructor);
|
|
}
|
|
if (checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type)) {
|
|
return true;
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */ && isPrivateIdentifier(node.name)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */ && isAutoAccessorPropertyDeclaration(node)) {
|
|
return grammarErrorOnNode(node.name, Diagnostics.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher);
|
|
}
|
|
if (isAutoAccessorPropertyDeclaration(node) && checkGrammarForInvalidQuestionMark(node.questionToken, Diagnostics.An_accessor_property_cannot_be_declared_optional)) {
|
|
return true;
|
|
}
|
|
} else if (node.parent.kind === 261 /* InterfaceDeclaration */) {
|
|
if (checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
|
|
return true;
|
|
}
|
|
Debug.assertNode(node, isPropertySignature);
|
|
if (node.initializer) {
|
|
return grammarErrorOnNode(node.initializer, Diagnostics.An_interface_property_cannot_have_an_initializer);
|
|
}
|
|
} else if (isTypeLiteralNode(node.parent)) {
|
|
if (checkGrammarForInvalidDynamicName(node.name, Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) {
|
|
return true;
|
|
}
|
|
Debug.assertNode(node, isPropertySignature);
|
|
if (node.initializer) {
|
|
return grammarErrorOnNode(node.initializer, Diagnostics.A_type_literal_property_cannot_have_an_initializer);
|
|
}
|
|
}
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
checkAmbientInitializer(node);
|
|
}
|
|
if (isPropertyDeclaration(node) && node.exclamationToken && (!isClassLike(node.parent) || !node.type || node.initializer || node.flags & 16777216 /* Ambient */ || isStatic(node) || hasAbstractModifier(node))) {
|
|
const message = node.initializer ? Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions : !node.type ? Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations : Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context;
|
|
return grammarErrorOnNode(node.exclamationToken, message);
|
|
}
|
|
}
|
|
function checkGrammarTopLevelElementForRequiredDeclareModifier(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */ || node.kind === 262 /* TypeAliasDeclaration */ || node.kind === 269 /* ImportDeclaration */ || node.kind === 268 /* ImportEqualsDeclaration */ || node.kind === 275 /* ExportDeclaration */ || node.kind === 274 /* ExportAssignment */ || node.kind === 267 /* NamespaceExportDeclaration */ || hasSyntacticModifier(node, 2 /* Ambient */ | 1 /* Export */ | 1024 /* Default */)) {
|
|
return false;
|
|
}
|
|
return grammarErrorOnFirstToken(node, Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier);
|
|
}
|
|
function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) {
|
|
for (const decl of file.statements) {
|
|
if (isDeclaration(decl) || decl.kind === 240 /* VariableStatement */) {
|
|
if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarSourceFile(node) {
|
|
return !!(node.flags & 16777216 /* Ambient */) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node);
|
|
}
|
|
function checkGrammarStatementInAmbientContext(node) {
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
const links = getNodeLinks(node);
|
|
if (!links.hasReportedStatementInAmbientContext && (isFunctionLike(node.parent) || isAccessor(node.parent))) {
|
|
return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts);
|
|
}
|
|
if (node.parent.kind === 238 /* Block */ || node.parent.kind === 265 /* ModuleBlock */ || node.parent.kind === 308 /* SourceFile */) {
|
|
const links2 = getNodeLinks(node.parent);
|
|
if (!links2.hasReportedStatementInAmbientContext) {
|
|
return links2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, Diagnostics.Statements_are_not_allowed_in_ambient_contexts);
|
|
}
|
|
} else {
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNumericLiteral(node) {
|
|
if (node.numericLiteralFlags & 32 /* Octal */) {
|
|
let diagnosticMessage;
|
|
if (languageVersion >= 1 /* ES5 */) {
|
|
diagnosticMessage = Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0;
|
|
} else if (isChildOfNodeWithKind(node, 198 /* LiteralType */)) {
|
|
diagnosticMessage = Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0;
|
|
} else if (isChildOfNodeWithKind(node, 302 /* EnumMember */)) {
|
|
diagnosticMessage = Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0;
|
|
}
|
|
if (diagnosticMessage) {
|
|
const withMinus = isPrefixUnaryExpression(node.parent) && node.parent.operator === 40 /* MinusToken */;
|
|
const literal = (withMinus ? "-" : "") + "0o" + node.text;
|
|
return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal);
|
|
}
|
|
}
|
|
checkNumericLiteralValueSize(node);
|
|
return false;
|
|
}
|
|
function checkNumericLiteralValueSize(node) {
|
|
const isFractional = getTextOfNode(node).indexOf(".") !== -1;
|
|
const isScientific = node.numericLiteralFlags & 16 /* Scientific */;
|
|
if (isFractional || isScientific) {
|
|
return;
|
|
}
|
|
const value = +node.text;
|
|
if (value <= 2 ** 53 - 1) {
|
|
return;
|
|
}
|
|
addErrorOrSuggestion(false, createDiagnosticForNode(node, Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
|
|
}
|
|
function checkGrammarBigIntLiteral(node) {
|
|
const literalType = isLiteralTypeNode(node.parent) || isPrefixUnaryExpression(node.parent) && isLiteralTypeNode(node.parent.parent);
|
|
if (!literalType) {
|
|
if (languageVersion < 7 /* ES2020 */) {
|
|
if (grammarErrorOnNode(node, Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
if (!hasParseDiagnostics(sourceFile)) {
|
|
const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
|
|
diagnostics.add(createFileDiagnostic(sourceFile, textSpanEnd(span), 0, message, arg0, arg1, arg2));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getAmbientModules() {
|
|
if (!ambientModulesCache) {
|
|
ambientModulesCache = [];
|
|
globals.forEach((global2, sym) => {
|
|
if (ambientModuleSymbolRegex.test(sym)) {
|
|
ambientModulesCache.push(global2);
|
|
}
|
|
});
|
|
}
|
|
return ambientModulesCache;
|
|
}
|
|
function checkGrammarImportClause(node) {
|
|
var _a2;
|
|
if (node.isTypeOnly && node.name && node.namedBindings) {
|
|
return grammarErrorOnNode(node, Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both);
|
|
}
|
|
if (node.isTypeOnly && ((_a2 = node.namedBindings) == null ? void 0 : _a2.kind) === 272 /* NamedImports */) {
|
|
return checkGrammarNamedImportsOrExports(node.namedBindings);
|
|
}
|
|
return false;
|
|
}
|
|
function checkGrammarNamedImportsOrExports(namedBindings) {
|
|
return !!forEach(namedBindings.elements, (specifier) => {
|
|
if (specifier.isTypeOnly) {
|
|
return grammarErrorOnFirstToken(
|
|
specifier,
|
|
specifier.kind === 273 /* ImportSpecifier */ ? Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement : Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement
|
|
);
|
|
}
|
|
});
|
|
}
|
|
function checkGrammarImportCallExpression(node) {
|
|
if (moduleKind === 5 /* ES2015 */) {
|
|
return grammarErrorOnNode(node, Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext);
|
|
}
|
|
if (node.typeArguments) {
|
|
return grammarErrorOnNode(node, Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
|
|
}
|
|
const nodeArguments = node.arguments;
|
|
if (moduleKind !== 99 /* ESNext */ && moduleKind !== 199 /* NodeNext */ && moduleKind !== 100 /* Node16 */) {
|
|
checkGrammarForDisallowedTrailingComma(nodeArguments);
|
|
if (nodeArguments.length > 1) {
|
|
const assertionArgument = nodeArguments[1];
|
|
return grammarErrorOnNode(assertionArgument, Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext);
|
|
}
|
|
}
|
|
if (nodeArguments.length === 0 || nodeArguments.length > 2) {
|
|
return grammarErrorOnNode(node, Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments);
|
|
}
|
|
const spreadElement = find(nodeArguments, isSpreadElement);
|
|
if (spreadElement) {
|
|
return grammarErrorOnNode(spreadElement, Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element);
|
|
}
|
|
return false;
|
|
}
|
|
function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) {
|
|
const sourceObjectFlags = getObjectFlags(source);
|
|
if (sourceObjectFlags & (4 /* Reference */ | 16 /* Anonymous */) && unionTarget.flags & 1048576 /* Union */) {
|
|
return find(unionTarget.types, (target) => {
|
|
if (target.flags & 524288 /* Object */) {
|
|
const overlapObjFlags = sourceObjectFlags & getObjectFlags(target);
|
|
if (overlapObjFlags & 4 /* Reference */) {
|
|
return source.target === target.target;
|
|
}
|
|
if (overlapObjFlags & 16 /* Anonymous */) {
|
|
return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
function findBestTypeForObjectLiteral(source, unionTarget) {
|
|
if (getObjectFlags(source) & 128 /* ObjectLiteral */ && someType(unionTarget, isArrayLikeType)) {
|
|
return find(unionTarget.types, (t) => !isArrayLikeType(t));
|
|
}
|
|
}
|
|
function findBestTypeForInvokable(source, unionTarget) {
|
|
let signatureKind = 0 /* Call */;
|
|
const hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 || (signatureKind = 1 /* Construct */, getSignaturesOfType(source, signatureKind).length > 0);
|
|
if (hasSignatures) {
|
|
return find(unionTarget.types, (t) => getSignaturesOfType(t, signatureKind).length > 0);
|
|
}
|
|
}
|
|
function findMostOverlappyType(source, unionTarget) {
|
|
let bestMatch;
|
|
if (!(source.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
|
|
let matchingCount = 0;
|
|
for (const target of unionTarget.types) {
|
|
if (!(target.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
|
|
const overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
|
|
if (overlap.flags & 4194304 /* Index */) {
|
|
return target;
|
|
} else if (isUnitType(overlap) || overlap.flags & 1048576 /* Union */) {
|
|
const len = overlap.flags & 1048576 /* Union */ ? countWhere(overlap.types, isUnitType) : 1;
|
|
if (len >= matchingCount) {
|
|
bestMatch = target;
|
|
matchingCount = len;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return bestMatch;
|
|
}
|
|
function filterPrimitivesIfContainsNonPrimitive(type) {
|
|
if (maybeTypeOfKind(type, 67108864 /* NonPrimitive */)) {
|
|
const result = filterType(type, (t) => !(t.flags & 131068 /* Primitive */));
|
|
if (!(result.flags & 131072 /* Never */)) {
|
|
return result;
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) {
|
|
if (target.flags & 1048576 /* Union */ && source.flags & (2097152 /* Intersection */ | 524288 /* Object */)) {
|
|
const match = getMatchingUnionConstituentForType(target, source);
|
|
if (match) {
|
|
return match;
|
|
}
|
|
const sourceProperties = getPropertiesOfType(source);
|
|
if (sourceProperties) {
|
|
const sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target);
|
|
if (sourcePropertiesFiltered) {
|
|
return discriminateTypeByDiscriminableItems(target, map(sourcePropertiesFiltered, (p) => [() => getTypeOfSymbol(p), p.escapedName]), isRelatedTo, void 0, skipPartial);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function isNotAccessor(declaration) {
|
|
return !isAccessor(declaration);
|
|
}
|
|
function isNotOverload(declaration) {
|
|
return declaration.kind !== 259 /* FunctionDeclaration */ && declaration.kind !== 171 /* MethodDeclaration */ || !!declaration.body;
|
|
}
|
|
function isDeclarationNameOrImportPropertyName(name) {
|
|
switch (name.parent.kind) {
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
return isIdentifier(name);
|
|
default:
|
|
return isDeclarationName(name);
|
|
}
|
|
}
|
|
var JsxNames;
|
|
((JsxNames2) => {
|
|
JsxNames2.JSX = "JSX";
|
|
JsxNames2.IntrinsicElements = "IntrinsicElements";
|
|
JsxNames2.ElementClass = "ElementClass";
|
|
JsxNames2.ElementAttributesPropertyNameContainer = "ElementAttributesProperty";
|
|
JsxNames2.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute";
|
|
JsxNames2.Element = "Element";
|
|
JsxNames2.IntrinsicAttributes = "IntrinsicAttributes";
|
|
JsxNames2.IntrinsicClassAttributes = "IntrinsicClassAttributes";
|
|
JsxNames2.LibraryManagedAttributes = "LibraryManagedAttributes";
|
|
})(JsxNames || (JsxNames = {}));
|
|
function getIterationTypesKeyFromIterationTypeKind(typeKind) {
|
|
switch (typeKind) {
|
|
case 0 /* Yield */:
|
|
return "yieldType";
|
|
case 1 /* Return */:
|
|
return "returnType";
|
|
case 2 /* Next */:
|
|
return "nextType";
|
|
}
|
|
}
|
|
function signatureHasRestParameter(s) {
|
|
return !!(s.flags & 1 /* HasRestParameter */);
|
|
}
|
|
function signatureHasLiteralTypes(s) {
|
|
return !!(s.flags & 2 /* HasLiteralTypes */);
|
|
}
|
|
|
|
// src/compiler/visitorPublic.ts
|
|
function visitNode(node, visitor, test, lift) {
|
|
if (node === void 0 || visitor === void 0) {
|
|
return node;
|
|
}
|
|
const visited = visitor(node);
|
|
if (visited === node) {
|
|
return node;
|
|
}
|
|
let visitedNode;
|
|
if (visited === void 0) {
|
|
return void 0;
|
|
} else if (isArray(visited)) {
|
|
visitedNode = (lift || extractSingleNode)(visited);
|
|
} else {
|
|
visitedNode = visited;
|
|
}
|
|
Debug.assertNode(visitedNode, test);
|
|
return visitedNode;
|
|
}
|
|
function visitNodes2(nodes, visitor, test, start2, count) {
|
|
if (nodes === void 0 || visitor === void 0) {
|
|
return nodes;
|
|
}
|
|
const length2 = nodes.length;
|
|
if (start2 === void 0 || start2 < 0) {
|
|
start2 = 0;
|
|
}
|
|
if (count === void 0 || count > length2 - start2) {
|
|
count = length2 - start2;
|
|
}
|
|
let hasTrailingComma;
|
|
let pos = -1;
|
|
let end = -1;
|
|
if (start2 > 0 || count < length2) {
|
|
hasTrailingComma = nodes.hasTrailingComma && start2 + count === length2;
|
|
} else {
|
|
pos = nodes.pos;
|
|
end = nodes.end;
|
|
hasTrailingComma = nodes.hasTrailingComma;
|
|
}
|
|
const updated = visitArrayWorker(nodes, visitor, test, start2, count);
|
|
if (updated !== nodes) {
|
|
const updatedArray = factory.createNodeArray(updated, hasTrailingComma);
|
|
setTextRangePosEnd(updatedArray, pos, end);
|
|
return updatedArray;
|
|
}
|
|
return nodes;
|
|
}
|
|
function visitArray(nodes, visitor, test, start2, count) {
|
|
if (nodes === void 0) {
|
|
return nodes;
|
|
}
|
|
const length2 = nodes.length;
|
|
if (start2 === void 0 || start2 < 0) {
|
|
start2 = 0;
|
|
}
|
|
if (count === void 0 || count > length2 - start2) {
|
|
count = length2 - start2;
|
|
}
|
|
return visitArrayWorker(nodes, visitor, test, start2, count);
|
|
}
|
|
function visitArrayWorker(nodes, visitor, test, start2, count) {
|
|
let updated;
|
|
const length2 = nodes.length;
|
|
if (start2 > 0 || count < length2) {
|
|
updated = [];
|
|
}
|
|
for (let i = 0; i < count; i++) {
|
|
const node = nodes[i + start2];
|
|
const visited = node !== void 0 ? visitor(node) : void 0;
|
|
if (updated !== void 0 || visited === void 0 || visited !== node) {
|
|
if (updated === void 0) {
|
|
updated = nodes.slice(0, i);
|
|
}
|
|
if (visited) {
|
|
if (isArray(visited)) {
|
|
for (const visitedNode of visited) {
|
|
void Debug.assertNode(visitedNode, test);
|
|
updated.push(visitedNode);
|
|
}
|
|
} else {
|
|
void Debug.assertNode(visited, test);
|
|
updated.push(visited);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return updated != null ? updated : nodes;
|
|
}
|
|
function visitLexicalEnvironment(statements, visitor, context, start2, ensureUseStrict, nodesVisitor = visitNodes2) {
|
|
context.startLexicalEnvironment();
|
|
statements = nodesVisitor(statements, visitor, isStatement, start2);
|
|
if (ensureUseStrict)
|
|
statements = context.factory.ensureUseStrict(statements);
|
|
return factory.mergeLexicalEnvironment(statements, context.endLexicalEnvironment());
|
|
}
|
|
function visitParameterList(nodes, visitor, context, nodesVisitor = visitNodes2) {
|
|
let updated;
|
|
context.startLexicalEnvironment();
|
|
if (nodes) {
|
|
context.setLexicalEnvironmentFlags(1 /* InParameters */, true);
|
|
updated = nodesVisitor(nodes, visitor, isParameterDeclaration);
|
|
if (context.getLexicalEnvironmentFlags() & 2 /* VariablesHoistedInParameters */ && getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ES2015 */) {
|
|
updated = addDefaultValueAssignmentsIfNeeded(updated, context);
|
|
}
|
|
context.setLexicalEnvironmentFlags(1 /* InParameters */, false);
|
|
}
|
|
context.suspendLexicalEnvironment();
|
|
return updated;
|
|
}
|
|
function addDefaultValueAssignmentsIfNeeded(parameters, context) {
|
|
let result;
|
|
for (let i = 0; i < parameters.length; i++) {
|
|
const parameter = parameters[i];
|
|
const updated = addDefaultValueAssignmentIfNeeded(parameter, context);
|
|
if (result || updated !== parameter) {
|
|
if (!result)
|
|
result = parameters.slice(0, i);
|
|
result[i] = updated;
|
|
}
|
|
}
|
|
if (result) {
|
|
return setTextRange(context.factory.createNodeArray(result, parameters.hasTrailingComma), parameters);
|
|
}
|
|
return parameters;
|
|
}
|
|
function addDefaultValueAssignmentIfNeeded(parameter, context) {
|
|
return parameter.dotDotDotToken ? parameter : isBindingPattern(parameter.name) ? addDefaultValueAssignmentForBindingPattern(parameter, context) : parameter.initializer ? addDefaultValueAssignmentForInitializer(parameter, parameter.name, parameter.initializer, context) : parameter;
|
|
}
|
|
function addDefaultValueAssignmentForBindingPattern(parameter, context) {
|
|
const { factory: factory2 } = context;
|
|
context.addInitializationStatement(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
parameter.name,
|
|
void 0,
|
|
parameter.type,
|
|
parameter.initializer ? factory2.createConditionalExpression(
|
|
factory2.createStrictEquality(
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
factory2.createVoidZero()
|
|
),
|
|
void 0,
|
|
parameter.initializer,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
) : factory2.getGeneratedNameForNode(parameter)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
return factory2.updateParameterDeclaration(
|
|
parameter,
|
|
parameter.modifiers,
|
|
parameter.dotDotDotToken,
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
parameter.questionToken,
|
|
parameter.type,
|
|
void 0
|
|
);
|
|
}
|
|
function addDefaultValueAssignmentForInitializer(parameter, name, initializer, context) {
|
|
const factory2 = context.factory;
|
|
context.addInitializationStatement(
|
|
factory2.createIfStatement(
|
|
factory2.createTypeCheck(factory2.cloneNode(name), "undefined"),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
setEmitFlags(factory2.cloneNode(name), 96 /* NoSourceMap */),
|
|
setEmitFlags(initializer, 96 /* NoSourceMap */ | getEmitFlags(initializer) | 3072 /* NoComments */)
|
|
),
|
|
parameter
|
|
),
|
|
3072 /* NoComments */
|
|
)
|
|
)
|
|
]),
|
|
parameter
|
|
),
|
|
1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */
|
|
)
|
|
)
|
|
);
|
|
return factory2.updateParameterDeclaration(
|
|
parameter,
|
|
parameter.modifiers,
|
|
parameter.dotDotDotToken,
|
|
parameter.name,
|
|
parameter.questionToken,
|
|
parameter.type,
|
|
void 0
|
|
);
|
|
}
|
|
function visitFunctionBody(node, visitor, context, nodeVisitor = visitNode) {
|
|
context.resumeLexicalEnvironment();
|
|
const updated = nodeVisitor(node, visitor, isConciseBody);
|
|
const declarations = context.endLexicalEnvironment();
|
|
if (some(declarations)) {
|
|
if (!updated) {
|
|
return context.factory.createBlock(declarations);
|
|
}
|
|
const block = context.factory.converters.convertToFunctionBlock(updated);
|
|
const statements = factory.mergeLexicalEnvironment(block.statements, declarations);
|
|
return context.factory.updateBlock(block, statements);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitIterationBody(body, visitor, context, nodeVisitor = visitNode) {
|
|
context.startBlockScope();
|
|
const updated = nodeVisitor(body, visitor, isStatement, context.factory.liftToBlock);
|
|
const declarations = context.endBlockScope();
|
|
if (some(declarations)) {
|
|
if (isBlock(updated)) {
|
|
declarations.push(...updated.statements);
|
|
return context.factory.updateBlock(updated, declarations);
|
|
}
|
|
declarations.push(updated);
|
|
return context.factory.createBlock(declarations);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitEachChild(node, visitor, context, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
|
|
if (node === void 0) {
|
|
return void 0;
|
|
}
|
|
const fn = visitEachChildTable[node.kind];
|
|
return fn === void 0 ? node : fn(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor);
|
|
}
|
|
var visitEachChildTable = {
|
|
[79 /* Identifier */]: function visitEachChildOfIdentifier(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIdentifier(
|
|
node,
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration)
|
|
);
|
|
},
|
|
[163 /* QualifiedName */]: function visitEachChildOfQualifiedName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateQualifiedName(
|
|
node,
|
|
nodeVisitor(node.left, visitor, isEntityName),
|
|
nodeVisitor(node.right, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[164 /* ComputedPropertyName */]: function visitEachChildOfComputedPropertyName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateComputedPropertyName(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[165 /* TypeParameter */]: function visitEachChildOfTypeParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeParameterDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.constraint, visitor, isTypeNode),
|
|
nodeVisitor(node.default, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[166 /* Parameter */]: function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateParameterDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[167 /* Decorator */]: function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDecorator(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[168 /* PropertySignature */]: function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updatePropertySignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[169 /* PropertyDeclaration */]: function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
var _a2;
|
|
return context.factory.updatePropertyDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor((_a2 = node.questionToken) != null ? _a2 : node.exclamationToken, tokenVisitor, isQuestionOrExclamationToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[170 /* MethodSignature */]: function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMethodSignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[171 /* MethodDeclaration */]: function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMethodDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[173 /* Constructor */]: function visitEachChildOfConstructorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[174 /* GetAccessor */]: function visitEachChildOfGetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateGetAccessorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[175 /* SetAccessor */]: function visitEachChildOfSetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSetAccessorDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[172 /* ClassStaticBlockDeclaration */]: function visitEachChildOfClassStaticBlockDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
context.startLexicalEnvironment();
|
|
context.suspendLexicalEnvironment();
|
|
return context.factory.updateClassStaticBlockDeclaration(
|
|
node,
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[176 /* CallSignature */]: function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCallSignature(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[177 /* ConstructSignature */]: function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructSignature(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[178 /* IndexSignature */]: function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIndexSignature(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[179 /* TypePredicate */]: function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypePredicateNode(
|
|
node,
|
|
nodeVisitor(node.assertsModifier, visitor, isAssertsKeyword),
|
|
nodeVisitor(node.parameterName, visitor, isIdentifierOrThisTypeNode),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[180 /* TypeReference */]: function visitEachChildOfTypeReferenceNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeReferenceNode(
|
|
node,
|
|
nodeVisitor(node.typeName, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[181 /* FunctionType */]: function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateFunctionTypeNode(
|
|
node,
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[182 /* ConstructorType */]: function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConstructorTypeNode(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.parameters, visitor, isParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[183 /* TypeQuery */]: function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeQueryNode(
|
|
node,
|
|
nodeVisitor(node.exprName, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[184 /* TypeLiteral */]: function visitEachChildOfTypeLiteralNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeLiteralNode(
|
|
node,
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[185 /* ArrayType */]: function visitEachChildOfArrayTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayTypeNode(
|
|
node,
|
|
nodeVisitor(node.elementType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[186 /* TupleType */]: function visitEachChildOfTupleTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTupleTypeNode(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[187 /* OptionalType */]: function visitEachChildOfOptionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateOptionalTypeNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[188 /* RestType */]: function visitEachChildOfRestTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateRestTypeNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[189 /* UnionType */]: function visitEachChildOfUnionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateUnionTypeNode(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[190 /* IntersectionType */]: function visitEachChildOfIntersectionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIntersectionTypeNode(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[191 /* ConditionalType */]: function visitEachChildOfConditionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateConditionalTypeNode(
|
|
node,
|
|
nodeVisitor(node.checkType, visitor, isTypeNode),
|
|
nodeVisitor(node.extendsType, visitor, isTypeNode),
|
|
nodeVisitor(node.trueType, visitor, isTypeNode),
|
|
nodeVisitor(node.falseType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[192 /* InferType */]: function visitEachChildOfInferTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateInferTypeNode(
|
|
node,
|
|
nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration)
|
|
);
|
|
},
|
|
[202 /* ImportType */]: function visitEachChildOfImportTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportTypeNode(
|
|
node,
|
|
nodeVisitor(node.argument, visitor, isTypeNode),
|
|
nodeVisitor(node.assertions, visitor, isImportTypeAssertionContainer),
|
|
nodeVisitor(node.qualifier, visitor, isEntityName),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
node.isTypeOf
|
|
);
|
|
},
|
|
[298 /* ImportTypeAssertionContainer */]: function visitEachChildOfImportTypeAssertionContainer(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportTypeAssertionContainer(
|
|
node,
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause),
|
|
node.multiLine
|
|
);
|
|
},
|
|
[199 /* NamedTupleMember */]: function visitEachChildOfNamedTupleMember(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateNamedTupleMember(
|
|
node,
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[193 /* ParenthesizedType */]: function visitEachChildOfParenthesizedType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateParenthesizedType(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[195 /* TypeOperator */]: function visitEachChildOfTypeOperatorNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeOperatorNode(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[196 /* IndexedAccessType */]: function visitEachChildOfIndexedAccessType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIndexedAccessTypeNode(
|
|
node,
|
|
nodeVisitor(node.objectType, visitor, isTypeNode),
|
|
nodeVisitor(node.indexType, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[197 /* MappedType */]: function visitEachChildOfMappedType(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateMappedTypeNode(
|
|
node,
|
|
nodeVisitor(node.readonlyToken, tokenVisitor, isReadonlyKeywordOrPlusOrMinusToken),
|
|
nodeVisitor(node.typeParameter, visitor, isTypeParameterDeclaration),
|
|
nodeVisitor(node.nameType, visitor, isTypeNode),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionOrPlusOrMinusToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[198 /* LiteralType */]: function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateLiteralTypeNode(
|
|
node,
|
|
nodeVisitor(node.literal, visitor, isExpression)
|
|
);
|
|
},
|
|
[200 /* TemplateLiteralType */]: function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateLiteralType(
|
|
node,
|
|
nodeVisitor(node.head, visitor, isTemplateHead),
|
|
nodesVisitor(node.templateSpans, visitor, isTemplateLiteralTypeSpan)
|
|
);
|
|
},
|
|
[201 /* TemplateLiteralTypeSpan */]: function visitEachChildOfTemplateLiteralTypeSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateLiteralTypeSpan(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)
|
|
);
|
|
},
|
|
[203 /* ObjectBindingPattern */]: function visitEachChildOfObjectBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateObjectBindingPattern(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isBindingElement)
|
|
);
|
|
},
|
|
[204 /* ArrayBindingPattern */]: function visitEachChildOfArrayBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayBindingPattern(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isArrayBindingElement)
|
|
);
|
|
},
|
|
[205 /* BindingElement */]: function visitEachChildOfBindingElement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateBindingElement(
|
|
node,
|
|
nodeVisitor(node.dotDotDotToken, tokenVisitor, isDotDotDotToken),
|
|
nodeVisitor(node.propertyName, visitor, isPropertyName),
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[206 /* ArrayLiteralExpression */]: function visitEachChildOfArrayLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateArrayLiteralExpression(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExpression)
|
|
);
|
|
},
|
|
[207 /* ObjectLiteralExpression */]: function visitEachChildOfObjectLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateObjectLiteralExpression(
|
|
node,
|
|
nodesVisitor(node.properties, visitor, isObjectLiteralElementLike)
|
|
);
|
|
},
|
|
[208 /* PropertyAccessExpression */]: function visitEachChildOfPropertyAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isPropertyAccessChain(node) ? context.factory.updatePropertyAccessChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodeVisitor(node.name, visitor, isMemberName)
|
|
) : context.factory.updatePropertyAccessExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.name, visitor, isMemberName)
|
|
);
|
|
},
|
|
[209 /* ElementAccessExpression */]: function visitEachChildOfElementAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isElementAccessChain(node) ? context.factory.updateElementAccessChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodeVisitor(node.argumentExpression, visitor, isExpression)
|
|
) : context.factory.updateElementAccessExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
},
|
|
[210 /* CallExpression */]: function visitEachChildOfCallExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return isCallChain(node) ? context.factory.updateCallChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.questionDotToken, tokenVisitor, isQuestionDotToken),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
) : context.factory.updateCallExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
);
|
|
},
|
|
[211 /* NewExpression */]: function visitEachChildOfNewExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNewExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodesVisitor(node.arguments, visitor, isExpression)
|
|
);
|
|
},
|
|
[212 /* TaggedTemplateExpression */]: function visitEachChildOfTaggedTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTaggedTemplateExpression(
|
|
node,
|
|
nodeVisitor(node.tag, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
},
|
|
[213 /* TypeAssertionExpression */]: function visitEachChildOfTypeAssertionExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeAssertion(
|
|
node,
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[214 /* ParenthesizedExpression */]: function visitEachChildOfParenthesizedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateParenthesizedExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[215 /* FunctionExpression */]: function visitEachChildOfFunctionExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateFunctionExpression(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[216 /* ArrowFunction */]: function visitEachChildOfArrowFunction(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateArrowFunction(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, isEqualsGreaterThanToken),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[217 /* DeleteExpression */]: function visitEachChildOfDeleteExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDeleteExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[218 /* TypeOfExpression */]: function visitEachChildOfTypeOfExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeOfExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[219 /* VoidExpression */]: function visitEachChildOfVoidExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVoidExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[220 /* AwaitExpression */]: function visitEachChildOfAwaitExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAwaitExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[221 /* PrefixUnaryExpression */]: function visitEachChildOfPrefixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePrefixUnaryExpression(
|
|
node,
|
|
nodeVisitor(node.operand, visitor, isExpression)
|
|
);
|
|
},
|
|
[222 /* PostfixUnaryExpression */]: function visitEachChildOfPostfixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePostfixUnaryExpression(
|
|
node,
|
|
nodeVisitor(node.operand, visitor, isExpression)
|
|
);
|
|
},
|
|
[223 /* BinaryExpression */]: function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateBinaryExpression(
|
|
node,
|
|
nodeVisitor(node.left, visitor, isExpression),
|
|
nodeVisitor(node.operatorToken, tokenVisitor, isBinaryOperatorToken),
|
|
nodeVisitor(node.right, visitor, isExpression)
|
|
);
|
|
},
|
|
[224 /* ConditionalExpression */]: function visitEachChildOfConditionalExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateConditionalExpression(
|
|
node,
|
|
nodeVisitor(node.condition, visitor, isExpression),
|
|
nodeVisitor(node.questionToken, tokenVisitor, isQuestionToken),
|
|
nodeVisitor(node.whenTrue, visitor, isExpression),
|
|
nodeVisitor(node.colonToken, tokenVisitor, isColonToken),
|
|
nodeVisitor(node.whenFalse, visitor, isExpression)
|
|
);
|
|
},
|
|
[225 /* TemplateExpression */]: function visitEachChildOfTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateExpression(
|
|
node,
|
|
nodeVisitor(node.head, visitor, isTemplateHead),
|
|
nodesVisitor(node.templateSpans, visitor, isTemplateSpan)
|
|
);
|
|
},
|
|
[226 /* YieldExpression */]: function visitEachChildOfYieldExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateYieldExpression(
|
|
node,
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[227 /* SpreadElement */]: function visitEachChildOfSpreadElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSpreadElement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[228 /* ClassExpression */]: function visitEachChildOfClassExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateClassExpression(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isClassElement)
|
|
);
|
|
},
|
|
[230 /* ExpressionWithTypeArguments */]: function visitEachChildOfExpressionWithTypeArguments(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExpressionWithTypeArguments(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[231 /* AsExpression */]: function visitEachChildOfAsExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAsExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[235 /* SatisfiesExpression */]: function visitEachChildOfSatisfiesExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSatisfiesExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[232 /* NonNullExpression */]: function visitEachChildOfNonNullExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return isOptionalChain(node) ? context.factory.updateNonNullChain(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
) : context.factory.updateNonNullExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[233 /* MetaProperty */]: function visitEachChildOfMetaProperty(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateMetaProperty(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[236 /* TemplateSpan */]: function visitEachChildOfTemplateSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTemplateSpan(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.literal, visitor, isTemplateMiddleOrTemplateTail)
|
|
);
|
|
},
|
|
[238 /* Block */]: function visitEachChildOfBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateBlock(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[240 /* VariableStatement */]: function visitEachChildOfVariableStatement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVariableStatement(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.declarationList, visitor, isVariableDeclarationList)
|
|
);
|
|
},
|
|
[241 /* ExpressionStatement */]: function visitEachChildOfExpressionStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExpressionStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[242 /* IfStatement */]: function visitEachChildOfIfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateIfStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.thenStatement, visitor, isStatement, context.factory.liftToBlock),
|
|
nodeVisitor(node.elseStatement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[243 /* DoStatement */]: function visitEachChildOfDoStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDoStatement(
|
|
node,
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[244 /* WhileStatement */]: function visitEachChildOfWhileStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateWhileStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[245 /* ForStatement */]: function visitEachChildOfForStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateForStatement(
|
|
node,
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.condition, visitor, isExpression),
|
|
nodeVisitor(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[246 /* ForInStatement */]: function visitEachChildOfForInStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateForInStatement(
|
|
node,
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[247 /* ForOfStatement */]: function visitEachChildOfForOfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateForOfStatement(
|
|
node,
|
|
nodeVisitor(node.awaitModifier, tokenVisitor, isAwaitKeyword),
|
|
nodeVisitor(node.initializer, visitor, isForInitializer),
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[248 /* ContinueStatement */]: function visitEachChildOfContinueStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateContinueStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[249 /* BreakStatement */]: function visitEachChildOfBreakStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateBreakStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[250 /* ReturnStatement */]: function visitEachChildOfReturnStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateReturnStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[251 /* WithStatement */]: function visitEachChildOfWithStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateWithStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[252 /* SwitchStatement */]: function visitEachChildOfSwitchStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSwitchStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodeVisitor(node.caseBlock, visitor, isCaseBlock)
|
|
);
|
|
},
|
|
[253 /* LabeledStatement */]: function visitEachChildOfLabeledStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateLabeledStatement(
|
|
node,
|
|
nodeVisitor(node.label, visitor, isIdentifier),
|
|
nodeVisitor(node.statement, visitor, isStatement, context.factory.liftToBlock)
|
|
);
|
|
},
|
|
[254 /* ThrowStatement */]: function visitEachChildOfThrowStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateThrowStatement(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[255 /* TryStatement */]: function visitEachChildOfTryStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTryStatement(
|
|
node,
|
|
nodeVisitor(node.tryBlock, visitor, isBlock),
|
|
nodeVisitor(node.catchClause, visitor, isCatchClause),
|
|
nodeVisitor(node.finallyBlock, visitor, isBlock)
|
|
);
|
|
},
|
|
[257 /* VariableDeclaration */]: function visitEachChildOfVariableDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateVariableDeclaration(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isBindingName),
|
|
nodeVisitor(node.exclamationToken, tokenVisitor, isExclamationToken),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[258 /* VariableDeclarationList */]: function visitEachChildOfVariableDeclarationList(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateVariableDeclarationList(
|
|
node,
|
|
nodesVisitor(node.declarations, visitor, isVariableDeclaration)
|
|
);
|
|
},
|
|
[259 /* FunctionDeclaration */]: function visitEachChildOfFunctionDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
|
|
return context.factory.updateFunctionDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.asteriskToken, tokenVisitor, isAsteriskToken),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
visitParameterList(node.parameters, visitor, context, nodesVisitor),
|
|
nodeVisitor(node.type, visitor, isTypeNode),
|
|
visitFunctionBody(node.body, visitor, context, nodeVisitor)
|
|
);
|
|
},
|
|
[260 /* ClassDeclaration */]: function visitEachChildOfClassDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateClassDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifierLike),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isClassElement)
|
|
);
|
|
},
|
|
[261 /* InterfaceDeclaration */]: function visitEachChildOfInterfaceDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateInterfaceDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodesVisitor(node.heritageClauses, visitor, isHeritageClause),
|
|
nodesVisitor(node.members, visitor, isTypeElement)
|
|
);
|
|
},
|
|
[262 /* TypeAliasDeclaration */]: function visitEachChildOfTypeAliasDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateTypeAliasDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration),
|
|
nodeVisitor(node.type, visitor, isTypeNode)
|
|
);
|
|
},
|
|
[263 /* EnumDeclaration */]: function visitEachChildOfEnumDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateEnumDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodesVisitor(node.members, visitor, isEnumMember)
|
|
);
|
|
},
|
|
[264 /* ModuleDeclaration */]: function visitEachChildOfModuleDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateModuleDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.name, visitor, isModuleName),
|
|
nodeVisitor(node.body, visitor, isModuleBody)
|
|
);
|
|
},
|
|
[265 /* ModuleBlock */]: function visitEachChildOfModuleBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateModuleBlock(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[266 /* CaseBlock */]: function visitEachChildOfCaseBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCaseBlock(
|
|
node,
|
|
nodesVisitor(node.clauses, visitor, isCaseOrDefaultClause)
|
|
);
|
|
},
|
|
[267 /* NamespaceExportDeclaration */]: function visitEachChildOfNamespaceExportDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceExportDeclaration(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[268 /* ImportEqualsDeclaration */]: function visitEachChildOfImportEqualsDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportEqualsDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.moduleReference, visitor, isModuleReference)
|
|
);
|
|
},
|
|
[269 /* ImportDeclaration */]: function visitEachChildOfImportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.importClause, visitor, isImportClause),
|
|
nodeVisitor(node.moduleSpecifier, visitor, isExpression),
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause)
|
|
);
|
|
},
|
|
[296 /* AssertClause */]: function visitEachChildOfAssertClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAssertClause(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isAssertEntry),
|
|
node.multiLine
|
|
);
|
|
},
|
|
[297 /* AssertEntry */]: function visitEachChildOfAssertEntry(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateAssertEntry(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isAssertionKey),
|
|
nodeVisitor(node.value, visitor, isExpression)
|
|
);
|
|
},
|
|
[270 /* ImportClause */]: function visitEachChildOfImportClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportClause(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.namedBindings, visitor, isNamedImportBindings)
|
|
);
|
|
},
|
|
[271 /* NamespaceImport */]: function visitEachChildOfNamespaceImport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceImport(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[277 /* NamespaceExport */]: function visitEachChildOfNamespaceExport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamespaceExport(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[272 /* NamedImports */]: function visitEachChildOfNamedImports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamedImports(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isImportSpecifier)
|
|
);
|
|
},
|
|
[273 /* ImportSpecifier */]: function visitEachChildOfImportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateImportSpecifier(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.propertyName, visitor, isIdentifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[274 /* ExportAssignment */]: function visitEachChildOfExportAssignment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportAssignment(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[275 /* ExportDeclaration */]: function visitEachChildOfExportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportDeclaration(
|
|
node,
|
|
nodesVisitor(node.modifiers, visitor, isModifier),
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.exportClause, visitor, isNamedExportBindings),
|
|
nodeVisitor(node.moduleSpecifier, visitor, isExpression),
|
|
nodeVisitor(node.assertClause, visitor, isAssertClause)
|
|
);
|
|
},
|
|
[276 /* NamedExports */]: function visitEachChildOfNamedExports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateNamedExports(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExportSpecifier)
|
|
);
|
|
},
|
|
[278 /* ExportSpecifier */]: function visitEachChildOfExportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExportSpecifier(
|
|
node,
|
|
node.isTypeOnly,
|
|
nodeVisitor(node.propertyName, visitor, isIdentifier),
|
|
nodeVisitor(node.name, visitor, isIdentifier)
|
|
);
|
|
},
|
|
[280 /* ExternalModuleReference */]: function visitEachChildOfExternalModuleReference(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateExternalModuleReference(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[281 /* JsxElement */]: function visitEachChildOfJsxElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxElement(
|
|
node,
|
|
nodeVisitor(node.openingElement, visitor, isJsxOpeningElement),
|
|
nodesVisitor(node.children, visitor, isJsxChild),
|
|
nodeVisitor(node.closingElement, visitor, isJsxClosingElement)
|
|
);
|
|
},
|
|
[282 /* JsxSelfClosingElement */]: function visitEachChildOfJsxSelfClosingElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxSelfClosingElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
},
|
|
[283 /* JsxOpeningElement */]: function visitEachChildOfJsxOpeningElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxOpeningElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression),
|
|
nodesVisitor(node.typeArguments, visitor, isTypeNode),
|
|
nodeVisitor(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
},
|
|
[284 /* JsxClosingElement */]: function visitEachChildOfJsxClosingElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxClosingElement(
|
|
node,
|
|
nodeVisitor(node.tagName, visitor, isJsxTagNameExpression)
|
|
);
|
|
},
|
|
[285 /* JsxFragment */]: function visitEachChildOfJsxFragment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxFragment(
|
|
node,
|
|
nodeVisitor(node.openingFragment, visitor, isJsxOpeningFragment),
|
|
nodesVisitor(node.children, visitor, isJsxChild),
|
|
nodeVisitor(node.closingFragment, visitor, isJsxClosingFragment)
|
|
);
|
|
},
|
|
[288 /* JsxAttribute */]: function visitEachChildOfJsxAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxAttribute(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.initializer, visitor, isStringLiteralOrJsxExpression)
|
|
);
|
|
},
|
|
[289 /* JsxAttributes */]: function visitEachChildOfJsxAttributes(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxAttributes(
|
|
node,
|
|
nodesVisitor(node.properties, visitor, isJsxAttributeLike)
|
|
);
|
|
},
|
|
[290 /* JsxSpreadAttribute */]: function visitEachChildOfJsxSpreadAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxSpreadAttribute(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[291 /* JsxExpression */]: function visitEachChildOfJsxExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateJsxExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[292 /* CaseClause */]: function visitEachChildOfCaseClause(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCaseClause(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression),
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[293 /* DefaultClause */]: function visitEachChildOfDefaultClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateDefaultClause(
|
|
node,
|
|
nodesVisitor(node.statements, visitor, isStatement)
|
|
);
|
|
},
|
|
[294 /* HeritageClause */]: function visitEachChildOfHeritageClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateHeritageClause(
|
|
node,
|
|
nodesVisitor(node.types, visitor, isExpressionWithTypeArguments)
|
|
);
|
|
},
|
|
[295 /* CatchClause */]: function visitEachChildOfCatchClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCatchClause(
|
|
node,
|
|
nodeVisitor(node.variableDeclaration, visitor, isVariableDeclaration),
|
|
nodeVisitor(node.block, visitor, isBlock)
|
|
);
|
|
},
|
|
[299 /* PropertyAssignment */]: function visitEachChildOfPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePropertyAssignment(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[300 /* ShorthandPropertyAssignment */]: function visitEachChildOfShorthandPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateShorthandPropertyAssignment(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isIdentifier),
|
|
nodeVisitor(node.objectAssignmentInitializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[301 /* SpreadAssignment */]: function visitEachChildOfSpreadAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSpreadAssignment(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[302 /* EnumMember */]: function visitEachChildOfEnumMember(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateEnumMember(
|
|
node,
|
|
nodeVisitor(node.name, visitor, isPropertyName),
|
|
nodeVisitor(node.initializer, visitor, isExpression)
|
|
);
|
|
},
|
|
[308 /* SourceFile */]: function visitEachChildOfSourceFile(node, visitor, context, _nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateSourceFile(
|
|
node,
|
|
visitLexicalEnvironment(node.statements, visitor, context)
|
|
);
|
|
},
|
|
[353 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updatePartiallyEmittedExpression(
|
|
node,
|
|
nodeVisitor(node.expression, visitor, isExpression)
|
|
);
|
|
},
|
|
[354 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
|
|
return context.factory.updateCommaListExpression(
|
|
node,
|
|
nodesVisitor(node.elements, visitor, isExpression)
|
|
);
|
|
}
|
|
};
|
|
function extractSingleNode(nodes) {
|
|
Debug.assert(nodes.length <= 1, "Too many nodes written to output.");
|
|
return singleOrUndefined(nodes);
|
|
}
|
|
|
|
// src/compiler/sourcemap.ts
|
|
function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) {
|
|
const { enter, exit } = generatorOptions.extendedDiagnostics ? createTimer("Source Map", "beforeSourcemap", "afterSourcemap") : nullTimer;
|
|
const rawSources = [];
|
|
const sources = [];
|
|
const sourceToSourceIndexMap = /* @__PURE__ */ new Map();
|
|
let sourcesContent;
|
|
const names = [];
|
|
let nameToNameIndexMap;
|
|
const mappingCharCodes = [];
|
|
let mappings = "";
|
|
let lastGeneratedLine = 0;
|
|
let lastGeneratedCharacter = 0;
|
|
let lastSourceIndex = 0;
|
|
let lastSourceLine = 0;
|
|
let lastSourceCharacter = 0;
|
|
let lastNameIndex = 0;
|
|
let hasLast = false;
|
|
let pendingGeneratedLine = 0;
|
|
let pendingGeneratedCharacter = 0;
|
|
let pendingSourceIndex = 0;
|
|
let pendingSourceLine = 0;
|
|
let pendingSourceCharacter = 0;
|
|
let pendingNameIndex = 0;
|
|
let hasPending = false;
|
|
let hasPendingSource = false;
|
|
let hasPendingName = false;
|
|
return {
|
|
getSources: () => rawSources,
|
|
addSource,
|
|
setSourceContent,
|
|
addName,
|
|
addMapping,
|
|
appendSourceMap,
|
|
toJSON,
|
|
toString: () => JSON.stringify(toJSON())
|
|
};
|
|
function addSource(fileName) {
|
|
enter();
|
|
const source = getRelativePathToDirectoryOrUrl(
|
|
sourcesDirectoryPath,
|
|
fileName,
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
true
|
|
);
|
|
let sourceIndex = sourceToSourceIndexMap.get(source);
|
|
if (sourceIndex === void 0) {
|
|
sourceIndex = sources.length;
|
|
sources.push(source);
|
|
rawSources.push(fileName);
|
|
sourceToSourceIndexMap.set(source, sourceIndex);
|
|
}
|
|
exit();
|
|
return sourceIndex;
|
|
}
|
|
function setSourceContent(sourceIndex, content) {
|
|
enter();
|
|
if (content !== null) {
|
|
if (!sourcesContent)
|
|
sourcesContent = [];
|
|
while (sourcesContent.length < sourceIndex) {
|
|
sourcesContent.push(null);
|
|
}
|
|
sourcesContent[sourceIndex] = content;
|
|
}
|
|
exit();
|
|
}
|
|
function addName(name) {
|
|
enter();
|
|
if (!nameToNameIndexMap)
|
|
nameToNameIndexMap = /* @__PURE__ */ new Map();
|
|
let nameIndex = nameToNameIndexMap.get(name);
|
|
if (nameIndex === void 0) {
|
|
nameIndex = names.length;
|
|
names.push(name);
|
|
nameToNameIndexMap.set(name, nameIndex);
|
|
}
|
|
exit();
|
|
return nameIndex;
|
|
}
|
|
function isNewGeneratedPosition(generatedLine, generatedCharacter) {
|
|
return !hasPending || pendingGeneratedLine !== generatedLine || pendingGeneratedCharacter !== generatedCharacter;
|
|
}
|
|
function isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter) {
|
|
return sourceIndex !== void 0 && sourceLine !== void 0 && sourceCharacter !== void 0 && pendingSourceIndex === sourceIndex && (pendingSourceLine > sourceLine || pendingSourceLine === sourceLine && pendingSourceCharacter > sourceCharacter);
|
|
}
|
|
function addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, nameIndex) {
|
|
Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative");
|
|
Debug.assert(sourceIndex === void 0 || sourceIndex >= 0, "sourceIndex cannot be negative");
|
|
Debug.assert(sourceLine === void 0 || sourceLine >= 0, "sourceLine cannot be negative");
|
|
Debug.assert(sourceCharacter === void 0 || sourceCharacter >= 0, "sourceCharacter cannot be negative");
|
|
enter();
|
|
if (isNewGeneratedPosition(generatedLine, generatedCharacter) || isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter)) {
|
|
commitPendingMapping();
|
|
pendingGeneratedLine = generatedLine;
|
|
pendingGeneratedCharacter = generatedCharacter;
|
|
hasPendingSource = false;
|
|
hasPendingName = false;
|
|
hasPending = true;
|
|
}
|
|
if (sourceIndex !== void 0 && sourceLine !== void 0 && sourceCharacter !== void 0) {
|
|
pendingSourceIndex = sourceIndex;
|
|
pendingSourceLine = sourceLine;
|
|
pendingSourceCharacter = sourceCharacter;
|
|
hasPendingSource = true;
|
|
if (nameIndex !== void 0) {
|
|
pendingNameIndex = nameIndex;
|
|
hasPendingName = true;
|
|
}
|
|
}
|
|
exit();
|
|
}
|
|
function appendSourceMap(generatedLine, generatedCharacter, map2, sourceMapPath, start2, end) {
|
|
Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative");
|
|
enter();
|
|
const sourceIndexToNewSourceIndexMap = [];
|
|
let nameIndexToNewNameIndexMap;
|
|
const mappingIterator = decodeMappings(map2.mappings);
|
|
for (let iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) {
|
|
const raw = iterResult.value;
|
|
if (end && (raw.generatedLine > end.line || raw.generatedLine === end.line && raw.generatedCharacter > end.character)) {
|
|
break;
|
|
}
|
|
if (start2 && (raw.generatedLine < start2.line || start2.line === raw.generatedLine && raw.generatedCharacter < start2.character)) {
|
|
continue;
|
|
}
|
|
let newSourceIndex;
|
|
let newSourceLine;
|
|
let newSourceCharacter;
|
|
let newNameIndex;
|
|
if (raw.sourceIndex !== void 0) {
|
|
newSourceIndex = sourceIndexToNewSourceIndexMap[raw.sourceIndex];
|
|
if (newSourceIndex === void 0) {
|
|
const rawPath = map2.sources[raw.sourceIndex];
|
|
const relativePath = map2.sourceRoot ? combinePaths(map2.sourceRoot, rawPath) : rawPath;
|
|
const combinedPath = combinePaths(getDirectoryPath(sourceMapPath), relativePath);
|
|
sourceIndexToNewSourceIndexMap[raw.sourceIndex] = newSourceIndex = addSource(combinedPath);
|
|
if (map2.sourcesContent && typeof map2.sourcesContent[raw.sourceIndex] === "string") {
|
|
setSourceContent(newSourceIndex, map2.sourcesContent[raw.sourceIndex]);
|
|
}
|
|
}
|
|
newSourceLine = raw.sourceLine;
|
|
newSourceCharacter = raw.sourceCharacter;
|
|
if (map2.names && raw.nameIndex !== void 0) {
|
|
if (!nameIndexToNewNameIndexMap)
|
|
nameIndexToNewNameIndexMap = [];
|
|
newNameIndex = nameIndexToNewNameIndexMap[raw.nameIndex];
|
|
if (newNameIndex === void 0) {
|
|
nameIndexToNewNameIndexMap[raw.nameIndex] = newNameIndex = addName(map2.names[raw.nameIndex]);
|
|
}
|
|
}
|
|
}
|
|
const rawGeneratedLine = raw.generatedLine - (start2 ? start2.line : 0);
|
|
const newGeneratedLine = rawGeneratedLine + generatedLine;
|
|
const rawGeneratedCharacter = start2 && start2.line === raw.generatedLine ? raw.generatedCharacter - start2.character : raw.generatedCharacter;
|
|
const newGeneratedCharacter = rawGeneratedLine === 0 ? rawGeneratedCharacter + generatedCharacter : rawGeneratedCharacter;
|
|
addMapping(newGeneratedLine, newGeneratedCharacter, newSourceIndex, newSourceLine, newSourceCharacter, newNameIndex);
|
|
}
|
|
exit();
|
|
}
|
|
function shouldCommitMapping() {
|
|
return !hasLast || lastGeneratedLine !== pendingGeneratedLine || lastGeneratedCharacter !== pendingGeneratedCharacter || lastSourceIndex !== pendingSourceIndex || lastSourceLine !== pendingSourceLine || lastSourceCharacter !== pendingSourceCharacter || lastNameIndex !== pendingNameIndex;
|
|
}
|
|
function appendMappingCharCode(charCode) {
|
|
mappingCharCodes.push(charCode);
|
|
if (mappingCharCodes.length >= 1024) {
|
|
flushMappingBuffer();
|
|
}
|
|
}
|
|
function commitPendingMapping() {
|
|
if (!hasPending || !shouldCommitMapping()) {
|
|
return;
|
|
}
|
|
enter();
|
|
if (lastGeneratedLine < pendingGeneratedLine) {
|
|
do {
|
|
appendMappingCharCode(59 /* semicolon */);
|
|
lastGeneratedLine++;
|
|
} while (lastGeneratedLine < pendingGeneratedLine);
|
|
lastGeneratedCharacter = 0;
|
|
} else {
|
|
Debug.assertEqual(lastGeneratedLine, pendingGeneratedLine, "generatedLine cannot backtrack");
|
|
if (hasLast) {
|
|
appendMappingCharCode(44 /* comma */);
|
|
}
|
|
}
|
|
appendBase64VLQ(pendingGeneratedCharacter - lastGeneratedCharacter);
|
|
lastGeneratedCharacter = pendingGeneratedCharacter;
|
|
if (hasPendingSource) {
|
|
appendBase64VLQ(pendingSourceIndex - lastSourceIndex);
|
|
lastSourceIndex = pendingSourceIndex;
|
|
appendBase64VLQ(pendingSourceLine - lastSourceLine);
|
|
lastSourceLine = pendingSourceLine;
|
|
appendBase64VLQ(pendingSourceCharacter - lastSourceCharacter);
|
|
lastSourceCharacter = pendingSourceCharacter;
|
|
if (hasPendingName) {
|
|
appendBase64VLQ(pendingNameIndex - lastNameIndex);
|
|
lastNameIndex = pendingNameIndex;
|
|
}
|
|
}
|
|
hasLast = true;
|
|
exit();
|
|
}
|
|
function flushMappingBuffer() {
|
|
if (mappingCharCodes.length > 0) {
|
|
mappings += String.fromCharCode.apply(void 0, mappingCharCodes);
|
|
mappingCharCodes.length = 0;
|
|
}
|
|
}
|
|
function toJSON() {
|
|
commitPendingMapping();
|
|
flushMappingBuffer();
|
|
return {
|
|
version: 3,
|
|
file,
|
|
sourceRoot,
|
|
sources,
|
|
names,
|
|
mappings,
|
|
sourcesContent
|
|
};
|
|
}
|
|
function appendBase64VLQ(inValue) {
|
|
if (inValue < 0) {
|
|
inValue = (-inValue << 1) + 1;
|
|
} else {
|
|
inValue = inValue << 1;
|
|
}
|
|
do {
|
|
let currentDigit = inValue & 31;
|
|
inValue = inValue >> 5;
|
|
if (inValue > 0) {
|
|
currentDigit = currentDigit | 32;
|
|
}
|
|
appendMappingCharCode(base64FormatEncode(currentDigit));
|
|
} while (inValue > 0);
|
|
}
|
|
}
|
|
var sourceMapCommentRegExpDontCareLineStart = /\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
|
|
var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/;
|
|
var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/;
|
|
function getLineInfo(text, lineStarts) {
|
|
return {
|
|
getLineCount: () => lineStarts.length,
|
|
getLineText: (line) => text.substring(lineStarts[line], lineStarts[line + 1])
|
|
};
|
|
}
|
|
function tryGetSourceMappingURL(lineInfo) {
|
|
for (let index = lineInfo.getLineCount() - 1; index >= 0; index--) {
|
|
const line = lineInfo.getLineText(index);
|
|
const comment = sourceMapCommentRegExp.exec(line);
|
|
if (comment) {
|
|
return trimStringEnd(comment[1]);
|
|
} else if (!line.match(whitespaceOrMapCommentRegExp)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function isStringOrNull(x) {
|
|
return typeof x === "string" || x === null;
|
|
}
|
|
function isRawSourceMap(x) {
|
|
return x !== null && typeof x === "object" && x.version === 3 && typeof x.file === "string" && typeof x.mappings === "string" && isArray(x.sources) && every(x.sources, isString) && (x.sourceRoot === void 0 || x.sourceRoot === null || typeof x.sourceRoot === "string") && (x.sourcesContent === void 0 || x.sourcesContent === null || isArray(x.sourcesContent) && every(x.sourcesContent, isStringOrNull)) && (x.names === void 0 || x.names === null || isArray(x.names) && every(x.names, isString));
|
|
}
|
|
function tryParseRawSourceMap(text) {
|
|
try {
|
|
const parsed = JSON.parse(text);
|
|
if (isRawSourceMap(parsed)) {
|
|
return parsed;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return void 0;
|
|
}
|
|
function decodeMappings(mappings) {
|
|
let done = false;
|
|
let pos = 0;
|
|
let generatedLine = 0;
|
|
let generatedCharacter = 0;
|
|
let sourceIndex = 0;
|
|
let sourceLine = 0;
|
|
let sourceCharacter = 0;
|
|
let nameIndex = 0;
|
|
let error;
|
|
return {
|
|
get pos() {
|
|
return pos;
|
|
},
|
|
get error() {
|
|
return error;
|
|
},
|
|
get state() {
|
|
return captureMapping(true, true);
|
|
},
|
|
next() {
|
|
while (!done && pos < mappings.length) {
|
|
const ch = mappings.charCodeAt(pos);
|
|
if (ch === 59 /* semicolon */) {
|
|
generatedLine++;
|
|
generatedCharacter = 0;
|
|
pos++;
|
|
continue;
|
|
}
|
|
if (ch === 44 /* comma */) {
|
|
pos++;
|
|
continue;
|
|
}
|
|
let hasSource = false;
|
|
let hasName = false;
|
|
generatedCharacter += base64VLQFormatDecode();
|
|
if (hasReportedError())
|
|
return stopIterating();
|
|
if (generatedCharacter < 0)
|
|
return setErrorAndStopIterating("Invalid generatedCharacter found");
|
|
if (!isSourceMappingSegmentEnd()) {
|
|
hasSource = true;
|
|
sourceIndex += base64VLQFormatDecode();
|
|
if (hasReportedError())
|
|
return stopIterating();
|
|
if (sourceIndex < 0)
|
|
return setErrorAndStopIterating("Invalid sourceIndex found");
|
|
if (isSourceMappingSegmentEnd())
|
|
return setErrorAndStopIterating("Unsupported Format: No entries after sourceIndex");
|
|
sourceLine += base64VLQFormatDecode();
|
|
if (hasReportedError())
|
|
return stopIterating();
|
|
if (sourceLine < 0)
|
|
return setErrorAndStopIterating("Invalid sourceLine found");
|
|
if (isSourceMappingSegmentEnd())
|
|
return setErrorAndStopIterating("Unsupported Format: No entries after sourceLine");
|
|
sourceCharacter += base64VLQFormatDecode();
|
|
if (hasReportedError())
|
|
return stopIterating();
|
|
if (sourceCharacter < 0)
|
|
return setErrorAndStopIterating("Invalid sourceCharacter found");
|
|
if (!isSourceMappingSegmentEnd()) {
|
|
hasName = true;
|
|
nameIndex += base64VLQFormatDecode();
|
|
if (hasReportedError())
|
|
return stopIterating();
|
|
if (nameIndex < 0)
|
|
return setErrorAndStopIterating("Invalid nameIndex found");
|
|
if (!isSourceMappingSegmentEnd())
|
|
return setErrorAndStopIterating("Unsupported Error Format: Entries after nameIndex");
|
|
}
|
|
}
|
|
return { value: captureMapping(hasSource, hasName), done };
|
|
}
|
|
return stopIterating();
|
|
}
|
|
};
|
|
function captureMapping(hasSource, hasName) {
|
|
return {
|
|
generatedLine,
|
|
generatedCharacter,
|
|
sourceIndex: hasSource ? sourceIndex : void 0,
|
|
sourceLine: hasSource ? sourceLine : void 0,
|
|
sourceCharacter: hasSource ? sourceCharacter : void 0,
|
|
nameIndex: hasName ? nameIndex : void 0
|
|
};
|
|
}
|
|
function stopIterating() {
|
|
done = true;
|
|
return { value: void 0, done: true };
|
|
}
|
|
function setError(message) {
|
|
if (error === void 0) {
|
|
error = message;
|
|
}
|
|
}
|
|
function setErrorAndStopIterating(message) {
|
|
setError(message);
|
|
return stopIterating();
|
|
}
|
|
function hasReportedError() {
|
|
return error !== void 0;
|
|
}
|
|
function isSourceMappingSegmentEnd() {
|
|
return pos === mappings.length || mappings.charCodeAt(pos) === 44 /* comma */ || mappings.charCodeAt(pos) === 59 /* semicolon */;
|
|
}
|
|
function base64VLQFormatDecode() {
|
|
let moreDigits = true;
|
|
let shiftCount = 0;
|
|
let value = 0;
|
|
for (; moreDigits; pos++) {
|
|
if (pos >= mappings.length)
|
|
return setError("Error in decoding base64VLQFormatDecode, past the mapping string"), -1;
|
|
const currentByte = base64FormatDecode(mappings.charCodeAt(pos));
|
|
if (currentByte === -1)
|
|
return setError("Invalid character in VLQ"), -1;
|
|
moreDigits = (currentByte & 32) !== 0;
|
|
value = value | (currentByte & 31) << shiftCount;
|
|
shiftCount += 5;
|
|
}
|
|
if ((value & 1) === 0) {
|
|
value = value >> 1;
|
|
} else {
|
|
value = value >> 1;
|
|
value = -value;
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
function sameMapping(left, right) {
|
|
return left === right || left.generatedLine === right.generatedLine && left.generatedCharacter === right.generatedCharacter && left.sourceIndex === right.sourceIndex && left.sourceLine === right.sourceLine && left.sourceCharacter === right.sourceCharacter && left.nameIndex === right.nameIndex;
|
|
}
|
|
function isSourceMapping(mapping) {
|
|
return mapping.sourceIndex !== void 0 && mapping.sourceLine !== void 0 && mapping.sourceCharacter !== void 0;
|
|
}
|
|
function base64FormatEncode(value) {
|
|
return value >= 0 && value < 26 ? 65 /* A */ + value : value >= 26 && value < 52 ? 97 /* a */ + value - 26 : value >= 52 && value < 62 ? 48 /* _0 */ + value - 52 : value === 62 ? 43 /* plus */ : value === 63 ? 47 /* slash */ : Debug.fail(`${value}: not a base64 value`);
|
|
}
|
|
function base64FormatDecode(ch) {
|
|
return ch >= 65 /* A */ && ch <= 90 /* Z */ ? ch - 65 /* A */ : ch >= 97 /* a */ && ch <= 122 /* z */ ? ch - 97 /* a */ + 26 : ch >= 48 /* _0 */ && ch <= 57 /* _9 */ ? ch - 48 /* _0 */ + 52 : ch === 43 /* plus */ ? 62 : ch === 47 /* slash */ ? 63 : -1;
|
|
}
|
|
function isSourceMappedPosition(value) {
|
|
return value.sourceIndex !== void 0 && value.sourcePosition !== void 0;
|
|
}
|
|
function sameMappedPosition(left, right) {
|
|
return left.generatedPosition === right.generatedPosition && left.sourceIndex === right.sourceIndex && left.sourcePosition === right.sourcePosition;
|
|
}
|
|
function compareSourcePositions(left, right) {
|
|
Debug.assert(left.sourceIndex === right.sourceIndex);
|
|
return compareValues(left.sourcePosition, right.sourcePosition);
|
|
}
|
|
function compareGeneratedPositions(left, right) {
|
|
return compareValues(left.generatedPosition, right.generatedPosition);
|
|
}
|
|
function getSourcePositionOfMapping(value) {
|
|
return value.sourcePosition;
|
|
}
|
|
function getGeneratedPositionOfMapping(value) {
|
|
return value.generatedPosition;
|
|
}
|
|
function createDocumentPositionMapper(host, map2, mapPath) {
|
|
const mapDirectory = getDirectoryPath(mapPath);
|
|
const sourceRoot = map2.sourceRoot ? getNormalizedAbsolutePath(map2.sourceRoot, mapDirectory) : mapDirectory;
|
|
const generatedAbsoluteFilePath = getNormalizedAbsolutePath(map2.file, mapDirectory);
|
|
const generatedFile = host.getSourceFileLike(generatedAbsoluteFilePath);
|
|
const sourceFileAbsolutePaths = map2.sources.map((source) => getNormalizedAbsolutePath(source, sourceRoot));
|
|
const sourceToSourceIndexMap = new Map(sourceFileAbsolutePaths.map((source, i) => [host.getCanonicalFileName(source), i]));
|
|
let decodedMappings;
|
|
let generatedMappings;
|
|
let sourceMappings;
|
|
return {
|
|
getSourcePosition,
|
|
getGeneratedPosition
|
|
};
|
|
function processMapping(mapping) {
|
|
const generatedPosition = generatedFile !== void 0 ? getPositionOfLineAndCharacter(generatedFile, mapping.generatedLine, mapping.generatedCharacter, true) : -1;
|
|
let source;
|
|
let sourcePosition;
|
|
if (isSourceMapping(mapping)) {
|
|
const sourceFile = host.getSourceFileLike(sourceFileAbsolutePaths[mapping.sourceIndex]);
|
|
source = map2.sources[mapping.sourceIndex];
|
|
sourcePosition = sourceFile !== void 0 ? getPositionOfLineAndCharacter(sourceFile, mapping.sourceLine, mapping.sourceCharacter, true) : -1;
|
|
}
|
|
return {
|
|
generatedPosition,
|
|
source,
|
|
sourceIndex: mapping.sourceIndex,
|
|
sourcePosition,
|
|
nameIndex: mapping.nameIndex
|
|
};
|
|
}
|
|
function getDecodedMappings() {
|
|
if (decodedMappings === void 0) {
|
|
const decoder = decodeMappings(map2.mappings);
|
|
const mappings = arrayFrom(decoder, processMapping);
|
|
if (decoder.error !== void 0) {
|
|
if (host.log) {
|
|
host.log(`Encountered error while decoding sourcemap: ${decoder.error}`);
|
|
}
|
|
decodedMappings = emptyArray;
|
|
} else {
|
|
decodedMappings = mappings;
|
|
}
|
|
}
|
|
return decodedMappings;
|
|
}
|
|
function getSourceMappings(sourceIndex) {
|
|
if (sourceMappings === void 0) {
|
|
const lists = [];
|
|
for (const mapping of getDecodedMappings()) {
|
|
if (!isSourceMappedPosition(mapping))
|
|
continue;
|
|
let list = lists[mapping.sourceIndex];
|
|
if (!list)
|
|
lists[mapping.sourceIndex] = list = [];
|
|
list.push(mapping);
|
|
}
|
|
sourceMappings = lists.map((list) => sortAndDeduplicate(list, compareSourcePositions, sameMappedPosition));
|
|
}
|
|
return sourceMappings[sourceIndex];
|
|
}
|
|
function getGeneratedMappings() {
|
|
if (generatedMappings === void 0) {
|
|
const list = [];
|
|
for (const mapping of getDecodedMappings()) {
|
|
list.push(mapping);
|
|
}
|
|
generatedMappings = sortAndDeduplicate(list, compareGeneratedPositions, sameMappedPosition);
|
|
}
|
|
return generatedMappings;
|
|
}
|
|
function getGeneratedPosition(loc) {
|
|
const sourceIndex = sourceToSourceIndexMap.get(host.getCanonicalFileName(loc.fileName));
|
|
if (sourceIndex === void 0)
|
|
return loc;
|
|
const sourceMappings2 = getSourceMappings(sourceIndex);
|
|
if (!some(sourceMappings2))
|
|
return loc;
|
|
let targetIndex = binarySearchKey(sourceMappings2, loc.pos, getSourcePositionOfMapping, compareValues);
|
|
if (targetIndex < 0) {
|
|
targetIndex = ~targetIndex;
|
|
}
|
|
const mapping = sourceMappings2[targetIndex];
|
|
if (mapping === void 0 || mapping.sourceIndex !== sourceIndex) {
|
|
return loc;
|
|
}
|
|
return { fileName: generatedAbsoluteFilePath, pos: mapping.generatedPosition };
|
|
}
|
|
function getSourcePosition(loc) {
|
|
const generatedMappings2 = getGeneratedMappings();
|
|
if (!some(generatedMappings2))
|
|
return loc;
|
|
let targetIndex = binarySearchKey(generatedMappings2, loc.pos, getGeneratedPositionOfMapping, compareValues);
|
|
if (targetIndex < 0) {
|
|
targetIndex = ~targetIndex;
|
|
}
|
|
const mapping = generatedMappings2[targetIndex];
|
|
if (mapping === void 0 || !isSourceMappedPosition(mapping)) {
|
|
return loc;
|
|
}
|
|
return { fileName: sourceFileAbsolutePaths[mapping.sourceIndex], pos: mapping.sourcePosition };
|
|
}
|
|
}
|
|
var identitySourceMapConsumer = {
|
|
getSourcePosition: identity,
|
|
getGeneratedPosition: identity
|
|
};
|
|
|
|
// src/compiler/transformers/utilities.ts
|
|
function getOriginalNodeId(node) {
|
|
node = getOriginalNode(node);
|
|
return node ? getNodeId(node) : 0;
|
|
}
|
|
function containsDefaultReference(node) {
|
|
if (!node)
|
|
return false;
|
|
if (!isNamedImports(node))
|
|
return false;
|
|
return some(node.elements, isNamedDefaultReference);
|
|
}
|
|
function isNamedDefaultReference(e) {
|
|
return e.propertyName !== void 0 && e.propertyName.escapedText === "default" /* Default */;
|
|
}
|
|
function chainBundle(context, transformSourceFile) {
|
|
return transformSourceFileOrBundle;
|
|
function transformSourceFileOrBundle(node) {
|
|
return node.kind === 308 /* SourceFile */ ? transformSourceFile(node) : transformBundle(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return context.factory.createBundle(map(node.sourceFiles, transformSourceFile), node.prepends);
|
|
}
|
|
}
|
|
function getExportNeedsImportStarHelper(node) {
|
|
return !!getNamespaceDeclarationNode(node);
|
|
}
|
|
function getImportNeedsImportStarHelper(node) {
|
|
if (!!getNamespaceDeclarationNode(node)) {
|
|
return true;
|
|
}
|
|
const bindings = node.importClause && node.importClause.namedBindings;
|
|
if (!bindings) {
|
|
return false;
|
|
}
|
|
if (!isNamedImports(bindings))
|
|
return false;
|
|
let defaultRefCount = 0;
|
|
for (const binding of bindings.elements) {
|
|
if (isNamedDefaultReference(binding)) {
|
|
defaultRefCount++;
|
|
}
|
|
}
|
|
return defaultRefCount > 0 && defaultRefCount !== bindings.elements.length || !!(bindings.elements.length - defaultRefCount) && isDefaultImport(node);
|
|
}
|
|
function getImportNeedsImportDefaultHelper(node) {
|
|
return !getImportNeedsImportStarHelper(node) && (isDefaultImport(node) || !!node.importClause && isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings));
|
|
}
|
|
function collectExternalModuleInfo(context, sourceFile, resolver, compilerOptions) {
|
|
const externalImports = [];
|
|
const exportSpecifiers = createMultiMap();
|
|
const exportedBindings = [];
|
|
const uniqueExports = /* @__PURE__ */ new Map();
|
|
let exportedNames;
|
|
let hasExportDefault = false;
|
|
let exportEquals;
|
|
let hasExportStarsToExportValues = false;
|
|
let hasImportStar = false;
|
|
let hasImportDefault = false;
|
|
for (const node of sourceFile.statements) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
externalImports.push(node);
|
|
if (!hasImportStar && getImportNeedsImportStarHelper(node)) {
|
|
hasImportStar = true;
|
|
}
|
|
if (!hasImportDefault && getImportNeedsImportDefaultHelper(node)) {
|
|
hasImportDefault = true;
|
|
}
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
externalImports.push(node);
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
if (node.moduleSpecifier) {
|
|
if (!node.exportClause) {
|
|
externalImports.push(node);
|
|
hasExportStarsToExportValues = true;
|
|
} else {
|
|
externalImports.push(node);
|
|
if (isNamedExports(node.exportClause)) {
|
|
addExportedNamesForExportDeclaration(node);
|
|
} else {
|
|
const name = node.exportClause.name;
|
|
if (!uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
hasImportStar = true;
|
|
}
|
|
}
|
|
} else {
|
|
addExportedNamesForExportDeclaration(node);
|
|
}
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
if (node.isExportEquals && !exportEquals) {
|
|
exportEquals = node;
|
|
}
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
for (const decl of node.declarationList.declarations) {
|
|
exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames);
|
|
}
|
|
}
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
if (hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
if (!hasExportDefault) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
|
|
hasExportDefault = true;
|
|
}
|
|
} else {
|
|
const name = node.name;
|
|
if (!uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
if (hasSyntacticModifier(node, 1024 /* Default */)) {
|
|
if (!hasExportDefault) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node));
|
|
hasExportDefault = true;
|
|
}
|
|
} else {
|
|
const name = node.name;
|
|
if (name && !uniqueExports.get(idText(name))) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name);
|
|
uniqueExports.set(idText(name), true);
|
|
exportedNames = append(exportedNames, name);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
const externalHelpersImportDeclaration = createExternalHelpersImportDeclarationIfNeeded(context.factory, context.getEmitHelperFactory(), sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault);
|
|
if (externalHelpersImportDeclaration) {
|
|
externalImports.unshift(externalHelpersImportDeclaration);
|
|
}
|
|
return { externalImports, exportSpecifiers, exportEquals, hasExportStarsToExportValues, exportedBindings, exportedNames, externalHelpersImportDeclaration };
|
|
function addExportedNamesForExportDeclaration(node) {
|
|
for (const specifier of cast(node.exportClause, isNamedExports).elements) {
|
|
if (!uniqueExports.get(idText(specifier.name))) {
|
|
const name = specifier.propertyName || specifier.name;
|
|
if (!node.moduleSpecifier) {
|
|
exportSpecifiers.add(idText(name), specifier);
|
|
}
|
|
const decl = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (decl) {
|
|
multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name);
|
|
}
|
|
uniqueExports.set(idText(specifier.name), true);
|
|
exportedNames = append(exportedNames, specifier.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function collectExportedVariableInfo(decl, uniqueExports, exportedNames) {
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
exportedNames = collectExportedVariableInfo(element, uniqueExports, exportedNames);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
const text = idText(decl.name);
|
|
if (!uniqueExports.get(text)) {
|
|
uniqueExports.set(text, true);
|
|
exportedNames = append(exportedNames, decl.name);
|
|
}
|
|
}
|
|
return exportedNames;
|
|
}
|
|
function multiMapSparseArrayAdd(map2, key, value) {
|
|
let values = map2[key];
|
|
if (values) {
|
|
values.push(value);
|
|
} else {
|
|
map2[key] = values = [value];
|
|
}
|
|
return values;
|
|
}
|
|
function isSimpleCopiableExpression(expression) {
|
|
return isStringLiteralLike(expression) || expression.kind === 8 /* NumericLiteral */ || isKeyword(expression.kind) || isIdentifier(expression);
|
|
}
|
|
function isSimpleInlineableExpression(expression) {
|
|
return !isIdentifier(expression) && isSimpleCopiableExpression(expression);
|
|
}
|
|
function isCompoundAssignment(kind) {
|
|
return kind >= 64 /* FirstCompoundAssignment */ && kind <= 78 /* LastCompoundAssignment */;
|
|
}
|
|
function getNonAssignmentOperatorForCompoundAssignment(kind) {
|
|
switch (kind) {
|
|
case 64 /* PlusEqualsToken */:
|
|
return 39 /* PlusToken */;
|
|
case 65 /* MinusEqualsToken */:
|
|
return 40 /* MinusToken */;
|
|
case 66 /* AsteriskEqualsToken */:
|
|
return 41 /* AsteriskToken */;
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
return 42 /* AsteriskAsteriskToken */;
|
|
case 68 /* SlashEqualsToken */:
|
|
return 43 /* SlashToken */;
|
|
case 69 /* PercentEqualsToken */:
|
|
return 44 /* PercentToken */;
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
return 47 /* LessThanLessThanToken */;
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
return 48 /* GreaterThanGreaterThanToken */;
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
return 49 /* GreaterThanGreaterThanGreaterThanToken */;
|
|
case 73 /* AmpersandEqualsToken */:
|
|
return 50 /* AmpersandToken */;
|
|
case 74 /* BarEqualsToken */:
|
|
return 51 /* BarToken */;
|
|
case 78 /* CaretEqualsToken */:
|
|
return 52 /* CaretToken */;
|
|
case 75 /* BarBarEqualsToken */:
|
|
return 56 /* BarBarToken */;
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
return 55 /* AmpersandAmpersandToken */;
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return 60 /* QuestionQuestionToken */;
|
|
}
|
|
}
|
|
function getSuperCallFromStatement(statement) {
|
|
if (!isExpressionStatement(statement)) {
|
|
return void 0;
|
|
}
|
|
const expression = skipParentheses(statement.expression);
|
|
return isSuperCall(expression) ? expression : void 0;
|
|
}
|
|
function findSuperStatementIndex(statements, indexAfterLastPrologueStatement) {
|
|
for (let i = indexAfterLastPrologueStatement; i < statements.length; i += 1) {
|
|
const statement = statements[i];
|
|
if (getSuperCallFromStatement(statement)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function getProperties(node, requireInitializer, isStatic2) {
|
|
return filter(node.members, (m) => isInitializedOrStaticProperty(m, requireInitializer, isStatic2));
|
|
}
|
|
function isStaticPropertyDeclarationOrClassStaticBlockDeclaration(element) {
|
|
return isStaticPropertyDeclaration(element) || isClassStaticBlockDeclaration(element);
|
|
}
|
|
function getStaticPropertiesAndClassStaticBlock(node) {
|
|
return filter(node.members, isStaticPropertyDeclarationOrClassStaticBlockDeclaration);
|
|
}
|
|
function isInitializedOrStaticProperty(member, requireInitializer, isStatic2) {
|
|
return isPropertyDeclaration(member) && (!!member.initializer || !requireInitializer) && hasStaticModifier(member) === isStatic2;
|
|
}
|
|
function isStaticPropertyDeclaration(member) {
|
|
return isPropertyDeclaration(member) && hasStaticModifier(member);
|
|
}
|
|
function isInitializedProperty(member) {
|
|
return member.kind === 169 /* PropertyDeclaration */ && member.initializer !== void 0;
|
|
}
|
|
function isNonStaticMethodOrAccessorWithPrivateName(member) {
|
|
return !isStatic(member) && (isMethodOrAccessor(member) || isAutoAccessorPropertyDeclaration(member)) && isPrivateIdentifier(member.name);
|
|
}
|
|
function getDecoratorsOfParameters(node) {
|
|
let decorators;
|
|
if (node) {
|
|
const parameters = node.parameters;
|
|
const firstParameterIsThis = parameters.length > 0 && parameterIsThisKeyword(parameters[0]);
|
|
const firstParameterOffset = firstParameterIsThis ? 1 : 0;
|
|
const numParameters = firstParameterIsThis ? parameters.length - 1 : parameters.length;
|
|
for (let i = 0; i < numParameters; i++) {
|
|
const parameter = parameters[i + firstParameterOffset];
|
|
if (decorators || hasDecorators(parameter)) {
|
|
if (!decorators) {
|
|
decorators = new Array(numParameters);
|
|
}
|
|
decorators[i] = getDecorators(parameter);
|
|
}
|
|
}
|
|
}
|
|
return decorators;
|
|
}
|
|
function getAllDecoratorsOfClass(node) {
|
|
const decorators = getDecorators(node);
|
|
const parameters = getDecoratorsOfParameters(getFirstConstructorWithBody(node));
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return {
|
|
decorators,
|
|
parameters
|
|
};
|
|
}
|
|
function getAllDecoratorsOfClassElement(member, parent2) {
|
|
switch (member.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return getAllDecoratorsOfAccessors(member, parent2);
|
|
case 171 /* MethodDeclaration */:
|
|
return getAllDecoratorsOfMethod(member);
|
|
case 169 /* PropertyDeclaration */:
|
|
return getAllDecoratorsOfProperty(member);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getAllDecoratorsOfAccessors(accessor, parent2) {
|
|
if (!accessor.body) {
|
|
return void 0;
|
|
}
|
|
const { firstAccessor, secondAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(parent2.members, accessor);
|
|
const firstAccessorWithDecorators = hasDecorators(firstAccessor) ? firstAccessor : secondAccessor && hasDecorators(secondAccessor) ? secondAccessor : void 0;
|
|
if (!firstAccessorWithDecorators || accessor !== firstAccessorWithDecorators) {
|
|
return void 0;
|
|
}
|
|
const decorators = getDecorators(firstAccessorWithDecorators);
|
|
const parameters = getDecoratorsOfParameters(setAccessor);
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return {
|
|
decorators,
|
|
parameters,
|
|
getDecorators: getAccessor && getDecorators(getAccessor),
|
|
setDecorators: setAccessor && getDecorators(setAccessor)
|
|
};
|
|
}
|
|
function getAllDecoratorsOfMethod(method) {
|
|
if (!method.body) {
|
|
return void 0;
|
|
}
|
|
const decorators = getDecorators(method);
|
|
const parameters = getDecoratorsOfParameters(method);
|
|
if (!some(decorators) && !some(parameters)) {
|
|
return void 0;
|
|
}
|
|
return { decorators, parameters };
|
|
}
|
|
function getAllDecoratorsOfProperty(property) {
|
|
const decorators = getDecorators(property);
|
|
if (!some(decorators)) {
|
|
return void 0;
|
|
}
|
|
return { decorators };
|
|
}
|
|
|
|
// src/compiler/transformers/destructuring.ts
|
|
var FlattenLevel = /* @__PURE__ */ ((FlattenLevel2) => {
|
|
FlattenLevel2[FlattenLevel2["All"] = 0] = "All";
|
|
FlattenLevel2[FlattenLevel2["ObjectRest"] = 1] = "ObjectRest";
|
|
return FlattenLevel2;
|
|
})(FlattenLevel || {});
|
|
function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) {
|
|
let location2 = node;
|
|
let value;
|
|
if (isDestructuringAssignment(node)) {
|
|
value = node.right;
|
|
while (isEmptyArrayLiteral(node.left) || isEmptyObjectLiteral(node.left)) {
|
|
if (isDestructuringAssignment(value)) {
|
|
location2 = node = value;
|
|
value = node.right;
|
|
} else {
|
|
return visitNode(value, visitor, isExpression);
|
|
}
|
|
}
|
|
}
|
|
let expressions;
|
|
const flattenContext = {
|
|
context,
|
|
level,
|
|
downlevelIteration: !!context.getCompilerOptions().downlevelIteration,
|
|
hoistTempVariables: true,
|
|
emitExpression,
|
|
emitBindingOrAssignment,
|
|
createArrayBindingOrAssignmentPattern: (elements) => makeArrayAssignmentPattern(context.factory, elements),
|
|
createObjectBindingOrAssignmentPattern: (elements) => makeObjectAssignmentPattern(context.factory, elements),
|
|
createArrayBindingOrAssignmentElement: makeAssignmentElement,
|
|
visitor
|
|
};
|
|
if (value) {
|
|
value = visitNode(value, visitor, isExpression);
|
|
if (isIdentifier(value) && bindingOrAssignmentElementAssignsToName(node, value.escapedText) || bindingOrAssignmentElementContainsNonLiteralComputedName(node)) {
|
|
value = ensureIdentifier(flattenContext, value, false, location2);
|
|
} else if (needsValue) {
|
|
value = ensureIdentifier(flattenContext, value, true, location2);
|
|
} else if (nodeIsSynthesized(node)) {
|
|
location2 = value;
|
|
}
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, node, value, location2, isDestructuringAssignment(node));
|
|
if (value && needsValue) {
|
|
if (!some(expressions)) {
|
|
return value;
|
|
}
|
|
expressions.push(value);
|
|
}
|
|
return context.factory.inlineExpressions(expressions) || context.factory.createOmittedExpression();
|
|
function emitExpression(expression) {
|
|
expressions = append(expressions, expression);
|
|
}
|
|
function emitBindingOrAssignment(target, value2, location3, original) {
|
|
Debug.assertNode(target, createAssignmentCallback ? isIdentifier : isExpression);
|
|
const expression = createAssignmentCallback ? createAssignmentCallback(target, value2, location3) : setTextRange(
|
|
context.factory.createAssignment(visitNode(target, visitor, isExpression), value2),
|
|
location3
|
|
);
|
|
expression.original = original;
|
|
emitExpression(expression);
|
|
}
|
|
}
|
|
function bindingOrAssignmentElementAssignsToName(element, escapedName) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (isBindingOrAssignmentPattern(target)) {
|
|
return bindingOrAssignmentPatternAssignsToName(target, escapedName);
|
|
} else if (isIdentifier(target)) {
|
|
return target.escapedText === escapedName;
|
|
}
|
|
return false;
|
|
}
|
|
function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
for (const element of elements) {
|
|
if (bindingOrAssignmentElementAssignsToName(element, escapedName)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function bindingOrAssignmentElementContainsNonLiteralComputedName(element) {
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (propertyName && isComputedPropertyName(propertyName) && !isLiteralExpression(propertyName.expression)) {
|
|
return true;
|
|
}
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
return !!target && isBindingOrAssignmentPattern(target) && bindingOrAssignmentPatternContainsNonLiteralComputedName(target);
|
|
}
|
|
function bindingOrAssignmentPatternContainsNonLiteralComputedName(pattern) {
|
|
return !!forEach(getElementsOfBindingOrAssignmentPattern(pattern), bindingOrAssignmentElementContainsNonLiteralComputedName);
|
|
}
|
|
function flattenDestructuringBinding(node, visitor, context, level, rval, hoistTempVariables = false, skipInitializer) {
|
|
let pendingExpressions;
|
|
const pendingDeclarations = [];
|
|
const declarations = [];
|
|
const flattenContext = {
|
|
context,
|
|
level,
|
|
downlevelIteration: !!context.getCompilerOptions().downlevelIteration,
|
|
hoistTempVariables,
|
|
emitExpression,
|
|
emitBindingOrAssignment,
|
|
createArrayBindingOrAssignmentPattern: (elements) => makeArrayBindingPattern(context.factory, elements),
|
|
createObjectBindingOrAssignmentPattern: (elements) => makeObjectBindingPattern(context.factory, elements),
|
|
createArrayBindingOrAssignmentElement: (name) => makeBindingElement(context.factory, name),
|
|
visitor
|
|
};
|
|
if (isVariableDeclaration(node)) {
|
|
let initializer = getInitializerOfBindingOrAssignmentElement(node);
|
|
if (initializer && (isIdentifier(initializer) && bindingOrAssignmentElementAssignsToName(node, initializer.escapedText) || bindingOrAssignmentElementContainsNonLiteralComputedName(node))) {
|
|
initializer = ensureIdentifier(flattenContext, visitNode(initializer, flattenContext.visitor), false, initializer);
|
|
node = context.factory.updateVariableDeclaration(node, node.name, void 0, void 0, initializer);
|
|
}
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, node, rval, node, skipInitializer);
|
|
if (pendingExpressions) {
|
|
const temp = context.factory.createTempVariable(void 0);
|
|
if (hoistTempVariables) {
|
|
const value = context.factory.inlineExpressions(pendingExpressions);
|
|
pendingExpressions = void 0;
|
|
emitBindingOrAssignment(temp, value, void 0, void 0);
|
|
} else {
|
|
context.hoistVariableDeclaration(temp);
|
|
const pendingDeclaration = last(pendingDeclarations);
|
|
pendingDeclaration.pendingExpressions = append(
|
|
pendingDeclaration.pendingExpressions,
|
|
context.factory.createAssignment(temp, pendingDeclaration.value)
|
|
);
|
|
addRange(pendingDeclaration.pendingExpressions, pendingExpressions);
|
|
pendingDeclaration.value = temp;
|
|
}
|
|
}
|
|
for (const { pendingExpressions: pendingExpressions2, name, value, location: location2, original } of pendingDeclarations) {
|
|
const variable = context.factory.createVariableDeclaration(
|
|
name,
|
|
void 0,
|
|
void 0,
|
|
pendingExpressions2 ? context.factory.inlineExpressions(append(pendingExpressions2, value)) : value
|
|
);
|
|
variable.original = original;
|
|
setTextRange(variable, location2);
|
|
declarations.push(variable);
|
|
}
|
|
return declarations;
|
|
function emitExpression(value) {
|
|
pendingExpressions = append(pendingExpressions, value);
|
|
}
|
|
function emitBindingOrAssignment(target, value, location2, original) {
|
|
Debug.assertNode(target, isBindingName);
|
|
if (pendingExpressions) {
|
|
value = context.factory.inlineExpressions(append(pendingExpressions, value));
|
|
pendingExpressions = void 0;
|
|
}
|
|
pendingDeclarations.push({ pendingExpressions, name: target, value, location: location2, original });
|
|
}
|
|
}
|
|
function flattenBindingOrAssignmentElement(flattenContext, element, value, location2, skipInitializer) {
|
|
const bindingTarget = getTargetOfBindingOrAssignmentElement(element);
|
|
if (!skipInitializer) {
|
|
const initializer = visitNode(getInitializerOfBindingOrAssignmentElement(element), flattenContext.visitor, isExpression);
|
|
if (initializer) {
|
|
if (value) {
|
|
value = createDefaultValueCheck(flattenContext, value, initializer, location2);
|
|
if (!isSimpleInlineableExpression(initializer) && isBindingOrAssignmentPattern(bindingTarget)) {
|
|
value = ensureIdentifier(flattenContext, value, true, location2);
|
|
}
|
|
} else {
|
|
value = initializer;
|
|
}
|
|
} else if (!value) {
|
|
value = flattenContext.context.factory.createVoidZero();
|
|
}
|
|
}
|
|
if (isObjectBindingOrAssignmentPattern(bindingTarget)) {
|
|
flattenObjectBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location2);
|
|
} else if (isArrayBindingOrAssignmentPattern(bindingTarget)) {
|
|
flattenArrayBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location2);
|
|
} else {
|
|
flattenContext.emitBindingOrAssignment(bindingTarget, value, location2, element);
|
|
}
|
|
}
|
|
function flattenObjectBindingOrAssignmentPattern(flattenContext, parent2, pattern, value, location2) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
const numElements = elements.length;
|
|
if (numElements !== 1) {
|
|
const reuseIdentifierExpressions = !isDeclarationBindingElement(parent2) || numElements !== 0;
|
|
value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location2);
|
|
}
|
|
let bindingElements;
|
|
let computedTempVariables;
|
|
for (let i = 0; i < numElements; i++) {
|
|
const element = elements[i];
|
|
if (!getRestIndicatorOfBindingOrAssignmentElement(element)) {
|
|
const propertyName = getPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (flattenContext.level >= 1 /* ObjectRest */ && !(element.transformFlags & (32768 /* ContainsRestOrSpread */ | 65536 /* ContainsObjectRestOrSpread */)) && !(getTargetOfBindingOrAssignmentElement(element).transformFlags & (32768 /* ContainsRestOrSpread */ | 65536 /* ContainsObjectRestOrSpread */)) && !isComputedPropertyName(propertyName)) {
|
|
bindingElements = append(bindingElements, visitNode(element, flattenContext.visitor));
|
|
} else {
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location2, pattern);
|
|
bindingElements = void 0;
|
|
}
|
|
const rhsValue = createDestructuringPropertyAccess(flattenContext, value, propertyName);
|
|
if (isComputedPropertyName(propertyName)) {
|
|
computedTempVariables = append(computedTempVariables, rhsValue.argumentExpression);
|
|
}
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
} else if (i === numElements - 1) {
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location2, pattern);
|
|
bindingElements = void 0;
|
|
}
|
|
const rhsValue = flattenContext.context.getEmitHelperFactory().createRestHelper(value, elements, computedTempVariables, pattern);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
}
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location2, pattern);
|
|
}
|
|
}
|
|
function flattenArrayBindingOrAssignmentPattern(flattenContext, parent2, pattern, value, location2) {
|
|
const elements = getElementsOfBindingOrAssignmentPattern(pattern);
|
|
const numElements = elements.length;
|
|
if (flattenContext.level < 1 /* ObjectRest */ && flattenContext.downlevelIteration) {
|
|
value = ensureIdentifier(
|
|
flattenContext,
|
|
setTextRange(
|
|
flattenContext.context.getEmitHelperFactory().createReadHelper(
|
|
value,
|
|
numElements > 0 && getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1]) ? void 0 : numElements
|
|
),
|
|
location2
|
|
),
|
|
false,
|
|
location2
|
|
);
|
|
} else if (numElements !== 1 && (flattenContext.level < 1 /* ObjectRest */ || numElements === 0) || every(elements, isOmittedExpression)) {
|
|
const reuseIdentifierExpressions = !isDeclarationBindingElement(parent2) || numElements !== 0;
|
|
value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location2);
|
|
}
|
|
let bindingElements;
|
|
let restContainingElements;
|
|
for (let i = 0; i < numElements; i++) {
|
|
const element = elements[i];
|
|
if (flattenContext.level >= 1 /* ObjectRest */) {
|
|
if (element.transformFlags & 65536 /* ContainsObjectRestOrSpread */ || flattenContext.hasTransformedPriorElement && !isSimpleBindingOrAssignmentElement(element)) {
|
|
flattenContext.hasTransformedPriorElement = true;
|
|
const temp = flattenContext.context.factory.createTempVariable(void 0);
|
|
if (flattenContext.hoistTempVariables) {
|
|
flattenContext.context.hoistVariableDeclaration(temp);
|
|
}
|
|
restContainingElements = append(restContainingElements, [temp, element]);
|
|
bindingElements = append(bindingElements, flattenContext.createArrayBindingOrAssignmentElement(temp));
|
|
} else {
|
|
bindingElements = append(bindingElements, element);
|
|
}
|
|
} else if (isOmittedExpression(element)) {
|
|
continue;
|
|
} else if (!getRestIndicatorOfBindingOrAssignmentElement(element)) {
|
|
const rhsValue = flattenContext.context.factory.createElementAccessExpression(value, i);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
} else if (i === numElements - 1) {
|
|
const rhsValue = flattenContext.context.factory.createArraySliceCall(value, i);
|
|
flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element);
|
|
}
|
|
}
|
|
if (bindingElements) {
|
|
flattenContext.emitBindingOrAssignment(flattenContext.createArrayBindingOrAssignmentPattern(bindingElements), value, location2, pattern);
|
|
}
|
|
if (restContainingElements) {
|
|
for (const [id, element] of restContainingElements) {
|
|
flattenBindingOrAssignmentElement(flattenContext, element, id, element);
|
|
}
|
|
}
|
|
}
|
|
function isSimpleBindingOrAssignmentElement(element) {
|
|
const target = getTargetOfBindingOrAssignmentElement(element);
|
|
if (!target || isOmittedExpression(target))
|
|
return true;
|
|
const propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(element);
|
|
if (propertyName && !isPropertyNameLiteral(propertyName))
|
|
return false;
|
|
const initializer = getInitializerOfBindingOrAssignmentElement(element);
|
|
if (initializer && !isSimpleInlineableExpression(initializer))
|
|
return false;
|
|
if (isBindingOrAssignmentPattern(target))
|
|
return every(getElementsOfBindingOrAssignmentPattern(target), isSimpleBindingOrAssignmentElement);
|
|
return isIdentifier(target);
|
|
}
|
|
function createDefaultValueCheck(flattenContext, value, defaultValue, location2) {
|
|
value = ensureIdentifier(flattenContext, value, true, location2);
|
|
return flattenContext.context.factory.createConditionalExpression(flattenContext.context.factory.createTypeCheck(value, "undefined"), void 0, defaultValue, void 0, value);
|
|
}
|
|
function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
|
|
if (isComputedPropertyName(propertyName)) {
|
|
const argumentExpression = ensureIdentifier(flattenContext, visitNode(propertyName.expression, flattenContext.visitor), false, propertyName);
|
|
return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
|
|
} else if (isStringOrNumericLiteralLike(propertyName)) {
|
|
const argumentExpression = factory.cloneNode(propertyName);
|
|
return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
|
|
} else {
|
|
const name = flattenContext.context.factory.createIdentifier(idText(propertyName));
|
|
return flattenContext.context.factory.createPropertyAccessExpression(value, name);
|
|
}
|
|
}
|
|
function ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location2) {
|
|
if (isIdentifier(value) && reuseIdentifierExpressions) {
|
|
return value;
|
|
} else {
|
|
const temp = flattenContext.context.factory.createTempVariable(void 0);
|
|
if (flattenContext.hoistTempVariables) {
|
|
flattenContext.context.hoistVariableDeclaration(temp);
|
|
flattenContext.emitExpression(setTextRange(flattenContext.context.factory.createAssignment(temp, value), location2));
|
|
} else {
|
|
flattenContext.emitBindingOrAssignment(temp, value, location2, void 0);
|
|
}
|
|
return temp;
|
|
}
|
|
}
|
|
function makeArrayBindingPattern(factory2, elements) {
|
|
Debug.assertEachNode(elements, isArrayBindingElement);
|
|
return factory2.createArrayBindingPattern(elements);
|
|
}
|
|
function makeArrayAssignmentPattern(factory2, elements) {
|
|
return factory2.createArrayLiteralExpression(map(elements, factory2.converters.convertToArrayAssignmentElement));
|
|
}
|
|
function makeObjectBindingPattern(factory2, elements) {
|
|
Debug.assertEachNode(elements, isBindingElement);
|
|
return factory2.createObjectBindingPattern(elements);
|
|
}
|
|
function makeObjectAssignmentPattern(factory2, elements) {
|
|
return factory2.createObjectLiteralExpression(map(elements, factory2.converters.convertToObjectAssignmentElement));
|
|
}
|
|
function makeBindingElement(factory2, name) {
|
|
return factory2.createBindingElement(void 0, void 0, name);
|
|
}
|
|
function makeAssignmentElement(name) {
|
|
return name;
|
|
}
|
|
|
|
// src/compiler/transformers/taggedTemplate.ts
|
|
var ProcessLevel = /* @__PURE__ */ ((ProcessLevel2) => {
|
|
ProcessLevel2[ProcessLevel2["LiftRestriction"] = 0] = "LiftRestriction";
|
|
ProcessLevel2[ProcessLevel2["All"] = 1] = "All";
|
|
return ProcessLevel2;
|
|
})(ProcessLevel || {});
|
|
function processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, level) {
|
|
const tag = visitNode(node.tag, visitor, isExpression);
|
|
const templateArguments = [void 0];
|
|
const cookedStrings = [];
|
|
const rawStrings = [];
|
|
const template = node.template;
|
|
if (level === 0 /* LiftRestriction */ && !hasInvalidEscape(template)) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
if (isNoSubstitutionTemplateLiteral(template)) {
|
|
cookedStrings.push(createTemplateCooked(template));
|
|
rawStrings.push(getRawLiteral(template, currentSourceFile));
|
|
} else {
|
|
cookedStrings.push(createTemplateCooked(template.head));
|
|
rawStrings.push(getRawLiteral(template.head, currentSourceFile));
|
|
for (const templateSpan of template.templateSpans) {
|
|
cookedStrings.push(createTemplateCooked(templateSpan.literal));
|
|
rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile));
|
|
templateArguments.push(visitNode(templateSpan.expression, visitor, isExpression));
|
|
}
|
|
}
|
|
const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(
|
|
factory.createArrayLiteralExpression(cookedStrings),
|
|
factory.createArrayLiteralExpression(rawStrings)
|
|
);
|
|
if (isExternalModule(currentSourceFile)) {
|
|
const tempVar = factory.createUniqueName("templateObject");
|
|
recordTaggedTemplateString(tempVar);
|
|
templateArguments[0] = factory.createLogicalOr(
|
|
tempVar,
|
|
factory.createAssignment(
|
|
tempVar,
|
|
helperCall
|
|
)
|
|
);
|
|
} else {
|
|
templateArguments[0] = helperCall;
|
|
}
|
|
return factory.createCallExpression(tag, void 0, templateArguments);
|
|
}
|
|
function createTemplateCooked(template) {
|
|
return template.templateFlags ? factory.createVoidZero() : factory.createStringLiteral(template.text);
|
|
}
|
|
function getRawLiteral(node, currentSourceFile) {
|
|
let text = node.rawText;
|
|
if (text === void 0) {
|
|
Debug.assertIsDefined(
|
|
currentSourceFile,
|
|
"Template literal node is missing 'rawText' and does not have a source file. Possibly bad transform."
|
|
);
|
|
text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node);
|
|
const isLast = node.kind === 14 /* NoSubstitutionTemplateLiteral */ || node.kind === 17 /* TemplateTail */;
|
|
text = text.substring(1, text.length - (isLast ? 1 : 2));
|
|
}
|
|
text = text.replace(/\r\n?/g, "\n");
|
|
return setTextRange(factory.createStringLiteral(text), node);
|
|
}
|
|
|
|
// src/compiler/transformers/ts.ts
|
|
var USE_NEW_TYPE_METADATA_FORMAT = false;
|
|
function transformTypeScript(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const typeSerializer = compilerOptions.emitDecoratorMetadata ? createRuntimeTypeSerializer(context) : void 0;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
let currentSourceFile;
|
|
let currentNamespace;
|
|
let currentNamespaceContainerName;
|
|
let currentLexicalScope;
|
|
let currentScopeFirstDeclarationsOfName;
|
|
let currentClassHasParameterProperties;
|
|
let enabledSubstitutions;
|
|
let applicableSubstitutions;
|
|
return transformSourceFileOrBundle;
|
|
function transformSourceFileOrBundle(node) {
|
|
if (node.kind === 309 /* Bundle */) {
|
|
return transformBundle(node);
|
|
}
|
|
return transformSourceFile(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return factory2.createBundle(node.sourceFiles.map(transformSourceFile), mapDefined(node.prepends, (prepend) => {
|
|
if (prepend.kind === 311 /* InputFiles */) {
|
|
return createUnparsedSourceFile(prepend, "js");
|
|
}
|
|
return prepend;
|
|
}));
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const visited = saveStateAndInvoke(node, visitSourceFile);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
return visited;
|
|
}
|
|
function saveStateAndInvoke(node, f) {
|
|
const savedCurrentScope = currentLexicalScope;
|
|
const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
|
|
const savedCurrentClassHasParameterProperties = currentClassHasParameterProperties;
|
|
onBeforeVisitNode(node);
|
|
const visited = f(node);
|
|
if (currentLexicalScope !== savedCurrentScope) {
|
|
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
|
|
}
|
|
currentLexicalScope = savedCurrentScope;
|
|
currentClassHasParameterProperties = savedCurrentClassHasParameterProperties;
|
|
return visited;
|
|
}
|
|
function onBeforeVisitNode(node) {
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 266 /* CaseBlock */:
|
|
case 265 /* ModuleBlock */:
|
|
case 238 /* Block */:
|
|
currentLexicalScope = node;
|
|
currentScopeFirstDeclarationsOfName = void 0;
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
if (hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
break;
|
|
}
|
|
if (node.name) {
|
|
recordEmittedDeclarationInScope(node);
|
|
} else {
|
|
Debug.assert(node.kind === 260 /* ClassDeclaration */ || hasSyntacticModifier(node, 1024 /* Default */));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function visitor(node) {
|
|
return saveStateAndInvoke(node, visitorWorker);
|
|
}
|
|
function visitorWorker(node) {
|
|
if (node.transformFlags & 1 /* ContainsTypeScript */) {
|
|
return visitTypeScript(node);
|
|
}
|
|
return node;
|
|
}
|
|
function sourceElementVisitor(node) {
|
|
return saveStateAndInvoke(node, sourceElementVisitorWorker);
|
|
}
|
|
function sourceElementVisitorWorker(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 275 /* ExportDeclaration */:
|
|
return visitElidableStatement(node);
|
|
default:
|
|
return visitorWorker(node);
|
|
}
|
|
}
|
|
function visitElidableStatement(node) {
|
|
const parsed = getParseTreeNode(node);
|
|
if (parsed !== node) {
|
|
if (node.transformFlags & 1 /* ContainsTypeScript */) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
default:
|
|
Debug.fail("Unhandled ellided statement");
|
|
}
|
|
}
|
|
function namespaceElementVisitor(node) {
|
|
return saveStateAndInvoke(node, namespaceElementVisitorWorker);
|
|
}
|
|
function namespaceElementVisitorWorker(node) {
|
|
if (node.kind === 275 /* ExportDeclaration */ || node.kind === 269 /* ImportDeclaration */ || node.kind === 270 /* ImportClause */ || node.kind === 268 /* ImportEqualsDeclaration */ && node.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
return void 0;
|
|
} else if (node.transformFlags & 1 /* ContainsTypeScript */ || hasSyntacticModifier(node, 1 /* Export */)) {
|
|
return visitTypeScript(node);
|
|
}
|
|
return node;
|
|
}
|
|
function getClassElementVisitor(parent2) {
|
|
return (node) => saveStateAndInvoke(node, (n) => classElementVisitorWorker(n, parent2));
|
|
}
|
|
function classElementVisitorWorker(node, parent2) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return visitConstructor(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node, parent2);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessor(node, parent2);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessor(node, parent2);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node, parent2);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return visitEachChild(node, visitor, context);
|
|
case 237 /* SemicolonClassElement */:
|
|
return node;
|
|
case 178 /* IndexSignature */:
|
|
return;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function getObjectLiteralElementVisitor(parent2) {
|
|
return (node) => saveStateAndInvoke(node, (n) => objectLiteralElementVisitorWorker(n, parent2));
|
|
}
|
|
function objectLiteralElementVisitorWorker(node, parent2) {
|
|
switch (node.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return visitor(node);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessor(node, parent2);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessor(node, parent2);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node, parent2);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function modifierVisitor(node) {
|
|
if (isDecorator(node))
|
|
return void 0;
|
|
if (modifierToFlag(node.kind) & 117086 /* TypeScriptModifier */) {
|
|
return void 0;
|
|
} else if (currentNamespace && node.kind === 93 /* ExportKeyword */) {
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function visitTypeScript(node) {
|
|
if (isStatement(node) && hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return currentNamespace ? void 0 : node;
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
case 187 /* OptionalType */:
|
|
case 188 /* RestType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 179 /* TypePredicate */:
|
|
case 165 /* TypeParameter */:
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 114 /* VoidKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 182 /* ConstructorType */:
|
|
case 181 /* FunctionType */:
|
|
case 183 /* TypeQuery */:
|
|
case 180 /* TypeReference */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 191 /* ConditionalType */:
|
|
case 193 /* ParenthesizedType */:
|
|
case 194 /* ThisType */:
|
|
case 195 /* TypeOperator */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 197 /* MappedType */:
|
|
case 198 /* LiteralType */:
|
|
case 178 /* IndexSignature */:
|
|
return void 0;
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return factory2.createNotEmittedStatement(node);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return void 0;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return factory2.createNotEmittedStatement(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 294 /* HeritageClause */:
|
|
return visitHeritageClause(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return visitExpressionWithTypeArguments(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return Debug.fail("Class and object literal elements must be visited with their respective visitors");
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 216 /* ArrowFunction */:
|
|
return visitArrowFunction(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
return visitAssertionExpression(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return visitSatisfiesExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 232 /* NonNullExpression */:
|
|
return visitNonNullExpression(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return visitEnumDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return visitModuleDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node);
|
|
case 283 /* JsxOpeningElement */:
|
|
return visitJsxJsxOpeningElement(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitSourceFile(node) {
|
|
const alwaysStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") && !(isExternalModule(node) && moduleKind >= 5 /* ES2015 */) && !isJsonSourceFile(node);
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
visitLexicalEnvironment(node.statements, sourceElementVisitor, context, 0, alwaysStrict)
|
|
);
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
return factory2.updateObjectLiteralExpression(
|
|
node,
|
|
visitNodes2(node.properties, getObjectLiteralElementVisitor(node), isObjectLiteralElement)
|
|
);
|
|
}
|
|
function getClassFacts(node, staticProperties) {
|
|
let facts = 0 /* None */;
|
|
if (some(staticProperties))
|
|
facts |= 1 /* HasStaticInitializedProperties */;
|
|
const extendsClauseElement = getEffectiveBaseTypeNode(node);
|
|
if (extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */)
|
|
facts |= 64 /* IsDerivedClass */;
|
|
if (classOrConstructorParameterIsDecorated(node))
|
|
facts |= 2 /* HasConstructorDecorators */;
|
|
if (childIsDecorated(node))
|
|
facts |= 4 /* HasMemberDecorators */;
|
|
if (isExportOfNamespace(node))
|
|
facts |= 8 /* IsExportOfNamespace */;
|
|
else if (isDefaultExternalModuleExport(node))
|
|
facts |= 32 /* IsDefaultExternalExport */;
|
|
else if (isNamedExternalModuleExport(node))
|
|
facts |= 16 /* IsNamedExternalExport */;
|
|
if (languageVersion <= 1 /* ES5 */ && facts & 7 /* MayNeedImmediatelyInvokedFunctionExpression */)
|
|
facts |= 128 /* UseImmediatelyInvokedFunctionExpression */;
|
|
return facts;
|
|
}
|
|
function hasTypeScriptClassSyntax(node) {
|
|
return !!(node.transformFlags & 8192 /* ContainsTypeScriptClassSyntax */);
|
|
}
|
|
function isClassLikeDeclarationWithTypeScriptSyntax(node) {
|
|
return hasDecorators(node) || some(node.typeParameters) || some(node.heritageClauses, hasTypeScriptClassSyntax) || some(node.members, hasTypeScriptClassSyntax);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && hasSyntacticModifier(node, 1 /* Export */))) {
|
|
return factory2.updateClassDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, getClassElementVisitor(node), isClassElement)
|
|
);
|
|
}
|
|
const staticProperties = getProperties(node, true, true);
|
|
const facts = getClassFacts(node, staticProperties);
|
|
if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */) {
|
|
context.startLexicalEnvironment();
|
|
}
|
|
const name = node.name || (facts & 5 /* NeedsName */ ? factory2.getGeneratedNameForNode(node) : void 0);
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators);
|
|
const modifiers = !(facts & 128 /* UseImmediatelyInvokedFunctionExpression */) ? visitNodes2(node.modifiers, modifierVisitor, isModifier) : elideNodes(factory2, node.modifiers);
|
|
const classStatement = factory2.updateClassDeclaration(
|
|
node,
|
|
concatenate(decorators, modifiers),
|
|
name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
transformClassMembers(node)
|
|
);
|
|
let emitFlags = getEmitFlags(node);
|
|
if (facts & 1 /* HasStaticInitializedProperties */) {
|
|
emitFlags |= 64 /* NoTrailingSourceMap */;
|
|
}
|
|
setEmitFlags(classStatement, emitFlags);
|
|
let statements = [classStatement];
|
|
if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */) {
|
|
const closingBraceLocation = createTokenRange(skipTrivia(currentSourceFile.text, node.members.end), 19 /* CloseBraceToken */);
|
|
const localName = factory2.getInternalName(node);
|
|
const outer = factory2.createPartiallyEmittedExpression(localName);
|
|
setTextRangeEnd(outer, closingBraceLocation.end);
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const statement = factory2.createReturnStatement(outer);
|
|
setTextRangePos(statement, closingBraceLocation.pos);
|
|
setEmitFlags(statement, 3072 /* NoComments */ | 768 /* NoTokenSourceMaps */);
|
|
statements.push(statement);
|
|
insertStatementsAfterStandardPrologue(statements, context.endLexicalEnvironment());
|
|
const iife = factory2.createImmediatelyInvokedArrowFunction(statements);
|
|
setEmitFlags(iife, 67108864 /* TypeScriptClassWrapper */);
|
|
const varStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, false, false),
|
|
void 0,
|
|
void 0,
|
|
iife
|
|
)
|
|
])
|
|
);
|
|
setOriginalNode(varStatement, node);
|
|
setCommentRange(varStatement, node);
|
|
setSourceMapRange(varStatement, moveRangePastDecorators(node));
|
|
startOnNewLine(varStatement);
|
|
statements = [varStatement];
|
|
}
|
|
if (facts & 8 /* IsExportOfNamespace */) {
|
|
addExportMemberAssignment(statements, node);
|
|
} else if (facts & 128 /* UseImmediatelyInvokedFunctionExpression */ || facts & 2 /* HasConstructorDecorators */) {
|
|
if (facts & 32 /* IsDefaultExternalExport */) {
|
|
statements.push(factory2.createExportDefault(factory2.getLocalName(node, false, true)));
|
|
} else if (facts & 16 /* IsNamedExternalExport */) {
|
|
statements.push(factory2.createExternalModuleExport(factory2.getLocalName(node, false, true)));
|
|
}
|
|
}
|
|
if (statements.length > 1) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(classStatement, getEmitFlags(classStatement) | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassExpression(node) {
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators);
|
|
return factory2.updateClassExpression(
|
|
node,
|
|
decorators,
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
isClassLikeDeclarationWithTypeScriptSyntax(node) ? transformClassMembers(node) : visitNodes2(node.members, getClassElementVisitor(node), isClassElement)
|
|
);
|
|
}
|
|
function transformClassMembers(node) {
|
|
const members = [];
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
const parametersWithPropertyAssignments = constructor && filter(constructor.parameters, (p) => isParameterPropertyDeclaration(p, constructor));
|
|
if (parametersWithPropertyAssignments) {
|
|
for (const parameter of parametersWithPropertyAssignments) {
|
|
if (isIdentifier(parameter.name)) {
|
|
members.push(setOriginalNode(factory2.createPropertyDeclaration(
|
|
void 0,
|
|
parameter.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
), parameter));
|
|
}
|
|
}
|
|
}
|
|
addRange(members, visitNodes2(node.members, getClassElementVisitor(node), isClassElement));
|
|
return setTextRange(factory2.createNodeArray(members), node.members);
|
|
}
|
|
function transformAllDecoratorsOfDeclaration(node, container, allDecorators) {
|
|
var _a2, _b, _c, _d;
|
|
if (!allDecorators) {
|
|
return void 0;
|
|
}
|
|
const decorators = visitArray(allDecorators.decorators, visitor, isDecorator);
|
|
const parameterDecorators = flatMap(allDecorators.parameters, transformDecoratorsOfParameter);
|
|
const metadataDecorators = some(decorators) || some(parameterDecorators) ? getTypeMetadata(node, container) : void 0;
|
|
const result = factory2.createNodeArray(concatenate(concatenate(decorators, parameterDecorators), metadataDecorators));
|
|
const pos = (_b = (_a2 = firstOrUndefined(allDecorators.decorators)) == null ? void 0 : _a2.pos) != null ? _b : -1;
|
|
const end = (_d = (_c = lastOrUndefined(allDecorators.decorators)) == null ? void 0 : _c.end) != null ? _d : -1;
|
|
setTextRangePosEnd(result, pos, end);
|
|
return result;
|
|
}
|
|
function transformDecoratorsOfParameter(parameterDecorators, parameterOffset) {
|
|
if (parameterDecorators) {
|
|
const decorators = [];
|
|
for (const parameterDecorator of parameterDecorators) {
|
|
const expression = visitNode(parameterDecorator.expression, visitor, isExpression);
|
|
const helper = emitHelpers().createParamHelper(expression, parameterOffset);
|
|
setTextRange(helper, parameterDecorator.expression);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
const decorator = factory2.createDecorator(helper);
|
|
setSourceMapRange(decorator, parameterDecorator.expression);
|
|
setCommentRange(decorator, parameterDecorator.expression);
|
|
setEmitFlags(decorator, 3072 /* NoComments */);
|
|
decorators.push(decorator);
|
|
}
|
|
return decorators;
|
|
}
|
|
}
|
|
function getTypeMetadata(node, container) {
|
|
return USE_NEW_TYPE_METADATA_FORMAT ? getNewTypeMetadata(node, container) : getOldTypeMetadata(node, container);
|
|
}
|
|
function getOldTypeMetadata(node, container) {
|
|
if (typeSerializer) {
|
|
let decorators;
|
|
if (shouldAddTypeMetadata(node)) {
|
|
const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
|
|
decorators = append(decorators, factory2.createDecorator(typeMetadata));
|
|
}
|
|
if (shouldAddParamTypesMetadata(node)) {
|
|
const paramTypesMetadata = emitHelpers().createMetadataHelper("design:paramtypes", typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope, currentNameScope: container }, node, container));
|
|
decorators = append(decorators, factory2.createDecorator(paramTypesMetadata));
|
|
}
|
|
if (shouldAddReturnTypeMetadata(node)) {
|
|
const returnTypeMetadata = emitHelpers().createMetadataHelper("design:returntype", typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
|
|
decorators = append(decorators, factory2.createDecorator(returnTypeMetadata));
|
|
}
|
|
return decorators;
|
|
}
|
|
}
|
|
function getNewTypeMetadata(node, container) {
|
|
if (typeSerializer) {
|
|
let properties;
|
|
if (shouldAddTypeMetadata(node)) {
|
|
const typeProperty = factory2.createPropertyAssignment("type", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)));
|
|
properties = append(properties, typeProperty);
|
|
}
|
|
if (shouldAddParamTypesMetadata(node)) {
|
|
const paramTypeProperty = factory2.createPropertyAssignment("paramTypes", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope, currentNameScope: container }, node, container)));
|
|
properties = append(properties, paramTypeProperty);
|
|
}
|
|
if (shouldAddReturnTypeMetadata(node)) {
|
|
const returnTypeProperty = factory2.createPropertyAssignment("returnType", factory2.createArrowFunction(void 0, void 0, [], void 0, factory2.createToken(38 /* EqualsGreaterThanToken */), typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)));
|
|
properties = append(properties, returnTypeProperty);
|
|
}
|
|
if (properties) {
|
|
const typeInfoMetadata = emitHelpers().createMetadataHelper("design:typeinfo", factory2.createObjectLiteralExpression(properties, true));
|
|
return [factory2.createDecorator(typeInfoMetadata)];
|
|
}
|
|
}
|
|
}
|
|
function shouldAddTypeMetadata(node) {
|
|
const kind = node.kind;
|
|
return kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */ || kind === 169 /* PropertyDeclaration */;
|
|
}
|
|
function shouldAddReturnTypeMetadata(node) {
|
|
return node.kind === 171 /* MethodDeclaration */;
|
|
}
|
|
function shouldAddParamTypesMetadata(node) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return getFirstConstructorWithBody(node) !== void 0;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
|
|
const name = member.name;
|
|
if (isPrivateIdentifier(name)) {
|
|
return factory2.createIdentifier("");
|
|
} else if (isComputedPropertyName(name)) {
|
|
return generateNameForComputedPropertyName && !isSimpleInlineableExpression(name.expression) ? factory2.getGeneratedNameForNode(name) : name.expression;
|
|
} else if (isIdentifier(name)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return factory2.cloneNode(name);
|
|
}
|
|
}
|
|
function visitPropertyNameOfClassElement(member) {
|
|
const name = member.name;
|
|
if (isComputedPropertyName(name) && (!hasStaticModifier(member) && currentClassHasParameterProperties || hasDecorators(member))) {
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const innerExpression = skipPartiallyEmittedExpressions(expression);
|
|
if (!isSimpleInlineableExpression(innerExpression)) {
|
|
const generatedName = factory2.getGeneratedNameForNode(name);
|
|
hoistVariableDeclaration(generatedName);
|
|
return factory2.updateComputedPropertyName(name, factory2.createAssignment(generatedName, expression));
|
|
}
|
|
}
|
|
return visitNode(name, visitor, isPropertyName);
|
|
}
|
|
function visitHeritageClause(node) {
|
|
if (node.token === 117 /* ImplementsKeyword */) {
|
|
return void 0;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitExpressionWithTypeArguments(node) {
|
|
return factory2.updateExpressionWithTypeArguments(
|
|
node,
|
|
visitNode(node.expression, visitor, isLeftHandSideExpression),
|
|
void 0
|
|
);
|
|
}
|
|
function shouldEmitFunctionLikeDeclaration(node) {
|
|
return !nodeIsMissing(node.body);
|
|
}
|
|
function visitPropertyDeclaration(node, parent2) {
|
|
const isAmbient = node.flags & 16777216 /* Ambient */ || hasSyntacticModifier(node, 256 /* Abstract */);
|
|
if (isAmbient && !hasDecorators(node)) {
|
|
return void 0;
|
|
}
|
|
const allDecorators = getAllDecoratorsOfClassElement(node, parent2);
|
|
const decorators = transformAllDecoratorsOfDeclaration(node, parent2, allDecorators);
|
|
if (isAmbient) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
concatenate(decorators, factory2.createModifiersFromModifierFlags(2 /* Ambient */)),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor)
|
|
);
|
|
}
|
|
function visitConstructor(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformConstructorBody(node.body, node)
|
|
);
|
|
}
|
|
function transformConstructorBody(body, constructor) {
|
|
const parametersWithPropertyAssignments = constructor && filter(constructor.parameters, (p) => isParameterPropertyDeclaration(p, constructor));
|
|
if (!some(parametersWithPropertyAssignments)) {
|
|
return visitFunctionBody(body, visitor, context);
|
|
}
|
|
let statements = [];
|
|
resumeLexicalEnvironment();
|
|
const prologueStatementCount = factory2.copyPrologue(body.statements, statements, false, visitor);
|
|
const superStatementIndex = findSuperStatementIndex(body.statements, prologueStatementCount);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(
|
|
statements,
|
|
visitNodes2(body.statements, visitor, isStatement, prologueStatementCount, superStatementIndex + 1 - prologueStatementCount)
|
|
);
|
|
}
|
|
const parameterPropertyAssignments = mapDefined(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(statements, parameterPropertyAssignments);
|
|
} else {
|
|
statements = [
|
|
...statements.slice(0, prologueStatementCount),
|
|
...parameterPropertyAssignments,
|
|
...statements.slice(prologueStatementCount)
|
|
];
|
|
}
|
|
const start2 = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount;
|
|
addRange(statements, visitNodes2(body.statements, visitor, isStatement, start2));
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), body.statements), true);
|
|
setTextRange(block, body);
|
|
setOriginalNode(block, body);
|
|
return block;
|
|
}
|
|
function transformParameterWithPropertyAssignment(node) {
|
|
const name = node.name;
|
|
if (!isIdentifier(name)) {
|
|
return void 0;
|
|
}
|
|
const propertyName = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setEmitFlags(propertyName, 3072 /* NoComments */ | 96 /* NoSourceMap */);
|
|
const localName = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setEmitFlags(localName, 3072 /* NoComments */);
|
|
return startOnNewLine(
|
|
removeAllComments(
|
|
setTextRange(
|
|
setOriginalNode(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createThis(),
|
|
propertyName
|
|
),
|
|
node.name
|
|
),
|
|
localName
|
|
)
|
|
),
|
|
node
|
|
),
|
|
moveRangePos(node, -1)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function visitMethodDeclaration(node, parent2) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const allDecorators = isClassLike(parent2) ? getAllDecoratorsOfClassElement(node, parent2) : void 0;
|
|
const decorators = isClassLike(parent2) ? transformAllDecoratorsOfDeclaration(node, parent2, allDecorators) : void 0;
|
|
return factory2.updateMethodDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
node.asteriskToken,
|
|
visitPropertyNameOfClassElement(node),
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function shouldEmitAccessorDeclaration(node) {
|
|
return !(nodeIsMissing(node.body) && hasSyntacticModifier(node, 256 /* Abstract */));
|
|
}
|
|
function visitGetAccessor(node, parent2) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitAccessorDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const decorators = isClassLike(parent2) ? transformAllDecoratorsOfDeclaration(node, parent2, getAllDecoratorsOfClassElement(node, parent2)) : void 0;
|
|
return factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
}
|
|
function visitSetAccessor(node, parent2) {
|
|
if (!(node.transformFlags & 1 /* ContainsTypeScript */)) {
|
|
return node;
|
|
}
|
|
if (!shouldEmitAccessorDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const decorators = isClassLike(parent2) ? transformAllDecoratorsOfDeclaration(node, parent2, getAllDecoratorsOfClassElement(node, parent2)) : void 0;
|
|
return factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
concatenate(decorators, visitNodes2(node.modifiers, modifierVisitor, isModifierLike)),
|
|
visitPropertyNameOfClassElement(node),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
const updated = factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
if (isExportOfNamespace(node)) {
|
|
const statements = [updated];
|
|
addExportMemberAssignment(statements, node);
|
|
return statements;
|
|
}
|
|
return updated;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
if (!shouldEmitFunctionLikeDeclaration(node)) {
|
|
return factory2.createOmittedExpression();
|
|
}
|
|
const updated = factory2.updateFunctionExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context) || factory2.createBlock([])
|
|
);
|
|
return updated;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
const updated = factory2.updateArrowFunction(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
return updated;
|
|
}
|
|
function visitParameter(node) {
|
|
if (parameterIsThisKeyword(node)) {
|
|
return void 0;
|
|
}
|
|
const updated = factory2.updateParameterDeclaration(
|
|
node,
|
|
elideNodes(factory2, node.modifiers),
|
|
node.dotDotDotToken,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (updated !== node) {
|
|
setCommentRange(updated, node);
|
|
setTextRange(updated, moveRangePastModifiers(node));
|
|
setSourceMapRange(updated, moveRangePastModifiers(node));
|
|
setEmitFlags(updated.name, 64 /* NoTrailingSourceMap */);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (isExportOfNamespace(node)) {
|
|
const variables = getInitializedVariables(node.declarationList);
|
|
if (variables.length === 0) {
|
|
return void 0;
|
|
}
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.inlineExpressions(
|
|
map(variables, transformInitializedVariable)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createNamespaceExportExpression
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
getNamespaceMemberNameWithSourceMapsAndWithoutComments(name),
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
const updated = factory2.updateVariableDeclaration(
|
|
node,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (node.type) {
|
|
setTypeNode(updated.name, node.type);
|
|
}
|
|
return updated;
|
|
}
|
|
function visitParenthesizedExpression(node) {
|
|
const innerExpression = skipOuterExpressions(node.expression, ~6 /* Assertions */);
|
|
if (isAssertionExpression(innerExpression)) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitAssertionExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitNonNullExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isLeftHandSideExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitSatisfiesExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return factory2.createPartiallyEmittedExpression(expression, node);
|
|
}
|
|
function visitCallExpression(node) {
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitNewExpression(node) {
|
|
return factory2.updateNewExpression(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
visitNode(node.tag, visitor, isExpression),
|
|
void 0,
|
|
visitNode(node.template, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitJsxSelfClosingElement(node) {
|
|
return factory2.updateJsxSelfClosingElement(
|
|
node,
|
|
visitNode(node.tagName, visitor, isJsxTagNameExpression),
|
|
void 0,
|
|
visitNode(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
}
|
|
function visitJsxJsxOpeningElement(node) {
|
|
return factory2.updateJsxOpeningElement(
|
|
node,
|
|
visitNode(node.tagName, visitor, isJsxTagNameExpression),
|
|
void 0,
|
|
visitNode(node.attributes, visitor, isJsxAttributes)
|
|
);
|
|
}
|
|
function shouldEmitEnumDeclaration(node) {
|
|
return !isEnumConst(node) || shouldPreserveConstEnums(compilerOptions);
|
|
}
|
|
function visitEnumDeclaration(node) {
|
|
if (!shouldEmitEnumDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
const statements = [];
|
|
let emitFlags = 4 /* AdviseOnEmitNode */;
|
|
const varAdded = addVarForEnumOrModuleDeclaration(statements, node);
|
|
if (varAdded) {
|
|
if (moduleKind !== 4 /* System */ || currentLexicalScope !== currentSourceFile) {
|
|
emitFlags |= 1024 /* NoLeadingComments */;
|
|
}
|
|
}
|
|
const parameterName = getNamespaceParameterName(node);
|
|
const containerName = getNamespaceContainerName(node);
|
|
const exportName = hasSyntacticModifier(node, 1 /* Export */) ? factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) : factory2.getLocalName(node, false, true);
|
|
let moduleArg = factory2.createLogicalOr(
|
|
exportName,
|
|
factory2.createAssignment(
|
|
exportName,
|
|
factory2.createObjectLiteralExpression()
|
|
)
|
|
);
|
|
if (hasNamespaceQualifiedExportName(node)) {
|
|
const localName = factory2.getLocalName(node, false, true);
|
|
moduleArg = factory2.createAssignment(localName, moduleArg);
|
|
}
|
|
const enumStatement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
transformEnumBody(node, containerName)
|
|
),
|
|
void 0,
|
|
[moduleArg]
|
|
)
|
|
);
|
|
setOriginalNode(enumStatement, node);
|
|
if (varAdded) {
|
|
setSyntheticLeadingComments(enumStatement, void 0);
|
|
setSyntheticTrailingComments(enumStatement, void 0);
|
|
}
|
|
setTextRange(enumStatement, node);
|
|
addEmitFlags(enumStatement, emitFlags);
|
|
statements.push(enumStatement);
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
return statements;
|
|
}
|
|
function transformEnumBody(node, localName) {
|
|
const savedCurrentNamespaceLocalName = currentNamespaceContainerName;
|
|
currentNamespaceContainerName = localName;
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const members = map(node.members, transformEnumMember);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
addRange(statements, members);
|
|
currentNamespaceContainerName = savedCurrentNamespaceLocalName;
|
|
return factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), node.members),
|
|
true
|
|
);
|
|
}
|
|
function transformEnumMember(member) {
|
|
const name = getExpressionForPropertyName(member, false);
|
|
const valueExpression = transformEnumMemberDeclarationValue(member);
|
|
const innerAssignment = factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
currentNamespaceContainerName,
|
|
name
|
|
),
|
|
valueExpression
|
|
);
|
|
const outerAssignment = valueExpression.kind === 10 /* StringLiteral */ ? innerAssignment : factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
currentNamespaceContainerName,
|
|
innerAssignment
|
|
),
|
|
name
|
|
);
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
setTextRange(
|
|
outerAssignment,
|
|
member
|
|
)
|
|
),
|
|
member
|
|
);
|
|
}
|
|
function transformEnumMemberDeclarationValue(member) {
|
|
const value = resolver.getConstantValue(member);
|
|
if (value !== void 0) {
|
|
return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
|
|
} else {
|
|
enableSubstitutionForNonQualifiedEnumMembers();
|
|
if (member.initializer) {
|
|
return visitNode(member.initializer, visitor, isExpression);
|
|
} else {
|
|
return factory2.createVoidZero();
|
|
}
|
|
}
|
|
}
|
|
function shouldEmitModuleDeclaration(nodeIn) {
|
|
const node = getParseTreeNode(nodeIn, isModuleDeclaration);
|
|
if (!node) {
|
|
return true;
|
|
}
|
|
return isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions));
|
|
}
|
|
function hasNamespaceQualifiedExportName(node) {
|
|
return isExportOfNamespace(node) || isExternalModuleExport(node) && moduleKind !== 5 /* ES2015 */ && moduleKind !== 6 /* ES2020 */ && moduleKind !== 7 /* ES2022 */ && moduleKind !== 99 /* ESNext */ && moduleKind !== 4 /* System */;
|
|
}
|
|
function recordEmittedDeclarationInScope(node) {
|
|
if (!currentScopeFirstDeclarationsOfName) {
|
|
currentScopeFirstDeclarationsOfName = /* @__PURE__ */ new Map();
|
|
}
|
|
const name = declaredNameInScope(node);
|
|
if (!currentScopeFirstDeclarationsOfName.has(name)) {
|
|
currentScopeFirstDeclarationsOfName.set(name, node);
|
|
}
|
|
}
|
|
function isFirstEmittedDeclarationInScope(node) {
|
|
if (currentScopeFirstDeclarationsOfName) {
|
|
const name = declaredNameInScope(node);
|
|
return currentScopeFirstDeclarationsOfName.get(name) === node;
|
|
}
|
|
return true;
|
|
}
|
|
function declaredNameInScope(node) {
|
|
Debug.assertNode(node.name, isIdentifier);
|
|
return node.name.escapedText;
|
|
}
|
|
function addVarForEnumOrModuleDeclaration(statements, node) {
|
|
const statement = factory2.createVariableStatement(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, false, true)
|
|
)
|
|
], currentLexicalScope.kind === 308 /* SourceFile */ ? 0 /* None */ : 1 /* Let */)
|
|
);
|
|
setOriginalNode(statement, node);
|
|
recordEmittedDeclarationInScope(node);
|
|
if (isFirstEmittedDeclarationInScope(node)) {
|
|
if (node.kind === 263 /* EnumDeclaration */) {
|
|
setSourceMapRange(statement.declarationList, node);
|
|
} else {
|
|
setSourceMapRange(statement, node);
|
|
}
|
|
setCommentRange(statement, node);
|
|
addEmitFlags(statement, 2048 /* NoTrailingComments */ | 8388608 /* HasEndOfDeclarationMarker */);
|
|
statements.push(statement);
|
|
return true;
|
|
} else {
|
|
const mergeMarker = factory2.createMergeDeclarationMarker(statement);
|
|
setEmitFlags(mergeMarker, 3072 /* NoComments */ | 8388608 /* HasEndOfDeclarationMarker */);
|
|
statements.push(mergeMarker);
|
|
return false;
|
|
}
|
|
}
|
|
function visitModuleDeclaration(node) {
|
|
if (!shouldEmitModuleDeclaration(node)) {
|
|
return factory2.createNotEmittedStatement(node);
|
|
}
|
|
Debug.assertNode(node.name, isIdentifier, "A TypeScript namespace should have an Identifier name.");
|
|
enableSubstitutionForNamespaceExports();
|
|
const statements = [];
|
|
let emitFlags = 4 /* AdviseOnEmitNode */;
|
|
const varAdded = addVarForEnumOrModuleDeclaration(statements, node);
|
|
if (varAdded) {
|
|
if (moduleKind !== 4 /* System */ || currentLexicalScope !== currentSourceFile) {
|
|
emitFlags |= 1024 /* NoLeadingComments */;
|
|
}
|
|
}
|
|
const parameterName = getNamespaceParameterName(node);
|
|
const containerName = getNamespaceContainerName(node);
|
|
const exportName = hasSyntacticModifier(node, 1 /* Export */) ? factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true) : factory2.getLocalName(node, false, true);
|
|
let moduleArg = factory2.createLogicalOr(
|
|
exportName,
|
|
factory2.createAssignment(
|
|
exportName,
|
|
factory2.createObjectLiteralExpression()
|
|
)
|
|
);
|
|
if (hasNamespaceQualifiedExportName(node)) {
|
|
const localName = factory2.getLocalName(node, false, true);
|
|
moduleArg = factory2.createAssignment(localName, moduleArg);
|
|
}
|
|
const moduleStatement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
transformModuleBody(node, containerName)
|
|
),
|
|
void 0,
|
|
[moduleArg]
|
|
)
|
|
);
|
|
setOriginalNode(moduleStatement, node);
|
|
if (varAdded) {
|
|
setSyntheticLeadingComments(moduleStatement, void 0);
|
|
setSyntheticTrailingComments(moduleStatement, void 0);
|
|
}
|
|
setTextRange(moduleStatement, node);
|
|
addEmitFlags(moduleStatement, emitFlags);
|
|
statements.push(moduleStatement);
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
return statements;
|
|
}
|
|
function transformModuleBody(node, namespaceLocalName) {
|
|
const savedCurrentNamespaceContainerName = currentNamespaceContainerName;
|
|
const savedCurrentNamespace = currentNamespace;
|
|
const savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName;
|
|
currentNamespaceContainerName = namespaceLocalName;
|
|
currentNamespace = node;
|
|
currentScopeFirstDeclarationsOfName = void 0;
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
let statementsLocation;
|
|
let blockLocation;
|
|
if (node.body) {
|
|
if (node.body.kind === 265 /* ModuleBlock */) {
|
|
saveStateAndInvoke(node.body, (body) => addRange(statements, visitNodes2(body.statements, namespaceElementVisitor, isStatement)));
|
|
statementsLocation = node.body.statements;
|
|
blockLocation = node.body;
|
|
} else {
|
|
const result = visitModuleDeclaration(node.body);
|
|
if (result) {
|
|
if (isArray(result)) {
|
|
addRange(statements, result);
|
|
} else {
|
|
statements.push(result);
|
|
}
|
|
}
|
|
const moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body;
|
|
statementsLocation = moveRangePos(moduleBlock.statements, -1);
|
|
}
|
|
}
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
currentNamespaceContainerName = savedCurrentNamespaceContainerName;
|
|
currentNamespace = savedCurrentNamespace;
|
|
currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName;
|
|
const block = factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(statements),
|
|
statementsLocation
|
|
),
|
|
true
|
|
);
|
|
setTextRange(block, blockLocation);
|
|
if (!node.body || node.body.kind !== 265 /* ModuleBlock */) {
|
|
setEmitFlags(block, getEmitFlags(block) | 3072 /* NoComments */);
|
|
}
|
|
return block;
|
|
}
|
|
function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) {
|
|
if (moduleDeclaration.body.kind === 264 /* ModuleDeclaration */) {
|
|
const recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body);
|
|
return recursiveInnerModule || moduleDeclaration.body;
|
|
}
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
if (!node.importClause) {
|
|
return node;
|
|
}
|
|
if (node.importClause.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
const importClause = visitNode(node.importClause, visitImportClause, isImportClause);
|
|
return importClause || compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */ ? factory2.updateImportDeclaration(
|
|
node,
|
|
void 0,
|
|
importClause,
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
) : void 0;
|
|
}
|
|
function visitImportClause(node) {
|
|
Debug.assert(!node.isTypeOnly);
|
|
const name = shouldEmitAliasDeclaration(node) ? node.name : void 0;
|
|
const namedBindings = visitNode(node.namedBindings, visitNamedImportBindings, isNamedImportBindings);
|
|
return name || namedBindings ? factory2.updateImportClause(node, false, name, namedBindings) : void 0;
|
|
}
|
|
function visitNamedImportBindings(node) {
|
|
if (node.kind === 271 /* NamespaceImport */) {
|
|
return shouldEmitAliasDeclaration(node) ? node : void 0;
|
|
} else {
|
|
const allowEmpty = compilerOptions.preserveValueImports && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */);
|
|
const elements = visitNodes2(node.elements, visitImportSpecifier, isImportSpecifier);
|
|
return allowEmpty || some(elements) ? factory2.updateNamedImports(node, elements) : void 0;
|
|
}
|
|
}
|
|
function visitImportSpecifier(node) {
|
|
return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : void 0;
|
|
}
|
|
function visitExportAssignment(node) {
|
|
return resolver.isValueAliasDeclaration(node) ? visitEachChild(node, visitor, context) : void 0;
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (node.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
if (!node.exportClause || isNamespaceExport(node.exportClause)) {
|
|
return node;
|
|
}
|
|
const allowEmpty = !!node.moduleSpecifier && (compilerOptions.importsNotUsedAsValues === 1 /* Preserve */ || compilerOptions.importsNotUsedAsValues === 2 /* Error */);
|
|
const exportClause = visitNode(
|
|
node.exportClause,
|
|
(bindings) => visitNamedExportBindings(bindings, allowEmpty),
|
|
isNamedExportBindings
|
|
);
|
|
return exportClause ? factory2.updateExportDeclaration(
|
|
node,
|
|
void 0,
|
|
node.isTypeOnly,
|
|
exportClause,
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
) : void 0;
|
|
}
|
|
function visitNamedExports(node, allowEmpty) {
|
|
const elements = visitNodes2(node.elements, visitExportSpecifier, isExportSpecifier);
|
|
return allowEmpty || some(elements) ? factory2.updateNamedExports(node, elements) : void 0;
|
|
}
|
|
function visitNamespaceExports(node) {
|
|
return factory2.updateNamespaceExport(node, visitNode(node.name, visitor, isIdentifier));
|
|
}
|
|
function visitNamedExportBindings(node, allowEmpty) {
|
|
return isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node, allowEmpty);
|
|
}
|
|
function visitExportSpecifier(node) {
|
|
return !node.isTypeOnly && resolver.isValueAliasDeclaration(node) ? node : void 0;
|
|
}
|
|
function shouldEmitImportEqualsDeclaration(node) {
|
|
return shouldEmitAliasDeclaration(node) || !isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
if (node.isTypeOnly) {
|
|
return void 0;
|
|
}
|
|
if (isExternalModuleImportEqualsDeclaration(node)) {
|
|
const isReferenced = shouldEmitAliasDeclaration(node);
|
|
if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1 /* Preserve */) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createImportDeclaration(
|
|
void 0,
|
|
void 0,
|
|
node.moduleReference.expression,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return isReferenced ? visitEachChild(node, visitor, context) : void 0;
|
|
}
|
|
if (!shouldEmitImportEqualsDeclaration(node)) {
|
|
return void 0;
|
|
}
|
|
const moduleReference = createExpressionFromEntityName(factory2, node.moduleReference);
|
|
setEmitFlags(moduleReference, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
|
|
if (isNamedExternalModuleExport(node) || !isExportOfNamespace(node)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
factory2.createVariableDeclarationList([
|
|
setOriginalNode(
|
|
factory2.createVariableDeclaration(
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
moduleReference
|
|
),
|
|
node
|
|
)
|
|
])
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return setOriginalNode(
|
|
createNamespaceExport2(
|
|
node.name,
|
|
moduleReference,
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function isExportOfNamespace(node) {
|
|
return currentNamespace !== void 0 && hasSyntacticModifier(node, 1 /* Export */);
|
|
}
|
|
function isExternalModuleExport(node) {
|
|
return currentNamespace === void 0 && hasSyntacticModifier(node, 1 /* Export */);
|
|
}
|
|
function isNamedExternalModuleExport(node) {
|
|
return isExternalModuleExport(node) && !hasSyntacticModifier(node, 1024 /* Default */);
|
|
}
|
|
function isDefaultExternalModuleExport(node) {
|
|
return isExternalModuleExport(node) && hasSyntacticModifier(node, 1024 /* Default */);
|
|
}
|
|
function addExportMemberAssignment(statements, node) {
|
|
const expression = factory2.createAssignment(
|
|
factory2.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, false, true),
|
|
factory2.getLocalName(node)
|
|
);
|
|
setSourceMapRange(expression, createRange(node.name ? node.name.pos : node.pos, node.end));
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
setSourceMapRange(statement, createRange(-1, node.end));
|
|
statements.push(statement);
|
|
}
|
|
function createNamespaceExport2(exportName, exportValue, location2) {
|
|
return setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.getNamespaceMemberName(currentNamespaceContainerName, exportName, false, true),
|
|
exportValue
|
|
)
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createNamespaceExportExpression(exportName, exportValue, location2) {
|
|
return setTextRange(factory2.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location2);
|
|
}
|
|
function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name) {
|
|
return factory2.getNamespaceMemberName(currentNamespaceContainerName, name, false, true);
|
|
}
|
|
function getNamespaceParameterName(node) {
|
|
const name = factory2.getGeneratedNameForNode(node);
|
|
setSourceMapRange(name, node.name);
|
|
return name;
|
|
}
|
|
function getNamespaceContainerName(node) {
|
|
return factory2.getGeneratedNameForNode(node);
|
|
}
|
|
function enableSubstitutionForNonQualifiedEnumMembers() {
|
|
if ((enabledSubstitutions & 8 /* NonQualifiedEnumMembers */) === 0) {
|
|
enabledSubstitutions |= 8 /* NonQualifiedEnumMembers */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
}
|
|
function enableSubstitutionForNamespaceExports() {
|
|
if ((enabledSubstitutions & 2 /* NamespaceExports */) === 0) {
|
|
enabledSubstitutions |= 2 /* NamespaceExports */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableEmitNotification(264 /* ModuleDeclaration */);
|
|
}
|
|
}
|
|
function isTransformedModuleDeclaration(node) {
|
|
return getOriginalNode(node).kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isTransformedEnumDeclaration(node) {
|
|
return getOriginalNode(node).kind === 263 /* EnumDeclaration */;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
const savedApplicableSubstitutions = applicableSubstitutions;
|
|
const savedCurrentSourceFile = currentSourceFile;
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
}
|
|
if (enabledSubstitutions & 2 /* NamespaceExports */ && isTransformedModuleDeclaration(node)) {
|
|
applicableSubstitutions |= 2 /* NamespaceExports */;
|
|
}
|
|
if (enabledSubstitutions & 8 /* NonQualifiedEnumMembers */ && isTransformedEnumDeclaration(node)) {
|
|
applicableSubstitutions |= 8 /* NonQualifiedEnumMembers */;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
applicableSubstitutions = savedApplicableSubstitutions;
|
|
currentSourceFile = savedCurrentSourceFile;
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
if (enabledSubstitutions & 2 /* NamespaceExports */) {
|
|
const name = node.name;
|
|
const exportedName = trySubstituteNamespaceExportedName(name);
|
|
if (exportedName) {
|
|
if (node.objectAssignmentInitializer) {
|
|
const initializer = factory2.createAssignment(exportedName, node.objectAssignmentInitializer);
|
|
return setTextRange(factory2.createPropertyAssignment(name, initializer), node);
|
|
}
|
|
return setTextRange(factory2.createPropertyAssignment(name, exportedName), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
return trySubstituteNamespaceExportedName(node) || node;
|
|
}
|
|
function trySubstituteNamespaceExportedName(node) {
|
|
if (enabledSubstitutions & applicableSubstitutions && !isGeneratedIdentifier(node) && !isLocalName(node)) {
|
|
const container = resolver.getReferencedExportContainer(node, false);
|
|
if (container && container.kind !== 308 /* SourceFile */) {
|
|
const substitute = applicableSubstitutions & 2 /* NamespaceExports */ && container.kind === 264 /* ModuleDeclaration */ || applicableSubstitutions & 8 /* NonQualifiedEnumMembers */ && container.kind === 263 /* EnumDeclaration */;
|
|
if (substitute) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(factory2.getGeneratedNameForNode(container), node),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
return substituteConstantValue(node);
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
return substituteConstantValue(node);
|
|
}
|
|
function safeMultiLineComment(value) {
|
|
return value.replace(/\*\//g, "*_/");
|
|
}
|
|
function substituteConstantValue(node) {
|
|
const constantValue = tryGetConstEnumValue(node);
|
|
if (constantValue !== void 0) {
|
|
setConstantValue(node, constantValue);
|
|
const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : factory2.createNumericLiteral(constantValue);
|
|
if (!compilerOptions.removeComments) {
|
|
const originalNode = getOriginalNode(node, isAccessExpression);
|
|
addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, ` ${safeMultiLineComment(getTextOfNode(originalNode))} `);
|
|
}
|
|
return substitute;
|
|
}
|
|
return node;
|
|
}
|
|
function tryGetConstEnumValue(node) {
|
|
if (compilerOptions.isolatedModules) {
|
|
return void 0;
|
|
}
|
|
return isPropertyAccessExpression(node) || isElementAccessExpression(node) ? resolver.getConstantValue(node) : void 0;
|
|
}
|
|
function shouldEmitAliasDeclaration(node) {
|
|
return isInJSFile(node) || (compilerOptions.preserveValueImports ? resolver.isValueAliasDeclaration(node) : resolver.isReferencedAliasDeclaration(node));
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/classFields.ts
|
|
var PrivateIdentifierKind2 = /* @__PURE__ */ ((PrivateIdentifierKind3) => {
|
|
PrivateIdentifierKind3["Field"] = "f";
|
|
PrivateIdentifierKind3["Method"] = "m";
|
|
PrivateIdentifierKind3["Accessor"] = "a";
|
|
return PrivateIdentifierKind3;
|
|
})(PrivateIdentifierKind2 || {});
|
|
function transformClassFields(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration,
|
|
endLexicalEnvironment,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
addBlockScopedVariable
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const useDefineForClassFields = getUseDefineForClassFields(compilerOptions);
|
|
const shouldTransformInitializersUsingSet = !useDefineForClassFields;
|
|
const shouldTransformInitializersUsingDefine = useDefineForClassFields && languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformInitializers = shouldTransformInitializersUsingSet || shouldTransformInitializersUsingDefine;
|
|
const shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformAutoAccessors = languageVersion < 99 /* ESNext */;
|
|
const shouldTransformThisInStaticInitializers = languageVersion < 9 /* ES2022 */;
|
|
const shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2 /* ES2015 */;
|
|
const shouldTransformAnything = shouldTransformInitializers || shouldTransformPrivateElementsOrClassStaticBlocks || shouldTransformAutoAccessors;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
let enabledSubstitutions;
|
|
let classAliases;
|
|
let pendingExpressions;
|
|
let pendingStatements;
|
|
const classLexicalEnvironmentStack = [];
|
|
const classLexicalEnvironmentMap = /* @__PURE__ */ new Map();
|
|
let currentClassLexicalEnvironment;
|
|
let currentClassContainer;
|
|
let currentComputedPropertyNameClassLexicalEnvironment;
|
|
let currentStaticPropertyDeclarationOrStaticBlock;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !shouldTransformAnything) {
|
|
return node;
|
|
}
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
if (!(node.transformFlags & 16777216 /* ContainsClassFields */) && !(node.transformFlags & 134234112 /* ContainsLexicalThisOrSuper */)) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 127 /* AccessorKeyword */:
|
|
return shouldTransformAutoAccessors ? void 0 : node;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return visitClassStaticBlockDeclaration(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return visitPrivateIdentifier(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return visitPropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitElementAccessExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, false);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, false);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */: {
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
fallbackVisitor,
|
|
node
|
|
);
|
|
}
|
|
default:
|
|
return fallbackVisitor(node);
|
|
}
|
|
}
|
|
function fallbackVisitor(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
switch (node.kind) {
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, true);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, true);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function heritageClauseVisitor(node) {
|
|
switch (node.kind) {
|
|
case 294 /* HeritageClause */:
|
|
return visitEachChild(node, heritageClauseVisitor, context);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return visitExpressionWithTypeArgumentsInHeritageClause(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function assignmentTargetVisitor(node) {
|
|
switch (node.kind) {
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitAssignmentPattern(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function classElementVisitor(node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
return visitConstructorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
visitMethodOrAccessorDeclaration,
|
|
node
|
|
);
|
|
case 169 /* PropertyDeclaration */:
|
|
return setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
void 0,
|
|
visitPropertyDeclaration,
|
|
node
|
|
);
|
|
case 164 /* ComputedPropertyName */:
|
|
return visitComputedPropertyName(node);
|
|
case 237 /* SemicolonClassElement */:
|
|
return node;
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function accessorFieldResultVisitor(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
return transformFieldInitializer(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return classElementVisitor(node);
|
|
default:
|
|
Debug.assertMissingNode(node, "Expected node to either be a PropertyDeclaration, GetAccessorDeclaration, or SetAccessorDeclaration");
|
|
break;
|
|
}
|
|
}
|
|
function visitPrivateIdentifier(node) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
return node;
|
|
}
|
|
if (isStatement(node.parent)) {
|
|
return node;
|
|
}
|
|
return setOriginalNode(factory2.createIdentifier(""), node);
|
|
}
|
|
function isPrivateIdentifierInExpression(node) {
|
|
return isPrivateIdentifier(node.left) && node.operatorToken.kind === 101 /* InKeyword */;
|
|
}
|
|
function transformPrivateIdentifierInInExpression(node) {
|
|
const info = accessPrivateIdentifier(node.left);
|
|
if (info) {
|
|
const receiver = visitNode(node.right, visitor, isExpression);
|
|
return setOriginalNode(
|
|
context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
const savedPendingStatements = pendingStatements;
|
|
pendingStatements = [];
|
|
const visitedNode = visitEachChild(node, visitor, context);
|
|
const statement = some(pendingStatements) ? [visitedNode, ...pendingStatements] : visitedNode;
|
|
pendingStatements = savedPendingStatements;
|
|
return statement;
|
|
}
|
|
function visitComputedPropertyName(node) {
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
if (some(pendingExpressions)) {
|
|
if (isParenthesizedExpression(expression)) {
|
|
expression = factory2.updateParenthesizedExpression(expression, factory2.inlineExpressions([...pendingExpressions, expression.expression]));
|
|
} else {
|
|
expression = factory2.inlineExpressions([...pendingExpressions, expression]);
|
|
}
|
|
pendingExpressions = void 0;
|
|
}
|
|
return factory2.updateComputedPropertyName(node, expression);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
if (currentClassContainer) {
|
|
return transformConstructor(node, currentClassContainer);
|
|
}
|
|
return fallbackVisitor(node);
|
|
}
|
|
function visitMethodOrAccessorDeclaration(node) {
|
|
Debug.assert(!hasDecorators(node));
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks || !isPrivateIdentifier(node.name)) {
|
|
return visitEachChild(node, classElementVisitor, context);
|
|
}
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
if (!info.isValid) {
|
|
return node;
|
|
}
|
|
const functionName = getHoistedFunctionName(node);
|
|
if (functionName) {
|
|
getPendingExpressions().push(
|
|
factory2.createAssignment(
|
|
functionName,
|
|
factory2.createFunctionExpression(
|
|
filter(node.modifiers, (m) => isModifier(m) && !isStaticModifier(m) && !isAccessorModifier(m)),
|
|
node.asteriskToken,
|
|
functionName,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
visitFunctionBody(node.body, visitor, context)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
return void 0;
|
|
}
|
|
function setCurrentStaticPropertyDeclarationOrStaticBlockAnd(current, visitor2, arg) {
|
|
const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock;
|
|
currentStaticPropertyDeclarationOrStaticBlock = current;
|
|
const result = visitor2(arg);
|
|
currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock;
|
|
return result;
|
|
}
|
|
function getHoistedFunctionName(node) {
|
|
Debug.assert(isPrivateIdentifier(node.name));
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
if (info.kind === "m" /* Method */) {
|
|
return info.methodName;
|
|
}
|
|
if (info.kind === "a" /* Accessor */) {
|
|
if (isGetAccessor(node)) {
|
|
return info.getterName;
|
|
}
|
|
if (isSetAccessor(node)) {
|
|
return info.setterName;
|
|
}
|
|
}
|
|
}
|
|
function transformAutoAccessor(node) {
|
|
Debug.assertEachNode(node.modifiers, isModifier);
|
|
const commentRange = getCommentRange(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
const name = node.name;
|
|
let getterName = name;
|
|
let setterName = name;
|
|
if (isComputedPropertyName(name) && !isSimpleInlineableExpression(name.expression)) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setSourceMapRange(temp, name.expression);
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const assignment = factory2.createAssignment(temp, expression);
|
|
setSourceMapRange(assignment, name.expression);
|
|
getterName = factory2.updateComputedPropertyName(name, factory2.inlineExpressions([assignment, temp]));
|
|
setterName = factory2.updateComputedPropertyName(name, temp);
|
|
}
|
|
const backingField = createAccessorPropertyBackingField(factory2, node, node.modifiers, node.initializer);
|
|
setOriginalNode(backingField, node);
|
|
setEmitFlags(backingField, 3072 /* NoComments */);
|
|
setSourceMapRange(backingField, sourceMapRange);
|
|
const getter = createAccessorPropertyGetRedirector(factory2, node, node.modifiers, getterName);
|
|
setOriginalNode(getter, node);
|
|
setCommentRange(getter, commentRange);
|
|
setSourceMapRange(getter, sourceMapRange);
|
|
const setter = createAccessorPropertySetRedirector(factory2, node, node.modifiers, setterName);
|
|
setOriginalNode(setter, node);
|
|
setEmitFlags(setter, 3072 /* NoComments */);
|
|
setSourceMapRange(setter, sourceMapRange);
|
|
return visitArray([backingField, getter, setter], accessorFieldResultVisitor, isClassElement);
|
|
}
|
|
function transformPrivateFieldInitializer(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const info = accessPrivateIdentifier(node.name);
|
|
Debug.assert(info, "Undeclared private name for property declaration.");
|
|
return info.isValid ? void 0 : node;
|
|
}
|
|
if (shouldTransformInitializersUsingSet && !isStatic(node)) {
|
|
return factory2.updatePropertyDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformPublicFieldInitializer(node) {
|
|
if (shouldTransformInitializers) {
|
|
const expr = getPropertyNameExpressionIfNeeded(node.name, !!node.initializer || useDefineForClassFields);
|
|
if (expr) {
|
|
getPendingExpressions().push(expr);
|
|
}
|
|
if (isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const initializerStatement = transformPropertyOrClassStaticBlock(node, factory2.createThis());
|
|
if (initializerStatement) {
|
|
const staticBlock = factory2.createClassStaticBlockDeclaration(
|
|
factory2.createBlock([initializerStatement])
|
|
);
|
|
setOriginalNode(staticBlock, node);
|
|
setCommentRange(staticBlock, node);
|
|
setCommentRange(initializerStatement, { pos: -1, end: -1 });
|
|
setSyntheticLeadingComments(initializerStatement, void 0);
|
|
setSyntheticTrailingComments(initializerStatement, void 0);
|
|
return staticBlock;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
return visitEachChild(node, classElementVisitor, context);
|
|
}
|
|
function transformFieldInitializer(node) {
|
|
Debug.assert(!hasDecorators(node), "Decorators should already have been transformed and elided.");
|
|
return isPrivateIdentifierClassElementDeclaration(node) ? transformPrivateFieldInitializer(node) : transformPublicFieldInitializer(node);
|
|
}
|
|
function visitPropertyDeclaration(node) {
|
|
if (shouldTransformAutoAccessors && isAutoAccessorPropertyDeclaration(node)) {
|
|
return transformAutoAccessor(node);
|
|
}
|
|
return transformFieldInitializer(node);
|
|
}
|
|
function createPrivateIdentifierAccess(info, receiver) {
|
|
return createPrivateIdentifierAccessHelper(info, visitNode(receiver, visitor, isExpression));
|
|
}
|
|
function createPrivateIdentifierAccessHelper(info, receiver) {
|
|
setCommentRange(receiver, moveRangePos(receiver, -1));
|
|
switch (info.kind) {
|
|
case "a" /* Accessor */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.getterName
|
|
);
|
|
case "m" /* Method */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.methodName
|
|
);
|
|
case "f" /* Field */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
info.kind,
|
|
info.variableName
|
|
);
|
|
default:
|
|
Debug.assertNever(info, "Unknown private element type");
|
|
}
|
|
}
|
|
function visitPropertyAccessExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifier(node.name)) {
|
|
const privateIdentifierInfo = accessPrivateIdentifier(node.name);
|
|
if (privateIdentifierInfo) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
createPrivateIdentifierAccess(privateIdentifierInfo, node.expression),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node) && isIdentifier(node.name) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return visitInvalidSuperProperty(node);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
const superProperty = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
factory2.createStringLiteralFromNode(node.name),
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superProperty, node.expression);
|
|
setTextRange(superProperty, node.expression);
|
|
return superProperty;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitElementAccessExpression(node) {
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return visitInvalidSuperProperty(node);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
const superProperty = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
visitNode(node.argumentExpression, visitor, isExpression),
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superProperty, node.expression);
|
|
setTextRange(superProperty, node.expression);
|
|
return superProperty;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if (node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) {
|
|
const operand = skipParentheses(node.operand);
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(operand)) {
|
|
let info;
|
|
if (info = accessPrivateIdentifier(operand.name)) {
|
|
const receiver = visitNode(operand.expression, visitor, isExpression);
|
|
const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver);
|
|
let expression = createPrivateIdentifierAccess(info, readExpression);
|
|
const temp = isPrefixUnaryExpression(node) || valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, hoistVariableDeclaration, temp);
|
|
expression = createPrivateIdentifierAssignment(
|
|
info,
|
|
initializeExpression || readExpression,
|
|
expression,
|
|
63 /* EqualsToken */
|
|
);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(operand) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
const expression = visitInvalidSuperProperty(operand);
|
|
return isPrefixUnaryExpression(node) ? factory2.updatePrefixUnaryExpression(node, expression) : factory2.updatePostfixUnaryExpression(node, expression);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
let setterName;
|
|
let getterName;
|
|
if (isPropertyAccessExpression(operand)) {
|
|
if (isIdentifier(operand.name)) {
|
|
getterName = setterName = factory2.createStringLiteralFromNode(operand.name);
|
|
}
|
|
} else {
|
|
if (isSimpleInlineableExpression(operand.argumentExpression)) {
|
|
getterName = setterName = operand.argumentExpression;
|
|
} else {
|
|
getterName = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setterName = factory2.createAssignment(getterName, visitNode(operand.argumentExpression, visitor, isExpression));
|
|
}
|
|
}
|
|
if (setterName && getterName) {
|
|
let expression = factory2.createReflectGetCall(superClassReference, getterName, classConstructor);
|
|
setTextRange(expression, operand);
|
|
const temp = valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = expandPreOrPostfixIncrementOrDecrementExpression(factory2, node, expression, hoistVariableDeclaration, temp);
|
|
expression = factory2.createReflectSetCall(superClassReference, setterName, expression, classConstructor);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(
|
|
node,
|
|
visitNode(node.expression, discardedValueVisitor, isExpression)
|
|
);
|
|
}
|
|
function createCopiableReceiverExpr(receiver) {
|
|
const clone2 = nodeIsSynthesized(receiver) ? receiver : factory2.cloneNode(receiver);
|
|
if (isSimpleInlineableExpression(receiver)) {
|
|
return { readExpression: clone2, initializeExpression: void 0 };
|
|
}
|
|
const readExpression = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const initializeExpression = factory2.createAssignment(readExpression, clone2);
|
|
return { readExpression, initializeExpression };
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.expression)) {
|
|
const { thisArg, target } = factory2.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion);
|
|
if (isCallChain(node)) {
|
|
return factory2.updateCallChain(
|
|
node,
|
|
factory2.createPropertyAccessChain(visitNode(target, visitor), node.questionDotToken, "call"),
|
|
void 0,
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression), ...visitNodes2(node.arguments, visitor, isExpression)]
|
|
);
|
|
}
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
factory2.createPropertyAccessExpression(visitNode(target, visitor), "call"),
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression), ...visitNodes2(node.arguments, visitor, isExpression)]
|
|
);
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.expression) && currentStaticPropertyDeclarationOrStaticBlock && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.classConstructor)) {
|
|
const invocation = factory2.createFunctionCallCall(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
currentClassLexicalEnvironment.classConstructor,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
setOriginalNode(invocation, node);
|
|
setTextRange(invocation, node);
|
|
return invocation;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.tag)) {
|
|
const { thisArg, target } = factory2.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion);
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(visitNode(target, visitor), "bind"),
|
|
void 0,
|
|
[visitNode(thisArg, visitor, isExpression)]
|
|
),
|
|
void 0,
|
|
visitNode(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.tag) && currentStaticPropertyDeclarationOrStaticBlock && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.classConstructor)) {
|
|
const invocation = factory2.createFunctionBindCall(
|
|
visitNode(node.tag, visitor, isExpression),
|
|
currentClassLexicalEnvironment.classConstructor,
|
|
[]
|
|
);
|
|
setOriginalNode(invocation, node);
|
|
setTextRange(invocation, node);
|
|
return factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
invocation,
|
|
void 0,
|
|
visitNode(node.template, visitor, isTemplateLiteral)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformClassStaticBlockDeclaration(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
if (currentClassLexicalEnvironment) {
|
|
classLexicalEnvironmentMap.set(getOriginalNodeId(node), currentClassLexicalEnvironment);
|
|
}
|
|
startLexicalEnvironment();
|
|
let statements = setCurrentStaticPropertyDeclarationOrStaticBlockAnd(
|
|
node,
|
|
(statements2) => visitNodes2(statements2, visitor, isStatement),
|
|
node.body.statements
|
|
);
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
const iife = factory2.createImmediatelyInvokedArrowFunction(statements);
|
|
setOriginalNode(iife, node);
|
|
setTextRange(iife, node);
|
|
addEmitFlags(iife, 4 /* AdviseOnEmitNode */);
|
|
return iife;
|
|
}
|
|
}
|
|
function visitBinaryExpression(node, valueIsDiscarded) {
|
|
if (isDestructuringAssignment(node)) {
|
|
const savedPendingExpressions = pendingExpressions;
|
|
pendingExpressions = void 0;
|
|
node = factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, assignmentTargetVisitor),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor)
|
|
);
|
|
const expr = some(pendingExpressions) ? factory2.inlineExpressions(compact([...pendingExpressions, node])) : node;
|
|
pendingExpressions = savedPendingExpressions;
|
|
return expr;
|
|
}
|
|
if (isAssignmentExpression(node)) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierPropertyAccessExpression(node.left)) {
|
|
const info = accessPrivateIdentifier(node.left.name);
|
|
if (info) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
createPrivateIdentifierAssignment(info, node.left.expression, node.right, node.operatorToken.kind),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(node.left) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitInvalidSuperProperty(node.left),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
}
|
|
if (classConstructor && superClassReference) {
|
|
let setterName = isElementAccessExpression(node.left) ? visitNode(node.left.argumentExpression, visitor, isExpression) : isIdentifier(node.left.name) ? factory2.createStringLiteralFromNode(node.left.name) : void 0;
|
|
if (setterName) {
|
|
let expression = visitNode(node.right, visitor, isExpression);
|
|
if (isCompoundAssignment(node.operatorToken.kind)) {
|
|
let getterName = setterName;
|
|
if (!isSimpleInlineableExpression(setterName)) {
|
|
getterName = factory2.createTempVariable(hoistVariableDeclaration);
|
|
setterName = factory2.createAssignment(getterName, setterName);
|
|
}
|
|
const superPropertyGet = factory2.createReflectGetCall(
|
|
superClassReference,
|
|
getterName,
|
|
classConstructor
|
|
);
|
|
setOriginalNode(superPropertyGet, node.left);
|
|
setTextRange(superPropertyGet, node.left);
|
|
expression = factory2.createBinaryExpression(
|
|
superPropertyGet,
|
|
getNonAssignmentOperatorForCompoundAssignment(node.operatorToken.kind),
|
|
expression
|
|
);
|
|
setTextRange(expression, node);
|
|
}
|
|
const temp = valueIsDiscarded ? void 0 : factory2.createTempVariable(hoistVariableDeclaration);
|
|
if (temp) {
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(temp, node);
|
|
}
|
|
expression = factory2.createReflectSetCall(
|
|
superClassReference,
|
|
setterName,
|
|
expression,
|
|
classConstructor
|
|
);
|
|
setOriginalNode(expression, node);
|
|
setTextRange(expression, node);
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierInExpression(node)) {
|
|
return transformPrivateIdentifierInInExpression(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function createPrivateIdentifierAssignment(info, receiver, right, operator) {
|
|
receiver = visitNode(receiver, visitor, isExpression);
|
|
right = visitNode(right, visitor, isExpression);
|
|
if (isCompoundAssignment(operator)) {
|
|
const { readExpression, initializeExpression } = createCopiableReceiverExpr(receiver);
|
|
receiver = initializeExpression || readExpression;
|
|
right = factory2.createBinaryExpression(
|
|
createPrivateIdentifierAccessHelper(info, readExpression),
|
|
getNonAssignmentOperatorForCompoundAssignment(operator),
|
|
right
|
|
);
|
|
}
|
|
setCommentRange(receiver, moveRangePos(receiver, -1));
|
|
switch (info.kind) {
|
|
case "a" /* Accessor */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
info.setterName
|
|
);
|
|
case "m" /* Method */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
void 0
|
|
);
|
|
case "f" /* Field */:
|
|
return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(
|
|
receiver,
|
|
info.brandCheckIdentifier,
|
|
right,
|
|
info.kind,
|
|
info.variableName
|
|
);
|
|
default:
|
|
Debug.assertNever(info, "Unknown private element type");
|
|
}
|
|
}
|
|
function getPrivateInstanceMethodsAndAccessors(node) {
|
|
return filter(node.members, isNonStaticMethodOrAccessorWithPrivateName);
|
|
}
|
|
function getClassFacts(node) {
|
|
let facts = 0 /* None */;
|
|
const original = getOriginalNode(node);
|
|
if (isClassDeclaration(original) && classOrConstructorParameterIsDecorated(original)) {
|
|
facts |= 1 /* ClassWasDecorated */;
|
|
}
|
|
for (const member of node.members) {
|
|
if (!isStatic(member))
|
|
continue;
|
|
if (member.name && (isPrivateIdentifier(member.name) || isAutoAccessorPropertyDeclaration(member)) && shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
facts |= 2 /* NeedsClassConstructorReference */;
|
|
}
|
|
if (isPropertyDeclaration(member) || isClassStaticBlockDeclaration(member)) {
|
|
if (shouldTransformThisInStaticInitializers && member.transformFlags & 16384 /* ContainsLexicalThis */) {
|
|
facts |= 8 /* NeedsSubstitutionForThisInClassStaticField */;
|
|
if (!(facts & 1 /* ClassWasDecorated */)) {
|
|
facts |= 2 /* NeedsClassConstructorReference */;
|
|
}
|
|
}
|
|
if (shouldTransformSuperInStaticInitializers && member.transformFlags & 134217728 /* ContainsLexicalSuper */) {
|
|
if (!(facts & 1 /* ClassWasDecorated */)) {
|
|
facts |= 2 /* NeedsClassConstructorReference */ | 4 /* NeedsClassSuperReference */;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return facts;
|
|
}
|
|
function visitExpressionWithTypeArgumentsInHeritageClause(node) {
|
|
const facts = (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.facts) || 0 /* None */;
|
|
if (facts & 4 /* NeedsClassSuperReference */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getClassLexicalEnvironment().superClassReference = temp;
|
|
return factory2.updateExpressionWithTypeArguments(
|
|
node,
|
|
factory2.createAssignment(
|
|
temp,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
),
|
|
void 0
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitInNewClassLexicalEnvironment(node, visitor2) {
|
|
const savedCurrentClassContainer = currentClassContainer;
|
|
const savedPendingExpressions = pendingExpressions;
|
|
currentClassContainer = node;
|
|
pendingExpressions = void 0;
|
|
startClassLexicalEnvironment();
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const name = getNameOfDeclaration(node);
|
|
if (name && isIdentifier(name)) {
|
|
getPrivateIdentifierEnvironment().className = name;
|
|
}
|
|
const privateInstanceMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
|
|
if (some(privateInstanceMethodsAndAccessors)) {
|
|
getPrivateIdentifierEnvironment().weakSetName = createHoistedVariableForClass(
|
|
"instances",
|
|
privateInstanceMethodsAndAccessors[0].name
|
|
);
|
|
}
|
|
}
|
|
const facts = getClassFacts(node);
|
|
if (facts) {
|
|
getClassLexicalEnvironment().facts = facts;
|
|
}
|
|
if (facts & 8 /* NeedsSubstitutionForThisInClassStaticField */) {
|
|
enableSubstitutionForClassStaticThisOrSuperReference();
|
|
}
|
|
const result = visitor2(node, facts);
|
|
endClassLexicalEnvironment();
|
|
currentClassContainer = savedCurrentClassContainer;
|
|
pendingExpressions = savedPendingExpressions;
|
|
return result;
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
return visitInNewClassLexicalEnvironment(node, visitClassDeclarationInNewClassLexicalEnvironment);
|
|
}
|
|
function visitClassDeclarationInNewClassLexicalEnvironment(node, facts) {
|
|
let pendingClassReferenceAssignment;
|
|
if (facts & 2 /* NeedsClassConstructorReference */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getClassLexicalEnvironment().classConstructor = factory2.cloneNode(temp);
|
|
pendingClassReferenceAssignment = factory2.createAssignment(temp, factory2.getInternalName(node));
|
|
}
|
|
const modifiers = visitNodes2(node.modifiers, visitor, isModifierLike);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
|
|
const { members, prologue } = transformClassMembers(node);
|
|
const classDecl = factory2.updateClassDeclaration(
|
|
node,
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
const statements = [];
|
|
if (prologue) {
|
|
statements.push(factory2.createExpressionStatement(prologue));
|
|
}
|
|
statements.push(classDecl);
|
|
if (pendingClassReferenceAssignment) {
|
|
getPendingExpressions().unshift(pendingClassReferenceAssignment);
|
|
}
|
|
if (some(pendingExpressions)) {
|
|
statements.push(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
}
|
|
if (shouldTransformInitializersUsingSet || shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
const staticProperties = getStaticPropertiesAndClassStaticBlock(node);
|
|
if (some(staticProperties)) {
|
|
addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory2.getInternalName(node));
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function visitClassExpression(node) {
|
|
return visitInNewClassLexicalEnvironment(node, visitClassExpressionInNewClassLexicalEnvironment);
|
|
}
|
|
function visitClassExpressionInNewClassLexicalEnvironment(node, facts) {
|
|
const isDecoratedClassDeclaration = !!(facts & 1 /* ClassWasDecorated */);
|
|
const staticPropertiesOrClassStaticBlocks = getStaticPropertiesAndClassStaticBlock(node);
|
|
const isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */;
|
|
let temp;
|
|
function createClassTempVar() {
|
|
const classCheckFlags = resolver.getNodeCheckFlags(node);
|
|
const isClassWithConstructorReference2 = classCheckFlags & 1048576 /* ClassWithConstructorReference */;
|
|
const requiresBlockScopedVar = classCheckFlags & 32768 /* BlockScopedBindingInLoop */;
|
|
return factory2.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference2);
|
|
}
|
|
if (facts & 2 /* NeedsClassConstructorReference */) {
|
|
temp = createClassTempVar();
|
|
getClassLexicalEnvironment().classConstructor = factory2.cloneNode(temp);
|
|
}
|
|
const modifiers = visitNodes2(node.modifiers, visitor, isModifierLike);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, heritageClauseVisitor, isHeritageClause);
|
|
const { members, prologue } = transformClassMembers(node);
|
|
const classExpression = factory2.updateClassExpression(
|
|
node,
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
const expressions = [];
|
|
if (prologue) {
|
|
expressions.push(prologue);
|
|
}
|
|
const hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && some(staticPropertiesOrClassStaticBlocks, (node2) => isClassStaticBlockDeclaration(node2) || isPrivateIdentifierClassElementDeclaration(node2) || shouldTransformInitializers && isInitializedProperty(node2));
|
|
if (hasTransformableStatics || some(pendingExpressions)) {
|
|
if (isDecoratedClassDeclaration) {
|
|
Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
|
|
if (pendingStatements && pendingExpressions && some(pendingExpressions)) {
|
|
pendingStatements.push(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
}
|
|
if (pendingStatements && some(staticPropertiesOrClassStaticBlocks)) {
|
|
addPropertyOrClassStaticBlockStatements(pendingStatements, staticPropertiesOrClassStaticBlocks, factory2.getInternalName(node));
|
|
}
|
|
if (temp) {
|
|
expressions.push(
|
|
startOnNewLine(factory2.createAssignment(temp, classExpression)),
|
|
startOnNewLine(temp)
|
|
);
|
|
} else {
|
|
expressions.push(classExpression);
|
|
if (prologue) {
|
|
startOnNewLine(classExpression);
|
|
}
|
|
}
|
|
} else {
|
|
temp || (temp = createClassTempVar());
|
|
if (isClassWithConstructorReference) {
|
|
enableSubstitutionForClassAliases();
|
|
const alias = factory2.cloneNode(temp);
|
|
alias.autoGenerateFlags &= ~8 /* ReservedInNestedScopes */;
|
|
classAliases[getOriginalNodeId(node)] = alias;
|
|
}
|
|
setEmitFlags(classExpression, 131072 /* Indented */ | getEmitFlags(classExpression));
|
|
expressions.push(startOnNewLine(factory2.createAssignment(temp, classExpression)));
|
|
addRange(expressions, map(pendingExpressions, startOnNewLine));
|
|
addRange(expressions, generateInitializedPropertyExpressionsOrClassStaticBlock(staticPropertiesOrClassStaticBlocks, temp));
|
|
expressions.push(startOnNewLine(temp));
|
|
}
|
|
} else {
|
|
expressions.push(classExpression);
|
|
if (prologue) {
|
|
startOnNewLine(classExpression);
|
|
}
|
|
}
|
|
return factory2.inlineExpressions(expressions);
|
|
}
|
|
function visitClassStaticBlockDeclaration(node) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformClassMembers(node) {
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks) {
|
|
for (const member of node.members) {
|
|
if (isPrivateIdentifierClassElementDeclaration(member)) {
|
|
addPrivateIdentifierToEnvironment(member, member.name, addPrivateIdentifierClassElementToEnvironment);
|
|
}
|
|
}
|
|
if (some(getPrivateInstanceMethodsAndAccessors(node))) {
|
|
createBrandCheckWeakSetForPrivateMethods();
|
|
}
|
|
if (shouldTransformAutoAccessors) {
|
|
for (const member of node.members) {
|
|
if (isAutoAccessorPropertyDeclaration(member)) {
|
|
const storageName = factory2.getGeneratedPrivateNameForNode(member.name, void 0, "_accessor_storage");
|
|
addPrivateIdentifierToEnvironment(member, storageName, addPrivateIdentifierPropertyDeclarationToEnvironment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let members = visitNodes2(node.members, classElementVisitor, isClassElement);
|
|
let syntheticConstructor;
|
|
if (!some(members, isConstructorDeclaration)) {
|
|
syntheticConstructor = transformConstructor(void 0, node);
|
|
}
|
|
let prologue;
|
|
let syntheticStaticBlock;
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks && some(pendingExpressions)) {
|
|
let statement = factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions));
|
|
if (statement.transformFlags & 134234112 /* ContainsLexicalThisOrSuper */) {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const arrow = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
void 0,
|
|
factory2.createBlock([statement])
|
|
);
|
|
prologue = factory2.createAssignment(temp, arrow);
|
|
statement = factory2.createExpressionStatement(factory2.createCallExpression(temp, void 0, []));
|
|
}
|
|
const block = factory2.createBlock([statement]);
|
|
syntheticStaticBlock = factory2.createClassStaticBlockDeclaration(block);
|
|
pendingExpressions = void 0;
|
|
}
|
|
if (syntheticConstructor || syntheticStaticBlock) {
|
|
let membersArray;
|
|
membersArray = append(membersArray, syntheticConstructor);
|
|
membersArray = append(membersArray, syntheticStaticBlock);
|
|
membersArray = addRange(membersArray, members);
|
|
members = setTextRange(factory2.createNodeArray(membersArray), node.members);
|
|
}
|
|
return { members, prologue };
|
|
}
|
|
function createBrandCheckWeakSetForPrivateMethods() {
|
|
const { weakSetName } = getPrivateIdentifierEnvironment();
|
|
Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
|
|
getPendingExpressions().push(
|
|
factory2.createAssignment(
|
|
weakSetName,
|
|
factory2.createNewExpression(
|
|
factory2.createIdentifier("WeakSet"),
|
|
void 0,
|
|
[]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function isClassElementThatRequiresConstructorStatement(member) {
|
|
if (isStatic(member) || hasAbstractModifier(getOriginalNode(member))) {
|
|
return false;
|
|
}
|
|
return shouldTransformInitializersUsingDefine && isPropertyDeclaration(member) || shouldTransformInitializersUsingSet && isInitializedProperty(member) || shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierClassElementDeclaration(member) || shouldTransformPrivateElementsOrClassStaticBlocks && shouldTransformAutoAccessors && isAutoAccessorPropertyDeclaration(member);
|
|
}
|
|
function transformConstructor(constructor, container) {
|
|
constructor = visitNode(constructor, visitor, isConstructorDeclaration);
|
|
if (!some(container.members, isClassElementThatRequiresConstructorStatement)) {
|
|
return constructor;
|
|
}
|
|
const extendsClauseElement = getEffectiveBaseTypeNode(container);
|
|
const isDerivedClass = !!(extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */);
|
|
const parameters = visitParameterList(constructor ? constructor.parameters : void 0, visitor, context);
|
|
const body = transformConstructorBody(container, constructor, isDerivedClass);
|
|
if (!body) {
|
|
return constructor;
|
|
}
|
|
if (constructor) {
|
|
Debug.assert(parameters);
|
|
return factory2.updateConstructorDeclaration(constructor, void 0, parameters, body);
|
|
}
|
|
return startOnNewLine(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createConstructorDeclaration(
|
|
void 0,
|
|
parameters != null ? parameters : [],
|
|
body
|
|
),
|
|
constructor || container
|
|
),
|
|
constructor
|
|
)
|
|
);
|
|
}
|
|
function transformConstructorBody(node, constructor, isDerivedClass) {
|
|
var _a2, _b;
|
|
let properties = getProperties(node, false, false);
|
|
if (!useDefineForClassFields) {
|
|
properties = filter(properties, (property) => !!property.initializer || isPrivateIdentifier(property.name) || hasAccessorModifier(property));
|
|
}
|
|
const privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node);
|
|
const needsConstructorBody = some(properties) || some(privateMethodsAndAccessors);
|
|
if (!constructor && !needsConstructorBody) {
|
|
return visitFunctionBody(void 0, visitor, context);
|
|
}
|
|
resumeLexicalEnvironment();
|
|
const needsSyntheticConstructor = !constructor && isDerivedClass;
|
|
let indexOfFirstStatementAfterSuperAndPrologue = 0;
|
|
let prologueStatementCount = 0;
|
|
let superStatementIndex = -1;
|
|
let statements = [];
|
|
if ((_a2 = constructor == null ? void 0 : constructor.body) == null ? void 0 : _a2.statements) {
|
|
prologueStatementCount = factory2.copyPrologue(constructor.body.statements, statements, false, visitor);
|
|
superStatementIndex = findSuperStatementIndex(constructor.body.statements, prologueStatementCount);
|
|
if (superStatementIndex >= 0) {
|
|
indexOfFirstStatementAfterSuperAndPrologue = superStatementIndex + 1;
|
|
statements = [
|
|
...statements.slice(0, prologueStatementCount),
|
|
...visitNodes2(constructor.body.statements, visitor, isStatement, prologueStatementCount, indexOfFirstStatementAfterSuperAndPrologue - prologueStatementCount),
|
|
...statements.slice(prologueStatementCount)
|
|
];
|
|
} else if (prologueStatementCount >= 0) {
|
|
indexOfFirstStatementAfterSuperAndPrologue = prologueStatementCount;
|
|
}
|
|
}
|
|
if (needsSyntheticConstructor) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createSuper(),
|
|
void 0,
|
|
[factory2.createSpreadElement(factory2.createIdentifier("arguments"))]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
let parameterPropertyDeclarationCount = 0;
|
|
if (constructor == null ? void 0 : constructor.body) {
|
|
if (useDefineForClassFields) {
|
|
statements = statements.filter((statement) => !isParameterPropertyDeclaration(getOriginalNode(statement), constructor));
|
|
} else {
|
|
for (const statement of constructor.body.statements) {
|
|
if (isParameterPropertyDeclaration(getOriginalNode(statement), constructor)) {
|
|
parameterPropertyDeclarationCount++;
|
|
}
|
|
}
|
|
if (parameterPropertyDeclarationCount > 0) {
|
|
const parameterProperties = visitNodes2(constructor.body.statements, visitor, isStatement, indexOfFirstStatementAfterSuperAndPrologue, parameterPropertyDeclarationCount);
|
|
if (superStatementIndex >= 0) {
|
|
addRange(statements, parameterProperties);
|
|
} else {
|
|
let superAndPrologueStatementCount = prologueStatementCount;
|
|
if (needsSyntheticConstructor)
|
|
superAndPrologueStatementCount++;
|
|
statements = [
|
|
...statements.slice(0, superAndPrologueStatementCount),
|
|
...parameterProperties,
|
|
...statements.slice(superAndPrologueStatementCount)
|
|
];
|
|
}
|
|
indexOfFirstStatementAfterSuperAndPrologue += parameterPropertyDeclarationCount;
|
|
}
|
|
}
|
|
}
|
|
const receiver = factory2.createThis();
|
|
addMethodStatements(statements, privateMethodsAndAccessors, receiver);
|
|
addPropertyOrClassStaticBlockStatements(statements, properties, receiver);
|
|
if (constructor) {
|
|
addRange(statements, visitNodes2(constructor.body.statements, visitBodyStatement, isStatement, indexOfFirstStatementAfterSuperAndPrologue));
|
|
}
|
|
statements = factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
if (statements.length === 0 && !constructor) {
|
|
return void 0;
|
|
}
|
|
const multiLine = (constructor == null ? void 0 : constructor.body) && constructor.body.statements.length >= statements.length ? (_b = constructor.body.multiLine) != null ? _b : statements.length > 0 : statements.length > 0;
|
|
return setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(statements),
|
|
constructor ? constructor.body.statements : node.members
|
|
),
|
|
multiLine
|
|
),
|
|
constructor ? constructor.body : void 0
|
|
);
|
|
function visitBodyStatement(statement) {
|
|
if (useDefineForClassFields && isParameterPropertyDeclaration(getOriginalNode(statement), constructor)) {
|
|
return void 0;
|
|
}
|
|
return visitor(statement);
|
|
}
|
|
}
|
|
function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
|
|
for (const property of properties) {
|
|
if (isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
|
|
continue;
|
|
}
|
|
const statement = transformPropertyOrClassStaticBlock(property, receiver);
|
|
if (!statement) {
|
|
continue;
|
|
}
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
function transformPropertyOrClassStaticBlock(property, receiver) {
|
|
const expression = isClassStaticBlockDeclaration(property) ? transformClassStaticBlockDeclaration(property) : transformProperty(property, receiver);
|
|
if (!expression) {
|
|
return void 0;
|
|
}
|
|
const statement = factory2.createExpressionStatement(expression);
|
|
setOriginalNode(statement, property);
|
|
addEmitFlags(statement, getEmitFlags(property) & 3072 /* NoComments */);
|
|
setSourceMapRange(statement, moveRangePastModifiers(property));
|
|
setCommentRange(statement, property);
|
|
setSyntheticLeadingComments(expression, void 0);
|
|
setSyntheticTrailingComments(expression, void 0);
|
|
return statement;
|
|
}
|
|
function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) {
|
|
const expressions = [];
|
|
for (const property of propertiesOrClassStaticBlocks) {
|
|
const expression = isClassStaticBlockDeclaration(property) ? transformClassStaticBlockDeclaration(property) : transformProperty(property, receiver);
|
|
if (!expression) {
|
|
continue;
|
|
}
|
|
startOnNewLine(expression);
|
|
setOriginalNode(expression, property);
|
|
addEmitFlags(expression, getEmitFlags(property) & 3072 /* NoComments */);
|
|
setSourceMapRange(expression, moveRangePastModifiers(property));
|
|
setCommentRange(expression, property);
|
|
expressions.push(expression);
|
|
}
|
|
return expressions;
|
|
}
|
|
function transformProperty(property, receiver) {
|
|
const savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock;
|
|
const transformed = transformPropertyWorker(property, receiver);
|
|
if (transformed && hasStaticModifier(property) && (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.facts)) {
|
|
setOriginalNode(transformed, property);
|
|
addEmitFlags(transformed, 4 /* AdviseOnEmitNode */);
|
|
classLexicalEnvironmentMap.set(getOriginalNodeId(transformed), currentClassLexicalEnvironment);
|
|
}
|
|
currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock;
|
|
return transformed;
|
|
}
|
|
function transformPropertyWorker(property, receiver) {
|
|
var _a2;
|
|
const emitAssignment = !useDefineForClassFields;
|
|
const propertyName = hasAccessorModifier(property) ? factory2.getGeneratedPrivateNameForNode(property.name) : isComputedPropertyName(property.name) && !isSimpleInlineableExpression(property.name.expression) ? factory2.updateComputedPropertyName(property.name, factory2.getGeneratedNameForNode(property.name)) : property.name;
|
|
if (hasStaticModifier(property)) {
|
|
currentStaticPropertyDeclarationOrStaticBlock = property;
|
|
}
|
|
if (shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifier(propertyName)) {
|
|
const privateIdentifierInfo = accessPrivateIdentifier(propertyName);
|
|
if (privateIdentifierInfo) {
|
|
if (privateIdentifierInfo.kind === "f" /* Field */) {
|
|
if (!privateIdentifierInfo.isStatic) {
|
|
return createPrivateInstanceFieldInitializer(
|
|
receiver,
|
|
visitNode(property.initializer, visitor, isExpression),
|
|
privateIdentifierInfo.brandCheckIdentifier
|
|
);
|
|
} else {
|
|
return createPrivateStaticFieldInitializer(
|
|
privateIdentifierInfo.variableName,
|
|
visitNode(property.initializer, visitor, isExpression)
|
|
);
|
|
}
|
|
} else {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
Debug.fail("Undeclared private name for property declaration.");
|
|
}
|
|
}
|
|
if ((isPrivateIdentifier(propertyName) || hasStaticModifier(property)) && !property.initializer) {
|
|
return void 0;
|
|
}
|
|
const propertyOriginalNode = getOriginalNode(property);
|
|
if (hasSyntacticModifier(propertyOriginalNode, 256 /* Abstract */)) {
|
|
return void 0;
|
|
}
|
|
const initializer = property.initializer || emitAssignment ? (_a2 = visitNode(property.initializer, visitor, isExpression)) != null ? _a2 : factory2.createVoidZero() : isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && isIdentifier(propertyName) ? propertyName : factory2.createVoidZero();
|
|
if (emitAssignment || isPrivateIdentifier(propertyName)) {
|
|
const memberAccess = createMemberAccessForPropertyName(factory2, receiver, propertyName, propertyName);
|
|
return factory2.createAssignment(memberAccess, initializer);
|
|
} else {
|
|
const name = isComputedPropertyName(propertyName) ? propertyName.expression : isIdentifier(propertyName) ? factory2.createStringLiteral(unescapeLeadingUnderscores(propertyName.escapedText)) : propertyName;
|
|
const descriptor = factory2.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true });
|
|
return factory2.createObjectDefinePropertyCall(receiver, name, descriptor);
|
|
}
|
|
}
|
|
function enableSubstitutionForClassAliases() {
|
|
if ((enabledSubstitutions & 1 /* ClassAliases */) === 0) {
|
|
enabledSubstitutions |= 1 /* ClassAliases */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
classAliases = [];
|
|
}
|
|
}
|
|
function enableSubstitutionForClassStaticThisOrSuperReference() {
|
|
if ((enabledSubstitutions & 2 /* ClassStaticThisOrSuperReference */) === 0) {
|
|
enabledSubstitutions |= 2 /* ClassStaticThisOrSuperReference */;
|
|
context.enableSubstitution(108 /* ThisKeyword */);
|
|
context.enableEmitNotification(259 /* FunctionDeclaration */);
|
|
context.enableEmitNotification(215 /* FunctionExpression */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(169 /* PropertyDeclaration */);
|
|
context.enableEmitNotification(164 /* ComputedPropertyName */);
|
|
}
|
|
}
|
|
function addMethodStatements(statements, methods, receiver) {
|
|
if (!shouldTransformPrivateElementsOrClassStaticBlocks || !some(methods)) {
|
|
return;
|
|
}
|
|
const { weakSetName } = getPrivateIdentifierEnvironment();
|
|
Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
createPrivateInstanceMethodInitializer(receiver, weakSetName)
|
|
)
|
|
);
|
|
}
|
|
function visitInvalidSuperProperty(node) {
|
|
return isPropertyAccessExpression(node) ? factory2.updatePropertyAccessExpression(
|
|
node,
|
|
factory2.createVoidZero(),
|
|
node.name
|
|
) : factory2.updateElementAccessExpression(
|
|
node,
|
|
factory2.createVoidZero(),
|
|
visitNode(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
const original = getOriginalNode(node);
|
|
if (original.id) {
|
|
const classLexicalEnvironment = classLexicalEnvironmentMap.get(original.id);
|
|
if (classLexicalEnvironment) {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = classLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = classLexicalEnvironment;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) {
|
|
break;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 173 /* Constructor */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = void 0;
|
|
currentComputedPropertyNameClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 169 /* PropertyDeclaration */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
case 164 /* ComputedPropertyName */: {
|
|
const savedClassLexicalEnvironment = currentClassLexicalEnvironment;
|
|
const savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = void 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentClassLexicalEnvironment = savedClassLexicalEnvironment;
|
|
currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment;
|
|
return;
|
|
}
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 108 /* ThisKeyword */:
|
|
return substituteThisExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteThisExpression(node) {
|
|
if (enabledSubstitutions & 2 /* ClassStaticThisOrSuperReference */ && currentClassLexicalEnvironment) {
|
|
const { facts, classConstructor } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
return factory2.createParenthesizedExpression(factory2.createVoidZero());
|
|
}
|
|
if (classConstructor) {
|
|
return setTextRange(
|
|
setOriginalNode(
|
|
factory2.cloneNode(classConstructor),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
return trySubstituteClassAlias(node) || node;
|
|
}
|
|
function trySubstituteClassAlias(node) {
|
|
if (enabledSubstitutions & 1 /* ClassAliases */) {
|
|
if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
|
|
const declaration = resolver.getReferencedValueDeclaration(node);
|
|
if (declaration) {
|
|
const classAlias = classAliases[declaration.id];
|
|
if (classAlias) {
|
|
const clone2 = factory2.cloneNode(classAlias);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPropertyNameExpressionIfNeeded(name, shouldHoist) {
|
|
if (isComputedPropertyName(name)) {
|
|
const expression = visitNode(name.expression, visitor, isExpression);
|
|
const innerExpression = skipPartiallyEmittedExpressions(expression);
|
|
const inlinable = isSimpleInlineableExpression(innerExpression);
|
|
const alreadyTransformed = isAssignmentExpression(innerExpression) && isGeneratedIdentifier(innerExpression.left);
|
|
if (!alreadyTransformed && !inlinable && shouldHoist) {
|
|
const generatedName = factory2.getGeneratedNameForNode(name);
|
|
if (resolver.getNodeCheckFlags(name) & 32768 /* BlockScopedBindingInLoop */) {
|
|
addBlockScopedVariable(generatedName);
|
|
} else {
|
|
hoistVariableDeclaration(generatedName);
|
|
}
|
|
return factory2.createAssignment(generatedName, expression);
|
|
}
|
|
return inlinable || isIdentifier(innerExpression) ? void 0 : expression;
|
|
}
|
|
}
|
|
function startClassLexicalEnvironment() {
|
|
classLexicalEnvironmentStack.push(currentClassLexicalEnvironment);
|
|
currentClassLexicalEnvironment = void 0;
|
|
}
|
|
function endClassLexicalEnvironment() {
|
|
currentClassLexicalEnvironment = classLexicalEnvironmentStack.pop();
|
|
}
|
|
function getClassLexicalEnvironment() {
|
|
return currentClassLexicalEnvironment || (currentClassLexicalEnvironment = {
|
|
facts: 0 /* None */,
|
|
classConstructor: void 0,
|
|
superClassReference: void 0,
|
|
privateIdentifierEnvironment: void 0
|
|
});
|
|
}
|
|
function getPrivateIdentifierEnvironment() {
|
|
const lex = getClassLexicalEnvironment();
|
|
lex.privateIdentifierEnvironment || (lex.privateIdentifierEnvironment = {
|
|
className: void 0,
|
|
weakSetName: void 0,
|
|
identifiers: void 0,
|
|
generatedIdentifiers: void 0
|
|
});
|
|
return lex.privateIdentifierEnvironment;
|
|
}
|
|
function getPendingExpressions() {
|
|
return pendingExpressions != null ? pendingExpressions : pendingExpressions = [];
|
|
}
|
|
function addPrivateIdentifierClassElementToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
if (isAutoAccessorPropertyDeclaration(node)) {
|
|
addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isPropertyDeclaration(node)) {
|
|
addPrivateIdentifierPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isMethodDeclaration(node)) {
|
|
addPrivateIdentifierMethodDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isGetAccessorDeclaration(node)) {
|
|
addPrivateIdentifierGetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
} else if (isSetAccessorDeclaration(node)) {
|
|
addPrivateIdentifierSetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
}
|
|
}
|
|
function addPrivateIdentifierPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
if (isStatic2) {
|
|
Debug.assert(lex.classConstructor, "classConstructor should be set in private identifier environment");
|
|
const variableName = createHoistedVariableForPrivateName(name);
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "f" /* Field */,
|
|
brandCheckIdentifier: lex.classConstructor,
|
|
variableName,
|
|
isStatic: true,
|
|
isValid
|
|
});
|
|
} else {
|
|
const weakMapName = createHoistedVariableForPrivateName(name);
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "f" /* Field */,
|
|
brandCheckIdentifier: weakMapName,
|
|
variableName: void 0,
|
|
isStatic: false,
|
|
isValid
|
|
});
|
|
getPendingExpressions().push(factory2.createAssignment(
|
|
weakMapName,
|
|
factory2.createNewExpression(
|
|
factory2.createIdentifier("WeakMap"),
|
|
void 0,
|
|
[]
|
|
)
|
|
));
|
|
}
|
|
}
|
|
function addPrivateIdentifierMethodDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
const methodName = createHoistedVariableForPrivateName(name);
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "m" /* Method */,
|
|
methodName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
function addPrivateIdentifierGetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
const getterName = createHoistedVariableForPrivateName(name, "_get");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
if ((previousInfo == null ? void 0 : previousInfo.kind) === "a" /* Accessor */ && previousInfo.isStatic === isStatic2 && !previousInfo.getterName) {
|
|
previousInfo.getterName = getterName;
|
|
} else {
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName,
|
|
setterName: void 0,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
}
|
|
function addPrivateIdentifierSetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, previousInfo) {
|
|
const setterName = createHoistedVariableForPrivateName(name, "_set");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
if ((previousInfo == null ? void 0 : previousInfo.kind) === "a" /* Accessor */ && previousInfo.isStatic === isStatic2 && !previousInfo.setterName) {
|
|
previousInfo.setterName = setterName;
|
|
} else {
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName: void 0,
|
|
setterName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
}
|
|
function addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic2, isValid, _previousInfo) {
|
|
const getterName = createHoistedVariableForPrivateName(name, "_get");
|
|
const setterName = createHoistedVariableForPrivateName(name, "_set");
|
|
const brandCheckIdentifier = isStatic2 ? Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment");
|
|
setPrivateIdentifier(privateEnv, name, {
|
|
kind: "a" /* Accessor */,
|
|
getterName,
|
|
setterName,
|
|
brandCheckIdentifier,
|
|
isStatic: isStatic2,
|
|
isValid
|
|
});
|
|
}
|
|
function addPrivateIdentifierToEnvironment(node, name, addDeclaration) {
|
|
const lex = getClassLexicalEnvironment();
|
|
const privateEnv = getPrivateIdentifierEnvironment();
|
|
const previousInfo = getPrivateIdentifier(privateEnv, name);
|
|
const isStatic2 = hasStaticModifier(node);
|
|
const isValid = !isReservedPrivateName(name) && previousInfo === void 0;
|
|
addDeclaration(node, name, lex, privateEnv, isStatic2, isValid, previousInfo);
|
|
}
|
|
function createHoistedVariableForClass(name, node, suffix) {
|
|
const { className } = getPrivateIdentifierEnvironment();
|
|
const prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_";
|
|
const identifier = typeof name === "object" ? factory2.getGeneratedNameForNode(name, 16 /* Optimistic */ | 8 /* ReservedInNestedScopes */, prefix, suffix) : typeof name === "string" ? factory2.createUniqueName(name, 16 /* Optimistic */, prefix, suffix) : factory2.createTempVariable(void 0, true, prefix, suffix);
|
|
if (resolver.getNodeCheckFlags(node) & 32768 /* BlockScopedBindingInLoop */) {
|
|
addBlockScopedVariable(identifier);
|
|
} else {
|
|
hoistVariableDeclaration(identifier);
|
|
}
|
|
return identifier;
|
|
}
|
|
function createHoistedVariableForPrivateName(name, suffix) {
|
|
var _a2;
|
|
const text = tryGetTextOfPropertyName(name);
|
|
return createHoistedVariableForClass((_a2 = text == null ? void 0 : text.substring(1)) != null ? _a2 : name, name, suffix);
|
|
}
|
|
function accessPrivateIdentifier(name) {
|
|
if (isGeneratedPrivateIdentifier(name)) {
|
|
return accessGeneratedPrivateIdentifier(name);
|
|
} else {
|
|
return accessPrivateIdentifierByText(name.escapedText);
|
|
}
|
|
}
|
|
function accessPrivateIdentifierByText(text) {
|
|
return accessPrivateIdentifierWorker(getPrivateIdentifierInfo, text);
|
|
}
|
|
function accessGeneratedPrivateIdentifier(name) {
|
|
return accessPrivateIdentifierWorker(getGeneratedPrivateIdentifierInfo, getNodeForGeneratedName(name));
|
|
}
|
|
function accessPrivateIdentifierWorker(getPrivateIdentifierInfo2, privateIdentifierKey) {
|
|
if (currentClassLexicalEnvironment == null ? void 0 : currentClassLexicalEnvironment.privateIdentifierEnvironment) {
|
|
const info = getPrivateIdentifierInfo2(currentClassLexicalEnvironment.privateIdentifierEnvironment, privateIdentifierKey);
|
|
if (info) {
|
|
return info;
|
|
}
|
|
}
|
|
for (let i = classLexicalEnvironmentStack.length - 1; i >= 0; --i) {
|
|
const env = classLexicalEnvironmentStack[i];
|
|
if (!env) {
|
|
continue;
|
|
}
|
|
if (env.privateIdentifierEnvironment) {
|
|
const info = getPrivateIdentifierInfo2(env.privateIdentifierEnvironment, privateIdentifierKey);
|
|
if (info) {
|
|
return info;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function wrapPrivateIdentifierForDestructuringTarget(node) {
|
|
const parameter = factory2.getGeneratedNameForNode(node);
|
|
const info = accessPrivateIdentifier(node.name);
|
|
if (!info) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
let receiver = node.expression;
|
|
if (isThisProperty(node) || isSuperProperty(node) || !isSimpleCopiableExpression(node.expression)) {
|
|
receiver = factory2.createTempVariable(hoistVariableDeclaration, true);
|
|
getPendingExpressions().push(factory2.createBinaryExpression(receiver, 63 /* EqualsToken */, visitNode(node.expression, visitor, isExpression)));
|
|
}
|
|
return factory2.createAssignmentTargetWrapper(
|
|
parameter,
|
|
createPrivateIdentifierAssignment(
|
|
info,
|
|
receiver,
|
|
parameter,
|
|
63 /* EqualsToken */
|
|
)
|
|
);
|
|
}
|
|
function visitArrayAssignmentTarget(node) {
|
|
const target = getTargetOfBindingOrAssignmentElement(node);
|
|
if (target) {
|
|
let wrapped;
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(target) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
wrapped = visitInvalidSuperProperty(target);
|
|
} else if (classConstructor && superClassReference) {
|
|
const name = isElementAccessExpression(target) ? visitNode(target.argumentExpression, visitor, isExpression) : isIdentifier(target.name) ? factory2.createStringLiteralFromNode(target.name) : void 0;
|
|
if (name) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
wrapped = factory2.createAssignmentTargetWrapper(
|
|
temp,
|
|
factory2.createReflectSetCall(
|
|
superClassReference,
|
|
name,
|
|
temp,
|
|
classConstructor
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (wrapped) {
|
|
if (isAssignmentExpression(node)) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
wrapped,
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
} else if (isSpreadElement(node)) {
|
|
return factory2.updateSpreadElement(node, wrapped);
|
|
} else {
|
|
return wrapped;
|
|
}
|
|
}
|
|
}
|
|
return visitNode(node, assignmentTargetVisitor);
|
|
}
|
|
function visitObjectAssignmentTarget(node) {
|
|
if (isObjectBindingOrAssignmentElement(node) && !isShorthandPropertyAssignment(node)) {
|
|
const target = getTargetOfBindingOrAssignmentElement(node);
|
|
let wrapped;
|
|
if (target) {
|
|
if (isPrivateIdentifierPropertyAccessExpression(target)) {
|
|
wrapped = wrapPrivateIdentifierForDestructuringTarget(target);
|
|
} else if (shouldTransformSuperInStaticInitializers && isSuperProperty(target) && currentStaticPropertyDeclarationOrStaticBlock && currentClassLexicalEnvironment) {
|
|
const { classConstructor, superClassReference, facts } = currentClassLexicalEnvironment;
|
|
if (facts & 1 /* ClassWasDecorated */) {
|
|
wrapped = visitInvalidSuperProperty(target);
|
|
} else if (classConstructor && superClassReference) {
|
|
const name = isElementAccessExpression(target) ? visitNode(target.argumentExpression, visitor, isExpression) : isIdentifier(target.name) ? factory2.createStringLiteralFromNode(target.name) : void 0;
|
|
if (name) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
wrapped = factory2.createAssignmentTargetWrapper(
|
|
temp,
|
|
factory2.createReflectSetCall(
|
|
superClassReference,
|
|
name,
|
|
temp,
|
|
classConstructor
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (isPropertyAssignment(node)) {
|
|
const initializer = getInitializerOfBindingOrAssignmentElement(node);
|
|
return factory2.updatePropertyAssignment(
|
|
node,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
wrapped ? initializer ? factory2.createAssignment(wrapped, visitNode(initializer, visitor)) : wrapped : visitNode(node.initializer, assignmentTargetVisitor, isExpression)
|
|
);
|
|
}
|
|
if (isSpreadAssignment(node)) {
|
|
return factory2.updateSpreadAssignment(
|
|
node,
|
|
wrapped || visitNode(node.expression, assignmentTargetVisitor, isExpression)
|
|
);
|
|
}
|
|
Debug.assert(wrapped === void 0, "Should not have generated a wrapped target");
|
|
}
|
|
return visitNode(node, visitor);
|
|
}
|
|
function visitAssignmentPattern(node) {
|
|
if (isArrayLiteralExpression(node)) {
|
|
return factory2.updateArrayLiteralExpression(
|
|
node,
|
|
visitNodes2(node.elements, visitArrayAssignmentTarget, isExpression)
|
|
);
|
|
} else {
|
|
return factory2.updateObjectLiteralExpression(
|
|
node,
|
|
visitNodes2(node.properties, visitObjectAssignmentTarget, isObjectLiteralElementLike)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function createPrivateStaticFieldInitializer(variableName, initializer) {
|
|
return factory.createAssignment(
|
|
variableName,
|
|
factory.createObjectLiteralExpression([
|
|
factory.createPropertyAssignment("value", initializer || factory.createVoidZero())
|
|
])
|
|
);
|
|
}
|
|
function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
|
|
return factory.createCallExpression(
|
|
factory.createPropertyAccessExpression(weakMapName, "set"),
|
|
void 0,
|
|
[receiver, initializer || factory.createVoidZero()]
|
|
);
|
|
}
|
|
function createPrivateInstanceMethodInitializer(receiver, weakSetName) {
|
|
return factory.createCallExpression(
|
|
factory.createPropertyAccessExpression(weakSetName, "add"),
|
|
void 0,
|
|
[receiver]
|
|
);
|
|
}
|
|
function isReservedPrivateName(node) {
|
|
return !isGeneratedPrivateIdentifier(node) && node.escapedText === "#constructor";
|
|
}
|
|
function getPrivateIdentifier(privateEnv, name) {
|
|
return isGeneratedPrivateIdentifier(name) ? getGeneratedPrivateIdentifierInfo(privateEnv, getNodeForGeneratedName(name)) : getPrivateIdentifierInfo(privateEnv, name.escapedText);
|
|
}
|
|
function setPrivateIdentifier(privateEnv, name, info) {
|
|
var _a2, _b;
|
|
if (isGeneratedPrivateIdentifier(name)) {
|
|
(_a2 = privateEnv.generatedIdentifiers) != null ? _a2 : privateEnv.generatedIdentifiers = /* @__PURE__ */ new Map();
|
|
privateEnv.generatedIdentifiers.set(getNodeForGeneratedName(name), info);
|
|
} else {
|
|
(_b = privateEnv.identifiers) != null ? _b : privateEnv.identifiers = /* @__PURE__ */ new Map();
|
|
privateEnv.identifiers.set(name.escapedText, info);
|
|
}
|
|
}
|
|
function getPrivateIdentifierInfo(privateEnv, key) {
|
|
var _a2;
|
|
return (_a2 = privateEnv.identifiers) == null ? void 0 : _a2.get(key);
|
|
}
|
|
function getGeneratedPrivateIdentifierInfo(privateEnv, key) {
|
|
var _a2;
|
|
return (_a2 = privateEnv.generatedIdentifiers) == null ? void 0 : _a2.get(key);
|
|
}
|
|
|
|
// src/compiler/transformers/typeSerializer.ts
|
|
function createRuntimeTypeSerializer(context) {
|
|
const {
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const strictNullChecks = getStrictOptionValue(compilerOptions, "strictNullChecks");
|
|
let currentLexicalScope;
|
|
let currentNameScope;
|
|
return {
|
|
serializeTypeNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeNode, node),
|
|
serializeTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node),
|
|
serializeParameterTypesOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container),
|
|
serializeReturnTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node)
|
|
};
|
|
function setSerializerContextAnd(serializerContext, cb, node, arg) {
|
|
const savedCurrentLexicalScope = currentLexicalScope;
|
|
const savedCurrentNameScope = currentNameScope;
|
|
currentLexicalScope = serializerContext.currentLexicalScope;
|
|
currentNameScope = serializerContext.currentNameScope;
|
|
const result = arg === void 0 ? cb(node) : cb(node, arg);
|
|
currentLexicalScope = savedCurrentLexicalScope;
|
|
currentNameScope = savedCurrentNameScope;
|
|
return result;
|
|
}
|
|
function getAccessorTypeNode(node) {
|
|
const accessors = resolver.getAllAccessorDeclarations(node);
|
|
return accessors.setAccessor && getSetAccessorTypeAnnotationNode(accessors.setAccessor) || accessors.getAccessor && getEffectiveReturnTypeNode(accessors.getAccessor);
|
|
}
|
|
function serializeTypeOfNode(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 166 /* Parameter */:
|
|
return serializeTypeNode(node.type);
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
return serializeTypeNode(getAccessorTypeNode(node));
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
return factory.createIdentifier("Function");
|
|
default:
|
|
return factory.createVoidZero();
|
|
}
|
|
}
|
|
function serializeParameterTypesOfNode(node, container) {
|
|
const valueDeclaration = isClassLike(node) ? getFirstConstructorWithBody(node) : isFunctionLike(node) && nodeIsPresent(node.body) ? node : void 0;
|
|
const expressions = [];
|
|
if (valueDeclaration) {
|
|
const parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container);
|
|
const numParameters = parameters.length;
|
|
for (let i = 0; i < numParameters; i++) {
|
|
const parameter = parameters[i];
|
|
if (i === 0 && isIdentifier(parameter.name) && parameter.name.escapedText === "this") {
|
|
continue;
|
|
}
|
|
if (parameter.dotDotDotToken) {
|
|
expressions.push(serializeTypeNode(getRestParameterElementType(parameter.type)));
|
|
} else {
|
|
expressions.push(serializeTypeOfNode(parameter));
|
|
}
|
|
}
|
|
}
|
|
return factory.createArrayLiteralExpression(expressions);
|
|
}
|
|
function getParametersOfDecoratedDeclaration(node, container) {
|
|
if (container && node.kind === 174 /* GetAccessor */) {
|
|
const { setAccessor } = getAllAccessorDeclarations(container.members, node);
|
|
if (setAccessor) {
|
|
return setAccessor.parameters;
|
|
}
|
|
}
|
|
return node.parameters;
|
|
}
|
|
function serializeReturnTypeOfNode(node) {
|
|
if (isFunctionLike(node) && node.type) {
|
|
return serializeTypeNode(node.type);
|
|
} else if (isAsyncFunction(node)) {
|
|
return factory.createIdentifier("Promise");
|
|
}
|
|
return factory.createVoidZero();
|
|
}
|
|
function serializeTypeNode(node) {
|
|
if (node === void 0) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
node = skipTypeParentheses(node);
|
|
switch (node.kind) {
|
|
case 114 /* VoidKeyword */:
|
|
case 155 /* UndefinedKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
return factory.createVoidZero();
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return factory.createIdentifier("Function");
|
|
case 185 /* ArrayType */:
|
|
case 186 /* TupleType */:
|
|
return factory.createIdentifier("Array");
|
|
case 179 /* TypePredicate */:
|
|
return node.assertsModifier ? factory.createVoidZero() : factory.createIdentifier("Boolean");
|
|
case 134 /* BooleanKeyword */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 200 /* TemplateLiteralType */:
|
|
case 152 /* StringKeyword */:
|
|
return factory.createIdentifier("String");
|
|
case 149 /* ObjectKeyword */:
|
|
return factory.createIdentifier("Object");
|
|
case 198 /* LiteralType */:
|
|
return serializeLiteralOfLiteralTypeNode(node.literal);
|
|
case 148 /* NumberKeyword */:
|
|
return factory.createIdentifier("Number");
|
|
case 160 /* BigIntKeyword */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 153 /* SymbolKeyword */:
|
|
return getGlobalConstructor("Symbol", 2 /* ES2015 */);
|
|
case 180 /* TypeReference */:
|
|
return serializeTypeReferenceNode(node);
|
|
case 190 /* IntersectionType */:
|
|
return serializeUnionOrIntersectionConstituents(node.types, true);
|
|
case 189 /* UnionType */:
|
|
return serializeUnionOrIntersectionConstituents(node.types, false);
|
|
case 191 /* ConditionalType */:
|
|
return serializeUnionOrIntersectionConstituents([node.trueType, node.falseType], false);
|
|
case 195 /* TypeOperator */:
|
|
if (node.operator === 146 /* ReadonlyKeyword */) {
|
|
return serializeTypeNode(node.type);
|
|
}
|
|
break;
|
|
case 183 /* TypeQuery */:
|
|
case 196 /* IndexedAccessType */:
|
|
case 197 /* MappedType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 131 /* AnyKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
case 194 /* ThisType */:
|
|
case 202 /* ImportType */:
|
|
break;
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
case 320 /* JSDocFunctionType */:
|
|
case 321 /* JSDocVariadicType */:
|
|
case 322 /* JSDocNamepathType */:
|
|
break;
|
|
case 317 /* JSDocNullableType */:
|
|
case 318 /* JSDocNonNullableType */:
|
|
case 319 /* JSDocOptionalType */:
|
|
return serializeTypeNode(node.type);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
function serializeLiteralOfLiteralTypeNode(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return factory.createIdentifier("String");
|
|
case 221 /* PrefixUnaryExpression */: {
|
|
const operand = node.operand;
|
|
switch (operand.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return serializeLiteralOfLiteralTypeNode(operand);
|
|
default:
|
|
return Debug.failBadSyntaxKind(operand);
|
|
}
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
return factory.createIdentifier("Number");
|
|
case 9 /* BigIntLiteral */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 104 /* NullKeyword */:
|
|
return factory.createVoidZero();
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function serializeUnionOrIntersectionConstituents(types, isIntersection) {
|
|
let serializedType;
|
|
for (let typeNode of types) {
|
|
typeNode = skipTypeParentheses(typeNode);
|
|
if (typeNode.kind === 144 /* NeverKeyword */) {
|
|
if (isIntersection)
|
|
return factory.createVoidZero();
|
|
continue;
|
|
}
|
|
if (typeNode.kind === 157 /* UnknownKeyword */) {
|
|
if (!isIntersection)
|
|
return factory.createIdentifier("Object");
|
|
continue;
|
|
}
|
|
if (typeNode.kind === 131 /* AnyKeyword */) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
if (!strictNullChecks && (isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
|
|
continue;
|
|
}
|
|
const serializedConstituent = serializeTypeNode(typeNode);
|
|
if (isIdentifier(serializedConstituent) && serializedConstituent.escapedText === "Object") {
|
|
return serializedConstituent;
|
|
}
|
|
if (serializedType) {
|
|
if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
} else {
|
|
serializedType = serializedConstituent;
|
|
}
|
|
}
|
|
return serializedType != null ? serializedType : factory.createVoidZero();
|
|
}
|
|
function equateSerializedTypeNodes(left, right) {
|
|
return isGeneratedIdentifier(left) ? isGeneratedIdentifier(right) : isIdentifier(left) ? isIdentifier(right) && left.escapedText === right.escapedText : isPropertyAccessExpression(left) ? isPropertyAccessExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) && equateSerializedTypeNodes(left.name, right.name) : isVoidExpression(left) ? isVoidExpression(right) && isNumericLiteral(left.expression) && left.expression.text === "0" && isNumericLiteral(right.expression) && right.expression.text === "0" : isStringLiteral(left) ? isStringLiteral(right) && left.text === right.text : isTypeOfExpression(left) ? isTypeOfExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) : isParenthesizedExpression(left) ? isParenthesizedExpression(right) && equateSerializedTypeNodes(left.expression, right.expression) : isConditionalExpression(left) ? isConditionalExpression(right) && equateSerializedTypeNodes(left.condition, right.condition) && equateSerializedTypeNodes(left.whenTrue, right.whenTrue) && equateSerializedTypeNodes(left.whenFalse, right.whenFalse) : isBinaryExpression(left) ? isBinaryExpression(right) && left.operatorToken.kind === right.operatorToken.kind && equateSerializedTypeNodes(left.left, right.left) && equateSerializedTypeNodes(left.right, right.right) : false;
|
|
}
|
|
function serializeTypeReferenceNode(node) {
|
|
const kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope != null ? currentNameScope : currentLexicalScope);
|
|
switch (kind) {
|
|
case 0 /* Unknown */:
|
|
if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
|
|
return factory.createIdentifier("Object");
|
|
}
|
|
const serialized = serializeEntityNameAsExpressionFallback(node.typeName);
|
|
const temp = factory.createTempVariable(hoistVariableDeclaration);
|
|
return factory.createConditionalExpression(
|
|
factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"),
|
|
void 0,
|
|
temp,
|
|
void 0,
|
|
factory.createIdentifier("Object")
|
|
);
|
|
case 1 /* TypeWithConstructSignatureAndValue */:
|
|
return serializeEntityNameAsExpression(node.typeName);
|
|
case 2 /* VoidNullableOrNeverType */:
|
|
return factory.createVoidZero();
|
|
case 4 /* BigIntLikeType */:
|
|
return getGlobalConstructor("BigInt", 7 /* ES2020 */);
|
|
case 6 /* BooleanType */:
|
|
return factory.createIdentifier("Boolean");
|
|
case 3 /* NumberLikeType */:
|
|
return factory.createIdentifier("Number");
|
|
case 5 /* StringLikeType */:
|
|
return factory.createIdentifier("String");
|
|
case 7 /* ArrayLikeType */:
|
|
return factory.createIdentifier("Array");
|
|
case 8 /* ESSymbolType */:
|
|
return getGlobalConstructor("Symbol", 2 /* ES2015 */);
|
|
case 10 /* TypeWithCallSignature */:
|
|
return factory.createIdentifier("Function");
|
|
case 9 /* Promise */:
|
|
return factory.createIdentifier("Promise");
|
|
case 11 /* ObjectType */:
|
|
return factory.createIdentifier("Object");
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
}
|
|
function createCheckedValue(left, right) {
|
|
return factory.createLogicalAnd(
|
|
factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")),
|
|
right
|
|
);
|
|
}
|
|
function serializeEntityNameAsExpressionFallback(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
const copied = serializeEntityNameAsExpression(node);
|
|
return createCheckedValue(copied, copied);
|
|
}
|
|
if (node.left.kind === 79 /* Identifier */) {
|
|
return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
|
|
}
|
|
const left = serializeEntityNameAsExpressionFallback(node.left);
|
|
const temp = factory.createTempVariable(hoistVariableDeclaration);
|
|
return factory.createLogicalAnd(
|
|
factory.createLogicalAnd(
|
|
left.left,
|
|
factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero())
|
|
),
|
|
factory.createPropertyAccessExpression(temp, node.right)
|
|
);
|
|
}
|
|
function serializeEntityNameAsExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
const name = setParent(setTextRange(parseNodeFactory.cloneNode(node), node), node.parent);
|
|
name.original = void 0;
|
|
setParent(name, getParseTreeNode(currentLexicalScope));
|
|
return name;
|
|
case 163 /* QualifiedName */:
|
|
return serializeQualifiedNameAsExpression(node);
|
|
}
|
|
}
|
|
function serializeQualifiedNameAsExpression(node) {
|
|
return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
|
|
}
|
|
function getGlobalConstructorWithFallback(name) {
|
|
return factory.createConditionalExpression(
|
|
factory.createTypeCheck(factory.createIdentifier(name), "function"),
|
|
void 0,
|
|
factory.createIdentifier(name),
|
|
void 0,
|
|
factory.createIdentifier("Object")
|
|
);
|
|
}
|
|
function getGlobalConstructor(name, minLanguageVersion) {
|
|
return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory.createIdentifier(name);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/legacyDecorators.ts
|
|
function transformLegacyDecorators(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let classAliases;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function modifierVisitor(node) {
|
|
return isDecorator(node) ? void 0 : node;
|
|
}
|
|
function visitor(node) {
|
|
if (!(node.transformFlags & 33554432 /* ContainsDecorators */)) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 167 /* Decorator */:
|
|
return void 0;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 173 /* Constructor */:
|
|
return visitConstructorDeclaration(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node);
|
|
case 175 /* SetAccessor */:
|
|
return visitSetAccessorDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
return visitGetAccessorDeclaration(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return visitPropertyDeclaration(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameterDeclaration(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
if (!(classOrConstructorParameterIsDecorated(node) || childIsDecorated(node)))
|
|
return visitEachChild(node, visitor, context);
|
|
const statements = hasDecorators(node) ? transformClassDeclarationWithClassDecorators(node, node.name) : transformClassDeclarationWithoutClassDecorators(node, node.name);
|
|
if (statements.length > 1) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(statements[0], getEmitFlags(statements[0]) | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function decoratorContainsPrivateIdentifierInExpression(decorator) {
|
|
return !!(decorator.transformFlags & 536870912 /* ContainsPrivateIdentifierInExpression */);
|
|
}
|
|
function parameterDecoratorsContainPrivateIdentifierInExpression(parameterDecorators) {
|
|
return some(parameterDecorators, decoratorContainsPrivateIdentifierInExpression);
|
|
}
|
|
function hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node) {
|
|
for (const member of node.members) {
|
|
if (!canHaveDecorators(member))
|
|
continue;
|
|
const allDecorators = getAllDecoratorsOfClassElement(member, node);
|
|
if (some(allDecorators == null ? void 0 : allDecorators.decorators, decoratorContainsPrivateIdentifierInExpression))
|
|
return true;
|
|
if (some(allDecorators == null ? void 0 : allDecorators.parameters, parameterDecoratorsContainPrivateIdentifierInExpression))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function transformDecoratorsOfClassElements(node, members) {
|
|
let decorationStatements = [];
|
|
addClassElementDecorationStatements(decorationStatements, node, false);
|
|
addClassElementDecorationStatements(decorationStatements, node, true);
|
|
if (hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node)) {
|
|
members = setTextRange(factory2.createNodeArray([
|
|
...members,
|
|
factory2.createClassStaticBlockDeclaration(
|
|
factory2.createBlock(decorationStatements, true)
|
|
)
|
|
]), members);
|
|
decorationStatements = void 0;
|
|
}
|
|
return { decorationStatements, members };
|
|
}
|
|
function transformClassDeclarationWithoutClassDecorators(node, name) {
|
|
const modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, visitor, isHeritageClause);
|
|
let members = visitNodes2(node.members, visitor, isClassElement);
|
|
let decorationStatements = [];
|
|
({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
|
|
const updated = factory2.updateClassDeclaration(
|
|
node,
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
return addRange([updated], decorationStatements);
|
|
}
|
|
function transformClassDeclarationWithClassDecorators(node, name) {
|
|
const location2 = moveRangePastModifiers(node);
|
|
const classAlias = getClassAliasIfNeeded(node);
|
|
const declName = languageVersion <= 2 /* ES2015 */ ? factory2.getInternalName(node, false, true) : factory2.getLocalName(node, false, true);
|
|
const heritageClauses = visitNodes2(node.heritageClauses, visitor, isHeritageClause);
|
|
let members = visitNodes2(node.members, visitor, isClassElement);
|
|
let decorationStatements = [];
|
|
({ members, decorationStatements } = transformDecoratorsOfClassElements(node, members));
|
|
const classExpression = factory2.createClassExpression(
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
heritageClauses,
|
|
members
|
|
);
|
|
setOriginalNode(classExpression, node);
|
|
setTextRange(classExpression, location2);
|
|
const statement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
declName,
|
|
void 0,
|
|
void 0,
|
|
classAlias ? factory2.createAssignment(classAlias, classExpression) : classExpression
|
|
)
|
|
], 1 /* Let */)
|
|
);
|
|
setOriginalNode(statement, node);
|
|
setTextRange(statement, location2);
|
|
setCommentRange(statement, node);
|
|
const statements = [statement];
|
|
addRange(statements, decorationStatements);
|
|
addConstructorDecorationStatement(statements, node);
|
|
return statements;
|
|
}
|
|
function visitClassExpression(node) {
|
|
return factory2.updateClassExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, visitor, isClassElement)
|
|
);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
visitNode(node.body, visitor, isBlock)
|
|
);
|
|
}
|
|
function finishClassElement(updated, original) {
|
|
if (updated !== original) {
|
|
setCommentRange(updated, original);
|
|
setSourceMapRange(updated, moveRangePastModifiers(original));
|
|
}
|
|
return updated;
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
return finishClassElement(factory2.updateMethodDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
return finishClassElement(factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
return finishClassElement(factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
visitNode(node.body, visitor, isBlock)
|
|
), node);
|
|
}
|
|
function visitPropertyDeclaration(node) {
|
|
if (node.flags & 16777216 /* Ambient */ || hasSyntacticModifier(node, 2 /* Ambient */)) {
|
|
return void 0;
|
|
}
|
|
return finishClassElement(factory2.updatePropertyDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
), node);
|
|
}
|
|
function visitParameterDeclaration(node) {
|
|
const updated = factory2.updateParameterDeclaration(
|
|
node,
|
|
elideNodes(factory2, node.modifiers),
|
|
node.dotDotDotToken,
|
|
visitNode(node.name, visitor, isBindingName),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
if (updated !== node) {
|
|
setCommentRange(updated, node);
|
|
setTextRange(updated, moveRangePastModifiers(node));
|
|
setSourceMapRange(updated, moveRangePastModifiers(node));
|
|
setEmitFlags(updated.name, 64 /* NoTrailingSourceMap */);
|
|
}
|
|
return updated;
|
|
}
|
|
function transformAllDecoratorsOfDeclaration(allDecorators) {
|
|
if (!allDecorators) {
|
|
return void 0;
|
|
}
|
|
const decoratorExpressions = [];
|
|
addRange(decoratorExpressions, map(allDecorators.decorators, transformDecorator));
|
|
addRange(decoratorExpressions, flatMap(allDecorators.parameters, transformDecoratorsOfParameter));
|
|
return decoratorExpressions;
|
|
}
|
|
function addClassElementDecorationStatements(statements, node, isStatic2) {
|
|
addRange(statements, map(generateClassElementDecorationExpressions(node, isStatic2), (expr) => factory2.createExpressionStatement(expr)));
|
|
}
|
|
function isDecoratedClassElement(member, isStaticElement, parent2) {
|
|
return nodeOrChildIsDecorated(member, parent2) && isStaticElement === isStatic(member);
|
|
}
|
|
function getDecoratedClassElements(node, isStatic2) {
|
|
return filter(node.members, (m) => isDecoratedClassElement(m, isStatic2, node));
|
|
}
|
|
function generateClassElementDecorationExpressions(node, isStatic2) {
|
|
const members = getDecoratedClassElements(node, isStatic2);
|
|
let expressions;
|
|
for (const member of members) {
|
|
expressions = append(expressions, generateClassElementDecorationExpression(node, member));
|
|
}
|
|
return expressions;
|
|
}
|
|
function generateClassElementDecorationExpression(node, member) {
|
|
const allDecorators = getAllDecoratorsOfClassElement(member, node);
|
|
const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
|
|
if (!decoratorExpressions) {
|
|
return void 0;
|
|
}
|
|
const prefix = getClassMemberPrefix(node, member);
|
|
const memberName = getExpressionForPropertyName(member, !hasSyntacticModifier(member, 2 /* Ambient */));
|
|
const descriptor = languageVersion > 0 /* ES3 */ ? isPropertyDeclaration(member) && !hasAccessorModifier(member) ? factory2.createVoidZero() : factory2.createNull() : void 0;
|
|
const helper = emitHelpers().createDecorateHelper(
|
|
decoratorExpressions,
|
|
prefix,
|
|
memberName,
|
|
descriptor
|
|
);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
setSourceMapRange(helper, moveRangePastModifiers(member));
|
|
return helper;
|
|
}
|
|
function addConstructorDecorationStatement(statements, node) {
|
|
const expression = generateConstructorDecorationExpression(node);
|
|
if (expression) {
|
|
statements.push(setOriginalNode(factory2.createExpressionStatement(expression), node));
|
|
}
|
|
}
|
|
function generateConstructorDecorationExpression(node) {
|
|
const allDecorators = getAllDecoratorsOfClass(node);
|
|
const decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators);
|
|
if (!decoratorExpressions) {
|
|
return void 0;
|
|
}
|
|
const classAlias = classAliases && classAliases[getOriginalNodeId(node)];
|
|
const localName = languageVersion <= 2 /* ES2015 */ ? factory2.getInternalName(node, false, true) : factory2.getLocalName(node, false, true);
|
|
const decorate = emitHelpers().createDecorateHelper(decoratorExpressions, localName);
|
|
const expression = factory2.createAssignment(localName, classAlias ? factory2.createAssignment(classAlias, decorate) : decorate);
|
|
setEmitFlags(expression, 3072 /* NoComments */);
|
|
setSourceMapRange(expression, moveRangePastModifiers(node));
|
|
return expression;
|
|
}
|
|
function transformDecorator(decorator) {
|
|
return visitNode(decorator.expression, visitor, isExpression);
|
|
}
|
|
function transformDecoratorsOfParameter(decorators, parameterOffset) {
|
|
let expressions;
|
|
if (decorators) {
|
|
expressions = [];
|
|
for (const decorator of decorators) {
|
|
const helper = emitHelpers().createParamHelper(
|
|
transformDecorator(decorator),
|
|
parameterOffset
|
|
);
|
|
setTextRange(helper, decorator.expression);
|
|
setEmitFlags(helper, 3072 /* NoComments */);
|
|
expressions.push(helper);
|
|
}
|
|
}
|
|
return expressions;
|
|
}
|
|
function getExpressionForPropertyName(member, generateNameForComputedPropertyName) {
|
|
const name = member.name;
|
|
if (isPrivateIdentifier(name)) {
|
|
return factory2.createIdentifier("");
|
|
} else if (isComputedPropertyName(name)) {
|
|
return generateNameForComputedPropertyName && !isSimpleInlineableExpression(name.expression) ? factory2.getGeneratedNameForNode(name) : name.expression;
|
|
} else if (isIdentifier(name)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return factory2.cloneNode(name);
|
|
}
|
|
}
|
|
function enableSubstitutionForClassAliases() {
|
|
if (!classAliases) {
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
classAliases = [];
|
|
}
|
|
}
|
|
function getClassAliasIfNeeded(node) {
|
|
if (resolver.getNodeCheckFlags(node) & 1048576 /* ClassWithConstructorReference */) {
|
|
enableSubstitutionForClassAliases();
|
|
const classAlias = factory2.createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? idText(node.name) : "default");
|
|
classAliases[getOriginalNodeId(node)] = classAlias;
|
|
hoistVariableDeclaration(classAlias);
|
|
return classAlias;
|
|
}
|
|
}
|
|
function getClassPrototype(node) {
|
|
return factory2.createPropertyAccessExpression(factory2.getDeclarationName(node), "prototype");
|
|
}
|
|
function getClassMemberPrefix(node, member) {
|
|
return isStatic(member) ? factory2.getDeclarationName(node) : getClassPrototype(node);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2;
|
|
return (_a2 = trySubstituteClassAlias(node)) != null ? _a2 : node;
|
|
}
|
|
function trySubstituteClassAlias(node) {
|
|
if (classAliases) {
|
|
if (resolver.getNodeCheckFlags(node) & 2097152 /* ConstructorReferenceInClass */) {
|
|
const declaration = resolver.getReferencedValueDeclaration(node);
|
|
if (declaration) {
|
|
const classAlias = classAliases[declaration.id];
|
|
if (classAlias) {
|
|
const clone2 = factory2.cloneNode(classAlias);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2017.ts
|
|
function transformES2017(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
let enabledSubstitutions;
|
|
let enclosingSuperContainerFlags = 0;
|
|
let enclosingFunctionParameterNames;
|
|
let capturedSuperProperties;
|
|
let hasSuperElementAccess;
|
|
const substitutedSuperAccessors = [];
|
|
let contextFlags = 0 /* None */;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
setContextFlag(1 /* NonTopLevel */, false);
|
|
setContextFlag(2 /* HasLexicalThis */, !isEffectiveStrictModeSourceFile(node, compilerOptions));
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function setContextFlag(flag, val) {
|
|
contextFlags = val ? contextFlags | flag : contextFlags & ~flag;
|
|
}
|
|
function inContext(flags) {
|
|
return (contextFlags & flags) !== 0;
|
|
}
|
|
function inTopLevelContext() {
|
|
return !inContext(1 /* NonTopLevel */);
|
|
}
|
|
function inHasLexicalThisContext() {
|
|
return inContext(2 /* HasLexicalThis */);
|
|
}
|
|
function doWithContext(flags, cb, value) {
|
|
const contextFlagsToSet = flags & ~contextFlags;
|
|
if (contextFlagsToSet) {
|
|
setContextFlag(contextFlagsToSet, true);
|
|
const result = cb(value);
|
|
setContextFlag(contextFlagsToSet, false);
|
|
return result;
|
|
}
|
|
return cb(value);
|
|
}
|
|
function visitDefault(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 256 /* ContainsES2017 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 132 /* AsyncKeyword */:
|
|
return void 0;
|
|
case 220 /* AwaitExpression */:
|
|
return visitAwaitExpression(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitMethodDeclaration, node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitFunctionDeclaration, node);
|
|
case 215 /* FunctionExpression */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitFunctionExpression, node);
|
|
case 216 /* ArrowFunction */:
|
|
return doWithContext(1 /* NonTopLevel */, visitArrowFunction, node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === 106 /* SuperKeyword */) {
|
|
capturedSuperProperties.add(node.name.escapedText);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 209 /* ElementAccessExpression */:
|
|
if (capturedSuperProperties && node.expression.kind === 106 /* SuperKeyword */) {
|
|
hasSuperElementAccess = true;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 174 /* GetAccessor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitGetAccessorDeclaration, node);
|
|
case 175 /* SetAccessor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitSetAccessorDeclaration, node);
|
|
case 173 /* Constructor */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitConstructorDeclaration, node);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return doWithContext(1 /* NonTopLevel */ | 2 /* HasLexicalThis */, visitDefault, node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function asyncBodyVisitor(node) {
|
|
if (isNodeWithPossibleHoistedDeclaration(node)) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatementInAsyncBody(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatementInAsyncBody(node);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatementInAsyncBody(node);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatementInAsyncBody(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClauseInAsyncBody(node);
|
|
case 238 /* Block */:
|
|
case 252 /* SwitchStatement */:
|
|
case 266 /* CaseBlock */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
case 255 /* TryStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 253 /* LabeledStatement */:
|
|
return visitEachChild(node, asyncBodyVisitor, context);
|
|
default:
|
|
return Debug.assertNever(node, "Unhandled node.");
|
|
}
|
|
}
|
|
return visitor(node);
|
|
}
|
|
function visitCatchClauseInAsyncBody(node) {
|
|
const catchClauseNames = /* @__PURE__ */ new Set();
|
|
recordDeclarationName(node.variableDeclaration, catchClauseNames);
|
|
let catchClauseUnshadowedNames;
|
|
catchClauseNames.forEach((_, escapedName) => {
|
|
if (enclosingFunctionParameterNames.has(escapedName)) {
|
|
if (!catchClauseUnshadowedNames) {
|
|
catchClauseUnshadowedNames = new Set(enclosingFunctionParameterNames);
|
|
}
|
|
catchClauseUnshadowedNames.delete(escapedName);
|
|
}
|
|
});
|
|
if (catchClauseUnshadowedNames) {
|
|
const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
|
|
enclosingFunctionParameterNames = catchClauseUnshadowedNames;
|
|
const result = visitEachChild(node, asyncBodyVisitor, context);
|
|
enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames;
|
|
return result;
|
|
} else {
|
|
return visitEachChild(node, asyncBodyVisitor, context);
|
|
}
|
|
}
|
|
function visitVariableStatementInAsyncBody(node) {
|
|
if (isVariableDeclarationListWithCollidingName(node.declarationList)) {
|
|
const expression = visitVariableDeclarationListWithCollidingNames(node.declarationList, false);
|
|
return expression ? factory2.createExpressionStatement(expression) : void 0;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForInStatementInAsyncBody(node) {
|
|
return factory2.updateForInStatement(
|
|
node,
|
|
isVariableDeclarationListWithCollidingName(node.initializer) ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitForOfStatementInAsyncBody(node) {
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
visitNode(node.awaitModifier, visitor, isToken),
|
|
isVariableDeclarationListWithCollidingName(node.initializer) ? visitVariableDeclarationListWithCollidingNames(node.initializer, true) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitForStatementInAsyncBody(node) {
|
|
const initializer = node.initializer;
|
|
return factory2.updateForStatement(
|
|
node,
|
|
isVariableDeclarationListWithCollidingName(initializer) ? visitVariableDeclarationListWithCollidingNames(initializer, false) : visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, asyncBodyVisitor, context)
|
|
);
|
|
}
|
|
function visitAwaitExpression(node) {
|
|
if (inTopLevelContext()) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
return factory2.updateConstructorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
return factory2.updateMethodDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
return factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
return factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.name,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
transformMethodBody(node)
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
return factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
return factory2.updateFunctionExpression(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function visitArrowFunction(node) {
|
|
return factory2.updateArrowFunction(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifierLike),
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
getFunctionFlags(node) & 2 /* Async */ ? transformAsyncFunctionBody(node) : visitFunctionBody(node.body, visitor, context)
|
|
);
|
|
}
|
|
function recordDeclarationName({ name }, names) {
|
|
if (isIdentifier(name)) {
|
|
names.add(name.escapedText);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
recordDeclarationName(element, names);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isVariableDeclarationListWithCollidingName(node) {
|
|
return !!node && isVariableDeclarationList(node) && !(node.flags & 3 /* BlockScoped */) && node.declarations.some(collidesWithParameterName);
|
|
}
|
|
function visitVariableDeclarationListWithCollidingNames(node, hasReceiver) {
|
|
hoistVariableDeclarationList(node);
|
|
const variables = getInitializedVariables(node);
|
|
if (variables.length === 0) {
|
|
if (hasReceiver) {
|
|
return visitNode(factory2.converters.convertToAssignmentElementTarget(node.declarations[0].name), visitor, isExpression);
|
|
}
|
|
return void 0;
|
|
}
|
|
return factory2.inlineExpressions(map(variables, transformInitializedVariable));
|
|
}
|
|
function hoistVariableDeclarationList(node) {
|
|
forEach(node.declarations, hoistVariable);
|
|
}
|
|
function hoistVariable({ name }) {
|
|
if (isIdentifier(name)) {
|
|
hoistVariableDeclaration(name);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
hoistVariable(element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
const converted = setSourceMapRange(
|
|
factory2.createAssignment(
|
|
factory2.converters.convertToAssignmentElementTarget(node.name),
|
|
node.initializer
|
|
),
|
|
node
|
|
);
|
|
return visitNode(converted, visitor, isExpression);
|
|
}
|
|
function collidesWithParameterName({ name }) {
|
|
if (isIdentifier(name)) {
|
|
return enclosingFunctionParameterNames.has(name.escapedText);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element) && collidesWithParameterName(element)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function transformMethodBody(node) {
|
|
Debug.assertIsDefined(node.body);
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
let updated = visitFunctionBody(node.body, visitor, context);
|
|
const originalMethod = getOriginalNode(node, isFunctionLikeDeclaration);
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */) && (getFunctionFlags(originalMethod) & 3 /* AsyncGenerator */) !== 3 /* AsyncGenerator */;
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
if (capturedSuperProperties.size) {
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
const statements = updated.statements.slice();
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
updated = factory2.updateBlock(updated, statements);
|
|
}
|
|
if (hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(updated, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(updated, asyncSuperHelper);
|
|
}
|
|
}
|
|
}
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
return updated;
|
|
}
|
|
function transformAsyncFunctionBody(node) {
|
|
resumeLexicalEnvironment();
|
|
const original = getOriginalNode(node, isFunctionLike);
|
|
const nodeType = original.type;
|
|
const promiseConstructor = languageVersion < 2 /* ES2015 */ ? getPromiseConstructor(nodeType) : void 0;
|
|
const isArrowFunction2 = node.kind === 216 /* ArrowFunction */;
|
|
const hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 512 /* CaptureArguments */) !== 0;
|
|
const savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames;
|
|
enclosingFunctionParameterNames = /* @__PURE__ */ new Set();
|
|
for (const parameter of node.parameters) {
|
|
recordDeclarationName(parameter, enclosingFunctionParameterNames);
|
|
}
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
if (!isArrowFunction2) {
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
}
|
|
let result;
|
|
if (!isArrowFunction2) {
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.body.statements, statements, false, visitor);
|
|
statements.push(
|
|
factory2.createReturnStatement(
|
|
emitHelpers().createAwaiterHelper(
|
|
inHasLexicalThisContext(),
|
|
hasLexicalArguments,
|
|
promiseConstructor,
|
|
transformAsyncFunctionBodyWorker(node.body, statementOffset)
|
|
)
|
|
)
|
|
);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
if (capturedSuperProperties.size) {
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
}
|
|
}
|
|
const block = factory2.createBlock(statements, true);
|
|
setTextRange(block, node.body);
|
|
if (emitSuperHelpers && hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(block, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(block, asyncSuperHelper);
|
|
}
|
|
}
|
|
result = block;
|
|
} else {
|
|
const expression = emitHelpers().createAwaiterHelper(
|
|
inHasLexicalThisContext(),
|
|
hasLexicalArguments,
|
|
promiseConstructor,
|
|
transformAsyncFunctionBodyWorker(node.body)
|
|
);
|
|
const declarations = endLexicalEnvironment();
|
|
if (some(declarations)) {
|
|
const block = factory2.converters.convertToFunctionBlock(expression);
|
|
result = factory2.updateBlock(block, setTextRange(factory2.createNodeArray(concatenate(declarations, block.statements)), block.statements));
|
|
} else {
|
|
result = expression;
|
|
}
|
|
}
|
|
enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames;
|
|
if (!isArrowFunction2) {
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
}
|
|
return result;
|
|
}
|
|
function transformAsyncFunctionBodyWorker(body, start2) {
|
|
if (isBlock(body)) {
|
|
return factory2.updateBlock(body, visitNodes2(body.statements, asyncBodyVisitor, isStatement, start2));
|
|
} else {
|
|
return factory2.converters.convertToFunctionBlock(visitNode(body, asyncBodyVisitor, isConciseBody));
|
|
}
|
|
}
|
|
function getPromiseConstructor(type) {
|
|
const typeName = type && getEntityNameFromTypeNode(type);
|
|
if (typeName && isEntityName(typeName)) {
|
|
const serializationKind = resolver.getTypeReferenceSerializationKind(typeName);
|
|
if (serializationKind === 1 /* TypeWithConstructSignatureAndValue */ || serializationKind === 0 /* Unknown */) {
|
|
return typeName;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function enableSubstitutionForAsyncMethodsWithSuper() {
|
|
if ((enabledSubstitutions & 1 /* AsyncMethodsWithSuper */) === 0) {
|
|
enabledSubstitutions |= 1 /* AsyncMethodsWithSuper */;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
context.enableEmitNotification(260 /* ClassDeclaration */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(240 /* VariableStatement */);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
|
|
const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
|
|
if (superContainerFlags !== enclosingSuperContainerFlags) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = superContainerFlags;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
} else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */ && enclosingSuperContainerFlags) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
node.name
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return createSuperElementAccessInAsyncMethod(
|
|
node.argumentExpression,
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
const expression = node.expression;
|
|
if (isSuperProperty(expression)) {
|
|
const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression);
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(argumentExpression, "call"),
|
|
void 0,
|
|
[
|
|
factory2.createThis(),
|
|
...node.arguments
|
|
]
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function isSuperContainer(node) {
|
|
const kind = node.kind;
|
|
return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function createSuperElementAccessInAsyncMethod(argumentExpression, location2) {
|
|
if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createCallExpression(
|
|
factory2.createUniqueName("_superIndex", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
"value"
|
|
),
|
|
location2
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createUniqueName("_superIndex", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
}
|
|
}
|
|
function createSuperAccessVariableStatement(factory2, resolver, node, names) {
|
|
const hasBinding = (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) !== 0;
|
|
const accessors = [];
|
|
names.forEach((_, key) => {
|
|
const name = unescapeLeadingUnderscores(key);
|
|
const getterAndSetter = [];
|
|
getterAndSetter.push(factory2.createPropertyAssignment(
|
|
"get",
|
|
factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(
|
|
factory2.createSuper(),
|
|
8 /* NoSubstitution */
|
|
),
|
|
name
|
|
),
|
|
8 /* NoSubstitution */
|
|
)
|
|
)
|
|
));
|
|
if (hasBinding) {
|
|
getterAndSetter.push(
|
|
factory2.createPropertyAssignment(
|
|
"set",
|
|
factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"v",
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)
|
|
],
|
|
void 0,
|
|
void 0,
|
|
factory2.createAssignment(
|
|
setEmitFlags(
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(
|
|
factory2.createSuper(),
|
|
8 /* NoSubstitution */
|
|
),
|
|
name
|
|
),
|
|
8 /* NoSubstitution */
|
|
),
|
|
factory2.createIdentifier("v")
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
accessors.push(
|
|
factory2.createPropertyAssignment(
|
|
name,
|
|
factory2.createObjectLiteralExpression(getterAndSetter)
|
|
)
|
|
);
|
|
});
|
|
return factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("Object"),
|
|
"create"
|
|
),
|
|
void 0,
|
|
[
|
|
factory2.createNull(),
|
|
factory2.createObjectLiteralExpression(accessors, true)
|
|
]
|
|
)
|
|
)
|
|
],
|
|
2 /* Const */
|
|
)
|
|
);
|
|
}
|
|
|
|
// src/compiler/transformers/es2018.ts
|
|
function transformES2018(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let exportedVariableStatement = false;
|
|
let enabledSubstitutions;
|
|
let enclosingFunctionFlags;
|
|
let parametersWithPrecedingObjectRestOrSpread;
|
|
let enclosingSuperContainerFlags = 0;
|
|
let hierarchyFacts = 0;
|
|
let currentSourceFile;
|
|
let taggedTemplateStringDeclarations;
|
|
let capturedSuperProperties;
|
|
let hasSuperElementAccess;
|
|
const substitutedSuperAccessors = [];
|
|
return chainBundle(context, transformSourceFile);
|
|
function affectsSubtree(excludeFacts, includeFacts) {
|
|
return hierarchyFacts !== (hierarchyFacts & ~excludeFacts | includeFacts);
|
|
}
|
|
function enterSubtree(excludeFacts, includeFacts) {
|
|
const ancestorFacts = hierarchyFacts;
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 3 /* AncestorFactsMask */;
|
|
return ancestorFacts;
|
|
}
|
|
function exitSubtree(ancestorFacts) {
|
|
hierarchyFacts = ancestorFacts;
|
|
}
|
|
function recordTaggedTemplateString(temp) {
|
|
taggedTemplateStringDeclarations = append(
|
|
taggedTemplateStringDeclarations,
|
|
factory2.createVariableDeclaration(temp)
|
|
);
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const visited = visitSourceFile(node);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
taggedTemplateStringDeclarations = void 0;
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function visitorWithUnusedExpressionResult(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function visitorNoAsyncModifier(node) {
|
|
if (node.kind === 132 /* AsyncKeyword */) {
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function doWithHierarchyFacts(cb, value, excludeFacts, includeFacts) {
|
|
if (affectsSubtree(excludeFacts, includeFacts)) {
|
|
const ancestorFacts = enterSubtree(excludeFacts, includeFacts);
|
|
const result = cb(value);
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
return cb(value);
|
|
}
|
|
function visitDefault(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitorWorker(node, expressionResultIsUnused2) {
|
|
if ((node.transformFlags & 128 /* ContainsES2018 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 220 /* AwaitExpression */:
|
|
return visitAwaitExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, expressionResultIsUnused2);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node, expressionResultIsUnused2);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 246 /* ForInStatement */:
|
|
return doWithHierarchyFacts(
|
|
visitDefault,
|
|
node,
|
|
0 /* IterationStatementExcludes */,
|
|
2 /* IterationStatementIncludes */
|
|
);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, void 0);
|
|
case 245 /* ForStatement */:
|
|
return doWithHierarchyFacts(
|
|
visitForStatement,
|
|
node,
|
|
0 /* IterationStatementExcludes */,
|
|
2 /* IterationStatementIncludes */
|
|
);
|
|
case 219 /* VoidExpression */:
|
|
return visitVoidExpression(node);
|
|
case 173 /* Constructor */:
|
|
return doWithHierarchyFacts(
|
|
visitConstructorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 171 /* MethodDeclaration */:
|
|
return doWithHierarchyFacts(
|
|
visitMethodDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 174 /* GetAccessor */:
|
|
return doWithHierarchyFacts(
|
|
visitGetAccessorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 175 /* SetAccessor */:
|
|
return doWithHierarchyFacts(
|
|
visitSetAccessorDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 259 /* FunctionDeclaration */:
|
|
return doWithHierarchyFacts(
|
|
visitFunctionDeclaration,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 215 /* FunctionExpression */:
|
|
return doWithHierarchyFacts(
|
|
visitFunctionExpression,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
case 216 /* ArrowFunction */:
|
|
return doWithHierarchyFacts(
|
|
visitArrowFunction,
|
|
node,
|
|
2 /* ArrowFunctionExcludes */,
|
|
0 /* ArrowFunctionIncludes */
|
|
);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, expressionResultIsUnused2);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
if (capturedSuperProperties && isPropertyAccessExpression(node) && node.expression.kind === 106 /* SuperKeyword */) {
|
|
capturedSuperProperties.add(node.name.escapedText);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 209 /* ElementAccessExpression */:
|
|
if (capturedSuperProperties && node.expression.kind === 106 /* SuperKeyword */) {
|
|
hasSuperElementAccess = true;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return doWithHierarchyFacts(
|
|
visitDefault,
|
|
node,
|
|
2 /* ClassOrFunctionExcludes */,
|
|
1 /* ClassOrFunctionIncludes */
|
|
);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitAwaitExpression(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(void 0, emitHelpers().createAwaitHelper(visitNode(node.expression, visitor, isExpression))),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
if (node.asteriskToken) {
|
|
const expression = visitNode(Debug.checkDefined(node.expression), visitor, isExpression);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
emitHelpers().createAwaitHelper(
|
|
factory2.updateYieldExpression(
|
|
node,
|
|
node.asteriskToken,
|
|
setTextRange(
|
|
emitHelpers().createAsyncDelegatorHelper(
|
|
setTextRange(
|
|
emitHelpers().createAsyncValuesHelper(expression),
|
|
expression
|
|
)
|
|
),
|
|
expression
|
|
)
|
|
)
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createYieldExpression(
|
|
void 0,
|
|
createDownlevelAwait(
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */) {
|
|
return factory2.updateReturnStatement(node, createDownlevelAwait(
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
));
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (enclosingFunctionFlags & 2 /* Async */) {
|
|
const statement = unwrapInnermostStatementOfLabel(node);
|
|
if (statement.kind === 247 /* ForOfStatement */ && statement.awaitModifier) {
|
|
return visitForOfStatement(statement, node);
|
|
}
|
|
return factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock), node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function chunkObjectLiteralElements(elements) {
|
|
let chunkObject;
|
|
const objects = [];
|
|
for (const e of elements) {
|
|
if (e.kind === 301 /* SpreadAssignment */) {
|
|
if (chunkObject) {
|
|
objects.push(factory2.createObjectLiteralExpression(chunkObject));
|
|
chunkObject = void 0;
|
|
}
|
|
const target = e.expression;
|
|
objects.push(visitNode(target, visitor, isExpression));
|
|
} else {
|
|
chunkObject = append(chunkObject, e.kind === 299 /* PropertyAssignment */ ? factory2.createPropertyAssignment(e.name, visitNode(e.initializer, visitor, isExpression)) : visitNode(e, visitor, isObjectLiteralElementLike));
|
|
}
|
|
}
|
|
if (chunkObject) {
|
|
objects.push(factory2.createObjectLiteralExpression(chunkObject));
|
|
}
|
|
return objects;
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
const objects = chunkObjectLiteralElements(node.properties);
|
|
if (objects.length && objects[0].kind !== 207 /* ObjectLiteralExpression */) {
|
|
objects.unshift(factory2.createObjectLiteralExpression());
|
|
}
|
|
let expression = objects[0];
|
|
if (objects.length > 1) {
|
|
for (let i = 1; i < objects.length; i++) {
|
|
expression = emitHelpers().createAssignHelper([expression, objects[i]]);
|
|
}
|
|
return expression;
|
|
} else {
|
|
return emitHelpers().createAssignHelper(objects);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitParenthesizedExpression(node, expressionResultIsUnused2) {
|
|
return visitEachChild(node, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, context);
|
|
}
|
|
function visitSourceFile(node) {
|
|
const ancestorFacts = enterSubtree(
|
|
2 /* SourceFileExcludes */,
|
|
isEffectiveStrictModeSourceFile(node, compilerOptions) ? 0 /* StrictModeSourceFileIncludes */ : 1 /* SourceFileIncludes */
|
|
);
|
|
exportedVariableStatement = false;
|
|
const visited = visitEachChild(node, visitor, context);
|
|
const statement = concatenate(visited.statements, taggedTemplateStringDeclarations && [
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(taggedTemplateStringDeclarations)
|
|
)
|
|
]);
|
|
const result = factory2.updateSourceFile(visited, setTextRange(factory2.createNodeArray(statement), node.statements));
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return processTaggedTemplateExpression(
|
|
context,
|
|
node,
|
|
visitor,
|
|
currentSourceFile,
|
|
recordTaggedTemplateString,
|
|
0 /* LiftRestriction */
|
|
);
|
|
}
|
|
function visitBinaryExpression(node, expressionResultIsUnused2) {
|
|
if (isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
!expressionResultIsUnused2
|
|
);
|
|
}
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, visitorWithUnusedExpressionResult, isExpression),
|
|
node.operatorToken,
|
|
visitNode(node.right, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaListExpression(node, expressionResultIsUnused2) {
|
|
if (expressionResultIsUnused2) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
let result;
|
|
for (let i = 0; i < node.elements.length; i++) {
|
|
const element = node.elements[i];
|
|
const visited = visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, isExpression);
|
|
if (result || visited !== element) {
|
|
result || (result = node.elements.slice(0, i));
|
|
result.push(visited);
|
|
}
|
|
}
|
|
const elements = result ? setTextRange(factory2.createNodeArray(result), node.elements) : node.elements;
|
|
return factory2.updateCommaListExpression(node, elements);
|
|
}
|
|
function visitCatchClause(node) {
|
|
if (node.variableDeclaration && isBindingPattern(node.variableDeclaration.name) && node.variableDeclaration.name.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
const name = factory2.getGeneratedNameForNode(node.variableDeclaration.name);
|
|
const updatedDecl = factory2.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, void 0, void 0, name);
|
|
const visitedBindings = flattenDestructuringBinding(updatedDecl, visitor, context, 1 /* ObjectRest */);
|
|
let block = visitNode(node.block, visitor, isBlock);
|
|
if (some(visitedBindings)) {
|
|
block = factory2.updateBlock(block, [
|
|
factory2.createVariableStatement(void 0, visitedBindings),
|
|
...block.statements
|
|
]);
|
|
}
|
|
return factory2.updateCatchClause(
|
|
node,
|
|
factory2.updateVariableDeclaration(node.variableDeclaration, name, void 0, void 0, void 0),
|
|
block
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
const savedExportedVariableStatement = exportedVariableStatement;
|
|
exportedVariableStatement = true;
|
|
const visited = visitEachChild(node, visitor, context);
|
|
exportedVariableStatement = savedExportedVariableStatement;
|
|
return visited;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
if (exportedVariableStatement) {
|
|
const savedExportedVariableStatement = exportedVariableStatement;
|
|
exportedVariableStatement = false;
|
|
const visited = visitVariableDeclarationWorker(node, true);
|
|
exportedVariableStatement = savedExportedVariableStatement;
|
|
return visited;
|
|
}
|
|
return visitVariableDeclarationWorker(node, false);
|
|
}
|
|
function visitVariableDeclarationWorker(node, exportedVariableStatement2) {
|
|
if (isBindingPattern(node.name) && node.name.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return flattenDestructuringBinding(
|
|
node,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
void 0,
|
|
exportedVariableStatement2
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitVoidExpression(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitForOfStatement(node, outermostLabeledStatement) {
|
|
const ancestorFacts = enterSubtree(0 /* IterationStatementExcludes */, 2 /* IterationStatementIncludes */);
|
|
if (node.initializer.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
node = transformForOfStatementWithObjectRest(node);
|
|
}
|
|
const result = node.awaitModifier ? transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) : factory2.restoreEnclosingLabel(visitEachChild(node, visitor, context), outermostLabeledStatement);
|
|
exitSubtree(ancestorFacts);
|
|
return result;
|
|
}
|
|
function transformForOfStatementWithObjectRest(node) {
|
|
const initializerWithoutParens = skipParentheses(node.initializer);
|
|
if (isVariableDeclarationList(initializerWithoutParens) || isAssignmentPattern(initializerWithoutParens)) {
|
|
let bodyLocation;
|
|
let statementsLocation;
|
|
const temp = factory2.createTempVariable(void 0);
|
|
const statements = [createForOfBindingStatement(factory2, initializerWithoutParens, temp)];
|
|
if (isBlock(node.statement)) {
|
|
addRange(statements, node.statement.statements);
|
|
bodyLocation = node.statement;
|
|
statementsLocation = node.statement.statements;
|
|
} else if (node.statement) {
|
|
append(statements, node.statement);
|
|
bodyLocation = node.statement;
|
|
statementsLocation = node.statement;
|
|
}
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
node.awaitModifier,
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
setTextRange(factory2.createVariableDeclaration(temp), node.initializer)
|
|
],
|
|
1 /* Let */
|
|
),
|
|
node.initializer
|
|
),
|
|
node.expression,
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), statementsLocation),
|
|
true
|
|
),
|
|
bodyLocation
|
|
)
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function convertForOfStatementHead(node, boundValue, nonUserCode) {
|
|
const value = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const iteratorValueExpression = factory2.createAssignment(value, boundValue);
|
|
const iteratorValueStatement = factory2.createExpressionStatement(iteratorValueExpression);
|
|
setSourceMapRange(iteratorValueStatement, node.expression);
|
|
const exitNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createFalse());
|
|
const exitNonUserCodeStatement = factory2.createExpressionStatement(exitNonUserCodeExpression);
|
|
setSourceMapRange(exitNonUserCodeStatement, node.expression);
|
|
const enterNonUserCodeExpression = factory2.createAssignment(nonUserCode, factory2.createTrue());
|
|
const enterNonUserCodeStatement = factory2.createExpressionStatement(enterNonUserCodeExpression);
|
|
setSourceMapRange(exitNonUserCodeStatement, node.expression);
|
|
const statements = [];
|
|
const binding = createForOfBindingStatement(factory2, node.initializer, value);
|
|
statements.push(visitNode(binding, visitor, isStatement));
|
|
let bodyLocation;
|
|
let statementsLocation;
|
|
const statement = visitIterationBody(node.statement, visitor, context);
|
|
if (isBlock(statement)) {
|
|
addRange(statements, statement.statements);
|
|
bodyLocation = statement;
|
|
statementsLocation = statement.statements;
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
const body = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
setTextRange(factory2.createNodeArray(statements), statementsLocation),
|
|
true
|
|
),
|
|
bodyLocation
|
|
),
|
|
96 /* NoSourceMap */ | 768 /* NoTokenSourceMaps */
|
|
);
|
|
return factory2.createBlock([
|
|
iteratorValueStatement,
|
|
exitNonUserCodeStatement,
|
|
factory2.createTryStatement(
|
|
body,
|
|
void 0,
|
|
factory2.createBlock([
|
|
enterNonUserCodeStatement
|
|
])
|
|
)
|
|
]);
|
|
}
|
|
function createDownlevelAwait(expression) {
|
|
return enclosingFunctionFlags & 1 /* Generator */ ? factory2.createYieldExpression(void 0, emitHelpers().createAwaitHelper(expression)) : factory2.createAwaitExpression(expression);
|
|
}
|
|
function transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const iterator = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
const result = isIdentifier(expression) ? factory2.getGeneratedNameForNode(iterator) : factory2.createTempVariable(void 0);
|
|
const nonUserCode = factory2.createTempVariable(void 0);
|
|
const done = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const errorRecord = factory2.createUniqueName("e");
|
|
const catchVariable = factory2.getGeneratedNameForNode(errorRecord);
|
|
const returnMethod = factory2.createTempVariable(void 0);
|
|
const callValues = setTextRange(emitHelpers().createAsyncValuesHelper(expression), node.expression);
|
|
const callNext = factory2.createCallExpression(factory2.createPropertyAccessExpression(iterator, "next"), void 0, []);
|
|
const getDone = factory2.createPropertyAccessExpression(result, "done");
|
|
const getValue = factory2.createPropertyAccessExpression(result, "value");
|
|
const callReturn = factory2.createFunctionCallCall(returnMethod, iterator, []);
|
|
hoistVariableDeclaration(errorRecord);
|
|
hoistVariableDeclaration(returnMethod);
|
|
const initializer = ancestorFacts & 2 /* IterationContainer */ ? factory2.inlineExpressions([factory2.createAssignment(errorRecord, factory2.createVoidZero()), callValues]) : callValues;
|
|
const forStatement = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(nonUserCode, void 0, void 0, factory2.createTrue()),
|
|
setTextRange(factory2.createVariableDeclaration(iterator, void 0, void 0, initializer), node.expression),
|
|
factory2.createVariableDeclaration(result)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
factory2.inlineExpressions([
|
|
factory2.createAssignment(result, createDownlevelAwait(callNext)),
|
|
factory2.createAssignment(done, getDone),
|
|
factory2.createLogicalNot(done)
|
|
]),
|
|
void 0,
|
|
convertForOfStatementHead(node, getValue, nonUserCode)
|
|
),
|
|
node
|
|
),
|
|
512 /* NoTokenTrailingSourceMaps */
|
|
);
|
|
setOriginalNode(forStatement, node);
|
|
return factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
factory2.restoreEnclosingLabel(
|
|
forStatement,
|
|
outermostLabeledStatement
|
|
)
|
|
]),
|
|
factory2.createCatchClause(
|
|
factory2.createVariableDeclaration(catchVariable),
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
errorRecord,
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("error", catchVariable)
|
|
])
|
|
)
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalNot(nonUserCode),
|
|
factory2.createLogicalNot(done)
|
|
),
|
|
factory2.createAssignment(
|
|
returnMethod,
|
|
factory2.createPropertyAccessExpression(iterator, "return")
|
|
)
|
|
),
|
|
factory2.createExpressionStatement(createDownlevelAwait(callReturn))
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
errorRecord,
|
|
factory2.createThrowStatement(
|
|
factory2.createPropertyAccessExpression(errorRecord, "error")
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function parameterVisitor(node) {
|
|
Debug.assertNode(node, isParameter);
|
|
return visitParameter(node);
|
|
}
|
|
function visitParameter(node) {
|
|
if (parametersWithPrecedingObjectRestOrSpread == null ? void 0 : parametersWithPrecedingObjectRestOrSpread.has(node)) {
|
|
return factory2.updateParameterDeclaration(
|
|
node,
|
|
void 0,
|
|
node.dotDotDotToken,
|
|
isBindingPattern(node.name) ? factory2.getGeneratedNameForNode(node) : node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
}
|
|
if (node.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
return factory2.updateParameterDeclaration(
|
|
node,
|
|
void 0,
|
|
node.dotDotDotToken,
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function collectParametersWithPrecedingObjectRestOrSpread(node) {
|
|
let parameters;
|
|
for (const parameter of node.parameters) {
|
|
if (parameters) {
|
|
parameters.add(parameter);
|
|
} else if (parameter.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
parameters = /* @__PURE__ */ new Set();
|
|
}
|
|
}
|
|
return parameters;
|
|
}
|
|
function visitConstructorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateConstructorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitGetAccessorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateGetAccessorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitSetAccessorDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateSetAccessorDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateMethodDeclaration(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifierLike) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
visitNode(node.name, visitor, isPropertyName),
|
|
visitNode(void 0, visitor, isToken),
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateFunctionDeclaration(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifier) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateArrowFunction(
|
|
node,
|
|
node.modifiers,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
node.equalsGreaterThanToken,
|
|
transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
const savedEnclosingFunctionFlags = enclosingFunctionFlags;
|
|
const savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread;
|
|
enclosingFunctionFlags = getFunctionFlags(node);
|
|
parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node);
|
|
const updated = factory2.updateFunctionExpression(
|
|
node,
|
|
enclosingFunctionFlags & 1 /* Generator */ ? visitNodes2(node.modifiers, visitorNoAsyncModifier, isModifier) : node.modifiers,
|
|
enclosingFunctionFlags & 2 /* Async */ ? void 0 : node.asteriskToken,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, parameterVisitor, context),
|
|
void 0,
|
|
enclosingFunctionFlags & 2 /* Async */ && enclosingFunctionFlags & 1 /* Generator */ ? transformAsyncGeneratorFunctionBody(node) : transformFunctionBody2(node)
|
|
);
|
|
enclosingFunctionFlags = savedEnclosingFunctionFlags;
|
|
parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread;
|
|
return updated;
|
|
}
|
|
function transformAsyncGeneratorFunctionBody(node) {
|
|
resumeLexicalEnvironment();
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.body.statements, statements, false, visitor);
|
|
appendObjectRestAssignmentsIfNeeded(statements, node);
|
|
const savedCapturedSuperProperties = capturedSuperProperties;
|
|
const savedHasSuperElementAccess = hasSuperElementAccess;
|
|
capturedSuperProperties = /* @__PURE__ */ new Set();
|
|
hasSuperElementAccess = false;
|
|
const returnStatement = factory2.createReturnStatement(
|
|
emitHelpers().createAsyncGeneratorHelper(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
node.name && factory2.getGeneratedNameForNode(node.name),
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.updateBlock(
|
|
node.body,
|
|
visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset)
|
|
)
|
|
),
|
|
!!(hierarchyFacts & 1 /* HasLexicalThis */)
|
|
)
|
|
);
|
|
const emitSuperHelpers = languageVersion >= 2 /* ES2015 */ && resolver.getNodeCheckFlags(node) & (256 /* MethodWithSuperPropertyAssignmentInAsync */ | 128 /* MethodWithSuperPropertyAccessInAsync */);
|
|
if (emitSuperHelpers) {
|
|
enableSubstitutionForAsyncMethodsWithSuper();
|
|
const variableStatement = createSuperAccessVariableStatement(factory2, resolver, node, capturedSuperProperties);
|
|
substitutedSuperAccessors[getNodeId(variableStatement)] = true;
|
|
insertStatementsAfterStandardPrologue(statements, [variableStatement]);
|
|
}
|
|
statements.push(returnStatement);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const block = factory2.updateBlock(node.body, statements);
|
|
if (emitSuperHelpers && hasSuperElementAccess) {
|
|
if (resolver.getNodeCheckFlags(node) & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
addEmitHelper(block, advancedAsyncSuperHelper);
|
|
} else if (resolver.getNodeCheckFlags(node) & 128 /* MethodWithSuperPropertyAccessInAsync */) {
|
|
addEmitHelper(block, asyncSuperHelper);
|
|
}
|
|
}
|
|
capturedSuperProperties = savedCapturedSuperProperties;
|
|
hasSuperElementAccess = savedHasSuperElementAccess;
|
|
return block;
|
|
}
|
|
function transformFunctionBody2(node) {
|
|
var _a2;
|
|
resumeLexicalEnvironment();
|
|
let statementOffset = 0;
|
|
const statements = [];
|
|
const body = (_a2 = visitNode(node.body, visitor, isConciseBody)) != null ? _a2 : factory2.createBlock([]);
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyPrologue(body.statements, statements, false, visitor);
|
|
}
|
|
addRange(statements, appendObjectRestAssignmentsIfNeeded(void 0, node));
|
|
const leadingStatements = endLexicalEnvironment();
|
|
if (statementOffset > 0 || some(statements) || some(leadingStatements)) {
|
|
const block = factory2.converters.convertToFunctionBlock(body, true);
|
|
insertStatementsAfterStandardPrologue(statements, leadingStatements);
|
|
addRange(statements, block.statements.slice(statementOffset));
|
|
return factory2.updateBlock(block, setTextRange(factory2.createNodeArray(statements), block.statements));
|
|
}
|
|
return body;
|
|
}
|
|
function appendObjectRestAssignmentsIfNeeded(statements, node) {
|
|
let containsPrecedingObjectRestOrSpread = false;
|
|
for (const parameter of node.parameters) {
|
|
if (containsPrecedingObjectRestOrSpread) {
|
|
if (isBindingPattern(parameter.name)) {
|
|
if (parameter.name.elements.length > 0) {
|
|
const declarations = flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
);
|
|
if (some(declarations)) {
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
const statement = factory2.createVariableStatement(void 0, declarationList);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.initializer) {
|
|
const name = factory2.getGeneratedNameForNode(parameter);
|
|
const initializer = visitNode(parameter.initializer, visitor, isExpression);
|
|
const assignment = factory2.createAssignment(name, initializer);
|
|
const statement = factory2.createExpressionStatement(assignment);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.initializer) {
|
|
const name = factory2.cloneNode(parameter.name);
|
|
setTextRange(name, parameter.name);
|
|
setEmitFlags(name, 96 /* NoSourceMap */);
|
|
const initializer = visitNode(parameter.initializer, visitor, isExpression);
|
|
addEmitFlags(initializer, 96 /* NoSourceMap */ | 3072 /* NoComments */);
|
|
const assignment = factory2.createAssignment(name, initializer);
|
|
setTextRange(assignment, parameter);
|
|
setEmitFlags(assignment, 3072 /* NoComments */);
|
|
const block = factory2.createBlock([factory2.createExpressionStatement(assignment)]);
|
|
setTextRange(block, parameter);
|
|
setEmitFlags(block, 1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */);
|
|
const typeCheck = factory2.createTypeCheck(factory2.cloneNode(parameter.name), "undefined");
|
|
const statement = factory2.createIfStatement(typeCheck, block);
|
|
startOnNewLine(statement);
|
|
setTextRange(statement, parameter);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2097152 /* CustomPrologue */ | 3072 /* NoComments */);
|
|
statements = append(statements, statement);
|
|
}
|
|
} else if (parameter.transformFlags & 65536 /* ContainsObjectRestOrSpread */) {
|
|
containsPrecedingObjectRestOrSpread = true;
|
|
const declarations = flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
1 /* ObjectRest */,
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
false,
|
|
true
|
|
);
|
|
if (some(declarations)) {
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
const statement = factory2.createVariableStatement(void 0, declarationList);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
statements = append(statements, statement);
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function enableSubstitutionForAsyncMethodsWithSuper() {
|
|
if ((enabledSubstitutions & 1 /* AsyncMethodsWithSuper */) === 0) {
|
|
enabledSubstitutions |= 1 /* AsyncMethodsWithSuper */;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(209 /* ElementAccessExpression */);
|
|
context.enableEmitNotification(260 /* ClassDeclaration */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(240 /* VariableStatement */);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* AsyncMethodsWithSuper */ && isSuperContainer(node)) {
|
|
const superContainerFlags = resolver.getNodeCheckFlags(node) & (128 /* MethodWithSuperPropertyAccessInAsync */ | 256 /* MethodWithSuperPropertyAssignmentInAsync */);
|
|
if (superContainerFlags !== enclosingSuperContainerFlags) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = superContainerFlags;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
} else if (enabledSubstitutions && substitutedSuperAccessors[getNodeId(node)]) {
|
|
const savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
|
|
enclosingSuperContainerFlags = 0;
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags;
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */ && enclosingSuperContainerFlags) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return substitutePropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return substituteElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
node.name
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteElementAccessExpression(node) {
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
return createSuperElementAccessInAsyncMethod(
|
|
node.argumentExpression,
|
|
node
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
const expression = node.expression;
|
|
if (isSuperProperty(expression)) {
|
|
const argumentExpression = isPropertyAccessExpression(expression) ? substitutePropertyAccessExpression(expression) : substituteElementAccessExpression(expression);
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(argumentExpression, "call"),
|
|
void 0,
|
|
[
|
|
factory2.createThis(),
|
|
...node.arguments
|
|
]
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function isSuperContainer(node) {
|
|
const kind = node.kind;
|
|
return kind === 260 /* ClassDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function createSuperElementAccessInAsyncMethod(argumentExpression, location2) {
|
|
if (enclosingSuperContainerFlags & 256 /* MethodWithSuperPropertyAssignmentInAsync */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("_superIndex"),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
"value"
|
|
),
|
|
location2
|
|
);
|
|
} else {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("_superIndex"),
|
|
void 0,
|
|
[argumentExpression]
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2019.ts
|
|
function transformES2019(context) {
|
|
const factory2 = context.factory;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 64 /* ContainsES2019 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitCatchClause(node) {
|
|
if (!node.variableDeclaration) {
|
|
return factory2.updateCatchClause(
|
|
node,
|
|
factory2.createVariableDeclaration(factory2.createTempVariable(void 0)),
|
|
visitNode(node.block, visitor, isBlock)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2020.ts
|
|
function transformES2020(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 32 /* ContainsES2020 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 210 /* CallExpression */: {
|
|
const updated = visitNonOptionalCallExpression(node, false);
|
|
Debug.assertNotNode(updated, isSyntheticReference);
|
|
return updated;
|
|
}
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (isOptionalChain(node)) {
|
|
const updated = visitOptionalExpression(node, false, false);
|
|
Debug.assertNotNode(updated, isSyntheticReference);
|
|
return updated;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 223 /* BinaryExpression */:
|
|
if (node.operatorToken.kind === 60 /* QuestionQuestionToken */) {
|
|
return transformNullishCoalescingExpression(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
case 217 /* DeleteExpression */:
|
|
return visitDeleteExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function flattenChain(chain) {
|
|
Debug.assertNotNode(chain, isNonNullChain);
|
|
const links = [chain];
|
|
while (!chain.questionDotToken && !isTaggedTemplateExpression(chain)) {
|
|
chain = cast(skipPartiallyEmittedExpressions(chain.expression), isOptionalChain);
|
|
Debug.assertNotNode(chain, isNonNullChain);
|
|
links.unshift(chain);
|
|
}
|
|
return { expression: chain.expression, chain: links };
|
|
}
|
|
function visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete) {
|
|
const expression = visitNonOptionalExpression(node.expression, captureThisArg, isDelete);
|
|
if (isSyntheticReference(expression)) {
|
|
return factory2.createSyntheticReferenceExpression(factory2.updateParenthesizedExpression(node, expression.expression), expression.thisArg);
|
|
}
|
|
return factory2.updateParenthesizedExpression(node, expression);
|
|
}
|
|
function visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete) {
|
|
if (isOptionalChain(node)) {
|
|
return visitOptionalExpression(node, captureThisArg, isDelete);
|
|
}
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
Debug.assertNotNode(expression, isSyntheticReference);
|
|
let thisArg;
|
|
if (captureThisArg) {
|
|
if (!isSimpleCopiableExpression(expression)) {
|
|
thisArg = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(thisArg, expression);
|
|
} else {
|
|
thisArg = expression;
|
|
}
|
|
}
|
|
expression = node.kind === 208 /* PropertyAccessExpression */ ? factory2.updatePropertyAccessExpression(node, expression, visitNode(node.name, visitor, isIdentifier)) : factory2.updateElementAccessExpression(node, expression, visitNode(node.argumentExpression, visitor, isExpression));
|
|
return thisArg ? factory2.createSyntheticReferenceExpression(expression, thisArg) : expression;
|
|
}
|
|
function visitNonOptionalCallExpression(node, captureThisArg) {
|
|
if (isOptionalChain(node)) {
|
|
return visitOptionalExpression(node, captureThisArg, false);
|
|
}
|
|
if (isParenthesizedExpression(node.expression) && isOptionalChain(skipParentheses(node.expression))) {
|
|
const expression = visitNonOptionalParenthesizedExpression(node.expression, true, false);
|
|
const args = visitNodes2(node.arguments, visitor, isExpression);
|
|
if (isSyntheticReference(expression)) {
|
|
return setTextRange(factory2.createFunctionCallCall(expression.expression, expression.thisArg, args), node);
|
|
}
|
|
return factory2.updateCallExpression(node, expression, void 0, args);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNonOptionalExpression(node, captureThisArg, isDelete) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete);
|
|
case 210 /* CallExpression */:
|
|
return visitNonOptionalCallExpression(node, captureThisArg);
|
|
default:
|
|
return visitNode(node, visitor, isExpression);
|
|
}
|
|
}
|
|
function visitOptionalExpression(node, captureThisArg, isDelete) {
|
|
const { expression, chain } = flattenChain(node);
|
|
const left = visitNonOptionalExpression(skipPartiallyEmittedExpressions(expression), isCallChain(chain[0]), false);
|
|
let leftThisArg = isSyntheticReference(left) ? left.thisArg : void 0;
|
|
let capturedLeft = isSyntheticReference(left) ? left.expression : left;
|
|
let leftExpression = factory2.restoreOuterExpressions(expression, capturedLeft, 8 /* PartiallyEmittedExpressions */);
|
|
if (!isSimpleCopiableExpression(capturedLeft)) {
|
|
capturedLeft = factory2.createTempVariable(hoistVariableDeclaration);
|
|
leftExpression = factory2.createAssignment(capturedLeft, leftExpression);
|
|
}
|
|
let rightExpression = capturedLeft;
|
|
let thisArg;
|
|
for (let i = 0; i < chain.length; i++) {
|
|
const segment = chain[i];
|
|
switch (segment.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
if (i === chain.length - 1 && captureThisArg) {
|
|
if (!isSimpleCopiableExpression(rightExpression)) {
|
|
thisArg = factory2.createTempVariable(hoistVariableDeclaration);
|
|
rightExpression = factory2.createAssignment(thisArg, rightExpression);
|
|
} else {
|
|
thisArg = rightExpression;
|
|
}
|
|
}
|
|
rightExpression = segment.kind === 208 /* PropertyAccessExpression */ ? factory2.createPropertyAccessExpression(rightExpression, visitNode(segment.name, visitor, isIdentifier)) : factory2.createElementAccessExpression(rightExpression, visitNode(segment.argumentExpression, visitor, isExpression));
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
if (i === 0 && leftThisArg) {
|
|
if (!isGeneratedIdentifier(leftThisArg)) {
|
|
leftThisArg = factory2.cloneNode(leftThisArg);
|
|
addEmitFlags(leftThisArg, 3072 /* NoComments */);
|
|
}
|
|
rightExpression = factory2.createFunctionCallCall(
|
|
rightExpression,
|
|
leftThisArg.kind === 106 /* SuperKeyword */ ? factory2.createThis() : leftThisArg,
|
|
visitNodes2(segment.arguments, visitor, isExpression)
|
|
);
|
|
} else {
|
|
rightExpression = factory2.createCallExpression(
|
|
rightExpression,
|
|
void 0,
|
|
visitNodes2(segment.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
setOriginalNode(rightExpression, segment);
|
|
}
|
|
const target = isDelete ? factory2.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), void 0, factory2.createTrue(), void 0, factory2.createDeleteExpression(rightExpression)) : factory2.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, true), void 0, factory2.createVoidZero(), void 0, rightExpression);
|
|
setTextRange(target, node);
|
|
return thisArg ? factory2.createSyntheticReferenceExpression(target, thisArg) : target;
|
|
}
|
|
function createNotNullCondition(left, right, invert) {
|
|
return factory2.createBinaryExpression(
|
|
factory2.createBinaryExpression(
|
|
left,
|
|
factory2.createToken(invert ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */),
|
|
factory2.createNull()
|
|
),
|
|
factory2.createToken(invert ? 56 /* BarBarToken */ : 55 /* AmpersandAmpersandToken */),
|
|
factory2.createBinaryExpression(
|
|
right,
|
|
factory2.createToken(invert ? 36 /* EqualsEqualsEqualsToken */ : 37 /* ExclamationEqualsEqualsToken */),
|
|
factory2.createVoidZero()
|
|
)
|
|
);
|
|
}
|
|
function transformNullishCoalescingExpression(node) {
|
|
let left = visitNode(node.left, visitor, isExpression);
|
|
let right = left;
|
|
if (!isSimpleCopiableExpression(left)) {
|
|
right = factory2.createTempVariable(hoistVariableDeclaration);
|
|
left = factory2.createAssignment(right, left);
|
|
}
|
|
return setTextRange(factory2.createConditionalExpression(
|
|
createNotNullCondition(left, right),
|
|
void 0,
|
|
right,
|
|
void 0,
|
|
visitNode(node.right, visitor, isExpression)
|
|
), node);
|
|
}
|
|
function visitDeleteExpression(node) {
|
|
return isOptionalChain(skipParentheses(node.expression)) ? setOriginalNode(visitNonOptionalExpression(node.expression, false, true), node) : factory2.updateDeleteExpression(node, visitNode(node.expression, visitor, isExpression));
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2021.ts
|
|
function transformES2021(context) {
|
|
const {
|
|
hoistVariableDeclaration,
|
|
factory: factory2
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 16 /* ContainsES2021 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
const binaryExpression = node;
|
|
if (isLogicalOrCoalescingAssignmentExpression(binaryExpression)) {
|
|
return transformLogicalAssignment(binaryExpression);
|
|
}
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformLogicalAssignment(binaryExpression) {
|
|
const operator = binaryExpression.operatorToken;
|
|
const nonAssignmentOperator = getNonAssignmentOperatorForCompoundAssignment(operator.kind);
|
|
let left = skipParentheses(visitNode(binaryExpression.left, visitor, isLeftHandSideExpression));
|
|
let assignmentTarget = left;
|
|
const right = skipParentheses(visitNode(binaryExpression.right, visitor, isExpression));
|
|
if (isAccessExpression(left)) {
|
|
const propertyAccessTargetSimpleCopiable = isSimpleCopiableExpression(left.expression);
|
|
const propertyAccessTarget = propertyAccessTargetSimpleCopiable ? left.expression : factory2.createTempVariable(hoistVariableDeclaration);
|
|
const propertyAccessTargetAssignment = propertyAccessTargetSimpleCopiable ? left.expression : factory2.createAssignment(
|
|
propertyAccessTarget,
|
|
left.expression
|
|
);
|
|
if (isPropertyAccessExpression(left)) {
|
|
assignmentTarget = factory2.createPropertyAccessExpression(
|
|
propertyAccessTarget,
|
|
left.name
|
|
);
|
|
left = factory2.createPropertyAccessExpression(
|
|
propertyAccessTargetAssignment,
|
|
left.name
|
|
);
|
|
} else {
|
|
const elementAccessArgumentSimpleCopiable = isSimpleCopiableExpression(left.argumentExpression);
|
|
const elementAccessArgument = elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory2.createTempVariable(hoistVariableDeclaration);
|
|
assignmentTarget = factory2.createElementAccessExpression(
|
|
propertyAccessTarget,
|
|
elementAccessArgument
|
|
);
|
|
left = factory2.createElementAccessExpression(
|
|
propertyAccessTargetAssignment,
|
|
elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory2.createAssignment(
|
|
elementAccessArgument,
|
|
left.argumentExpression
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return factory2.createBinaryExpression(
|
|
left,
|
|
nonAssignmentOperator,
|
|
factory2.createParenthesizedExpression(
|
|
factory2.createAssignment(
|
|
assignmentTarget,
|
|
right
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/esnext.ts
|
|
function transformESNext(context) {
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 4 /* ContainsESNext */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/jsx.ts
|
|
function transformJsx(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
let currentSourceFile;
|
|
let currentFileState;
|
|
return chainBundle(context, transformSourceFile);
|
|
function getCurrentFileNameExpression() {
|
|
if (currentFileState.filenameDeclaration) {
|
|
return currentFileState.filenameDeclaration.name;
|
|
}
|
|
const declaration = factory2.createVariableDeclaration(factory2.createUniqueName("_jsxFileName", 16 /* Optimistic */ | 32 /* FileLevel */), void 0, void 0, factory2.createStringLiteral(currentSourceFile.fileName));
|
|
currentFileState.filenameDeclaration = declaration;
|
|
return currentFileState.filenameDeclaration.name;
|
|
}
|
|
function getJsxFactoryCalleePrimitive(isStaticChildren) {
|
|
return compilerOptions.jsx === 5 /* ReactJSXDev */ ? "jsxDEV" : isStaticChildren ? "jsxs" : "jsx";
|
|
}
|
|
function getJsxFactoryCallee(isStaticChildren) {
|
|
const type = getJsxFactoryCalleePrimitive(isStaticChildren);
|
|
return getImplicitImportForName(type);
|
|
}
|
|
function getImplicitJsxFragmentReference() {
|
|
return getImplicitImportForName("Fragment");
|
|
}
|
|
function getImplicitImportForName(name) {
|
|
var _a2, _b;
|
|
const importSource = name === "createElement" ? currentFileState.importSpecifier : getJSXRuntimeImport(currentFileState.importSpecifier, compilerOptions);
|
|
const existing = (_b = (_a2 = currentFileState.utilizedImplicitRuntimeImports) == null ? void 0 : _a2.get(importSource)) == null ? void 0 : _b.get(name);
|
|
if (existing) {
|
|
return existing.name;
|
|
}
|
|
if (!currentFileState.utilizedImplicitRuntimeImports) {
|
|
currentFileState.utilizedImplicitRuntimeImports = /* @__PURE__ */ new Map();
|
|
}
|
|
let specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource);
|
|
if (!specifierSourceImports) {
|
|
specifierSourceImports = /* @__PURE__ */ new Map();
|
|
currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports);
|
|
}
|
|
const generatedName = factory2.createUniqueName(`_${name}`, 16 /* Optimistic */ | 32 /* FileLevel */ | 64 /* AllowNameSubstitution */);
|
|
const specifier = factory2.createImportSpecifier(false, factory2.createIdentifier(name), generatedName);
|
|
generatedName.generatedImportReference = specifier;
|
|
specifierSourceImports.set(name, specifier);
|
|
return generatedName;
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentFileState = {};
|
|
currentFileState.importSpecifier = getJSXImplicitImportBase(compilerOptions, node);
|
|
let visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
let statements = visited.statements;
|
|
if (currentFileState.filenameDeclaration) {
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([currentFileState.filenameDeclaration], 2 /* Const */)));
|
|
}
|
|
if (currentFileState.utilizedImplicitRuntimeImports) {
|
|
for (const [importSource, importSpecifiersMap] of arrayFrom(currentFileState.utilizedImplicitRuntimeImports.entries())) {
|
|
if (isExternalModule(node)) {
|
|
const importStatement = factory2.createImportDeclaration(void 0, factory2.createImportClause(false, void 0, factory2.createNamedImports(arrayFrom(importSpecifiersMap.values()))), factory2.createStringLiteral(importSource), void 0);
|
|
setParentRecursive(importStatement, false);
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), importStatement);
|
|
} else if (isExternalOrCommonJsModule(node)) {
|
|
const requireStatement = factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createObjectBindingPattern(map(arrayFrom(importSpecifiersMap.values()), (s) => factory2.createBindingElement(void 0, s.propertyName, s.name))),
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(factory2.createIdentifier("require"), void 0, [factory2.createStringLiteral(importSource)])
|
|
)
|
|
], 2 /* Const */));
|
|
setParentRecursive(requireStatement, false);
|
|
statements = insertStatementAfterCustomPrologue(statements.slice(), requireStatement);
|
|
} else {
|
|
}
|
|
}
|
|
}
|
|
if (statements !== visited.statements) {
|
|
visited = factory2.updateSourceFile(visited, statements);
|
|
}
|
|
currentFileState = void 0;
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
if (node.transformFlags & 2 /* ContainsJsx */) {
|
|
return visitorWorker(node);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitorWorker(node) {
|
|
switch (node.kind) {
|
|
case 281 /* JsxElement */:
|
|
return visitJsxElement(node, false);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node, false);
|
|
case 285 /* JsxFragment */:
|
|
return visitJsxFragment(node, false);
|
|
case 291 /* JsxExpression */:
|
|
return visitJsxExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformJsxChildToExpression(node) {
|
|
switch (node.kind) {
|
|
case 11 /* JsxText */:
|
|
return visitJsxText(node);
|
|
case 291 /* JsxExpression */:
|
|
return visitJsxExpression(node);
|
|
case 281 /* JsxElement */:
|
|
return visitJsxElement(node, true);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return visitJsxSelfClosingElement(node, true);
|
|
case 285 /* JsxFragment */:
|
|
return visitJsxFragment(node, true);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function hasKeyAfterPropsSpread(node) {
|
|
let spread = false;
|
|
for (const elem of node.attributes.properties) {
|
|
if (isJsxSpreadAttribute(elem)) {
|
|
spread = true;
|
|
} else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function shouldUseCreateElement(node) {
|
|
return currentFileState.importSpecifier === void 0 || hasKeyAfterPropsSpread(node);
|
|
}
|
|
function visitJsxElement(node, isChild) {
|
|
const tagTransform = shouldUseCreateElement(node.openingElement) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
|
|
return tagTransform(node.openingElement, node.children, isChild, node);
|
|
}
|
|
function visitJsxSelfClosingElement(node, isChild) {
|
|
const tagTransform = shouldUseCreateElement(node) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX;
|
|
return tagTransform(node, void 0, isChild, node);
|
|
}
|
|
function visitJsxFragment(node, isChild) {
|
|
const tagTransform = currentFileState.importSpecifier === void 0 ? visitJsxOpeningFragmentCreateElement : visitJsxOpeningFragmentJSX;
|
|
return tagTransform(node.openingFragment, node.children, isChild, node);
|
|
}
|
|
function convertJsxChildrenToChildrenPropObject(children) {
|
|
const prop = convertJsxChildrenToChildrenPropAssignment(children);
|
|
return prop && factory2.createObjectLiteralExpression([prop]);
|
|
}
|
|
function convertJsxChildrenToChildrenPropAssignment(children) {
|
|
const nonWhitespaceChildren = getSemanticJsxChildren(children);
|
|
if (length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
|
|
const result2 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
|
|
return result2 && factory2.createPropertyAssignment("children", result2);
|
|
}
|
|
const result = mapDefined(children, transformJsxChildToExpression);
|
|
return length(result) ? factory2.createPropertyAssignment("children", factory2.createArrayLiteralExpression(result)) : void 0;
|
|
}
|
|
function visitJsxOpeningLikeElementJSX(node, children, isChild, location2) {
|
|
const tagName = getTagName(node);
|
|
const childrenProp = children && children.length ? convertJsxChildrenToChildrenPropAssignment(children) : void 0;
|
|
const keyAttr = find(node.attributes.properties, (p) => !!p.name && isIdentifier(p.name) && p.name.escapedText === "key");
|
|
const attrs = keyAttr ? filter(node.attributes.properties, (p) => p !== keyAttr) : node.attributes.properties;
|
|
const objectProperties = length(attrs) ? transformJsxAttributesToObjectProps(attrs, childrenProp) : factory2.createObjectLiteralExpression(childrenProp ? [childrenProp] : emptyArray);
|
|
return visitJsxOpeningLikeElementOrFragmentJSX(
|
|
tagName,
|
|
objectProperties,
|
|
keyAttr,
|
|
children || emptyArray,
|
|
isChild,
|
|
location2
|
|
);
|
|
}
|
|
function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children, isChild, location2) {
|
|
var _a2;
|
|
const nonWhitespaceChildren = getSemanticJsxChildren(children);
|
|
const isStaticChildren = length(nonWhitespaceChildren) > 1 || !!((_a2 = nonWhitespaceChildren[0]) == null ? void 0 : _a2.dotDotDotToken);
|
|
const args = [tagName, objectProperties];
|
|
if (keyAttr) {
|
|
args.push(transformJsxAttributeInitializer(keyAttr.initializer));
|
|
}
|
|
if (compilerOptions.jsx === 5 /* ReactJSXDev */) {
|
|
const originalFile = getOriginalNode(currentSourceFile);
|
|
if (originalFile && isSourceFile(originalFile)) {
|
|
if (keyAttr === void 0) {
|
|
args.push(factory2.createVoidZero());
|
|
}
|
|
args.push(isStaticChildren ? factory2.createTrue() : factory2.createFalse());
|
|
const lineCol = getLineAndCharacterOfPosition(originalFile, location2.pos);
|
|
args.push(factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("fileName", getCurrentFileNameExpression()),
|
|
factory2.createPropertyAssignment("lineNumber", factory2.createNumericLiteral(lineCol.line + 1)),
|
|
factory2.createPropertyAssignment("columnNumber", factory2.createNumericLiteral(lineCol.character + 1))
|
|
]));
|
|
args.push(factory2.createThis());
|
|
}
|
|
}
|
|
const element = setTextRange(
|
|
factory2.createCallExpression(getJsxFactoryCallee(isStaticChildren), void 0, args),
|
|
location2
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function visitJsxOpeningLikeElementCreateElement(node, children, isChild, location2) {
|
|
const tagName = getTagName(node);
|
|
const attrs = node.attributes.properties;
|
|
const objectProperties = length(attrs) ? transformJsxAttributesToObjectProps(attrs) : factory2.createNull();
|
|
const callee = currentFileState.importSpecifier === void 0 ? createJsxFactoryExpression(
|
|
factory2,
|
|
context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),
|
|
compilerOptions.reactNamespace,
|
|
node
|
|
) : getImplicitImportForName("createElement");
|
|
const element = createExpressionForJsxElement(
|
|
factory2,
|
|
callee,
|
|
tagName,
|
|
objectProperties,
|
|
mapDefined(children, transformJsxChildToExpression),
|
|
location2
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function visitJsxOpeningFragmentJSX(_node, children, isChild, location2) {
|
|
let childrenProps;
|
|
if (children && children.length) {
|
|
const result = convertJsxChildrenToChildrenPropObject(children);
|
|
if (result) {
|
|
childrenProps = result;
|
|
}
|
|
}
|
|
return visitJsxOpeningLikeElementOrFragmentJSX(
|
|
getImplicitJsxFragmentReference(),
|
|
childrenProps || factory2.createObjectLiteralExpression([]),
|
|
void 0,
|
|
children,
|
|
isChild,
|
|
location2
|
|
);
|
|
}
|
|
function visitJsxOpeningFragmentCreateElement(node, children, isChild, location2) {
|
|
const element = createExpressionForJsxFragment(
|
|
factory2,
|
|
context.getEmitResolver().getJsxFactoryEntity(currentSourceFile),
|
|
context.getEmitResolver().getJsxFragmentFactoryEntity(currentSourceFile),
|
|
compilerOptions.reactNamespace,
|
|
mapDefined(children, transformJsxChildToExpression),
|
|
node,
|
|
location2
|
|
);
|
|
if (isChild) {
|
|
startOnNewLine(element);
|
|
}
|
|
return element;
|
|
}
|
|
function transformJsxSpreadAttributeToSpreadAssignment(node) {
|
|
return factory2.createSpreadAssignment(visitNode(node.expression, visitor, isExpression));
|
|
}
|
|
function transformJsxAttributesToObjectProps(attrs, children) {
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
|
|
}
|
|
function transformJsxAttributesToProps(attrs, children) {
|
|
const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
|
|
if (children) {
|
|
props.push(children);
|
|
}
|
|
return props;
|
|
}
|
|
function transformJsxAttributesToExpression(attrs, children) {
|
|
const expressions = flatten(
|
|
spanMap(
|
|
attrs,
|
|
isJsxSpreadAttribute,
|
|
(attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
|
|
)
|
|
);
|
|
if (isJsxSpreadAttribute(attrs[0])) {
|
|
expressions.unshift(factory2.createObjectLiteralExpression());
|
|
}
|
|
if (children) {
|
|
expressions.push(factory2.createObjectLiteralExpression([children]));
|
|
}
|
|
return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
|
|
}
|
|
function transformJsxSpreadAttributeToExpression(node) {
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
function transformJsxAttributeToObjectLiteralElement(node) {
|
|
const name = getAttributeName(node);
|
|
const expression = transformJsxAttributeInitializer(node.initializer);
|
|
return factory2.createPropertyAssignment(name, expression);
|
|
}
|
|
function transformJsxAttributeInitializer(node) {
|
|
if (node === void 0) {
|
|
return factory2.createTrue();
|
|
}
|
|
if (node.kind === 10 /* StringLiteral */) {
|
|
const singleQuote = node.singleQuote !== void 0 ? node.singleQuote : !isStringDoubleQuoted(node, currentSourceFile);
|
|
const literal = factory2.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote);
|
|
return setTextRange(literal, node);
|
|
}
|
|
if (node.kind === 291 /* JsxExpression */) {
|
|
if (node.expression === void 0) {
|
|
return factory2.createTrue();
|
|
}
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
if (isJsxElement(node)) {
|
|
return visitJsxElement(node, false);
|
|
}
|
|
if (isJsxSelfClosingElement(node)) {
|
|
return visitJsxSelfClosingElement(node, false);
|
|
}
|
|
if (isJsxFragment(node)) {
|
|
return visitJsxFragment(node, false);
|
|
}
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
function visitJsxText(node) {
|
|
const fixed = fixupWhitespaceAndDecodeEntities(node.text);
|
|
return fixed === void 0 ? void 0 : factory2.createStringLiteral(fixed);
|
|
}
|
|
function fixupWhitespaceAndDecodeEntities(text) {
|
|
let acc;
|
|
let firstNonWhitespace = 0;
|
|
let lastNonWhitespace = -1;
|
|
for (let i = 0; i < text.length; i++) {
|
|
const c = text.charCodeAt(i);
|
|
if (isLineBreak(c)) {
|
|
if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) {
|
|
acc = addLineOfJsxText(acc, text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1));
|
|
}
|
|
firstNonWhitespace = -1;
|
|
} else if (!isWhiteSpaceSingleLine(c)) {
|
|
lastNonWhitespace = i;
|
|
if (firstNonWhitespace === -1) {
|
|
firstNonWhitespace = i;
|
|
}
|
|
}
|
|
}
|
|
return firstNonWhitespace !== -1 ? addLineOfJsxText(acc, text.substr(firstNonWhitespace)) : acc;
|
|
}
|
|
function addLineOfJsxText(acc, trimmedLine) {
|
|
const decoded = decodeEntities(trimmedLine);
|
|
return acc === void 0 ? decoded : acc + " " + decoded;
|
|
}
|
|
function decodeEntities(text) {
|
|
return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
|
|
if (decimal) {
|
|
return utf16EncodeAsString(parseInt(decimal, 10));
|
|
} else if (hex) {
|
|
return utf16EncodeAsString(parseInt(hex, 16));
|
|
} else {
|
|
const ch = entities.get(word);
|
|
return ch ? utf16EncodeAsString(ch) : match;
|
|
}
|
|
});
|
|
}
|
|
function tryDecodeEntities(text) {
|
|
const decoded = decodeEntities(text);
|
|
return decoded === text ? void 0 : decoded;
|
|
}
|
|
function getTagName(node) {
|
|
if (node.kind === 281 /* JsxElement */) {
|
|
return getTagName(node.openingElement);
|
|
} else {
|
|
const name = node.tagName;
|
|
if (isIdentifier(name) && isIntrinsicJsxName(name.escapedText)) {
|
|
return factory2.createStringLiteral(idText(name));
|
|
} else {
|
|
return createExpressionFromEntityName(factory2, name);
|
|
}
|
|
}
|
|
}
|
|
function getAttributeName(node) {
|
|
const name = node.name;
|
|
const text = idText(name);
|
|
if (/^[A-Za-z_]\w*$/.test(text)) {
|
|
return name;
|
|
} else {
|
|
return factory2.createStringLiteral(text);
|
|
}
|
|
}
|
|
function visitJsxExpression(node) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
return node.dotDotDotToken ? factory2.createSpreadElement(expression) : expression;
|
|
}
|
|
}
|
|
var entities = new Map(getEntries({
|
|
quot: 34,
|
|
amp: 38,
|
|
apos: 39,
|
|
lt: 60,
|
|
gt: 62,
|
|
nbsp: 160,
|
|
iexcl: 161,
|
|
cent: 162,
|
|
pound: 163,
|
|
curren: 164,
|
|
yen: 165,
|
|
brvbar: 166,
|
|
sect: 167,
|
|
uml: 168,
|
|
copy: 169,
|
|
ordf: 170,
|
|
laquo: 171,
|
|
not: 172,
|
|
shy: 173,
|
|
reg: 174,
|
|
macr: 175,
|
|
deg: 176,
|
|
plusmn: 177,
|
|
sup2: 178,
|
|
sup3: 179,
|
|
acute: 180,
|
|
micro: 181,
|
|
para: 182,
|
|
middot: 183,
|
|
cedil: 184,
|
|
sup1: 185,
|
|
ordm: 186,
|
|
raquo: 187,
|
|
frac14: 188,
|
|
frac12: 189,
|
|
frac34: 190,
|
|
iquest: 191,
|
|
Agrave: 192,
|
|
Aacute: 193,
|
|
Acirc: 194,
|
|
Atilde: 195,
|
|
Auml: 196,
|
|
Aring: 197,
|
|
AElig: 198,
|
|
Ccedil: 199,
|
|
Egrave: 200,
|
|
Eacute: 201,
|
|
Ecirc: 202,
|
|
Euml: 203,
|
|
Igrave: 204,
|
|
Iacute: 205,
|
|
Icirc: 206,
|
|
Iuml: 207,
|
|
ETH: 208,
|
|
Ntilde: 209,
|
|
Ograve: 210,
|
|
Oacute: 211,
|
|
Ocirc: 212,
|
|
Otilde: 213,
|
|
Ouml: 214,
|
|
times: 215,
|
|
Oslash: 216,
|
|
Ugrave: 217,
|
|
Uacute: 218,
|
|
Ucirc: 219,
|
|
Uuml: 220,
|
|
Yacute: 221,
|
|
THORN: 222,
|
|
szlig: 223,
|
|
agrave: 224,
|
|
aacute: 225,
|
|
acirc: 226,
|
|
atilde: 227,
|
|
auml: 228,
|
|
aring: 229,
|
|
aelig: 230,
|
|
ccedil: 231,
|
|
egrave: 232,
|
|
eacute: 233,
|
|
ecirc: 234,
|
|
euml: 235,
|
|
igrave: 236,
|
|
iacute: 237,
|
|
icirc: 238,
|
|
iuml: 239,
|
|
eth: 240,
|
|
ntilde: 241,
|
|
ograve: 242,
|
|
oacute: 243,
|
|
ocirc: 244,
|
|
otilde: 245,
|
|
ouml: 246,
|
|
divide: 247,
|
|
oslash: 248,
|
|
ugrave: 249,
|
|
uacute: 250,
|
|
ucirc: 251,
|
|
uuml: 252,
|
|
yacute: 253,
|
|
thorn: 254,
|
|
yuml: 255,
|
|
OElig: 338,
|
|
oelig: 339,
|
|
Scaron: 352,
|
|
scaron: 353,
|
|
Yuml: 376,
|
|
fnof: 402,
|
|
circ: 710,
|
|
tilde: 732,
|
|
Alpha: 913,
|
|
Beta: 914,
|
|
Gamma: 915,
|
|
Delta: 916,
|
|
Epsilon: 917,
|
|
Zeta: 918,
|
|
Eta: 919,
|
|
Theta: 920,
|
|
Iota: 921,
|
|
Kappa: 922,
|
|
Lambda: 923,
|
|
Mu: 924,
|
|
Nu: 925,
|
|
Xi: 926,
|
|
Omicron: 927,
|
|
Pi: 928,
|
|
Rho: 929,
|
|
Sigma: 931,
|
|
Tau: 932,
|
|
Upsilon: 933,
|
|
Phi: 934,
|
|
Chi: 935,
|
|
Psi: 936,
|
|
Omega: 937,
|
|
alpha: 945,
|
|
beta: 946,
|
|
gamma: 947,
|
|
delta: 948,
|
|
epsilon: 949,
|
|
zeta: 950,
|
|
eta: 951,
|
|
theta: 952,
|
|
iota: 953,
|
|
kappa: 954,
|
|
lambda: 955,
|
|
mu: 956,
|
|
nu: 957,
|
|
xi: 958,
|
|
omicron: 959,
|
|
pi: 960,
|
|
rho: 961,
|
|
sigmaf: 962,
|
|
sigma: 963,
|
|
tau: 964,
|
|
upsilon: 965,
|
|
phi: 966,
|
|
chi: 967,
|
|
psi: 968,
|
|
omega: 969,
|
|
thetasym: 977,
|
|
upsih: 978,
|
|
piv: 982,
|
|
ensp: 8194,
|
|
emsp: 8195,
|
|
thinsp: 8201,
|
|
zwnj: 8204,
|
|
zwj: 8205,
|
|
lrm: 8206,
|
|
rlm: 8207,
|
|
ndash: 8211,
|
|
mdash: 8212,
|
|
lsquo: 8216,
|
|
rsquo: 8217,
|
|
sbquo: 8218,
|
|
ldquo: 8220,
|
|
rdquo: 8221,
|
|
bdquo: 8222,
|
|
dagger: 8224,
|
|
Dagger: 8225,
|
|
bull: 8226,
|
|
hellip: 8230,
|
|
permil: 8240,
|
|
prime: 8242,
|
|
Prime: 8243,
|
|
lsaquo: 8249,
|
|
rsaquo: 8250,
|
|
oline: 8254,
|
|
frasl: 8260,
|
|
euro: 8364,
|
|
image: 8465,
|
|
weierp: 8472,
|
|
real: 8476,
|
|
trade: 8482,
|
|
alefsym: 8501,
|
|
larr: 8592,
|
|
uarr: 8593,
|
|
rarr: 8594,
|
|
darr: 8595,
|
|
harr: 8596,
|
|
crarr: 8629,
|
|
lArr: 8656,
|
|
uArr: 8657,
|
|
rArr: 8658,
|
|
dArr: 8659,
|
|
hArr: 8660,
|
|
forall: 8704,
|
|
part: 8706,
|
|
exist: 8707,
|
|
empty: 8709,
|
|
nabla: 8711,
|
|
isin: 8712,
|
|
notin: 8713,
|
|
ni: 8715,
|
|
prod: 8719,
|
|
sum: 8721,
|
|
minus: 8722,
|
|
lowast: 8727,
|
|
radic: 8730,
|
|
prop: 8733,
|
|
infin: 8734,
|
|
ang: 8736,
|
|
and: 8743,
|
|
or: 8744,
|
|
cap: 8745,
|
|
cup: 8746,
|
|
int: 8747,
|
|
there4: 8756,
|
|
sim: 8764,
|
|
cong: 8773,
|
|
asymp: 8776,
|
|
ne: 8800,
|
|
equiv: 8801,
|
|
le: 8804,
|
|
ge: 8805,
|
|
sub: 8834,
|
|
sup: 8835,
|
|
nsub: 8836,
|
|
sube: 8838,
|
|
supe: 8839,
|
|
oplus: 8853,
|
|
otimes: 8855,
|
|
perp: 8869,
|
|
sdot: 8901,
|
|
lceil: 8968,
|
|
rceil: 8969,
|
|
lfloor: 8970,
|
|
rfloor: 8971,
|
|
lang: 9001,
|
|
rang: 9002,
|
|
loz: 9674,
|
|
spades: 9824,
|
|
clubs: 9827,
|
|
hearts: 9829,
|
|
diams: 9830
|
|
}));
|
|
|
|
// src/compiler/transformers/es2016.ts
|
|
function transformES2016(context) {
|
|
const {
|
|
factory: factory2,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
if ((node.transformFlags & 512 /* ContainsES2016 */) === 0) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitBinaryExpression(node) {
|
|
switch (node.operatorToken.kind) {
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
return visitExponentiationAssignmentExpression(node);
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
return visitExponentiationExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitExponentiationAssignmentExpression(node) {
|
|
let target;
|
|
let value;
|
|
const left = visitNode(node.left, visitor, isExpression);
|
|
const right = visitNode(node.right, visitor, isExpression);
|
|
if (isElementAccessExpression(left)) {
|
|
const expressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const argumentExpressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
target = setTextRange(
|
|
factory2.createElementAccessExpression(
|
|
setTextRange(factory2.createAssignment(expressionTemp, left.expression), left.expression),
|
|
setTextRange(factory2.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)
|
|
),
|
|
left
|
|
);
|
|
value = setTextRange(
|
|
factory2.createElementAccessExpression(
|
|
expressionTemp,
|
|
argumentExpressionTemp
|
|
),
|
|
left
|
|
);
|
|
} else if (isPropertyAccessExpression(left)) {
|
|
const expressionTemp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
target = setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
setTextRange(factory2.createAssignment(expressionTemp, left.expression), left.expression),
|
|
left.name
|
|
),
|
|
left
|
|
);
|
|
value = setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
expressionTemp,
|
|
left.name
|
|
),
|
|
left
|
|
);
|
|
} else {
|
|
target = left;
|
|
value = left;
|
|
}
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
target,
|
|
setTextRange(factory2.createGlobalMethodCall("Math", "pow", [value, right]), node)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitExponentiationExpression(node) {
|
|
const left = visitNode(node.left, visitor, isExpression);
|
|
const right = visitNode(node.right, visitor, isExpression);
|
|
return setTextRange(factory2.createGlobalMethodCall("Math", "pow", [left, right]), node);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es2015.ts
|
|
function createSpreadSegment(kind, expression) {
|
|
return { kind, expression };
|
|
}
|
|
function transformES2015(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let currentSourceFile;
|
|
let currentText;
|
|
let hierarchyFacts;
|
|
let taggedTemplateStringDeclarations;
|
|
function recordTaggedTemplateString(temp) {
|
|
taggedTemplateStringDeclarations = append(
|
|
taggedTemplateStringDeclarations,
|
|
factory2.createVariableDeclaration(temp)
|
|
);
|
|
}
|
|
let convertedLoopState;
|
|
let enabledSubstitutions;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentText = node.text;
|
|
const visited = visitSourceFile(node);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
currentSourceFile = void 0;
|
|
currentText = void 0;
|
|
taggedTemplateStringDeclarations = void 0;
|
|
hierarchyFacts = 0 /* None */;
|
|
return visited;
|
|
}
|
|
function enterSubtree(excludeFacts, includeFacts) {
|
|
const ancestorFacts = hierarchyFacts;
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 32767 /* AncestorFactsMask */;
|
|
return ancestorFacts;
|
|
}
|
|
function exitSubtree(ancestorFacts, excludeFacts, includeFacts) {
|
|
hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & -32768 /* SubtreeFactsMask */ | ancestorFacts;
|
|
}
|
|
function isReturnVoidStatementInConstructorWithCapturedSuper(node) {
|
|
return (hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */) !== 0 && node.kind === 250 /* ReturnStatement */ && !node.expression;
|
|
}
|
|
function isOrMayContainReturnCompletion(node) {
|
|
return node.transformFlags & 4194304 /* ContainsHoistedDeclarationOrCompletion */ && (isReturnStatement(node) || isIfStatement(node) || isWithStatement(node) || isSwitchStatement(node) || isCaseBlock(node) || isCaseClause(node) || isDefaultClause(node) || isTryStatement(node) || isCatchClause(node) || isLabeledStatement(node) || isIterationStatement(node, false) || isBlock(node));
|
|
}
|
|
function shouldVisitNode(node) {
|
|
return (node.transformFlags & 1024 /* ContainsES2015 */) !== 0 || convertedLoopState !== void 0 || hierarchyFacts & 8192 /* ConstructorWithCapturedSuper */ && isOrMayContainReturnCompletion(node) || isIterationStatement(node, false) && shouldConvertIterationStatement(node) || (getEmitFlags(node) & 67108864 /* TypeScriptClassWrapper */) !== 0;
|
|
}
|
|
function visitor(node) {
|
|
return shouldVisitNode(node) ? visitorWorker(node, false) : node;
|
|
}
|
|
function visitorWithUnusedExpressionResult(node) {
|
|
return shouldVisitNode(node) ? visitorWorker(node, true) : node;
|
|
}
|
|
function classWrapperStatementVisitor(node) {
|
|
if (shouldVisitNode(node)) {
|
|
const original = getOriginalNode(node);
|
|
if (isPropertyDeclaration(original) && hasStaticModifier(original)) {
|
|
const ancestorFacts = enterSubtree(
|
|
32670 /* StaticInitializerExcludes */,
|
|
16449 /* StaticInitializerIncludes */
|
|
);
|
|
const result = visitorWorker(node, false);
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
return result;
|
|
}
|
|
return visitorWorker(node, false);
|
|
}
|
|
return node;
|
|
}
|
|
function callExpressionVisitor(node) {
|
|
if (node.kind === 106 /* SuperKeyword */) {
|
|
return visitSuperKeyword(true);
|
|
}
|
|
return visitor(node);
|
|
}
|
|
function visitorWorker(node, expressionResultIsUnused2) {
|
|
switch (node.kind) {
|
|
case 124 /* StaticKeyword */:
|
|
return void 0;
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 228 /* ClassExpression */:
|
|
return visitClassExpression(node);
|
|
case 166 /* Parameter */:
|
|
return visitParameter(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 216 /* ArrowFunction */:
|
|
return visitArrowFunction(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return visitVariableDeclaration(node);
|
|
case 79 /* Identifier */:
|
|
return visitIdentifier(node);
|
|
case 258 /* VariableDeclarationList */:
|
|
return visitVariableDeclarationList(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 266 /* CaseBlock */:
|
|
return visitCaseBlock(node);
|
|
case 238 /* Block */:
|
|
return visitBlock(node, false);
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
return visitBreakOrContinueStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return visitDoOrWhileStatement(node, void 0);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, void 0);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node, void 0);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, void 0);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return visitShorthandPropertyAssignment(node);
|
|
case 164 /* ComputedPropertyName */:
|
|
return visitComputedPropertyName(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitArrayLiteralExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, expressionResultIsUnused2);
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node, expressionResultIsUnused2);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node, expressionResultIsUnused2);
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
return visitTemplateLiteral(node);
|
|
case 10 /* StringLiteral */:
|
|
return visitStringLiteral(node);
|
|
case 8 /* NumericLiteral */:
|
|
return visitNumericLiteral(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return visitTaggedTemplateExpression(node);
|
|
case 225 /* TemplateExpression */:
|
|
return visitTemplateExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 227 /* SpreadElement */:
|
|
return visitSpreadElement(node);
|
|
case 106 /* SuperKeyword */:
|
|
return visitSuperKeyword(false);
|
|
case 108 /* ThisKeyword */:
|
|
return visitThisKeyword(node);
|
|
case 233 /* MetaProperty */:
|
|
return visitMetaProperty(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return visitMethodDeclaration(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return visitAccessorDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
case 219 /* VoidExpression */:
|
|
return visitVoidExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitSourceFile(node) {
|
|
const ancestorFacts = enterSubtree(8064 /* SourceFileExcludes */, 64 /* SourceFileIncludes */);
|
|
const prologue = [];
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const statementOffset = factory2.copyPrologue(node.statements, prologue, false, visitor);
|
|
addRange(statements, visitNodes2(node.statements, visitor, isStatement, statementOffset));
|
|
if (taggedTemplateStringDeclarations) {
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(taggedTemplateStringDeclarations)
|
|
)
|
|
);
|
|
}
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureThisForNodeIfNeeded(prologue, node);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(factory2.createNodeArray(concatenate(prologue, statements)), node.statements)
|
|
);
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
if (convertedLoopState !== void 0) {
|
|
const savedAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
|
|
convertedLoopState.allowedNonLabeledJumps |= 2 /* Break */;
|
|
const result = visitEachChild(node, visitor, context);
|
|
convertedLoopState.allowedNonLabeledJumps = savedAllowedNonLabeledJumps;
|
|
return result;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCaseBlock(node) {
|
|
const ancestorFacts = enterSubtree(7104 /* BlockScopeExcludes */, 0 /* BlockScopeIncludes */);
|
|
const updated = visitEachChild(node, visitor, context);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function returnCapturedThis(node) {
|
|
return setOriginalNode(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)), node);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
if (convertedLoopState) {
|
|
convertedLoopState.nonLocalJumps |= 8 /* Return */;
|
|
if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
|
|
node = returnCapturedThis(node);
|
|
}
|
|
return factory2.createReturnStatement(
|
|
factory2.createObjectLiteralExpression(
|
|
[
|
|
factory2.createPropertyAssignment(
|
|
factory2.createIdentifier("value"),
|
|
node.expression ? visitNode(node.expression, visitor, isExpression) : factory2.createVoidZero()
|
|
)
|
|
]
|
|
)
|
|
);
|
|
} else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) {
|
|
return returnCapturedThis(node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitThisKeyword(node) {
|
|
if (hierarchyFacts & 2 /* ArrowFunction */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
|
|
hierarchyFacts |= 65536 /* CapturedLexicalThis */;
|
|
}
|
|
if (convertedLoopState) {
|
|
if (hierarchyFacts & 2 /* ArrowFunction */) {
|
|
convertedLoopState.containsLexicalThis = true;
|
|
return node;
|
|
}
|
|
return convertedLoopState.thisName || (convertedLoopState.thisName = factory2.createUniqueName("this"));
|
|
}
|
|
return node;
|
|
}
|
|
function visitVoidExpression(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitIdentifier(node) {
|
|
if (convertedLoopState) {
|
|
if (resolver.isArgumentsLocalBinding(node)) {
|
|
return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory2.createUniqueName("arguments"));
|
|
}
|
|
}
|
|
if (node.hasExtendedUnicodeEscape) {
|
|
return setOriginalNode(setTextRange(
|
|
factory2.createIdentifier(unescapeLeadingUnderscores(node.escapedText)),
|
|
node
|
|
), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitBreakOrContinueStatement(node) {
|
|
if (convertedLoopState) {
|
|
const jump = node.kind === 249 /* BreakStatement */ ? 2 /* Break */ : 4 /* Continue */;
|
|
const canUseBreakOrContinue = node.label && convertedLoopState.labels && convertedLoopState.labels.get(idText(node.label)) || !node.label && convertedLoopState.allowedNonLabeledJumps & jump;
|
|
if (!canUseBreakOrContinue) {
|
|
let labelMarker;
|
|
const label = node.label;
|
|
if (!label) {
|
|
if (node.kind === 249 /* BreakStatement */) {
|
|
convertedLoopState.nonLocalJumps |= 2 /* Break */;
|
|
labelMarker = "break";
|
|
} else {
|
|
convertedLoopState.nonLocalJumps |= 4 /* Continue */;
|
|
labelMarker = "continue";
|
|
}
|
|
} else {
|
|
if (node.kind === 249 /* BreakStatement */) {
|
|
labelMarker = `break-${label.escapedText}`;
|
|
setLabeledJump(convertedLoopState, true, idText(label), labelMarker);
|
|
} else {
|
|
labelMarker = `continue-${label.escapedText}`;
|
|
setLabeledJump(convertedLoopState, false, idText(label), labelMarker);
|
|
}
|
|
}
|
|
let returnExpression = factory2.createStringLiteral(labelMarker);
|
|
if (convertedLoopState.loopOutParameters.length) {
|
|
const outParams = convertedLoopState.loopOutParameters;
|
|
let expr;
|
|
for (let i = 0; i < outParams.length; i++) {
|
|
const copyExpr = copyOutParameter(outParams[i], 1 /* ToOutParameter */);
|
|
if (i === 0) {
|
|
expr = copyExpr;
|
|
} else {
|
|
expr = factory2.createBinaryExpression(expr, 27 /* CommaToken */, copyExpr);
|
|
}
|
|
}
|
|
returnExpression = factory2.createBinaryExpression(expr, 27 /* CommaToken */, returnExpression);
|
|
}
|
|
return factory2.createReturnStatement(returnExpression);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
const variable = factory2.createVariableDeclaration(
|
|
factory2.getLocalName(node, true),
|
|
void 0,
|
|
void 0,
|
|
transformClassLikeDeclarationToExpression(node)
|
|
);
|
|
setOriginalNode(variable, node);
|
|
const statements = [];
|
|
const statement = factory2.createVariableStatement(void 0, factory2.createVariableDeclarationList([variable]));
|
|
setOriginalNode(statement, node);
|
|
setTextRange(statement, node);
|
|
startOnNewLine(statement);
|
|
statements.push(statement);
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
const exportStatement = hasSyntacticModifier(node, 1024 /* Default */) ? factory2.createExportDefault(factory2.getLocalName(node)) : factory2.createExternalModuleExport(factory2.getLocalName(node));
|
|
setOriginalNode(exportStatement, statement);
|
|
statements.push(exportStatement);
|
|
}
|
|
const emitFlags = getEmitFlags(node);
|
|
if ((emitFlags & 8388608 /* HasEndOfDeclarationMarker */) === 0) {
|
|
statements.push(factory2.createEndOfDeclarationMarker(node));
|
|
setEmitFlags(statement, emitFlags | 8388608 /* HasEndOfDeclarationMarker */);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassExpression(node) {
|
|
return transformClassLikeDeclarationToExpression(node);
|
|
}
|
|
function transformClassLikeDeclarationToExpression(node) {
|
|
if (node.name) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const extendsClauseElement = getClassExtendsHeritageElement(node);
|
|
const classFunction = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
extendsClauseElement ? [factory2.createParameterDeclaration(void 0, void 0, factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */))] : [],
|
|
void 0,
|
|
transformClassBody(node, extendsClauseElement)
|
|
);
|
|
setEmitFlags(classFunction, getEmitFlags(node) & 131072 /* Indented */ | 1048576 /* ReuseTempVariableScope */);
|
|
const inner = factory2.createPartiallyEmittedExpression(classFunction);
|
|
setTextRangeEnd(inner, node.end);
|
|
setEmitFlags(inner, 3072 /* NoComments */);
|
|
const outer = factory2.createPartiallyEmittedExpression(inner);
|
|
setTextRangeEnd(outer, skipTrivia(currentText, node.pos));
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const result = factory2.createParenthesizedExpression(
|
|
factory2.createCallExpression(
|
|
outer,
|
|
void 0,
|
|
extendsClauseElement ? [visitNode(extendsClauseElement.expression, visitor, isExpression)] : []
|
|
)
|
|
);
|
|
addSyntheticLeadingComment(result, 3 /* MultiLineCommentTrivia */, "* @class ");
|
|
return result;
|
|
}
|
|
function transformClassBody(node, extendsClauseElement) {
|
|
const statements = [];
|
|
const name = factory2.getInternalName(node);
|
|
const constructorLikeName = isIdentifierANonContextualKeyword(name) ? factory2.getGeneratedNameForNode(name) : name;
|
|
startLexicalEnvironment();
|
|
addExtendsHelperIfNeeded(statements, node, extendsClauseElement);
|
|
addConstructor(statements, node, constructorLikeName, extendsClauseElement);
|
|
addClassMembers(statements, node);
|
|
const closingBraceLocation = createTokenRange(skipTrivia(currentText, node.members.end), 19 /* CloseBraceToken */);
|
|
const outer = factory2.createPartiallyEmittedExpression(constructorLikeName);
|
|
setTextRangeEnd(outer, closingBraceLocation.end);
|
|
setEmitFlags(outer, 3072 /* NoComments */);
|
|
const statement = factory2.createReturnStatement(outer);
|
|
setTextRangePos(statement, closingBraceLocation.pos);
|
|
setEmitFlags(statement, 3072 /* NoComments */ | 768 /* NoTokenSourceMaps */);
|
|
statements.push(statement);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), node.members), true);
|
|
setEmitFlags(block, 3072 /* NoComments */);
|
|
return block;
|
|
}
|
|
function addExtendsHelperIfNeeded(statements, node, extendsClauseElement) {
|
|
if (extendsClauseElement) {
|
|
statements.push(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createExtendsHelper(factory2.getInternalName(node))
|
|
),
|
|
extendsClauseElement
|
|
)
|
|
);
|
|
}
|
|
}
|
|
function addConstructor(statements, node, name, extendsClauseElement) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32662 /* ConstructorExcludes */, 73 /* ConstructorIncludes */);
|
|
const constructor = getFirstConstructorWithBody(node);
|
|
const hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== void 0);
|
|
const constructorFunction = factory2.createFunctionDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
transformConstructorParameters(constructor, hasSynthesizedSuper),
|
|
void 0,
|
|
transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)
|
|
);
|
|
setTextRange(constructorFunction, constructor || node);
|
|
if (extendsClauseElement) {
|
|
setEmitFlags(constructorFunction, 16 /* CapturesThis */);
|
|
}
|
|
statements.push(constructorFunction);
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
}
|
|
function transformConstructorParameters(constructor, hasSynthesizedSuper) {
|
|
return visitParameterList(constructor && !hasSynthesizedSuper ? constructor.parameters : void 0, visitor, context) || [];
|
|
}
|
|
function createDefaultConstructorBody(node, isDerivedClass) {
|
|
const statements = [];
|
|
resumeLexicalEnvironment();
|
|
factory2.mergeLexicalEnvironment(statements, endLexicalEnvironment());
|
|
if (isDerivedClass) {
|
|
statements.push(factory2.createReturnStatement(createDefaultSuperCallOrThis()));
|
|
}
|
|
const statementsArray = factory2.createNodeArray(statements);
|
|
setTextRange(statementsArray, node.members);
|
|
const block = factory2.createBlock(statementsArray, true);
|
|
setTextRange(block, node);
|
|
setEmitFlags(block, 3072 /* NoComments */);
|
|
return block;
|
|
}
|
|
function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) {
|
|
const isDerivedClass = !!extendsClauseElement && skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* NullKeyword */;
|
|
if (!constructor)
|
|
return createDefaultConstructorBody(node, isDerivedClass);
|
|
const prologue = [];
|
|
const statements = [];
|
|
resumeLexicalEnvironment();
|
|
const existingPrologue = takeWhile(constructor.body.statements, isPrologueDirective);
|
|
const { superCall, superStatementIndex } = findSuperCallAndStatementIndex(constructor.body.statements, existingPrologue);
|
|
const postSuperStatementsStart = superStatementIndex === -1 ? existingPrologue.length : superStatementIndex + 1;
|
|
let statementOffset = postSuperStatementsStart;
|
|
if (!hasSynthesizedSuper)
|
|
statementOffset = factory2.copyStandardPrologue(constructor.body.statements, prologue, statementOffset, false);
|
|
if (!hasSynthesizedSuper)
|
|
statementOffset = factory2.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor, void 0);
|
|
let superCallExpression;
|
|
if (hasSynthesizedSuper) {
|
|
superCallExpression = createDefaultSuperCallOrThis();
|
|
} else if (superCall) {
|
|
superCallExpression = visitSuperCallInBody(superCall);
|
|
}
|
|
if (superCallExpression) {
|
|
hierarchyFacts |= 8192 /* ConstructorWithCapturedSuper */;
|
|
}
|
|
addDefaultValueAssignmentsIfNeeded2(prologue, constructor);
|
|
addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper);
|
|
addRange(statements, visitNodes2(constructor.body.statements, visitor, isStatement, statementOffset));
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureNewTargetIfNeeded(prologue, constructor, false);
|
|
if (isDerivedClass || superCallExpression) {
|
|
if (superCallExpression && postSuperStatementsStart === constructor.body.statements.length && !(constructor.body.transformFlags & 16384 /* ContainsLexicalThis */)) {
|
|
const superCall2 = cast(cast(superCallExpression, isBinaryExpression).left, isCallExpression);
|
|
const returnStatement = factory2.createReturnStatement(superCallExpression);
|
|
setCommentRange(returnStatement, getCommentRange(superCall2));
|
|
setEmitFlags(superCall2, 3072 /* NoComments */);
|
|
statements.push(returnStatement);
|
|
} else {
|
|
if (superStatementIndex <= existingPrologue.length) {
|
|
insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis());
|
|
} else {
|
|
insertCaptureThisForNode(prologue, constructor, createActualThis());
|
|
if (superCallExpression) {
|
|
insertSuperThisCaptureThisForNode(statements, superCallExpression);
|
|
}
|
|
}
|
|
if (!isSufficientlyCoveredByReturnStatements(constructor.body)) {
|
|
statements.push(factory2.createReturnStatement(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */)));
|
|
}
|
|
}
|
|
} else {
|
|
insertCaptureThisForNodeIfNeeded(prologue, constructor);
|
|
}
|
|
const body = factory2.createBlock(
|
|
setTextRange(
|
|
factory2.createNodeArray(
|
|
[
|
|
...existingPrologue,
|
|
...prologue,
|
|
...superStatementIndex <= existingPrologue.length ? emptyArray : visitNodes2(constructor.body.statements, visitor, isStatement, existingPrologue.length, superStatementIndex - existingPrologue.length),
|
|
...statements
|
|
]
|
|
),
|
|
constructor.body.statements
|
|
),
|
|
true
|
|
);
|
|
setTextRange(body, constructor.body);
|
|
return body;
|
|
}
|
|
function findSuperCallAndStatementIndex(originalBodyStatements, existingPrologue) {
|
|
for (let i = existingPrologue.length; i < originalBodyStatements.length; i += 1) {
|
|
const superCall = getSuperCallFromStatement(originalBodyStatements[i]);
|
|
if (superCall) {
|
|
return {
|
|
superCall,
|
|
superStatementIndex: i
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
superStatementIndex: -1
|
|
};
|
|
}
|
|
function isSufficientlyCoveredByReturnStatements(statement) {
|
|
if (statement.kind === 250 /* ReturnStatement */) {
|
|
return true;
|
|
} else if (statement.kind === 242 /* IfStatement */) {
|
|
const ifStatement = statement;
|
|
if (ifStatement.elseStatement) {
|
|
return isSufficientlyCoveredByReturnStatements(ifStatement.thenStatement) && isSufficientlyCoveredByReturnStatements(ifStatement.elseStatement);
|
|
}
|
|
} else if (statement.kind === 238 /* Block */) {
|
|
const lastStatement = lastOrUndefined(statement.statements);
|
|
if (lastStatement && isSufficientlyCoveredByReturnStatements(lastStatement)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function createActualThis() {
|
|
return setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */);
|
|
}
|
|
function createDefaultSuperCallOrThis() {
|
|
return factory2.createLogicalOr(
|
|
factory2.createLogicalAnd(
|
|
factory2.createStrictInequality(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
factory2.createNull()
|
|
),
|
|
factory2.createFunctionApplyCall(
|
|
factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
createActualThis(),
|
|
factory2.createIdentifier("arguments")
|
|
)
|
|
),
|
|
createActualThis()
|
|
);
|
|
}
|
|
function visitParameter(node) {
|
|
if (node.dotDotDotToken) {
|
|
return void 0;
|
|
} else if (isBindingPattern(node.name)) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else if (node.initializer) {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function hasDefaultValueOrBindingPattern(node) {
|
|
return node.initializer !== void 0 || isBindingPattern(node.name);
|
|
}
|
|
function addDefaultValueAssignmentsIfNeeded2(statements, node) {
|
|
if (!some(node.parameters, hasDefaultValueOrBindingPattern)) {
|
|
return false;
|
|
}
|
|
let added = false;
|
|
for (const parameter of node.parameters) {
|
|
const { name, initializer, dotDotDotToken } = parameter;
|
|
if (dotDotDotToken) {
|
|
continue;
|
|
}
|
|
if (isBindingPattern(name)) {
|
|
added = insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) || added;
|
|
} else if (initializer) {
|
|
insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer);
|
|
added = true;
|
|
}
|
|
}
|
|
return added;
|
|
}
|
|
function insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) {
|
|
if (name.elements.length > 0) {
|
|
insertStatementAfterCustomPrologue(
|
|
statements,
|
|
setEmitFlags(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
flattenDestructuringBinding(
|
|
parameter,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
factory2.getGeneratedNameForNode(parameter)
|
|
)
|
|
)
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
return true;
|
|
} else if (initializer) {
|
|
insertStatementAfterCustomPrologue(
|
|
statements,
|
|
setEmitFlags(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.getGeneratedNameForNode(parameter),
|
|
visitNode(initializer, visitor, isExpression)
|
|
)
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer) {
|
|
initializer = visitNode(initializer, visitor, isExpression);
|
|
const statement = factory2.createIfStatement(
|
|
factory2.createTypeCheck(factory2.cloneNode(name), "undefined"),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createAssignment(
|
|
setEmitFlags(setParent(setTextRange(factory2.cloneNode(name), name), name.parent), 96 /* NoSourceMap */),
|
|
setEmitFlags(initializer, 96 /* NoSourceMap */ | getEmitFlags(initializer) | 3072 /* NoComments */)
|
|
),
|
|
parameter
|
|
),
|
|
3072 /* NoComments */
|
|
)
|
|
)
|
|
]),
|
|
parameter
|
|
),
|
|
1 /* SingleLine */ | 64 /* NoTrailingSourceMap */ | 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */
|
|
)
|
|
);
|
|
startOnNewLine(statement);
|
|
setTextRange(statement, parameter);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2097152 /* CustomPrologue */ | 3072 /* NoComments */);
|
|
insertStatementAfterCustomPrologue(statements, statement);
|
|
}
|
|
function shouldAddRestParameter(node, inConstructorWithSynthesizedSuper) {
|
|
return !!(node && node.dotDotDotToken && !inConstructorWithSynthesizedSuper);
|
|
}
|
|
function addRestParameterIfNeeded(statements, node, inConstructorWithSynthesizedSuper) {
|
|
const prologueStatements = [];
|
|
const parameter = lastOrUndefined(node.parameters);
|
|
if (!shouldAddRestParameter(parameter, inConstructorWithSynthesizedSuper)) {
|
|
return false;
|
|
}
|
|
const declarationName = parameter.name.kind === 79 /* Identifier */ ? setParent(setTextRange(factory2.cloneNode(parameter.name), parameter.name), parameter.name.parent) : factory2.createTempVariable(void 0);
|
|
setEmitFlags(declarationName, 96 /* NoSourceMap */);
|
|
const expressionName = parameter.name.kind === 79 /* Identifier */ ? factory2.cloneNode(parameter.name) : declarationName;
|
|
const restIndex = node.parameters.length - 1;
|
|
const temp = factory2.createLoopVariable();
|
|
prologueStatements.push(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
declarationName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createArrayLiteralExpression([])
|
|
)
|
|
])
|
|
),
|
|
parameter
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
const forStatement = factory2.createForStatement(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(temp, void 0, void 0, factory2.createNumericLiteral(restIndex))
|
|
]),
|
|
parameter
|
|
),
|
|
setTextRange(
|
|
factory2.createLessThan(
|
|
temp,
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("arguments"), "length")
|
|
),
|
|
parameter
|
|
),
|
|
setTextRange(factory2.createPostfixIncrement(temp), parameter),
|
|
factory2.createBlock([
|
|
startOnNewLine(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createElementAccessExpression(
|
|
expressionName,
|
|
restIndex === 0 ? temp : factory2.createSubtract(temp, factory2.createNumericLiteral(restIndex))
|
|
),
|
|
factory2.createElementAccessExpression(factory2.createIdentifier("arguments"), temp)
|
|
)
|
|
),
|
|
parameter
|
|
)
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(forStatement, 2097152 /* CustomPrologue */);
|
|
startOnNewLine(forStatement);
|
|
prologueStatements.push(forStatement);
|
|
if (parameter.name.kind !== 79 /* Identifier */) {
|
|
prologueStatements.push(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
flattenDestructuringBinding(parameter, visitor, context, 0 /* All */, expressionName)
|
|
)
|
|
),
|
|
parameter
|
|
),
|
|
2097152 /* CustomPrologue */
|
|
)
|
|
);
|
|
}
|
|
insertStatementsAfterCustomPrologue(statements, prologueStatements);
|
|
return true;
|
|
}
|
|
function insertCaptureThisForNodeIfNeeded(statements, node) {
|
|
if (hierarchyFacts & 65536 /* CapturedLexicalThis */ && node.kind !== 216 /* ArrowFunction */) {
|
|
insertCaptureThisForNode(statements, node, factory2.createThis());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function insertSuperThisCaptureThisForNode(statements, superExpression) {
|
|
enableSubstitutionsForCapturedThis();
|
|
const assignSuperExpression = factory2.createExpressionStatement(
|
|
factory2.createBinaryExpression(
|
|
factory2.createThis(),
|
|
63 /* EqualsToken */,
|
|
superExpression
|
|
)
|
|
);
|
|
insertStatementAfterCustomPrologue(statements, assignSuperExpression);
|
|
setCommentRange(assignSuperExpression, getOriginalNode(superExpression).parent);
|
|
}
|
|
function insertCaptureThisForNode(statements, node, initializer) {
|
|
enableSubstitutionsForCapturedThis();
|
|
const captureThisStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
initializer
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(captureThisStatement, 3072 /* NoComments */ | 2097152 /* CustomPrologue */);
|
|
setSourceMapRange(captureThisStatement, node);
|
|
insertStatementAfterCustomPrologue(statements, captureThisStatement);
|
|
}
|
|
function insertCaptureNewTargetIfNeeded(statements, node, copyOnWrite) {
|
|
if (hierarchyFacts & 32768 /* NewTarget */) {
|
|
let newTarget;
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
return statements;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
newTarget = factory2.createVoidZero();
|
|
break;
|
|
case 173 /* Constructor */:
|
|
newTarget = factory2.createPropertyAccessExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
"constructor"
|
|
);
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
newTarget = factory2.createConditionalExpression(
|
|
factory2.createLogicalAnd(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
factory2.createBinaryExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
102 /* InstanceOfKeyword */,
|
|
factory2.getLocalName(node)
|
|
)
|
|
),
|
|
void 0,
|
|
factory2.createPropertyAccessExpression(
|
|
setEmitFlags(factory2.createThis(), 8 /* NoSubstitution */),
|
|
"constructor"
|
|
),
|
|
void 0,
|
|
factory2.createVoidZero()
|
|
);
|
|
break;
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
const captureNewTargetStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
factory2.createUniqueName("_newTarget", 16 /* Optimistic */ | 32 /* FileLevel */),
|
|
void 0,
|
|
void 0,
|
|
newTarget
|
|
)
|
|
])
|
|
);
|
|
setEmitFlags(captureNewTargetStatement, 3072 /* NoComments */ | 2097152 /* CustomPrologue */);
|
|
if (copyOnWrite) {
|
|
statements = statements.slice();
|
|
}
|
|
insertStatementAfterCustomPrologue(statements, captureNewTargetStatement);
|
|
}
|
|
return statements;
|
|
}
|
|
function addClassMembers(statements, node) {
|
|
for (const member of node.members) {
|
|
switch (member.kind) {
|
|
case 237 /* SemicolonClassElement */:
|
|
statements.push(transformSemicolonClassElementToStatement(member));
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
statements.push(transformClassMethodDeclarationToStatement(getClassMemberPrefix(node, member), member, node));
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const accessors = getAllAccessorDeclarations(node.members, member);
|
|
if (member === accessors.firstAccessor) {
|
|
statements.push(transformAccessorsToStatement(getClassMemberPrefix(node, member), accessors, node));
|
|
}
|
|
break;
|
|
case 173 /* Constructor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(member, currentSourceFile && currentSourceFile.fileName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function transformSemicolonClassElementToStatement(member) {
|
|
return setTextRange(factory2.createEmptyStatement(), member);
|
|
}
|
|
function transformClassMethodDeclarationToStatement(receiver, member, container) {
|
|
const commentRange = getCommentRange(member);
|
|
const sourceMapRange = getSourceMapRange(member);
|
|
const memberFunction = transformFunctionLikeToExpression(member, member, void 0, container);
|
|
const propertyName = visitNode(member.name, visitor, isPropertyName);
|
|
let e;
|
|
if (!isPrivateIdentifier(propertyName) && getUseDefineForClassFields(context.getCompilerOptions())) {
|
|
const name = isComputedPropertyName(propertyName) ? propertyName.expression : isIdentifier(propertyName) ? factory2.createStringLiteral(unescapeLeadingUnderscores(propertyName.escapedText)) : propertyName;
|
|
e = factory2.createObjectDefinePropertyCall(receiver, name, factory2.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true }));
|
|
} else {
|
|
const memberName = createMemberAccessForPropertyName(factory2, receiver, propertyName, member.name);
|
|
e = factory2.createAssignment(memberName, memberFunction);
|
|
}
|
|
setEmitFlags(memberFunction, 3072 /* NoComments */);
|
|
setSourceMapRange(memberFunction, sourceMapRange);
|
|
const statement = setTextRange(factory2.createExpressionStatement(e), member);
|
|
setOriginalNode(statement, member);
|
|
setCommentRange(statement, commentRange);
|
|
setEmitFlags(statement, 96 /* NoSourceMap */);
|
|
return statement;
|
|
}
|
|
function transformAccessorsToStatement(receiver, accessors, container) {
|
|
const statement = factory2.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, false));
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
setSourceMapRange(statement, getSourceMapRange(accessors.firstAccessor));
|
|
return statement;
|
|
}
|
|
function transformAccessorsToExpression(receiver, { firstAccessor, getAccessor, setAccessor }, container, startsOnNewLine) {
|
|
const target = setParent(setTextRange(factory2.cloneNode(receiver), receiver), receiver.parent);
|
|
setEmitFlags(target, 3072 /* NoComments */ | 64 /* NoTrailingSourceMap */);
|
|
setSourceMapRange(target, firstAccessor.name);
|
|
const visitedAccessorName = visitNode(firstAccessor.name, visitor, isPropertyName);
|
|
if (isPrivateIdentifier(visitedAccessorName)) {
|
|
return Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015.");
|
|
}
|
|
const propertyName = createExpressionForPropertyName(factory2, visitedAccessorName);
|
|
setEmitFlags(propertyName, 3072 /* NoComments */ | 32 /* NoLeadingSourceMap */);
|
|
setSourceMapRange(propertyName, firstAccessor.name);
|
|
const properties = [];
|
|
if (getAccessor) {
|
|
const getterFunction = transformFunctionLikeToExpression(getAccessor, void 0, void 0, container);
|
|
setSourceMapRange(getterFunction, getSourceMapRange(getAccessor));
|
|
setEmitFlags(getterFunction, 1024 /* NoLeadingComments */);
|
|
const getter = factory2.createPropertyAssignment("get", getterFunction);
|
|
setCommentRange(getter, getCommentRange(getAccessor));
|
|
properties.push(getter);
|
|
}
|
|
if (setAccessor) {
|
|
const setterFunction = transformFunctionLikeToExpression(setAccessor, void 0, void 0, container);
|
|
setSourceMapRange(setterFunction, getSourceMapRange(setAccessor));
|
|
setEmitFlags(setterFunction, 1024 /* NoLeadingComments */);
|
|
const setter = factory2.createPropertyAssignment("set", setterFunction);
|
|
setCommentRange(setter, getCommentRange(setAccessor));
|
|
properties.push(setter);
|
|
}
|
|
properties.push(
|
|
factory2.createPropertyAssignment("enumerable", getAccessor || setAccessor ? factory2.createFalse() : factory2.createTrue()),
|
|
factory2.createPropertyAssignment("configurable", factory2.createTrue())
|
|
);
|
|
const call = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "defineProperty"),
|
|
void 0,
|
|
[
|
|
target,
|
|
propertyName,
|
|
factory2.createObjectLiteralExpression(properties, true)
|
|
]
|
|
);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(call);
|
|
}
|
|
return call;
|
|
}
|
|
function visitArrowFunction(node) {
|
|
if (node.transformFlags & 16384 /* ContainsLexicalThis */ && !(hierarchyFacts & 16384 /* StaticInitializer */)) {
|
|
hierarchyFacts |= 65536 /* CapturedLexicalThis */;
|
|
}
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(15232 /* ArrowFunctionExcludes */, 66 /* ArrowFunctionIncludes */);
|
|
const func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformFunctionBody2(node)
|
|
);
|
|
setTextRange(func, node);
|
|
setOriginalNode(func, node);
|
|
setEmitFlags(func, 16 /* CapturesThis */);
|
|
exitSubtree(ancestorFacts, 0 /* ArrowFunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return func;
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
const ancestorFacts = getEmitFlags(node) & 524288 /* AsyncFunctionBody */ ? enterSubtree(32662 /* AsyncFunctionBodyExcludes */, 69 /* AsyncFunctionBodyIncludes */) : enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody2(node);
|
|
const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return factory2.updateFunctionExpression(
|
|
node,
|
|
void 0,
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody2(node);
|
|
const name = hierarchyFacts & 32768 /* NewTarget */ ? factory2.getLocalName(node) : node.name;
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, visitor, isModifier),
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
}
|
|
function transformFunctionLikeToExpression(node, location2, name, container) {
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = container && isClassLike(container) && !isStatic(node) ? enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */ | 8 /* NonStaticClassElement */) : enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody2(node);
|
|
if (hierarchyFacts & 32768 /* NewTarget */ && !name && (node.kind === 259 /* FunctionDeclaration */ || node.kind === 215 /* FunctionExpression */)) {
|
|
name = factory2.getGeneratedNameForNode(node);
|
|
}
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
node.asteriskToken,
|
|
name,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
),
|
|
location2
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function transformFunctionBody2(node) {
|
|
let multiLine = false;
|
|
let singleLine = false;
|
|
let statementsLocation;
|
|
let closeBraceLocation;
|
|
const prologue = [];
|
|
const statements = [];
|
|
const body = node.body;
|
|
let statementOffset;
|
|
resumeLexicalEnvironment();
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyStandardPrologue(body.statements, prologue, 0, false);
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor, isHoistedFunction);
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor, isHoistedVariableStatement);
|
|
}
|
|
multiLine = addDefaultValueAssignmentsIfNeeded2(statements, node) || multiLine;
|
|
multiLine = addRestParameterIfNeeded(statements, node, false) || multiLine;
|
|
if (isBlock(body)) {
|
|
statementOffset = factory2.copyCustomPrologue(body.statements, statements, statementOffset, visitor);
|
|
statementsLocation = body.statements;
|
|
addRange(statements, visitNodes2(body.statements, visitor, isStatement, statementOffset));
|
|
if (!multiLine && body.multiLine) {
|
|
multiLine = true;
|
|
}
|
|
} else {
|
|
Debug.assert(node.kind === 216 /* ArrowFunction */);
|
|
statementsLocation = moveRangeEnd(body, -1);
|
|
const equalsGreaterThanToken = node.equalsGreaterThanToken;
|
|
if (!nodeIsSynthesized(equalsGreaterThanToken) && !nodeIsSynthesized(body)) {
|
|
if (rangeEndIsOnSameLineAsRangeStart(equalsGreaterThanToken, body, currentSourceFile)) {
|
|
singleLine = true;
|
|
} else {
|
|
multiLine = true;
|
|
}
|
|
}
|
|
const expression = visitNode(body, visitor, isExpression);
|
|
const returnStatement = factory2.createReturnStatement(expression);
|
|
setTextRange(returnStatement, body);
|
|
moveSyntheticComments(returnStatement, body);
|
|
setEmitFlags(returnStatement, 768 /* NoTokenSourceMaps */ | 64 /* NoTrailingSourceMap */ | 2048 /* NoTrailingComments */);
|
|
statements.push(returnStatement);
|
|
closeBraceLocation = body;
|
|
}
|
|
factory2.mergeLexicalEnvironment(prologue, endLexicalEnvironment());
|
|
insertCaptureNewTargetIfNeeded(prologue, node, false);
|
|
insertCaptureThisForNodeIfNeeded(prologue, node);
|
|
if (some(prologue)) {
|
|
multiLine = true;
|
|
}
|
|
statements.unshift(...prologue);
|
|
if (isBlock(body) && arrayIsEqualTo(statements, body.statements)) {
|
|
return body;
|
|
}
|
|
const block = factory2.createBlock(setTextRange(factory2.createNodeArray(statements), statementsLocation), multiLine);
|
|
setTextRange(block, node.body);
|
|
if (!multiLine && singleLine) {
|
|
setEmitFlags(block, 1 /* SingleLine */);
|
|
}
|
|
if (closeBraceLocation) {
|
|
setTokenSourceMapRange(block, 19 /* CloseBraceToken */, closeBraceLocation);
|
|
}
|
|
setOriginalNode(block, node.body);
|
|
return block;
|
|
}
|
|
function visitBlock(node, isFunctionBody2) {
|
|
if (isFunctionBody2) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
const ancestorFacts = hierarchyFacts & 256 /* IterationStatement */ ? enterSubtree(7104 /* IterationStatementBlockExcludes */, 512 /* IterationStatementBlockIncludes */) : enterSubtree(6976 /* BlockExcludes */, 128 /* BlockIncludes */);
|
|
const updated = visitEachChild(node, visitor, context);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
function visitParenthesizedExpression(node, expressionResultIsUnused2) {
|
|
return visitEachChild(node, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, context);
|
|
}
|
|
function visitBinaryExpression(node, expressionResultIsUnused2) {
|
|
if (isDestructuringAssignment(node)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
!expressionResultIsUnused2
|
|
);
|
|
}
|
|
if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
visitNode(node.left, visitorWithUnusedExpressionResult, isExpression),
|
|
node.operatorToken,
|
|
visitNode(node.right, expressionResultIsUnused2 ? visitorWithUnusedExpressionResult : visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaListExpression(node, expressionResultIsUnused2) {
|
|
if (expressionResultIsUnused2) {
|
|
return visitEachChild(node, visitorWithUnusedExpressionResult, context);
|
|
}
|
|
let result;
|
|
for (let i = 0; i < node.elements.length; i++) {
|
|
const element = node.elements[i];
|
|
const visited = visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, isExpression);
|
|
if (result || visited !== element) {
|
|
result || (result = node.elements.slice(0, i));
|
|
result.push(visited);
|
|
}
|
|
}
|
|
const elements = result ? setTextRange(factory2.createNodeArray(result), node.elements) : node.elements;
|
|
return factory2.updateCommaListExpression(node, elements);
|
|
}
|
|
function isVariableStatementOfTypeScriptClassWrapper(node) {
|
|
return node.declarationList.declarations.length === 1 && !!node.declarationList.declarations[0].initializer && !!(getEmitFlags(node.declarationList.declarations[0].initializer) & 67108864 /* TypeScriptClassWrapper */);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
const ancestorFacts = enterSubtree(0 /* None */, hasSyntacticModifier(node, 1 /* Export */) ? 32 /* ExportedVariableStatement */ : 0 /* None */);
|
|
let updated;
|
|
if (convertedLoopState && (node.declarationList.flags & 3 /* BlockScoped */) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) {
|
|
let assignments;
|
|
for (const decl of node.declarationList.declarations) {
|
|
hoistVariableDeclarationDeclaredInConvertedLoop(convertedLoopState, decl);
|
|
if (decl.initializer) {
|
|
let assignment;
|
|
if (isBindingPattern(decl.name)) {
|
|
assignment = flattenDestructuringAssignment(
|
|
decl,
|
|
visitor,
|
|
context,
|
|
0 /* All */
|
|
);
|
|
} else {
|
|
assignment = factory2.createBinaryExpression(decl.name, 63 /* EqualsToken */, visitNode(decl.initializer, visitor, isExpression));
|
|
setTextRange(assignment, decl);
|
|
}
|
|
assignments = append(assignments, assignment);
|
|
}
|
|
}
|
|
if (assignments) {
|
|
updated = setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(assignments)), node);
|
|
} else {
|
|
updated = void 0;
|
|
}
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitVariableDeclarationList(node) {
|
|
if (node.flags & 3 /* BlockScoped */ || node.transformFlags & 524288 /* ContainsBindingPattern */) {
|
|
if (node.flags & 3 /* BlockScoped */) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const declarations = flatMap(node.declarations, node.flags & 1 /* Let */ ? visitVariableDeclarationInLetDeclarationList : visitVariableDeclaration);
|
|
const declarationList = factory2.createVariableDeclarationList(declarations);
|
|
setOriginalNode(declarationList, node);
|
|
setTextRange(declarationList, node);
|
|
setCommentRange(declarationList, node);
|
|
if (node.transformFlags & 524288 /* ContainsBindingPattern */ && (isBindingPattern(node.declarations[0].name) || isBindingPattern(last(node.declarations).name))) {
|
|
setSourceMapRange(declarationList, getRangeUnion(declarations));
|
|
}
|
|
return declarationList;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function getRangeUnion(declarations) {
|
|
let pos = -1, end = -1;
|
|
for (const node of declarations) {
|
|
pos = pos === -1 ? node.pos : node.pos === -1 ? pos : Math.min(pos, node.pos);
|
|
end = Math.max(end, node.end);
|
|
}
|
|
return createRange(pos, end);
|
|
}
|
|
function shouldEmitExplicitInitializerForLetDeclaration(node) {
|
|
const flags = resolver.getNodeCheckFlags(node);
|
|
const isCapturedInFunction = flags & 16384 /* CapturedBlockScopedBinding */;
|
|
const isDeclaredInLoop = flags & 32768 /* BlockScopedBindingInLoop */;
|
|
const emittedAsTopLevel = (hierarchyFacts & 64 /* TopLevel */) !== 0 || isCapturedInFunction && isDeclaredInLoop && (hierarchyFacts & 512 /* IterationStatementBlock */) !== 0;
|
|
const emitExplicitInitializer = !emittedAsTopLevel && (hierarchyFacts & 4096 /* ForInOrForOfStatement */) === 0 && (!resolver.isDeclarationWithCollidingName(node) || isDeclaredInLoop && !isCapturedInFunction && (hierarchyFacts & (2048 /* ForStatement */ | 4096 /* ForInOrForOfStatement */)) === 0);
|
|
return emitExplicitInitializer;
|
|
}
|
|
function visitVariableDeclarationInLetDeclarationList(node) {
|
|
const name = node.name;
|
|
if (isBindingPattern(name)) {
|
|
return visitVariableDeclaration(node);
|
|
}
|
|
if (!node.initializer && shouldEmitExplicitInitializerForLetDeclaration(node)) {
|
|
return factory2.updateVariableDeclaration(node, node.name, void 0, void 0, factory2.createVoidZero());
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitVariableDeclaration(node) {
|
|
const ancestorFacts = enterSubtree(32 /* ExportedVariableStatement */, 0 /* None */);
|
|
let updated;
|
|
if (isBindingPattern(node.name)) {
|
|
updated = flattenDestructuringBinding(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
void 0,
|
|
(ancestorFacts & 32 /* ExportedVariableStatement */) !== 0
|
|
);
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function recordLabel(node) {
|
|
convertedLoopState.labels.set(idText(node.label), true);
|
|
}
|
|
function resetLabel(node) {
|
|
convertedLoopState.labels.set(idText(node.label), false);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (convertedLoopState && !convertedLoopState.labels) {
|
|
convertedLoopState.labels = /* @__PURE__ */ new Map();
|
|
}
|
|
const statement = unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel);
|
|
return isIterationStatement(statement, false) ? visitIterationStatement(statement, node) : factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock), node, convertedLoopState && resetLabel);
|
|
}
|
|
function visitIterationStatement(node, outermostLabeledStatement) {
|
|
switch (node.kind) {
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return visitDoOrWhileStatement(node, outermostLabeledStatement);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, outermostLabeledStatement);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node, outermostLabeledStatement);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node, outermostLabeledStatement);
|
|
}
|
|
}
|
|
function visitIterationStatementWithFacts(excludeFacts, includeFacts, node, outermostLabeledStatement, convert) {
|
|
const ancestorFacts = enterSubtree(excludeFacts, includeFacts);
|
|
const updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function visitDoOrWhileStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
0 /* DoOrWhileStatementExcludes */,
|
|
1280 /* DoOrWhileStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitForStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
5056 /* ForStatementExcludes */,
|
|
3328 /* ForStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitEachChildOfForStatement2(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
visitNode(node.statement, visitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitForInStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
3008 /* ForInOrForOfStatementExcludes */,
|
|
5376 /* ForInOrForOfStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement
|
|
);
|
|
}
|
|
function visitForOfStatement(node, outermostLabeledStatement) {
|
|
return visitIterationStatementWithFacts(
|
|
3008 /* ForInOrForOfStatementExcludes */,
|
|
5376 /* ForInOrForOfStatementIncludes */,
|
|
node,
|
|
outermostLabeledStatement,
|
|
compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray
|
|
);
|
|
}
|
|
function convertForOfStatementHead(node, boundValue, convertedLoopBodyStatements) {
|
|
const statements = [];
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
if (node.initializer.flags & 3 /* BlockScoped */) {
|
|
enableSubstitutionsForBlockScopedBindings();
|
|
}
|
|
const firstOriginalDeclaration = firstOrUndefined(initializer.declarations);
|
|
if (firstOriginalDeclaration && isBindingPattern(firstOriginalDeclaration.name)) {
|
|
const declarations = flattenDestructuringBinding(
|
|
firstOriginalDeclaration,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
boundValue
|
|
);
|
|
const declarationList = setTextRange(factory2.createVariableDeclarationList(declarations), node.initializer);
|
|
setOriginalNode(declarationList, node.initializer);
|
|
setSourceMapRange(declarationList, createRange(declarations[0].pos, last(declarations).end));
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
declarationList
|
|
)
|
|
);
|
|
} else {
|
|
statements.push(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
firstOriginalDeclaration ? firstOriginalDeclaration.name : factory2.createTempVariable(void 0),
|
|
void 0,
|
|
void 0,
|
|
boundValue
|
|
)
|
|
]),
|
|
moveRangePos(initializer, -1)
|
|
),
|
|
initializer
|
|
)
|
|
),
|
|
moveRangeEnd(initializer, -1)
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
const assignment = factory2.createAssignment(initializer, boundValue);
|
|
if (isDestructuringAssignment(assignment)) {
|
|
statements.push(factory2.createExpressionStatement(visitBinaryExpression(assignment, true)));
|
|
} else {
|
|
setTextRangeEnd(assignment, initializer.end);
|
|
statements.push(setTextRange(factory2.createExpressionStatement(visitNode(assignment, visitor, isExpression)), moveRangeEnd(initializer, -1)));
|
|
}
|
|
}
|
|
if (convertedLoopBodyStatements) {
|
|
return createSyntheticBlockForConvertedStatements(addRange(statements, convertedLoopBodyStatements));
|
|
} else {
|
|
const statement = visitNode(node.statement, visitor, isStatement, factory2.liftToBlock);
|
|
if (isBlock(statement)) {
|
|
return factory2.updateBlock(statement, setTextRange(factory2.createNodeArray(concatenate(statements, statement.statements)), statement.statements));
|
|
} else {
|
|
statements.push(statement);
|
|
return createSyntheticBlockForConvertedStatements(statements);
|
|
}
|
|
}
|
|
}
|
|
function createSyntheticBlockForConvertedStatements(statements) {
|
|
return setEmitFlags(
|
|
factory2.createBlock(
|
|
factory2.createNodeArray(statements),
|
|
true
|
|
),
|
|
96 /* NoSourceMap */ | 768 /* NoTokenSourceMaps */
|
|
);
|
|
}
|
|
function convertForOfStatementForArray(node, outermostLabeledStatement, convertedLoopBodyStatements) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const counter = factory2.createLoopVariable();
|
|
const rhsReference = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
setEmitFlags(expression, 96 /* NoSourceMap */ | getEmitFlags(expression));
|
|
const forStatement = setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
setTextRange(factory2.createVariableDeclaration(counter, void 0, void 0, factory2.createNumericLiteral(0)), moveRangePos(node.expression, -1)),
|
|
setTextRange(factory2.createVariableDeclaration(rhsReference, void 0, void 0, expression), node.expression)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
setTextRange(
|
|
factory2.createLessThan(
|
|
counter,
|
|
factory2.createPropertyAccessExpression(rhsReference, "length")
|
|
),
|
|
node.expression
|
|
),
|
|
setTextRange(factory2.createPostfixIncrement(counter), node.expression),
|
|
convertForOfStatementHead(
|
|
node,
|
|
factory2.createElementAccessExpression(rhsReference, counter),
|
|
convertedLoopBodyStatements
|
|
)
|
|
),
|
|
node
|
|
);
|
|
setEmitFlags(forStatement, 512 /* NoTokenTrailingSourceMaps */);
|
|
setTextRange(forStatement, node);
|
|
return factory2.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) {
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const iterator = isIdentifier(expression) ? factory2.getGeneratedNameForNode(expression) : factory2.createTempVariable(void 0);
|
|
const result = isIdentifier(expression) ? factory2.getGeneratedNameForNode(iterator) : factory2.createTempVariable(void 0);
|
|
const errorRecord = factory2.createUniqueName("e");
|
|
const catchVariable = factory2.getGeneratedNameForNode(errorRecord);
|
|
const returnMethod = factory2.createTempVariable(void 0);
|
|
const values = setTextRange(emitHelpers().createValuesHelper(expression), node.expression);
|
|
const next = factory2.createCallExpression(factory2.createPropertyAccessExpression(iterator, "next"), void 0, []);
|
|
hoistVariableDeclaration(errorRecord);
|
|
hoistVariableDeclaration(returnMethod);
|
|
const initializer = ancestorFacts & 1024 /* IterationContainer */ ? factory2.inlineExpressions([factory2.createAssignment(errorRecord, factory2.createVoidZero()), values]) : values;
|
|
const forStatement = setEmitFlags(
|
|
setTextRange(
|
|
factory2.createForStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createVariableDeclarationList([
|
|
setTextRange(factory2.createVariableDeclaration(iterator, void 0, void 0, initializer), node.expression),
|
|
factory2.createVariableDeclaration(result, void 0, void 0, next)
|
|
]),
|
|
node.expression
|
|
),
|
|
4194304 /* NoHoisting */
|
|
),
|
|
factory2.createLogicalNot(factory2.createPropertyAccessExpression(result, "done")),
|
|
factory2.createAssignment(result, next),
|
|
convertForOfStatementHead(
|
|
node,
|
|
factory2.createPropertyAccessExpression(result, "value"),
|
|
convertedLoopBodyStatements
|
|
)
|
|
),
|
|
node
|
|
),
|
|
512 /* NoTokenTrailingSourceMaps */
|
|
);
|
|
return factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
factory2.restoreEnclosingLabel(
|
|
forStatement,
|
|
outermostLabeledStatement,
|
|
convertedLoopState && resetLabel
|
|
)
|
|
]),
|
|
factory2.createCatchClause(
|
|
factory2.createVariableDeclaration(catchVariable),
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
errorRecord,
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("error", catchVariable)
|
|
])
|
|
)
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createTryStatement(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createLogicalAnd(
|
|
result,
|
|
factory2.createLogicalNot(
|
|
factory2.createPropertyAccessExpression(result, "done")
|
|
)
|
|
),
|
|
factory2.createAssignment(
|
|
returnMethod,
|
|
factory2.createPropertyAccessExpression(iterator, "return")
|
|
)
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createFunctionCallCall(returnMethod, iterator, [])
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
errorRecord,
|
|
factory2.createThrowStatement(
|
|
factory2.createPropertyAccessExpression(errorRecord, "error")
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
1 /* SingleLine */
|
|
)
|
|
)
|
|
])
|
|
);
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
const properties = node.properties;
|
|
let numInitialProperties = -1, hasComputed = false;
|
|
for (let i = 0; i < properties.length; i++) {
|
|
const property = properties[i];
|
|
if (property.transformFlags & 1048576 /* ContainsYield */ && hierarchyFacts & 4 /* AsyncFunctionBody */ || (hasComputed = Debug.checkDefined(property.name).kind === 164 /* ComputedPropertyName */)) {
|
|
numInitialProperties = i;
|
|
break;
|
|
}
|
|
}
|
|
if (numInitialProperties < 0) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
const expressions = [];
|
|
const assignment = factory2.createAssignment(
|
|
temp,
|
|
setEmitFlags(
|
|
factory2.createObjectLiteralExpression(
|
|
visitNodes2(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
|
|
node.multiLine
|
|
),
|
|
hasComputed ? 131072 /* Indented */ : 0
|
|
)
|
|
);
|
|
if (node.multiLine) {
|
|
startOnNewLine(assignment);
|
|
}
|
|
expressions.push(assignment);
|
|
addObjectLiteralMembers(expressions, node, temp, numInitialProperties);
|
|
expressions.push(node.multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
|
|
return factory2.inlineExpressions(expressions);
|
|
}
|
|
function shouldConvertPartOfIterationStatement(node) {
|
|
return (resolver.getNodeCheckFlags(node) & 8192 /* ContainsCapturedBlockScopeBinding */) !== 0;
|
|
}
|
|
function shouldConvertInitializerOfForStatement(node) {
|
|
return isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer);
|
|
}
|
|
function shouldConvertConditionOfForStatement(node) {
|
|
return isForStatement(node) && !!node.condition && shouldConvertPartOfIterationStatement(node.condition);
|
|
}
|
|
function shouldConvertIncrementorOfForStatement(node) {
|
|
return isForStatement(node) && !!node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor);
|
|
}
|
|
function shouldConvertIterationStatement(node) {
|
|
return shouldConvertBodyOfIterationStatement(node) || shouldConvertInitializerOfForStatement(node);
|
|
}
|
|
function shouldConvertBodyOfIterationStatement(node) {
|
|
return (resolver.getNodeCheckFlags(node) & 4096 /* LoopWithCapturedBlockScopedBinding */) !== 0;
|
|
}
|
|
function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) {
|
|
if (!state.hoistedLocalVariables) {
|
|
state.hoistedLocalVariables = [];
|
|
}
|
|
visit(node.name);
|
|
function visit(node2) {
|
|
if (node2.kind === 79 /* Identifier */) {
|
|
state.hoistedLocalVariables.push(node2);
|
|
} else {
|
|
for (const element of node2.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
visit(element.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert) {
|
|
if (!shouldConvertIterationStatement(node)) {
|
|
let saveAllowedNonLabeledJumps;
|
|
if (convertedLoopState) {
|
|
saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
|
|
convertedLoopState.allowedNonLabeledJumps = 2 /* Break */ | 4 /* Continue */;
|
|
}
|
|
const result = convert ? convert(node, outermostLabeledStatement, void 0, ancestorFacts) : factory2.restoreEnclosingLabel(
|
|
isForStatement(node) ? visitEachChildOfForStatement2(node) : visitEachChild(node, visitor, context),
|
|
outermostLabeledStatement,
|
|
convertedLoopState && resetLabel
|
|
);
|
|
if (convertedLoopState) {
|
|
convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
|
|
}
|
|
return result;
|
|
}
|
|
const currentState = createConvertedLoopState(node);
|
|
const statements = [];
|
|
const outerConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = currentState;
|
|
const initializerFunction = shouldConvertInitializerOfForStatement(node) ? createFunctionForInitializerOfForStatement(node, currentState) : void 0;
|
|
const bodyFunction = shouldConvertBodyOfIterationStatement(node) ? createFunctionForBodyOfIterationStatement(node, currentState, outerConvertedLoopState) : void 0;
|
|
convertedLoopState = outerConvertedLoopState;
|
|
if (initializerFunction)
|
|
statements.push(initializerFunction.functionDeclaration);
|
|
if (bodyFunction)
|
|
statements.push(bodyFunction.functionDeclaration);
|
|
addExtraDeclarationsForConvertedLoop(statements, currentState, outerConvertedLoopState);
|
|
if (initializerFunction) {
|
|
statements.push(generateCallToConvertedLoopInitializer(initializerFunction.functionName, initializerFunction.containsYield));
|
|
}
|
|
let loop;
|
|
if (bodyFunction) {
|
|
if (convert) {
|
|
loop = convert(node, outermostLabeledStatement, bodyFunction.part, ancestorFacts);
|
|
} else {
|
|
const clone2 = convertIterationStatementCore(node, initializerFunction, factory2.createBlock(bodyFunction.part, true));
|
|
loop = factory2.restoreEnclosingLabel(clone2, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
} else {
|
|
const clone2 = convertIterationStatementCore(node, initializerFunction, visitNode(node.statement, visitor, isStatement, factory2.liftToBlock));
|
|
loop = factory2.restoreEnclosingLabel(clone2, outermostLabeledStatement, convertedLoopState && resetLabel);
|
|
}
|
|
statements.push(loop);
|
|
return statements;
|
|
}
|
|
function convertIterationStatementCore(node, initializerFunction, convertedLoopBody) {
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return convertForStatement(node, initializerFunction, convertedLoopBody);
|
|
case 246 /* ForInStatement */:
|
|
return convertForInStatement(node, convertedLoopBody);
|
|
case 247 /* ForOfStatement */:
|
|
return convertForOfStatement(node, convertedLoopBody);
|
|
case 243 /* DoStatement */:
|
|
return convertDoStatement(node, convertedLoopBody);
|
|
case 244 /* WhileStatement */:
|
|
return convertWhileStatement(node, convertedLoopBody);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node, "IterationStatement expected");
|
|
}
|
|
}
|
|
function convertForStatement(node, initializerFunction, convertedLoopBody) {
|
|
const shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition);
|
|
const shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor);
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitorWithUnusedExpressionResult, isForInitializer),
|
|
visitNode(shouldConvertCondition ? void 0 : node.condition, visitor, isExpression),
|
|
visitNode(shouldConvertIncrementor ? void 0 : node.incrementor, visitorWithUnusedExpressionResult, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertForOfStatement(node, convertedLoopBody) {
|
|
return factory2.updateForOfStatement(
|
|
node,
|
|
void 0,
|
|
visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertForInStatement(node, convertedLoopBody) {
|
|
return factory2.updateForInStatement(
|
|
node,
|
|
visitNode(node.initializer, visitor, isForInitializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function convertDoStatement(node, convertedLoopBody) {
|
|
return factory2.updateDoStatement(
|
|
node,
|
|
convertedLoopBody,
|
|
visitNode(node.expression, visitor, isExpression)
|
|
);
|
|
}
|
|
function convertWhileStatement(node, convertedLoopBody) {
|
|
return factory2.updateWhileStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
convertedLoopBody
|
|
);
|
|
}
|
|
function createConvertedLoopState(node) {
|
|
let loopInitializer;
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
const initializer = node.initializer;
|
|
if (initializer && initializer.kind === 258 /* VariableDeclarationList */) {
|
|
loopInitializer = initializer;
|
|
}
|
|
break;
|
|
}
|
|
const loopParameters = [];
|
|
const loopOutParameters = [];
|
|
if (loopInitializer && getCombinedNodeFlags(loopInitializer) & 3 /* BlockScoped */) {
|
|
const hasCapturedBindingsInForHead = shouldConvertInitializerOfForStatement(node) || shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node);
|
|
for (const decl of loopInitializer.declarations) {
|
|
processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
|
|
}
|
|
}
|
|
const currentState = { loopParameters, loopOutParameters };
|
|
if (convertedLoopState) {
|
|
if (convertedLoopState.argumentsName) {
|
|
currentState.argumentsName = convertedLoopState.argumentsName;
|
|
}
|
|
if (convertedLoopState.thisName) {
|
|
currentState.thisName = convertedLoopState.thisName;
|
|
}
|
|
if (convertedLoopState.hoistedLocalVariables) {
|
|
currentState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables;
|
|
}
|
|
}
|
|
return currentState;
|
|
}
|
|
function addExtraDeclarationsForConvertedLoop(statements, state, outerState) {
|
|
let extraVariableDeclarations;
|
|
if (state.argumentsName) {
|
|
if (outerState) {
|
|
outerState.argumentsName = state.argumentsName;
|
|
} else {
|
|
(extraVariableDeclarations || (extraVariableDeclarations = [])).push(
|
|
factory2.createVariableDeclaration(
|
|
state.argumentsName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createIdentifier("arguments")
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (state.thisName) {
|
|
if (outerState) {
|
|
outerState.thisName = state.thisName;
|
|
} else {
|
|
(extraVariableDeclarations || (extraVariableDeclarations = [])).push(
|
|
factory2.createVariableDeclaration(
|
|
state.thisName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createIdentifier("this")
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (state.hoistedLocalVariables) {
|
|
if (outerState) {
|
|
outerState.hoistedLocalVariables = state.hoistedLocalVariables;
|
|
} else {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
for (const identifier of state.hoistedLocalVariables) {
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(identifier));
|
|
}
|
|
}
|
|
}
|
|
if (state.loopOutParameters.length) {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
for (const outParam of state.loopOutParameters) {
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(outParam.outParamName));
|
|
}
|
|
}
|
|
if (state.conditionVariable) {
|
|
if (!extraVariableDeclarations) {
|
|
extraVariableDeclarations = [];
|
|
}
|
|
extraVariableDeclarations.push(factory2.createVariableDeclaration(state.conditionVariable, void 0, void 0, factory2.createFalse()));
|
|
}
|
|
if (extraVariableDeclarations) {
|
|
statements.push(factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(extraVariableDeclarations)
|
|
));
|
|
}
|
|
}
|
|
function createOutVariable(p) {
|
|
return factory2.createVariableDeclaration(p.originalName, void 0, void 0, p.outParamName);
|
|
}
|
|
function createFunctionForInitializerOfForStatement(node, currentState) {
|
|
const functionName = factory2.createUniqueName("_loop_init");
|
|
const containsYield = (node.initializer.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
let emitFlags = 0 /* None */;
|
|
if (currentState.containsLexicalThis)
|
|
emitFlags |= 16 /* CapturesThis */;
|
|
if (containsYield && hierarchyFacts & 4 /* AsyncFunctionBody */)
|
|
emitFlags |= 524288 /* AsyncFunctionBody */;
|
|
const statements = [];
|
|
statements.push(factory2.createVariableStatement(void 0, node.initializer));
|
|
copyOutParameters(currentState.loopOutParameters, 2 /* Initializer */, 1 /* ToOutParameter */, statements);
|
|
const functionDeclaration = factory2.createVariableStatement(
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
functionName,
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
containsYield ? factory2.createToken(41 /* AsteriskToken */) : void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
visitNode(
|
|
factory2.createBlock(statements, true),
|
|
visitor,
|
|
isBlock
|
|
)
|
|
),
|
|
emitFlags
|
|
)
|
|
)
|
|
]),
|
|
4194304 /* NoHoisting */
|
|
)
|
|
);
|
|
const part = factory2.createVariableDeclarationList(map(currentState.loopOutParameters, createOutVariable));
|
|
return { functionName, containsYield, functionDeclaration, part };
|
|
}
|
|
function createFunctionForBodyOfIterationStatement(node, currentState, outerState) {
|
|
const functionName = factory2.createUniqueName("_loop");
|
|
startLexicalEnvironment();
|
|
const statement = visitNode(node.statement, visitor, isStatement, factory2.liftToBlock);
|
|
const lexicalEnvironment = endLexicalEnvironment();
|
|
const statements = [];
|
|
if (shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node)) {
|
|
currentState.conditionVariable = factory2.createUniqueName("inc");
|
|
if (node.incrementor) {
|
|
statements.push(factory2.createIfStatement(
|
|
currentState.conditionVariable,
|
|
factory2.createExpressionStatement(visitNode(node.incrementor, visitor, isExpression)),
|
|
factory2.createExpressionStatement(factory2.createAssignment(currentState.conditionVariable, factory2.createTrue()))
|
|
));
|
|
} else {
|
|
statements.push(factory2.createIfStatement(
|
|
factory2.createLogicalNot(currentState.conditionVariable),
|
|
factory2.createExpressionStatement(factory2.createAssignment(currentState.conditionVariable, factory2.createTrue()))
|
|
));
|
|
}
|
|
if (shouldConvertConditionOfForStatement(node)) {
|
|
statements.push(factory2.createIfStatement(
|
|
factory2.createPrefixUnaryExpression(53 /* ExclamationToken */, visitNode(node.condition, visitor, isExpression)),
|
|
visitNode(factory2.createBreakStatement(), visitor, isStatement)
|
|
));
|
|
}
|
|
}
|
|
if (isBlock(statement)) {
|
|
addRange(statements, statement.statements);
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
copyOutParameters(currentState.loopOutParameters, 1 /* Body */, 1 /* ToOutParameter */, statements);
|
|
insertStatementsAfterStandardPrologue(statements, lexicalEnvironment);
|
|
const loopBody = factory2.createBlock(statements, true);
|
|
if (isBlock(statement))
|
|
setOriginalNode(loopBody, statement);
|
|
const containsYield = (node.statement.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
let emitFlags = 1048576 /* ReuseTempVariableScope */;
|
|
if (currentState.containsLexicalThis)
|
|
emitFlags |= 16 /* CapturesThis */;
|
|
if (containsYield && (hierarchyFacts & 4 /* AsyncFunctionBody */) !== 0)
|
|
emitFlags |= 524288 /* AsyncFunctionBody */;
|
|
const functionDeclaration = factory2.createVariableStatement(
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
functionName,
|
|
void 0,
|
|
void 0,
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
containsYield ? factory2.createToken(41 /* AsteriskToken */) : void 0,
|
|
void 0,
|
|
void 0,
|
|
currentState.loopParameters,
|
|
void 0,
|
|
loopBody
|
|
),
|
|
emitFlags
|
|
)
|
|
)
|
|
]
|
|
),
|
|
4194304 /* NoHoisting */
|
|
)
|
|
);
|
|
const part = generateCallToConvertedLoop(functionName, currentState, outerState, containsYield);
|
|
return { functionName, containsYield, functionDeclaration, part };
|
|
}
|
|
function copyOutParameter(outParam, copyDirection) {
|
|
const source = copyDirection === 0 /* ToOriginal */ ? outParam.outParamName : outParam.originalName;
|
|
const target = copyDirection === 0 /* ToOriginal */ ? outParam.originalName : outParam.outParamName;
|
|
return factory2.createBinaryExpression(target, 63 /* EqualsToken */, source);
|
|
}
|
|
function copyOutParameters(outParams, partFlags, copyDirection, statements) {
|
|
for (const outParam of outParams) {
|
|
if (outParam.flags & partFlags) {
|
|
statements.push(factory2.createExpressionStatement(copyOutParameter(outParam, copyDirection)));
|
|
}
|
|
}
|
|
}
|
|
function generateCallToConvertedLoopInitializer(initFunctionExpressionName, containsYield) {
|
|
const call = factory2.createCallExpression(initFunctionExpressionName, void 0, []);
|
|
const callResult = containsYield ? factory2.createYieldExpression(
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
setEmitFlags(call, 16777216 /* Iterator */)
|
|
) : call;
|
|
return factory2.createExpressionStatement(callResult);
|
|
}
|
|
function generateCallToConvertedLoop(loopFunctionExpressionName, state, outerState, containsYield) {
|
|
const statements = [];
|
|
const isSimpleLoop = !(state.nonLocalJumps & ~4 /* Continue */) && !state.labeledNonLocalBreaks && !state.labeledNonLocalContinues;
|
|
const call = factory2.createCallExpression(loopFunctionExpressionName, void 0, map(state.loopParameters, (p) => p.name));
|
|
const callResult = containsYield ? factory2.createYieldExpression(
|
|
factory2.createToken(41 /* AsteriskToken */),
|
|
setEmitFlags(call, 16777216 /* Iterator */)
|
|
) : call;
|
|
if (isSimpleLoop) {
|
|
statements.push(factory2.createExpressionStatement(callResult));
|
|
copyOutParameters(state.loopOutParameters, 1 /* Body */, 0 /* ToOriginal */, statements);
|
|
} else {
|
|
const loopResultName = factory2.createUniqueName("state");
|
|
const stateVariable = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[factory2.createVariableDeclaration(loopResultName, void 0, void 0, callResult)]
|
|
)
|
|
);
|
|
statements.push(stateVariable);
|
|
copyOutParameters(state.loopOutParameters, 1 /* Body */, 0 /* ToOriginal */, statements);
|
|
if (state.nonLocalJumps & 8 /* Return */) {
|
|
let returnStatement;
|
|
if (outerState) {
|
|
outerState.nonLocalJumps |= 8 /* Return */;
|
|
returnStatement = factory2.createReturnStatement(loopResultName);
|
|
} else {
|
|
returnStatement = factory2.createReturnStatement(factory2.createPropertyAccessExpression(loopResultName, "value"));
|
|
}
|
|
statements.push(
|
|
factory2.createIfStatement(
|
|
factory2.createTypeCheck(loopResultName, "object"),
|
|
returnStatement
|
|
)
|
|
);
|
|
}
|
|
if (state.nonLocalJumps & 2 /* Break */) {
|
|
statements.push(
|
|
factory2.createIfStatement(
|
|
factory2.createStrictEquality(
|
|
loopResultName,
|
|
factory2.createStringLiteral("break")
|
|
),
|
|
factory2.createBreakStatement()
|
|
)
|
|
);
|
|
}
|
|
if (state.labeledNonLocalBreaks || state.labeledNonLocalContinues) {
|
|
const caseClauses = [];
|
|
processLabeledJumps(state.labeledNonLocalBreaks, true, loopResultName, outerState, caseClauses);
|
|
processLabeledJumps(state.labeledNonLocalContinues, false, loopResultName, outerState, caseClauses);
|
|
statements.push(
|
|
factory2.createSwitchStatement(
|
|
loopResultName,
|
|
factory2.createCaseBlock(caseClauses)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function setLabeledJump(state, isBreak, labelText, labelMarker) {
|
|
if (isBreak) {
|
|
if (!state.labeledNonLocalBreaks) {
|
|
state.labeledNonLocalBreaks = /* @__PURE__ */ new Map();
|
|
}
|
|
state.labeledNonLocalBreaks.set(labelText, labelMarker);
|
|
} else {
|
|
if (!state.labeledNonLocalContinues) {
|
|
state.labeledNonLocalContinues = /* @__PURE__ */ new Map();
|
|
}
|
|
state.labeledNonLocalContinues.set(labelText, labelMarker);
|
|
}
|
|
}
|
|
function processLabeledJumps(table, isBreak, loopResultName, outerLoop, caseClauses) {
|
|
if (!table) {
|
|
return;
|
|
}
|
|
table.forEach((labelMarker, labelText) => {
|
|
const statements = [];
|
|
if (!outerLoop || outerLoop.labels && outerLoop.labels.get(labelText)) {
|
|
const label = factory2.createIdentifier(labelText);
|
|
statements.push(isBreak ? factory2.createBreakStatement(label) : factory2.createContinueStatement(label));
|
|
} else {
|
|
setLabeledJump(outerLoop, isBreak, labelText, labelMarker);
|
|
statements.push(factory2.createReturnStatement(loopResultName));
|
|
}
|
|
caseClauses.push(factory2.createCaseClause(factory2.createStringLiteral(labelMarker), statements));
|
|
});
|
|
}
|
|
function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead) {
|
|
const name = decl.name;
|
|
if (isBindingPattern(name)) {
|
|
for (const element of name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForHead);
|
|
}
|
|
}
|
|
} else {
|
|
loopParameters.push(factory2.createParameterDeclaration(void 0, void 0, name));
|
|
const checkFlags = resolver.getNodeCheckFlags(decl);
|
|
if (checkFlags & 262144 /* NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) {
|
|
const outParamName = factory2.createUniqueName("out_" + idText(name));
|
|
let flags = 0 /* None */;
|
|
if (checkFlags & 262144 /* NeedsLoopOutParameter */) {
|
|
flags |= 1 /* Body */;
|
|
}
|
|
if (isForStatement(container)) {
|
|
if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) {
|
|
flags |= 2 /* Initializer */;
|
|
}
|
|
if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) || container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) {
|
|
flags |= 1 /* Body */;
|
|
}
|
|
}
|
|
loopOutParameters.push({ flags, originalName: name, outParamName });
|
|
}
|
|
}
|
|
}
|
|
function addObjectLiteralMembers(expressions, node, receiver, start2) {
|
|
const properties = node.properties;
|
|
const numProperties = properties.length;
|
|
for (let i = start2; i < numProperties; i++) {
|
|
const property = properties[i];
|
|
switch (property.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
const accessors = getAllAccessorDeclarations(node.properties, property);
|
|
if (property === accessors.firstAccessor) {
|
|
expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine));
|
|
}
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine));
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine));
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine));
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(node);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(property.name, visitor, isPropertyName)
|
|
),
|
|
visitNode(property.initializer, visitor, isExpression)
|
|
);
|
|
setTextRange(expression, property);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(property.name, visitor, isPropertyName)
|
|
),
|
|
factory2.cloneNode(property.name)
|
|
);
|
|
setTextRange(expression, property);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function transformObjectLiteralMethodDeclarationToExpression(method, receiver, container, startsOnNewLine) {
|
|
const expression = factory2.createAssignment(
|
|
createMemberAccessForPropertyName(
|
|
factory2,
|
|
receiver,
|
|
visitNode(method.name, visitor, isPropertyName)
|
|
),
|
|
transformFunctionLikeToExpression(method, method, void 0, container)
|
|
);
|
|
setTextRange(expression, method);
|
|
if (startsOnNewLine) {
|
|
startOnNewLine(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
function visitCatchClause(node) {
|
|
const ancestorFacts = enterSubtree(7104 /* BlockScopeExcludes */, 0 /* BlockScopeIncludes */);
|
|
let updated;
|
|
Debug.assert(!!node.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015.");
|
|
if (isBindingPattern(node.variableDeclaration.name)) {
|
|
const temp = factory2.createTempVariable(void 0);
|
|
const newVariableDeclaration = factory2.createVariableDeclaration(temp);
|
|
setTextRange(newVariableDeclaration, node.variableDeclaration);
|
|
const vars = flattenDestructuringBinding(
|
|
node.variableDeclaration,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
temp
|
|
);
|
|
const list = factory2.createVariableDeclarationList(vars);
|
|
setTextRange(list, node.variableDeclaration);
|
|
const destructure = factory2.createVariableStatement(void 0, list);
|
|
updated = factory2.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure));
|
|
} else {
|
|
updated = visitEachChild(node, visitor, context);
|
|
}
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return updated;
|
|
}
|
|
function addStatementToStartOfBlock(block, statement) {
|
|
const transformedStatements = visitNodes2(block.statements, visitor, isStatement);
|
|
return factory2.updateBlock(block, [statement, ...transformedStatements]);
|
|
}
|
|
function visitMethodDeclaration(node) {
|
|
Debug.assert(!isComputedPropertyName(node.name));
|
|
const functionExpression = transformFunctionLikeToExpression(node, moveRangePos(node, -1), void 0, void 0);
|
|
setEmitFlags(functionExpression, 1024 /* NoLeadingComments */ | getEmitFlags(functionExpression));
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
node.name,
|
|
functionExpression
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitAccessorDeclaration(node) {
|
|
Debug.assert(!isComputedPropertyName(node.name));
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const ancestorFacts = enterSubtree(32670 /* FunctionExcludes */, 65 /* FunctionIncludes */);
|
|
let updated;
|
|
const parameters = visitParameterList(node.parameters, visitor, context);
|
|
const body = transformFunctionBody2(node);
|
|
if (node.kind === 174 /* GetAccessor */) {
|
|
updated = factory2.updateGetAccessorDeclaration(node, node.modifiers, node.name, parameters, node.type, body);
|
|
} else {
|
|
updated = factory2.updateSetAccessorDeclaration(node, node.modifiers, node.name, parameters, body);
|
|
}
|
|
exitSubtree(ancestorFacts, 98304 /* FunctionSubtreeExcludes */, 0 /* None */);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
return updated;
|
|
}
|
|
function visitShorthandPropertyAssignment(node) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
node.name,
|
|
visitIdentifier(factory2.cloneNode(node.name))
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function visitComputedPropertyName(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitArrayLiteralExpression(node) {
|
|
if (some(node.elements, isSpreadElement)) {
|
|
return transformAndSpreadElements(node.elements, false, !!node.multiLine, !!node.elements.hasTrailingComma);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (getEmitFlags(node) & 67108864 /* TypeScriptClassWrapper */) {
|
|
return visitTypeScriptClassWrapper(node);
|
|
}
|
|
const expression = skipOuterExpressions(node.expression);
|
|
if (expression.kind === 106 /* SuperKeyword */ || isSuperProperty(expression) || some(node.arguments, isSpreadElement)) {
|
|
return visitCallExpressionWithPotentialCapturedThisAssignment(node, true);
|
|
}
|
|
return factory2.updateCallExpression(
|
|
node,
|
|
visitNode(node.expression, callExpressionVisitor, isExpression),
|
|
void 0,
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitTypeScriptClassWrapper(node) {
|
|
const body = cast(cast(skipOuterExpressions(node.expression), isArrowFunction).body, isBlock);
|
|
const isVariableStatementWithInitializer = (stmt) => isVariableStatement(stmt) && !!first(stmt.declarationList.declarations).initializer;
|
|
const savedConvertedLoopState = convertedLoopState;
|
|
convertedLoopState = void 0;
|
|
const bodyStatements = visitNodes2(body.statements, classWrapperStatementVisitor, isStatement);
|
|
convertedLoopState = savedConvertedLoopState;
|
|
const classStatements = filter(bodyStatements, isVariableStatementWithInitializer);
|
|
const remainingStatements = filter(bodyStatements, (stmt) => !isVariableStatementWithInitializer(stmt));
|
|
const varStatement = cast(first(classStatements), isVariableStatement);
|
|
const variable = varStatement.declarationList.declarations[0];
|
|
const initializer = skipOuterExpressions(variable.initializer);
|
|
let aliasAssignment = tryCast(initializer, isAssignmentExpression);
|
|
if (!aliasAssignment && isBinaryExpression(initializer) && initializer.operatorToken.kind === 27 /* CommaToken */) {
|
|
aliasAssignment = tryCast(initializer.left, isAssignmentExpression);
|
|
}
|
|
const call = cast(aliasAssignment ? skipOuterExpressions(aliasAssignment.right) : initializer, isCallExpression);
|
|
const func = cast(skipOuterExpressions(call.expression), isFunctionExpression);
|
|
const funcStatements = func.body.statements;
|
|
let classBodyStart = 0;
|
|
let classBodyEnd = -1;
|
|
const statements = [];
|
|
if (aliasAssignment) {
|
|
const extendsCall = tryCast(funcStatements[classBodyStart], isExpressionStatement);
|
|
if (extendsCall) {
|
|
statements.push(extendsCall);
|
|
classBodyStart++;
|
|
}
|
|
statements.push(funcStatements[classBodyStart]);
|
|
classBodyStart++;
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
aliasAssignment.left,
|
|
cast(variable.name, isIdentifier)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
while (!isReturnStatement(elementAt(funcStatements, classBodyEnd))) {
|
|
classBodyEnd--;
|
|
}
|
|
addRange(statements, funcStatements, classBodyStart, classBodyEnd);
|
|
if (classBodyEnd < -1) {
|
|
addRange(statements, funcStatements, classBodyEnd + 1);
|
|
}
|
|
addRange(statements, remainingStatements);
|
|
addRange(statements, classStatements, 1);
|
|
return factory2.restoreOuterExpressions(
|
|
node.expression,
|
|
factory2.restoreOuterExpressions(
|
|
variable.initializer,
|
|
factory2.restoreOuterExpressions(
|
|
aliasAssignment && aliasAssignment.right,
|
|
factory2.updateCallExpression(
|
|
call,
|
|
factory2.restoreOuterExpressions(
|
|
call.expression,
|
|
factory2.updateFunctionExpression(
|
|
func,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
func.parameters,
|
|
void 0,
|
|
factory2.updateBlock(
|
|
func.body,
|
|
statements
|
|
)
|
|
)
|
|
),
|
|
void 0,
|
|
call.arguments
|
|
)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
function visitSuperCallInBody(node) {
|
|
return visitCallExpressionWithPotentialCapturedThisAssignment(node, false);
|
|
}
|
|
function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) {
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */ || node.expression.kind === 106 /* SuperKeyword */ || isSuperProperty(skipOuterExpressions(node.expression))) {
|
|
const { target, thisArg } = factory2.createCallBinding(node.expression, hoistVariableDeclaration);
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
setEmitFlags(thisArg, 8 /* NoSubstitution */);
|
|
}
|
|
let resultingCall;
|
|
if (node.transformFlags & 32768 /* ContainsRestOrSpread */) {
|
|
resultingCall = factory2.createFunctionApplyCall(
|
|
visitNode(target, callExpressionVisitor, isExpression),
|
|
node.expression.kind === 106 /* SuperKeyword */ ? thisArg : visitNode(thisArg, visitor, isExpression),
|
|
transformAndSpreadElements(node.arguments, true, false, false)
|
|
);
|
|
} else {
|
|
resultingCall = setTextRange(
|
|
factory2.createFunctionCallCall(
|
|
visitNode(target, callExpressionVisitor, isExpression),
|
|
node.expression.kind === 106 /* SuperKeyword */ ? thisArg : visitNode(thisArg, visitor, isExpression),
|
|
visitNodes2(node.arguments, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
if (node.expression.kind === 106 /* SuperKeyword */) {
|
|
const initializer = factory2.createLogicalOr(
|
|
resultingCall,
|
|
createActualThis()
|
|
);
|
|
resultingCall = assignToCapturedThis ? factory2.createAssignment(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), initializer) : initializer;
|
|
}
|
|
return setOriginalNode(resultingCall, node);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNewExpression(node) {
|
|
if (some(node.arguments, isSpreadElement)) {
|
|
const { target, thisArg } = factory2.createCallBinding(factory2.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration);
|
|
return factory2.createNewExpression(
|
|
factory2.createFunctionApplyCall(
|
|
visitNode(target, visitor, isExpression),
|
|
thisArg,
|
|
transformAndSpreadElements(factory2.createNodeArray([factory2.createVoidZero(), ...node.arguments]), true, false, false)
|
|
),
|
|
void 0,
|
|
[]
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndSpreadElements(elements, isArgumentList, multiLine, hasTrailingComma) {
|
|
const numElements = elements.length;
|
|
const segments = flatten(
|
|
spanMap(
|
|
elements,
|
|
partitionSpread,
|
|
(partition, visitPartition, _start, end) => visitPartition(partition, multiLine, hasTrailingComma && end === numElements)
|
|
)
|
|
);
|
|
if (segments.length === 1) {
|
|
const firstSegment = segments[0];
|
|
if (isArgumentList && !compilerOptions.downlevelIteration || isPackedArrayLiteral(firstSegment.expression) || isCallToHelper(firstSegment.expression, "___spreadArray")) {
|
|
return firstSegment.expression;
|
|
}
|
|
}
|
|
const helpers = emitHelpers();
|
|
const startsWithSpread = segments[0].kind !== 0 /* None */;
|
|
let expression = startsWithSpread ? factory2.createArrayLiteralExpression() : segments[0].expression;
|
|
for (let i = startsWithSpread ? 0 : 1; i < segments.length; i++) {
|
|
const segment = segments[i];
|
|
expression = helpers.createSpreadArrayHelper(
|
|
expression,
|
|
segment.expression,
|
|
segment.kind === 1 /* UnpackedSpread */ && !isArgumentList
|
|
);
|
|
}
|
|
return expression;
|
|
}
|
|
function partitionSpread(node) {
|
|
return isSpreadElement(node) ? visitSpanOfSpreads : visitSpanOfNonSpreads;
|
|
}
|
|
function visitSpanOfSpreads(chunk) {
|
|
return map(chunk, visitExpressionOfSpread);
|
|
}
|
|
function visitExpressionOfSpread(node) {
|
|
let expression = visitNode(node.expression, visitor, isExpression);
|
|
const isCallToReadHelper = isCallToHelper(expression, "___read");
|
|
let kind = isCallToReadHelper || isPackedArrayLiteral(expression) ? 2 /* PackedSpread */ : 1 /* UnpackedSpread */;
|
|
if (compilerOptions.downlevelIteration && kind === 1 /* UnpackedSpread */ && !isArrayLiteralExpression(expression) && !isCallToReadHelper) {
|
|
expression = emitHelpers().createReadHelper(expression, void 0);
|
|
kind = 2 /* PackedSpread */;
|
|
}
|
|
return createSpreadSegment(kind, expression);
|
|
}
|
|
function visitSpanOfNonSpreads(chunk, multiLine, hasTrailingComma) {
|
|
const expression = factory2.createArrayLiteralExpression(
|
|
visitNodes2(factory2.createNodeArray(chunk, hasTrailingComma), visitor, isExpression),
|
|
multiLine
|
|
);
|
|
return createSpreadSegment(0 /* None */, expression);
|
|
}
|
|
function visitSpreadElement(node) {
|
|
return visitNode(node.expression, visitor, isExpression);
|
|
}
|
|
function visitTemplateLiteral(node) {
|
|
return setTextRange(factory2.createStringLiteral(node.text), node);
|
|
}
|
|
function visitStringLiteral(node) {
|
|
if (node.hasExtendedUnicodeEscape) {
|
|
return setTextRange(factory2.createStringLiteral(node.text), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitNumericLiteral(node) {
|
|
if (node.numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */) {
|
|
return setTextRange(factory2.createNumericLiteral(node.text), node);
|
|
}
|
|
return node;
|
|
}
|
|
function visitTaggedTemplateExpression(node) {
|
|
return processTaggedTemplateExpression(
|
|
context,
|
|
node,
|
|
visitor,
|
|
currentSourceFile,
|
|
recordTaggedTemplateString,
|
|
1 /* All */
|
|
);
|
|
}
|
|
function visitTemplateExpression(node) {
|
|
let expression = factory2.createStringLiteral(node.head.text);
|
|
for (const span of node.templateSpans) {
|
|
const args = [visitNode(span.expression, visitor, isExpression)];
|
|
if (span.literal.text.length > 0) {
|
|
args.push(factory2.createStringLiteral(span.literal.text));
|
|
}
|
|
expression = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(expression, "concat"),
|
|
void 0,
|
|
args
|
|
);
|
|
}
|
|
return setTextRange(expression, node);
|
|
}
|
|
function visitSuperKeyword(isExpressionOfCall) {
|
|
return hierarchyFacts & 8 /* NonStaticClassElement */ && !isExpressionOfCall ? factory2.createPropertyAccessExpression(factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */), "prototype") : factory2.createUniqueName("_super", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
}
|
|
function visitMetaProperty(node) {
|
|
if (node.keywordToken === 103 /* NewKeyword */ && node.name.escapedText === "target") {
|
|
hierarchyFacts |= 32768 /* NewTarget */;
|
|
return factory2.createUniqueName("_newTarget", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (enabledSubstitutions & 1 /* CapturedThis */ && isFunctionLike(node)) {
|
|
const ancestorFacts = enterSubtree(
|
|
32670 /* FunctionExcludes */,
|
|
getEmitFlags(node) & 16 /* CapturesThis */ ? 65 /* FunctionIncludes */ | 16 /* CapturesThis */ : 65 /* FunctionIncludes */
|
|
);
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
exitSubtree(ancestorFacts, 0 /* None */, 0 /* None */);
|
|
return;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function enableSubstitutionsForBlockScopedBindings() {
|
|
if ((enabledSubstitutions & 2 /* BlockScopedBindings */) === 0) {
|
|
enabledSubstitutions |= 2 /* BlockScopedBindings */;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
}
|
|
function enableSubstitutionsForCapturedThis() {
|
|
if ((enabledSubstitutions & 1 /* CapturedThis */) === 0) {
|
|
enabledSubstitutions |= 1 /* CapturedThis */;
|
|
context.enableSubstitution(108 /* ThisKeyword */);
|
|
context.enableEmitNotification(173 /* Constructor */);
|
|
context.enableEmitNotification(171 /* MethodDeclaration */);
|
|
context.enableEmitNotification(174 /* GetAccessor */);
|
|
context.enableEmitNotification(175 /* SetAccessor */);
|
|
context.enableEmitNotification(216 /* ArrowFunction */);
|
|
context.enableEmitNotification(215 /* FunctionExpression */);
|
|
context.enableEmitNotification(259 /* FunctionDeclaration */);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
if (isIdentifier(node)) {
|
|
return substituteIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteIdentifier(node) {
|
|
if (enabledSubstitutions & 2 /* BlockScopedBindings */ && !isInternalName(node)) {
|
|
const original = getParseTreeNode(node, isIdentifier);
|
|
if (original && isNameOfDeclarationWithCollidingName(original)) {
|
|
return setTextRange(factory2.getGeneratedNameForNode(original), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function isNameOfDeclarationWithCollidingName(node) {
|
|
switch (node.parent.kind) {
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 257 /* VariableDeclaration */:
|
|
return node.parent.name === node && resolver.isDeclarationWithCollidingName(node.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 108 /* ThisKeyword */:
|
|
return substituteThisKeyword(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
if (enabledSubstitutions & 2 /* BlockScopedBindings */ && !isInternalName(node)) {
|
|
const declaration = resolver.getReferencedDeclarationWithCollidingName(node);
|
|
if (declaration && !(isClassLike(declaration) && isPartOfClassBody(declaration, node))) {
|
|
return setTextRange(factory2.getGeneratedNameForNode(getNameOfDeclaration(declaration)), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function isPartOfClassBody(declaration, node) {
|
|
let currentNode = getParseTreeNode(node);
|
|
if (!currentNode || currentNode === declaration || currentNode.end <= declaration.pos || currentNode.pos >= declaration.end) {
|
|
return false;
|
|
}
|
|
const blockScope = getEnclosingBlockScopeContainer(declaration);
|
|
while (currentNode) {
|
|
if (currentNode === blockScope || currentNode === declaration) {
|
|
return false;
|
|
}
|
|
if (isClassElement(currentNode) && currentNode.parent === declaration) {
|
|
return true;
|
|
}
|
|
currentNode = currentNode.parent;
|
|
}
|
|
return false;
|
|
}
|
|
function substituteThisKeyword(node) {
|
|
if (enabledSubstitutions & 1 /* CapturedThis */ && hierarchyFacts & 16 /* CapturesThis */) {
|
|
return setTextRange(factory2.createUniqueName("_this", 16 /* Optimistic */ | 32 /* FileLevel */), node);
|
|
}
|
|
return node;
|
|
}
|
|
function getClassMemberPrefix(node, member) {
|
|
return isStatic(member) ? factory2.getInternalName(node) : factory2.createPropertyAccessExpression(factory2.getInternalName(node), "prototype");
|
|
}
|
|
function hasSynthesizedDefaultSuperCall(constructor, hasExtendsClause) {
|
|
if (!constructor || !hasExtendsClause) {
|
|
return false;
|
|
}
|
|
if (some(constructor.parameters)) {
|
|
return false;
|
|
}
|
|
const statement = firstOrUndefined(constructor.body.statements);
|
|
if (!statement || !nodeIsSynthesized(statement) || statement.kind !== 241 /* ExpressionStatement */) {
|
|
return false;
|
|
}
|
|
const statementExpression = statement.expression;
|
|
if (!nodeIsSynthesized(statementExpression) || statementExpression.kind !== 210 /* CallExpression */) {
|
|
return false;
|
|
}
|
|
const callTarget = statementExpression.expression;
|
|
if (!nodeIsSynthesized(callTarget) || callTarget.kind !== 106 /* SuperKeyword */) {
|
|
return false;
|
|
}
|
|
const callArgument = singleOrUndefined(statementExpression.arguments);
|
|
if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== 227 /* SpreadElement */) {
|
|
return false;
|
|
}
|
|
const expression = callArgument.expression;
|
|
return isIdentifier(expression) && expression.escapedText === "arguments";
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/es5.ts
|
|
function transformES5(context) {
|
|
const { factory: factory2 } = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
let previousOnEmitNode;
|
|
let noSubstitution;
|
|
if (compilerOptions.jsx === 1 /* Preserve */ || compilerOptions.jsx === 3 /* ReactNative */) {
|
|
previousOnEmitNode = context.onEmitNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableEmitNotification(283 /* JsxOpeningElement */);
|
|
context.enableEmitNotification(284 /* JsxClosingElement */);
|
|
context.enableEmitNotification(282 /* JsxSelfClosingElement */);
|
|
noSubstitution = [];
|
|
}
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableSubstitution(208 /* PropertyAccessExpression */);
|
|
context.enableSubstitution(299 /* PropertyAssignment */);
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
switch (node.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
const tagName = node.tagName;
|
|
noSubstitution[getOriginalNodeId(tagName)] = true;
|
|
break;
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
if (node.id && noSubstitution && noSubstitution[node.id]) {
|
|
return previousOnSubstituteNode(hint, node);
|
|
}
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (isPropertyAccessExpression(node)) {
|
|
return substitutePropertyAccessExpression(node);
|
|
} else if (isPropertyAssignment(node)) {
|
|
return substitutePropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAccessExpression(node) {
|
|
if (isPrivateIdentifier(node.name)) {
|
|
return node;
|
|
}
|
|
const literalName = trySubstituteReservedName(node.name);
|
|
if (literalName) {
|
|
return setTextRange(factory2.createElementAccessExpression(node.expression, literalName), node);
|
|
}
|
|
return node;
|
|
}
|
|
function substitutePropertyAssignment(node) {
|
|
const literalName = isIdentifier(node.name) && trySubstituteReservedName(node.name);
|
|
if (literalName) {
|
|
return factory2.updatePropertyAssignment(node, literalName, node.initializer);
|
|
}
|
|
return node;
|
|
}
|
|
function trySubstituteReservedName(name) {
|
|
const token = name.originalKeywordKind || (nodeIsSynthesized(name) ? stringToToken(idText(name)) : void 0);
|
|
if (token !== void 0 && token >= 81 /* FirstReservedWord */ && token <= 116 /* LastReservedWord */) {
|
|
return setTextRange(factory2.createStringLiteralFromNode(name), name);
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/generators.ts
|
|
function getInstructionName(instruction) {
|
|
switch (instruction) {
|
|
case 2 /* Return */:
|
|
return "return";
|
|
case 3 /* Break */:
|
|
return "break";
|
|
case 4 /* Yield */:
|
|
return "yield";
|
|
case 5 /* YieldStar */:
|
|
return "yield*";
|
|
case 7 /* Endfinally */:
|
|
return "endfinally";
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function transformGenerators(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistFunctionDeclaration,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const resolver = context.getEmitResolver();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
let renamedCatchVariables;
|
|
let renamedCatchVariableDeclarations;
|
|
let inGeneratorFunctionBody;
|
|
let inStatementContainingYield;
|
|
let blocks;
|
|
let blockOffsets;
|
|
let blockActions;
|
|
let blockStack;
|
|
let labelOffsets;
|
|
let labelExpressions;
|
|
let nextLabelId = 1;
|
|
let operations;
|
|
let operationArguments;
|
|
let operationLocations;
|
|
let state;
|
|
let blockIndex = 0;
|
|
let labelNumber = 0;
|
|
let labelNumbers;
|
|
let lastOperationWasAbrupt;
|
|
let lastOperationWasCompletion;
|
|
let clauses;
|
|
let statements;
|
|
let exceptionBlockStack;
|
|
let currentExceptionBlock;
|
|
let withBlockStack;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || (node.transformFlags & 2048 /* ContainsGenerator */) === 0) {
|
|
return node;
|
|
}
|
|
const visited = visitEachChild(node, visitor, context);
|
|
addEmitHelpers(visited, context.readEmitHelpers());
|
|
return visited;
|
|
}
|
|
function visitor(node) {
|
|
const transformFlags = node.transformFlags;
|
|
if (inStatementContainingYield) {
|
|
return visitJavaScriptInStatementContainingYield(node);
|
|
} else if (inGeneratorFunctionBody) {
|
|
return visitJavaScriptInGeneratorFunctionBody(node);
|
|
} else if (isFunctionLikeDeclaration(node) && node.asteriskToken) {
|
|
return visitGenerator(node);
|
|
} else if (transformFlags & 2048 /* ContainsGenerator */) {
|
|
return visitEachChild(node, visitor, context);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitJavaScriptInStatementContainingYield(node) {
|
|
switch (node.kind) {
|
|
case 243 /* DoStatement */:
|
|
return visitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return visitWhileStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
default:
|
|
return visitJavaScriptInGeneratorFunctionBody(node);
|
|
}
|
|
}
|
|
function visitJavaScriptInGeneratorFunctionBody(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return visitAccessorDeclaration(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return visitBreakStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return visitContinueStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return visitReturnStatement(node);
|
|
default:
|
|
if (node.transformFlags & 1048576 /* ContainsYield */) {
|
|
return visitJavaScriptContainingYield(node);
|
|
} else if (node.transformFlags & (2048 /* ContainsGenerator */ | 4194304 /* ContainsHoistedDeclarationOrCompletion */)) {
|
|
return visitEachChild(node, visitor, context);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function visitJavaScriptContainingYield(node) {
|
|
switch (node.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
return visitBinaryExpression(node);
|
|
case 354 /* CommaListExpression */:
|
|
return visitCommaListExpression(node);
|
|
case 224 /* ConditionalExpression */:
|
|
return visitConditionalExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return visitYieldExpression(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return visitArrayLiteralExpression(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return visitObjectLiteralExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return visitElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return visitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return visitNewExpression(node);
|
|
default:
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitGenerator(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 215 /* FunctionExpression */:
|
|
return visitFunctionExpression(node);
|
|
default:
|
|
return Debug.failBadSyntaxKind(node);
|
|
}
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (node.asteriskToken) {
|
|
node = setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionDeclaration(
|
|
node.modifiers,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformGeneratorFunctionBody(node.body)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
if (inGeneratorFunctionBody) {
|
|
hoistFunctionDeclaration(node);
|
|
return void 0;
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
function visitFunctionExpression(node) {
|
|
if (node.asteriskToken) {
|
|
node = setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
node.name,
|
|
void 0,
|
|
visitParameterList(node.parameters, visitor, context),
|
|
void 0,
|
|
transformGeneratorFunctionBody(node.body)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
return node;
|
|
}
|
|
function visitAccessorDeclaration(node) {
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
inGeneratorFunctionBody = false;
|
|
inStatementContainingYield = false;
|
|
node = visitEachChild(node, visitor, context);
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
return node;
|
|
}
|
|
function transformGeneratorFunctionBody(body) {
|
|
const statements2 = [];
|
|
const savedInGeneratorFunctionBody = inGeneratorFunctionBody;
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
const savedBlocks = blocks;
|
|
const savedBlockOffsets = blockOffsets;
|
|
const savedBlockActions = blockActions;
|
|
const savedBlockStack = blockStack;
|
|
const savedLabelOffsets = labelOffsets;
|
|
const savedLabelExpressions = labelExpressions;
|
|
const savedNextLabelId = nextLabelId;
|
|
const savedOperations = operations;
|
|
const savedOperationArguments = operationArguments;
|
|
const savedOperationLocations = operationLocations;
|
|
const savedState = state;
|
|
inGeneratorFunctionBody = true;
|
|
inStatementContainingYield = false;
|
|
blocks = void 0;
|
|
blockOffsets = void 0;
|
|
blockActions = void 0;
|
|
blockStack = void 0;
|
|
labelOffsets = void 0;
|
|
labelExpressions = void 0;
|
|
nextLabelId = 1;
|
|
operations = void 0;
|
|
operationArguments = void 0;
|
|
operationLocations = void 0;
|
|
state = factory2.createTempVariable(void 0);
|
|
resumeLexicalEnvironment();
|
|
const statementOffset = factory2.copyPrologue(body.statements, statements2, false, visitor);
|
|
transformAndEmitStatements(body.statements, statementOffset);
|
|
const buildResult = build2();
|
|
insertStatementsAfterStandardPrologue(statements2, endLexicalEnvironment());
|
|
statements2.push(factory2.createReturnStatement(buildResult));
|
|
inGeneratorFunctionBody = savedInGeneratorFunctionBody;
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
blocks = savedBlocks;
|
|
blockOffsets = savedBlockOffsets;
|
|
blockActions = savedBlockActions;
|
|
blockStack = savedBlockStack;
|
|
labelOffsets = savedLabelOffsets;
|
|
labelExpressions = savedLabelExpressions;
|
|
nextLabelId = savedNextLabelId;
|
|
operations = savedOperations;
|
|
operationArguments = savedOperationArguments;
|
|
operationLocations = savedOperationLocations;
|
|
state = savedState;
|
|
return setTextRange(factory2.createBlock(statements2, body.multiLine), body);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (node.transformFlags & 1048576 /* ContainsYield */) {
|
|
transformAndEmitVariableDeclarationList(node.declarationList);
|
|
return void 0;
|
|
} else {
|
|
if (getEmitFlags(node) & 2097152 /* CustomPrologue */) {
|
|
return node;
|
|
}
|
|
for (const variable of node.declarationList.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
const variables = getInitializedVariables(node.declarationList);
|
|
if (variables.length === 0) {
|
|
return void 0;
|
|
}
|
|
return setSourceMapRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.inlineExpressions(
|
|
map(variables, transformInitializedVariable)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitBinaryExpression(node) {
|
|
const assoc = getExpressionAssociativity(node);
|
|
switch (assoc) {
|
|
case 0 /* Left */:
|
|
return visitLeftAssociativeBinaryExpression(node);
|
|
case 1 /* Right */:
|
|
return visitRightAssociativeBinaryExpression(node);
|
|
default:
|
|
return Debug.assertNever(assoc);
|
|
}
|
|
}
|
|
function visitRightAssociativeBinaryExpression(node) {
|
|
const { left, right } = node;
|
|
if (containsYield(right)) {
|
|
let target;
|
|
switch (left.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
target = factory2.updatePropertyAccessExpression(
|
|
left,
|
|
cacheExpression(visitNode(left.expression, visitor, isLeftHandSideExpression)),
|
|
left.name
|
|
);
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
target = factory2.updateElementAccessExpression(
|
|
left,
|
|
cacheExpression(visitNode(left.expression, visitor, isLeftHandSideExpression)),
|
|
cacheExpression(visitNode(left.argumentExpression, visitor, isExpression))
|
|
);
|
|
break;
|
|
default:
|
|
target = visitNode(left, visitor, isExpression);
|
|
break;
|
|
}
|
|
const operator = node.operatorToken.kind;
|
|
if (isCompoundAssignment(operator)) {
|
|
return setTextRange(
|
|
factory2.createAssignment(
|
|
target,
|
|
setTextRange(
|
|
factory2.createBinaryExpression(
|
|
cacheExpression(target),
|
|
getNonAssignmentOperatorForCompoundAssignment(operator),
|
|
visitNode(right, visitor, isExpression)
|
|
),
|
|
node
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else {
|
|
return factory2.updateBinaryExpression(node, target, node.operatorToken, visitNode(right, visitor, isExpression));
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitLeftAssociativeBinaryExpression(node) {
|
|
if (containsYield(node.right)) {
|
|
if (isLogicalOperator(node.operatorToken.kind)) {
|
|
return visitLogicalBinaryExpression(node);
|
|
} else if (node.operatorToken.kind === 27 /* CommaToken */) {
|
|
return visitCommaExpression(node);
|
|
}
|
|
return factory2.updateBinaryExpression(
|
|
node,
|
|
cacheExpression(visitNode(node.left, visitor, isExpression)),
|
|
node.operatorToken,
|
|
visitNode(node.right, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCommaExpression(node) {
|
|
let pendingExpressions = [];
|
|
visit(node.left);
|
|
visit(node.right);
|
|
return factory2.inlineExpressions(pendingExpressions);
|
|
function visit(node2) {
|
|
if (isBinaryExpression(node2) && node2.operatorToken.kind === 27 /* CommaToken */) {
|
|
visit(node2.left);
|
|
visit(node2.right);
|
|
} else {
|
|
if (containsYield(node2) && pendingExpressions.length > 0) {
|
|
emitWorker(1 /* Statement */, [factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions))]);
|
|
pendingExpressions = [];
|
|
}
|
|
pendingExpressions.push(visitNode(node2, visitor, isExpression));
|
|
}
|
|
}
|
|
}
|
|
function visitCommaListExpression(node) {
|
|
let pendingExpressions = [];
|
|
for (const elem of node.elements) {
|
|
if (isBinaryExpression(elem) && elem.operatorToken.kind === 27 /* CommaToken */) {
|
|
pendingExpressions.push(visitCommaExpression(elem));
|
|
} else {
|
|
if (containsYield(elem) && pendingExpressions.length > 0) {
|
|
emitWorker(1 /* Statement */, [factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions))]);
|
|
pendingExpressions = [];
|
|
}
|
|
pendingExpressions.push(visitNode(elem, visitor, isExpression));
|
|
}
|
|
}
|
|
return factory2.inlineExpressions(pendingExpressions);
|
|
}
|
|
function visitLogicalBinaryExpression(node) {
|
|
const resultLabel = defineLabel();
|
|
const resultLocal = declareLocal();
|
|
emitAssignment(resultLocal, visitNode(node.left, visitor, isExpression), node.left);
|
|
if (node.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
emitBreakWhenFalse(resultLabel, resultLocal, node.left);
|
|
} else {
|
|
emitBreakWhenTrue(resultLabel, resultLocal, node.left);
|
|
}
|
|
emitAssignment(resultLocal, visitNode(node.right, visitor, isExpression), node.right);
|
|
markLabel(resultLabel);
|
|
return resultLocal;
|
|
}
|
|
function visitConditionalExpression(node) {
|
|
if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) {
|
|
const whenFalseLabel = defineLabel();
|
|
const resultLabel = defineLabel();
|
|
const resultLocal = declareLocal();
|
|
emitBreakWhenFalse(whenFalseLabel, visitNode(node.condition, visitor, isExpression), node.condition);
|
|
emitAssignment(resultLocal, visitNode(node.whenTrue, visitor, isExpression), node.whenTrue);
|
|
emitBreak(resultLabel);
|
|
markLabel(whenFalseLabel);
|
|
emitAssignment(resultLocal, visitNode(node.whenFalse, visitor, isExpression), node.whenFalse);
|
|
markLabel(resultLabel);
|
|
return resultLocal;
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitYieldExpression(node) {
|
|
const resumeLabel = defineLabel();
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
if (node.asteriskToken) {
|
|
const iterator = (getEmitFlags(node.expression) & 16777216 /* Iterator */) === 0 ? setTextRange(emitHelpers().createValuesHelper(expression), node) : expression;
|
|
emitYieldStar(iterator, node);
|
|
} else {
|
|
emitYield(expression, node);
|
|
}
|
|
markLabel(resumeLabel);
|
|
return createGeneratorResume(node);
|
|
}
|
|
function visitArrayLiteralExpression(node) {
|
|
return visitElements(node.elements, void 0, void 0, node.multiLine);
|
|
}
|
|
function visitElements(elements, leadingElement, location2, multiLine) {
|
|
const numInitialElements = countInitialNodesWithoutYield(elements);
|
|
let temp;
|
|
if (numInitialElements > 0) {
|
|
temp = declareLocal();
|
|
const initialElements = visitNodes2(elements, visitor, isExpression, 0, numInitialElements);
|
|
emitAssignment(
|
|
temp,
|
|
factory2.createArrayLiteralExpression(
|
|
leadingElement ? [leadingElement, ...initialElements] : initialElements
|
|
)
|
|
);
|
|
leadingElement = void 0;
|
|
}
|
|
const expressions = reduceLeft(elements, reduceElement, [], numInitialElements);
|
|
return temp ? factory2.createArrayConcatCall(temp, [factory2.createArrayLiteralExpression(expressions, multiLine)]) : setTextRange(
|
|
factory2.createArrayLiteralExpression(leadingElement ? [leadingElement, ...expressions] : expressions, multiLine),
|
|
location2
|
|
);
|
|
function reduceElement(expressions2, element) {
|
|
if (containsYield(element) && expressions2.length > 0) {
|
|
const hasAssignedTemp = temp !== void 0;
|
|
if (!temp) {
|
|
temp = declareLocal();
|
|
}
|
|
emitAssignment(
|
|
temp,
|
|
hasAssignedTemp ? factory2.createArrayConcatCall(
|
|
temp,
|
|
[factory2.createArrayLiteralExpression(expressions2, multiLine)]
|
|
) : factory2.createArrayLiteralExpression(
|
|
leadingElement ? [leadingElement, ...expressions2] : expressions2,
|
|
multiLine
|
|
)
|
|
);
|
|
leadingElement = void 0;
|
|
expressions2 = [];
|
|
}
|
|
expressions2.push(visitNode(element, visitor, isExpression));
|
|
return expressions2;
|
|
}
|
|
}
|
|
function visitObjectLiteralExpression(node) {
|
|
const properties = node.properties;
|
|
const multiLine = node.multiLine;
|
|
const numInitialProperties = countInitialNodesWithoutYield(properties);
|
|
const temp = declareLocal();
|
|
emitAssignment(
|
|
temp,
|
|
factory2.createObjectLiteralExpression(
|
|
visitNodes2(properties, visitor, isObjectLiteralElementLike, 0, numInitialProperties),
|
|
multiLine
|
|
)
|
|
);
|
|
const expressions = reduceLeft(properties, reduceProperty, [], numInitialProperties);
|
|
expressions.push(multiLine ? startOnNewLine(setParent(setTextRange(factory2.cloneNode(temp), temp), temp.parent)) : temp);
|
|
return factory2.inlineExpressions(expressions);
|
|
function reduceProperty(expressions2, property) {
|
|
if (containsYield(property) && expressions2.length > 0) {
|
|
emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(expressions2)));
|
|
expressions2 = [];
|
|
}
|
|
const expression = createExpressionForObjectLiteralElementLike(factory2, node, property, temp);
|
|
const visited = visitNode(expression, visitor, isExpression);
|
|
if (visited) {
|
|
if (multiLine) {
|
|
startOnNewLine(visited);
|
|
}
|
|
expressions2.push(visited);
|
|
}
|
|
return expressions2;
|
|
}
|
|
}
|
|
function visitElementAccessExpression(node) {
|
|
if (containsYield(node.argumentExpression)) {
|
|
return factory2.updateElementAccessExpression(
|
|
node,
|
|
cacheExpression(visitNode(node.expression, visitor, isLeftHandSideExpression)),
|
|
visitNode(node.argumentExpression, visitor, isExpression)
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitCallExpression(node) {
|
|
if (!isImportCall(node) && forEach(node.arguments, containsYield)) {
|
|
const { target, thisArg } = factory2.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, true);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionApplyCall(
|
|
cacheExpression(visitNode(target, visitor, isLeftHandSideExpression)),
|
|
thisArg,
|
|
visitElements(node.arguments)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitNewExpression(node) {
|
|
if (forEach(node.arguments, containsYield)) {
|
|
const { target, thisArg } = factory2.createCallBinding(factory2.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration);
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createNewExpression(
|
|
factory2.createFunctionApplyCall(
|
|
cacheExpression(visitNode(target, visitor, isExpression)),
|
|
thisArg,
|
|
visitElements(
|
|
node.arguments,
|
|
factory2.createVoidZero()
|
|
)
|
|
),
|
|
void 0,
|
|
[]
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitStatements(statements2, start2 = 0) {
|
|
const numStatements = statements2.length;
|
|
for (let i = start2; i < numStatements; i++) {
|
|
transformAndEmitStatement(statements2[i]);
|
|
}
|
|
}
|
|
function transformAndEmitEmbeddedStatement(node) {
|
|
if (isBlock(node)) {
|
|
transformAndEmitStatements(node.statements);
|
|
} else {
|
|
transformAndEmitStatement(node);
|
|
}
|
|
}
|
|
function transformAndEmitStatement(node) {
|
|
const savedInStatementContainingYield = inStatementContainingYield;
|
|
if (!inStatementContainingYield) {
|
|
inStatementContainingYield = containsYield(node);
|
|
}
|
|
transformAndEmitStatementWorker(node);
|
|
inStatementContainingYield = savedInStatementContainingYield;
|
|
}
|
|
function transformAndEmitStatementWorker(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
return transformAndEmitBlock(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return transformAndEmitExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return transformAndEmitIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return transformAndEmitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return transformAndEmitWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return transformAndEmitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return transformAndEmitForInStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return transformAndEmitContinueStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return transformAndEmitBreakStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return transformAndEmitReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return transformAndEmitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return transformAndEmitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return transformAndEmitLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return transformAndEmitThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return transformAndEmitTryStatement(node);
|
|
default:
|
|
return emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitBlock(node) {
|
|
if (containsYield(node)) {
|
|
transformAndEmitStatements(node.statements);
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitExpressionStatement(node) {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
function transformAndEmitVariableDeclarationList(node) {
|
|
for (const variable of node.declarations) {
|
|
const name = factory2.cloneNode(variable.name);
|
|
setCommentRange(name, variable.name);
|
|
hoistVariableDeclaration(name);
|
|
}
|
|
const variables = getInitializedVariables(node);
|
|
const numVariables = variables.length;
|
|
let variablesWritten = 0;
|
|
let pendingExpressions = [];
|
|
while (variablesWritten < numVariables) {
|
|
for (let i = variablesWritten; i < numVariables; i++) {
|
|
const variable = variables[i];
|
|
if (containsYield(variable.initializer) && pendingExpressions.length > 0) {
|
|
break;
|
|
}
|
|
pendingExpressions.push(transformInitializedVariable(variable));
|
|
}
|
|
if (pendingExpressions.length) {
|
|
emitStatement(factory2.createExpressionStatement(factory2.inlineExpressions(pendingExpressions)));
|
|
variablesWritten += pendingExpressions.length;
|
|
pendingExpressions = [];
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
return setSourceMapRange(
|
|
factory2.createAssignment(
|
|
setSourceMapRange(factory2.cloneNode(node.name), node.name),
|
|
visitNode(node.initializer, visitor, isExpression)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitIfStatement(node) {
|
|
if (containsYield(node)) {
|
|
if (containsYield(node.thenStatement) || containsYield(node.elseStatement)) {
|
|
const endLabel = defineLabel();
|
|
const elseLabel = node.elseStatement ? defineLabel() : void 0;
|
|
emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, visitNode(node.expression, visitor, isExpression), node.expression);
|
|
transformAndEmitEmbeddedStatement(node.thenStatement);
|
|
if (node.elseStatement) {
|
|
emitBreak(endLabel);
|
|
markLabel(elseLabel);
|
|
transformAndEmitEmbeddedStatement(node.elseStatement);
|
|
}
|
|
markLabel(endLabel);
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitDoStatement(node) {
|
|
if (containsYield(node)) {
|
|
const conditionLabel = defineLabel();
|
|
const loopLabel = defineLabel();
|
|
beginLoopBlock(conditionLabel);
|
|
markLabel(loopLabel);
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(conditionLabel);
|
|
emitBreakWhenTrue(loopLabel, visitNode(node.expression, visitor, isExpression));
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitDoStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
node = visitEachChild(node, visitor, context);
|
|
endLoopBlock();
|
|
return node;
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformAndEmitWhileStatement(node) {
|
|
if (containsYield(node)) {
|
|
const loopLabel = defineLabel();
|
|
const endLabel = beginLoopBlock(loopLabel);
|
|
markLabel(loopLabel);
|
|
emitBreakWhenFalse(endLabel, visitNode(node.expression, visitor, isExpression));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
emitBreak(loopLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitWhileStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
node = visitEachChild(node, visitor, context);
|
|
endLoopBlock();
|
|
return node;
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function transformAndEmitForStatement(node) {
|
|
if (containsYield(node)) {
|
|
const conditionLabel = defineLabel();
|
|
const incrementLabel = defineLabel();
|
|
const endLabel = beginLoopBlock(incrementLabel);
|
|
if (node.initializer) {
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
transformAndEmitVariableDeclarationList(initializer);
|
|
} else {
|
|
emitStatement(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
visitNode(initializer, visitor, isExpression)
|
|
),
|
|
initializer
|
|
)
|
|
);
|
|
}
|
|
}
|
|
markLabel(conditionLabel);
|
|
if (node.condition) {
|
|
emitBreakWhenFalse(endLabel, visitNode(node.condition, visitor, isExpression));
|
|
}
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(incrementLabel);
|
|
if (node.incrementor) {
|
|
emitStatement(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
visitNode(node.incrementor, visitor, isExpression)
|
|
),
|
|
node.incrementor
|
|
)
|
|
);
|
|
}
|
|
emitBreak(conditionLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitForStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
}
|
|
const initializer = node.initializer;
|
|
if (initializer && isVariableDeclarationList(initializer)) {
|
|
for (const variable of initializer.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
const variables = getInitializedVariables(initializer);
|
|
node = factory2.updateForStatement(
|
|
node,
|
|
variables.length > 0 ? factory2.inlineExpressions(map(variables, transformInitializedVariable)) : void 0,
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, visitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
} else {
|
|
node = visitEachChild(node, visitor, context);
|
|
}
|
|
if (inStatementContainingYield) {
|
|
endLoopBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitForInStatement(node) {
|
|
if (containsYield(node)) {
|
|
const obj = declareLocal();
|
|
const keysArray = declareLocal();
|
|
const key = declareLocal();
|
|
const keysIndex = factory2.createLoopVariable();
|
|
const initializer = node.initializer;
|
|
hoistVariableDeclaration(keysIndex);
|
|
emitAssignment(obj, visitNode(node.expression, visitor, isExpression));
|
|
emitAssignment(keysArray, factory2.createArrayLiteralExpression());
|
|
emitStatement(
|
|
factory2.createForInStatement(
|
|
key,
|
|
obj,
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(keysArray, "push"),
|
|
void 0,
|
|
[key]
|
|
)
|
|
)
|
|
)
|
|
);
|
|
emitAssignment(keysIndex, factory2.createNumericLiteral(0));
|
|
const conditionLabel = defineLabel();
|
|
const incrementLabel = defineLabel();
|
|
const endLoopLabel = beginLoopBlock(incrementLabel);
|
|
markLabel(conditionLabel);
|
|
emitBreakWhenFalse(endLoopLabel, factory2.createLessThan(keysIndex, factory2.createPropertyAccessExpression(keysArray, "length")));
|
|
emitAssignment(key, factory2.createElementAccessExpression(keysArray, keysIndex));
|
|
emitBreakWhenFalse(incrementLabel, factory2.createBinaryExpression(key, 101 /* InKeyword */, obj));
|
|
let variable;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
for (const variable2 of initializer.declarations) {
|
|
hoistVariableDeclaration(variable2.name);
|
|
}
|
|
variable = factory2.cloneNode(initializer.declarations[0].name);
|
|
} else {
|
|
variable = visitNode(initializer, visitor, isExpression);
|
|
Debug.assert(isLeftHandSideExpression(variable));
|
|
}
|
|
emitAssignment(variable, key);
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
markLabel(incrementLabel);
|
|
emitStatement(factory2.createExpressionStatement(factory2.createPostfixIncrement(keysIndex)));
|
|
emitBreak(conditionLabel);
|
|
endLoopBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitForInStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLoopBlock();
|
|
}
|
|
const initializer = node.initializer;
|
|
if (isVariableDeclarationList(initializer)) {
|
|
for (const variable of initializer.declarations) {
|
|
hoistVariableDeclaration(variable.name);
|
|
}
|
|
node = factory2.updateForInStatement(
|
|
node,
|
|
initializer.declarations[0].name,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.statement, visitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
} else {
|
|
node = visitEachChild(node, visitor, context);
|
|
}
|
|
if (inStatementContainingYield) {
|
|
endLoopBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitContinueStatement(node) {
|
|
const label = findContinueTarget(node.label ? idText(node.label) : void 0);
|
|
if (label > 0) {
|
|
emitBreak(label, node);
|
|
} else {
|
|
emitStatement(node);
|
|
}
|
|
}
|
|
function visitContinueStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
const label = findContinueTarget(node.label && idText(node.label));
|
|
if (label > 0) {
|
|
return createInlineBreak(label, node);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitBreakStatement(node) {
|
|
const label = findBreakTarget(node.label ? idText(node.label) : void 0);
|
|
if (label > 0) {
|
|
emitBreak(label, node);
|
|
} else {
|
|
emitStatement(node);
|
|
}
|
|
}
|
|
function visitBreakStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
const label = findBreakTarget(node.label && idText(node.label));
|
|
if (label > 0) {
|
|
return createInlineBreak(label, node);
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function transformAndEmitReturnStatement(node) {
|
|
emitReturn(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function visitReturnStatement(node) {
|
|
return createInlineReturn(
|
|
visitNode(node.expression, visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitWithStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginWithBlock(cacheExpression(visitNode(node.expression, visitor, isExpression)));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
endWithBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function transformAndEmitSwitchStatement(node) {
|
|
if (containsYield(node.caseBlock)) {
|
|
const caseBlock = node.caseBlock;
|
|
const numClauses = caseBlock.clauses.length;
|
|
const endLabel = beginSwitchBlock();
|
|
const expression = cacheExpression(visitNode(node.expression, visitor, isExpression));
|
|
const clauseLabels = [];
|
|
let defaultClauseIndex = -1;
|
|
for (let i = 0; i < numClauses; i++) {
|
|
const clause = caseBlock.clauses[i];
|
|
clauseLabels.push(defineLabel());
|
|
if (clause.kind === 293 /* DefaultClause */ && defaultClauseIndex === -1) {
|
|
defaultClauseIndex = i;
|
|
}
|
|
}
|
|
let clausesWritten = 0;
|
|
let pendingClauses = [];
|
|
while (clausesWritten < numClauses) {
|
|
let defaultClausesSkipped = 0;
|
|
for (let i = clausesWritten; i < numClauses; i++) {
|
|
const clause = caseBlock.clauses[i];
|
|
if (clause.kind === 292 /* CaseClause */) {
|
|
if (containsYield(clause.expression) && pendingClauses.length > 0) {
|
|
break;
|
|
}
|
|
pendingClauses.push(
|
|
factory2.createCaseClause(
|
|
visitNode(clause.expression, visitor, isExpression),
|
|
[
|
|
createInlineBreak(clauseLabels[i], clause.expression)
|
|
]
|
|
)
|
|
);
|
|
} else {
|
|
defaultClausesSkipped++;
|
|
}
|
|
}
|
|
if (pendingClauses.length) {
|
|
emitStatement(factory2.createSwitchStatement(expression, factory2.createCaseBlock(pendingClauses)));
|
|
clausesWritten += pendingClauses.length;
|
|
pendingClauses = [];
|
|
}
|
|
if (defaultClausesSkipped > 0) {
|
|
clausesWritten += defaultClausesSkipped;
|
|
defaultClausesSkipped = 0;
|
|
}
|
|
}
|
|
if (defaultClauseIndex >= 0) {
|
|
emitBreak(clauseLabels[defaultClauseIndex]);
|
|
} else {
|
|
emitBreak(endLabel);
|
|
}
|
|
for (let i = 0; i < numClauses; i++) {
|
|
markLabel(clauseLabels[i]);
|
|
transformAndEmitStatements(caseBlock.clauses[i].statements);
|
|
}
|
|
endSwitchBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptSwitchBlock();
|
|
}
|
|
node = visitEachChild(node, visitor, context);
|
|
if (inStatementContainingYield) {
|
|
endSwitchBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitLabeledStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginLabeledBlock(idText(node.label));
|
|
transformAndEmitEmbeddedStatement(node.statement);
|
|
endLabeledBlock();
|
|
} else {
|
|
emitStatement(visitNode(node, visitor, isStatement));
|
|
}
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
if (inStatementContainingYield) {
|
|
beginScriptLabeledBlock(idText(node.label));
|
|
}
|
|
node = visitEachChild(node, visitor, context);
|
|
if (inStatementContainingYield) {
|
|
endLabeledBlock();
|
|
}
|
|
return node;
|
|
}
|
|
function transformAndEmitThrowStatement(node) {
|
|
var _a2;
|
|
emitThrow(
|
|
visitNode((_a2 = node.expression) != null ? _a2 : factory2.createVoidZero(), visitor, isExpression),
|
|
node
|
|
);
|
|
}
|
|
function transformAndEmitTryStatement(node) {
|
|
if (containsYield(node)) {
|
|
beginExceptionBlock();
|
|
transformAndEmitEmbeddedStatement(node.tryBlock);
|
|
if (node.catchClause) {
|
|
beginCatchBlock(node.catchClause.variableDeclaration);
|
|
transformAndEmitEmbeddedStatement(node.catchClause.block);
|
|
}
|
|
if (node.finallyBlock) {
|
|
beginFinallyBlock();
|
|
transformAndEmitEmbeddedStatement(node.finallyBlock);
|
|
}
|
|
endExceptionBlock();
|
|
} else {
|
|
emitStatement(visitEachChild(node, visitor, context));
|
|
}
|
|
}
|
|
function containsYield(node) {
|
|
return !!node && (node.transformFlags & 1048576 /* ContainsYield */) !== 0;
|
|
}
|
|
function countInitialNodesWithoutYield(nodes) {
|
|
const numNodes = nodes.length;
|
|
for (let i = 0; i < numNodes; i++) {
|
|
if (containsYield(nodes[i])) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
if (isIdentifier(node)) {
|
|
return substituteExpressionIdentifier(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
if (!isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(idText(node))) {
|
|
const original = getOriginalNode(node);
|
|
if (isIdentifier(original) && original.parent) {
|
|
const declaration = resolver.getReferencedValueDeclaration(original);
|
|
if (declaration) {
|
|
const name = renamedCatchVariableDeclarations[getOriginalNodeId(declaration)];
|
|
if (name) {
|
|
const clone2 = setParent(setTextRange(factory2.cloneNode(name), name), name.parent);
|
|
setSourceMapRange(clone2, node);
|
|
setCommentRange(clone2, node);
|
|
return clone2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function cacheExpression(node) {
|
|
if (isGeneratedIdentifier(node) || getEmitFlags(node) & 8192 /* HelperName */) {
|
|
return node;
|
|
}
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
emitAssignment(temp, node, node);
|
|
return temp;
|
|
}
|
|
function declareLocal(name) {
|
|
const temp = name ? factory2.createUniqueName(name) : factory2.createTempVariable(void 0);
|
|
hoistVariableDeclaration(temp);
|
|
return temp;
|
|
}
|
|
function defineLabel() {
|
|
if (!labelOffsets) {
|
|
labelOffsets = [];
|
|
}
|
|
const label = nextLabelId;
|
|
nextLabelId++;
|
|
labelOffsets[label] = -1;
|
|
return label;
|
|
}
|
|
function markLabel(label) {
|
|
Debug.assert(labelOffsets !== void 0, "No labels were defined.");
|
|
labelOffsets[label] = operations ? operations.length : 0;
|
|
}
|
|
function beginBlock(block) {
|
|
if (!blocks) {
|
|
blocks = [];
|
|
blockActions = [];
|
|
blockOffsets = [];
|
|
blockStack = [];
|
|
}
|
|
const index = blockActions.length;
|
|
blockActions[index] = 0 /* Open */;
|
|
blockOffsets[index] = operations ? operations.length : 0;
|
|
blocks[index] = block;
|
|
blockStack.push(block);
|
|
return index;
|
|
}
|
|
function endBlock() {
|
|
const block = peekBlock();
|
|
if (block === void 0)
|
|
return Debug.fail("beginBlock was never called.");
|
|
const index = blockActions.length;
|
|
blockActions[index] = 1 /* Close */;
|
|
blockOffsets[index] = operations ? operations.length : 0;
|
|
blocks[index] = block;
|
|
blockStack.pop();
|
|
return block;
|
|
}
|
|
function peekBlock() {
|
|
return lastOrUndefined(blockStack);
|
|
}
|
|
function peekBlockKind() {
|
|
const block = peekBlock();
|
|
return block && block.kind;
|
|
}
|
|
function beginWithBlock(expression) {
|
|
const startLabel = defineLabel();
|
|
const endLabel = defineLabel();
|
|
markLabel(startLabel);
|
|
beginBlock({
|
|
kind: 1 /* With */,
|
|
expression,
|
|
startLabel,
|
|
endLabel
|
|
});
|
|
}
|
|
function endWithBlock() {
|
|
Debug.assert(peekBlockKind() === 1 /* With */);
|
|
const block = endBlock();
|
|
markLabel(block.endLabel);
|
|
}
|
|
function beginExceptionBlock() {
|
|
const startLabel = defineLabel();
|
|
const endLabel = defineLabel();
|
|
markLabel(startLabel);
|
|
beginBlock({
|
|
kind: 0 /* Exception */,
|
|
state: 0 /* Try */,
|
|
startLabel,
|
|
endLabel
|
|
});
|
|
emitNop();
|
|
return endLabel;
|
|
}
|
|
function beginCatchBlock(variable) {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
let name;
|
|
if (isGeneratedIdentifier(variable.name)) {
|
|
name = variable.name;
|
|
hoistVariableDeclaration(variable.name);
|
|
} else {
|
|
const text = idText(variable.name);
|
|
name = declareLocal(text);
|
|
if (!renamedCatchVariables) {
|
|
renamedCatchVariables = /* @__PURE__ */ new Map();
|
|
renamedCatchVariableDeclarations = [];
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
}
|
|
renamedCatchVariables.set(text, true);
|
|
renamedCatchVariableDeclarations[getOriginalNodeId(variable)] = name;
|
|
}
|
|
const exception = peekBlock();
|
|
Debug.assert(exception.state < 1 /* Catch */);
|
|
const endLabel = exception.endLabel;
|
|
emitBreak(endLabel);
|
|
const catchLabel = defineLabel();
|
|
markLabel(catchLabel);
|
|
exception.state = 1 /* Catch */;
|
|
exception.catchVariable = name;
|
|
exception.catchLabel = catchLabel;
|
|
emitAssignment(name, factory2.createCallExpression(factory2.createPropertyAccessExpression(state, "sent"), void 0, []));
|
|
emitNop();
|
|
}
|
|
function beginFinallyBlock() {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
const exception = peekBlock();
|
|
Debug.assert(exception.state < 2 /* Finally */);
|
|
const endLabel = exception.endLabel;
|
|
emitBreak(endLabel);
|
|
const finallyLabel = defineLabel();
|
|
markLabel(finallyLabel);
|
|
exception.state = 2 /* Finally */;
|
|
exception.finallyLabel = finallyLabel;
|
|
}
|
|
function endExceptionBlock() {
|
|
Debug.assert(peekBlockKind() === 0 /* Exception */);
|
|
const exception = endBlock();
|
|
const state2 = exception.state;
|
|
if (state2 < 2 /* Finally */) {
|
|
emitBreak(exception.endLabel);
|
|
} else {
|
|
emitEndfinally();
|
|
}
|
|
markLabel(exception.endLabel);
|
|
emitNop();
|
|
exception.state = 3 /* Done */;
|
|
}
|
|
function beginScriptLoopBlock() {
|
|
beginBlock({
|
|
kind: 3 /* Loop */,
|
|
isScript: true,
|
|
breakLabel: -1,
|
|
continueLabel: -1
|
|
});
|
|
}
|
|
function beginLoopBlock(continueLabel) {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 3 /* Loop */,
|
|
isScript: false,
|
|
breakLabel,
|
|
continueLabel
|
|
});
|
|
return breakLabel;
|
|
}
|
|
function endLoopBlock() {
|
|
Debug.assert(peekBlockKind() === 3 /* Loop */);
|
|
const block = endBlock();
|
|
const breakLabel = block.breakLabel;
|
|
if (!block.isScript) {
|
|
markLabel(breakLabel);
|
|
}
|
|
}
|
|
function beginScriptSwitchBlock() {
|
|
beginBlock({
|
|
kind: 2 /* Switch */,
|
|
isScript: true,
|
|
breakLabel: -1
|
|
});
|
|
}
|
|
function beginSwitchBlock() {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 2 /* Switch */,
|
|
isScript: false,
|
|
breakLabel
|
|
});
|
|
return breakLabel;
|
|
}
|
|
function endSwitchBlock() {
|
|
Debug.assert(peekBlockKind() === 2 /* Switch */);
|
|
const block = endBlock();
|
|
const breakLabel = block.breakLabel;
|
|
if (!block.isScript) {
|
|
markLabel(breakLabel);
|
|
}
|
|
}
|
|
function beginScriptLabeledBlock(labelText) {
|
|
beginBlock({
|
|
kind: 4 /* Labeled */,
|
|
isScript: true,
|
|
labelText,
|
|
breakLabel: -1
|
|
});
|
|
}
|
|
function beginLabeledBlock(labelText) {
|
|
const breakLabel = defineLabel();
|
|
beginBlock({
|
|
kind: 4 /* Labeled */,
|
|
isScript: false,
|
|
labelText,
|
|
breakLabel
|
|
});
|
|
}
|
|
function endLabeledBlock() {
|
|
Debug.assert(peekBlockKind() === 4 /* Labeled */);
|
|
const block = endBlock();
|
|
if (!block.isScript) {
|
|
markLabel(block.breakLabel);
|
|
}
|
|
}
|
|
function supportsUnlabeledBreak(block) {
|
|
return block.kind === 2 /* Switch */ || block.kind === 3 /* Loop */;
|
|
}
|
|
function supportsLabeledBreakOrContinue(block) {
|
|
return block.kind === 4 /* Labeled */;
|
|
}
|
|
function supportsUnlabeledContinue(block) {
|
|
return block.kind === 3 /* Loop */;
|
|
}
|
|
function hasImmediateContainingLabeledBlock(labelText, start2) {
|
|
for (let j = start2; j >= 0; j--) {
|
|
const containingBlock = blockStack[j];
|
|
if (supportsLabeledBreakOrContinue(containingBlock)) {
|
|
if (containingBlock.labelText === labelText) {
|
|
return true;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function findBreakTarget(labelText) {
|
|
if (blockStack) {
|
|
if (labelText) {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsLabeledBreakOrContinue(block) && block.labelText === labelText) {
|
|
return block.breakLabel;
|
|
} else if (supportsUnlabeledBreak(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) {
|
|
return block.breakLabel;
|
|
}
|
|
}
|
|
} else {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledBreak(block)) {
|
|
return block.breakLabel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function findContinueTarget(labelText) {
|
|
if (blockStack) {
|
|
if (labelText) {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledContinue(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) {
|
|
return block.continueLabel;
|
|
}
|
|
}
|
|
} else {
|
|
for (let i = blockStack.length - 1; i >= 0; i--) {
|
|
const block = blockStack[i];
|
|
if (supportsUnlabeledContinue(block)) {
|
|
return block.continueLabel;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
function createLabel2(label) {
|
|
if (label !== void 0 && label > 0) {
|
|
if (labelExpressions === void 0) {
|
|
labelExpressions = [];
|
|
}
|
|
const expression = factory2.createNumericLiteral(-1);
|
|
if (labelExpressions[label] === void 0) {
|
|
labelExpressions[label] = [expression];
|
|
} else {
|
|
labelExpressions[label].push(expression);
|
|
}
|
|
return expression;
|
|
}
|
|
return factory2.createOmittedExpression();
|
|
}
|
|
function createInstruction(instruction) {
|
|
const literal = factory2.createNumericLiteral(instruction);
|
|
addSyntheticTrailingComment(literal, 3 /* MultiLineCommentTrivia */, getInstructionName(instruction));
|
|
return literal;
|
|
}
|
|
function createInlineBreak(label, location2) {
|
|
Debug.assertLessThan(0, label, "Invalid label");
|
|
return setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel2(label)
|
|
])
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createInlineReturn(expression, location2) {
|
|
return setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(2 /* Return */), expression] : [createInstruction(2 /* Return */)]
|
|
)
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function createGeneratorResume(location2) {
|
|
return setTextRange(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(state, "sent"),
|
|
void 0,
|
|
[]
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function emitNop() {
|
|
emitWorker(0 /* Nop */);
|
|
}
|
|
function emitStatement(node) {
|
|
if (node) {
|
|
emitWorker(1 /* Statement */, [node]);
|
|
} else {
|
|
emitNop();
|
|
}
|
|
}
|
|
function emitAssignment(left, right, location2) {
|
|
emitWorker(2 /* Assign */, [left, right], location2);
|
|
}
|
|
function emitBreak(label, location2) {
|
|
emitWorker(3 /* Break */, [label], location2);
|
|
}
|
|
function emitBreakWhenTrue(label, condition, location2) {
|
|
emitWorker(4 /* BreakWhenTrue */, [label, condition], location2);
|
|
}
|
|
function emitBreakWhenFalse(label, condition, location2) {
|
|
emitWorker(5 /* BreakWhenFalse */, [label, condition], location2);
|
|
}
|
|
function emitYieldStar(expression, location2) {
|
|
emitWorker(7 /* YieldStar */, [expression], location2);
|
|
}
|
|
function emitYield(expression, location2) {
|
|
emitWorker(6 /* Yield */, [expression], location2);
|
|
}
|
|
function emitReturn(expression, location2) {
|
|
emitWorker(8 /* Return */, [expression], location2);
|
|
}
|
|
function emitThrow(expression, location2) {
|
|
emitWorker(9 /* Throw */, [expression], location2);
|
|
}
|
|
function emitEndfinally() {
|
|
emitWorker(10 /* Endfinally */);
|
|
}
|
|
function emitWorker(code, args, location2) {
|
|
if (operations === void 0) {
|
|
operations = [];
|
|
operationArguments = [];
|
|
operationLocations = [];
|
|
}
|
|
if (labelOffsets === void 0) {
|
|
markLabel(defineLabel());
|
|
}
|
|
const operationIndex = operations.length;
|
|
operations[operationIndex] = code;
|
|
operationArguments[operationIndex] = args;
|
|
operationLocations[operationIndex] = location2;
|
|
}
|
|
function build2() {
|
|
blockIndex = 0;
|
|
labelNumber = 0;
|
|
labelNumbers = void 0;
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
clauses = void 0;
|
|
statements = void 0;
|
|
exceptionBlockStack = void 0;
|
|
currentExceptionBlock = void 0;
|
|
withBlockStack = void 0;
|
|
const buildResult = buildStatements();
|
|
return emitHelpers().createGeneratorHelper(
|
|
setEmitFlags(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, state)],
|
|
void 0,
|
|
factory2.createBlock(
|
|
buildResult,
|
|
buildResult.length > 0
|
|
)
|
|
),
|
|
1048576 /* ReuseTempVariableScope */
|
|
)
|
|
);
|
|
}
|
|
function buildStatements() {
|
|
if (operations) {
|
|
for (let operationIndex = 0; operationIndex < operations.length; operationIndex++) {
|
|
writeOperation(operationIndex);
|
|
}
|
|
flushFinalLabel(operations.length);
|
|
} else {
|
|
flushFinalLabel(0);
|
|
}
|
|
if (clauses) {
|
|
const labelExpression = factory2.createPropertyAccessExpression(state, "label");
|
|
const switchStatement = factory2.createSwitchStatement(labelExpression, factory2.createCaseBlock(clauses));
|
|
return [startOnNewLine(switchStatement)];
|
|
}
|
|
if (statements) {
|
|
return statements;
|
|
}
|
|
return [];
|
|
}
|
|
function flushLabel() {
|
|
if (!statements) {
|
|
return;
|
|
}
|
|
appendLabel(!lastOperationWasAbrupt);
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
labelNumber++;
|
|
}
|
|
function flushFinalLabel(operationIndex) {
|
|
if (isFinalLabelReachable(operationIndex)) {
|
|
tryEnterLabel(operationIndex);
|
|
withBlockStack = void 0;
|
|
writeReturn(void 0, void 0);
|
|
}
|
|
if (statements && clauses) {
|
|
appendLabel(false);
|
|
}
|
|
updateLabelExpressions();
|
|
}
|
|
function isFinalLabelReachable(operationIndex) {
|
|
if (!lastOperationWasCompletion) {
|
|
return true;
|
|
}
|
|
if (!labelOffsets || !labelExpressions) {
|
|
return false;
|
|
}
|
|
for (let label = 0; label < labelOffsets.length; label++) {
|
|
if (labelOffsets[label] === operationIndex && labelExpressions[label]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function appendLabel(markLabelEnd) {
|
|
if (!clauses) {
|
|
clauses = [];
|
|
}
|
|
if (statements) {
|
|
if (withBlockStack) {
|
|
for (let i = withBlockStack.length - 1; i >= 0; i--) {
|
|
const withBlock = withBlockStack[i];
|
|
statements = [factory2.createWithStatement(withBlock.expression, factory2.createBlock(statements))];
|
|
}
|
|
}
|
|
if (currentExceptionBlock) {
|
|
const { startLabel, catchLabel, finallyLabel, endLabel } = currentExceptionBlock;
|
|
statements.unshift(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createPropertyAccessExpression(state, "trys"), "push"),
|
|
void 0,
|
|
[
|
|
factory2.createArrayLiteralExpression([
|
|
createLabel2(startLabel),
|
|
createLabel2(catchLabel),
|
|
createLabel2(finallyLabel),
|
|
createLabel2(endLabel)
|
|
])
|
|
]
|
|
)
|
|
)
|
|
);
|
|
currentExceptionBlock = void 0;
|
|
}
|
|
if (markLabelEnd) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(state, "label"),
|
|
factory2.createNumericLiteral(labelNumber + 1)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
clauses.push(
|
|
factory2.createCaseClause(
|
|
factory2.createNumericLiteral(labelNumber),
|
|
statements || []
|
|
)
|
|
);
|
|
statements = void 0;
|
|
}
|
|
function tryEnterLabel(operationIndex) {
|
|
if (!labelOffsets) {
|
|
return;
|
|
}
|
|
for (let label = 0; label < labelOffsets.length; label++) {
|
|
if (labelOffsets[label] === operationIndex) {
|
|
flushLabel();
|
|
if (labelNumbers === void 0) {
|
|
labelNumbers = [];
|
|
}
|
|
if (labelNumbers[labelNumber] === void 0) {
|
|
labelNumbers[labelNumber] = [label];
|
|
} else {
|
|
labelNumbers[labelNumber].push(label);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function updateLabelExpressions() {
|
|
if (labelExpressions !== void 0 && labelNumbers !== void 0) {
|
|
for (let labelNumber2 = 0; labelNumber2 < labelNumbers.length; labelNumber2++) {
|
|
const labels = labelNumbers[labelNumber2];
|
|
if (labels !== void 0) {
|
|
for (const label of labels) {
|
|
const expressions = labelExpressions[label];
|
|
if (expressions !== void 0) {
|
|
for (const expression of expressions) {
|
|
expression.text = String(labelNumber2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function tryEnterOrLeaveBlock(operationIndex) {
|
|
if (blocks) {
|
|
for (; blockIndex < blockActions.length && blockOffsets[blockIndex] <= operationIndex; blockIndex++) {
|
|
const block = blocks[blockIndex];
|
|
const blockAction = blockActions[blockIndex];
|
|
switch (block.kind) {
|
|
case 0 /* Exception */:
|
|
if (blockAction === 0 /* Open */) {
|
|
if (!exceptionBlockStack) {
|
|
exceptionBlockStack = [];
|
|
}
|
|
if (!statements) {
|
|
statements = [];
|
|
}
|
|
exceptionBlockStack.push(currentExceptionBlock);
|
|
currentExceptionBlock = block;
|
|
} else if (blockAction === 1 /* Close */) {
|
|
currentExceptionBlock = exceptionBlockStack.pop();
|
|
}
|
|
break;
|
|
case 1 /* With */:
|
|
if (blockAction === 0 /* Open */) {
|
|
if (!withBlockStack) {
|
|
withBlockStack = [];
|
|
}
|
|
withBlockStack.push(block);
|
|
} else if (blockAction === 1 /* Close */) {
|
|
withBlockStack.pop();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function writeOperation(operationIndex) {
|
|
tryEnterLabel(operationIndex);
|
|
tryEnterOrLeaveBlock(operationIndex);
|
|
if (lastOperationWasAbrupt) {
|
|
return;
|
|
}
|
|
lastOperationWasAbrupt = false;
|
|
lastOperationWasCompletion = false;
|
|
const opcode = operations[operationIndex];
|
|
if (opcode === 0 /* Nop */) {
|
|
return;
|
|
} else if (opcode === 10 /* Endfinally */) {
|
|
return writeEndfinally();
|
|
}
|
|
const args = operationArguments[operationIndex];
|
|
if (opcode === 1 /* Statement */) {
|
|
return writeStatement(args[0]);
|
|
}
|
|
const location2 = operationLocations[operationIndex];
|
|
switch (opcode) {
|
|
case 2 /* Assign */:
|
|
return writeAssign(args[0], args[1], location2);
|
|
case 3 /* Break */:
|
|
return writeBreak(args[0], location2);
|
|
case 4 /* BreakWhenTrue */:
|
|
return writeBreakWhenTrue(args[0], args[1], location2);
|
|
case 5 /* BreakWhenFalse */:
|
|
return writeBreakWhenFalse(args[0], args[1], location2);
|
|
case 6 /* Yield */:
|
|
return writeYield(args[0], location2);
|
|
case 7 /* YieldStar */:
|
|
return writeYieldStar(args[0], location2);
|
|
case 8 /* Return */:
|
|
return writeReturn(args[0], location2);
|
|
case 9 /* Throw */:
|
|
return writeThrow(args[0], location2);
|
|
}
|
|
}
|
|
function writeStatement(statement) {
|
|
if (statement) {
|
|
if (!statements) {
|
|
statements = [statement];
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
}
|
|
function writeAssign(left, right, operationLocation) {
|
|
writeStatement(setTextRange(factory2.createExpressionStatement(factory2.createAssignment(left, right)), operationLocation));
|
|
}
|
|
function writeThrow(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
lastOperationWasCompletion = true;
|
|
writeStatement(setTextRange(factory2.createThrowStatement(expression), operationLocation));
|
|
}
|
|
function writeReturn(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
lastOperationWasCompletion = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(2 /* Return */), expression] : [createInstruction(2 /* Return */)]
|
|
)
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeBreak(label, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel2(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeBreakWhenTrue(label, condition, operationLocation) {
|
|
writeStatement(
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
condition,
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel2(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
);
|
|
}
|
|
function writeBreakWhenFalse(label, condition, operationLocation) {
|
|
writeStatement(
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalNot(condition),
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(3 /* Break */),
|
|
createLabel2(label)
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
);
|
|
}
|
|
function writeYield(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression(
|
|
expression ? [createInstruction(4 /* Yield */), expression] : [createInstruction(4 /* Yield */)]
|
|
)
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeYieldStar(expression, operationLocation) {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
setEmitFlags(
|
|
setTextRange(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(5 /* YieldStar */),
|
|
expression
|
|
])
|
|
),
|
|
operationLocation
|
|
),
|
|
768 /* NoTokenSourceMaps */
|
|
)
|
|
);
|
|
}
|
|
function writeEndfinally() {
|
|
lastOperationWasAbrupt = true;
|
|
writeStatement(
|
|
factory2.createReturnStatement(
|
|
factory2.createArrayLiteralExpression([
|
|
createInstruction(7 /* Endfinally */)
|
|
])
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/module.ts
|
|
function transformModule(context) {
|
|
function getTransformModuleDelegate(moduleKind2) {
|
|
switch (moduleKind2) {
|
|
case 2 /* AMD */:
|
|
return transformAMDModule;
|
|
case 3 /* UMD */:
|
|
return transformUMDModule;
|
|
default:
|
|
return transformCommonJSModule;
|
|
}
|
|
}
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers,
|
|
startLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const host = context.getEmitHost();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(210 /* CallExpression */);
|
|
context.enableSubstitution(212 /* TaggedTemplateExpression */);
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(223 /* BinaryExpression */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
const moduleInfoMap = [];
|
|
const deferredExports = [];
|
|
let currentSourceFile;
|
|
let currentModuleInfo;
|
|
const noSubstitution = [];
|
|
let needUMDDynamicImportHelper;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !(isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 8388608 /* ContainsDynamicImport */ || isJsonSourceFile(node) && hasJsonModuleEmitEnabled(compilerOptions) && outFile(compilerOptions))) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
currentModuleInfo = collectExternalModuleInfo(context, node, resolver, compilerOptions);
|
|
moduleInfoMap[getOriginalNodeId(node)] = currentModuleInfo;
|
|
const transformModule2 = getTransformModuleDelegate(moduleKind);
|
|
const updated = transformModule2(node);
|
|
currentSourceFile = void 0;
|
|
currentModuleInfo = void 0;
|
|
needUMDDynamicImportHelper = false;
|
|
return updated;
|
|
}
|
|
function shouldEmitUnderscoreUnderscoreESModule() {
|
|
if (!currentModuleInfo.exportEquals && isExternalModule(currentSourceFile)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function transformCommonJSModule(node) {
|
|
startLexicalEnvironment();
|
|
const statements = [];
|
|
const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || !compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile);
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, ensureUseStrict && !isJsonSourceFile(node), topLevelVisitor);
|
|
if (shouldEmitUnderscoreUnderscoreESModule()) {
|
|
append(statements, createUnderscoreUnderscoreESModule());
|
|
}
|
|
if (length(currentModuleInfo.exportedNames)) {
|
|
const chunkSize = 50;
|
|
for (let i = 0; i < currentModuleInfo.exportedNames.length; i += chunkSize) {
|
|
append(
|
|
statements,
|
|
factory2.createExpressionStatement(
|
|
reduceLeft(
|
|
currentModuleInfo.exportedNames.slice(i, i + chunkSize),
|
|
(prev, nextId) => factory2.createAssignment(factory2.createPropertyAccessExpression(factory2.createIdentifier("exports"), factory2.createIdentifier(idText(nextId))), prev),
|
|
factory2.createVoidZero()
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement));
|
|
addRange(statements, visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset));
|
|
addExportEqualsIfNeeded(statements, false);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const updated = factory2.updateSourceFile(node, setTextRange(factory2.createNodeArray(statements), node.statements));
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function transformAMDModule(node) {
|
|
const define = factory2.createIdentifier("define");
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const jsonSourceFile = isJsonSourceFile(node) && node;
|
|
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, true);
|
|
const updated = factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
define,
|
|
void 0,
|
|
[
|
|
...moduleName ? [moduleName] : [],
|
|
factory2.createArrayLiteralExpression(jsonSourceFile ? emptyArray : [
|
|
factory2.createStringLiteral("require"),
|
|
factory2.createStringLiteral("exports"),
|
|
...aliasedModuleNames,
|
|
...unaliasedModuleNames
|
|
]),
|
|
jsonSourceFile ? jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory2.createObjectLiteralExpression() : factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, "require"),
|
|
factory2.createParameterDeclaration(void 0, void 0, "exports"),
|
|
...importAliasNames
|
|
],
|
|
void 0,
|
|
transformAsynchronousModuleBody(node)
|
|
)
|
|
]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
);
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function transformUMDModule(node) {
|
|
const { aliasedModuleNames, unaliasedModuleNames, importAliasNames } = collectAsynchronousDependencies(node, false);
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const umdHeader = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, "factory")],
|
|
void 0,
|
|
setTextRange(
|
|
factory2.createBlock(
|
|
[
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createTypeCheck(factory2.createIdentifier("module"), "object"),
|
|
factory2.createTypeCheck(factory2.createPropertyAccessExpression(factory2.createIdentifier("module"), "exports"), "object")
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
"v",
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("factory"),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("require"),
|
|
factory2.createIdentifier("exports")
|
|
]
|
|
)
|
|
)
|
|
]
|
|
),
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
factory2.createStrictInequality(
|
|
factory2.createIdentifier("v"),
|
|
factory2.createIdentifier("undefined")
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("module"), "exports"),
|
|
factory2.createIdentifier("v")
|
|
)
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
]),
|
|
factory2.createIfStatement(
|
|
factory2.createLogicalAnd(
|
|
factory2.createTypeCheck(factory2.createIdentifier("define"), "function"),
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("define"), "amd")
|
|
),
|
|
factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("define"),
|
|
void 0,
|
|
[
|
|
...moduleName ? [moduleName] : [],
|
|
factory2.createArrayLiteralExpression([
|
|
factory2.createStringLiteral("require"),
|
|
factory2.createStringLiteral("exports"),
|
|
...aliasedModuleNames,
|
|
...unaliasedModuleNames
|
|
]),
|
|
factory2.createIdentifier("factory")
|
|
]
|
|
)
|
|
)
|
|
])
|
|
)
|
|
)
|
|
],
|
|
true
|
|
),
|
|
void 0
|
|
)
|
|
);
|
|
const updated = factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
umdHeader,
|
|
void 0,
|
|
[
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, "require"),
|
|
factory2.createParameterDeclaration(void 0, void 0, "exports"),
|
|
...importAliasNames
|
|
],
|
|
void 0,
|
|
transformAsynchronousModuleBody(node)
|
|
)
|
|
]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
);
|
|
addEmitHelpers(updated, context.readEmitHelpers());
|
|
return updated;
|
|
}
|
|
function collectAsynchronousDependencies(node, includeNonAmdDependencies) {
|
|
const aliasedModuleNames = [];
|
|
const unaliasedModuleNames = [];
|
|
const importAliasNames = [];
|
|
for (const amdDependency of node.amdDependencies) {
|
|
if (amdDependency.name) {
|
|
aliasedModuleNames.push(factory2.createStringLiteral(amdDependency.path));
|
|
importAliasNames.push(factory2.createParameterDeclaration(void 0, void 0, amdDependency.name));
|
|
} else {
|
|
unaliasedModuleNames.push(factory2.createStringLiteral(amdDependency.path));
|
|
}
|
|
}
|
|
for (const importNode of currentModuleInfo.externalImports) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
|
|
const importAliasName = getLocalNameForExternalImport(factory2, importNode, currentSourceFile);
|
|
if (externalModuleName) {
|
|
if (includeNonAmdDependencies && importAliasName) {
|
|
setEmitFlags(importAliasName, 8 /* NoSubstitution */);
|
|
aliasedModuleNames.push(externalModuleName);
|
|
importAliasNames.push(factory2.createParameterDeclaration(void 0, void 0, importAliasName));
|
|
} else {
|
|
unaliasedModuleNames.push(externalModuleName);
|
|
}
|
|
}
|
|
}
|
|
return { aliasedModuleNames, unaliasedModuleNames, importAliasNames };
|
|
}
|
|
function getAMDImportExpressionForImport(node) {
|
|
if (isImportEqualsDeclaration(node) || isExportDeclaration(node) || !getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions)) {
|
|
return void 0;
|
|
}
|
|
const name = getLocalNameForExternalImport(factory2, node, currentSourceFile);
|
|
const expr = getHelperExpressionForImport(node, name);
|
|
if (expr === name) {
|
|
return void 0;
|
|
}
|
|
return factory2.createExpressionStatement(factory2.createAssignment(name, expr));
|
|
}
|
|
function transformAsynchronousModuleBody(node) {
|
|
startLexicalEnvironment();
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, !compilerOptions.noImplicitUseStrict, topLevelVisitor);
|
|
if (shouldEmitUnderscoreUnderscoreESModule()) {
|
|
append(statements, createUnderscoreUnderscoreESModule());
|
|
}
|
|
if (length(currentModuleInfo.exportedNames)) {
|
|
append(statements, factory2.createExpressionStatement(reduceLeft(currentModuleInfo.exportedNames, (prev, nextId) => factory2.createAssignment(factory2.createPropertyAccessExpression(factory2.createIdentifier("exports"), factory2.createIdentifier(idText(nextId))), prev), factory2.createVoidZero())));
|
|
}
|
|
append(statements, visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement));
|
|
if (moduleKind === 2 /* AMD */) {
|
|
addRange(statements, mapDefined(currentModuleInfo.externalImports, getAMDImportExpressionForImport));
|
|
}
|
|
addRange(statements, visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset));
|
|
addExportEqualsIfNeeded(statements, true);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const body = factory2.createBlock(statements, true);
|
|
if (needUMDDynamicImportHelper) {
|
|
addEmitHelper(body, dynamicImportUMDHelper);
|
|
}
|
|
return body;
|
|
}
|
|
function addExportEqualsIfNeeded(statements, emitAsReturn) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
const expressionResult = visitNode(currentModuleInfo.exportEquals.expression, visitor);
|
|
if (expressionResult) {
|
|
if (emitAsReturn) {
|
|
const statement = factory2.createReturnStatement(expressionResult);
|
|
setTextRange(statement, currentModuleInfo.exportEquals);
|
|
setEmitFlags(statement, 768 /* NoTokenSourceMaps */ | 3072 /* NoComments */);
|
|
statements.push(statement);
|
|
} else {
|
|
const statement = factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("module"),
|
|
"exports"
|
|
),
|
|
expressionResult
|
|
)
|
|
);
|
|
setTextRange(statement, currentModuleInfo.exportEquals);
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function topLevelVisitor(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return visitMergeDeclarationMarker(node);
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return visitEndOfDeclarationMarker(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function visitorWorker(node, valueIsDiscarded) {
|
|
if (!(node.transformFlags & (8388608 /* ContainsDynamicImport */ | 4096 /* ContainsDestructuringAssignment */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, valueIsDiscarded);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return visitPartiallyEmittedExpression(node, valueIsDiscarded);
|
|
case 210 /* CallExpression */:
|
|
if (isImportCall(node) && currentSourceFile.impliedNodeFormat === void 0) {
|
|
return visitImportCallExpression(node);
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
return visitDestructuringAssignment(node, valueIsDiscarded);
|
|
}
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPreOrPostfixUnaryExpression(node, valueIsDiscarded);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function destructuringNeedsFlattening(node) {
|
|
if (isObjectLiteralExpression(node)) {
|
|
for (const elem of node.properties) {
|
|
switch (elem.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
if (destructuringNeedsFlattening(elem.initializer)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
if (destructuringNeedsFlattening(elem.name)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
if (destructuringNeedsFlattening(elem.expression)) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return false;
|
|
default:
|
|
Debug.assertNever(elem, "Unhandled object member kind");
|
|
}
|
|
}
|
|
} else if (isArrayLiteralExpression(node)) {
|
|
for (const elem of node.elements) {
|
|
if (isSpreadElement(elem)) {
|
|
if (destructuringNeedsFlattening(elem.expression)) {
|
|
return true;
|
|
}
|
|
} else if (destructuringNeedsFlattening(elem)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else if (isIdentifier(node)) {
|
|
return length(getExports(node)) > (isExportName(node) ? 1 : 0);
|
|
}
|
|
return false;
|
|
}
|
|
function visitDestructuringAssignment(node, valueIsDiscarded) {
|
|
if (destructuringNeedsFlattening(node.left)) {
|
|
return flattenDestructuringAssignment(node, visitor, context, 0 /* All */, !valueIsDiscarded, createAllExportExpressions);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitForStatement(node) {
|
|
return factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, visitor, context)
|
|
);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(
|
|
node,
|
|
visitNode(node.expression, discardedValueVisitor, isExpression)
|
|
);
|
|
}
|
|
function visitParenthesizedExpression(node, valueIsDiscarded) {
|
|
return factory2.updateParenthesizedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPartiallyEmittedExpression(node, valueIsDiscarded) {
|
|
return factory2.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if ((node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand) && !isDeclarationNameOfEnumOrNamespace(node.operand)) {
|
|
const exportedNames = getExports(node.operand);
|
|
if (exportedNames) {
|
|
let temp;
|
|
let expression = visitNode(node.operand, visitor, isExpression);
|
|
if (isPrefixUnaryExpression(node)) {
|
|
expression = factory2.updatePrefixUnaryExpression(node, expression);
|
|
} else {
|
|
expression = factory2.updatePostfixUnaryExpression(node, expression);
|
|
if (!valueIsDiscarded) {
|
|
temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
expression = factory2.createComma(expression, factory2.cloneNode(node.operand));
|
|
setTextRange(expression, node);
|
|
}
|
|
for (const exportName of exportedNames) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = createExportExpression(exportName, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
if (temp) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitImportCallExpression(node) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
|
|
const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor);
|
|
const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
|
|
const containsLexicalThis = !!(node.transformFlags & 16384 /* ContainsLexicalThis */);
|
|
switch (compilerOptions.module) {
|
|
case 2 /* AMD */:
|
|
return createImportCallExpressionAMD(argument, containsLexicalThis);
|
|
case 3 /* UMD */:
|
|
return createImportCallExpressionUMD(argument != null ? argument : factory2.createVoidZero(), containsLexicalThis);
|
|
case 1 /* CommonJS */:
|
|
default:
|
|
return createImportCallExpressionCommonJS(argument);
|
|
}
|
|
}
|
|
function createImportCallExpressionUMD(arg, containsLexicalThis) {
|
|
needUMDDynamicImportHelper = true;
|
|
if (isSimpleCopiableExpression(arg)) {
|
|
const argClone = isGeneratedIdentifier(arg) ? arg : isStringLiteral(arg) ? factory2.createStringLiteralFromNode(arg) : setEmitFlags(setTextRange(factory2.cloneNode(arg), arg), 3072 /* NoComments */);
|
|
return factory2.createConditionalExpression(
|
|
factory2.createIdentifier("__syncRequire"),
|
|
void 0,
|
|
createImportCallExpressionCommonJS(arg),
|
|
void 0,
|
|
createImportCallExpressionAMD(argClone, containsLexicalThis)
|
|
);
|
|
} else {
|
|
const temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
return factory2.createComma(factory2.createAssignment(temp, arg), factory2.createConditionalExpression(
|
|
factory2.createIdentifier("__syncRequire"),
|
|
void 0,
|
|
createImportCallExpressionCommonJS(temp, true),
|
|
void 0,
|
|
createImportCallExpressionAMD(temp, containsLexicalThis)
|
|
));
|
|
}
|
|
}
|
|
function createImportCallExpressionAMD(arg, containsLexicalThis) {
|
|
const resolve = factory2.createUniqueName("resolve");
|
|
const reject = factory2.createUniqueName("reject");
|
|
const parameters = [
|
|
factory2.createParameterDeclaration(void 0, void 0, resolve),
|
|
factory2.createParameterDeclaration(void 0, void 0, reject)
|
|
];
|
|
const body = factory2.createBlock([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createIdentifier("require"),
|
|
void 0,
|
|
[factory2.createArrayLiteralExpression([arg || factory2.createOmittedExpression()]), resolve, reject]
|
|
)
|
|
)
|
|
]);
|
|
let func;
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
func = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
body
|
|
);
|
|
} else {
|
|
func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
if (containsLexicalThis) {
|
|
setEmitFlags(func, 16 /* CapturesThis */);
|
|
}
|
|
}
|
|
const promise = factory2.createNewExpression(factory2.createIdentifier("Promise"), void 0, [func]);
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
return factory2.createCallExpression(factory2.createPropertyAccessExpression(promise, factory2.createIdentifier("then")), void 0, [emitHelpers().createImportStarCallbackHelper()]);
|
|
}
|
|
return promise;
|
|
}
|
|
function createImportCallExpressionCommonJS(arg, isInlineable) {
|
|
const needSyncEval = arg && !isSimpleInlineableExpression(arg) && !isInlineable;
|
|
const promiseResolveCall = factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Promise"), "resolve"),
|
|
void 0,
|
|
needSyncEval ? languageVersion >= 2 /* ES2015 */ ? [
|
|
factory2.createTemplateExpression(factory2.createTemplateHead(""), [
|
|
factory2.createTemplateSpan(arg, factory2.createTemplateTail(""))
|
|
])
|
|
] : [
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createStringLiteral(""), "concat"),
|
|
void 0,
|
|
[arg]
|
|
)
|
|
] : []
|
|
);
|
|
let requireCall = factory2.createCallExpression(
|
|
factory2.createIdentifier("require"),
|
|
void 0,
|
|
needSyncEval ? [factory2.createIdentifier("s")] : arg ? [arg] : []
|
|
);
|
|
if (getESModuleInterop(compilerOptions)) {
|
|
requireCall = emitHelpers().createImportStarHelper(requireCall);
|
|
}
|
|
const parameters = needSyncEval ? [
|
|
factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"s"
|
|
)
|
|
] : [];
|
|
let func;
|
|
if (languageVersion >= 2 /* ES2015 */) {
|
|
func = factory2.createArrowFunction(
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
void 0,
|
|
requireCall
|
|
);
|
|
} else {
|
|
func = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
factory2.createBlock([factory2.createReturnStatement(requireCall)])
|
|
);
|
|
}
|
|
const downleveledImport = factory2.createCallExpression(factory2.createPropertyAccessExpression(promiseResolveCall, "then"), void 0, [func]);
|
|
return downleveledImport;
|
|
}
|
|
function getHelperExpressionForExport(node, innerExpr) {
|
|
if (!getESModuleInterop(compilerOptions) || getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) {
|
|
return innerExpr;
|
|
}
|
|
if (getExportNeedsImportStarHelper(node)) {
|
|
return emitHelpers().createImportStarHelper(innerExpr);
|
|
}
|
|
return innerExpr;
|
|
}
|
|
function getHelperExpressionForImport(node, innerExpr) {
|
|
if (!getESModuleInterop(compilerOptions) || getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) {
|
|
return innerExpr;
|
|
}
|
|
if (getImportNeedsImportStarHelper(node)) {
|
|
return emitHelpers().createImportStarHelper(innerExpr);
|
|
}
|
|
if (getImportNeedsImportDefaultHelper(node)) {
|
|
return emitHelpers().createImportDefaultHelper(innerExpr);
|
|
}
|
|
return innerExpr;
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
let statements;
|
|
const namespaceDeclaration = getNamespaceDeclarationNode(node);
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
if (!node.importClause) {
|
|
return setOriginalNode(setTextRange(factory2.createExpressionStatement(createRequireCall2(node)), node), node);
|
|
} else {
|
|
const variables = [];
|
|
if (namespaceDeclaration && !isDefaultImport(node)) {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
getHelperExpressionForImport(node, createRequireCall2(node))
|
|
)
|
|
);
|
|
} else {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.getGeneratedNameForNode(node),
|
|
void 0,
|
|
void 0,
|
|
getHelperExpressionForImport(node, createRequireCall2(node))
|
|
)
|
|
);
|
|
if (namespaceDeclaration && isDefaultImport(node)) {
|
|
variables.push(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
variables,
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
} else if (namespaceDeclaration && isDefaultImport(node)) {
|
|
statements = append(
|
|
statements,
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(namespaceDeclaration.name),
|
|
void 0,
|
|
void 0,
|
|
factory2.getGeneratedNameForNode(node)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
)
|
|
);
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function createRequireCall2(importNode) {
|
|
const moduleName = getExternalModuleNameLiteral(factory2, importNode, currentSourceFile, host, resolver, compilerOptions);
|
|
const args = [];
|
|
if (moduleName) {
|
|
args.push(moduleName);
|
|
}
|
|
return factory2.createCallExpression(factory2.createIdentifier("require"), void 0, args);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
node.name,
|
|
createRequireCall2(node)
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(node.name),
|
|
void 0,
|
|
void 0,
|
|
createRequireCall2(node)
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(factory2.getExportName(node), factory2.getLocalName(node))
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (!node.moduleSpecifier) {
|
|
return void 0;
|
|
}
|
|
const generatedName = factory2.getGeneratedNameForNode(node);
|
|
if (node.exportClause && isNamedExports(node.exportClause)) {
|
|
const statements = [];
|
|
if (moduleKind !== 2 /* AMD */) {
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
generatedName,
|
|
void 0,
|
|
void 0,
|
|
createRequireCall2(node)
|
|
)
|
|
])
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
}
|
|
for (const specifier of node.exportClause.elements) {
|
|
if (languageVersion === 0 /* ES3 */) {
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createCreateBindingHelper(generatedName, factory2.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory2.createStringLiteralFromNode(specifier.name) : void 0)
|
|
),
|
|
specifier
|
|
),
|
|
specifier
|
|
)
|
|
);
|
|
} else {
|
|
const exportNeedsImportDefault = !!getESModuleInterop(compilerOptions) && !(getEmitFlags(node) & 134217728 /* NeverApplyImportHelper */) && idText(specifier.propertyName || specifier.name) === "default";
|
|
const exportedValue = factory2.createPropertyAccessExpression(
|
|
exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName,
|
|
specifier.propertyName || specifier.name
|
|
);
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(factory2.getExportName(specifier), exportedValue, void 0, true)
|
|
),
|
|
specifier
|
|
),
|
|
specifier
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return singleOrMany(statements);
|
|
} else if (node.exportClause) {
|
|
const statements = [];
|
|
statements.push(
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
factory2.cloneNode(node.exportClause.name),
|
|
getHelperExpressionForExport(node, moduleKind !== 2 /* AMD */ ? createRequireCall2(node) : isExportNamespaceAsDefaultDeclaration(node) ? generatedName : factory2.createIdentifier(idText(node.exportClause.name)))
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
return singleOrMany(statements);
|
|
} else {
|
|
return setOriginalNode(
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
emitHelpers().createExportStarHelper(moduleKind !== 2 /* AMD */ ? createRequireCall2(node) : generatedName)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
function visitExportAssignment(node) {
|
|
if (node.isExportEquals) {
|
|
return void 0;
|
|
}
|
|
let statements;
|
|
const original = node.original;
|
|
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportStatement(deferredExports[id], factory2.createIdentifier("default"), visitNode(node.expression, visitor), node, true);
|
|
} else {
|
|
statements = appendExportStatement(statements, factory2.createIdentifier("default"), visitNode(node.expression, visitor), node, true);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
let statements;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createFunctionDeclaration(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifier),
|
|
node.asteriskToken,
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor),
|
|
void 0,
|
|
visitEachChild(node.body, visitor, context)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
let statements;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createClassDeclaration(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor),
|
|
visitNodes2(node.members, visitor)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
let statements;
|
|
let variables;
|
|
let expressions;
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
let modifiers;
|
|
let removeCommentsOnExpressions = false;
|
|
for (const variable of node.declarationList.declarations) {
|
|
if (isIdentifier(variable.name) && isLocalName(variable.name)) {
|
|
if (!modifiers) {
|
|
modifiers = visitNodes2(node.modifiers, modifierVisitor, isModifier);
|
|
}
|
|
variables = append(variables, variable);
|
|
} else if (variable.initializer) {
|
|
if (!isBindingPattern(variable.name) && (isArrowFunction(variable.initializer) || isFunctionExpression(variable.initializer) || isClassExpression(variable.initializer))) {
|
|
const expression = factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
variable.name
|
|
),
|
|
variable.name
|
|
),
|
|
factory2.createIdentifier(getTextOfIdentifierOrLiteral(variable.name))
|
|
);
|
|
const updatedVariable = factory2.createVariableDeclaration(
|
|
variable.name,
|
|
variable.exclamationToken,
|
|
variable.type,
|
|
visitNode(variable.initializer, visitor)
|
|
);
|
|
variables = append(variables, updatedVariable);
|
|
expressions = append(expressions, expression);
|
|
removeCommentsOnExpressions = true;
|
|
} else {
|
|
expressions = append(expressions, transformInitializedVariable(variable));
|
|
}
|
|
}
|
|
}
|
|
if (variables) {
|
|
statements = append(statements, factory2.updateVariableStatement(node, modifiers, factory2.updateVariableDeclarationList(node.declarationList, variables)));
|
|
}
|
|
if (expressions) {
|
|
const statement = setOriginalNode(setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(expressions)), node), node);
|
|
if (removeCommentsOnExpressions) {
|
|
removeAllComments(statement);
|
|
}
|
|
statements = append(statements, statement);
|
|
}
|
|
} else {
|
|
statements = append(statements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfVariableStatement(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function createAllExportExpressions(name, value, location2) {
|
|
const exportedNames = getExports(name);
|
|
if (exportedNames) {
|
|
let expression = isExportName(name) ? value : factory2.createAssignment(name, value);
|
|
for (const exportName of exportedNames) {
|
|
setEmitFlags(expression, 8 /* NoSubstitution */);
|
|
expression = createExportExpression(exportName, expression, location2);
|
|
}
|
|
return expression;
|
|
}
|
|
return factory2.createAssignment(name, value);
|
|
}
|
|
function transformInitializedVariable(node) {
|
|
if (isBindingPattern(node.name)) {
|
|
return flattenDestructuringAssignment(
|
|
visitNode(node, visitor),
|
|
void 0,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createAllExportExpressions
|
|
);
|
|
} else {
|
|
return factory2.createAssignment(
|
|
setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
node.name
|
|
),
|
|
node.name
|
|
),
|
|
node.initializer ? visitNode(node.initializer, visitor) : factory2.createVoidZero()
|
|
);
|
|
}
|
|
}
|
|
function visitMergeDeclarationMarker(node) {
|
|
if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* VariableStatement */) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original);
|
|
}
|
|
return node;
|
|
}
|
|
function hasAssociatedEndOfDeclarationMarker(node) {
|
|
return (getEmitFlags(node) & 8388608 /* HasEndOfDeclarationMarker */) !== 0;
|
|
}
|
|
function visitEndOfDeclarationMarker(node) {
|
|
const id = getOriginalNodeId(node);
|
|
const statements = deferredExports[id];
|
|
if (statements) {
|
|
delete deferredExports[id];
|
|
return append(statements, node);
|
|
}
|
|
return node;
|
|
}
|
|
function appendExportsOfImportDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const importClause = decl.importClause;
|
|
if (!importClause) {
|
|
return statements;
|
|
}
|
|
if (importClause.name) {
|
|
statements = appendExportsOfDeclaration(statements, importClause);
|
|
}
|
|
const namedBindings = importClause.namedBindings;
|
|
if (namedBindings) {
|
|
switch (namedBindings.kind) {
|
|
case 271 /* NamespaceImport */:
|
|
statements = appendExportsOfDeclaration(statements, namedBindings);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
for (const importBinding of namedBindings.elements) {
|
|
statements = appendExportsOfDeclaration(statements, importBinding, true);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
return appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
function appendExportsOfVariableStatement(statements, node) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
for (const decl of node.declarationList.declarations) {
|
|
statements = appendExportsOfBindingElement(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfBindingElement(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
statements = appendExportsOfBindingElement(statements, element);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
statements = appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfHoistedDeclaration(statements, decl) {
|
|
if (currentModuleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (hasSyntacticModifier(decl, 1 /* Export */)) {
|
|
const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createIdentifier("default") : factory2.getDeclarationName(decl);
|
|
statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl), decl);
|
|
}
|
|
if (decl.name) {
|
|
statements = appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfDeclaration(statements, decl, liveBinding) {
|
|
const name = factory2.getDeclarationName(decl);
|
|
const exportSpecifiers = currentModuleInfo.exportSpecifiers.get(idText(name));
|
|
if (exportSpecifiers) {
|
|
for (const exportSpecifier of exportSpecifiers) {
|
|
statements = appendExportStatement(statements, exportSpecifier.name, name, exportSpecifier.name, void 0, liveBinding);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportStatement(statements, exportName, expression, location2, allowComments, liveBinding) {
|
|
statements = append(statements, createExportStatement(exportName, expression, location2, allowComments, liveBinding));
|
|
return statements;
|
|
}
|
|
function createUnderscoreUnderscoreESModule() {
|
|
let statement;
|
|
if (languageVersion === 0 /* ES3 */) {
|
|
statement = factory2.createExpressionStatement(
|
|
createExportExpression(
|
|
factory2.createIdentifier("__esModule"),
|
|
factory2.createTrue()
|
|
)
|
|
);
|
|
} else {
|
|
statement = factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("Object"), "defineProperty"),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("exports"),
|
|
factory2.createStringLiteral("__esModule"),
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("value", factory2.createTrue())
|
|
])
|
|
]
|
|
)
|
|
);
|
|
}
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
return statement;
|
|
}
|
|
function createExportStatement(name, value, location2, allowComments, liveBinding) {
|
|
const statement = setTextRange(factory2.createExpressionStatement(createExportExpression(name, value, void 0, liveBinding)), location2);
|
|
startOnNewLine(statement);
|
|
if (!allowComments) {
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
}
|
|
return statement;
|
|
}
|
|
function createExportExpression(name, value, location2, liveBinding) {
|
|
return setTextRange(
|
|
liveBinding && languageVersion !== 0 /* ES3 */ ? factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("Object"),
|
|
"defineProperty"
|
|
),
|
|
void 0,
|
|
[
|
|
factory2.createIdentifier("exports"),
|
|
factory2.createStringLiteralFromNode(name),
|
|
factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment("enumerable", factory2.createTrue()),
|
|
factory2.createPropertyAssignment("get", factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock([factory2.createReturnStatement(value)])
|
|
))
|
|
])
|
|
]
|
|
) : factory2.createAssignment(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
factory2.cloneNode(name)
|
|
),
|
|
value
|
|
),
|
|
location2
|
|
);
|
|
}
|
|
function modifierVisitor(node) {
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
currentSourceFile = node;
|
|
currentModuleInfo = moduleInfoMap[getOriginalNodeId(currentSourceFile)];
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentSourceFile = void 0;
|
|
currentModuleInfo = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (node.id && noSubstitution[node.id]) {
|
|
return node;
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
const name = node.name;
|
|
const exportedOrImportedName = substituteExpressionIdentifier(name);
|
|
if (exportedOrImportedName !== name) {
|
|
if (node.objectAssignmentInitializer) {
|
|
const initializer = factory2.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer);
|
|
return setTextRange(factory2.createPropertyAssignment(name, initializer), node);
|
|
}
|
|
return setTextRange(factory2.createPropertyAssignment(name, exportedOrImportedName), node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 210 /* CallExpression */:
|
|
return substituteCallExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return substituteTaggedTemplateExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return substituteBinaryExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteCallExpression(node) {
|
|
if (isIdentifier(node.expression)) {
|
|
const expression = substituteExpressionIdentifier(node.expression);
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
if (!isIdentifier(expression) && !(getEmitFlags(node.expression) & 8192 /* HelperName */)) {
|
|
return addEmitFlags(
|
|
factory2.updateCallExpression(
|
|
node,
|
|
expression,
|
|
void 0,
|
|
node.arguments
|
|
),
|
|
1073741824 /* IndirectCall */
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteTaggedTemplateExpression(node) {
|
|
if (isIdentifier(node.tag)) {
|
|
const tag = substituteExpressionIdentifier(node.tag);
|
|
noSubstitution[getNodeId(tag)] = true;
|
|
if (!isIdentifier(tag) && !(getEmitFlags(node.tag) & 8192 /* HelperName */)) {
|
|
return addEmitFlags(
|
|
factory2.updateTaggedTemplateExpression(
|
|
node,
|
|
tag,
|
|
void 0,
|
|
node.template
|
|
),
|
|
1073741824 /* IndirectCall */
|
|
);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2, _b;
|
|
if (getEmitFlags(node) & 8192 /* HelperName */) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile);
|
|
if (externalHelpersModuleName) {
|
|
return factory2.createPropertyAccessExpression(externalHelpersModuleName, node);
|
|
}
|
|
return node;
|
|
} else if (!(isGeneratedIdentifier(node) && !(node.autoGenerateFlags & 64 /* AllowNameSubstitution */)) && !isLocalName(node)) {
|
|
const exportContainer = resolver.getReferencedExportContainer(node, isExportName(node));
|
|
if (exportContainer && exportContainer.kind === 308 /* SourceFile */) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.createIdentifier("exports"),
|
|
factory2.cloneNode(node)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(node);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
const name = importDeclaration.propertyName || importDeclaration.name;
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(name)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteBinaryExpression(node) {
|
|
if (isAssignmentOperator(node.operatorToken.kind) && isIdentifier(node.left) && !isGeneratedIdentifier(node.left) && !isLocalName(node.left) && !isDeclarationNameOfEnumOrNamespace(node.left)) {
|
|
const exportedNames = getExports(node.left);
|
|
if (exportedNames) {
|
|
let expression = node;
|
|
for (const exportName of exportedNames) {
|
|
noSubstitution[getNodeId(expression)] = true;
|
|
expression = createExportExpression(exportName, expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getExports(name) {
|
|
if (!isGeneratedIdentifier(name)) {
|
|
const valueDeclaration = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (valueDeclaration) {
|
|
return currentModuleInfo && currentModuleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var dynamicImportUMDHelper = {
|
|
name: "typescript:dynamicimport-sync-require",
|
|
scoped: true,
|
|
text: `
|
|
var __syncRequire = typeof module === "object" && typeof module.exports === "object";`
|
|
};
|
|
|
|
// src/compiler/transformers/module/system.ts
|
|
function transformSystemModule(context) {
|
|
const {
|
|
factory: factory2,
|
|
startLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
hoistVariableDeclaration
|
|
} = context;
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const resolver = context.getEmitResolver();
|
|
const host = context.getEmitHost();
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
context.enableSubstitution(300 /* ShorthandPropertyAssignment */);
|
|
context.enableSubstitution(223 /* BinaryExpression */);
|
|
context.enableSubstitution(233 /* MetaProperty */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
const moduleInfoMap = [];
|
|
const deferredExports = [];
|
|
const exportFunctionsMap = [];
|
|
const noSubstitutionMap = [];
|
|
const contextObjectMap = [];
|
|
let currentSourceFile;
|
|
let moduleInfo;
|
|
let exportFunction;
|
|
let contextObject;
|
|
let hoistedStatements;
|
|
let enclosingBlockScopedContainer;
|
|
let noSubstitution;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile || !(isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 8388608 /* ContainsDynamicImport */)) {
|
|
return node;
|
|
}
|
|
const id = getOriginalNodeId(node);
|
|
currentSourceFile = node;
|
|
enclosingBlockScopedContainer = node;
|
|
moduleInfo = moduleInfoMap[id] = collectExternalModuleInfo(context, node, resolver, compilerOptions);
|
|
exportFunction = factory2.createUniqueName("exports");
|
|
exportFunctionsMap[id] = exportFunction;
|
|
contextObject = contextObjectMap[id] = factory2.createUniqueName("context");
|
|
const dependencyGroups = collectDependencyGroups(moduleInfo.externalImports);
|
|
const moduleBodyBlock = createSystemModuleBody(node, dependencyGroups);
|
|
const moduleBodyFunction = factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[
|
|
factory2.createParameterDeclaration(void 0, void 0, exportFunction),
|
|
factory2.createParameterDeclaration(void 0, void 0, contextObject)
|
|
],
|
|
void 0,
|
|
moduleBodyBlock
|
|
);
|
|
const moduleName = tryGetModuleNameFromFile(factory2, node, host, compilerOptions);
|
|
const dependencies = factory2.createArrayLiteralExpression(map(dependencyGroups, (dependencyGroup) => dependencyGroup.name));
|
|
const updated = setEmitFlags(
|
|
factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(
|
|
factory2.createNodeArray([
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(factory2.createIdentifier("System"), "register"),
|
|
void 0,
|
|
moduleName ? [moduleName, dependencies, moduleBodyFunction] : [dependencies, moduleBodyFunction]
|
|
)
|
|
)
|
|
]),
|
|
node.statements
|
|
)
|
|
),
|
|
2048 /* NoTrailingComments */
|
|
);
|
|
if (!outFile(compilerOptions)) {
|
|
moveEmitHelpers(updated, moduleBodyBlock, (helper) => !helper.scoped);
|
|
}
|
|
if (noSubstitution) {
|
|
noSubstitutionMap[id] = noSubstitution;
|
|
noSubstitution = void 0;
|
|
}
|
|
currentSourceFile = void 0;
|
|
moduleInfo = void 0;
|
|
exportFunction = void 0;
|
|
contextObject = void 0;
|
|
hoistedStatements = void 0;
|
|
enclosingBlockScopedContainer = void 0;
|
|
return updated;
|
|
}
|
|
function collectDependencyGroups(externalImports) {
|
|
const groupIndices = /* @__PURE__ */ new Map();
|
|
const dependencyGroups = [];
|
|
for (const externalImport of externalImports) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, externalImport, currentSourceFile, host, resolver, compilerOptions);
|
|
if (externalModuleName) {
|
|
const text = externalModuleName.text;
|
|
const groupIndex = groupIndices.get(text);
|
|
if (groupIndex !== void 0) {
|
|
dependencyGroups[groupIndex].externalImports.push(externalImport);
|
|
} else {
|
|
groupIndices.set(text, dependencyGroups.length);
|
|
dependencyGroups.push({
|
|
name: externalModuleName,
|
|
externalImports: [externalImport]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return dependencyGroups;
|
|
}
|
|
function createSystemModuleBody(node, dependencyGroups) {
|
|
const statements = [];
|
|
startLexicalEnvironment();
|
|
const ensureUseStrict = getStrictOptionValue(compilerOptions, "alwaysStrict") || !compilerOptions.noImplicitUseStrict && isExternalModule(currentSourceFile);
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements, ensureUseStrict, topLevelVisitor);
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
"__moduleName",
|
|
void 0,
|
|
void 0,
|
|
factory2.createLogicalAnd(
|
|
contextObject,
|
|
factory2.createPropertyAccessExpression(contextObject, "id")
|
|
)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
visitNode(moduleInfo.externalHelpersImportDeclaration, topLevelVisitor, isStatement);
|
|
const executeStatements = visitNodes2(node.statements, topLevelVisitor, isStatement, statementOffset);
|
|
addRange(statements, hoistedStatements);
|
|
insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
|
|
const exportStarFunction = addExportStarIfNeeded(statements);
|
|
const modifiers = node.transformFlags & 2097152 /* ContainsAwait */ ? factory2.createModifiersFromModifierFlags(512 /* Async */) : void 0;
|
|
const moduleObject = factory2.createObjectLiteralExpression([
|
|
factory2.createPropertyAssignment(
|
|
"setters",
|
|
createSettersArray(exportStarFunction, dependencyGroups)
|
|
),
|
|
factory2.createPropertyAssignment(
|
|
"execute",
|
|
factory2.createFunctionExpression(
|
|
modifiers,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[],
|
|
void 0,
|
|
factory2.createBlock(executeStatements, true)
|
|
)
|
|
)
|
|
], true);
|
|
statements.push(factory2.createReturnStatement(moduleObject));
|
|
return factory2.createBlock(statements, true);
|
|
}
|
|
function addExportStarIfNeeded(statements) {
|
|
if (!moduleInfo.hasExportStarsToExportValues) {
|
|
return;
|
|
}
|
|
if (!moduleInfo.exportedNames && moduleInfo.exportSpecifiers.size === 0) {
|
|
let hasExportDeclarationWithExportClause = false;
|
|
for (const externalImport of moduleInfo.externalImports) {
|
|
if (externalImport.kind === 275 /* ExportDeclaration */ && externalImport.exportClause) {
|
|
hasExportDeclarationWithExportClause = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasExportDeclarationWithExportClause) {
|
|
const exportStarFunction2 = createExportStarFunction(void 0);
|
|
statements.push(exportStarFunction2);
|
|
return exportStarFunction2.name;
|
|
}
|
|
}
|
|
const exportedNames = [];
|
|
if (moduleInfo.exportedNames) {
|
|
for (const exportedLocalName of moduleInfo.exportedNames) {
|
|
if (exportedLocalName.escapedText === "default") {
|
|
continue;
|
|
}
|
|
exportedNames.push(
|
|
factory2.createPropertyAssignment(
|
|
factory2.createStringLiteralFromNode(exportedLocalName),
|
|
factory2.createTrue()
|
|
)
|
|
);
|
|
}
|
|
}
|
|
const exportedNamesStorageRef = factory2.createUniqueName("exportedNames");
|
|
statements.push(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
exportedNamesStorageRef,
|
|
void 0,
|
|
void 0,
|
|
factory2.createObjectLiteralExpression(exportedNames, true)
|
|
)
|
|
])
|
|
)
|
|
);
|
|
const exportStarFunction = createExportStarFunction(exportedNamesStorageRef);
|
|
statements.push(exportStarFunction);
|
|
return exportStarFunction.name;
|
|
}
|
|
function createExportStarFunction(localNames) {
|
|
const exportStarFunction = factory2.createUniqueName("exportStar");
|
|
const m = factory2.createIdentifier("m");
|
|
const n = factory2.createIdentifier("n");
|
|
const exports = factory2.createIdentifier("exports");
|
|
let condition = factory2.createStrictInequality(n, factory2.createStringLiteral("default"));
|
|
if (localNames) {
|
|
condition = factory2.createLogicalAnd(
|
|
condition,
|
|
factory2.createLogicalNot(
|
|
factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(localNames, "hasOwnProperty"),
|
|
void 0,
|
|
[n]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
return factory2.createFunctionDeclaration(
|
|
void 0,
|
|
void 0,
|
|
exportStarFunction,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, m)],
|
|
void 0,
|
|
factory2.createBlock([
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(
|
|
exports,
|
|
void 0,
|
|
void 0,
|
|
factory2.createObjectLiteralExpression([])
|
|
)
|
|
])
|
|
),
|
|
factory2.createForInStatement(
|
|
factory2.createVariableDeclarationList([
|
|
factory2.createVariableDeclaration(n)
|
|
]),
|
|
m,
|
|
factory2.createBlock([
|
|
setEmitFlags(
|
|
factory2.createIfStatement(
|
|
condition,
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
factory2.createElementAccessExpression(exports, n),
|
|
factory2.createElementAccessExpression(m, n)
|
|
)
|
|
)
|
|
),
|
|
1 /* SingleLine */
|
|
)
|
|
])
|
|
),
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[exports]
|
|
)
|
|
)
|
|
], true)
|
|
);
|
|
}
|
|
function createSettersArray(exportStarFunction, dependencyGroups) {
|
|
const setters = [];
|
|
for (const group2 of dependencyGroups) {
|
|
const localName = forEach(group2.externalImports, (i) => getLocalNameForExternalImport(factory2, i, currentSourceFile));
|
|
const parameterName = localName ? factory2.getGeneratedNameForNode(localName) : factory2.createUniqueName("");
|
|
const statements = [];
|
|
for (const entry of group2.externalImports) {
|
|
const importVariableName = getLocalNameForExternalImport(factory2, entry, currentSourceFile);
|
|
switch (entry.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
if (!entry.importClause) {
|
|
break;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
Debug.assert(importVariableName !== void 0);
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(importVariableName, parameterName)
|
|
)
|
|
);
|
|
if (hasSyntacticModifier(entry, 1 /* Export */)) {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(idText(importVariableName)),
|
|
parameterName
|
|
]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
Debug.assert(importVariableName !== void 0);
|
|
if (entry.exportClause) {
|
|
if (isNamedExports(entry.exportClause)) {
|
|
const properties = [];
|
|
for (const e of entry.exportClause.elements) {
|
|
properties.push(
|
|
factory2.createPropertyAssignment(
|
|
factory2.createStringLiteral(idText(e.name)),
|
|
factory2.createElementAccessExpression(
|
|
parameterName,
|
|
factory2.createStringLiteral(idText(e.propertyName || e.name))
|
|
)
|
|
)
|
|
);
|
|
}
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[factory2.createObjectLiteralExpression(properties, true)]
|
|
)
|
|
)
|
|
);
|
|
} else {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportFunction,
|
|
void 0,
|
|
[
|
|
factory2.createStringLiteral(idText(entry.exportClause.name)),
|
|
parameterName
|
|
]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
} else {
|
|
statements.push(
|
|
factory2.createExpressionStatement(
|
|
factory2.createCallExpression(
|
|
exportStarFunction,
|
|
void 0,
|
|
[parameterName]
|
|
)
|
|
)
|
|
);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
setters.push(
|
|
factory2.createFunctionExpression(
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
[factory2.createParameterDeclaration(void 0, void 0, parameterName)],
|
|
void 0,
|
|
factory2.createBlock(statements, true)
|
|
)
|
|
);
|
|
}
|
|
return factory2.createArrayLiteralExpression(setters, true);
|
|
}
|
|
function topLevelVisitor(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return visitImportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return visitImportEqualsDeclaration(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return visitExportDeclaration(node);
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
default:
|
|
return topLevelNestedVisitor(node);
|
|
}
|
|
}
|
|
function visitImportDeclaration(node) {
|
|
let statements;
|
|
if (node.importClause) {
|
|
hoistVariableDeclaration(getLocalNameForExternalImport(factory2, node, currentSourceFile));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
Debug.assertIsDefined(node);
|
|
return void 0;
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
hoistVariableDeclaration(getLocalNameForExternalImport(factory2, node, currentSourceFile));
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitExportAssignment(node) {
|
|
if (node.isExportEquals) {
|
|
return void 0;
|
|
}
|
|
const expression = visitNode(node.expression, visitor, isExpression);
|
|
const original = node.original;
|
|
if (original && hasAssociatedEndOfDeclarationMarker(original)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportStatement(deferredExports[id], factory2.createIdentifier("default"), expression, true);
|
|
} else {
|
|
return createExportStatement(factory2.createIdentifier("default"), expression, true);
|
|
}
|
|
}
|
|
function visitFunctionDeclaration(node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
hoistedStatements = append(
|
|
hoistedStatements,
|
|
factory2.updateFunctionDeclaration(
|
|
node,
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
node.asteriskToken,
|
|
factory2.getDeclarationName(node, true, true),
|
|
void 0,
|
|
visitNodes2(node.parameters, visitor, isParameterDeclaration),
|
|
void 0,
|
|
visitNode(node.body, visitor, isBlock)
|
|
)
|
|
);
|
|
} else {
|
|
hoistedStatements = append(hoistedStatements, visitEachChild(node, visitor, context));
|
|
}
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function visitClassDeclaration(node) {
|
|
let statements;
|
|
const name = factory2.getLocalName(node);
|
|
hoistVariableDeclaration(name);
|
|
statements = append(
|
|
statements,
|
|
setTextRange(
|
|
factory2.createExpressionStatement(
|
|
factory2.createAssignment(
|
|
name,
|
|
setTextRange(
|
|
factory2.createClassExpression(
|
|
visitNodes2(node.modifiers, modifierVisitor, isModifierLike),
|
|
node.name,
|
|
void 0,
|
|
visitNodes2(node.heritageClauses, visitor, isHeritageClause),
|
|
visitNodes2(node.members, visitor, isClassElement)
|
|
),
|
|
node
|
|
)
|
|
)
|
|
),
|
|
node
|
|
)
|
|
);
|
|
if (hasAssociatedEndOfDeclarationMarker(node)) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node);
|
|
} else {
|
|
statements = appendExportsOfHoistedDeclaration(statements, node);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function visitVariableStatement(node) {
|
|
if (!shouldHoistVariableDeclarationList(node.declarationList)) {
|
|
return visitNode(node, visitor, isStatement);
|
|
}
|
|
let expressions;
|
|
const isExportedDeclaration = hasSyntacticModifier(node, 1 /* Export */);
|
|
const isMarkedDeclaration = hasAssociatedEndOfDeclarationMarker(node);
|
|
for (const variable of node.declarationList.declarations) {
|
|
if (variable.initializer) {
|
|
expressions = append(expressions, transformInitializedVariable(variable, isExportedDeclaration && !isMarkedDeclaration));
|
|
} else {
|
|
hoistBindingElement(variable);
|
|
}
|
|
}
|
|
let statements;
|
|
if (expressions) {
|
|
statements = append(statements, setTextRange(factory2.createExpressionStatement(factory2.inlineExpressions(expressions)), node));
|
|
}
|
|
if (isMarkedDeclaration) {
|
|
const id = getOriginalNodeId(node);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration);
|
|
} else {
|
|
statements = appendExportsOfVariableStatement(statements, node, false);
|
|
}
|
|
return singleOrMany(statements);
|
|
}
|
|
function hoistBindingElement(node) {
|
|
if (isBindingPattern(node.name)) {
|
|
for (const element of node.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
hoistBindingElement(element);
|
|
}
|
|
}
|
|
} else {
|
|
hoistVariableDeclaration(factory2.cloneNode(node.name));
|
|
}
|
|
}
|
|
function shouldHoistVariableDeclarationList(node) {
|
|
return (getEmitFlags(node) & 4194304 /* NoHoisting */) === 0 && (enclosingBlockScopedContainer.kind === 308 /* SourceFile */ || (getOriginalNode(node).flags & 3 /* BlockScoped */) === 0);
|
|
}
|
|
function transformInitializedVariable(node, isExportedDeclaration) {
|
|
const createAssignment3 = isExportedDeclaration ? createExportedVariableAssignment : createNonExportedVariableAssignment;
|
|
return isBindingPattern(node.name) ? flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
false,
|
|
createAssignment3
|
|
) : node.initializer ? createAssignment3(node.name, visitNode(node.initializer, visitor, isExpression)) : node.name;
|
|
}
|
|
function createExportedVariableAssignment(name, value, location2) {
|
|
return createVariableAssignment(name, value, location2, true);
|
|
}
|
|
function createNonExportedVariableAssignment(name, value, location2) {
|
|
return createVariableAssignment(name, value, location2, false);
|
|
}
|
|
function createVariableAssignment(name, value, location2, isExportedDeclaration) {
|
|
hoistVariableDeclaration(factory2.cloneNode(name));
|
|
return isExportedDeclaration ? createExportExpression(name, preventSubstitution(setTextRange(factory2.createAssignment(name, value), location2))) : preventSubstitution(setTextRange(factory2.createAssignment(name, value), location2));
|
|
}
|
|
function visitMergeDeclarationMarker(node) {
|
|
if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* VariableStatement */) {
|
|
const id = getOriginalNodeId(node);
|
|
const isExportedDeclaration = hasSyntacticModifier(node.original, 1 /* Export */);
|
|
deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original, isExportedDeclaration);
|
|
}
|
|
return node;
|
|
}
|
|
function hasAssociatedEndOfDeclarationMarker(node) {
|
|
return (getEmitFlags(node) & 8388608 /* HasEndOfDeclarationMarker */) !== 0;
|
|
}
|
|
function visitEndOfDeclarationMarker(node) {
|
|
const id = getOriginalNodeId(node);
|
|
const statements = deferredExports[id];
|
|
if (statements) {
|
|
delete deferredExports[id];
|
|
return append(statements, node);
|
|
} else {
|
|
const original = getOriginalNode(node);
|
|
if (isModuleOrEnumDeclaration(original)) {
|
|
return append(appendExportsOfDeclaration(statements, original), node);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function appendExportsOfImportDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const importClause = decl.importClause;
|
|
if (!importClause) {
|
|
return statements;
|
|
}
|
|
if (importClause.name) {
|
|
statements = appendExportsOfDeclaration(statements, importClause);
|
|
}
|
|
const namedBindings = importClause.namedBindings;
|
|
if (namedBindings) {
|
|
switch (namedBindings.kind) {
|
|
case 271 /* NamespaceImport */:
|
|
statements = appendExportsOfDeclaration(statements, namedBindings);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
for (const importBinding of namedBindings.elements) {
|
|
statements = appendExportsOfDeclaration(statements, importBinding);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
return appendExportsOfDeclaration(statements, decl);
|
|
}
|
|
function appendExportsOfVariableStatement(statements, node, exportSelf) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
for (const decl of node.declarationList.declarations) {
|
|
if (decl.initializer || exportSelf) {
|
|
statements = appendExportsOfBindingElement(statements, decl, exportSelf);
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfBindingElement(statements, decl, exportSelf) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
if (isBindingPattern(decl.name)) {
|
|
for (const element of decl.name.elements) {
|
|
if (!isOmittedExpression(element)) {
|
|
statements = appendExportsOfBindingElement(statements, element, exportSelf);
|
|
}
|
|
}
|
|
} else if (!isGeneratedIdentifier(decl.name)) {
|
|
let excludeName;
|
|
if (exportSelf) {
|
|
statements = appendExportStatement(statements, decl.name, factory2.getLocalName(decl));
|
|
excludeName = idText(decl.name);
|
|
}
|
|
statements = appendExportsOfDeclaration(statements, decl, excludeName);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfHoistedDeclaration(statements, decl) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
let excludeName;
|
|
if (hasSyntacticModifier(decl, 1 /* Export */)) {
|
|
const exportName = hasSyntacticModifier(decl, 1024 /* Default */) ? factory2.createStringLiteral("default") : decl.name;
|
|
statements = appendExportStatement(statements, exportName, factory2.getLocalName(decl));
|
|
excludeName = getTextOfIdentifierOrLiteral(exportName);
|
|
}
|
|
if (decl.name) {
|
|
statements = appendExportsOfDeclaration(statements, decl, excludeName);
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportsOfDeclaration(statements, decl, excludeName) {
|
|
if (moduleInfo.exportEquals) {
|
|
return statements;
|
|
}
|
|
const name = factory2.getDeclarationName(decl);
|
|
const exportSpecifiers = moduleInfo.exportSpecifiers.get(idText(name));
|
|
if (exportSpecifiers) {
|
|
for (const exportSpecifier of exportSpecifiers) {
|
|
if (exportSpecifier.name.escapedText !== excludeName) {
|
|
statements = appendExportStatement(statements, exportSpecifier.name, name);
|
|
}
|
|
}
|
|
}
|
|
return statements;
|
|
}
|
|
function appendExportStatement(statements, exportName, expression, allowComments) {
|
|
statements = append(statements, createExportStatement(exportName, expression, allowComments));
|
|
return statements;
|
|
}
|
|
function createExportStatement(name, value, allowComments) {
|
|
const statement = factory2.createExpressionStatement(createExportExpression(name, value));
|
|
startOnNewLine(statement);
|
|
if (!allowComments) {
|
|
setEmitFlags(statement, 3072 /* NoComments */);
|
|
}
|
|
return statement;
|
|
}
|
|
function createExportExpression(name, value) {
|
|
const exportName = isIdentifier(name) ? factory2.createStringLiteralFromNode(name) : name;
|
|
setEmitFlags(value, getEmitFlags(value) | 3072 /* NoComments */);
|
|
return setCommentRange(factory2.createCallExpression(exportFunction, void 0, [exportName, value]), value);
|
|
}
|
|
function topLevelNestedVisitor(node) {
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return visitVariableStatement(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return visitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return visitClassDeclaration(node);
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, true);
|
|
case 246 /* ForInStatement */:
|
|
return visitForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return visitForOfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return visitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return visitWhileStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return visitLabeledStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return visitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return visitSwitchStatement(node);
|
|
case 266 /* CaseBlock */:
|
|
return visitCaseBlock(node);
|
|
case 292 /* CaseClause */:
|
|
return visitCaseClause(node);
|
|
case 293 /* DefaultClause */:
|
|
return visitDefaultClause(node);
|
|
case 255 /* TryStatement */:
|
|
return visitTryStatement(node);
|
|
case 295 /* CatchClause */:
|
|
return visitCatchClause(node);
|
|
case 238 /* Block */:
|
|
return visitBlock(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return visitMergeDeclarationMarker(node);
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return visitEndOfDeclarationMarker(node);
|
|
default:
|
|
return visitor(node);
|
|
}
|
|
}
|
|
function visitForStatement(node, isTopLevel) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForStatement(
|
|
node,
|
|
visitNode(node.initializer, isTopLevel ? visitForInitializer : discardedValueVisitor, isForInitializer),
|
|
visitNode(node.condition, visitor, isExpression),
|
|
visitNode(node.incrementor, discardedValueVisitor, isExpression),
|
|
visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitForInStatement(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForInStatement(
|
|
node,
|
|
visitForInitializer(node.initializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitForOfStatement(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateForOfStatement(
|
|
node,
|
|
node.awaitModifier,
|
|
visitForInitializer(node.initializer),
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function shouldHoistForInitializer(node) {
|
|
return isVariableDeclarationList(node) && shouldHoistVariableDeclarationList(node);
|
|
}
|
|
function visitForInitializer(node) {
|
|
if (shouldHoistForInitializer(node)) {
|
|
let expressions;
|
|
for (const variable of node.declarations) {
|
|
expressions = append(expressions, transformInitializedVariable(variable, false));
|
|
if (!variable.initializer) {
|
|
hoistBindingElement(variable);
|
|
}
|
|
}
|
|
return expressions ? factory2.inlineExpressions(expressions) : factory2.createOmittedExpression();
|
|
} else {
|
|
return visitNode(node, discardedValueVisitor, isExpression);
|
|
}
|
|
}
|
|
function visitDoStatement(node) {
|
|
return factory2.updateDoStatement(
|
|
node,
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context),
|
|
visitNode(node.expression, visitor, isExpression)
|
|
);
|
|
}
|
|
function visitWhileStatement(node) {
|
|
return factory2.updateWhileStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitIterationBody(node.statement, topLevelNestedVisitor, context)
|
|
);
|
|
}
|
|
function visitLabeledStatement(node) {
|
|
return factory2.updateLabeledStatement(
|
|
node,
|
|
node.label,
|
|
visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitWithStatement(node) {
|
|
return factory2.updateWithStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock)
|
|
);
|
|
}
|
|
function visitSwitchStatement(node) {
|
|
return factory2.updateSwitchStatement(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNode(node.caseBlock, topLevelNestedVisitor, isCaseBlock)
|
|
);
|
|
}
|
|
function visitCaseBlock(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateCaseBlock(
|
|
node,
|
|
visitNodes2(node.clauses, topLevelNestedVisitor, isCaseOrDefaultClause)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitCaseClause(node) {
|
|
return factory2.updateCaseClause(
|
|
node,
|
|
visitNode(node.expression, visitor, isExpression),
|
|
visitNodes2(node.statements, topLevelNestedVisitor, isStatement)
|
|
);
|
|
}
|
|
function visitDefaultClause(node) {
|
|
return visitEachChild(node, topLevelNestedVisitor, context);
|
|
}
|
|
function visitTryStatement(node) {
|
|
return visitEachChild(node, topLevelNestedVisitor, context);
|
|
}
|
|
function visitCatchClause(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = factory2.updateCatchClause(
|
|
node,
|
|
node.variableDeclaration,
|
|
visitNode(node.block, topLevelNestedVisitor, isBlock)
|
|
);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitBlock(node) {
|
|
const savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer;
|
|
enclosingBlockScopedContainer = node;
|
|
node = visitEachChild(node, topLevelNestedVisitor, context);
|
|
enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer;
|
|
return node;
|
|
}
|
|
function visitorWorker(node, valueIsDiscarded) {
|
|
if (!(node.transformFlags & (4096 /* ContainsDestructuringAssignment */ | 8388608 /* ContainsDynamicImport */ | 268435456 /* ContainsUpdateExpressionForIdentifier */))) {
|
|
return node;
|
|
}
|
|
switch (node.kind) {
|
|
case 245 /* ForStatement */:
|
|
return visitForStatement(node, false);
|
|
case 241 /* ExpressionStatement */:
|
|
return visitExpressionStatement(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return visitParenthesizedExpression(node, valueIsDiscarded);
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return visitPartiallyEmittedExpression(node, valueIsDiscarded);
|
|
case 223 /* BinaryExpression */:
|
|
if (isDestructuringAssignment(node)) {
|
|
return visitDestructuringAssignment(node, valueIsDiscarded);
|
|
}
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
if (isImportCall(node)) {
|
|
return visitImportCallExpression(node);
|
|
}
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function visitor(node) {
|
|
return visitorWorker(node, false);
|
|
}
|
|
function discardedValueVisitor(node) {
|
|
return visitorWorker(node, true);
|
|
}
|
|
function visitExpressionStatement(node) {
|
|
return factory2.updateExpressionStatement(node, visitNode(node.expression, discardedValueVisitor, isExpression));
|
|
}
|
|
function visitParenthesizedExpression(node, valueIsDiscarded) {
|
|
return factory2.updateParenthesizedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitPartiallyEmittedExpression(node, valueIsDiscarded) {
|
|
return factory2.updatePartiallyEmittedExpression(node, visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, isExpression));
|
|
}
|
|
function visitImportCallExpression(node) {
|
|
const externalModuleName = getExternalModuleNameLiteral(factory2, node, currentSourceFile, host, resolver, compilerOptions);
|
|
const firstArgument = visitNode(firstOrUndefined(node.arguments), visitor);
|
|
const argument = externalModuleName && (!firstArgument || !isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument;
|
|
return factory2.createCallExpression(
|
|
factory2.createPropertyAccessExpression(
|
|
contextObject,
|
|
factory2.createIdentifier("import")
|
|
),
|
|
void 0,
|
|
argument ? [argument] : []
|
|
);
|
|
}
|
|
function visitDestructuringAssignment(node, valueIsDiscarded) {
|
|
if (hasExportedReferenceInDestructuringTarget(node.left)) {
|
|
return flattenDestructuringAssignment(
|
|
node,
|
|
visitor,
|
|
context,
|
|
0 /* All */,
|
|
!valueIsDiscarded
|
|
);
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function hasExportedReferenceInDestructuringTarget(node) {
|
|
if (isAssignmentExpression(node, true)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.left);
|
|
} else if (isSpreadElement(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.expression);
|
|
} else if (isObjectLiteralExpression(node)) {
|
|
return some(node.properties, hasExportedReferenceInDestructuringTarget);
|
|
} else if (isArrayLiteralExpression(node)) {
|
|
return some(node.elements, hasExportedReferenceInDestructuringTarget);
|
|
} else if (isShorthandPropertyAssignment(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.name);
|
|
} else if (isPropertyAssignment(node)) {
|
|
return hasExportedReferenceInDestructuringTarget(node.initializer);
|
|
} else if (isIdentifier(node)) {
|
|
const container = resolver.getReferencedExportContainer(node);
|
|
return container !== void 0 && container.kind === 308 /* SourceFile */;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
function visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded) {
|
|
if ((node.operator === 45 /* PlusPlusToken */ || node.operator === 46 /* MinusMinusToken */) && isIdentifier(node.operand) && !isGeneratedIdentifier(node.operand) && !isLocalName(node.operand) && !isDeclarationNameOfEnumOrNamespace(node.operand)) {
|
|
const exportedNames = getExports(node.operand);
|
|
if (exportedNames) {
|
|
let temp;
|
|
let expression = visitNode(node.operand, visitor, isExpression);
|
|
if (isPrefixUnaryExpression(node)) {
|
|
expression = factory2.updatePrefixUnaryExpression(node, expression);
|
|
} else {
|
|
expression = factory2.updatePostfixUnaryExpression(node, expression);
|
|
if (!valueIsDiscarded) {
|
|
temp = factory2.createTempVariable(hoistVariableDeclaration);
|
|
expression = factory2.createAssignment(temp, expression);
|
|
setTextRange(expression, node);
|
|
}
|
|
expression = factory2.createComma(expression, factory2.cloneNode(node.operand));
|
|
setTextRange(expression, node);
|
|
}
|
|
for (const exportName of exportedNames) {
|
|
expression = createExportExpression(exportName, preventSubstitution(expression));
|
|
}
|
|
if (temp) {
|
|
expression = factory2.createComma(expression, temp);
|
|
setTextRange(expression, node);
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
function modifierVisitor(node) {
|
|
switch (node.kind) {
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
const id = getOriginalNodeId(node);
|
|
currentSourceFile = node;
|
|
moduleInfo = moduleInfoMap[id];
|
|
exportFunction = exportFunctionsMap[id];
|
|
noSubstitution = noSubstitutionMap[id];
|
|
contextObject = contextObjectMap[id];
|
|
if (noSubstitution) {
|
|
delete noSubstitutionMap[id];
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
currentSourceFile = void 0;
|
|
moduleInfo = void 0;
|
|
exportFunction = void 0;
|
|
contextObject = void 0;
|
|
noSubstitution = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (isSubstitutionPrevented(node)) {
|
|
return node;
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
return substituteExpression(node);
|
|
} else if (hint === 4 /* Unspecified */) {
|
|
return substituteUnspecified(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteUnspecified(node) {
|
|
switch (node.kind) {
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return substituteShorthandPropertyAssignment(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteShorthandPropertyAssignment(node) {
|
|
var _a2, _b;
|
|
const name = node.name;
|
|
if (!isGeneratedIdentifier(name) && !isLocalName(name)) {
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(name);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
factory2.cloneNode(name),
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
)
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAssignment(
|
|
factory2.cloneNode(name),
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(importDeclaration.propertyName || importDeclaration.name)
|
|
)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpression(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return substituteExpressionIdentifier(node);
|
|
case 223 /* BinaryExpression */:
|
|
return substituteBinaryExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return substituteMetaProperty(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteExpressionIdentifier(node) {
|
|
var _a2, _b;
|
|
if (getEmitFlags(node) & 8192 /* HelperName */) {
|
|
const externalHelpersModuleName = getExternalHelpersModuleName(currentSourceFile);
|
|
if (externalHelpersModuleName) {
|
|
return factory2.createPropertyAccessExpression(externalHelpersModuleName, node);
|
|
}
|
|
return node;
|
|
}
|
|
if (!isGeneratedIdentifier(node) && !isLocalName(node)) {
|
|
const importDeclaration = resolver.getReferencedImportDeclaration(node);
|
|
if (importDeclaration) {
|
|
if (isImportClause(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(importDeclaration.parent),
|
|
factory2.createIdentifier("default")
|
|
),
|
|
node
|
|
);
|
|
} else if (isImportSpecifier(importDeclaration)) {
|
|
return setTextRange(
|
|
factory2.createPropertyAccessExpression(
|
|
factory2.getGeneratedNameForNode(((_b = (_a2 = importDeclaration.parent) == null ? void 0 : _a2.parent) == null ? void 0 : _b.parent) || importDeclaration),
|
|
factory2.cloneNode(importDeclaration.propertyName || importDeclaration.name)
|
|
),
|
|
node
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteBinaryExpression(node) {
|
|
if (isAssignmentOperator(node.operatorToken.kind) && isIdentifier(node.left) && !isGeneratedIdentifier(node.left) && !isLocalName(node.left) && !isDeclarationNameOfEnumOrNamespace(node.left)) {
|
|
const exportedNames = getExports(node.left);
|
|
if (exportedNames) {
|
|
let expression = node;
|
|
for (const exportName of exportedNames) {
|
|
expression = createExportExpression(exportName, preventSubstitution(expression));
|
|
}
|
|
return expression;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function substituteMetaProperty(node) {
|
|
if (isImportMeta(node)) {
|
|
return factory2.createPropertyAccessExpression(contextObject, factory2.createIdentifier("meta"));
|
|
}
|
|
return node;
|
|
}
|
|
function getExports(name) {
|
|
let exportedNames;
|
|
if (!isGeneratedIdentifier(name)) {
|
|
const valueDeclaration = resolver.getReferencedImportDeclaration(name) || resolver.getReferencedValueDeclaration(name);
|
|
if (valueDeclaration) {
|
|
const exportContainer = resolver.getReferencedExportContainer(name, false);
|
|
if (exportContainer && exportContainer.kind === 308 /* SourceFile */) {
|
|
exportedNames = append(exportedNames, factory2.getDeclarationName(valueDeclaration));
|
|
}
|
|
exportedNames = addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[getOriginalNodeId(valueDeclaration)]);
|
|
}
|
|
}
|
|
return exportedNames;
|
|
}
|
|
function preventSubstitution(node) {
|
|
if (noSubstitution === void 0)
|
|
noSubstitution = [];
|
|
noSubstitution[getNodeId(node)] = true;
|
|
return node;
|
|
}
|
|
function isSubstitutionPrevented(node) {
|
|
return noSubstitution && node.id && noSubstitution[node.id];
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/esnextAnd2015.ts
|
|
function transformECMAScriptModule(context) {
|
|
const {
|
|
factory: factory2,
|
|
getEmitHelperFactory: emitHelpers
|
|
} = context;
|
|
const host = context.getEmitHost();
|
|
const resolver = context.getEmitResolver();
|
|
const compilerOptions = context.getCompilerOptions();
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
context.enableSubstitution(79 /* Identifier */);
|
|
let helperNameSubstitutions;
|
|
let currentSourceFile;
|
|
let importRequireStatements;
|
|
return chainBundle(context, transformSourceFile);
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
if (isExternalModule(node) || compilerOptions.isolatedModules) {
|
|
currentSourceFile = node;
|
|
importRequireStatements = void 0;
|
|
let result = updateExternalModule(node);
|
|
currentSourceFile = void 0;
|
|
if (importRequireStatements) {
|
|
result = factory2.updateSourceFile(
|
|
result,
|
|
setTextRange(factory2.createNodeArray(insertStatementsAfterCustomPrologue(result.statements.slice(), importRequireStatements)), result.statements)
|
|
);
|
|
}
|
|
if (!isExternalModule(node) || some(result.statements, isExternalModuleIndicator)) {
|
|
return result;
|
|
}
|
|
return factory2.updateSourceFile(
|
|
result,
|
|
setTextRange(factory2.createNodeArray([...result.statements, createEmptyExports(factory2)]), result.statements)
|
|
);
|
|
}
|
|
return node;
|
|
}
|
|
function updateExternalModule(node) {
|
|
const externalHelpersImportDeclaration = createExternalHelpersImportDeclarationIfNeeded(factory2, emitHelpers(), node, compilerOptions);
|
|
if (externalHelpersImportDeclaration) {
|
|
const statements = [];
|
|
const statementOffset = factory2.copyPrologue(node.statements, statements);
|
|
append(statements, externalHelpersImportDeclaration);
|
|
addRange(statements, visitNodes2(node.statements, visitor, isStatement, statementOffset));
|
|
return factory2.updateSourceFile(
|
|
node,
|
|
setTextRange(factory2.createNodeArray(statements), node.statements)
|
|
);
|
|
} else {
|
|
return visitEachChild(node, visitor, context);
|
|
}
|
|
}
|
|
function visitor(node) {
|
|
switch (node.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return getEmitModuleKind(compilerOptions) >= 100 /* Node16 */ ? visitImportEqualsDeclaration(node) : void 0;
|
|
case 274 /* ExportAssignment */:
|
|
return visitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
const exportDecl = node;
|
|
return visitExportDeclaration(exportDecl);
|
|
}
|
|
return node;
|
|
}
|
|
function createRequireCall2(importNode) {
|
|
const moduleName = getExternalModuleNameLiteral(factory2, importNode, Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions);
|
|
const args = [];
|
|
if (moduleName) {
|
|
args.push(moduleName);
|
|
}
|
|
if (!importRequireStatements) {
|
|
const createRequireName = factory2.createUniqueName("_createRequire", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
const importStatement = factory2.createImportDeclaration(
|
|
void 0,
|
|
factory2.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory2.createNamedImports([
|
|
factory2.createImportSpecifier(false, factory2.createIdentifier("createRequire"), createRequireName)
|
|
])
|
|
),
|
|
factory2.createStringLiteral("module")
|
|
);
|
|
const requireHelperName = factory2.createUniqueName("__require", 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
const requireStatement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
requireHelperName,
|
|
void 0,
|
|
void 0,
|
|
factory2.createCallExpression(factory2.cloneNode(createRequireName), void 0, [
|
|
factory2.createPropertyAccessExpression(factory2.createMetaProperty(100 /* ImportKeyword */, factory2.createIdentifier("meta")), factory2.createIdentifier("url"))
|
|
])
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
);
|
|
importRequireStatements = [importStatement, requireStatement];
|
|
}
|
|
const name = importRequireStatements[1].declarationList.declarations[0].name;
|
|
Debug.assertNode(name, isIdentifier);
|
|
return factory2.createCallExpression(factory2.cloneNode(name), void 0, args);
|
|
}
|
|
function visitImportEqualsDeclaration(node) {
|
|
Debug.assert(isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer.");
|
|
let statements;
|
|
statements = append(
|
|
statements,
|
|
setOriginalNode(
|
|
setTextRange(
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
[
|
|
factory2.createVariableDeclaration(
|
|
factory2.cloneNode(node.name),
|
|
void 0,
|
|
void 0,
|
|
createRequireCall2(node)
|
|
)
|
|
],
|
|
languageVersion >= 2 /* ES2015 */ ? 2 /* Const */ : 0 /* None */
|
|
)
|
|
),
|
|
node
|
|
),
|
|
node
|
|
)
|
|
);
|
|
statements = appendExportsOfImportEqualsDeclaration(statements, node);
|
|
return singleOrMany(statements);
|
|
}
|
|
function appendExportsOfImportEqualsDeclaration(statements, node) {
|
|
if (hasSyntacticModifier(node, 1 /* Export */)) {
|
|
statements = append(statements, factory2.createExportDeclaration(
|
|
void 0,
|
|
node.isTypeOnly,
|
|
factory2.createNamedExports([factory2.createExportSpecifier(false, void 0, idText(node.name))])
|
|
));
|
|
}
|
|
return statements;
|
|
}
|
|
function visitExportAssignment(node) {
|
|
return node.isExportEquals ? void 0 : node;
|
|
}
|
|
function visitExportDeclaration(node) {
|
|
if (compilerOptions.module !== void 0 && compilerOptions.module > 5 /* ES2015 */) {
|
|
return node;
|
|
}
|
|
if (!node.exportClause || !isNamespaceExport(node.exportClause) || !node.moduleSpecifier) {
|
|
return node;
|
|
}
|
|
const oldIdentifier = node.exportClause.name;
|
|
const synthName = factory2.getGeneratedNameForNode(oldIdentifier);
|
|
const importDecl = factory2.createImportDeclaration(
|
|
void 0,
|
|
factory2.createImportClause(
|
|
false,
|
|
void 0,
|
|
factory2.createNamespaceImport(
|
|
synthName
|
|
)
|
|
),
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
);
|
|
setOriginalNode(importDecl, node.exportClause);
|
|
const exportDecl = isExportNamespaceAsDefaultDeclaration(node) ? factory2.createExportDefault(synthName) : factory2.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory2.createNamedExports([factory2.createExportSpecifier(false, synthName, oldIdentifier)])
|
|
);
|
|
setOriginalNode(exportDecl, node);
|
|
return [importDecl, exportDecl];
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (isSourceFile(node)) {
|
|
if ((isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) {
|
|
helperNameSubstitutions = /* @__PURE__ */ new Map();
|
|
}
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
helperNameSubstitutions = void 0;
|
|
} else {
|
|
previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
}
|
|
function onSubstituteNode(hint, node) {
|
|
node = previousOnSubstituteNode(hint, node);
|
|
if (helperNameSubstitutions && isIdentifier(node) && getEmitFlags(node) & 8192 /* HelperName */) {
|
|
return substituteHelperName(node);
|
|
}
|
|
return node;
|
|
}
|
|
function substituteHelperName(node) {
|
|
const name = idText(node);
|
|
let substitution = helperNameSubstitutions.get(name);
|
|
if (!substitution) {
|
|
helperNameSubstitutions.set(name, substitution = factory2.createUniqueName(name, 16 /* Optimistic */ | 32 /* FileLevel */));
|
|
}
|
|
return substitution;
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/module/node.ts
|
|
function transformNodeModule(context) {
|
|
const previousOnSubstituteNode = context.onSubstituteNode;
|
|
const previousOnEmitNode = context.onEmitNode;
|
|
const esmTransform = transformECMAScriptModule(context);
|
|
const esmOnSubstituteNode = context.onSubstituteNode;
|
|
const esmOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = previousOnSubstituteNode;
|
|
context.onEmitNode = previousOnEmitNode;
|
|
const cjsTransform = transformModule(context);
|
|
const cjsOnSubstituteNode = context.onSubstituteNode;
|
|
const cjsOnEmitNode = context.onEmitNode;
|
|
context.onSubstituteNode = onSubstituteNode;
|
|
context.onEmitNode = onEmitNode;
|
|
context.enableSubstitution(308 /* SourceFile */);
|
|
context.enableEmitNotification(308 /* SourceFile */);
|
|
let currentSourceFile;
|
|
return transformSourceFileOrBundle;
|
|
function onSubstituteNode(hint, node) {
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
return previousOnSubstituteNode(hint, node);
|
|
} else {
|
|
if (!currentSourceFile) {
|
|
return previousOnSubstituteNode(hint, node);
|
|
}
|
|
if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
return esmOnSubstituteNode(hint, node);
|
|
}
|
|
return cjsOnSubstituteNode(hint, node);
|
|
}
|
|
}
|
|
function onEmitNode(hint, node, emitCallback) {
|
|
if (isSourceFile(node)) {
|
|
currentSourceFile = node;
|
|
}
|
|
if (!currentSourceFile) {
|
|
return previousOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
if (currentSourceFile.impliedNodeFormat === 99 /* ESNext */) {
|
|
return esmOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
return cjsOnEmitNode(hint, node, emitCallback);
|
|
}
|
|
function getModuleTransformForFile(file) {
|
|
return file.impliedNodeFormat === 99 /* ESNext */ ? esmTransform : cjsTransform;
|
|
}
|
|
function transformSourceFile(node) {
|
|
if (node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
currentSourceFile = node;
|
|
const result = getModuleTransformForFile(node)(node);
|
|
currentSourceFile = void 0;
|
|
Debug.assert(isSourceFile(result));
|
|
return result;
|
|
}
|
|
function transformSourceFileOrBundle(node) {
|
|
return node.kind === 308 /* SourceFile */ ? transformSourceFile(node) : transformBundle(node);
|
|
}
|
|
function transformBundle(node) {
|
|
return context.factory.createBundle(map(node.sourceFiles, transformSourceFile), node.prepends);
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/declarations/diagnostics.ts
|
|
function canProduceDiagnostics(node) {
|
|
return isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isBindingElement(node) || isSetAccessor(node) || isGetAccessor(node) || isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isParameter(node) || isTypeParameterDeclaration(node) || isExpressionWithTypeArguments(node) || isImportEqualsDeclaration(node) || isTypeAliasDeclaration(node) || isConstructorDeclaration(node) || isIndexSignatureDeclaration(node) || isPropertyAccessExpression(node) || isJSDocTypeAlias(node);
|
|
}
|
|
function createGetSymbolAccessibilityDiagnosticForNodeName(node) {
|
|
if (isSetAccessor(node) || isGetAccessor(node)) {
|
|
return getAccessorNameVisibilityError;
|
|
} else if (isMethodSignature(node) || isMethodDeclaration(node)) {
|
|
return getMethodNameVisibilityError;
|
|
} else {
|
|
return createGetSymbolAccessibilityDiagnosticForNode(node);
|
|
}
|
|
function getAccessorNameVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
function getMethodNameVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_method_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Method_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
}
|
|
function createGetSymbolAccessibilityDiagnosticForNode(node) {
|
|
if (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isPropertyAccessExpression(node) || isBindingElement(node) || isConstructorDeclaration(node)) {
|
|
return getVariableDeclarationTypeVisibilityError;
|
|
} else if (isSetAccessor(node) || isGetAccessor(node)) {
|
|
return getAccessorDeclarationTypeVisibilityError;
|
|
} else if (isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isIndexSignatureDeclaration(node)) {
|
|
return getReturnTypeVisibilityError;
|
|
} else if (isParameter(node)) {
|
|
if (isParameterPropertyDeclaration(node, node.parent) && hasSyntacticModifier(node.parent, 8 /* Private */)) {
|
|
return getVariableDeclarationTypeVisibilityError;
|
|
}
|
|
return getParameterDeclarationTypeVisibilityError;
|
|
} else if (isTypeParameterDeclaration(node)) {
|
|
return getTypeParameterConstraintVisibilityError;
|
|
} else if (isExpressionWithTypeArguments(node)) {
|
|
return getHeritageClauseVisibilityError;
|
|
} else if (isImportEqualsDeclaration(node)) {
|
|
return getImportEntityNameVisibilityError;
|
|
} else if (isTypeAliasDeclaration(node) || isJSDocTypeAlias(node)) {
|
|
return getTypeAliasDeclarationVisibilityError;
|
|
} else {
|
|
return Debug.assertNever(node, `Attempted to set a declaration diagnostic context for unhandled node kind: ${Debug.formatSyntaxKind(node.kind)}`);
|
|
}
|
|
function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
|
|
} else if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 208 /* PropertyAccessExpression */ || node.kind === 168 /* PropertySignature */ || node.kind === 166 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
|
|
if (isStatic(node)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */ || node.kind === 166 /* Parameter */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
}
|
|
function getVariableDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
let diagnosticMessage;
|
|
if (node.kind === 175 /* SetAccessor */) {
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
}
|
|
} else {
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1;
|
|
}
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node.name,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getReturnTypeVisibilityError(symbolAccessibilityResult) {
|
|
let diagnosticMessage;
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 178 /* IndexSignature */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node)) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0;
|
|
} else if (node.parent.kind === 260 /* ClassDeclaration */) {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0;
|
|
} else {
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0;
|
|
}
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
diagnosticMessage = symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0;
|
|
break;
|
|
default:
|
|
return Debug.fail("This is unknown kind for signature: " + node.kind);
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node.name || node
|
|
};
|
|
}
|
|
function getParameterDeclarationTypeVisibilityError(symbolAccessibilityResult) {
|
|
const diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult);
|
|
return diagnosticMessage !== void 0 ? {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
} : void 0;
|
|
}
|
|
function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
|
|
switch (node.parent.kind) {
|
|
case 173 /* Constructor */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1;
|
|
case 177 /* ConstructSignature */:
|
|
case 182 /* ConstructorType */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 176 /* CallSignature */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 178 /* IndexSignature */:
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node.parent)) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.parent.kind === 260 /* ClassDeclaration */) {
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
return symbolAccessibilityResult.errorModuleName ? Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 181 /* FunctionType */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1;
|
|
case 175 /* SetAccessor */:
|
|
case 174 /* GetAccessor */:
|
|
return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Parameter_0_of_accessor_has_or_is_using_private_name_1;
|
|
default:
|
|
return Debug.fail(`Unknown parent for parameter: ${Debug.formatSyntaxKind(node.parent.kind)}`);
|
|
}
|
|
}
|
|
function getTypeParameterConstraintVisibilityError() {
|
|
let diagnosticMessage;
|
|
switch (node.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1;
|
|
break;
|
|
case 261 /* InterfaceDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 197 /* MappedType */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1;
|
|
break;
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 176 /* CallSignature */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1;
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isStatic(node.parent)) {
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else if (node.parent.parent.kind === 260 /* ClassDeclaration */) {
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1;
|
|
} else {
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1;
|
|
}
|
|
break;
|
|
case 181 /* FunctionType */:
|
|
case 259 /* FunctionDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1;
|
|
break;
|
|
case 262 /* TypeAliasDeclaration */:
|
|
diagnosticMessage = Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1;
|
|
break;
|
|
default:
|
|
return Debug.fail("This is unknown parent for type parameter: " + node.parent.kind);
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getHeritageClauseVisibilityError() {
|
|
let diagnosticMessage;
|
|
if (isClassDeclaration(node.parent.parent)) {
|
|
diagnosticMessage = isHeritageClause(node.parent) && node.parent.token === 117 /* ImplementsKeyword */ ? Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : node.parent.parent.name ? Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1 : Diagnostics.extends_clause_of_exported_class_has_or_is_using_private_name_0;
|
|
} else {
|
|
diagnosticMessage = Diagnostics.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1;
|
|
}
|
|
return {
|
|
diagnosticMessage,
|
|
errorNode: node,
|
|
typeName: getNameOfDeclaration(node.parent.parent)
|
|
};
|
|
}
|
|
function getImportEntityNameVisibilityError() {
|
|
return {
|
|
diagnosticMessage: Diagnostics.Import_declaration_0_is_using_private_name_1,
|
|
errorNode: node,
|
|
typeName: node.name
|
|
};
|
|
}
|
|
function getTypeAliasDeclarationVisibilityError(symbolAccessibilityResult) {
|
|
return {
|
|
diagnosticMessage: symbolAccessibilityResult.errorModuleName ? Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2 : Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
|
|
errorNode: isJSDocTypeAlias(node) ? Debug.checkDefined(node.typeExpression) : node.type,
|
|
typeName: isJSDocTypeAlias(node) ? getNameOfDeclaration(node) : node.name
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/compiler/transformers/declarations.ts
|
|
function getDeclarationDiagnostics(host, resolver, file) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const result = transformNodes(resolver, host, factory, compilerOptions, file ? [file] : filter(host.getSourceFiles(), isSourceFileNotJson), [transformDeclarations], false);
|
|
return result.diagnostics;
|
|
}
|
|
function hasInternalAnnotation(range, currentSourceFile) {
|
|
const comment = currentSourceFile.text.substring(range.pos, range.end);
|
|
return stringContains(comment, "@internal");
|
|
}
|
|
function isInternalDeclaration(node, currentSourceFile) {
|
|
const parseTreeNode = getParseTreeNode(node);
|
|
if (parseTreeNode && parseTreeNode.kind === 166 /* Parameter */) {
|
|
const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
|
|
const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
|
|
const text = currentSourceFile.text;
|
|
const commentRanges = previousSibling ? concatenate(
|
|
getTrailingCommentRanges(text, skipTrivia(text, previousSibling.end + 1, false, true)),
|
|
getLeadingCommentRanges(text, node.pos)
|
|
) : getTrailingCommentRanges(text, skipTrivia(text, node.pos, false, true));
|
|
return commentRanges && commentRanges.length && hasInternalAnnotation(last(commentRanges), currentSourceFile);
|
|
}
|
|
const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile);
|
|
return !!forEach(leadingCommentRanges, (range) => {
|
|
return hasInternalAnnotation(range, currentSourceFile);
|
|
});
|
|
}
|
|
var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
|
|
function transformDeclarations(context) {
|
|
const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
|
|
let getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
let needsDeclare = true;
|
|
let isBundledEmit = false;
|
|
let resultHasExternalModuleIndicator = false;
|
|
let needsScopeFixMarker = false;
|
|
let resultHasScopeMarker = false;
|
|
let enclosingDeclaration;
|
|
let necessaryTypeReferences;
|
|
let lateMarkedStatements;
|
|
let lateStatementReplacementMap;
|
|
let suppressNewDiagnosticContexts;
|
|
let exportedModulesFromDeclarationEmit;
|
|
const { factory: factory2 } = context;
|
|
const host = context.getEmitHost();
|
|
const symbolTracker = {
|
|
trackSymbol,
|
|
reportInaccessibleThisError,
|
|
reportInaccessibleUniqueSymbolError,
|
|
reportCyclicStructureError,
|
|
reportPrivateInBaseOfClassExpression,
|
|
reportLikelyUnsafeImportRequiredError,
|
|
reportTruncationError,
|
|
moduleResolverHost: host,
|
|
trackReferencedAmbientModule,
|
|
trackExternalModuleSymbolOfImportTypeNode,
|
|
reportNonlocalAugmentation,
|
|
reportNonSerializableProperty,
|
|
reportImportTypeNodeResolutionModeOverride
|
|
};
|
|
let errorNameNode;
|
|
let errorFallbackNode;
|
|
let currentSourceFile;
|
|
let refs;
|
|
let libs2;
|
|
let emittedImports;
|
|
const resolver = context.getEmitResolver();
|
|
const options = context.getCompilerOptions();
|
|
const { noResolve, stripInternal } = options;
|
|
return transformRoot;
|
|
function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) {
|
|
if (!typeReferenceDirectives) {
|
|
return;
|
|
}
|
|
necessaryTypeReferences = necessaryTypeReferences || /* @__PURE__ */ new Set();
|
|
for (const ref of typeReferenceDirectives) {
|
|
necessaryTypeReferences.add(ref);
|
|
}
|
|
}
|
|
function trackReferencedAmbientModule(node, symbol) {
|
|
const directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, 67108863 /* All */);
|
|
if (length(directives)) {
|
|
return recordTypeReferenceDirectivesIfNecessary(directives);
|
|
}
|
|
const container = getSourceFileOfNode(node);
|
|
refs.set(getOriginalNodeId(container), container);
|
|
}
|
|
function handleSymbolAccessibilityError(symbolAccessibilityResult) {
|
|
if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
|
|
if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
|
|
if (!lateMarkedStatements) {
|
|
lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
|
|
} else {
|
|
for (const ref of symbolAccessibilityResult.aliasesToMakeVisible) {
|
|
pushIfUnique(lateMarkedStatements, ref);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
|
|
if (errorInfo) {
|
|
if (errorInfo.typeName) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
symbolAccessibilityResult.errorNode || errorInfo.errorNode,
|
|
errorInfo.diagnosticMessage,
|
|
getTextOfNode(errorInfo.typeName),
|
|
symbolAccessibilityResult.errorSymbolName,
|
|
symbolAccessibilityResult.errorModuleName
|
|
));
|
|
} else {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
symbolAccessibilityResult.errorNode || errorInfo.errorNode,
|
|
errorInfo.diagnosticMessage,
|
|
symbolAccessibilityResult.errorSymbolName,
|
|
symbolAccessibilityResult.errorModuleName
|
|
));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function trackExternalModuleSymbolOfImportTypeNode(symbol) {
|
|
if (!isBundledEmit) {
|
|
(exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);
|
|
}
|
|
}
|
|
function trackSymbol(symbol, enclosingDeclaration2, meaning) {
|
|
if (symbol.flags & 262144 /* TypeParameter */)
|
|
return false;
|
|
const issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration2, meaning, true));
|
|
recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning));
|
|
return issuedDiagnostic;
|
|
}
|
|
function reportPrivateInBaseOfClassExpression(propertyName) {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(
|
|
createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)
|
|
);
|
|
}
|
|
}
|
|
function errorDeclarationNameWithFallback() {
|
|
return errorNameNode ? declarationNameToString(errorNameNode) : errorFallbackNode && getNameOfDeclaration(errorFallbackNode) ? declarationNameToString(getNameOfDeclaration(errorFallbackNode)) : errorFallbackNode && isExportAssignment(errorFallbackNode) ? errorFallbackNode.isExportEquals ? "export=" : "default" : "(Missing)";
|
|
}
|
|
function reportInaccessibleUniqueSymbolError() {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary,
|
|
errorDeclarationNameWithFallback(),
|
|
"unique symbol"
|
|
));
|
|
}
|
|
}
|
|
function reportCyclicStructureError() {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
Diagnostics.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary,
|
|
errorDeclarationNameWithFallback()
|
|
));
|
|
}
|
|
}
|
|
function reportInaccessibleThisError() {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary,
|
|
errorDeclarationNameWithFallback(),
|
|
"this"
|
|
));
|
|
}
|
|
}
|
|
function reportLikelyUnsafeImportRequiredError(specifier) {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(
|
|
errorNameNode || errorFallbackNode,
|
|
Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary,
|
|
errorDeclarationNameWithFallback(),
|
|
specifier
|
|
));
|
|
}
|
|
}
|
|
function reportTruncationError() {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, 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) {
|
|
var _a2;
|
|
const primaryDeclaration = (_a2 = parentSymbol.declarations) == null ? void 0 : _a2.find((d) => getSourceFileOfNode(d) === containingFile);
|
|
const augmentingDeclarations = filter(symbol.declarations, (d) => getSourceFileOfNode(d) !== containingFile);
|
|
if (primaryDeclaration && augmentingDeclarations) {
|
|
for (const augmentations of augmentingDeclarations) {
|
|
context.addDiagnostic(addRelatedInfo(
|
|
createDiagnosticForNode(augmentations, Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized),
|
|
createDiagnosticForNode(primaryDeclaration, Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file)
|
|
));
|
|
}
|
|
}
|
|
}
|
|
function reportNonSerializableProperty(propertyName) {
|
|
if (errorNameNode || errorFallbackNode) {
|
|
context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));
|
|
}
|
|
}
|
|
function reportImportTypeNodeResolutionModeOverride() {
|
|
if (!isNightly() && (errorNameNode || errorFallbackNode)) {
|
|
context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
|
|
}
|
|
}
|
|
function transformDeclarationsForJS(sourceFile, bundled) {
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = (s) => s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : {
|
|
diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
|
|
errorNode: s.errorNode || sourceFile
|
|
};
|
|
const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
return result;
|
|
}
|
|
function transformRoot(node) {
|
|
if (node.kind === 308 /* SourceFile */ && node.isDeclarationFile) {
|
|
return node;
|
|
}
|
|
if (node.kind === 309 /* Bundle */) {
|
|
isBundledEmit = true;
|
|
refs = /* @__PURE__ */ new Map();
|
|
libs2 = /* @__PURE__ */ new Map();
|
|
let hasNoDefaultLib = false;
|
|
const bundle = factory2.createBundle(map(
|
|
node.sourceFiles,
|
|
(sourceFile) => {
|
|
if (sourceFile.isDeclarationFile)
|
|
return void 0;
|
|
hasNoDefaultLib = hasNoDefaultLib || sourceFile.hasNoDefaultLib;
|
|
currentSourceFile = sourceFile;
|
|
enclosingDeclaration = sourceFile;
|
|
lateMarkedStatements = void 0;
|
|
suppressNewDiagnosticContexts = false;
|
|
lateStatementReplacementMap = /* @__PURE__ */ new Map();
|
|
getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
needsScopeFixMarker = false;
|
|
resultHasScopeMarker = false;
|
|
collectReferences(sourceFile, refs);
|
|
collectLibs(sourceFile, libs2);
|
|
if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
|
|
resultHasExternalModuleIndicator = false;
|
|
needsDeclare = false;
|
|
const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile, true)) : visitNodes2(sourceFile.statements, visitDeclarationStatements);
|
|
const newFile = factory2.updateSourceFile(sourceFile, [factory2.createModuleDeclaration(
|
|
[factory2.createModifier(136 /* DeclareKeyword */)],
|
|
factory2.createStringLiteral(getResolvedExternalModuleName(context.getEmitHost(), sourceFile)),
|
|
factory2.createModuleBlock(setTextRange(factory2.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements))
|
|
)], true, [], [], false, []);
|
|
return newFile;
|
|
}
|
|
needsDeclare = true;
|
|
const updated2 = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements);
|
|
return factory2.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated2), true, [], [], false, []);
|
|
}
|
|
), mapDefined(node.prepends, (prepend) => {
|
|
if (prepend.kind === 311 /* InputFiles */) {
|
|
const sourceFile = createUnparsedSourceFile(prepend, "dts", stripInternal);
|
|
hasNoDefaultLib = hasNoDefaultLib || !!sourceFile.hasNoDefaultLib;
|
|
collectReferences(sourceFile, refs);
|
|
recordTypeReferenceDirectivesIfNecessary(map(sourceFile.typeReferenceDirectives, (ref) => [ref.fileName, ref.resolutionMode]));
|
|
collectLibs(sourceFile, libs2);
|
|
return sourceFile;
|
|
}
|
|
return prepend;
|
|
}));
|
|
bundle.syntheticFileReferences = [];
|
|
bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences();
|
|
bundle.syntheticLibReferences = getLibReferences();
|
|
bundle.hasNoDefaultLib = hasNoDefaultLib;
|
|
const outputFilePath2 = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, true).declarationFilePath));
|
|
const referenceVisitor2 = mapReferencesIntoArray(bundle.syntheticFileReferences, outputFilePath2);
|
|
refs.forEach(referenceVisitor2);
|
|
return bundle;
|
|
}
|
|
needsDeclare = true;
|
|
needsScopeFixMarker = false;
|
|
resultHasScopeMarker = false;
|
|
enclosingDeclaration = node;
|
|
currentSourceFile = node;
|
|
getSymbolAccessibilityDiagnostic = throwDiagnostic;
|
|
isBundledEmit = false;
|
|
resultHasExternalModuleIndicator = false;
|
|
suppressNewDiagnosticContexts = false;
|
|
lateMarkedStatements = void 0;
|
|
lateStatementReplacementMap = /* @__PURE__ */ new Map();
|
|
necessaryTypeReferences = void 0;
|
|
refs = collectReferences(currentSourceFile, /* @__PURE__ */ new Map());
|
|
libs2 = collectLibs(currentSourceFile, /* @__PURE__ */ new Map());
|
|
const references = [];
|
|
const outputFilePath = getDirectoryPath(normalizeSlashes(getOutputPathsFor(node, host, true).declarationFilePath));
|
|
const referenceVisitor = mapReferencesIntoArray(references, outputFilePath);
|
|
let combinedStatements;
|
|
if (isSourceFileJS(currentSourceFile)) {
|
|
combinedStatements = factory2.createNodeArray(transformDeclarationsForJS(node));
|
|
refs.forEach(referenceVisitor);
|
|
emittedImports = filter(combinedStatements, isAnyImportSyntax);
|
|
} else {
|
|
const statements = visitNodes2(node.statements, visitDeclarationStatements);
|
|
combinedStatements = setTextRange(factory2.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements);
|
|
refs.forEach(referenceVisitor);
|
|
emittedImports = filter(combinedStatements, isAnyImportSyntax);
|
|
if (isExternalModule(node) && (!resultHasExternalModuleIndicator || needsScopeFixMarker && !resultHasScopeMarker)) {
|
|
combinedStatements = setTextRange(factory2.createNodeArray([...combinedStatements, createEmptyExports(factory2)]), combinedStatements);
|
|
}
|
|
}
|
|
const updated = factory2.updateSourceFile(node, combinedStatements, true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences());
|
|
updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;
|
|
return updated;
|
|
function getLibReferences() {
|
|
return map(arrayFrom(libs2.keys()), (lib) => ({ fileName: lib, pos: -1, end: -1 }));
|
|
}
|
|
function getFileReferencesForUsedTypeReferences() {
|
|
return necessaryTypeReferences ? mapDefined(arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForSpecifierModeTuple) : [];
|
|
}
|
|
function getFileReferenceForSpecifierModeTuple([typeName, mode]) {
|
|
if (emittedImports) {
|
|
for (const importStatement of emittedImports) {
|
|
if (isImportEqualsDeclaration(importStatement) && isExternalModuleReference(importStatement.moduleReference)) {
|
|
const expr = importStatement.moduleReference.expression;
|
|
if (isStringLiteralLike(expr) && expr.text === typeName) {
|
|
return void 0;
|
|
}
|
|
} else if (isImportDeclaration(importStatement) && isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) {
|
|
return void 0;
|
|
}
|
|
}
|
|
}
|
|
return { fileName: typeName, pos: -1, end: -1, ...mode ? { resolutionMode: mode } : void 0 };
|
|
}
|
|
function mapReferencesIntoArray(references2, outputFilePath2) {
|
|
return (file) => {
|
|
let declFileName;
|
|
if (file.isDeclarationFile) {
|
|
declFileName = file.fileName;
|
|
} else {
|
|
if (isBundledEmit && contains(node.sourceFiles, file))
|
|
return;
|
|
const paths = getOutputPathsFor(file, host, true);
|
|
declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName;
|
|
}
|
|
if (declFileName) {
|
|
const specifier = getModuleSpecifier(
|
|
options,
|
|
currentSourceFile,
|
|
toPath(outputFilePath2, host.getCurrentDirectory(), host.getCanonicalFileName),
|
|
toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName),
|
|
host
|
|
);
|
|
if (!pathIsRelative(specifier)) {
|
|
recordTypeReferenceDirectivesIfNecessary([[specifier, void 0]]);
|
|
return;
|
|
}
|
|
let fileName = getRelativePathToDirectoryOrUrl(
|
|
outputFilePath2,
|
|
declFileName,
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
false
|
|
);
|
|
if (startsWith(fileName, "./") && hasExtension(fileName)) {
|
|
fileName = fileName.substring(2);
|
|
}
|
|
if (startsWith(fileName, "node_modules/") || pathContainsNodeModules(fileName)) {
|
|
return;
|
|
}
|
|
references2.push({ pos: -1, end: -1, fileName });
|
|
}
|
|
};
|
|
}
|
|
}
|
|
function collectReferences(sourceFile, ret) {
|
|
if (noResolve || !isUnparsedSource(sourceFile) && isSourceFileJS(sourceFile))
|
|
return ret;
|
|
forEach(sourceFile.referencedFiles, (f) => {
|
|
const elem = host.getSourceFileFromReference(sourceFile, f);
|
|
if (elem) {
|
|
ret.set(getOriginalNodeId(elem), elem);
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function collectLibs(sourceFile, ret) {
|
|
forEach(sourceFile.libReferenceDirectives, (ref) => {
|
|
const lib = host.getLibFileFromReference(ref);
|
|
if (lib) {
|
|
ret.set(toFileNameLowerCase(ref.fileName), true);
|
|
}
|
|
});
|
|
return ret;
|
|
}
|
|
function filterBindingPatternInitializersAndRenamings(name) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
return name;
|
|
} else {
|
|
if (name.kind === 204 /* ArrayBindingPattern */) {
|
|
return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement));
|
|
} else {
|
|
return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement));
|
|
}
|
|
}
|
|
function visitBindingElement(elem) {
|
|
if (elem.kind === 229 /* OmittedExpression */) {
|
|
return elem;
|
|
}
|
|
if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced) {
|
|
return factory2.updateBindingElement(
|
|
elem,
|
|
elem.dotDotDotToken,
|
|
void 0,
|
|
elem.propertyName,
|
|
shouldPrintWithInitializer(elem) ? elem.initializer : void 0
|
|
);
|
|
}
|
|
return factory2.updateBindingElement(
|
|
elem,
|
|
elem.dotDotDotToken,
|
|
elem.propertyName,
|
|
filterBindingPatternInitializersAndRenamings(elem.name),
|
|
shouldPrintWithInitializer(elem) ? elem.initializer : void 0
|
|
);
|
|
}
|
|
}
|
|
function ensureParameter(p, modifierMask, type) {
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p);
|
|
}
|
|
const newParam = factory2.updateParameterDeclaration(
|
|
p,
|
|
maskModifiers(p, modifierMask),
|
|
p.dotDotDotToken,
|
|
filterBindingPatternInitializersAndRenamings(p.name),
|
|
resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(57 /* QuestionToken */) : void 0,
|
|
ensureType(p, type || p.type, true),
|
|
ensureNoInitializer(p)
|
|
);
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
return newParam;
|
|
}
|
|
function shouldPrintWithInitializer(node) {
|
|
return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(getParseTreeNode(node));
|
|
}
|
|
function ensureNoInitializer(node) {
|
|
if (shouldPrintWithInitializer(node)) {
|
|
return resolver.createLiteralConstValue(getParseTreeNode(node), symbolTracker);
|
|
}
|
|
return void 0;
|
|
}
|
|
function ensureType(node, type, ignorePrivate) {
|
|
if (!ignorePrivate && hasEffectiveModifier(node, 8 /* Private */)) {
|
|
return;
|
|
}
|
|
if (shouldPrintWithInitializer(node)) {
|
|
return;
|
|
}
|
|
const shouldUseResolverType = node.kind === 166 /* Parameter */ && (resolver.isRequiredInitializedParameter(node) || resolver.isOptionalUninitializedParameterProperty(node));
|
|
if (type && !shouldUseResolverType) {
|
|
return visitNode(type, visitDeclarationSubtree);
|
|
}
|
|
if (!getParseTreeNode(node)) {
|
|
return type ? visitNode(type, visitDeclarationSubtree) : factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
if (node.kind === 175 /* SetAccessor */) {
|
|
return factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
errorNameNode = node.name;
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(node);
|
|
}
|
|
if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
|
|
return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
|
|
}
|
|
if (node.kind === 166 /* Parameter */ || node.kind === 169 /* PropertyDeclaration */ || node.kind === 168 /* PropertySignature */) {
|
|
if (isPropertySignature(node) || !node.initializer)
|
|
return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType));
|
|
return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
|
|
}
|
|
return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker));
|
|
function cleanup(returnValue) {
|
|
errorNameNode = void 0;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
return returnValue || factory2.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
}
|
|
function isDeclarationAndNotVisible(node) {
|
|
node = getParseTreeNode(node);
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
return !resolver.isDeclarationVisible(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return !getBindingNameVisible(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
return false;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function shouldEmitFunctionProperties(input) {
|
|
var _a2;
|
|
if (input.body) {
|
|
return true;
|
|
}
|
|
const overloadSignatures = (_a2 = input.symbol.declarations) == null ? void 0 : _a2.filter((decl) => isFunctionDeclaration(decl) && !decl.body);
|
|
return !overloadSignatures || overloadSignatures.indexOf(input) === overloadSignatures.length - 1;
|
|
}
|
|
function getBindingNameVisible(elem) {
|
|
if (isOmittedExpression(elem)) {
|
|
return false;
|
|
}
|
|
if (isBindingPattern(elem.name)) {
|
|
return some(elem.name.elements, getBindingNameVisible);
|
|
} else {
|
|
return resolver.isDeclarationVisible(elem);
|
|
}
|
|
}
|
|
function updateParamsList(node, params, modifierMask) {
|
|
if (hasEffectiveModifier(node, 8 /* Private */)) {
|
|
return void 0;
|
|
}
|
|
const newParams = map(params, (p) => ensureParameter(p, modifierMask));
|
|
if (!newParams) {
|
|
return void 0;
|
|
}
|
|
return factory2.createNodeArray(newParams, params.hasTrailingComma);
|
|
}
|
|
function updateAccessorParamsList(input, isPrivate) {
|
|
let newParams;
|
|
if (!isPrivate) {
|
|
const thisParameter = getThisParameter(input);
|
|
if (thisParameter) {
|
|
newParams = [ensureParameter(thisParameter)];
|
|
}
|
|
}
|
|
if (isSetAccessorDeclaration(input)) {
|
|
let newValueParameter;
|
|
if (!isPrivate) {
|
|
const valueParameter = getSetAccessorValueParameter(input);
|
|
if (valueParameter) {
|
|
const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
|
|
newValueParameter = ensureParameter(valueParameter, void 0, accessorType);
|
|
}
|
|
}
|
|
if (!newValueParameter) {
|
|
newValueParameter = factory2.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"value"
|
|
);
|
|
}
|
|
newParams = append(newParams, newValueParameter);
|
|
}
|
|
return factory2.createNodeArray(newParams || emptyArray);
|
|
}
|
|
function ensureTypeParams(node, params) {
|
|
return hasEffectiveModifier(node, 8 /* Private */) ? void 0 : visitNodes2(params, visitDeclarationSubtree);
|
|
}
|
|
function isEnclosingDeclaration(node) {
|
|
return isSourceFile(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node) || isClassDeclaration(node) || isInterfaceDeclaration(node) || isFunctionLike(node) || isIndexSignatureDeclaration(node) || isMappedTypeNode(node);
|
|
}
|
|
function checkEntityNameVisibility(entityName, enclosingDeclaration2) {
|
|
const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration2);
|
|
handleSymbolAccessibilityError(visibilityResult);
|
|
recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));
|
|
}
|
|
function preserveJsDoc(updated, original) {
|
|
if (hasJSDocNodes(updated) && hasJSDocNodes(original)) {
|
|
updated.jsDoc = original.jsDoc;
|
|
}
|
|
return setCommentRange(updated, getCommentRange(original));
|
|
}
|
|
function rewriteModuleSpecifier(parent2, input) {
|
|
if (!input)
|
|
return void 0;
|
|
resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || parent2.kind !== 264 /* ModuleDeclaration */ && parent2.kind !== 202 /* ImportType */;
|
|
if (isStringLiteralLike(input)) {
|
|
if (isBundledEmit) {
|
|
const newName = getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent2);
|
|
if (newName) {
|
|
return factory2.createStringLiteral(newName);
|
|
}
|
|
} else {
|
|
const symbol = resolver.getSymbolOfExternalModuleSpecifier(input);
|
|
if (symbol) {
|
|
(exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol);
|
|
}
|
|
}
|
|
}
|
|
return input;
|
|
}
|
|
function transformImportEqualsDeclaration(decl) {
|
|
if (!resolver.isDeclarationVisible(decl))
|
|
return;
|
|
if (decl.moduleReference.kind === 280 /* ExternalModuleReference */) {
|
|
const specifier = getExternalModuleImportEqualsDeclarationExpression(decl);
|
|
return factory2.updateImportEqualsDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
decl.isTypeOnly,
|
|
decl.name,
|
|
factory2.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))
|
|
);
|
|
} else {
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(decl);
|
|
checkEntityNameVisibility(decl.moduleReference, enclosingDeclaration);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
return decl;
|
|
}
|
|
}
|
|
function transformImportDeclaration(decl) {
|
|
if (!decl.importClause) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
decl.importClause,
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
const visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : void 0;
|
|
if (!decl.importClause.namedBindings) {
|
|
return visibleDefaultBinding && factory2.updateImportDeclaration(decl, decl.modifiers, factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
void 0
|
|
), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause));
|
|
}
|
|
if (decl.importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
const namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : void 0;
|
|
return visibleDefaultBinding || namedBindings ? factory2.updateImportDeclaration(decl, decl.modifiers, factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
namedBindings
|
|
), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)) : void 0;
|
|
}
|
|
const bindingList = mapDefined(decl.importClause.namedBindings.elements, (b) => resolver.isDeclarationVisible(b) ? b : void 0);
|
|
if (bindingList && bindingList.length || visibleDefaultBinding) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
factory2.updateImportClause(
|
|
decl.importClause,
|
|
decl.importClause.isTypeOnly,
|
|
visibleDefaultBinding,
|
|
bindingList && bindingList.length ? factory2.updateNamedImports(decl.importClause.namedBindings, bindingList) : void 0
|
|
),
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
if (resolver.isImportRequiredByAugmentation(decl)) {
|
|
return factory2.updateImportDeclaration(
|
|
decl,
|
|
decl.modifiers,
|
|
void 0,
|
|
rewriteModuleSpecifier(decl, decl.moduleSpecifier),
|
|
getResolutionModeOverrideForClauseInNightly(decl.assertClause)
|
|
);
|
|
}
|
|
}
|
|
function getResolutionModeOverrideForClauseInNightly(assertClause) {
|
|
const mode = getResolutionModeOverrideForClause(assertClause);
|
|
if (mode !== void 0) {
|
|
if (!isNightly()) {
|
|
context.addDiagnostic(createDiagnosticForNode(assertClause, Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next));
|
|
}
|
|
return assertClause;
|
|
}
|
|
return void 0;
|
|
}
|
|
function transformAndReplaceLatePaintedStatements(statements) {
|
|
while (length(lateMarkedStatements)) {
|
|
const i = lateMarkedStatements.shift();
|
|
if (!isLateVisibilityPaintedStatement(i)) {
|
|
return Debug.fail(`Late replaced statement was found which is not handled by the declaration transformer!: ${Debug.formatSyntaxKind(i.kind)}`);
|
|
}
|
|
const priorNeedsDeclare = needsDeclare;
|
|
needsDeclare = i.parent && isSourceFile(i.parent) && !(isExternalModule(i.parent) && isBundledEmit);
|
|
const result = transformTopLevelDeclaration(i);
|
|
needsDeclare = priorNeedsDeclare;
|
|
lateStatementReplacementMap.set(getOriginalNodeId(i), result);
|
|
}
|
|
return visitNodes2(statements, visitLateVisibilityMarkedStatements);
|
|
function visitLateVisibilityMarkedStatements(statement) {
|
|
if (isLateVisibilityPaintedStatement(statement)) {
|
|
const key = getOriginalNodeId(statement);
|
|
if (lateStatementReplacementMap.has(key)) {
|
|
const result = lateStatementReplacementMap.get(key);
|
|
lateStatementReplacementMap.delete(key);
|
|
if (result) {
|
|
if (isArray(result) ? some(result, needsScopeMarker) : needsScopeMarker(result)) {
|
|
needsScopeFixMarker = true;
|
|
}
|
|
if (isSourceFile(statement.parent) && (isArray(result) ? some(result, isExternalModuleIndicator) : isExternalModuleIndicator(result))) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
return statement;
|
|
}
|
|
}
|
|
function visitDeclarationSubtree(input) {
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
if (isDeclaration(input)) {
|
|
if (isDeclarationAndNotVisible(input))
|
|
return;
|
|
if (hasDynamicName(input) && !resolver.isLateBound(getParseTreeNode(input))) {
|
|
return;
|
|
}
|
|
}
|
|
if (isFunctionLike(input) && resolver.isImplementationOfOverload(input))
|
|
return;
|
|
if (isSemicolonClassElement(input))
|
|
return;
|
|
let previousEnclosingDeclaration;
|
|
if (isEnclosingDeclaration(input)) {
|
|
previousEnclosingDeclaration = enclosingDeclaration;
|
|
enclosingDeclaration = input;
|
|
}
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
const canProduceDiagnostic = canProduceDiagnostics(input);
|
|
const oldWithinObjectLiteralType = suppressNewDiagnosticContexts;
|
|
let shouldEnterSuppressNewDiagnosticsContextContext = (input.kind === 184 /* TypeLiteral */ || input.kind === 197 /* MappedType */) && input.parent.kind !== 262 /* TypeAliasDeclaration */;
|
|
if (isMethodDeclaration(input) || isMethodSignature(input)) {
|
|
if (hasEffectiveModifier(input, 8 /* Private */)) {
|
|
if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input)
|
|
return;
|
|
return cleanup(factory2.createPropertyDeclaration(ensureModifiers(input), input.name, void 0, void 0, void 0));
|
|
}
|
|
}
|
|
if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(input);
|
|
}
|
|
if (isTypeQueryNode(input)) {
|
|
checkEntityNameVisibility(input.exprName, enclosingDeclaration);
|
|
}
|
|
if (shouldEnterSuppressNewDiagnosticsContextContext) {
|
|
suppressNewDiagnosticContexts = true;
|
|
}
|
|
if (isProcessedComponent(input)) {
|
|
switch (input.kind) {
|
|
case 230 /* ExpressionWithTypeArguments */: {
|
|
if (isEntityName(input.expression) || isEntityNameExpression(input.expression)) {
|
|
checkEntityNameVisibility(input.expression, enclosingDeclaration);
|
|
}
|
|
const node = visitEachChild(input, visitDeclarationSubtree, context);
|
|
return cleanup(factory2.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments));
|
|
}
|
|
case 180 /* TypeReference */: {
|
|
checkEntityNameVisibility(input.typeName, enclosingDeclaration);
|
|
const node = visitEachChild(input, visitDeclarationSubtree, context);
|
|
return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
|
|
}
|
|
case 177 /* ConstructSignature */:
|
|
return cleanup(factory2.updateConstructSignature(
|
|
input,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
case 173 /* Constructor */: {
|
|
const ctor = factory2.createConstructorDeclaration(
|
|
ensureModifiers(input),
|
|
updateParamsList(input, input.parameters, 0 /* None */),
|
|
void 0
|
|
);
|
|
return cleanup(ctor);
|
|
}
|
|
case 171 /* MethodDeclaration */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
const sig = factory2.createMethodDeclaration(
|
|
ensureModifiers(input),
|
|
void 0,
|
|
input.name,
|
|
input.questionToken,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type),
|
|
void 0
|
|
);
|
|
return cleanup(sig);
|
|
}
|
|
case 174 /* GetAccessor */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
|
|
return cleanup(factory2.updateGetAccessorDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
|
|
ensureType(input, accessorType),
|
|
void 0
|
|
));
|
|
}
|
|
case 175 /* SetAccessor */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updateSetAccessorDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
updateAccessorParamsList(input, hasEffectiveModifier(input, 8 /* Private */)),
|
|
void 0
|
|
));
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updatePropertyDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureType(input, input.type),
|
|
ensureNoInitializer(input)
|
|
));
|
|
case 168 /* PropertySignature */:
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updatePropertySignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureType(input, input.type)
|
|
));
|
|
case 170 /* MethodSignature */: {
|
|
if (isPrivateIdentifier(input.name)) {
|
|
return cleanup(void 0);
|
|
}
|
|
return cleanup(factory2.updateMethodSignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
input.questionToken,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
}
|
|
case 176 /* CallSignature */: {
|
|
return cleanup(factory2.updateCallSignature(
|
|
input,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type)
|
|
));
|
|
}
|
|
case 178 /* IndexSignature */: {
|
|
return cleanup(factory2.updateIndexSignature(
|
|
input,
|
|
ensureModifiers(input),
|
|
updateParamsList(input, input.parameters),
|
|
visitNode(input.type, visitDeclarationSubtree) || factory2.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
));
|
|
}
|
|
case 257 /* VariableDeclaration */: {
|
|
if (isBindingPattern(input.name)) {
|
|
return recreateBindingPattern(input.name);
|
|
}
|
|
shouldEnterSuppressNewDiagnosticsContextContext = true;
|
|
suppressNewDiagnosticContexts = true;
|
|
return cleanup(factory2.updateVariableDeclaration(input, input.name, void 0, ensureType(input, input.type), ensureNoInitializer(input)));
|
|
}
|
|
case 165 /* TypeParameter */: {
|
|
if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) {
|
|
return cleanup(factory2.updateTypeParameterDeclaration(input, input.modifiers, input.name, void 0, void 0));
|
|
}
|
|
return cleanup(visitEachChild(input, visitDeclarationSubtree, context));
|
|
}
|
|
case 191 /* ConditionalType */: {
|
|
const checkType = visitNode(input.checkType, visitDeclarationSubtree);
|
|
const extendsType = visitNode(input.extendsType, visitDeclarationSubtree);
|
|
const oldEnclosingDecl = enclosingDeclaration;
|
|
enclosingDeclaration = input.trueType;
|
|
const trueType = visitNode(input.trueType, visitDeclarationSubtree);
|
|
enclosingDeclaration = oldEnclosingDecl;
|
|
const falseType = visitNode(input.falseType, visitDeclarationSubtree);
|
|
return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
|
|
}
|
|
case 181 /* FunctionType */: {
|
|
return cleanup(factory2.updateFunctionTypeNode(input, visitNodes2(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), visitNode(input.type, visitDeclarationSubtree)));
|
|
}
|
|
case 182 /* ConstructorType */: {
|
|
return cleanup(factory2.updateConstructorTypeNode(input, ensureModifiers(input), visitNodes2(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), visitNode(input.type, visitDeclarationSubtree)));
|
|
}
|
|
case 202 /* ImportType */: {
|
|
if (!isLiteralImportTypeNode(input))
|
|
return cleanup(input);
|
|
return cleanup(factory2.updateImportTypeNode(
|
|
input,
|
|
factory2.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)),
|
|
input.assertions,
|
|
input.qualifier,
|
|
visitNodes2(input.typeArguments, visitDeclarationSubtree, isTypeNode),
|
|
input.isTypeOf
|
|
));
|
|
}
|
|
default:
|
|
Debug.assertNever(input, `Attempted to process unhandled node kind: ${Debug.formatSyntaxKind(input.kind)}`);
|
|
}
|
|
}
|
|
if (isTupleTypeNode(input) && getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === getLineAndCharacterOfPosition(currentSourceFile, input.end).line) {
|
|
setEmitFlags(input, 1 /* SingleLine */);
|
|
}
|
|
return cleanup(visitEachChild(input, visitDeclarationSubtree, context));
|
|
function cleanup(returnValue) {
|
|
if (returnValue && canProduceDiagnostic && hasDynamicName(input)) {
|
|
checkName(input);
|
|
}
|
|
if (isEnclosingDeclaration(input)) {
|
|
enclosingDeclaration = previousEnclosingDeclaration;
|
|
}
|
|
if (canProduceDiagnostic && !suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
if (shouldEnterSuppressNewDiagnosticsContextContext) {
|
|
suppressNewDiagnosticContexts = oldWithinObjectLiteralType;
|
|
}
|
|
if (returnValue === input) {
|
|
return returnValue;
|
|
}
|
|
return returnValue && setOriginalNode(preserveJsDoc(returnValue, input), input);
|
|
}
|
|
}
|
|
function isPrivateMethodTypeParameter(node) {
|
|
return node.parent.kind === 171 /* MethodDeclaration */ && hasEffectiveModifier(node.parent, 8 /* Private */);
|
|
}
|
|
function visitDeclarationStatements(input) {
|
|
if (!isPreservedDeclarationStatement(input)) {
|
|
return;
|
|
}
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
switch (input.kind) {
|
|
case 275 /* ExportDeclaration */: {
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
return factory2.updateExportDeclaration(
|
|
input,
|
|
input.modifiers,
|
|
input.isTypeOnly,
|
|
input.exportClause,
|
|
rewriteModuleSpecifier(input, input.moduleSpecifier),
|
|
getResolutionModeOverrideForClause(input.assertClause) ? input.assertClause : void 0
|
|
);
|
|
}
|
|
case 274 /* ExportAssignment */: {
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
if (input.expression.kind === 79 /* Identifier */) {
|
|
return input;
|
|
} else {
|
|
const newId = factory2.createUniqueName("_default", 16 /* Optimistic */);
|
|
getSymbolAccessibilityDiagnostic = () => ({
|
|
diagnosticMessage: Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0,
|
|
errorNode: input
|
|
});
|
|
errorFallbackNode = input;
|
|
const varDecl = factory2.createVariableDeclaration(newId, void 0, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), void 0);
|
|
errorFallbackNode = void 0;
|
|
const statement = factory2.createVariableStatement(needsDeclare ? [factory2.createModifier(136 /* DeclareKeyword */)] : [], factory2.createVariableDeclarationList([varDecl], 2 /* Const */));
|
|
preserveJsDoc(statement, input);
|
|
removeAllComments(input);
|
|
return [statement, factory2.updateExportAssignment(input, input.modifiers, newId)];
|
|
}
|
|
}
|
|
}
|
|
const result = transformTopLevelDeclaration(input);
|
|
lateStatementReplacementMap.set(getOriginalNodeId(input), result);
|
|
return input;
|
|
}
|
|
function stripExportModifiers(statement) {
|
|
if (isImportEqualsDeclaration(statement) || hasEffectiveModifier(statement, 1024 /* Default */) || !canHaveModifiers(statement)) {
|
|
return statement;
|
|
}
|
|
const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(statement) & (258047 /* All */ ^ 1 /* Export */));
|
|
return factory2.updateModifiers(statement, modifiers);
|
|
}
|
|
function transformTopLevelDeclaration(input) {
|
|
if (lateMarkedStatements) {
|
|
while (orderedRemoveItem(lateMarkedStatements, input))
|
|
;
|
|
}
|
|
if (shouldStripInternal(input))
|
|
return;
|
|
switch (input.kind) {
|
|
case 268 /* ImportEqualsDeclaration */: {
|
|
return transformImportEqualsDeclaration(input);
|
|
}
|
|
case 269 /* ImportDeclaration */: {
|
|
return transformImportDeclaration(input);
|
|
}
|
|
}
|
|
if (isDeclaration(input) && isDeclarationAndNotVisible(input))
|
|
return;
|
|
if (isFunctionLike(input) && resolver.isImplementationOfOverload(input))
|
|
return;
|
|
let previousEnclosingDeclaration;
|
|
if (isEnclosingDeclaration(input)) {
|
|
previousEnclosingDeclaration = enclosingDeclaration;
|
|
enclosingDeclaration = input;
|
|
}
|
|
const canProdiceDiagnostic = canProduceDiagnostics(input);
|
|
const oldDiag = getSymbolAccessibilityDiagnostic;
|
|
if (canProdiceDiagnostic) {
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(input);
|
|
}
|
|
const previousNeedsDeclare = needsDeclare;
|
|
switch (input.kind) {
|
|
case 262 /* TypeAliasDeclaration */: {
|
|
needsDeclare = false;
|
|
const clean2 = cleanup(factory2.updateTypeAliasDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
|
|
visitNode(input.type, visitDeclarationSubtree, isTypeNode)
|
|
));
|
|
needsDeclare = previousNeedsDeclare;
|
|
return clean2;
|
|
}
|
|
case 261 /* InterfaceDeclaration */: {
|
|
return cleanup(factory2.updateInterfaceDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
input.name,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
transformHeritageClauses(input.heritageClauses),
|
|
visitNodes2(input.members, visitDeclarationSubtree)
|
|
));
|
|
}
|
|
case 259 /* FunctionDeclaration */: {
|
|
const clean2 = cleanup(factory2.updateFunctionDeclaration(
|
|
input,
|
|
ensureModifiers(input),
|
|
void 0,
|
|
input.name,
|
|
ensureTypeParams(input, input.typeParameters),
|
|
updateParamsList(input, input.parameters),
|
|
ensureType(input, input.type),
|
|
void 0
|
|
));
|
|
if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
|
|
const props = resolver.getPropertiesOfContainerFunction(input);
|
|
const fakespace = parseNodeFactory.createModuleDeclaration(void 0, clean2.name || factory2.createIdentifier("_default"), factory2.createModuleBlock([]), 16 /* Namespace */);
|
|
setParent(fakespace, enclosingDeclaration);
|
|
fakespace.locals = createSymbolTable(props);
|
|
fakespace.symbol = props[0].parent;
|
|
const exportMappings = [];
|
|
let declarations = mapDefined(props, (p) => {
|
|
if (!p.valueDeclaration || !isPropertyAccessExpression(p.valueDeclaration)) {
|
|
return void 0;
|
|
}
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
|
|
const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, symbolTracker);
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
const nameStr = unescapeLeadingUnderscores(p.escapedName);
|
|
const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
|
|
const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
|
|
if (isNonContextualKeywordName) {
|
|
exportMappings.push([name, nameStr]);
|
|
}
|
|
const varDecl = factory2.createVariableDeclaration(name, void 0, type, void 0);
|
|
return factory2.createVariableStatement(isNonContextualKeywordName ? void 0 : [factory2.createToken(93 /* ExportKeyword */)], factory2.createVariableDeclarationList([varDecl]));
|
|
});
|
|
if (!exportMappings.length) {
|
|
declarations = mapDefined(declarations, (declaration) => factory2.updateModifiers(declaration, 0 /* None */));
|
|
} else {
|
|
declarations.push(factory2.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory2.createNamedExports(map(exportMappings, ([gen, exp]) => {
|
|
return factory2.createExportSpecifier(false, gen, exp);
|
|
}))
|
|
));
|
|
}
|
|
const namespaceDecl = factory2.createModuleDeclaration(ensureModifiers(input), input.name, factory2.createModuleBlock(declarations), 16 /* Namespace */);
|
|
if (!hasEffectiveModifier(clean2, 1024 /* Default */)) {
|
|
return [clean2, namespaceDecl];
|
|
}
|
|
const modifiers = factory2.createModifiersFromModifierFlags(getEffectiveModifierFlags(clean2) & ~1025 /* ExportDefault */ | 2 /* Ambient */);
|
|
const cleanDeclaration = factory2.updateFunctionDeclaration(
|
|
clean2,
|
|
modifiers,
|
|
void 0,
|
|
clean2.name,
|
|
clean2.typeParameters,
|
|
clean2.parameters,
|
|
clean2.type,
|
|
void 0
|
|
);
|
|
const namespaceDeclaration = factory2.updateModuleDeclaration(
|
|
namespaceDecl,
|
|
modifiers,
|
|
namespaceDecl.name,
|
|
namespaceDecl.body
|
|
);
|
|
const exportDefaultDeclaration = factory2.createExportAssignment(
|
|
void 0,
|
|
false,
|
|
namespaceDecl.name
|
|
);
|
|
if (isSourceFile(input.parent)) {
|
|
resultHasExternalModuleIndicator = true;
|
|
}
|
|
resultHasScopeMarker = true;
|
|
return [cleanDeclaration, namespaceDeclaration, exportDefaultDeclaration];
|
|
} else {
|
|
return clean2;
|
|
}
|
|
}
|
|
case 264 /* ModuleDeclaration */: {
|
|
needsDeclare = false;
|
|
const inner = input.body;
|
|
if (inner && inner.kind === 265 /* ModuleBlock */) {
|
|
const oldNeedsScopeFix = needsScopeFixMarker;
|
|
const oldHasScopeFix = resultHasScopeMarker;
|
|
resultHasScopeMarker = false;
|
|
needsScopeFixMarker = false;
|
|
const statements = visitNodes2(inner.statements, visitDeclarationStatements);
|
|
let lateStatements = transformAndReplaceLatePaintedStatements(statements);
|
|
if (input.flags & 16777216 /* Ambient */) {
|
|
needsScopeFixMarker = false;
|
|
}
|
|
if (!isGlobalScopeAugmentation(input) && !hasScopeMarker2(lateStatements) && !resultHasScopeMarker) {
|
|
if (needsScopeFixMarker) {
|
|
lateStatements = factory2.createNodeArray([...lateStatements, createEmptyExports(factory2)]);
|
|
} else {
|
|
lateStatements = visitNodes2(lateStatements, stripExportModifiers);
|
|
}
|
|
}
|
|
const body = factory2.updateModuleBlock(inner, lateStatements);
|
|
needsDeclare = previousNeedsDeclare;
|
|
needsScopeFixMarker = oldNeedsScopeFix;
|
|
resultHasScopeMarker = oldHasScopeFix;
|
|
const mods = ensureModifiers(input);
|
|
return cleanup(factory2.updateModuleDeclaration(
|
|
input,
|
|
mods,
|
|
isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name,
|
|
body
|
|
));
|
|
} else {
|
|
needsDeclare = previousNeedsDeclare;
|
|
const mods = ensureModifiers(input);
|
|
needsDeclare = false;
|
|
visitNode(inner, visitDeclarationStatements);
|
|
const id = getOriginalNodeId(inner);
|
|
const body = lateStatementReplacementMap.get(id);
|
|
lateStatementReplacementMap.delete(id);
|
|
return cleanup(factory2.updateModuleDeclaration(
|
|
input,
|
|
mods,
|
|
input.name,
|
|
body
|
|
));
|
|
}
|
|
}
|
|
case 260 /* ClassDeclaration */: {
|
|
errorNameNode = input.name;
|
|
errorFallbackNode = input;
|
|
const modifiers = factory2.createNodeArray(ensureModifiers(input));
|
|
const typeParameters = ensureTypeParams(input, input.typeParameters);
|
|
const ctor = getFirstConstructorWithBody(input);
|
|
let parameterProperties;
|
|
if (ctor) {
|
|
const oldDiag2 = getSymbolAccessibilityDiagnostic;
|
|
parameterProperties = compact(flatMap(ctor.parameters, (param) => {
|
|
if (!hasSyntacticModifier(param, 16476 /* ParameterPropertyModifier */) || shouldStripInternal(param))
|
|
return;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(param);
|
|
if (param.name.kind === 79 /* Identifier */) {
|
|
return preserveJsDoc(factory2.createPropertyDeclaration(
|
|
ensureModifiers(param),
|
|
param.name,
|
|
param.questionToken,
|
|
ensureType(param, param.type),
|
|
ensureNoInitializer(param)
|
|
), param);
|
|
} else {
|
|
return walkBindingPattern(param.name);
|
|
}
|
|
function walkBindingPattern(pattern) {
|
|
let elems;
|
|
for (const elem of pattern.elements) {
|
|
if (isOmittedExpression(elem))
|
|
continue;
|
|
if (isBindingPattern(elem.name)) {
|
|
elems = concatenate(elems, walkBindingPattern(elem.name));
|
|
}
|
|
elems = elems || [];
|
|
elems.push(factory2.createPropertyDeclaration(
|
|
ensureModifiers(param),
|
|
elem.name,
|
|
void 0,
|
|
ensureType(elem, void 0),
|
|
void 0
|
|
));
|
|
}
|
|
return elems;
|
|
}
|
|
}));
|
|
getSymbolAccessibilityDiagnostic = oldDiag2;
|
|
}
|
|
const hasPrivateIdentifier = some(input.members, (member) => !!member.name && isPrivateIdentifier(member.name));
|
|
const privateIdentifier = hasPrivateIdentifier ? [
|
|
factory2.createPropertyDeclaration(
|
|
void 0,
|
|
factory2.createPrivateIdentifier("#private"),
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
)
|
|
] : void 0;
|
|
const memberNodes = concatenate(concatenate(privateIdentifier, parameterProperties), visitNodes2(input.members, visitDeclarationSubtree));
|
|
const members = factory2.createNodeArray(memberNodes);
|
|
const extendsClause = getEffectiveBaseTypeNode(input);
|
|
if (extendsClause && !isEntityNameExpression(extendsClause.expression) && extendsClause.expression.kind !== 104 /* NullKeyword */) {
|
|
const oldId = input.name ? unescapeLeadingUnderscores(input.name.escapedText) : "default";
|
|
const newId = factory2.createUniqueName(`${oldId}_base`, 16 /* Optimistic */);
|
|
getSymbolAccessibilityDiagnostic = () => ({
|
|
diagnosticMessage: Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
|
|
errorNode: extendsClause,
|
|
typeName: input.name
|
|
});
|
|
const varDecl = factory2.createVariableDeclaration(newId, void 0, resolver.createTypeOfExpression(extendsClause.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), void 0);
|
|
const statement = factory2.createVariableStatement(needsDeclare ? [factory2.createModifier(136 /* DeclareKeyword */)] : [], factory2.createVariableDeclarationList([varDecl], 2 /* Const */));
|
|
const heritageClauses = factory2.createNodeArray(map(input.heritageClauses, (clause) => {
|
|
if (clause.token === 94 /* ExtendsKeyword */) {
|
|
const oldDiag2 = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]);
|
|
const newClause = factory2.updateHeritageClause(clause, map(clause.types, (t) => factory2.updateExpressionWithTypeArguments(t, newId, visitNodes2(t.typeArguments, visitDeclarationSubtree))));
|
|
getSymbolAccessibilityDiagnostic = oldDiag2;
|
|
return newClause;
|
|
}
|
|
return factory2.updateHeritageClause(clause, visitNodes2(factory2.createNodeArray(filter(clause.types, (t) => isEntityNameExpression(t.expression) || t.expression.kind === 104 /* NullKeyword */)), visitDeclarationSubtree));
|
|
}));
|
|
return [statement, cleanup(factory2.updateClassDeclaration(
|
|
input,
|
|
modifiers,
|
|
input.name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
))];
|
|
} else {
|
|
const heritageClauses = transformHeritageClauses(input.heritageClauses);
|
|
return cleanup(factory2.updateClassDeclaration(
|
|
input,
|
|
modifiers,
|
|
input.name,
|
|
typeParameters,
|
|
heritageClauses,
|
|
members
|
|
));
|
|
}
|
|
}
|
|
case 240 /* VariableStatement */: {
|
|
return cleanup(transformVariableStatement(input));
|
|
}
|
|
case 263 /* EnumDeclaration */: {
|
|
return cleanup(factory2.updateEnumDeclaration(input, factory2.createNodeArray(ensureModifiers(input)), input.name, factory2.createNodeArray(mapDefined(input.members, (m) => {
|
|
if (shouldStripInternal(m))
|
|
return;
|
|
const constValue = resolver.getConstantValue(m);
|
|
return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
|
|
}))));
|
|
}
|
|
}
|
|
return Debug.assertNever(input, `Unhandled top-level node in declaration emit: ${Debug.formatSyntaxKind(input.kind)}`);
|
|
function cleanup(node) {
|
|
if (isEnclosingDeclaration(input)) {
|
|
enclosingDeclaration = previousEnclosingDeclaration;
|
|
}
|
|
if (canProdiceDiagnostic) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
if (input.kind === 264 /* ModuleDeclaration */) {
|
|
needsDeclare = previousNeedsDeclare;
|
|
}
|
|
if (node === input) {
|
|
return node;
|
|
}
|
|
errorFallbackNode = void 0;
|
|
errorNameNode = void 0;
|
|
return node && setOriginalNode(preserveJsDoc(node, input), input);
|
|
}
|
|
}
|
|
function transformVariableStatement(input) {
|
|
if (!forEach(input.declarationList.declarations, getBindingNameVisible))
|
|
return;
|
|
const nodes = visitNodes2(input.declarationList.declarations, visitDeclarationSubtree);
|
|
if (!length(nodes))
|
|
return;
|
|
return factory2.updateVariableStatement(input, factory2.createNodeArray(ensureModifiers(input)), factory2.updateVariableDeclarationList(input.declarationList, nodes));
|
|
}
|
|
function recreateBindingPattern(d) {
|
|
return flatten(mapDefined(d.elements, (e) => recreateBindingElement(e)));
|
|
}
|
|
function recreateBindingElement(e) {
|
|
if (e.kind === 229 /* OmittedExpression */) {
|
|
return;
|
|
}
|
|
if (e.name) {
|
|
if (!getBindingNameVisible(e))
|
|
return;
|
|
if (isBindingPattern(e.name)) {
|
|
return recreateBindingPattern(e.name);
|
|
} else {
|
|
return factory2.createVariableDeclaration(e.name, void 0, ensureType(e, void 0), void 0);
|
|
}
|
|
}
|
|
}
|
|
function checkName(node) {
|
|
let oldDiag;
|
|
if (!suppressNewDiagnosticContexts) {
|
|
oldDiag = getSymbolAccessibilityDiagnostic;
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNodeName(node);
|
|
}
|
|
errorNameNode = node.name;
|
|
Debug.assert(resolver.isLateBound(getParseTreeNode(node)));
|
|
const decl = node;
|
|
const entityName = decl.name.expression;
|
|
checkEntityNameVisibility(entityName, enclosingDeclaration);
|
|
if (!suppressNewDiagnosticContexts) {
|
|
getSymbolAccessibilityDiagnostic = oldDiag;
|
|
}
|
|
errorNameNode = void 0;
|
|
}
|
|
function shouldStripInternal(node) {
|
|
return !!stripInternal && !!node && isInternalDeclaration(node, currentSourceFile);
|
|
}
|
|
function isScopeMarker2(node) {
|
|
return isExportAssignment(node) || isExportDeclaration(node);
|
|
}
|
|
function hasScopeMarker2(statements) {
|
|
return some(statements, isScopeMarker2);
|
|
}
|
|
function ensureModifiers(node) {
|
|
const currentFlags = getEffectiveModifierFlags(node);
|
|
const newFlags = ensureModifierFlags(node);
|
|
if (currentFlags === newFlags) {
|
|
return visitArray(node.modifiers, (n) => tryCast(n, isModifier), isModifier);
|
|
}
|
|
return factory2.createModifiersFromModifierFlags(newFlags);
|
|
}
|
|
function ensureModifierFlags(node) {
|
|
let mask2 = 258047 /* All */ ^ (4 /* Public */ | 512 /* Async */ | 16384 /* Override */);
|
|
let additions = needsDeclare && !isAlwaysType(node) ? 2 /* Ambient */ : 0 /* None */;
|
|
const parentIsFile = node.parent.kind === 308 /* SourceFile */;
|
|
if (!parentIsFile || isBundledEmit && parentIsFile && isExternalModule(node.parent)) {
|
|
mask2 ^= 2 /* Ambient */;
|
|
additions = 0 /* None */;
|
|
}
|
|
return maskModifierFlags(node, mask2, additions);
|
|
}
|
|
function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) {
|
|
let accessorType = getTypeAnnotationFromAccessor(node);
|
|
if (!accessorType && node !== accessors.firstAccessor) {
|
|
accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor);
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor);
|
|
}
|
|
if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) {
|
|
accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
|
|
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor);
|
|
}
|
|
return accessorType;
|
|
}
|
|
function transformHeritageClauses(nodes) {
|
|
return factory2.createNodeArray(filter(map(nodes, (clause) => factory2.updateHeritageClause(clause, visitNodes2(factory2.createNodeArray(filter(clause.types, (t) => {
|
|
return isEntityNameExpression(t.expression) || clause.token === 94 /* ExtendsKeyword */ && t.expression.kind === 104 /* NullKeyword */;
|
|
})), visitDeclarationSubtree))), (clause) => clause.types && !!clause.types.length));
|
|
}
|
|
}
|
|
function isAlwaysType(node) {
|
|
if (node.kind === 261 /* InterfaceDeclaration */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function maskModifiers(node, modifierMask, modifierAdditions) {
|
|
return factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
|
|
}
|
|
function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
|
|
let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;
|
|
if (flags & 1024 /* Default */ && !(flags & 1 /* Export */)) {
|
|
flags ^= 1 /* Export */;
|
|
}
|
|
if (flags & 1024 /* Default */ && flags & 2 /* Ambient */) {
|
|
flags ^= 2 /* Ambient */;
|
|
}
|
|
return flags;
|
|
}
|
|
function getTypeAnnotationFromAccessor(accessor) {
|
|
if (accessor) {
|
|
return accessor.kind === 174 /* GetAccessor */ ? accessor.type : accessor.parameters.length > 0 ? accessor.parameters[0].type : void 0;
|
|
}
|
|
}
|
|
function canHaveLiteralInitializer(node) {
|
|
switch (node.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return !hasEffectiveModifier(node, 8 /* Private */);
|
|
case 166 /* Parameter */:
|
|
case 257 /* VariableDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isPreservedDeclarationStatement(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 240 /* VariableStatement */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isProcessedComponent(node) {
|
|
switch (node.kind) {
|
|
case 177 /* ConstructSignature */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 178 /* IndexSignature */:
|
|
case 257 /* VariableDeclaration */:
|
|
case 165 /* TypeParameter */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 180 /* TypeReference */:
|
|
case 191 /* ConditionalType */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 202 /* ImportType */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// src/compiler/transformer.ts
|
|
function getModuleTransformer(moduleKind) {
|
|
switch (moduleKind) {
|
|
case 99 /* ESNext */:
|
|
case 7 /* ES2022 */:
|
|
case 6 /* ES2020 */:
|
|
case 5 /* ES2015 */:
|
|
return transformECMAScriptModule;
|
|
case 4 /* System */:
|
|
return transformSystemModule;
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return transformNodeModule;
|
|
default:
|
|
return transformModule;
|
|
}
|
|
}
|
|
var noTransformers = { scriptTransformers: emptyArray, declarationTransformers: emptyArray };
|
|
function getTransformers(compilerOptions, customTransformers, emitOnly) {
|
|
return {
|
|
scriptTransformers: getScriptTransformers(compilerOptions, customTransformers, emitOnly),
|
|
declarationTransformers: getDeclarationTransformers(customTransformers)
|
|
};
|
|
}
|
|
function getScriptTransformers(compilerOptions, customTransformers, emitOnly) {
|
|
if (emitOnly)
|
|
return emptyArray;
|
|
const languageVersion = getEmitScriptTarget(compilerOptions);
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const transformers = [];
|
|
addRange(transformers, customTransformers && map(customTransformers.before, wrapScriptTransformerFactory));
|
|
transformers.push(transformTypeScript);
|
|
transformers.push(transformLegacyDecorators);
|
|
transformers.push(transformClassFields);
|
|
if (getJSXTransformEnabled(compilerOptions)) {
|
|
transformers.push(transformJsx);
|
|
}
|
|
if (languageVersion < 99 /* ESNext */) {
|
|
transformers.push(transformESNext);
|
|
}
|
|
if (languageVersion < 8 /* ES2021 */) {
|
|
transformers.push(transformES2021);
|
|
}
|
|
if (languageVersion < 7 /* ES2020 */) {
|
|
transformers.push(transformES2020);
|
|
}
|
|
if (languageVersion < 6 /* ES2019 */) {
|
|
transformers.push(transformES2019);
|
|
}
|
|
if (languageVersion < 5 /* ES2018 */) {
|
|
transformers.push(transformES2018);
|
|
}
|
|
if (languageVersion < 4 /* ES2017 */) {
|
|
transformers.push(transformES2017);
|
|
}
|
|
if (languageVersion < 3 /* ES2016 */) {
|
|
transformers.push(transformES2016);
|
|
}
|
|
if (languageVersion < 2 /* ES2015 */) {
|
|
transformers.push(transformES2015);
|
|
transformers.push(transformGenerators);
|
|
}
|
|
transformers.push(getModuleTransformer(moduleKind));
|
|
if (languageVersion < 1 /* ES5 */) {
|
|
transformers.push(transformES5);
|
|
}
|
|
addRange(transformers, customTransformers && map(customTransformers.after, wrapScriptTransformerFactory));
|
|
return transformers;
|
|
}
|
|
function getDeclarationTransformers(customTransformers) {
|
|
const transformers = [];
|
|
transformers.push(transformDeclarations);
|
|
addRange(transformers, customTransformers && map(customTransformers.afterDeclarations, wrapDeclarationTransformerFactory));
|
|
return transformers;
|
|
}
|
|
function wrapCustomTransformer(transformer) {
|
|
return (node) => isBundle(node) ? transformer.transformBundle(node) : transformer.transformSourceFile(node);
|
|
}
|
|
function wrapCustomTransformerFactory(transformer, handleDefault) {
|
|
return (context) => {
|
|
const customTransformer = transformer(context);
|
|
return typeof customTransformer === "function" ? handleDefault(context, customTransformer) : wrapCustomTransformer(customTransformer);
|
|
};
|
|
}
|
|
function wrapScriptTransformerFactory(transformer) {
|
|
return wrapCustomTransformerFactory(transformer, chainBundle);
|
|
}
|
|
function wrapDeclarationTransformerFactory(transformer) {
|
|
return wrapCustomTransformerFactory(transformer, (_, node) => node);
|
|
}
|
|
function noEmitSubstitution(_hint, node) {
|
|
return node;
|
|
}
|
|
function noEmitNotification(hint, node, callback) {
|
|
callback(hint, node);
|
|
}
|
|
function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
|
|
var _a2, _b;
|
|
const enabledSyntaxKindFeatures = new Array(358 /* Count */);
|
|
let lexicalEnvironmentVariableDeclarations;
|
|
let lexicalEnvironmentFunctionDeclarations;
|
|
let lexicalEnvironmentStatements;
|
|
let lexicalEnvironmentFlags = 0 /* None */;
|
|
let lexicalEnvironmentVariableDeclarationsStack = [];
|
|
let lexicalEnvironmentFunctionDeclarationsStack = [];
|
|
let lexicalEnvironmentStatementsStack = [];
|
|
let lexicalEnvironmentFlagsStack = [];
|
|
let lexicalEnvironmentStackOffset = 0;
|
|
let lexicalEnvironmentSuspended = false;
|
|
let blockScopedVariableDeclarationsStack = [];
|
|
let blockScopeStackOffset = 0;
|
|
let blockScopedVariableDeclarations;
|
|
let emitHelpers;
|
|
let onSubstituteNode = noEmitSubstitution;
|
|
let onEmitNode = noEmitNotification;
|
|
let state = 0 /* Uninitialized */;
|
|
const diagnostics = [];
|
|
const context = {
|
|
factory: factory2,
|
|
getCompilerOptions: () => options,
|
|
getEmitResolver: () => resolver,
|
|
getEmitHost: () => host,
|
|
getEmitHelperFactory: memoize(() => createEmitHelperFactory(context)),
|
|
startLexicalEnvironment,
|
|
suspendLexicalEnvironment,
|
|
resumeLexicalEnvironment,
|
|
endLexicalEnvironment,
|
|
setLexicalEnvironmentFlags,
|
|
getLexicalEnvironmentFlags,
|
|
hoistVariableDeclaration,
|
|
hoistFunctionDeclaration,
|
|
addInitializationStatement,
|
|
startBlockScope,
|
|
endBlockScope,
|
|
addBlockScopedVariable,
|
|
requestEmitHelper,
|
|
readEmitHelpers,
|
|
enableSubstitution,
|
|
enableEmitNotification,
|
|
isSubstitutionEnabled,
|
|
isEmitNotificationEnabled,
|
|
get onSubstituteNode() {
|
|
return onSubstituteNode;
|
|
},
|
|
set onSubstituteNode(value) {
|
|
Debug.assert(state < 1 /* Initialized */, "Cannot modify transformation hooks after initialization has completed.");
|
|
Debug.assert(value !== void 0, "Value must not be 'undefined'");
|
|
onSubstituteNode = value;
|
|
},
|
|
get onEmitNode() {
|
|
return onEmitNode;
|
|
},
|
|
set onEmitNode(value) {
|
|
Debug.assert(state < 1 /* Initialized */, "Cannot modify transformation hooks after initialization has completed.");
|
|
Debug.assert(value !== void 0, "Value must not be 'undefined'");
|
|
onEmitNode = value;
|
|
},
|
|
addDiagnostic(diag2) {
|
|
diagnostics.push(diag2);
|
|
}
|
|
};
|
|
for (const node of nodes) {
|
|
disposeEmitNodes(getSourceFileOfNode(getParseTreeNode(node)));
|
|
}
|
|
mark("beforeTransform");
|
|
const transformersWithContext = transformers.map((t) => t(context));
|
|
const transformation = (node) => {
|
|
for (const transform2 of transformersWithContext) {
|
|
node = transform2(node);
|
|
}
|
|
return node;
|
|
};
|
|
state = 1 /* Initialized */;
|
|
const transformed = [];
|
|
for (const node of nodes) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "transformNodes", node.kind === 308 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end });
|
|
transformed.push((allowDtsFiles ? transformation : transformRoot)(node));
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
state = 2 /* Completed */;
|
|
mark("afterTransform");
|
|
measure("transformTime", "beforeTransform", "afterTransform");
|
|
return {
|
|
transformed,
|
|
substituteNode,
|
|
emitNodeWithNotification,
|
|
isEmitNotificationEnabled,
|
|
dispose,
|
|
diagnostics
|
|
};
|
|
function transformRoot(node) {
|
|
return node && (!isSourceFile(node) || !node.isDeclarationFile) ? transformation(node) : node;
|
|
}
|
|
function enableSubstitution(kind) {
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
enabledSyntaxKindFeatures[kind] |= 1 /* Substitution */;
|
|
}
|
|
function isSubstitutionEnabled(node) {
|
|
return (enabledSyntaxKindFeatures[node.kind] & 1 /* Substitution */) !== 0 && (getEmitFlags(node) & 8 /* NoSubstitution */) === 0;
|
|
}
|
|
function substituteNode(hint, node) {
|
|
Debug.assert(state < 3 /* Disposed */, "Cannot substitute a node after the result is disposed.");
|
|
return node && isSubstitutionEnabled(node) && onSubstituteNode(hint, node) || node;
|
|
}
|
|
function enableEmitNotification(kind) {
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
enabledSyntaxKindFeatures[kind] |= 2 /* EmitNotifications */;
|
|
}
|
|
function isEmitNotificationEnabled(node) {
|
|
return (enabledSyntaxKindFeatures[node.kind] & 2 /* EmitNotifications */) !== 0 || (getEmitFlags(node) & 4 /* AdviseOnEmitNode */) !== 0;
|
|
}
|
|
function emitNodeWithNotification(hint, node, emitCallback) {
|
|
Debug.assert(state < 3 /* Disposed */, "Cannot invoke TransformationResult callbacks after the result is disposed.");
|
|
if (node) {
|
|
if (isEmitNotificationEnabled(node)) {
|
|
onEmitNode(hint, node, emitCallback);
|
|
} else {
|
|
emitCallback(hint, node);
|
|
}
|
|
}
|
|
}
|
|
function hoistVariableDeclaration(name) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
const decl = setEmitFlags(factory2.createVariableDeclaration(name), 128 /* NoNestedSourceMaps */);
|
|
if (!lexicalEnvironmentVariableDeclarations) {
|
|
lexicalEnvironmentVariableDeclarations = [decl];
|
|
} else {
|
|
lexicalEnvironmentVariableDeclarations.push(decl);
|
|
}
|
|
if (lexicalEnvironmentFlags & 1 /* InParameters */) {
|
|
lexicalEnvironmentFlags |= 2 /* VariablesHoistedInParameters */;
|
|
}
|
|
}
|
|
function hoistFunctionDeclaration(func) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
setEmitFlags(func, 2097152 /* CustomPrologue */);
|
|
if (!lexicalEnvironmentFunctionDeclarations) {
|
|
lexicalEnvironmentFunctionDeclarations = [func];
|
|
} else {
|
|
lexicalEnvironmentFunctionDeclarations.push(func);
|
|
}
|
|
}
|
|
function addInitializationStatement(node) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
setEmitFlags(node, 2097152 /* CustomPrologue */);
|
|
if (!lexicalEnvironmentStatements) {
|
|
lexicalEnvironmentStatements = [node];
|
|
} else {
|
|
lexicalEnvironmentStatements.push(node);
|
|
}
|
|
}
|
|
function startLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended.");
|
|
lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentVariableDeclarations;
|
|
lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFunctionDeclarations;
|
|
lexicalEnvironmentStatementsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentStatements;
|
|
lexicalEnvironmentFlagsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFlags;
|
|
lexicalEnvironmentStackOffset++;
|
|
lexicalEnvironmentVariableDeclarations = void 0;
|
|
lexicalEnvironmentFunctionDeclarations = void 0;
|
|
lexicalEnvironmentStatements = void 0;
|
|
lexicalEnvironmentFlags = 0 /* None */;
|
|
}
|
|
function suspendLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is already suspended.");
|
|
lexicalEnvironmentSuspended = true;
|
|
}
|
|
function resumeLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(lexicalEnvironmentSuspended, "Lexical environment is not suspended.");
|
|
lexicalEnvironmentSuspended = false;
|
|
}
|
|
function endLexicalEnvironment() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the lexical environment during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the lexical environment after transformation has completed.");
|
|
Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended.");
|
|
let statements;
|
|
if (lexicalEnvironmentVariableDeclarations || lexicalEnvironmentFunctionDeclarations || lexicalEnvironmentStatements) {
|
|
if (lexicalEnvironmentFunctionDeclarations) {
|
|
statements = [...lexicalEnvironmentFunctionDeclarations];
|
|
}
|
|
if (lexicalEnvironmentVariableDeclarations) {
|
|
const statement = factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations)
|
|
);
|
|
setEmitFlags(statement, 2097152 /* CustomPrologue */);
|
|
if (!statements) {
|
|
statements = [statement];
|
|
} else {
|
|
statements.push(statement);
|
|
}
|
|
}
|
|
if (lexicalEnvironmentStatements) {
|
|
if (!statements) {
|
|
statements = [...lexicalEnvironmentStatements];
|
|
} else {
|
|
statements = [...statements, ...lexicalEnvironmentStatements];
|
|
}
|
|
}
|
|
}
|
|
lexicalEnvironmentStackOffset--;
|
|
lexicalEnvironmentVariableDeclarations = lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset];
|
|
lexicalEnvironmentFunctionDeclarations = lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset];
|
|
lexicalEnvironmentStatements = lexicalEnvironmentStatementsStack[lexicalEnvironmentStackOffset];
|
|
lexicalEnvironmentFlags = lexicalEnvironmentFlagsStack[lexicalEnvironmentStackOffset];
|
|
if (lexicalEnvironmentStackOffset === 0) {
|
|
lexicalEnvironmentVariableDeclarationsStack = [];
|
|
lexicalEnvironmentFunctionDeclarationsStack = [];
|
|
lexicalEnvironmentStatementsStack = [];
|
|
lexicalEnvironmentFlagsStack = [];
|
|
}
|
|
return statements;
|
|
}
|
|
function setLexicalEnvironmentFlags(flags, value) {
|
|
lexicalEnvironmentFlags = value ? lexicalEnvironmentFlags | flags : lexicalEnvironmentFlags & ~flags;
|
|
}
|
|
function getLexicalEnvironmentFlags() {
|
|
return lexicalEnvironmentFlags;
|
|
}
|
|
function startBlockScope() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot start a block scope during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot start a block scope after transformation has completed.");
|
|
blockScopedVariableDeclarationsStack[blockScopeStackOffset] = blockScopedVariableDeclarations;
|
|
blockScopeStackOffset++;
|
|
blockScopedVariableDeclarations = void 0;
|
|
}
|
|
function endBlockScope() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot end a block scope during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot end a block scope after transformation has completed.");
|
|
const statements = some(blockScopedVariableDeclarations) ? [
|
|
factory2.createVariableStatement(
|
|
void 0,
|
|
factory2.createVariableDeclarationList(
|
|
blockScopedVariableDeclarations.map((identifier) => factory2.createVariableDeclaration(identifier)),
|
|
1 /* Let */
|
|
)
|
|
)
|
|
] : void 0;
|
|
blockScopeStackOffset--;
|
|
blockScopedVariableDeclarations = blockScopedVariableDeclarationsStack[blockScopeStackOffset];
|
|
if (blockScopeStackOffset === 0) {
|
|
blockScopedVariableDeclarationsStack = [];
|
|
}
|
|
return statements;
|
|
}
|
|
function addBlockScopedVariable(name) {
|
|
Debug.assert(blockScopeStackOffset > 0, "Cannot add a block scoped variable outside of an iteration body.");
|
|
(blockScopedVariableDeclarations || (blockScopedVariableDeclarations = [])).push(name);
|
|
}
|
|
function requestEmitHelper(helper) {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the transformation context during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
Debug.assert(!helper.scoped, "Cannot request a scoped emit helper.");
|
|
if (helper.dependencies) {
|
|
for (const h of helper.dependencies) {
|
|
requestEmitHelper(h);
|
|
}
|
|
}
|
|
emitHelpers = append(emitHelpers, helper);
|
|
}
|
|
function readEmitHelpers() {
|
|
Debug.assert(state > 0 /* Uninitialized */, "Cannot modify the transformation context during initialization.");
|
|
Debug.assert(state < 2 /* Completed */, "Cannot modify the transformation context after transformation has completed.");
|
|
const helpers = emitHelpers;
|
|
emitHelpers = void 0;
|
|
return helpers;
|
|
}
|
|
function dispose() {
|
|
if (state < 3 /* Disposed */) {
|
|
for (const node of nodes) {
|
|
disposeEmitNodes(getSourceFileOfNode(getParseTreeNode(node)));
|
|
}
|
|
lexicalEnvironmentVariableDeclarations = void 0;
|
|
lexicalEnvironmentVariableDeclarationsStack = void 0;
|
|
lexicalEnvironmentFunctionDeclarations = void 0;
|
|
lexicalEnvironmentFunctionDeclarationsStack = void 0;
|
|
onSubstituteNode = void 0;
|
|
onEmitNode = void 0;
|
|
emitHelpers = void 0;
|
|
state = 3 /* Disposed */;
|
|
}
|
|
}
|
|
}
|
|
var nullTransformationContext = {
|
|
factory,
|
|
getCompilerOptions: () => ({}),
|
|
getEmitResolver: notImplemented,
|
|
getEmitHost: notImplemented,
|
|
getEmitHelperFactory: notImplemented,
|
|
startLexicalEnvironment: noop,
|
|
resumeLexicalEnvironment: noop,
|
|
suspendLexicalEnvironment: noop,
|
|
endLexicalEnvironment: returnUndefined,
|
|
setLexicalEnvironmentFlags: noop,
|
|
getLexicalEnvironmentFlags: () => 0,
|
|
hoistVariableDeclaration: noop,
|
|
hoistFunctionDeclaration: noop,
|
|
addInitializationStatement: noop,
|
|
startBlockScope: noop,
|
|
endBlockScope: returnUndefined,
|
|
addBlockScopedVariable: noop,
|
|
requestEmitHelper: noop,
|
|
readEmitHelpers: notImplemented,
|
|
enableSubstitution: noop,
|
|
enableEmitNotification: noop,
|
|
isSubstitutionEnabled: notImplemented,
|
|
isEmitNotificationEnabled: notImplemented,
|
|
onSubstituteNode: noEmitSubstitution,
|
|
onEmitNode: noEmitNotification,
|
|
addDiagnostic: noop
|
|
};
|
|
|
|
// src/compiler/emitter.ts
|
|
var brackets = createBracketsMap();
|
|
function isBuildInfoFile(file) {
|
|
return fileExtensionIs(file, ".tsbuildinfo" /* TsBuildInfo */);
|
|
}
|
|
function forEachEmittedFile(host, action, sourceFilesOrTargetSourceFile, forceDtsEmit = false, onlyBuildInfo, includeBuildInfo) {
|
|
const sourceFiles = isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit);
|
|
const options = host.getCompilerOptions();
|
|
if (outFile(options)) {
|
|
const prepends = host.getPrependNodes();
|
|
if (sourceFiles.length || prepends.length) {
|
|
const bundle = factory.createBundle(sourceFiles, prepends);
|
|
const result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
} else {
|
|
if (!onlyBuildInfo) {
|
|
for (const sourceFile of sourceFiles) {
|
|
const result = action(getOutputPathsFor(sourceFile, host, forceDtsEmit), sourceFile);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
if (includeBuildInfo) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
if (buildInfoPath)
|
|
return action({ buildInfoPath }, void 0);
|
|
}
|
|
}
|
|
}
|
|
function getTsBuildInfoEmitOutputFilePath(options) {
|
|
const configFile = options.configFilePath;
|
|
if (!isIncrementalCompilation(options))
|
|
return void 0;
|
|
if (options.tsBuildInfoFile)
|
|
return options.tsBuildInfoFile;
|
|
const outPath = outFile(options);
|
|
let buildInfoExtensionLess;
|
|
if (outPath) {
|
|
buildInfoExtensionLess = removeFileExtension(outPath);
|
|
} else {
|
|
if (!configFile)
|
|
return void 0;
|
|
const configFileExtensionLess = removeFileExtension(configFile);
|
|
buildInfoExtensionLess = options.outDir ? options.rootDir ? resolvePath(options.outDir, getRelativePathFromDirectory(options.rootDir, configFileExtensionLess, true)) : combinePaths(options.outDir, getBaseFileName(configFileExtensionLess)) : configFileExtensionLess;
|
|
}
|
|
return buildInfoExtensionLess + ".tsbuildinfo" /* TsBuildInfo */;
|
|
}
|
|
function getOutputPathsForBundle(options, forceDtsPaths) {
|
|
const outPath = outFile(options);
|
|
const jsFilePath = options.emitDeclarationOnly ? void 0 : outPath;
|
|
const sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options);
|
|
const declarationFilePath = forceDtsPaths || getEmitDeclarations(options) ? removeFileExtension(outPath) + ".d.ts" /* Dts */ : void 0;
|
|
const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : void 0;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath };
|
|
}
|
|
function getOutputPathsFor(sourceFile, host, forceDtsPaths) {
|
|
const options = host.getCompilerOptions();
|
|
if (sourceFile.kind === 309 /* Bundle */) {
|
|
return getOutputPathsForBundle(options, forceDtsPaths);
|
|
} else {
|
|
const ownOutputFilePath = getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile.fileName, options));
|
|
const isJsonFile = isJsonSourceFile(sourceFile);
|
|
const isJsonEmittedToSameLocation = isJsonFile && comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === 0 /* EqualTo */;
|
|
const jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? void 0 : ownOutputFilePath;
|
|
const sourceMapFilePath = !jsFilePath || isJsonSourceFile(sourceFile) ? void 0 : getSourceMapFilePath(jsFilePath, options);
|
|
const declarationFilePath = forceDtsPaths || getEmitDeclarations(options) && !isJsonFile ? getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : void 0;
|
|
const declarationMapPath = declarationFilePath && getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : void 0;
|
|
return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath: void 0 };
|
|
}
|
|
}
|
|
function getSourceMapFilePath(jsFilePath, options) {
|
|
return options.sourceMap && !options.inlineSourceMap ? jsFilePath + ".map" : void 0;
|
|
}
|
|
function getOutputExtension(fileName, options) {
|
|
return fileExtensionIs(fileName, ".json" /* Json */) ? ".json" /* Json */ : options.jsx === 1 /* Preserve */ && fileExtensionIsOneOf(fileName, [".jsx" /* Jsx */, ".tsx" /* Tsx */]) ? ".jsx" /* Jsx */ : fileExtensionIsOneOf(fileName, [".mts" /* Mts */, ".mjs" /* Mjs */]) ? ".mjs" /* Mjs */ : fileExtensionIsOneOf(fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]) ? ".cjs" /* Cjs */ : ".js" /* Js */;
|
|
}
|
|
function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory2) {
|
|
return outputDir ? resolvePath(
|
|
outputDir,
|
|
getRelativePathFromDirectory(getCommonSourceDirectory2 ? getCommonSourceDirectory2() : getCommonSourceDirectoryOfConfig(configFile, ignoreCase), inputFileName, ignoreCase)
|
|
) : inputFileName;
|
|
}
|
|
function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
|
|
return changeExtension(
|
|
getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory2),
|
|
getDeclarationEmitExtensionForPath(inputFileName)
|
|
);
|
|
}
|
|
function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2) {
|
|
if (configFile.options.emitDeclarationOnly)
|
|
return void 0;
|
|
const isJsonFile = fileExtensionIs(inputFileName, ".json" /* Json */);
|
|
const outputFileName = changeExtension(
|
|
getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory2),
|
|
getOutputExtension(inputFileName, configFile.options)
|
|
);
|
|
return !isJsonFile || comparePaths(inputFileName, outputFileName, Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 /* EqualTo */ ? outputFileName : void 0;
|
|
}
|
|
function createAddOutput() {
|
|
let outputs;
|
|
return { addOutput, getOutputs };
|
|
function addOutput(path) {
|
|
if (path) {
|
|
(outputs || (outputs = [])).push(path);
|
|
}
|
|
}
|
|
function getOutputs() {
|
|
return outputs || emptyArray;
|
|
}
|
|
}
|
|
function getSingleOutputFileNames(configFile, addOutput) {
|
|
const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(configFile.options, false);
|
|
addOutput(jsFilePath);
|
|
addOutput(sourceMapFilePath);
|
|
addOutput(declarationFilePath);
|
|
addOutput(declarationMapPath);
|
|
addOutput(buildInfoPath);
|
|
}
|
|
function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory2) {
|
|
if (isDeclarationFileName(inputFileName))
|
|
return;
|
|
const js = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
addOutput(js);
|
|
if (fileExtensionIs(inputFileName, ".json" /* Json */))
|
|
return;
|
|
if (js && configFile.options.sourceMap) {
|
|
addOutput(`${js}.map`);
|
|
}
|
|
if (getEmitDeclarations(configFile.options)) {
|
|
const dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
addOutput(dts);
|
|
if (configFile.options.declarationMap) {
|
|
addOutput(`${dts}.map`);
|
|
}
|
|
}
|
|
}
|
|
function getCommonSourceDirectory(options, emittedFiles, currentDirectory, getCanonicalFileName, checkSourceFilesBelongToPath) {
|
|
let commonSourceDirectory;
|
|
if (options.rootDir) {
|
|
commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);
|
|
checkSourceFilesBelongToPath == null ? void 0 : checkSourceFilesBelongToPath(options.rootDir);
|
|
} else if (options.composite && options.configFilePath) {
|
|
commonSourceDirectory = getDirectoryPath(normalizeSlashes(options.configFilePath));
|
|
checkSourceFilesBelongToPath == null ? void 0 : checkSourceFilesBelongToPath(commonSourceDirectory);
|
|
} else {
|
|
commonSourceDirectory = computeCommonSourceDirectoryOfFilenames(emittedFiles(), currentDirectory, getCanonicalFileName);
|
|
}
|
|
if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) {
|
|
commonSourceDirectory += directorySeparator;
|
|
}
|
|
return commonSourceDirectory;
|
|
}
|
|
function getCommonSourceDirectoryOfConfig({ options, fileNames }, ignoreCase) {
|
|
return getCommonSourceDirectory(
|
|
options,
|
|
() => filter(fileNames, (file) => !(options.noEmitForJsFiles && fileExtensionIsOneOf(file, supportedJSExtensionsFlat)) && !isDeclarationFileName(file)),
|
|
getDirectoryPath(normalizeSlashes(Debug.checkDefined(options.configFilePath))),
|
|
createGetCanonicalFileName(!ignoreCase)
|
|
);
|
|
}
|
|
function getAllProjectOutputs(configFile, ignoreCase) {
|
|
const { addOutput, getOutputs } = createAddOutput();
|
|
if (outFile(configFile.options)) {
|
|
getSingleOutputFileNames(configFile, addOutput);
|
|
} else {
|
|
const getCommonSourceDirectory2 = memoize(() => getCommonSourceDirectoryOfConfig(configFile, ignoreCase));
|
|
for (const inputFileName of configFile.fileNames) {
|
|
getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory2);
|
|
}
|
|
addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options));
|
|
}
|
|
return getOutputs();
|
|
}
|
|
function getOutputFileNames(commandLine, inputFileName, ignoreCase) {
|
|
inputFileName = normalizePath(inputFileName);
|
|
Debug.assert(contains(commandLine.fileNames, inputFileName), `Expected fileName to be present in command line`);
|
|
const { addOutput, getOutputs } = createAddOutput();
|
|
if (outFile(commandLine.options)) {
|
|
getSingleOutputFileNames(commandLine, addOutput);
|
|
} else {
|
|
getOwnOutputFileNames(commandLine, inputFileName, ignoreCase, addOutput);
|
|
}
|
|
return getOutputs();
|
|
}
|
|
function getFirstProjectOutput(configFile, ignoreCase) {
|
|
if (outFile(configFile.options)) {
|
|
const { jsFilePath, declarationFilePath } = getOutputPathsForBundle(configFile.options, false);
|
|
return Debug.checkDefined(jsFilePath || declarationFilePath, `project ${configFile.options.configFilePath} expected to have at least one output`);
|
|
}
|
|
const getCommonSourceDirectory2 = memoize(() => getCommonSourceDirectoryOfConfig(configFile, ignoreCase));
|
|
for (const inputFileName of configFile.fileNames) {
|
|
if (isDeclarationFileName(inputFileName))
|
|
continue;
|
|
const jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
if (jsFilePath)
|
|
return jsFilePath;
|
|
if (fileExtensionIs(inputFileName, ".json" /* Json */))
|
|
continue;
|
|
if (getEmitDeclarations(configFile.options)) {
|
|
return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory2);
|
|
}
|
|
}
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options);
|
|
if (buildInfoPath)
|
|
return buildInfoPath;
|
|
return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);
|
|
}
|
|
function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, declarationTransformers }, emitOnly, onlyBuildInfo, forceDtsEmit) {
|
|
const compilerOptions = host.getCompilerOptions();
|
|
const sourceMapDataList = compilerOptions.sourceMap || compilerOptions.inlineSourceMap || getAreDeclarationMapsEnabled(compilerOptions) ? [] : void 0;
|
|
const emittedFilesList = compilerOptions.listEmittedFiles ? [] : void 0;
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const newLine = getNewLineCharacter(compilerOptions, () => host.getNewLine());
|
|
const writer = createTextWriter(newLine);
|
|
const { enter, exit } = createTimer("printTime", "beforePrint", "afterPrint");
|
|
let bundleBuildInfo;
|
|
let emitSkipped = false;
|
|
enter();
|
|
forEachEmittedFile(
|
|
host,
|
|
emitSourceFileOrBundle,
|
|
getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit),
|
|
forceDtsEmit,
|
|
onlyBuildInfo,
|
|
!targetSourceFile
|
|
);
|
|
exit();
|
|
return {
|
|
emitSkipped,
|
|
diagnostics: emitterDiagnostics.getDiagnostics(),
|
|
emittedFiles: emittedFilesList,
|
|
sourceMaps: sourceMapDataList
|
|
};
|
|
function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath }, sourceFileOrBundle) {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
let buildInfoDirectory;
|
|
if (buildInfoPath && sourceFileOrBundle && isBundle(sourceFileOrBundle)) {
|
|
buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
bundleBuildInfo = {
|
|
commonSourceDirectory: relativeToBuildInfo(host.getCommonSourceDirectory()),
|
|
sourceFiles: sourceFileOrBundle.sourceFiles.map((file) => relativeToBuildInfo(getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())))
|
|
};
|
|
}
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitJsFileOrBundle", { jsFilePath });
|
|
emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
(_c = tracing) == null ? void 0 : _c.push(tracing.Phase.Emit, "emitDeclarationFileOrBundle", { declarationFilePath });
|
|
emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);
|
|
(_d = tracing) == null ? void 0 : _d.pop();
|
|
(_e = tracing) == null ? void 0 : _e.push(tracing.Phase.Emit, "emitBuildInfo", { buildInfoPath });
|
|
emitBuildInfo(bundleBuildInfo, buildInfoPath);
|
|
(_f = tracing) == null ? void 0 : _f.pop();
|
|
if (!emitSkipped && emittedFilesList) {
|
|
if (!emitOnly) {
|
|
if (jsFilePath) {
|
|
emittedFilesList.push(jsFilePath);
|
|
}
|
|
if (sourceMapFilePath) {
|
|
emittedFilesList.push(sourceMapFilePath);
|
|
}
|
|
if (buildInfoPath) {
|
|
emittedFilesList.push(buildInfoPath);
|
|
}
|
|
}
|
|
if (emitOnly !== 0 /* Js */) {
|
|
if (declarationFilePath) {
|
|
emittedFilesList.push(declarationFilePath);
|
|
}
|
|
if (declarationMapPath) {
|
|
emittedFilesList.push(declarationMapPath);
|
|
}
|
|
}
|
|
}
|
|
function relativeToBuildInfo(path) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName));
|
|
}
|
|
}
|
|
function emitBuildInfo(bundle, buildInfoPath) {
|
|
if (!buildInfoPath || targetSourceFile || emitSkipped)
|
|
return;
|
|
if (host.isEmitBlocked(buildInfoPath)) {
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const buildInfo = host.getBuildInfo(bundle) || createBuildInfo(void 0, bundle);
|
|
writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), false, void 0, { buildInfo });
|
|
}
|
|
function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) {
|
|
if (!sourceFileOrBundle || emitOnly || !jsFilePath) {
|
|
return;
|
|
}
|
|
if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit) {
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const transform2 = transformNodes(resolver, host, factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, false);
|
|
const printerOptions = {
|
|
removeComments: compilerOptions.removeComments,
|
|
newLine: compilerOptions.newLine,
|
|
noEmitHelpers: compilerOptions.noEmitHelpers,
|
|
module: compilerOptions.module,
|
|
target: compilerOptions.target,
|
|
sourceMap: compilerOptions.sourceMap,
|
|
inlineSourceMap: compilerOptions.inlineSourceMap,
|
|
inlineSources: compilerOptions.inlineSources,
|
|
extendedDiagnostics: compilerOptions.extendedDiagnostics,
|
|
writeBundleFileInfo: !!bundleBuildInfo,
|
|
relativeToBuildInfo
|
|
};
|
|
const printer = createPrinter(printerOptions, {
|
|
hasGlobalName: resolver.hasGlobalName,
|
|
onEmitNode: transform2.emitNodeWithNotification,
|
|
isEmitNotificationEnabled: transform2.isEmitNotificationEnabled,
|
|
substituteNode: transform2.substituteNode
|
|
});
|
|
Debug.assert(transform2.transformed.length === 1, "Should only see one output from the transform");
|
|
printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform2, printer, compilerOptions);
|
|
transform2.dispose();
|
|
if (bundleBuildInfo)
|
|
bundleBuildInfo.js = printer.bundleFileInfo;
|
|
}
|
|
function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) {
|
|
if (!sourceFileOrBundle || emitOnly === 0 /* Js */)
|
|
return;
|
|
if (!declarationFilePath) {
|
|
if (emitOnly || compilerOptions.emitDeclarationOnly)
|
|
emitSkipped = true;
|
|
return;
|
|
}
|
|
const sourceFiles = isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles;
|
|
const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);
|
|
const inputListOrBundle = outFile(compilerOptions) ? [factory.createBundle(filesForEmit, !isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : void 0)] : filesForEmit;
|
|
if (emitOnly && !getEmitDeclarations(compilerOptions)) {
|
|
filesForEmit.forEach(collectLinkedAliases);
|
|
}
|
|
const declarationTransform = transformNodes(resolver, host, factory, compilerOptions, inputListOrBundle, declarationTransformers, false);
|
|
if (length(declarationTransform.diagnostics)) {
|
|
for (const diagnostic of declarationTransform.diagnostics) {
|
|
emitterDiagnostics.add(diagnostic);
|
|
}
|
|
}
|
|
const printerOptions = {
|
|
removeComments: compilerOptions.removeComments,
|
|
newLine: compilerOptions.newLine,
|
|
noEmitHelpers: true,
|
|
module: compilerOptions.module,
|
|
target: compilerOptions.target,
|
|
sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
|
|
inlineSourceMap: compilerOptions.inlineSourceMap,
|
|
extendedDiagnostics: compilerOptions.extendedDiagnostics,
|
|
onlyPrintJsDocStyle: true,
|
|
writeBundleFileInfo: !!bundleBuildInfo,
|
|
recordInternalSection: !!bundleBuildInfo,
|
|
relativeToBuildInfo
|
|
};
|
|
const declarationPrinter = createPrinter(printerOptions, {
|
|
hasGlobalName: resolver.hasGlobalName,
|
|
onEmitNode: declarationTransform.emitNodeWithNotification,
|
|
isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled,
|
|
substituteNode: declarationTransform.substituteNode
|
|
});
|
|
const declBlocked = !!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
|
|
emitSkipped = emitSkipped || declBlocked;
|
|
if (!declBlocked || forceDtsEmit) {
|
|
Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");
|
|
printSourceFileOrBundle(
|
|
declarationFilePath,
|
|
declarationMapPath,
|
|
declarationTransform,
|
|
declarationPrinter,
|
|
{
|
|
sourceMap: printerOptions.sourceMap,
|
|
sourceRoot: compilerOptions.sourceRoot,
|
|
mapRoot: compilerOptions.mapRoot,
|
|
extendedDiagnostics: compilerOptions.extendedDiagnostics
|
|
}
|
|
);
|
|
}
|
|
declarationTransform.dispose();
|
|
if (bundleBuildInfo)
|
|
bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
|
|
}
|
|
function collectLinkedAliases(node) {
|
|
if (isExportAssignment(node)) {
|
|
if (node.expression.kind === 79 /* Identifier */) {
|
|
resolver.collectLinkedAliases(node.expression, true);
|
|
}
|
|
return;
|
|
} else if (isExportSpecifier(node)) {
|
|
resolver.collectLinkedAliases(node.propertyName || node.name, true);
|
|
return;
|
|
}
|
|
forEachChild(node, collectLinkedAliases);
|
|
}
|
|
function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform2, printer, mapOptions) {
|
|
const sourceFileOrBundle = transform2.transformed[0];
|
|
const bundle = sourceFileOrBundle.kind === 309 /* Bundle */ ? sourceFileOrBundle : void 0;
|
|
const sourceFile = sourceFileOrBundle.kind === 308 /* SourceFile */ ? sourceFileOrBundle : void 0;
|
|
const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
|
|
let sourceMapGenerator;
|
|
if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) {
|
|
sourceMapGenerator = createSourceMapGenerator(
|
|
host,
|
|
getBaseFileName(normalizeSlashes(jsFilePath)),
|
|
getSourceRoot(mapOptions),
|
|
getSourceMapDirectory(mapOptions, jsFilePath, sourceFile),
|
|
mapOptions
|
|
);
|
|
}
|
|
if (bundle) {
|
|
printer.writeBundle(bundle, writer, sourceMapGenerator);
|
|
} else {
|
|
printer.writeFile(sourceFile, writer, sourceMapGenerator);
|
|
}
|
|
let sourceMapUrlPos;
|
|
if (sourceMapGenerator) {
|
|
if (sourceMapDataList) {
|
|
sourceMapDataList.push({
|
|
inputSourceFileNames: sourceMapGenerator.getSources(),
|
|
sourceMap: sourceMapGenerator.toJSON()
|
|
});
|
|
}
|
|
const sourceMappingURL = getSourceMappingURL(
|
|
mapOptions,
|
|
sourceMapGenerator,
|
|
jsFilePath,
|
|
sourceMapFilePath,
|
|
sourceFile
|
|
);
|
|
if (sourceMappingURL) {
|
|
if (!writer.isAtStartOfLine())
|
|
writer.rawWrite(newLine);
|
|
sourceMapUrlPos = writer.getTextPos();
|
|
writer.writeComment(`//# ${"sourceMappingURL"}=${sourceMappingURL}`);
|
|
}
|
|
if (sourceMapFilePath) {
|
|
const sourceMap = sourceMapGenerator.toString();
|
|
writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, false, sourceFiles);
|
|
if (printer.bundleFileInfo)
|
|
printer.bundleFileInfo.mapHash = computeSignature(sourceMap, host);
|
|
}
|
|
} else {
|
|
writer.writeLine();
|
|
}
|
|
const text = writer.getText();
|
|
writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos, diagnostics: transform2.diagnostics });
|
|
if (printer.bundleFileInfo)
|
|
printer.bundleFileInfo.hash = computeSignature(text, host);
|
|
writer.clear();
|
|
}
|
|
function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) {
|
|
return (mapOptions.sourceMap || mapOptions.inlineSourceMap) && (sourceFileOrBundle.kind !== 308 /* SourceFile */ || !fileExtensionIs(sourceFileOrBundle.fileName, ".json" /* Json */));
|
|
}
|
|
function getSourceRoot(mapOptions) {
|
|
const sourceRoot = normalizeSlashes(mapOptions.sourceRoot || "");
|
|
return sourceRoot ? ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot;
|
|
}
|
|
function getSourceMapDirectory(mapOptions, filePath, sourceFile) {
|
|
if (mapOptions.sourceRoot)
|
|
return host.getCommonSourceDirectory();
|
|
if (mapOptions.mapRoot) {
|
|
let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);
|
|
if (sourceFile) {
|
|
sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));
|
|
}
|
|
if (getRootLength(sourceMapDir) === 0) {
|
|
sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
|
|
}
|
|
return sourceMapDir;
|
|
}
|
|
return getDirectoryPath(normalizePath(filePath));
|
|
}
|
|
function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile) {
|
|
if (mapOptions.inlineSourceMap) {
|
|
const sourceMapText = sourceMapGenerator.toString();
|
|
const base64SourceMapText = base64encode(sys, sourceMapText);
|
|
return `data:application/json;base64,${base64SourceMapText}`;
|
|
}
|
|
const sourceMapFile = getBaseFileName(normalizeSlashes(Debug.checkDefined(sourceMapFilePath)));
|
|
if (mapOptions.mapRoot) {
|
|
let sourceMapDir = normalizeSlashes(mapOptions.mapRoot);
|
|
if (sourceFile) {
|
|
sourceMapDir = getDirectoryPath(getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir));
|
|
}
|
|
if (getRootLength(sourceMapDir) === 0) {
|
|
sourceMapDir = combinePaths(host.getCommonSourceDirectory(), sourceMapDir);
|
|
return encodeURI(
|
|
getRelativePathToDirectoryOrUrl(
|
|
getDirectoryPath(normalizePath(filePath)),
|
|
combinePaths(sourceMapDir, sourceMapFile),
|
|
host.getCurrentDirectory(),
|
|
host.getCanonicalFileName,
|
|
true
|
|
)
|
|
);
|
|
} else {
|
|
return encodeURI(combinePaths(sourceMapDir, sourceMapFile));
|
|
}
|
|
}
|
|
return encodeURI(sourceMapFile);
|
|
}
|
|
}
|
|
function createBuildInfo(program, bundle) {
|
|
const version2 = version;
|
|
return { bundle, program, version: version2 };
|
|
}
|
|
function getBuildInfoText(buildInfo) {
|
|
return JSON.stringify(buildInfo);
|
|
}
|
|
function getBuildInfo(buildInfoFile, buildInfoText) {
|
|
return readJsonOrUndefined(buildInfoFile, buildInfoText);
|
|
}
|
|
var notImplementedResolver = {
|
|
hasGlobalName: notImplemented,
|
|
getReferencedExportContainer: notImplemented,
|
|
getReferencedImportDeclaration: notImplemented,
|
|
getReferencedDeclarationWithCollidingName: notImplemented,
|
|
isDeclarationWithCollidingName: notImplemented,
|
|
isValueAliasDeclaration: notImplemented,
|
|
isReferencedAliasDeclaration: notImplemented,
|
|
isTopLevelValueImportEqualsWithEntityName: notImplemented,
|
|
getNodeCheckFlags: notImplemented,
|
|
isDeclarationVisible: notImplemented,
|
|
isLateBound: (_node) => false,
|
|
collectLinkedAliases: notImplemented,
|
|
isImplementationOfOverload: notImplemented,
|
|
isRequiredInitializedParameter: notImplemented,
|
|
isOptionalUninitializedParameterProperty: notImplemented,
|
|
isExpandoFunctionDeclaration: notImplemented,
|
|
getPropertiesOfContainerFunction: notImplemented,
|
|
createTypeOfDeclaration: notImplemented,
|
|
createReturnTypeOfSignatureDeclaration: notImplemented,
|
|
createTypeOfExpression: notImplemented,
|
|
createLiteralConstValue: notImplemented,
|
|
isSymbolAccessible: notImplemented,
|
|
isEntityNameVisible: notImplemented,
|
|
getConstantValue: notImplemented,
|
|
getReferencedValueDeclaration: notImplemented,
|
|
getTypeReferenceSerializationKind: notImplemented,
|
|
isOptionalParameter: notImplemented,
|
|
moduleExportsSomeValue: notImplemented,
|
|
isArgumentsLocalBinding: notImplemented,
|
|
getExternalModuleFileFromDeclaration: notImplemented,
|
|
getTypeReferenceDirectivesForEntityName: notImplemented,
|
|
getTypeReferenceDirectivesForSymbol: notImplemented,
|
|
isLiteralConstDeclaration: notImplemented,
|
|
getJsxFactoryEntity: notImplemented,
|
|
getJsxFragmentFactoryEntity: notImplemented,
|
|
getAllAccessorDeclarations: notImplemented,
|
|
getSymbolOfExternalModuleSpecifier: notImplemented,
|
|
isBindingCapturedByNode: notImplemented,
|
|
getDeclarationStatementsForSourceFile: notImplemented,
|
|
isImportRequiredByAugmentation: notImplemented
|
|
};
|
|
function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host) {
|
|
var _a2;
|
|
const jsBundle = Debug.checkDefined(bundle.js);
|
|
const prologueMap = ((_a2 = jsBundle.sources) == null ? void 0 : _a2.prologues) && arrayToMap(jsBundle.sources.prologues, (prologueInfo) => prologueInfo.file);
|
|
return bundle.sourceFiles.map((fileName, index) => {
|
|
var _a3, _b;
|
|
const prologueInfo = prologueMap == null ? void 0 : prologueMap.get(index);
|
|
const statements = prologueInfo == null ? void 0 : prologueInfo.directives.map((directive) => {
|
|
const literal = setTextRange(factory.createStringLiteral(directive.expression.text), directive.expression);
|
|
const statement = setTextRange(factory.createExpressionStatement(literal), directive);
|
|
setParent(literal, statement);
|
|
return statement;
|
|
});
|
|
const eofToken = factory.createToken(1 /* EndOfFileToken */);
|
|
const sourceFile = factory.createSourceFile(statements != null ? statements : [], eofToken, 0 /* None */);
|
|
sourceFile.fileName = getRelativePathFromDirectory(
|
|
host.getCurrentDirectory(),
|
|
getNormalizedAbsolutePath(fileName, buildInfoDirectory),
|
|
!host.useCaseSensitiveFileNames()
|
|
);
|
|
sourceFile.text = (_a3 = prologueInfo == null ? void 0 : prologueInfo.text) != null ? _a3 : "";
|
|
setTextRangePosWidth(sourceFile, 0, (_b = prologueInfo == null ? void 0 : prologueInfo.text.length) != null ? _b : 0);
|
|
setEachParent(sourceFile.statements, sourceFile);
|
|
setTextRangePosWidth(eofToken, sourceFile.end, 0);
|
|
setParent(eofToken, sourceFile);
|
|
return sourceFile;
|
|
});
|
|
}
|
|
function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Emit, "emitUsingBuildInfo", {}, true);
|
|
ts_performance_exports.mark("beforeEmit");
|
|
const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
|
|
ts_performance_exports.mark("afterEmit");
|
|
ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers) {
|
|
const { buildInfoPath, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath } = getOutputPathsForBundle(config.options, false);
|
|
const buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath);
|
|
if (!buildInfo)
|
|
return buildInfoPath;
|
|
if (!buildInfo.bundle || !buildInfo.bundle.js || declarationFilePath && !buildInfo.bundle.dts)
|
|
return buildInfoPath;
|
|
const jsFileText = host.readFile(Debug.checkDefined(jsFilePath));
|
|
if (!jsFileText)
|
|
return jsFilePath;
|
|
if (computeSignature(jsFileText, host) !== buildInfo.bundle.js.hash)
|
|
return jsFilePath;
|
|
const sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
|
|
if (sourceMapFilePath && !sourceMapText || config.options.inlineSourceMap)
|
|
return sourceMapFilePath || "inline sourcemap decoding";
|
|
if (sourceMapFilePath && computeSignature(sourceMapText, host) !== buildInfo.bundle.js.mapHash)
|
|
return sourceMapFilePath;
|
|
const declarationText = declarationFilePath && host.readFile(declarationFilePath);
|
|
if (declarationFilePath && !declarationText)
|
|
return declarationFilePath;
|
|
if (declarationFilePath && computeSignature(declarationText, host) !== buildInfo.bundle.dts.hash)
|
|
return declarationFilePath;
|
|
const declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
|
|
if (declarationMapPath && !declarationMapText || config.options.inlineSourceMap)
|
|
return declarationMapPath || "inline sourcemap decoding";
|
|
if (declarationMapPath && computeSignature(declarationMapText, host) !== buildInfo.bundle.dts.mapHash)
|
|
return declarationMapPath;
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const ownPrependInput = createInputFilesWithFileTexts(
|
|
jsFilePath,
|
|
jsFileText,
|
|
sourceMapFilePath,
|
|
sourceMapText,
|
|
declarationFilePath,
|
|
declarationText,
|
|
declarationMapPath,
|
|
declarationMapText,
|
|
buildInfoPath,
|
|
buildInfo,
|
|
true
|
|
);
|
|
const outputFiles = [];
|
|
const prependNodes = createPrependNodes(config.projectReferences, getCommandLine, (f) => host.readFile(f), host);
|
|
const sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host);
|
|
let changedDtsText;
|
|
let changedDtsData;
|
|
const emitHost = {
|
|
getPrependNodes: memoize(() => [...prependNodes, ownPrependInput]),
|
|
getCanonicalFileName: host.getCanonicalFileName,
|
|
getCommonSourceDirectory: () => getNormalizedAbsolutePath(buildInfo.bundle.commonSourceDirectory, buildInfoDirectory),
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
getNewLine: () => host.getNewLine(),
|
|
getSourceFile: returnUndefined,
|
|
getSourceFileByPath: returnUndefined,
|
|
getSourceFiles: () => sourceFilesForJsEmit,
|
|
getLibFileFromReference: notImplemented,
|
|
isSourceFileFromExternalLibrary: returnFalse,
|
|
getResolvedProjectReferenceToRedirect: returnUndefined,
|
|
getProjectReferenceRedirect: returnUndefined,
|
|
isSourceOfProjectReferenceRedirect: returnFalse,
|
|
writeFile: (name, text, writeByteOrderMark, _onError, _sourceFiles, data) => {
|
|
switch (name) {
|
|
case jsFilePath:
|
|
if (jsFileText === text)
|
|
return;
|
|
break;
|
|
case sourceMapFilePath:
|
|
if (sourceMapText === text)
|
|
return;
|
|
break;
|
|
case buildInfoPath:
|
|
break;
|
|
case declarationFilePath:
|
|
if (declarationText === text)
|
|
return;
|
|
changedDtsText = text;
|
|
changedDtsData = data;
|
|
break;
|
|
case declarationMapPath:
|
|
if (declarationMapText === text)
|
|
return;
|
|
break;
|
|
default:
|
|
Debug.fail(`Unexpected path: ${name}`);
|
|
}
|
|
outputFiles.push({ name, text, writeByteOrderMark, data });
|
|
},
|
|
isEmitBlocked: returnFalse,
|
|
readFile: (f) => host.readFile(f),
|
|
fileExists: (f) => host.fileExists(f),
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getBuildInfo: (bundle) => {
|
|
const program = buildInfo.program;
|
|
if (program && changedDtsText !== void 0 && config.options.composite) {
|
|
program.outSignature = computeSignature(changedDtsText, host, changedDtsData);
|
|
}
|
|
const { js, dts, sourceFiles } = buildInfo.bundle;
|
|
bundle.js.sources = js.sources;
|
|
if (dts) {
|
|
bundle.dts.sources = dts.sources;
|
|
}
|
|
bundle.sourceFiles = sourceFiles;
|
|
return createBuildInfo(program, bundle);
|
|
},
|
|
getSourceFileFromReference: returnUndefined,
|
|
redirectTargetsMap: createMultiMap(),
|
|
getFileIncludeReasons: notImplemented,
|
|
createHash: maybeBind(host, host.createHash)
|
|
};
|
|
emitFiles(
|
|
notImplementedResolver,
|
|
emitHost,
|
|
void 0,
|
|
getTransformers(config.options, customTransformers)
|
|
);
|
|
return outputFiles;
|
|
}
|
|
function createPrinter(printerOptions = {}, handlers = {}) {
|
|
const {
|
|
hasGlobalName,
|
|
onEmitNode = noEmitNotification,
|
|
isEmitNotificationEnabled,
|
|
substituteNode = noEmitSubstitution,
|
|
onBeforeEmitNode,
|
|
onAfterEmitNode,
|
|
onBeforeEmitNodeArray,
|
|
onAfterEmitNodeArray,
|
|
onBeforeEmitToken,
|
|
onAfterEmitToken
|
|
} = handlers;
|
|
const extendedDiagnostics = !!printerOptions.extendedDiagnostics;
|
|
const newLine = getNewLineCharacter(printerOptions);
|
|
const moduleKind = getEmitModuleKind(printerOptions);
|
|
const bundledHelpers = /* @__PURE__ */ new Map();
|
|
let currentSourceFile;
|
|
let nodeIdToGeneratedName;
|
|
let autoGeneratedIdToGeneratedName;
|
|
let generatedNames;
|
|
let formattedNameTempFlagsStack;
|
|
let formattedNameTempFlags;
|
|
let privateNameTempFlagsStack;
|
|
let privateNameTempFlags;
|
|
let tempFlagsStack;
|
|
let tempFlags;
|
|
let reservedNamesStack;
|
|
let reservedNames;
|
|
let preserveSourceNewlines = printerOptions.preserveSourceNewlines;
|
|
let nextListElementPos;
|
|
let writer;
|
|
let ownWriter;
|
|
let write = writeBase;
|
|
let isOwnFileEmit;
|
|
const bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : void 0;
|
|
const relativeToBuildInfo = bundleFileInfo ? Debug.checkDefined(printerOptions.relativeToBuildInfo) : void 0;
|
|
const recordInternalSection = printerOptions.recordInternalSection;
|
|
let sourceFileTextPos = 0;
|
|
let sourceFileTextKind = "text" /* Text */;
|
|
let sourceMapsDisabled = true;
|
|
let sourceMapGenerator;
|
|
let sourceMapSource;
|
|
let sourceMapSourceIndex = -1;
|
|
let mostRecentlyAddedSourceMapSource;
|
|
let mostRecentlyAddedSourceMapSourceIndex = -1;
|
|
let containerPos = -1;
|
|
let containerEnd = -1;
|
|
let declarationListContainerEnd = -1;
|
|
let currentLineMap;
|
|
let detachedCommentsInfo;
|
|
let hasWrittenComment = false;
|
|
let commentsDisabled = !!printerOptions.removeComments;
|
|
let lastSubstitution;
|
|
let currentParenthesizerRule;
|
|
const { enter: enterComment, exit: exitComment } = createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment");
|
|
const parenthesizer = factory.parenthesizer;
|
|
const typeArgumentParenthesizerRuleSelector = {
|
|
select: (index) => index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : void 0
|
|
};
|
|
const emitBinaryExpression = createEmitBinaryExpression();
|
|
reset2();
|
|
return {
|
|
printNode,
|
|
printList,
|
|
printFile,
|
|
printBundle,
|
|
writeNode,
|
|
writeList,
|
|
writeFile: writeFile2,
|
|
writeBundle,
|
|
bundleFileInfo
|
|
};
|
|
function printNode(hint, node, sourceFile) {
|
|
switch (hint) {
|
|
case 0 /* SourceFile */:
|
|
Debug.assert(isSourceFile(node), "Expected a SourceFile node.");
|
|
break;
|
|
case 2 /* IdentifierName */:
|
|
Debug.assert(isIdentifier(node), "Expected an Identifier node.");
|
|
break;
|
|
case 1 /* Expression */:
|
|
Debug.assert(isExpression(node), "Expected an Expression node.");
|
|
break;
|
|
}
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
return printFile(node);
|
|
case 309 /* Bundle */:
|
|
return printBundle(node);
|
|
case 310 /* UnparsedSource */:
|
|
return printUnparsedSource(node);
|
|
}
|
|
writeNode(hint, node, sourceFile, beginPrint());
|
|
return endPrint();
|
|
}
|
|
function printList(format, nodes, sourceFile) {
|
|
writeList(format, nodes, sourceFile, beginPrint());
|
|
return endPrint();
|
|
}
|
|
function printBundle(bundle) {
|
|
writeBundle(bundle, beginPrint(), void 0);
|
|
return endPrint();
|
|
}
|
|
function printFile(sourceFile) {
|
|
writeFile2(sourceFile, beginPrint(), void 0);
|
|
return endPrint();
|
|
}
|
|
function printUnparsedSource(unparsed) {
|
|
writeUnparsedSource(unparsed, beginPrint());
|
|
return endPrint();
|
|
}
|
|
function writeNode(hint, node, sourceFile, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
print(hint, node, sourceFile);
|
|
reset2();
|
|
writer = previousWriter;
|
|
}
|
|
function writeList(format, nodes, sourceFile, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
if (sourceFile) {
|
|
setSourceFile(sourceFile);
|
|
}
|
|
emitList(void 0, nodes, format);
|
|
reset2();
|
|
writer = previousWriter;
|
|
}
|
|
function getTextPosWithWriteLine() {
|
|
return writer.getTextPosWithWriteLine ? writer.getTextPosWithWriteLine() : writer.getTextPos();
|
|
}
|
|
function updateOrPushBundleFileTextLike(pos, end, kind) {
|
|
const last2 = lastOrUndefined(bundleFileInfo.sections);
|
|
if (last2 && last2.kind === kind) {
|
|
last2.end = end;
|
|
} else {
|
|
bundleFileInfo.sections.push({ pos, end, kind });
|
|
}
|
|
}
|
|
function recordBundleFileInternalSectionStart(node) {
|
|
if (recordInternalSection && bundleFileInfo && currentSourceFile && (isDeclaration(node) || isVariableStatement(node)) && isInternalDeclaration(node, currentSourceFile) && sourceFileTextKind !== "internal" /* Internal */) {
|
|
const prevSourceFileTextKind = sourceFileTextKind;
|
|
recordBundleFileTextLikeSection(writer.getTextPos());
|
|
sourceFileTextPos = getTextPosWithWriteLine();
|
|
sourceFileTextKind = "internal" /* Internal */;
|
|
return prevSourceFileTextKind;
|
|
}
|
|
return void 0;
|
|
}
|
|
function recordBundleFileInternalSectionEnd(prevSourceFileTextKind) {
|
|
if (prevSourceFileTextKind) {
|
|
recordBundleFileTextLikeSection(writer.getTextPos());
|
|
sourceFileTextPos = getTextPosWithWriteLine();
|
|
sourceFileTextKind = prevSourceFileTextKind;
|
|
}
|
|
}
|
|
function recordBundleFileTextLikeSection(end) {
|
|
if (sourceFileTextPos < end) {
|
|
updateOrPushBundleFileTextLike(sourceFileTextPos, end, sourceFileTextKind);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function writeBundle(bundle, output, sourceMapGenerator2) {
|
|
isOwnFileEmit = false;
|
|
const previousWriter = writer;
|
|
setWriter(output, sourceMapGenerator2);
|
|
emitShebangIfNeeded(bundle);
|
|
emitPrologueDirectivesIfNeeded(bundle);
|
|
emitHelpers(bundle);
|
|
emitSyntheticTripleSlashReferencesIfNeeded(bundle);
|
|
for (const prepend of bundle.prepends) {
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
const savedSections = bundleFileInfo && bundleFileInfo.sections;
|
|
if (savedSections)
|
|
bundleFileInfo.sections = [];
|
|
print(4 /* Unspecified */, prepend, void 0);
|
|
if (bundleFileInfo) {
|
|
const newSections = bundleFileInfo.sections;
|
|
bundleFileInfo.sections = savedSections;
|
|
if (prepend.oldFileOfCurrentEmit)
|
|
bundleFileInfo.sections.push(...newSections);
|
|
else {
|
|
newSections.forEach((section) => Debug.assert(isBundleFileTextLike(section)));
|
|
bundleFileInfo.sections.push({
|
|
pos,
|
|
end: writer.getTextPos(),
|
|
kind: "prepend" /* Prepend */,
|
|
data: relativeToBuildInfo(prepend.fileName),
|
|
texts: newSections
|
|
});
|
|
}
|
|
}
|
|
}
|
|
sourceFileTextPos = getTextPosWithWriteLine();
|
|
for (const sourceFile of bundle.sourceFiles) {
|
|
print(0 /* SourceFile */, sourceFile, sourceFile);
|
|
}
|
|
if (bundleFileInfo && bundle.sourceFiles.length) {
|
|
const end = writer.getTextPos();
|
|
if (recordBundleFileTextLikeSection(end)) {
|
|
const prologues = getPrologueDirectivesFromBundledSourceFiles(bundle);
|
|
if (prologues) {
|
|
if (!bundleFileInfo.sources)
|
|
bundleFileInfo.sources = {};
|
|
bundleFileInfo.sources.prologues = prologues;
|
|
}
|
|
const helpers = getHelpersFromBundledSourceFiles(bundle);
|
|
if (helpers) {
|
|
if (!bundleFileInfo.sources)
|
|
bundleFileInfo.sources = {};
|
|
bundleFileInfo.sources.helpers = helpers;
|
|
}
|
|
}
|
|
}
|
|
reset2();
|
|
writer = previousWriter;
|
|
}
|
|
function writeUnparsedSource(unparsed, output) {
|
|
const previousWriter = writer;
|
|
setWriter(output, void 0);
|
|
print(4 /* Unspecified */, unparsed, void 0);
|
|
reset2();
|
|
writer = previousWriter;
|
|
}
|
|
function writeFile2(sourceFile, output, sourceMapGenerator2) {
|
|
isOwnFileEmit = true;
|
|
const previousWriter = writer;
|
|
setWriter(output, sourceMapGenerator2);
|
|
emitShebangIfNeeded(sourceFile);
|
|
emitPrologueDirectivesIfNeeded(sourceFile);
|
|
print(0 /* SourceFile */, sourceFile, sourceFile);
|
|
reset2();
|
|
writer = previousWriter;
|
|
}
|
|
function beginPrint() {
|
|
return ownWriter || (ownWriter = createTextWriter(newLine));
|
|
}
|
|
function endPrint() {
|
|
const text = ownWriter.getText();
|
|
ownWriter.clear();
|
|
return text;
|
|
}
|
|
function print(hint, node, sourceFile) {
|
|
if (sourceFile) {
|
|
setSourceFile(sourceFile);
|
|
}
|
|
pipelineEmit(hint, node, void 0);
|
|
}
|
|
function setSourceFile(sourceFile) {
|
|
currentSourceFile = sourceFile;
|
|
currentLineMap = void 0;
|
|
detachedCommentsInfo = void 0;
|
|
if (sourceFile) {
|
|
setSourceMapSource(sourceFile);
|
|
}
|
|
}
|
|
function setWriter(_writer, _sourceMapGenerator) {
|
|
if (_writer && printerOptions.omitTrailingSemicolon) {
|
|
_writer = getTrailingSemicolonDeferringWriter(_writer);
|
|
}
|
|
writer = _writer;
|
|
sourceMapGenerator = _sourceMapGenerator;
|
|
sourceMapsDisabled = !writer || !sourceMapGenerator;
|
|
}
|
|
function reset2() {
|
|
nodeIdToGeneratedName = [];
|
|
autoGeneratedIdToGeneratedName = [];
|
|
generatedNames = /* @__PURE__ */ new Set();
|
|
formattedNameTempFlagsStack = [];
|
|
formattedNameTempFlags = /* @__PURE__ */ new Map();
|
|
privateNameTempFlagsStack = [];
|
|
privateNameTempFlags = TempFlags.Auto;
|
|
tempFlagsStack = [];
|
|
tempFlags = TempFlags.Auto;
|
|
reservedNamesStack = [];
|
|
currentSourceFile = void 0;
|
|
currentLineMap = void 0;
|
|
detachedCommentsInfo = void 0;
|
|
setWriter(void 0, void 0);
|
|
}
|
|
function getCurrentLineMap() {
|
|
return currentLineMap || (currentLineMap = getLineStarts(Debug.checkDefined(currentSourceFile)));
|
|
}
|
|
function emit(node, parenthesizerRule) {
|
|
if (node === void 0)
|
|
return;
|
|
const prevSourceFileTextKind = recordBundleFileInternalSectionStart(node);
|
|
pipelineEmit(4 /* Unspecified */, node, parenthesizerRule);
|
|
recordBundleFileInternalSectionEnd(prevSourceFileTextKind);
|
|
}
|
|
function emitIdentifierName(node) {
|
|
if (node === void 0)
|
|
return;
|
|
pipelineEmit(2 /* IdentifierName */, node, void 0);
|
|
}
|
|
function emitExpression(node, parenthesizerRule) {
|
|
if (node === void 0)
|
|
return;
|
|
pipelineEmit(1 /* Expression */, node, parenthesizerRule);
|
|
}
|
|
function emitJsxAttributeValue(node) {
|
|
pipelineEmit(isStringLiteral(node) ? 6 /* JsxAttributeValue */ : 4 /* Unspecified */, node);
|
|
}
|
|
function beforeEmitNode(node) {
|
|
if (preserveSourceNewlines && getEmitFlags(node) & 268435456 /* IgnoreSourceNewlines */) {
|
|
preserveSourceNewlines = false;
|
|
}
|
|
}
|
|
function afterEmitNode(savedPreserveSourceNewlines) {
|
|
preserveSourceNewlines = savedPreserveSourceNewlines;
|
|
}
|
|
function pipelineEmit(emitHint, node, parenthesizerRule) {
|
|
currentParenthesizerRule = parenthesizerRule;
|
|
const pipelinePhase = getPipelinePhase(0 /* Notification */, emitHint, node);
|
|
pipelinePhase(emitHint, node);
|
|
currentParenthesizerRule = void 0;
|
|
}
|
|
function shouldEmitComments(node) {
|
|
return !commentsDisabled && !isSourceFile(node);
|
|
}
|
|
function shouldEmitSourceMaps(node) {
|
|
return !sourceMapsDisabled && !isSourceFile(node) && !isInJsonFile(node) && !isUnparsedSource(node) && !isUnparsedPrepend(node);
|
|
}
|
|
function getPipelinePhase(phase, emitHint, node) {
|
|
switch (phase) {
|
|
case 0 /* Notification */:
|
|
if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) {
|
|
return pipelineEmitWithNotification;
|
|
}
|
|
case 1 /* Substitution */:
|
|
if (substituteNode !== noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) {
|
|
if (currentParenthesizerRule) {
|
|
lastSubstitution = currentParenthesizerRule(lastSubstitution);
|
|
}
|
|
return pipelineEmitWithSubstitution;
|
|
}
|
|
case 2 /* Comments */:
|
|
if (shouldEmitComments(node)) {
|
|
return pipelineEmitWithComments;
|
|
}
|
|
case 3 /* SourceMaps */:
|
|
if (shouldEmitSourceMaps(node)) {
|
|
return pipelineEmitWithSourceMaps;
|
|
}
|
|
case 4 /* Emit */:
|
|
return pipelineEmitWithHint;
|
|
default:
|
|
return Debug.assertNever(phase);
|
|
}
|
|
}
|
|
function getNextPipelinePhase(currentPhase, emitHint, node) {
|
|
return getPipelinePhase(currentPhase + 1, emitHint, node);
|
|
}
|
|
function pipelineEmitWithNotification(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(0 /* Notification */, hint, node);
|
|
onEmitNode(hint, node, pipelinePhase);
|
|
}
|
|
function pipelineEmitWithHint(hint, node) {
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(node);
|
|
if (preserveSourceNewlines) {
|
|
const savedPreserveSourceNewlines = preserveSourceNewlines;
|
|
beforeEmitNode(node);
|
|
pipelineEmitWithHintWorker(hint, node);
|
|
afterEmitNode(savedPreserveSourceNewlines);
|
|
} else {
|
|
pipelineEmitWithHintWorker(hint, node);
|
|
}
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(node);
|
|
currentParenthesizerRule = void 0;
|
|
}
|
|
function pipelineEmitWithHintWorker(hint, node, allowSnippets = true) {
|
|
if (allowSnippets) {
|
|
const snippet = getSnippetElement(node);
|
|
if (snippet) {
|
|
return emitSnippetNode(hint, node, snippet);
|
|
}
|
|
}
|
|
if (hint === 0 /* SourceFile */)
|
|
return emitSourceFile(cast(node, isSourceFile));
|
|
if (hint === 2 /* IdentifierName */)
|
|
return emitIdentifier(cast(node, isIdentifier));
|
|
if (hint === 6 /* JsxAttributeValue */)
|
|
return emitLiteral(cast(node, isStringLiteral), true);
|
|
if (hint === 3 /* MappedTypeParameter */)
|
|
return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
|
|
if (hint === 5 /* EmbeddedStatement */) {
|
|
Debug.assertNode(node, isEmptyStatement);
|
|
return emitEmptyStatement(true);
|
|
}
|
|
if (hint === 4 /* Unspecified */) {
|
|
switch (node.kind) {
|
|
case 15 /* TemplateHead */:
|
|
case 16 /* TemplateMiddle */:
|
|
case 17 /* TemplateTail */:
|
|
return emitLiteral(node, false);
|
|
case 79 /* Identifier */:
|
|
return emitIdentifier(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return emitPrivateIdentifier(node);
|
|
case 163 /* QualifiedName */:
|
|
return emitQualifiedName(node);
|
|
case 164 /* ComputedPropertyName */:
|
|
return emitComputedPropertyName(node);
|
|
case 165 /* TypeParameter */:
|
|
return emitTypeParameter(node);
|
|
case 166 /* Parameter */:
|
|
return emitParameter(node);
|
|
case 167 /* Decorator */:
|
|
return emitDecorator(node);
|
|
case 168 /* PropertySignature */:
|
|
return emitPropertySignature(node);
|
|
case 169 /* PropertyDeclaration */:
|
|
return emitPropertyDeclaration(node);
|
|
case 170 /* MethodSignature */:
|
|
return emitMethodSignature(node);
|
|
case 171 /* MethodDeclaration */:
|
|
return emitMethodDeclaration(node);
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return emitClassStaticBlockDeclaration(node);
|
|
case 173 /* Constructor */:
|
|
return emitConstructor(node);
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return emitAccessorDeclaration(node);
|
|
case 176 /* CallSignature */:
|
|
return emitCallSignature(node);
|
|
case 177 /* ConstructSignature */:
|
|
return emitConstructSignature(node);
|
|
case 178 /* IndexSignature */:
|
|
return emitIndexSignature(node);
|
|
case 179 /* TypePredicate */:
|
|
return emitTypePredicate(node);
|
|
case 180 /* TypeReference */:
|
|
return emitTypeReference(node);
|
|
case 181 /* FunctionType */:
|
|
return emitFunctionType(node);
|
|
case 182 /* ConstructorType */:
|
|
return emitConstructorType(node);
|
|
case 183 /* TypeQuery */:
|
|
return emitTypeQuery(node);
|
|
case 184 /* TypeLiteral */:
|
|
return emitTypeLiteral(node);
|
|
case 185 /* ArrayType */:
|
|
return emitArrayType(node);
|
|
case 186 /* TupleType */:
|
|
return emitTupleType(node);
|
|
case 187 /* OptionalType */:
|
|
return emitOptionalType(node);
|
|
case 189 /* UnionType */:
|
|
return emitUnionType(node);
|
|
case 190 /* IntersectionType */:
|
|
return emitIntersectionType(node);
|
|
case 191 /* ConditionalType */:
|
|
return emitConditionalType(node);
|
|
case 192 /* InferType */:
|
|
return emitInferType(node);
|
|
case 193 /* ParenthesizedType */:
|
|
return emitParenthesizedType(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return emitExpressionWithTypeArguments(node);
|
|
case 194 /* ThisType */:
|
|
return emitThisType();
|
|
case 195 /* TypeOperator */:
|
|
return emitTypeOperator(node);
|
|
case 196 /* IndexedAccessType */:
|
|
return emitIndexedAccessType(node);
|
|
case 197 /* MappedType */:
|
|
return emitMappedType(node);
|
|
case 198 /* LiteralType */:
|
|
return emitLiteralType(node);
|
|
case 199 /* NamedTupleMember */:
|
|
return emitNamedTupleMember(node);
|
|
case 200 /* TemplateLiteralType */:
|
|
return emitTemplateType(node);
|
|
case 201 /* TemplateLiteralTypeSpan */:
|
|
return emitTemplateTypeSpan(node);
|
|
case 202 /* ImportType */:
|
|
return emitImportTypeNode(node);
|
|
case 203 /* ObjectBindingPattern */:
|
|
return emitObjectBindingPattern(node);
|
|
case 204 /* ArrayBindingPattern */:
|
|
return emitArrayBindingPattern(node);
|
|
case 205 /* BindingElement */:
|
|
return emitBindingElement(node);
|
|
case 236 /* TemplateSpan */:
|
|
return emitTemplateSpan(node);
|
|
case 237 /* SemicolonClassElement */:
|
|
return emitSemicolonClassElement();
|
|
case 238 /* Block */:
|
|
return emitBlock(node);
|
|
case 240 /* VariableStatement */:
|
|
return emitVariableStatement(node);
|
|
case 239 /* EmptyStatement */:
|
|
return emitEmptyStatement(false);
|
|
case 241 /* ExpressionStatement */:
|
|
return emitExpressionStatement(node);
|
|
case 242 /* IfStatement */:
|
|
return emitIfStatement(node);
|
|
case 243 /* DoStatement */:
|
|
return emitDoStatement(node);
|
|
case 244 /* WhileStatement */:
|
|
return emitWhileStatement(node);
|
|
case 245 /* ForStatement */:
|
|
return emitForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return emitForInStatement(node);
|
|
case 247 /* ForOfStatement */:
|
|
return emitForOfStatement(node);
|
|
case 248 /* ContinueStatement */:
|
|
return emitContinueStatement(node);
|
|
case 249 /* BreakStatement */:
|
|
return emitBreakStatement(node);
|
|
case 250 /* ReturnStatement */:
|
|
return emitReturnStatement(node);
|
|
case 251 /* WithStatement */:
|
|
return emitWithStatement(node);
|
|
case 252 /* SwitchStatement */:
|
|
return emitSwitchStatement(node);
|
|
case 253 /* LabeledStatement */:
|
|
return emitLabeledStatement(node);
|
|
case 254 /* ThrowStatement */:
|
|
return emitThrowStatement(node);
|
|
case 255 /* TryStatement */:
|
|
return emitTryStatement(node);
|
|
case 256 /* DebuggerStatement */:
|
|
return emitDebuggerStatement(node);
|
|
case 257 /* VariableDeclaration */:
|
|
return emitVariableDeclaration(node);
|
|
case 258 /* VariableDeclarationList */:
|
|
return emitVariableDeclarationList(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
return emitFunctionDeclaration(node);
|
|
case 260 /* ClassDeclaration */:
|
|
return emitClassDeclaration(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return emitInterfaceDeclaration(node);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return emitTypeAliasDeclaration(node);
|
|
case 263 /* EnumDeclaration */:
|
|
return emitEnumDeclaration(node);
|
|
case 264 /* ModuleDeclaration */:
|
|
return emitModuleDeclaration(node);
|
|
case 265 /* ModuleBlock */:
|
|
return emitModuleBlock(node);
|
|
case 266 /* CaseBlock */:
|
|
return emitCaseBlock(node);
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
return emitNamespaceExportDeclaration(node);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return emitImportEqualsDeclaration(node);
|
|
case 269 /* ImportDeclaration */:
|
|
return emitImportDeclaration(node);
|
|
case 270 /* ImportClause */:
|
|
return emitImportClause(node);
|
|
case 271 /* NamespaceImport */:
|
|
return emitNamespaceImport(node);
|
|
case 277 /* NamespaceExport */:
|
|
return emitNamespaceExport(node);
|
|
case 272 /* NamedImports */:
|
|
return emitNamedImports(node);
|
|
case 273 /* ImportSpecifier */:
|
|
return emitImportSpecifier(node);
|
|
case 274 /* ExportAssignment */:
|
|
return emitExportAssignment(node);
|
|
case 275 /* ExportDeclaration */:
|
|
return emitExportDeclaration(node);
|
|
case 276 /* NamedExports */:
|
|
return emitNamedExports(node);
|
|
case 278 /* ExportSpecifier */:
|
|
return emitExportSpecifier(node);
|
|
case 296 /* AssertClause */:
|
|
return emitAssertClause(node);
|
|
case 297 /* AssertEntry */:
|
|
return emitAssertEntry(node);
|
|
case 279 /* MissingDeclaration */:
|
|
return;
|
|
case 280 /* ExternalModuleReference */:
|
|
return emitExternalModuleReference(node);
|
|
case 11 /* JsxText */:
|
|
return emitJsxText(node);
|
|
case 283 /* JsxOpeningElement */:
|
|
case 286 /* JsxOpeningFragment */:
|
|
return emitJsxOpeningElementOrFragment(node);
|
|
case 284 /* JsxClosingElement */:
|
|
case 287 /* JsxClosingFragment */:
|
|
return emitJsxClosingElementOrFragment(node);
|
|
case 288 /* JsxAttribute */:
|
|
return emitJsxAttribute(node);
|
|
case 289 /* JsxAttributes */:
|
|
return emitJsxAttributes(node);
|
|
case 290 /* JsxSpreadAttribute */:
|
|
return emitJsxSpreadAttribute(node);
|
|
case 291 /* JsxExpression */:
|
|
return emitJsxExpression(node);
|
|
case 292 /* CaseClause */:
|
|
return emitCaseClause(node);
|
|
case 293 /* DefaultClause */:
|
|
return emitDefaultClause(node);
|
|
case 294 /* HeritageClause */:
|
|
return emitHeritageClause(node);
|
|
case 295 /* CatchClause */:
|
|
return emitCatchClause(node);
|
|
case 299 /* PropertyAssignment */:
|
|
return emitPropertyAssignment(node);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return emitShorthandPropertyAssignment(node);
|
|
case 301 /* SpreadAssignment */:
|
|
return emitSpreadAssignment(node);
|
|
case 302 /* EnumMember */:
|
|
return emitEnumMember(node);
|
|
case 303 /* UnparsedPrologue */:
|
|
return writeUnparsedNode(node);
|
|
case 310 /* UnparsedSource */:
|
|
case 304 /* UnparsedPrepend */:
|
|
return emitUnparsedSourceOrPrepend(node);
|
|
case 305 /* UnparsedText */:
|
|
case 306 /* UnparsedInternalText */:
|
|
return emitUnparsedTextLike(node);
|
|
case 307 /* UnparsedSyntheticReference */:
|
|
return emitUnparsedSyntheticReference(node);
|
|
case 308 /* SourceFile */:
|
|
return emitSourceFile(node);
|
|
case 309 /* Bundle */:
|
|
return Debug.fail("Bundles should be printed using printBundle");
|
|
case 311 /* InputFiles */:
|
|
return Debug.fail("InputFiles should not be printed");
|
|
case 312 /* JSDocTypeExpression */:
|
|
return emitJSDocTypeExpression(node);
|
|
case 313 /* JSDocNameReference */:
|
|
return emitJSDocNameReference(node);
|
|
case 315 /* JSDocAllType */:
|
|
return writePunctuation("*");
|
|
case 316 /* JSDocUnknownType */:
|
|
return writePunctuation("?");
|
|
case 317 /* JSDocNullableType */:
|
|
return emitJSDocNullableType(node);
|
|
case 318 /* JSDocNonNullableType */:
|
|
return emitJSDocNonNullableType(node);
|
|
case 319 /* JSDocOptionalType */:
|
|
return emitJSDocOptionalType(node);
|
|
case 320 /* JSDocFunctionType */:
|
|
return emitJSDocFunctionType(node);
|
|
case 188 /* RestType */:
|
|
case 321 /* JSDocVariadicType */:
|
|
return emitRestOrJSDocVariadicType(node);
|
|
case 322 /* JSDocNamepathType */:
|
|
return;
|
|
case 323 /* JSDoc */:
|
|
return emitJSDoc(node);
|
|
case 325 /* JSDocTypeLiteral */:
|
|
return emitJSDocTypeLiteral(node);
|
|
case 326 /* JSDocSignature */:
|
|
return emitJSDocSignature(node);
|
|
case 330 /* JSDocTag */:
|
|
case 335 /* JSDocClassTag */:
|
|
case 340 /* JSDocOverrideTag */:
|
|
return emitJSDocSimpleTag(node);
|
|
case 331 /* JSDocAugmentsTag */:
|
|
case 332 /* JSDocImplementsTag */:
|
|
return emitJSDocHeritageTag(node);
|
|
case 333 /* JSDocAuthorTag */:
|
|
case 334 /* JSDocDeprecatedTag */:
|
|
return;
|
|
case 336 /* JSDocPublicTag */:
|
|
case 337 /* JSDocPrivateTag */:
|
|
case 338 /* JSDocProtectedTag */:
|
|
case 339 /* JSDocReadonlyTag */:
|
|
return;
|
|
case 341 /* JSDocCallbackTag */:
|
|
return emitJSDocCallbackTag(node);
|
|
case 343 /* JSDocParameterTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
return emitJSDocPropertyLikeTag(node);
|
|
case 342 /* JSDocEnumTag */:
|
|
case 344 /* JSDocReturnTag */:
|
|
case 345 /* JSDocThisTag */:
|
|
case 346 /* JSDocTypeTag */:
|
|
return emitJSDocSimpleTypedTag(node);
|
|
case 347 /* JSDocTemplateTag */:
|
|
return emitJSDocTemplateTag(node);
|
|
case 348 /* JSDocTypedefTag */:
|
|
return emitJSDocTypedefTag(node);
|
|
case 349 /* JSDocSeeTag */:
|
|
return emitJSDocSeeTag(node);
|
|
case 352 /* NotEmittedStatement */:
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
case 355 /* MergeDeclarationMarker */:
|
|
return;
|
|
}
|
|
if (isExpression(node)) {
|
|
hint = 1 /* Expression */;
|
|
if (substituteNode !== noEmitSubstitution) {
|
|
const substitute = substituteNode(hint, node) || node;
|
|
if (substitute !== node) {
|
|
node = substitute;
|
|
if (currentParenthesizerRule) {
|
|
node = currentParenthesizerRule(node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (hint === 1 /* Expression */) {
|
|
switch (node.kind) {
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
return emitNumericOrBigIntLiteral(node);
|
|
case 10 /* StringLiteral */:
|
|
case 13 /* RegularExpressionLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return emitLiteral(node, false);
|
|
case 79 /* Identifier */:
|
|
return emitIdentifier(node);
|
|
case 80 /* PrivateIdentifier */:
|
|
return emitPrivateIdentifier(node);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return emitArrayLiteralExpression(node);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return emitObjectLiteralExpression(node);
|
|
case 208 /* PropertyAccessExpression */:
|
|
return emitPropertyAccessExpression(node);
|
|
case 209 /* ElementAccessExpression */:
|
|
return emitElementAccessExpression(node);
|
|
case 210 /* CallExpression */:
|
|
return emitCallExpression(node);
|
|
case 211 /* NewExpression */:
|
|
return emitNewExpression(node);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return emitTaggedTemplateExpression(node);
|
|
case 213 /* TypeAssertionExpression */:
|
|
return emitTypeAssertionExpression(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return emitParenthesizedExpression(node);
|
|
case 215 /* FunctionExpression */:
|
|
return emitFunctionExpression(node);
|
|
case 216 /* ArrowFunction */:
|
|
return emitArrowFunction(node);
|
|
case 217 /* DeleteExpression */:
|
|
return emitDeleteExpression(node);
|
|
case 218 /* TypeOfExpression */:
|
|
return emitTypeOfExpression(node);
|
|
case 219 /* VoidExpression */:
|
|
return emitVoidExpression(node);
|
|
case 220 /* AwaitExpression */:
|
|
return emitAwaitExpression(node);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return emitPrefixUnaryExpression(node);
|
|
case 222 /* PostfixUnaryExpression */:
|
|
return emitPostfixUnaryExpression(node);
|
|
case 223 /* BinaryExpression */:
|
|
return emitBinaryExpression(node);
|
|
case 224 /* ConditionalExpression */:
|
|
return emitConditionalExpression(node);
|
|
case 225 /* TemplateExpression */:
|
|
return emitTemplateExpression(node);
|
|
case 226 /* YieldExpression */:
|
|
return emitYieldExpression(node);
|
|
case 227 /* SpreadElement */:
|
|
return emitSpreadElement(node);
|
|
case 228 /* ClassExpression */:
|
|
return emitClassExpression(node);
|
|
case 229 /* OmittedExpression */:
|
|
return;
|
|
case 231 /* AsExpression */:
|
|
return emitAsExpression(node);
|
|
case 232 /* NonNullExpression */:
|
|
return emitNonNullExpression(node);
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return emitExpressionWithTypeArguments(node);
|
|
case 235 /* SatisfiesExpression */:
|
|
return emitSatisfiesExpression(node);
|
|
case 233 /* MetaProperty */:
|
|
return emitMetaProperty(node);
|
|
case 234 /* SyntheticExpression */:
|
|
return Debug.fail("SyntheticExpression should never be printed.");
|
|
case 281 /* JsxElement */:
|
|
return emitJsxElement(node);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return emitJsxSelfClosingElement(node);
|
|
case 285 /* JsxFragment */:
|
|
return emitJsxFragment(node);
|
|
case 351 /* SyntaxList */:
|
|
return Debug.fail("SyntaxList should not be printed");
|
|
case 352 /* NotEmittedStatement */:
|
|
return;
|
|
case 353 /* PartiallyEmittedExpression */:
|
|
return emitPartiallyEmittedExpression(node);
|
|
case 354 /* CommaListExpression */:
|
|
return emitCommaList(node);
|
|
case 355 /* MergeDeclarationMarker */:
|
|
case 356 /* EndOfDeclarationMarker */:
|
|
return;
|
|
case 357 /* SyntheticReferenceExpression */:
|
|
return Debug.fail("SyntheticReferenceExpression should not be printed");
|
|
}
|
|
}
|
|
if (isKeyword(node.kind))
|
|
return writeTokenNode(node, writeKeyword);
|
|
if (isTokenKind(node.kind))
|
|
return writeTokenNode(node, writePunctuation);
|
|
Debug.fail(`Unhandled SyntaxKind: ${Debug.formatSyntaxKind(node.kind)}.`);
|
|
}
|
|
function emitMappedTypeParameter(node) {
|
|
emit(node.name);
|
|
writeSpace();
|
|
writeKeyword("in");
|
|
writeSpace();
|
|
emit(node.constraint);
|
|
}
|
|
function pipelineEmitWithSubstitution(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(1 /* Substitution */, hint, node);
|
|
Debug.assertIsDefined(lastSubstitution);
|
|
node = lastSubstitution;
|
|
lastSubstitution = void 0;
|
|
pipelinePhase(hint, node);
|
|
}
|
|
function getHelpersFromBundledSourceFiles(bundle) {
|
|
let result;
|
|
if (moduleKind === 0 /* None */ || printerOptions.noEmitHelpers) {
|
|
return void 0;
|
|
}
|
|
const bundledHelpers2 = /* @__PURE__ */ new Map();
|
|
for (const sourceFile of bundle.sourceFiles) {
|
|
const shouldSkip = getExternalHelpersModuleName(sourceFile) !== void 0;
|
|
const helpers = getSortedEmitHelpers(sourceFile);
|
|
if (!helpers)
|
|
continue;
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped && !shouldSkip && !bundledHelpers2.get(helper.name)) {
|
|
bundledHelpers2.set(helper.name, true);
|
|
(result || (result = [])).push(helper.name);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function emitHelpers(node) {
|
|
let helpersEmitted = false;
|
|
const bundle = node.kind === 309 /* Bundle */ ? node : void 0;
|
|
if (bundle && moduleKind === 0 /* None */) {
|
|
return;
|
|
}
|
|
const numPrepends = bundle ? bundle.prepends.length : 0;
|
|
const numNodes = bundle ? bundle.sourceFiles.length + numPrepends : 1;
|
|
for (let i = 0; i < numNodes; i++) {
|
|
const currentNode = bundle ? i < numPrepends ? bundle.prepends[i] : bundle.sourceFiles[i - numPrepends] : node;
|
|
const sourceFile = isSourceFile(currentNode) ? currentNode : isUnparsedSource(currentNode) ? void 0 : currentSourceFile;
|
|
const shouldSkip = printerOptions.noEmitHelpers || !!sourceFile && hasRecordedExternalHelpers(sourceFile);
|
|
const shouldBundle = (isSourceFile(currentNode) || isUnparsedSource(currentNode)) && !isOwnFileEmit;
|
|
const helpers = isUnparsedSource(currentNode) ? currentNode.helpers : getSortedEmitHelpers(currentNode);
|
|
if (helpers) {
|
|
for (const helper of helpers) {
|
|
if (!helper.scoped) {
|
|
if (shouldSkip)
|
|
continue;
|
|
if (shouldBundle) {
|
|
if (bundledHelpers.get(helper.name)) {
|
|
continue;
|
|
}
|
|
bundledHelpers.set(helper.name, true);
|
|
}
|
|
} else if (bundle) {
|
|
continue;
|
|
}
|
|
const pos = getTextPosWithWriteLine();
|
|
if (typeof helper.text === "string") {
|
|
writeLines(helper.text);
|
|
} else {
|
|
writeLines(helper.text(makeFileLevelOptimisticUniqueName));
|
|
}
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "emitHelpers" /* EmitHelpers */, data: helper.name });
|
|
helpersEmitted = true;
|
|
}
|
|
}
|
|
}
|
|
return helpersEmitted;
|
|
}
|
|
function getSortedEmitHelpers(node) {
|
|
const helpers = getEmitHelpers(node);
|
|
return helpers && stableSort(helpers, compareEmitHelpers);
|
|
}
|
|
function emitNumericOrBigIntLiteral(node) {
|
|
emitLiteral(node, false);
|
|
}
|
|
function emitLiteral(node, jsxAttributeEscape) {
|
|
const text = getLiteralTextOfNode(node, printerOptions.neverAsciiEscape, jsxAttributeEscape);
|
|
if ((printerOptions.sourceMap || printerOptions.inlineSourceMap) && (node.kind === 10 /* StringLiteral */ || isTemplateLiteralKind(node.kind))) {
|
|
writeLiteral(text);
|
|
} else {
|
|
writeStringLiteral(text);
|
|
}
|
|
}
|
|
function emitUnparsedSourceOrPrepend(unparsed) {
|
|
for (const text of unparsed.texts) {
|
|
writeLine();
|
|
emit(text);
|
|
}
|
|
}
|
|
function writeUnparsedNode(unparsed) {
|
|
writer.rawWrite(unparsed.parent.text.substring(unparsed.pos, unparsed.end));
|
|
}
|
|
function emitUnparsedTextLike(unparsed) {
|
|
const pos = getTextPosWithWriteLine();
|
|
writeUnparsedNode(unparsed);
|
|
if (bundleFileInfo) {
|
|
updateOrPushBundleFileTextLike(
|
|
pos,
|
|
writer.getTextPos(),
|
|
unparsed.kind === 305 /* UnparsedText */ ? "text" /* Text */ : "internal" /* Internal */
|
|
);
|
|
}
|
|
}
|
|
function emitUnparsedSyntheticReference(unparsed) {
|
|
const pos = getTextPosWithWriteLine();
|
|
writeUnparsedNode(unparsed);
|
|
if (bundleFileInfo) {
|
|
const section = clone(unparsed.section);
|
|
section.pos = pos;
|
|
section.end = writer.getTextPos();
|
|
bundleFileInfo.sections.push(section);
|
|
}
|
|
}
|
|
function emitSnippetNode(hint, node, snippet) {
|
|
switch (snippet.kind) {
|
|
case 1 /* Placeholder */:
|
|
emitPlaceholder(hint, node, snippet);
|
|
break;
|
|
case 0 /* TabStop */:
|
|
emitTabStop(hint, node, snippet);
|
|
break;
|
|
}
|
|
}
|
|
function emitPlaceholder(hint, node, snippet) {
|
|
nonEscapingWrite(`\${${snippet.order}:`);
|
|
pipelineEmitWithHintWorker(hint, node, false);
|
|
nonEscapingWrite(`}`);
|
|
}
|
|
function emitTabStop(hint, node, snippet) {
|
|
Debug.assert(
|
|
node.kind === 239 /* EmptyStatement */,
|
|
`A tab stop cannot be attached to a node of kind ${Debug.formatSyntaxKind(node.kind)}.`
|
|
);
|
|
Debug.assert(
|
|
hint !== 5 /* EmbeddedStatement */,
|
|
`A tab stop cannot be attached to an embedded statement.`
|
|
);
|
|
nonEscapingWrite(`$${snippet.order}`);
|
|
}
|
|
function emitIdentifier(node) {
|
|
const writeText = node.symbol ? writeSymbol : write;
|
|
writeText(getTextOfNode2(node, false), node.symbol);
|
|
emitList(node, node.typeArguments, 53776 /* TypeParameters */);
|
|
}
|
|
function emitPrivateIdentifier(node) {
|
|
const writeText = node.symbol ? writeSymbol : write;
|
|
writeText(getTextOfNode2(node, false), node.symbol);
|
|
}
|
|
function emitQualifiedName(node) {
|
|
emitEntityName(node.left);
|
|
writePunctuation(".");
|
|
emit(node.right);
|
|
}
|
|
function emitEntityName(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitComputedPropertyName(node) {
|
|
writePunctuation("[");
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName);
|
|
writePunctuation("]");
|
|
}
|
|
function emitTypeParameter(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emit(node.name);
|
|
if (node.constraint) {
|
|
writeSpace();
|
|
writeKeyword("extends");
|
|
writeSpace();
|
|
emit(node.constraint);
|
|
}
|
|
if (node.default) {
|
|
writeSpace();
|
|
writeOperator("=");
|
|
writeSpace();
|
|
emit(node.default);
|
|
}
|
|
}
|
|
function emitParameter(node) {
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
emit(node.dotDotDotToken);
|
|
emitNodeWithWriter(node.name, writeParameter);
|
|
emit(node.questionToken);
|
|
if (node.parent && node.parent.kind === 320 /* JSDocFunctionType */ && !node.name) {
|
|
emit(node.type);
|
|
} else {
|
|
emitTypeAnnotation(node.type);
|
|
}
|
|
emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name ? node.name.end : node.modifiers ? node.modifiers.end : node.pos, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitDecorator(decorator) {
|
|
writePunctuation("@");
|
|
emitExpression(decorator.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
}
|
|
function emitPropertySignature(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitNodeWithWriter(node.name, writeProperty);
|
|
emit(node.questionToken);
|
|
emitTypeAnnotation(node.type);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitPropertyDeclaration(node) {
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
emit(node.name);
|
|
emit(node.questionToken);
|
|
emit(node.exclamationToken);
|
|
emitTypeAnnotation(node.type);
|
|
emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name.end, node);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitMethodSignature(node) {
|
|
pushNameGenerationScope(node);
|
|
emitModifiers(node, node.modifiers);
|
|
emit(node.name);
|
|
emit(node.questionToken);
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
writeTrailingSemicolon();
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitMethodDeclaration(node) {
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
emit(node.asteriskToken);
|
|
emit(node.name);
|
|
emit(node.questionToken);
|
|
emitSignatureAndBody(node, emitSignatureHead);
|
|
}
|
|
function emitClassStaticBlockDeclaration(node) {
|
|
writeKeyword("static");
|
|
emitBlockFunctionBody(node.body);
|
|
}
|
|
function emitConstructor(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("constructor");
|
|
emitSignatureAndBody(node, emitSignatureHead);
|
|
}
|
|
function emitAccessorDeclaration(node) {
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
writeKeyword(node.kind === 174 /* GetAccessor */ ? "get" : "set");
|
|
writeSpace();
|
|
emit(node.name);
|
|
emitSignatureAndBody(node, emitSignatureHead);
|
|
}
|
|
function emitCallSignature(node) {
|
|
pushNameGenerationScope(node);
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
writeTrailingSemicolon();
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitConstructSignature(node) {
|
|
pushNameGenerationScope(node);
|
|
writeKeyword("new");
|
|
writeSpace();
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
writeTrailingSemicolon();
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitIndexSignature(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitParametersForIndexSignature(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTemplateTypeSpan(node) {
|
|
emit(node.type);
|
|
emit(node.literal);
|
|
}
|
|
function emitSemicolonClassElement() {
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTypePredicate(node) {
|
|
if (node.assertsModifier) {
|
|
emit(node.assertsModifier);
|
|
writeSpace();
|
|
}
|
|
emit(node.parameterName);
|
|
if (node.type) {
|
|
writeSpace();
|
|
writeKeyword("is");
|
|
writeSpace();
|
|
emit(node.type);
|
|
}
|
|
}
|
|
function emitTypeReference(node) {
|
|
emit(node.typeName);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
}
|
|
function emitFunctionType(node) {
|
|
pushNameGenerationScope(node);
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParametersForArrow(node, node.parameters);
|
|
writeSpace();
|
|
writePunctuation("=>");
|
|
writeSpace();
|
|
emit(node.type);
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitJSDocFunctionType(node) {
|
|
writeKeyword("function");
|
|
emitParameters(node, node.parameters);
|
|
writePunctuation(":");
|
|
emit(node.type);
|
|
}
|
|
function emitJSDocNullableType(node) {
|
|
writePunctuation("?");
|
|
emit(node.type);
|
|
}
|
|
function emitJSDocNonNullableType(node) {
|
|
writePunctuation("!");
|
|
emit(node.type);
|
|
}
|
|
function emitJSDocOptionalType(node) {
|
|
emit(node.type);
|
|
writePunctuation("=");
|
|
}
|
|
function emitConstructorType(node) {
|
|
pushNameGenerationScope(node);
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("new");
|
|
writeSpace();
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
writeSpace();
|
|
writePunctuation("=>");
|
|
writeSpace();
|
|
emit(node.type);
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitTypeQuery(node) {
|
|
writeKeyword("typeof");
|
|
writeSpace();
|
|
emit(node.exprName);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
}
|
|
function emitTypeLiteral(node) {
|
|
writePunctuation("{");
|
|
const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineTypeLiteralMembers */ : 32897 /* MultiLineTypeLiteralMembers */;
|
|
emitList(node, node.members, flags | 524288 /* NoSpaceIfEmpty */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitArrayType(node) {
|
|
emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
|
|
writePunctuation("[");
|
|
writePunctuation("]");
|
|
}
|
|
function emitRestOrJSDocVariadicType(node) {
|
|
writePunctuation("...");
|
|
emit(node.type);
|
|
}
|
|
function emitTupleType(node) {
|
|
emitTokenWithComment(22 /* OpenBracketToken */, node.pos, writePunctuation, node);
|
|
const flags = getEmitFlags(node) & 1 /* SingleLine */ ? 528 /* SingleLineTupleTypeElements */ : 657 /* MultiLineTupleTypeElements */;
|
|
emitList(node, node.elements, flags | 524288 /* NoSpaceIfEmpty */, parenthesizer.parenthesizeElementTypeOfTupleType);
|
|
emitTokenWithComment(23 /* CloseBracketToken */, node.elements.end, writePunctuation, node);
|
|
}
|
|
function emitNamedTupleMember(node) {
|
|
emit(node.dotDotDotToken);
|
|
emit(node.name);
|
|
emit(node.questionToken);
|
|
emitTokenWithComment(58 /* ColonToken */, node.name.end, writePunctuation, node);
|
|
writeSpace();
|
|
emit(node.type);
|
|
}
|
|
function emitOptionalType(node) {
|
|
emit(node.type, parenthesizer.parenthesizeTypeOfOptionalType);
|
|
writePunctuation("?");
|
|
}
|
|
function emitUnionType(node) {
|
|
emitList(node, node.types, 516 /* UnionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfUnionType);
|
|
}
|
|
function emitIntersectionType(node) {
|
|
emitList(node, node.types, 520 /* IntersectionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfIntersectionType);
|
|
}
|
|
function emitConditionalType(node) {
|
|
emit(node.checkType, parenthesizer.parenthesizeCheckTypeOfConditionalType);
|
|
writeSpace();
|
|
writeKeyword("extends");
|
|
writeSpace();
|
|
emit(node.extendsType, parenthesizer.parenthesizeExtendsTypeOfConditionalType);
|
|
writeSpace();
|
|
writePunctuation("?");
|
|
writeSpace();
|
|
emit(node.trueType);
|
|
writeSpace();
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
emit(node.falseType);
|
|
}
|
|
function emitInferType(node) {
|
|
writeKeyword("infer");
|
|
writeSpace();
|
|
emit(node.typeParameter);
|
|
}
|
|
function emitParenthesizedType(node) {
|
|
writePunctuation("(");
|
|
emit(node.type);
|
|
writePunctuation(")");
|
|
}
|
|
function emitThisType() {
|
|
writeKeyword("this");
|
|
}
|
|
function emitTypeOperator(node) {
|
|
writeTokenText(node.operator, writeKeyword);
|
|
writeSpace();
|
|
const parenthesizerRule = node.operator === 146 /* ReadonlyKeyword */ ? parenthesizer.parenthesizeOperandOfReadonlyTypeOperator : parenthesizer.parenthesizeOperandOfTypeOperator;
|
|
emit(node.type, parenthesizerRule);
|
|
}
|
|
function emitIndexedAccessType(node) {
|
|
emit(node.objectType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType);
|
|
writePunctuation("[");
|
|
emit(node.indexType);
|
|
writePunctuation("]");
|
|
}
|
|
function emitMappedType(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
writePunctuation("{");
|
|
if (emitFlags & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else {
|
|
writeLine();
|
|
increaseIndent();
|
|
}
|
|
if (node.readonlyToken) {
|
|
emit(node.readonlyToken);
|
|
if (node.readonlyToken.kind !== 146 /* ReadonlyKeyword */) {
|
|
writeKeyword("readonly");
|
|
}
|
|
writeSpace();
|
|
}
|
|
writePunctuation("[");
|
|
pipelineEmit(3 /* MappedTypeParameter */, node.typeParameter);
|
|
if (node.nameType) {
|
|
writeSpace();
|
|
writeKeyword("as");
|
|
writeSpace();
|
|
emit(node.nameType);
|
|
}
|
|
writePunctuation("]");
|
|
if (node.questionToken) {
|
|
emit(node.questionToken);
|
|
if (node.questionToken.kind !== 57 /* QuestionToken */) {
|
|
writePunctuation("?");
|
|
}
|
|
}
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
emit(node.type);
|
|
writeTrailingSemicolon();
|
|
if (emitFlags & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else {
|
|
writeLine();
|
|
decreaseIndent();
|
|
}
|
|
emitList(node, node.members, 2 /* PreserveLines */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitLiteralType(node) {
|
|
emitExpression(node.literal);
|
|
}
|
|
function emitTemplateType(node) {
|
|
emit(node.head);
|
|
emitList(node, node.templateSpans, 262144 /* TemplateExpressionSpans */);
|
|
}
|
|
function emitImportTypeNode(node) {
|
|
if (node.isTypeOf) {
|
|
writeKeyword("typeof");
|
|
writeSpace();
|
|
}
|
|
writeKeyword("import");
|
|
writePunctuation("(");
|
|
emit(node.argument);
|
|
if (node.assertions) {
|
|
writePunctuation(",");
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
writeSpace();
|
|
writeKeyword("assert");
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
const elements = node.assertions.assertClause.elements;
|
|
emitList(node.assertions.assertClause, elements, 526226 /* ImportClauseEntries */);
|
|
writeSpace();
|
|
writePunctuation("}");
|
|
}
|
|
writePunctuation(")");
|
|
if (node.qualifier) {
|
|
writePunctuation(".");
|
|
emit(node.qualifier);
|
|
}
|
|
emitTypeArguments(node, node.typeArguments);
|
|
}
|
|
function emitObjectBindingPattern(node) {
|
|
writePunctuation("{");
|
|
emitList(node, node.elements, 525136 /* ObjectBindingPatternElements */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitArrayBindingPattern(node) {
|
|
writePunctuation("[");
|
|
emitList(node, node.elements, 524880 /* ArrayBindingPatternElements */);
|
|
writePunctuation("]");
|
|
}
|
|
function emitBindingElement(node) {
|
|
emit(node.dotDotDotToken);
|
|
if (node.propertyName) {
|
|
emit(node.propertyName);
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
emitInitializer(node.initializer, node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitArrayLiteralExpression(node) {
|
|
const elements = node.elements;
|
|
const preferNewLine = node.multiLine ? 65536 /* PreferNewLine */ : 0 /* None */;
|
|
emitExpressionList(node, elements, 8914 /* ArrayLiteralExpressionElements */ | preferNewLine, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitObjectLiteralExpression(node) {
|
|
forEach(node.properties, generateMemberNames);
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
const preferNewLine = node.multiLine ? 65536 /* PreferNewLine */ : 0 /* None */;
|
|
const allowTrailingComma = currentSourceFile && currentSourceFile.languageVersion >= 1 /* ES5 */ && !isJsonSourceFile(currentSourceFile) ? 64 /* AllowTrailingComma */ : 0 /* None */;
|
|
emitList(node, node.properties, 526226 /* ObjectLiteralExpressionProperties */ | allowTrailingComma | preferNewLine);
|
|
if (indentedFlag) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function emitPropertyAccessExpression(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
const token = node.questionDotToken || setTextRangePosEnd(factory.createToken(24 /* DotToken */), node.expression.end, node.name.pos);
|
|
const linesBeforeDot = getLinesBetweenNodes(node, node.expression, token);
|
|
const linesAfterDot = getLinesBetweenNodes(node, token, node.name);
|
|
writeLinesAndIndent(linesBeforeDot, false);
|
|
const shouldEmitDotDot = token.kind !== 28 /* QuestionDotToken */ && mayNeedDotDotForPropertyAccess(node.expression) && !writer.hasTrailingComment() && !writer.hasTrailingWhitespace();
|
|
if (shouldEmitDotDot) {
|
|
writePunctuation(".");
|
|
}
|
|
if (node.questionDotToken) {
|
|
emit(token);
|
|
} else {
|
|
emitTokenWithComment(token.kind, node.expression.end, writePunctuation, node);
|
|
}
|
|
writeLinesAndIndent(linesAfterDot, false);
|
|
emit(node.name);
|
|
decreaseIndentIf(linesBeforeDot, linesAfterDot);
|
|
}
|
|
function mayNeedDotDotForPropertyAccess(expression) {
|
|
expression = skipPartiallyEmittedExpressions(expression);
|
|
if (isNumericLiteral(expression)) {
|
|
const text = getLiteralTextOfNode(expression, true, false);
|
|
return !expression.numericLiteralFlags && !stringContains(text, tokenToString(24 /* DotToken */));
|
|
} else if (isAccessExpression(expression)) {
|
|
const constantValue = getConstantValue(expression);
|
|
return typeof constantValue === "number" && isFinite(constantValue) && Math.floor(constantValue) === constantValue;
|
|
}
|
|
}
|
|
function emitElementAccessExpression(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
emit(node.questionDotToken);
|
|
emitTokenWithComment(22 /* OpenBracketToken */, node.expression.end, writePunctuation, node);
|
|
emitExpression(node.argumentExpression);
|
|
emitTokenWithComment(23 /* CloseBracketToken */, node.argumentExpression.end, writePunctuation, node);
|
|
}
|
|
function emitCallExpression(node) {
|
|
const indirectCall = getEmitFlags(node) & 1073741824 /* IndirectCall */;
|
|
if (indirectCall) {
|
|
writePunctuation("(");
|
|
writeLiteral("0");
|
|
writePunctuation(",");
|
|
writeSpace();
|
|
}
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
if (indirectCall) {
|
|
writePunctuation(")");
|
|
}
|
|
emit(node.questionDotToken);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
emitExpressionList(node, node.arguments, 2576 /* CallExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitNewExpression(node) {
|
|
emitTokenWithComment(103 /* NewKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfNew);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
emitExpressionList(node, node.arguments, 18960 /* NewExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitTaggedTemplateExpression(node) {
|
|
const indirectCall = getEmitFlags(node) & 1073741824 /* IndirectCall */;
|
|
if (indirectCall) {
|
|
writePunctuation("(");
|
|
writeLiteral("0");
|
|
writePunctuation(",");
|
|
writeSpace();
|
|
}
|
|
emitExpression(node.tag, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
if (indirectCall) {
|
|
writePunctuation(")");
|
|
}
|
|
emitTypeArguments(node, node.typeArguments);
|
|
writeSpace();
|
|
emitExpression(node.template);
|
|
}
|
|
function emitTypeAssertionExpression(node) {
|
|
writePunctuation("<");
|
|
emit(node.type);
|
|
writePunctuation(">");
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitParenthesizedExpression(node) {
|
|
const openParenPos = emitTokenWithComment(20 /* OpenParenToken */, node.pos, writePunctuation, node);
|
|
const indented = writeLineSeparatorsAndIndentBefore(node.expression, node);
|
|
emitExpression(node.expression, void 0);
|
|
writeLineSeparatorsAfter(node.expression, node);
|
|
decreaseIndentIf(indented);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression ? node.expression.end : openParenPos, writePunctuation, node);
|
|
}
|
|
function emitFunctionExpression(node) {
|
|
generateNameIfNeeded(node.name);
|
|
emitFunctionDeclarationOrExpression(node);
|
|
}
|
|
function emitArrowFunction(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitSignatureAndBody(node, emitArrowFunctionHead);
|
|
}
|
|
function emitArrowFunctionHead(node) {
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParametersForArrow(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
writeSpace();
|
|
emit(node.equalsGreaterThanToken);
|
|
}
|
|
function emitDeleteExpression(node) {
|
|
emitTokenWithComment(89 /* DeleteKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitTypeOfExpression(node) {
|
|
emitTokenWithComment(112 /* TypeOfKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitVoidExpression(node) {
|
|
emitTokenWithComment(114 /* VoidKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitAwaitExpression(node) {
|
|
emitTokenWithComment(133 /* AwaitKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function emitPrefixUnaryExpression(node) {
|
|
writeTokenText(node.operator, writeOperator);
|
|
if (shouldEmitWhitespaceBeforeOperand(node)) {
|
|
writeSpace();
|
|
}
|
|
emitExpression(node.operand, parenthesizer.parenthesizeOperandOfPrefixUnary);
|
|
}
|
|
function shouldEmitWhitespaceBeforeOperand(node) {
|
|
const operand = node.operand;
|
|
return operand.kind === 221 /* PrefixUnaryExpression */ && (node.operator === 39 /* PlusToken */ && (operand.operator === 39 /* PlusToken */ || operand.operator === 45 /* PlusPlusToken */) || node.operator === 40 /* MinusToken */ && (operand.operator === 40 /* MinusToken */ || operand.operator === 46 /* MinusMinusToken */));
|
|
}
|
|
function emitPostfixUnaryExpression(node) {
|
|
emitExpression(node.operand, parenthesizer.parenthesizeOperandOfPostfixUnary);
|
|
writeTokenText(node.operator, writeOperator);
|
|
}
|
|
function createEmitBinaryExpression() {
|
|
return createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, void 0);
|
|
function onEnter(node, state) {
|
|
if (state) {
|
|
state.stackIndex++;
|
|
state.preserveSourceNewlinesStack[state.stackIndex] = preserveSourceNewlines;
|
|
state.containerPosStack[state.stackIndex] = containerPos;
|
|
state.containerEndStack[state.stackIndex] = containerEnd;
|
|
state.declarationListContainerEndStack[state.stackIndex] = declarationListContainerEnd;
|
|
const emitComments2 = state.shouldEmitCommentsStack[state.stackIndex] = shouldEmitComments(node);
|
|
const emitSourceMaps = state.shouldEmitSourceMapsStack[state.stackIndex] = shouldEmitSourceMaps(node);
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(node);
|
|
if (emitComments2)
|
|
emitCommentsBeforeNode(node);
|
|
if (emitSourceMaps)
|
|
emitSourceMapsBeforeNode(node);
|
|
beforeEmitNode(node);
|
|
} else {
|
|
state = {
|
|
stackIndex: 0,
|
|
preserveSourceNewlinesStack: [void 0],
|
|
containerPosStack: [-1],
|
|
containerEndStack: [-1],
|
|
declarationListContainerEndStack: [-1],
|
|
shouldEmitCommentsStack: [false],
|
|
shouldEmitSourceMapsStack: [false]
|
|
};
|
|
}
|
|
return state;
|
|
}
|
|
function onLeft(next, _workArea, parent2) {
|
|
return maybeEmitExpression(next, parent2, "left");
|
|
}
|
|
function onOperator(operatorToken, _state, node) {
|
|
const isCommaOperator = operatorToken.kind !== 27 /* CommaToken */;
|
|
const linesBeforeOperator = getLinesBetweenNodes(node, node.left, operatorToken);
|
|
const linesAfterOperator = getLinesBetweenNodes(node, operatorToken, node.right);
|
|
writeLinesAndIndent(linesBeforeOperator, isCommaOperator);
|
|
emitLeadingCommentsOfPosition(operatorToken.pos);
|
|
writeTokenNode(operatorToken, operatorToken.kind === 101 /* InKeyword */ ? writeKeyword : writeOperator);
|
|
emitTrailingCommentsOfPosition(operatorToken.end, true);
|
|
writeLinesAndIndent(linesAfterOperator, true);
|
|
}
|
|
function onRight(next, _workArea, parent2) {
|
|
return maybeEmitExpression(next, parent2, "right");
|
|
}
|
|
function onExit(node, state) {
|
|
const linesBeforeOperator = getLinesBetweenNodes(node, node.left, node.operatorToken);
|
|
const linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right);
|
|
decreaseIndentIf(linesBeforeOperator, linesAfterOperator);
|
|
if (state.stackIndex > 0) {
|
|
const savedPreserveSourceNewlines = state.preserveSourceNewlinesStack[state.stackIndex];
|
|
const savedContainerPos = state.containerPosStack[state.stackIndex];
|
|
const savedContainerEnd = state.containerEndStack[state.stackIndex];
|
|
const savedDeclarationListContainerEnd = state.declarationListContainerEndStack[state.stackIndex];
|
|
const shouldEmitComments2 = state.shouldEmitCommentsStack[state.stackIndex];
|
|
const shouldEmitSourceMaps2 = state.shouldEmitSourceMapsStack[state.stackIndex];
|
|
afterEmitNode(savedPreserveSourceNewlines);
|
|
if (shouldEmitSourceMaps2)
|
|
emitSourceMapsAfterNode(node);
|
|
if (shouldEmitComments2)
|
|
emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(node);
|
|
state.stackIndex--;
|
|
}
|
|
}
|
|
function maybeEmitExpression(next, parent2, side) {
|
|
const parenthesizerRule = side === "left" ? parenthesizer.getParenthesizeLeftSideOfBinaryForOperator(parent2.operatorToken.kind) : parenthesizer.getParenthesizeRightSideOfBinaryForOperator(parent2.operatorToken.kind);
|
|
let pipelinePhase = getPipelinePhase(0 /* Notification */, 1 /* Expression */, next);
|
|
if (pipelinePhase === pipelineEmitWithSubstitution) {
|
|
Debug.assertIsDefined(lastSubstitution);
|
|
next = parenthesizerRule(cast(lastSubstitution, isExpression));
|
|
pipelinePhase = getNextPipelinePhase(1 /* Substitution */, 1 /* Expression */, next);
|
|
lastSubstitution = void 0;
|
|
}
|
|
if (pipelinePhase === pipelineEmitWithComments || pipelinePhase === pipelineEmitWithSourceMaps || pipelinePhase === pipelineEmitWithHint) {
|
|
if (isBinaryExpression(next)) {
|
|
return next;
|
|
}
|
|
}
|
|
currentParenthesizerRule = parenthesizerRule;
|
|
pipelinePhase(1 /* Expression */, next);
|
|
}
|
|
}
|
|
function emitConditionalExpression(node) {
|
|
const linesBeforeQuestion = getLinesBetweenNodes(node, node.condition, node.questionToken);
|
|
const linesAfterQuestion = getLinesBetweenNodes(node, node.questionToken, node.whenTrue);
|
|
const linesBeforeColon = getLinesBetweenNodes(node, node.whenTrue, node.colonToken);
|
|
const linesAfterColon = getLinesBetweenNodes(node, node.colonToken, node.whenFalse);
|
|
emitExpression(node.condition, parenthesizer.parenthesizeConditionOfConditionalExpression);
|
|
writeLinesAndIndent(linesBeforeQuestion, true);
|
|
emit(node.questionToken);
|
|
writeLinesAndIndent(linesAfterQuestion, true);
|
|
emitExpression(node.whenTrue, parenthesizer.parenthesizeBranchOfConditionalExpression);
|
|
decreaseIndentIf(linesBeforeQuestion, linesAfterQuestion);
|
|
writeLinesAndIndent(linesBeforeColon, true);
|
|
emit(node.colonToken);
|
|
writeLinesAndIndent(linesAfterColon, true);
|
|
emitExpression(node.whenFalse, parenthesizer.parenthesizeBranchOfConditionalExpression);
|
|
decreaseIndentIf(linesBeforeColon, linesAfterColon);
|
|
}
|
|
function emitTemplateExpression(node) {
|
|
emit(node.head);
|
|
emitList(node, node.templateSpans, 262144 /* TemplateExpressionSpans */);
|
|
}
|
|
function emitYieldExpression(node) {
|
|
emitTokenWithComment(125 /* YieldKeyword */, node.pos, writeKeyword, node);
|
|
emit(node.asteriskToken);
|
|
emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsiAndDisallowedComma);
|
|
}
|
|
function emitSpreadElement(node) {
|
|
emitTokenWithComment(25 /* DotDotDotToken */, node.pos, writePunctuation, node);
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitClassExpression(node) {
|
|
generateNameIfNeeded(node.name);
|
|
emitClassDeclarationOrExpression(node);
|
|
}
|
|
function emitExpressionWithTypeArguments(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
}
|
|
function emitAsExpression(node) {
|
|
emitExpression(node.expression, void 0);
|
|
if (node.type) {
|
|
writeSpace();
|
|
writeKeyword("as");
|
|
writeSpace();
|
|
emit(node.type);
|
|
}
|
|
}
|
|
function emitNonNullExpression(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess);
|
|
writeOperator("!");
|
|
}
|
|
function emitSatisfiesExpression(node) {
|
|
emitExpression(node.expression, void 0);
|
|
if (node.type) {
|
|
writeSpace();
|
|
writeKeyword("satisfies");
|
|
writeSpace();
|
|
emit(node.type);
|
|
}
|
|
}
|
|
function emitMetaProperty(node) {
|
|
writeToken(node.keywordToken, node.pos, writePunctuation);
|
|
writePunctuation(".");
|
|
emit(node.name);
|
|
}
|
|
function emitTemplateSpan(node) {
|
|
emitExpression(node.expression);
|
|
emit(node.literal);
|
|
}
|
|
function emitBlock(node) {
|
|
emitBlockStatements(node, !node.multiLine && isEmptyBlock(node));
|
|
}
|
|
function emitBlockStatements(node, forceSingleLine) {
|
|
emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
const format = forceSingleLine || getEmitFlags(node) & 1 /* SingleLine */ ? 768 /* SingleLineBlockStatements */ : 129 /* MultiLineBlockStatements */;
|
|
emitList(node, node.statements, format);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, node.statements.end, writePunctuation, node, !!(format & 1 /* MultiLine */));
|
|
}
|
|
function emitVariableStatement(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emit(node.declarationList);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitEmptyStatement(isEmbeddedStatement) {
|
|
if (isEmbeddedStatement) {
|
|
writePunctuation(";");
|
|
} else {
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitExpressionStatement(node) {
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfExpressionStatement);
|
|
if (!currentSourceFile || !isJsonSourceFile(currentSourceFile) || nodeIsSynthesized(node.expression)) {
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitIfStatement(node) {
|
|
const openParenPos = emitTokenWithComment(99 /* IfKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.thenStatement);
|
|
if (node.elseStatement) {
|
|
writeLineOrSpace(node, node.thenStatement, node.elseStatement);
|
|
emitTokenWithComment(91 /* ElseKeyword */, node.thenStatement.end, writeKeyword, node);
|
|
if (node.elseStatement.kind === 242 /* IfStatement */) {
|
|
writeSpace();
|
|
emit(node.elseStatement);
|
|
} else {
|
|
emitEmbeddedStatement(node, node.elseStatement);
|
|
}
|
|
}
|
|
}
|
|
function emitWhileClause(node, startPos) {
|
|
const openParenPos = emitTokenWithComment(115 /* WhileKeyword */, startPos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
}
|
|
function emitDoStatement(node) {
|
|
emitTokenWithComment(90 /* DoKeyword */, node.pos, writeKeyword, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
if (isBlock(node.statement) && !preserveSourceNewlines) {
|
|
writeSpace();
|
|
} else {
|
|
writeLineOrSpace(node, node.statement, node.expression);
|
|
}
|
|
emitWhileClause(node, node.statement.end);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitWhileStatement(node) {
|
|
emitWhileClause(node, node.pos);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForStatement(node) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
let pos = emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
pos = emitTokenWithComment(26 /* SemicolonToken */, node.initializer ? node.initializer.end : pos, writePunctuation, node);
|
|
emitExpressionWithLeadingSpace(node.condition);
|
|
pos = emitTokenWithComment(26 /* SemicolonToken */, node.condition ? node.condition.end : pos, writePunctuation, node);
|
|
emitExpressionWithLeadingSpace(node.incrementor);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.incrementor ? node.incrementor.end : pos, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForInStatement(node) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
writeSpace();
|
|
emitTokenWithComment(101 /* InKeyword */, node.initializer.end, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForOfStatement(node) {
|
|
const openParenPos = emitTokenWithComment(97 /* ForKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitWithTrailingSpace(node.awaitModifier);
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitForBinding(node.initializer);
|
|
writeSpace();
|
|
emitTokenWithComment(162 /* OfKeyword */, node.initializer.end, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitForBinding(node) {
|
|
if (node !== void 0) {
|
|
if (node.kind === 258 /* VariableDeclarationList */) {
|
|
emit(node);
|
|
} else {
|
|
emitExpression(node);
|
|
}
|
|
}
|
|
}
|
|
function emitContinueStatement(node) {
|
|
emitTokenWithComment(86 /* ContinueKeyword */, node.pos, writeKeyword, node);
|
|
emitWithLeadingSpace(node.label);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitBreakStatement(node) {
|
|
emitTokenWithComment(81 /* BreakKeyword */, node.pos, writeKeyword, node);
|
|
emitWithLeadingSpace(node.label);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTokenWithComment(token, pos, writer2, contextNode, indentLeading) {
|
|
const node = getParseTreeNode(contextNode);
|
|
const isSimilarNode = node && node.kind === contextNode.kind;
|
|
const startPos = pos;
|
|
if (isSimilarNode && currentSourceFile) {
|
|
pos = skipTrivia(currentSourceFile.text, pos);
|
|
}
|
|
if (isSimilarNode && contextNode.pos !== startPos) {
|
|
const needsIndent = indentLeading && currentSourceFile && !positionsAreOnSameLine(startPos, pos, currentSourceFile);
|
|
if (needsIndent) {
|
|
increaseIndent();
|
|
}
|
|
emitLeadingCommentsOfPosition(startPos);
|
|
if (needsIndent) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
pos = writeTokenText(token, writer2, pos);
|
|
if (isSimilarNode && contextNode.end !== pos) {
|
|
const isJsxExprContext = contextNode.kind === 291 /* JsxExpression */;
|
|
emitTrailingCommentsOfPosition(pos, !isJsxExprContext, isJsxExprContext);
|
|
}
|
|
return pos;
|
|
}
|
|
function commentWillEmitNewLine(node) {
|
|
return node.kind === 2 /* SingleLineCommentTrivia */ || !!node.hasTrailingNewLine;
|
|
}
|
|
function willEmitLeadingNewLine(node) {
|
|
if (!currentSourceFile)
|
|
return false;
|
|
if (some(getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
|
|
return true;
|
|
if (some(getSyntheticLeadingComments(node), commentWillEmitNewLine))
|
|
return true;
|
|
if (isPartiallyEmittedExpression(node)) {
|
|
if (node.pos !== node.expression.pos) {
|
|
if (some(getTrailingCommentRanges(currentSourceFile.text, node.expression.pos), commentWillEmitNewLine))
|
|
return true;
|
|
}
|
|
return willEmitLeadingNewLine(node.expression);
|
|
}
|
|
return false;
|
|
}
|
|
function parenthesizeExpressionForNoAsi(node) {
|
|
if (!commentsDisabled && isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) {
|
|
const parseNode = getParseTreeNode(node);
|
|
if (parseNode && isParenthesizedExpression(parseNode)) {
|
|
const parens = factory.createParenthesizedExpression(node.expression);
|
|
setOriginalNode(parens, node);
|
|
setTextRange(parens, parseNode);
|
|
return parens;
|
|
}
|
|
return factory.createParenthesizedExpression(node);
|
|
}
|
|
return node;
|
|
}
|
|
function parenthesizeExpressionForNoAsiAndDisallowedComma(node) {
|
|
return parenthesizeExpressionForNoAsi(parenthesizer.parenthesizeExpressionForDisallowedComma(node));
|
|
}
|
|
function emitReturnStatement(node) {
|
|
emitTokenWithComment(105 /* ReturnKeyword */, node.pos, writeKeyword, node);
|
|
emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitWithStatement(node) {
|
|
const openParenPos = emitTokenWithComment(116 /* WithKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
emitEmbeddedStatement(node, node.statement);
|
|
}
|
|
function emitSwitchStatement(node) {
|
|
const openParenPos = emitTokenWithComment(107 /* SwitchKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.expression.end, writePunctuation, node);
|
|
writeSpace();
|
|
emit(node.caseBlock);
|
|
}
|
|
function emitLabeledStatement(node) {
|
|
emit(node.label);
|
|
emitTokenWithComment(58 /* ColonToken */, node.label.end, writePunctuation, node);
|
|
writeSpace();
|
|
emit(node.statement);
|
|
}
|
|
function emitThrowStatement(node) {
|
|
emitTokenWithComment(109 /* ThrowKeyword */, node.pos, writeKeyword, node);
|
|
emitExpressionWithLeadingSpace(parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitTryStatement(node) {
|
|
emitTokenWithComment(111 /* TryKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.tryBlock);
|
|
if (node.catchClause) {
|
|
writeLineOrSpace(node, node.tryBlock, node.catchClause);
|
|
emit(node.catchClause);
|
|
}
|
|
if (node.finallyBlock) {
|
|
writeLineOrSpace(node, node.catchClause || node.tryBlock, node.finallyBlock);
|
|
emitTokenWithComment(96 /* FinallyKeyword */, (node.catchClause || node.tryBlock).end, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.finallyBlock);
|
|
}
|
|
}
|
|
function emitDebuggerStatement(node) {
|
|
writeToken(87 /* DebuggerKeyword */, node.pos, writeKeyword);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitVariableDeclaration(node) {
|
|
var _a2, _b, _c, _d, _e;
|
|
emit(node.name);
|
|
emit(node.exclamationToken);
|
|
emitTypeAnnotation(node.type);
|
|
emitInitializer(node.initializer, (_e = (_d = (_a2 = node.type) == null ? void 0 : _a2.end) != null ? _d : (_c = (_b = node.name.emitNode) == null ? void 0 : _b.typeNode) == null ? void 0 : _c.end) != null ? _e : node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitVariableDeclarationList(node) {
|
|
writeKeyword(isLet(node) ? "let" : isVarConst(node) ? "const" : "var");
|
|
writeSpace();
|
|
emitList(node, node.declarations, 528 /* VariableDeclarationList */);
|
|
}
|
|
function emitFunctionDeclaration(node) {
|
|
emitFunctionDeclarationOrExpression(node);
|
|
}
|
|
function emitFunctionDeclarationOrExpression(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("function");
|
|
emit(node.asteriskToken);
|
|
writeSpace();
|
|
emitIdentifierName(node.name);
|
|
emitSignatureAndBody(node, emitSignatureHead);
|
|
}
|
|
function emitSignatureAndBody(node, emitSignatureHead2) {
|
|
const body = node.body;
|
|
if (body) {
|
|
if (isBlock(body)) {
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
pushNameGenerationScope(node);
|
|
forEach(node.parameters, generateNames);
|
|
generateNames(node.body);
|
|
emitSignatureHead2(node);
|
|
emitBlockFunctionBody(body);
|
|
popNameGenerationScope(node);
|
|
if (indentedFlag) {
|
|
decreaseIndent();
|
|
}
|
|
} else {
|
|
emitSignatureHead2(node);
|
|
writeSpace();
|
|
emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction);
|
|
}
|
|
} else {
|
|
emitSignatureHead2(node);
|
|
writeTrailingSemicolon();
|
|
}
|
|
}
|
|
function emitSignatureHead(node) {
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitParameters(node, node.parameters);
|
|
emitTypeAnnotation(node.type);
|
|
}
|
|
function shouldEmitBlockFunctionBodyOnSingleLine(body) {
|
|
if (getEmitFlags(body) & 1 /* SingleLine */) {
|
|
return true;
|
|
}
|
|
if (body.multiLine) {
|
|
return false;
|
|
}
|
|
if (!nodeIsSynthesized(body) && currentSourceFile && !rangeIsOnSingleLine(body, currentSourceFile)) {
|
|
return false;
|
|
}
|
|
if (getLeadingLineTerminatorCount(body, firstOrUndefined(body.statements), 2 /* PreserveLines */) || getClosingLineTerminatorCount(body, lastOrUndefined(body.statements), 2 /* PreserveLines */, body.statements)) {
|
|
return false;
|
|
}
|
|
let previousStatement;
|
|
for (const statement of body.statements) {
|
|
if (getSeparatingLineTerminatorCount(previousStatement, statement, 2 /* PreserveLines */) > 0) {
|
|
return false;
|
|
}
|
|
previousStatement = statement;
|
|
}
|
|
return true;
|
|
}
|
|
function emitBlockFunctionBody(body) {
|
|
onBeforeEmitNode == null ? void 0 : onBeforeEmitNode(body);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
increaseIndent();
|
|
const emitBlockFunctionBody2 = shouldEmitBlockFunctionBodyOnSingleLine(body) ? emitBlockFunctionBodyOnSingleLine : emitBlockFunctionBodyWorker;
|
|
emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody2);
|
|
decreaseIndent();
|
|
writeToken(19 /* CloseBraceToken */, body.statements.end, writePunctuation, body);
|
|
onAfterEmitNode == null ? void 0 : onAfterEmitNode(body);
|
|
}
|
|
function emitBlockFunctionBodyOnSingleLine(body) {
|
|
emitBlockFunctionBodyWorker(body, true);
|
|
}
|
|
function emitBlockFunctionBodyWorker(body, emitBlockFunctionBodyOnSingleLine2) {
|
|
const statementOffset = emitPrologueDirectives(body.statements);
|
|
const pos = writer.getTextPos();
|
|
emitHelpers(body);
|
|
if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine2) {
|
|
decreaseIndent();
|
|
emitList(body, body.statements, 768 /* SingleLineFunctionBodyStatements */);
|
|
increaseIndent();
|
|
} else {
|
|
emitList(body, body.statements, 1 /* MultiLineFunctionBodyStatements */, void 0, statementOffset);
|
|
}
|
|
}
|
|
function emitClassDeclaration(node) {
|
|
emitClassDeclarationOrExpression(node);
|
|
}
|
|
function emitClassDeclarationOrExpression(node) {
|
|
forEach(node.members, generateMemberNames);
|
|
emitDecoratorsAndModifiers(node, node.modifiers);
|
|
writeKeyword("class");
|
|
if (node.name) {
|
|
writeSpace();
|
|
emitIdentifierName(node.name);
|
|
}
|
|
const indentedFlag = getEmitFlags(node) & 131072 /* Indented */;
|
|
if (indentedFlag) {
|
|
increaseIndent();
|
|
}
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitList(node, node.heritageClauses, 0 /* ClassHeritageClauses */);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emitList(node, node.members, 129 /* ClassMembers */);
|
|
writePunctuation("}");
|
|
if (indentedFlag) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function emitInterfaceDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("interface");
|
|
writeSpace();
|
|
emit(node.name);
|
|
emitTypeParameters(node, node.typeParameters);
|
|
emitList(node, node.heritageClauses, 512 /* HeritageClauses */);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emitList(node, node.members, 129 /* InterfaceMembers */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitTypeAliasDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("type");
|
|
writeSpace();
|
|
emit(node.name);
|
|
emitTypeParameters(node, node.typeParameters);
|
|
writeSpace();
|
|
writePunctuation("=");
|
|
writeSpace();
|
|
emit(node.type);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitEnumDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
writeKeyword("enum");
|
|
writeSpace();
|
|
emit(node.name);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emitList(node, node.members, 145 /* EnumMembers */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitModuleDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
if (~node.flags & 1024 /* GlobalAugmentation */) {
|
|
writeKeyword(node.flags & 16 /* Namespace */ ? "namespace" : "module");
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
let body = node.body;
|
|
if (!body)
|
|
return writeTrailingSemicolon();
|
|
while (body && isModuleDeclaration(body)) {
|
|
writePunctuation(".");
|
|
emit(body.name);
|
|
body = body.body;
|
|
}
|
|
writeSpace();
|
|
emit(body);
|
|
}
|
|
function emitModuleBlock(node) {
|
|
pushNameGenerationScope(node);
|
|
forEach(node.statements, generateNames);
|
|
emitBlockStatements(node, isEmptyBlock(node));
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitCaseBlock(node) {
|
|
emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
emitList(node, node.clauses, 129 /* CaseBlockClauses */);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, node.clauses.end, writePunctuation, node, true);
|
|
}
|
|
function emitImportEqualsDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitTokenWithComment(100 /* ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isTypeOnly) {
|
|
emitTokenWithComment(154 /* TypeKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
writeSpace();
|
|
emitTokenWithComment(63 /* EqualsToken */, node.name.end, writePunctuation, node);
|
|
writeSpace();
|
|
emitModuleReference(node.moduleReference);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitModuleReference(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitImportDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
emitTokenWithComment(100 /* ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.importClause) {
|
|
emit(node.importClause);
|
|
writeSpace();
|
|
emitTokenWithComment(158 /* FromKeyword */, node.importClause.end, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emitExpression(node.moduleSpecifier);
|
|
if (node.assertClause) {
|
|
emitWithLeadingSpace(node.assertClause);
|
|
}
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitImportClause(node) {
|
|
if (node.isTypeOnly) {
|
|
emitTokenWithComment(154 /* TypeKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
if (node.name && node.namedBindings) {
|
|
emitTokenWithComment(27 /* CommaToken */, node.name.end, writePunctuation, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.namedBindings);
|
|
}
|
|
function emitNamespaceImport(node) {
|
|
const asPos = emitTokenWithComment(41 /* AsteriskToken */, node.pos, writePunctuation, node);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* AsKeyword */, asPos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.name);
|
|
}
|
|
function emitNamedImports(node) {
|
|
emitNamedImportsOrExports(node);
|
|
}
|
|
function emitImportSpecifier(node) {
|
|
emitImportOrExportSpecifier(node);
|
|
}
|
|
function emitExportAssignment(node) {
|
|
const nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isExportEquals) {
|
|
emitTokenWithComment(63 /* EqualsToken */, nextPos, writeOperator, node);
|
|
} else {
|
|
emitTokenWithComment(88 /* DefaultKeyword */, nextPos, writeKeyword, node);
|
|
}
|
|
writeSpace();
|
|
emitExpression(node.expression, node.isExportEquals ? parenthesizer.getParenthesizeRightSideOfBinaryForOperator(63 /* EqualsToken */) : parenthesizer.parenthesizeExpressionOfExportDefault);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitExportDeclaration(node) {
|
|
emitModifiers(node, node.modifiers);
|
|
let nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.isTypeOnly) {
|
|
nextPos = emitTokenWithComment(154 /* TypeKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
if (node.exportClause) {
|
|
emit(node.exportClause);
|
|
} else {
|
|
nextPos = emitTokenWithComment(41 /* AsteriskToken */, nextPos, writePunctuation, node);
|
|
}
|
|
if (node.moduleSpecifier) {
|
|
writeSpace();
|
|
const fromPos = node.exportClause ? node.exportClause.end : nextPos;
|
|
emitTokenWithComment(158 /* FromKeyword */, fromPos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.moduleSpecifier);
|
|
}
|
|
if (node.assertClause) {
|
|
emitWithLeadingSpace(node.assertClause);
|
|
}
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitAssertClause(node) {
|
|
emitTokenWithComment(130 /* AssertKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
const elements = node.elements;
|
|
emitList(node, elements, 526226 /* ImportClauseEntries */);
|
|
}
|
|
function emitAssertEntry(node) {
|
|
emit(node.name);
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
const value = node.value;
|
|
if ((getEmitFlags(value) & 1024 /* NoLeadingComments */) === 0) {
|
|
const commentRange = getCommentRange(value);
|
|
emitTrailingCommentsOfPosition(commentRange.pos);
|
|
}
|
|
emit(value);
|
|
}
|
|
function emitNamespaceExportDeclaration(node) {
|
|
let nextPos = emitTokenWithComment(93 /* ExportKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
nextPos = emitTokenWithComment(128 /* AsKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
nextPos = emitTokenWithComment(143 /* NamespaceKeyword */, nextPos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.name);
|
|
writeTrailingSemicolon();
|
|
}
|
|
function emitNamespaceExport(node) {
|
|
const asPos = emitTokenWithComment(41 /* AsteriskToken */, node.pos, writePunctuation, node);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* AsKeyword */, asPos, writeKeyword, node);
|
|
writeSpace();
|
|
emit(node.name);
|
|
}
|
|
function emitNamedExports(node) {
|
|
emitNamedImportsOrExports(node);
|
|
}
|
|
function emitExportSpecifier(node) {
|
|
emitImportOrExportSpecifier(node);
|
|
}
|
|
function emitNamedImportsOrExports(node) {
|
|
writePunctuation("{");
|
|
emitList(node, node.elements, 525136 /* NamedImportsOrExportsElements */);
|
|
writePunctuation("}");
|
|
}
|
|
function emitImportOrExportSpecifier(node) {
|
|
if (node.isTypeOnly) {
|
|
writeKeyword("type");
|
|
writeSpace();
|
|
}
|
|
if (node.propertyName) {
|
|
emit(node.propertyName);
|
|
writeSpace();
|
|
emitTokenWithComment(128 /* AsKeyword */, node.propertyName.end, writeKeyword, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.name);
|
|
}
|
|
function emitExternalModuleReference(node) {
|
|
writeKeyword("require");
|
|
writePunctuation("(");
|
|
emitExpression(node.expression);
|
|
writePunctuation(")");
|
|
}
|
|
function emitJsxElement(node) {
|
|
emit(node.openingElement);
|
|
emitList(node, node.children, 262144 /* JsxElementOrFragmentChildren */);
|
|
emit(node.closingElement);
|
|
}
|
|
function emitJsxSelfClosingElement(node) {
|
|
writePunctuation("<");
|
|
emitJsxTagName(node.tagName);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
writeSpace();
|
|
emit(node.attributes);
|
|
writePunctuation("/>");
|
|
}
|
|
function emitJsxFragment(node) {
|
|
emit(node.openingFragment);
|
|
emitList(node, node.children, 262144 /* JsxElementOrFragmentChildren */);
|
|
emit(node.closingFragment);
|
|
}
|
|
function emitJsxOpeningElementOrFragment(node) {
|
|
writePunctuation("<");
|
|
if (isJsxOpeningElement(node)) {
|
|
const indented = writeLineSeparatorsAndIndentBefore(node.tagName, node);
|
|
emitJsxTagName(node.tagName);
|
|
emitTypeArguments(node, node.typeArguments);
|
|
if (node.attributes.properties && node.attributes.properties.length > 0) {
|
|
writeSpace();
|
|
}
|
|
emit(node.attributes);
|
|
writeLineSeparatorsAfter(node.attributes, node);
|
|
decreaseIndentIf(indented);
|
|
}
|
|
writePunctuation(">");
|
|
}
|
|
function emitJsxText(node) {
|
|
writer.writeLiteral(node.text);
|
|
}
|
|
function emitJsxClosingElementOrFragment(node) {
|
|
writePunctuation("</");
|
|
if (isJsxClosingElement(node)) {
|
|
emitJsxTagName(node.tagName);
|
|
}
|
|
writePunctuation(">");
|
|
}
|
|
function emitJsxAttributes(node) {
|
|
emitList(node, node.properties, 262656 /* JsxElementAttributes */);
|
|
}
|
|
function emitJsxAttribute(node) {
|
|
emit(node.name);
|
|
emitNodeWithPrefix("=", writePunctuation, node.initializer, emitJsxAttributeValue);
|
|
}
|
|
function emitJsxSpreadAttribute(node) {
|
|
writePunctuation("{...");
|
|
emitExpression(node.expression);
|
|
writePunctuation("}");
|
|
}
|
|
function hasTrailingCommentsAtPosition(pos) {
|
|
let result = false;
|
|
forEachTrailingCommentRange((currentSourceFile == null ? void 0 : currentSourceFile.text) || "", pos + 1, () => result = true);
|
|
return result;
|
|
}
|
|
function hasLeadingCommentsAtPosition(pos) {
|
|
let result = false;
|
|
forEachLeadingCommentRange((currentSourceFile == null ? void 0 : currentSourceFile.text) || "", pos + 1, () => result = true);
|
|
return result;
|
|
}
|
|
function hasCommentsAtPosition(pos) {
|
|
return hasTrailingCommentsAtPosition(pos) || hasLeadingCommentsAtPosition(pos);
|
|
}
|
|
function emitJsxExpression(node) {
|
|
var _a2;
|
|
if (node.expression || !commentsDisabled && !nodeIsSynthesized(node) && hasCommentsAtPosition(node.pos)) {
|
|
const isMultiline = currentSourceFile && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(currentSourceFile, node.pos).line !== getLineAndCharacterOfPosition(currentSourceFile, node.end).line;
|
|
if (isMultiline) {
|
|
writer.increaseIndent();
|
|
}
|
|
const end = emitTokenWithComment(18 /* OpenBraceToken */, node.pos, writePunctuation, node);
|
|
emit(node.dotDotDotToken);
|
|
emitExpression(node.expression);
|
|
emitTokenWithComment(19 /* CloseBraceToken */, ((_a2 = node.expression) == null ? void 0 : _a2.end) || end, writePunctuation, node);
|
|
if (isMultiline) {
|
|
writer.decreaseIndent();
|
|
}
|
|
}
|
|
}
|
|
function emitJsxTagName(node) {
|
|
if (node.kind === 79 /* Identifier */) {
|
|
emitExpression(node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitCaseClause(node) {
|
|
emitTokenWithComment(82 /* CaseKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end);
|
|
}
|
|
function emitDefaultClause(node) {
|
|
const pos = emitTokenWithComment(88 /* DefaultKeyword */, node.pos, writeKeyword, node);
|
|
emitCaseOrDefaultClauseRest(node, node.statements, pos);
|
|
}
|
|
function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) {
|
|
const emitAsSingleStatement = statements.length === 1 && (!currentSourceFile || nodeIsSynthesized(parentNode) || nodeIsSynthesized(statements[0]) || rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile));
|
|
let format = 163969 /* CaseOrDefaultClauseStatements */;
|
|
if (emitAsSingleStatement) {
|
|
writeToken(58 /* ColonToken */, colonPos, writePunctuation, parentNode);
|
|
writeSpace();
|
|
format &= ~(1 /* MultiLine */ | 128 /* Indented */);
|
|
} else {
|
|
emitTokenWithComment(58 /* ColonToken */, colonPos, writePunctuation, parentNode);
|
|
}
|
|
emitList(parentNode, statements, format);
|
|
}
|
|
function emitHeritageClause(node) {
|
|
writeSpace();
|
|
writeTokenText(node.token, writeKeyword);
|
|
writeSpace();
|
|
emitList(node, node.types, 528 /* HeritageClauseTypes */);
|
|
}
|
|
function emitCatchClause(node) {
|
|
const openParenPos = emitTokenWithComment(83 /* CatchKeyword */, node.pos, writeKeyword, node);
|
|
writeSpace();
|
|
if (node.variableDeclaration) {
|
|
emitTokenWithComment(20 /* OpenParenToken */, openParenPos, writePunctuation, node);
|
|
emit(node.variableDeclaration);
|
|
emitTokenWithComment(21 /* CloseParenToken */, node.variableDeclaration.end, writePunctuation, node);
|
|
writeSpace();
|
|
}
|
|
emit(node.block);
|
|
}
|
|
function emitPropertyAssignment(node) {
|
|
emit(node.name);
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
const initializer = node.initializer;
|
|
if ((getEmitFlags(initializer) & 1024 /* NoLeadingComments */) === 0) {
|
|
const commentRange = getCommentRange(initializer);
|
|
emitTrailingCommentsOfPosition(commentRange.pos);
|
|
}
|
|
emitExpression(initializer, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitShorthandPropertyAssignment(node) {
|
|
emit(node.name);
|
|
if (node.objectAssignmentInitializer) {
|
|
writeSpace();
|
|
writePunctuation("=");
|
|
writeSpace();
|
|
emitExpression(node.objectAssignmentInitializer, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
}
|
|
function emitSpreadAssignment(node) {
|
|
if (node.expression) {
|
|
emitTokenWithComment(25 /* DotDotDotToken */, node.pos, writePunctuation, node);
|
|
emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
}
|
|
function emitEnumMember(node) {
|
|
emit(node.name);
|
|
emitInitializer(node.initializer, node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma);
|
|
}
|
|
function emitJSDoc(node) {
|
|
write("/**");
|
|
if (node.comment) {
|
|
const text = getTextOfJSDocComment(node.comment);
|
|
if (text) {
|
|
const lines = text.split(/\r\n?|\n/g);
|
|
for (const line of lines) {
|
|
writeLine();
|
|
writeSpace();
|
|
writePunctuation("*");
|
|
writeSpace();
|
|
write(line);
|
|
}
|
|
}
|
|
}
|
|
if (node.tags) {
|
|
if (node.tags.length === 1 && node.tags[0].kind === 346 /* JSDocTypeTag */ && !node.comment) {
|
|
writeSpace();
|
|
emit(node.tags[0]);
|
|
} else {
|
|
emitList(node, node.tags, 33 /* JSDocComment */);
|
|
}
|
|
}
|
|
writeSpace();
|
|
write("*/");
|
|
}
|
|
function emitJSDocSimpleTypedTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
emitJSDocTypeExpression(tag.typeExpression);
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocSeeTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
emit(tag.name);
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocNameReference(node) {
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emit(node.name);
|
|
writePunctuation("}");
|
|
}
|
|
function emitJSDocHeritageTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emit(tag.class);
|
|
writePunctuation("}");
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocTemplateTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
emitJSDocTypeExpression(tag.constraint);
|
|
writeSpace();
|
|
emitList(tag, tag.typeParameters, 528 /* CommaListElements */);
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocTypedefTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
if (tag.typeExpression) {
|
|
if (tag.typeExpression.kind === 312 /* JSDocTypeExpression */) {
|
|
emitJSDocTypeExpression(tag.typeExpression);
|
|
} else {
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
write("Object");
|
|
if (tag.typeExpression.isArrayType) {
|
|
writePunctuation("[");
|
|
writePunctuation("]");
|
|
}
|
|
writePunctuation("}");
|
|
}
|
|
}
|
|
if (tag.fullName) {
|
|
writeSpace();
|
|
emit(tag.fullName);
|
|
}
|
|
emitJSDocComment(tag.comment);
|
|
if (tag.typeExpression && tag.typeExpression.kind === 325 /* JSDocTypeLiteral */) {
|
|
emitJSDocTypeLiteral(tag.typeExpression);
|
|
}
|
|
}
|
|
function emitJSDocCallbackTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
if (tag.name) {
|
|
writeSpace();
|
|
emit(tag.name);
|
|
}
|
|
emitJSDocComment(tag.comment);
|
|
emitJSDocSignature(tag.typeExpression);
|
|
}
|
|
function emitJSDocSimpleTag(tag) {
|
|
emitJSDocTagName(tag.tagName);
|
|
emitJSDocComment(tag.comment);
|
|
}
|
|
function emitJSDocTypeLiteral(lit) {
|
|
emitList(lit, factory.createNodeArray(lit.jsDocPropertyTags), 33 /* JSDocComment */);
|
|
}
|
|
function emitJSDocSignature(sig) {
|
|
if (sig.typeParameters) {
|
|
emitList(sig, factory.createNodeArray(sig.typeParameters), 33 /* JSDocComment */);
|
|
}
|
|
if (sig.parameters) {
|
|
emitList(sig, factory.createNodeArray(sig.parameters), 33 /* JSDocComment */);
|
|
}
|
|
if (sig.type) {
|
|
writeLine();
|
|
writeSpace();
|
|
writePunctuation("*");
|
|
writeSpace();
|
|
emit(sig.type);
|
|
}
|
|
}
|
|
function emitJSDocPropertyLikeTag(param) {
|
|
emitJSDocTagName(param.tagName);
|
|
emitJSDocTypeExpression(param.typeExpression);
|
|
writeSpace();
|
|
if (param.isBracketed) {
|
|
writePunctuation("[");
|
|
}
|
|
emit(param.name);
|
|
if (param.isBracketed) {
|
|
writePunctuation("]");
|
|
}
|
|
emitJSDocComment(param.comment);
|
|
}
|
|
function emitJSDocTagName(tagName) {
|
|
writePunctuation("@");
|
|
emit(tagName);
|
|
}
|
|
function emitJSDocComment(comment) {
|
|
const text = getTextOfJSDocComment(comment);
|
|
if (text) {
|
|
writeSpace();
|
|
write(text);
|
|
}
|
|
}
|
|
function emitJSDocTypeExpression(typeExpression) {
|
|
if (typeExpression) {
|
|
writeSpace();
|
|
writePunctuation("{");
|
|
emit(typeExpression.type);
|
|
writePunctuation("}");
|
|
}
|
|
}
|
|
function emitSourceFile(node) {
|
|
writeLine();
|
|
const statements = node.statements;
|
|
const shouldEmitDetachedComment = statements.length === 0 || !isPrologueDirective(statements[0]) || nodeIsSynthesized(statements[0]);
|
|
if (shouldEmitDetachedComment) {
|
|
emitBodyWithDetachedComments(node, statements, emitSourceFileWorker);
|
|
return;
|
|
}
|
|
emitSourceFileWorker(node);
|
|
}
|
|
function emitSyntheticTripleSlashReferencesIfNeeded(node) {
|
|
emitTripleSlashDirectives(!!node.hasNoDefaultLib, node.syntheticFileReferences || [], node.syntheticTypeReferences || [], node.syntheticLibReferences || []);
|
|
for (const prepend of node.prepends) {
|
|
if (isUnparsedSource(prepend) && prepend.syntheticReferences) {
|
|
for (const ref of prepend.syntheticReferences) {
|
|
emit(ref);
|
|
writeLine();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitTripleSlashDirectivesIfNeeded(node) {
|
|
if (node.isDeclarationFile)
|
|
emitTripleSlashDirectives(node.hasNoDefaultLib, node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives);
|
|
}
|
|
function emitTripleSlashDirectives(hasNoDefaultLib, files, types, libs2) {
|
|
if (hasNoDefaultLib) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference no-default-lib="true"/>`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "no-default-lib" /* NoDefaultLib */ });
|
|
writeLine();
|
|
}
|
|
if (currentSourceFile && currentSourceFile.moduleName) {
|
|
writeComment(`/// <amd-module name="${currentSourceFile.moduleName}" />`);
|
|
writeLine();
|
|
}
|
|
if (currentSourceFile && currentSourceFile.amdDependencies) {
|
|
for (const dep of currentSourceFile.amdDependencies) {
|
|
if (dep.name) {
|
|
writeComment(`/// <amd-dependency name="${dep.name}" path="${dep.path}" />`);
|
|
} else {
|
|
writeComment(`/// <amd-dependency path="${dep.path}" />`);
|
|
}
|
|
writeLine();
|
|
}
|
|
}
|
|
for (const directive of files) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference path="${directive.fileName}" />`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "reference" /* Reference */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
for (const directive of types) {
|
|
const pos = writer.getTextPos();
|
|
const resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile == null ? void 0 : currentSourceFile.impliedNodeFormat) ? `resolution-mode="${directive.resolutionMode === 99 /* ESNext */ ? "import" : "require"}"` : "";
|
|
writeComment(`/// <reference types="${directive.fileName}" ${resolutionMode}/>`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: !directive.resolutionMode ? "type" /* Type */ : directive.resolutionMode === 99 /* ESNext */ ? "type-import" /* TypeResolutionModeImport */ : "type-require" /* TypeResolutionModeRequire */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
for (const directive of libs2) {
|
|
const pos = writer.getTextPos();
|
|
writeComment(`/// <reference lib="${directive.fileName}" />`);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "lib" /* Lib */, data: directive.fileName });
|
|
writeLine();
|
|
}
|
|
}
|
|
function emitSourceFileWorker(node) {
|
|
const statements = node.statements;
|
|
pushNameGenerationScope(node);
|
|
forEach(node.statements, generateNames);
|
|
emitHelpers(node);
|
|
const index = findIndex(statements, (statement) => !isPrologueDirective(statement));
|
|
emitTripleSlashDirectivesIfNeeded(node);
|
|
emitList(node, statements, 1 /* MultiLine */, void 0, index === -1 ? statements.length : index);
|
|
popNameGenerationScope(node);
|
|
}
|
|
function emitPartiallyEmittedExpression(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
if (!(emitFlags & 1024 /* NoLeadingComments */) && node.pos !== node.expression.pos) {
|
|
emitTrailingCommentsOfPosition(node.expression.pos);
|
|
}
|
|
emitExpression(node.expression);
|
|
if (!(emitFlags & 2048 /* NoTrailingComments */) && node.end !== node.expression.end) {
|
|
emitLeadingCommentsOfPosition(node.expression.end);
|
|
}
|
|
}
|
|
function emitCommaList(node) {
|
|
emitExpressionList(node, node.elements, 528 /* CommaListElements */, void 0);
|
|
}
|
|
function emitPrologueDirectives(statements, sourceFile, seenPrologueDirectives, recordBundleFileSection) {
|
|
let needsToSetSourceFile = !!sourceFile;
|
|
for (let i = 0; i < statements.length; i++) {
|
|
const statement = statements[i];
|
|
if (isPrologueDirective(statement)) {
|
|
const shouldEmitPrologueDirective = seenPrologueDirectives ? !seenPrologueDirectives.has(statement.expression.text) : true;
|
|
if (shouldEmitPrologueDirective) {
|
|
if (needsToSetSourceFile) {
|
|
needsToSetSourceFile = false;
|
|
setSourceFile(sourceFile);
|
|
}
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
emit(statement);
|
|
if (recordBundleFileSection && bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "prologue" /* Prologue */, data: statement.expression.text });
|
|
if (seenPrologueDirectives) {
|
|
seenPrologueDirectives.add(statement.expression.text);
|
|
}
|
|
}
|
|
} else {
|
|
return i;
|
|
}
|
|
}
|
|
return statements.length;
|
|
}
|
|
function emitUnparsedPrologues(prologues, seenPrologueDirectives) {
|
|
for (const prologue of prologues) {
|
|
if (!seenPrologueDirectives.has(prologue.data)) {
|
|
writeLine();
|
|
const pos = writer.getTextPos();
|
|
emit(prologue);
|
|
if (bundleFileInfo)
|
|
bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: "prologue" /* Prologue */, data: prologue.data });
|
|
if (seenPrologueDirectives) {
|
|
seenPrologueDirectives.add(prologue.data);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitPrologueDirectivesIfNeeded(sourceFileOrBundle) {
|
|
if (isSourceFile(sourceFileOrBundle)) {
|
|
emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle);
|
|
} else {
|
|
const seenPrologueDirectives = /* @__PURE__ */ new Set();
|
|
for (const prepend of sourceFileOrBundle.prepends) {
|
|
emitUnparsedPrologues(prepend.prologues, seenPrologueDirectives);
|
|
}
|
|
for (const sourceFile of sourceFileOrBundle.sourceFiles) {
|
|
emitPrologueDirectives(sourceFile.statements, sourceFile, seenPrologueDirectives, true);
|
|
}
|
|
setSourceFile(void 0);
|
|
}
|
|
}
|
|
function getPrologueDirectivesFromBundledSourceFiles(bundle) {
|
|
const seenPrologueDirectives = /* @__PURE__ */ new Set();
|
|
let prologues;
|
|
for (let index = 0; index < bundle.sourceFiles.length; index++) {
|
|
const sourceFile = bundle.sourceFiles[index];
|
|
let directives;
|
|
let end = 0;
|
|
for (const statement of sourceFile.statements) {
|
|
if (!isPrologueDirective(statement))
|
|
break;
|
|
if (seenPrologueDirectives.has(statement.expression.text))
|
|
continue;
|
|
seenPrologueDirectives.add(statement.expression.text);
|
|
(directives || (directives = [])).push({
|
|
pos: statement.pos,
|
|
end: statement.end,
|
|
expression: {
|
|
pos: statement.expression.pos,
|
|
end: statement.expression.end,
|
|
text: statement.expression.text
|
|
}
|
|
});
|
|
end = end < statement.end ? statement.end : end;
|
|
}
|
|
if (directives)
|
|
(prologues || (prologues = [])).push({ file: index, text: sourceFile.text.substring(0, end), directives });
|
|
}
|
|
return prologues;
|
|
}
|
|
function emitShebangIfNeeded(sourceFileOrBundle) {
|
|
if (isSourceFile(sourceFileOrBundle) || isUnparsedSource(sourceFileOrBundle)) {
|
|
const shebang = getShebang(sourceFileOrBundle.text);
|
|
if (shebang) {
|
|
writeComment(shebang);
|
|
writeLine();
|
|
return true;
|
|
}
|
|
} else {
|
|
for (const prepend of sourceFileOrBundle.prepends) {
|
|
Debug.assertNode(prepend, isUnparsedSource);
|
|
if (emitShebangIfNeeded(prepend)) {
|
|
return true;
|
|
}
|
|
}
|
|
for (const sourceFile of sourceFileOrBundle.sourceFiles) {
|
|
if (emitShebangIfNeeded(sourceFile)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function emitNodeWithWriter(node, writer2) {
|
|
if (!node)
|
|
return;
|
|
const savedWrite = write;
|
|
write = writer2;
|
|
emit(node);
|
|
write = savedWrite;
|
|
}
|
|
function emitDecoratorsAndModifiers(node, modifiers) {
|
|
if (modifiers == null ? void 0 : modifiers.length) {
|
|
if (every(modifiers, isModifier)) {
|
|
return emitModifiers(node, modifiers);
|
|
}
|
|
if (every(modifiers, isDecorator)) {
|
|
return emitDecorators(node, modifiers);
|
|
}
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(modifiers);
|
|
let lastMode;
|
|
let mode;
|
|
let start2 = 0;
|
|
let pos = 0;
|
|
while (start2 < modifiers.length) {
|
|
while (pos < modifiers.length) {
|
|
const modifier = modifiers[pos];
|
|
mode = isDecorator(modifier) ? "decorators" : "modifiers";
|
|
if (lastMode === void 0) {
|
|
lastMode = mode;
|
|
} else if (mode !== lastMode) {
|
|
break;
|
|
}
|
|
pos++;
|
|
}
|
|
const textRange = { pos: -1, end: -1 };
|
|
if (start2 === 0)
|
|
textRange.pos = modifiers.pos;
|
|
if (pos === modifiers.length - 1)
|
|
textRange.end = modifiers.end;
|
|
emitNodeListItems(
|
|
emit,
|
|
node,
|
|
modifiers,
|
|
lastMode === "modifiers" ? 2359808 /* Modifiers */ : 2146305 /* Decorators */,
|
|
void 0,
|
|
start2,
|
|
pos - start2,
|
|
false,
|
|
textRange
|
|
);
|
|
start2 = pos;
|
|
lastMode = mode;
|
|
pos++;
|
|
}
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(modifiers);
|
|
}
|
|
}
|
|
function emitModifiers(node, modifiers) {
|
|
emitList(node, modifiers, 2359808 /* Modifiers */);
|
|
}
|
|
function emitTypeAnnotation(node) {
|
|
if (node) {
|
|
writePunctuation(":");
|
|
writeSpace();
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitInitializer(node, equalCommentStartPos, container, parenthesizerRule) {
|
|
if (node) {
|
|
writeSpace();
|
|
emitTokenWithComment(63 /* EqualsToken */, equalCommentStartPos, writeOperator, container);
|
|
writeSpace();
|
|
emitExpression(node, parenthesizerRule);
|
|
}
|
|
}
|
|
function emitNodeWithPrefix(prefix, prefixWriter, node, emit2) {
|
|
if (node) {
|
|
prefixWriter(prefix);
|
|
emit2(node);
|
|
}
|
|
}
|
|
function emitWithLeadingSpace(node) {
|
|
if (node) {
|
|
writeSpace();
|
|
emit(node);
|
|
}
|
|
}
|
|
function emitExpressionWithLeadingSpace(node, parenthesizerRule) {
|
|
if (node) {
|
|
writeSpace();
|
|
emitExpression(node, parenthesizerRule);
|
|
}
|
|
}
|
|
function emitWithTrailingSpace(node) {
|
|
if (node) {
|
|
emit(node);
|
|
writeSpace();
|
|
}
|
|
}
|
|
function emitEmbeddedStatement(parent2, node) {
|
|
if (isBlock(node) || getEmitFlags(parent2) & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
emit(node);
|
|
} else {
|
|
writeLine();
|
|
increaseIndent();
|
|
if (isEmptyStatement(node)) {
|
|
pipelineEmit(5 /* EmbeddedStatement */, node);
|
|
} else {
|
|
emit(node);
|
|
}
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function emitDecorators(parentNode, decorators) {
|
|
emitList(parentNode, decorators, 2146305 /* Decorators */);
|
|
}
|
|
function emitTypeArguments(parentNode, typeArguments) {
|
|
emitList(parentNode, typeArguments, 53776 /* TypeArguments */, typeArgumentParenthesizerRuleSelector);
|
|
}
|
|
function emitTypeParameters(parentNode, typeParameters) {
|
|
if (isFunctionLike(parentNode) && parentNode.typeArguments) {
|
|
return emitTypeArguments(parentNode, parentNode.typeArguments);
|
|
}
|
|
emitList(parentNode, typeParameters, 53776 /* TypeParameters */);
|
|
}
|
|
function emitParameters(parentNode, parameters) {
|
|
emitList(parentNode, parameters, 2576 /* Parameters */);
|
|
}
|
|
function canEmitSimpleArrowHead(parentNode, parameters) {
|
|
const parameter = singleOrUndefined(parameters);
|
|
return parameter && parameter.pos === parentNode.pos && isArrowFunction(parentNode) && !parentNode.type && !some(parentNode.modifiers) && !some(parentNode.typeParameters) && !some(parameter.modifiers) && !parameter.dotDotDotToken && !parameter.questionToken && !parameter.type && !parameter.initializer && isIdentifier(parameter.name);
|
|
}
|
|
function emitParametersForArrow(parentNode, parameters) {
|
|
if (canEmitSimpleArrowHead(parentNode, parameters)) {
|
|
emitList(parentNode, parameters, 2576 /* Parameters */ & ~2048 /* Parenthesis */);
|
|
} else {
|
|
emitParameters(parentNode, parameters);
|
|
}
|
|
}
|
|
function emitParametersForIndexSignature(parentNode, parameters) {
|
|
emitList(parentNode, parameters, 8848 /* IndexSignatureParameters */);
|
|
}
|
|
function writeDelimiter(format) {
|
|
switch (format & 60 /* DelimitersMask */) {
|
|
case 0 /* None */:
|
|
break;
|
|
case 16 /* CommaDelimited */:
|
|
writePunctuation(",");
|
|
break;
|
|
case 4 /* BarDelimited */:
|
|
writeSpace();
|
|
writePunctuation("|");
|
|
break;
|
|
case 32 /* AsteriskDelimited */:
|
|
writeSpace();
|
|
writePunctuation("*");
|
|
writeSpace();
|
|
break;
|
|
case 8 /* AmpersandDelimited */:
|
|
writeSpace();
|
|
writePunctuation("&");
|
|
break;
|
|
}
|
|
}
|
|
function emitList(parentNode, children, format, parenthesizerRule, start2, count) {
|
|
emitNodeList(
|
|
emit,
|
|
parentNode,
|
|
children,
|
|
format | (parentNode && getEmitFlags(parentNode) & 2 /* MultiLine */ ? 65536 /* PreferNewLine */ : 0),
|
|
parenthesizerRule,
|
|
start2,
|
|
count
|
|
);
|
|
}
|
|
function emitExpressionList(parentNode, children, format, parenthesizerRule, start2, count) {
|
|
emitNodeList(emitExpression, parentNode, children, format, parenthesizerRule, start2, count);
|
|
}
|
|
function emitNodeList(emit2, parentNode, children, format, parenthesizerRule, start2 = 0, count = children ? children.length - start2 : 0) {
|
|
const isUndefined = children === void 0;
|
|
if (isUndefined && format & 16384 /* OptionalIfUndefined */) {
|
|
return;
|
|
}
|
|
const isEmpty = children === void 0 || start2 >= children.length || count === 0;
|
|
if (isEmpty && format & 32768 /* OptionalIfEmpty */) {
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(children);
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(children);
|
|
return;
|
|
}
|
|
if (format & 15360 /* BracketsMask */) {
|
|
writePunctuation(getOpeningBracket(format));
|
|
if (isEmpty && children) {
|
|
emitTrailingCommentsOfPosition(children.pos, true);
|
|
}
|
|
}
|
|
onBeforeEmitNodeArray == null ? void 0 : onBeforeEmitNodeArray(children);
|
|
if (isEmpty) {
|
|
if (format & 1 /* MultiLine */ && !(preserveSourceNewlines && (!parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile)))) {
|
|
writeLine();
|
|
} else if (format & 256 /* SpaceBetweenBraces */ && !(format & 524288 /* NoSpaceIfEmpty */)) {
|
|
writeSpace();
|
|
}
|
|
} else {
|
|
emitNodeListItems(emit2, parentNode, children, format, parenthesizerRule, start2, count, children.hasTrailingComma, children);
|
|
}
|
|
onAfterEmitNodeArray == null ? void 0 : onAfterEmitNodeArray(children);
|
|
if (format & 15360 /* BracketsMask */) {
|
|
if (isEmpty && children) {
|
|
emitLeadingCommentsOfPosition(children.end);
|
|
}
|
|
writePunctuation(getClosingBracket(format));
|
|
}
|
|
}
|
|
function emitNodeListItems(emit2, parentNode, children, format, parenthesizerRule, start2, count, hasTrailingComma, childrenTextRange) {
|
|
const mayEmitInterveningComments = (format & 262144 /* NoInterveningComments */) === 0;
|
|
let shouldEmitInterveningComments = mayEmitInterveningComments;
|
|
const leadingLineTerminatorCount = getLeadingLineTerminatorCount(parentNode, children[start2], format);
|
|
if (leadingLineTerminatorCount) {
|
|
writeLine(leadingLineTerminatorCount);
|
|
shouldEmitInterveningComments = false;
|
|
} else if (format & 256 /* SpaceBetweenBraces */) {
|
|
writeSpace();
|
|
}
|
|
if (format & 128 /* Indented */) {
|
|
increaseIndent();
|
|
}
|
|
const emitListItem = getEmitListItem(emit2, parenthesizerRule);
|
|
let previousSibling;
|
|
let previousSourceFileTextKind;
|
|
let shouldDecreaseIndentAfterEmit = false;
|
|
for (let i = 0; i < count; i++) {
|
|
const child = children[start2 + i];
|
|
if (format & 32 /* AsteriskDelimited */) {
|
|
writeLine();
|
|
writeDelimiter(format);
|
|
} else if (previousSibling) {
|
|
if (format & 60 /* DelimitersMask */ && previousSibling.end !== (parentNode ? parentNode.end : -1)) {
|
|
emitLeadingCommentsOfPosition(previousSibling.end);
|
|
}
|
|
writeDelimiter(format);
|
|
recordBundleFileInternalSectionEnd(previousSourceFileTextKind);
|
|
const separatingLineTerminatorCount = getSeparatingLineTerminatorCount(previousSibling, child, format);
|
|
if (separatingLineTerminatorCount > 0) {
|
|
if ((format & (3 /* LinesMask */ | 128 /* Indented */)) === 0 /* SingleLine */) {
|
|
increaseIndent();
|
|
shouldDecreaseIndentAfterEmit = true;
|
|
}
|
|
writeLine(separatingLineTerminatorCount);
|
|
shouldEmitInterveningComments = false;
|
|
} else if (previousSibling && format & 512 /* SpaceBetweenSiblings */) {
|
|
writeSpace();
|
|
}
|
|
}
|
|
previousSourceFileTextKind = recordBundleFileInternalSectionStart(child);
|
|
if (shouldEmitInterveningComments) {
|
|
const commentRange = getCommentRange(child);
|
|
emitTrailingCommentsOfPosition(commentRange.pos);
|
|
} else {
|
|
shouldEmitInterveningComments = mayEmitInterveningComments;
|
|
}
|
|
nextListElementPos = child.pos;
|
|
emitListItem(child, emit2, parenthesizerRule, i);
|
|
if (shouldDecreaseIndentAfterEmit) {
|
|
decreaseIndent();
|
|
shouldDecreaseIndentAfterEmit = false;
|
|
}
|
|
previousSibling = child;
|
|
}
|
|
const emitFlags = previousSibling ? getEmitFlags(previousSibling) : 0;
|
|
const skipTrailingComments = commentsDisabled || !!(emitFlags & 2048 /* NoTrailingComments */);
|
|
const emitTrailingComma = hasTrailingComma && format & 64 /* AllowTrailingComma */ && format & 16 /* CommaDelimited */;
|
|
if (emitTrailingComma) {
|
|
if (previousSibling && !skipTrailingComments) {
|
|
emitTokenWithComment(27 /* CommaToken */, previousSibling.end, writePunctuation, previousSibling);
|
|
} else {
|
|
writePunctuation(",");
|
|
}
|
|
}
|
|
if (previousSibling && (parentNode ? parentNode.end : -1) !== previousSibling.end && format & 60 /* DelimitersMask */ && !skipTrailingComments) {
|
|
emitLeadingCommentsOfPosition(emitTrailingComma && (childrenTextRange == null ? void 0 : childrenTextRange.end) ? childrenTextRange.end : previousSibling.end);
|
|
}
|
|
if (format & 128 /* Indented */) {
|
|
decreaseIndent();
|
|
}
|
|
recordBundleFileInternalSectionEnd(previousSourceFileTextKind);
|
|
const closingLineTerminatorCount = getClosingLineTerminatorCount(parentNode, children[start2 + count - 1], format, childrenTextRange);
|
|
if (closingLineTerminatorCount) {
|
|
writeLine(closingLineTerminatorCount);
|
|
} else if (format & (2097152 /* SpaceAfterList */ | 256 /* SpaceBetweenBraces */)) {
|
|
writeSpace();
|
|
}
|
|
}
|
|
function writeLiteral(s) {
|
|
writer.writeLiteral(s);
|
|
}
|
|
function writeStringLiteral(s) {
|
|
writer.writeStringLiteral(s);
|
|
}
|
|
function writeBase(s) {
|
|
writer.write(s);
|
|
}
|
|
function writeSymbol(s, sym) {
|
|
writer.writeSymbol(s, sym);
|
|
}
|
|
function writePunctuation(s) {
|
|
writer.writePunctuation(s);
|
|
}
|
|
function writeTrailingSemicolon() {
|
|
writer.writeTrailingSemicolon(";");
|
|
}
|
|
function writeKeyword(s) {
|
|
writer.writeKeyword(s);
|
|
}
|
|
function writeOperator(s) {
|
|
writer.writeOperator(s);
|
|
}
|
|
function writeParameter(s) {
|
|
writer.writeParameter(s);
|
|
}
|
|
function writeComment(s) {
|
|
writer.writeComment(s);
|
|
}
|
|
function writeSpace() {
|
|
writer.writeSpace(" ");
|
|
}
|
|
function writeProperty(s) {
|
|
writer.writeProperty(s);
|
|
}
|
|
function nonEscapingWrite(s) {
|
|
if (writer.nonEscapingWrite) {
|
|
writer.nonEscapingWrite(s);
|
|
} else {
|
|
writer.write(s);
|
|
}
|
|
}
|
|
function writeLine(count = 1) {
|
|
for (let i = 0; i < count; i++) {
|
|
writer.writeLine(i > 0);
|
|
}
|
|
}
|
|
function increaseIndent() {
|
|
writer.increaseIndent();
|
|
}
|
|
function decreaseIndent() {
|
|
writer.decreaseIndent();
|
|
}
|
|
function writeToken(token, pos, writer2, contextNode) {
|
|
return !sourceMapsDisabled ? emitTokenWithSourceMap(contextNode, token, writer2, pos, writeTokenText) : writeTokenText(token, writer2, pos);
|
|
}
|
|
function writeTokenNode(node, writer2) {
|
|
if (onBeforeEmitToken) {
|
|
onBeforeEmitToken(node);
|
|
}
|
|
writer2(tokenToString(node.kind));
|
|
if (onAfterEmitToken) {
|
|
onAfterEmitToken(node);
|
|
}
|
|
}
|
|
function writeTokenText(token, writer2, pos) {
|
|
const tokenString = tokenToString(token);
|
|
writer2(tokenString);
|
|
return pos < 0 ? pos : pos + tokenString.length;
|
|
}
|
|
function writeLineOrSpace(parentNode, prevChildNode, nextChildNode) {
|
|
if (getEmitFlags(parentNode) & 1 /* SingleLine */) {
|
|
writeSpace();
|
|
} else if (preserveSourceNewlines) {
|
|
const lines = getLinesBetweenNodes(parentNode, prevChildNode, nextChildNode);
|
|
if (lines) {
|
|
writeLine(lines);
|
|
} else {
|
|
writeSpace();
|
|
}
|
|
} else {
|
|
writeLine();
|
|
}
|
|
}
|
|
function writeLines(text) {
|
|
const lines = text.split(/\r\n?|\n/g);
|
|
const indentation = guessIndentation(lines);
|
|
for (const lineText of lines) {
|
|
const line = indentation ? lineText.slice(indentation) : lineText;
|
|
if (line.length) {
|
|
writeLine();
|
|
write(line);
|
|
}
|
|
}
|
|
}
|
|
function writeLinesAndIndent(lineCount, writeSpaceIfNotIndenting) {
|
|
if (lineCount) {
|
|
increaseIndent();
|
|
writeLine(lineCount);
|
|
} else if (writeSpaceIfNotIndenting) {
|
|
writeSpace();
|
|
}
|
|
}
|
|
function decreaseIndentIf(value1, value2) {
|
|
if (value1) {
|
|
decreaseIndent();
|
|
}
|
|
if (value2) {
|
|
decreaseIndent();
|
|
}
|
|
}
|
|
function getLeadingLineTerminatorCount(parentNode, firstChild, format) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (format & 65536 /* PreferNewLine */) {
|
|
return 1;
|
|
}
|
|
if (firstChild === void 0) {
|
|
return !parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (firstChild.pos === nextListElementPos) {
|
|
return 0;
|
|
}
|
|
if (firstChild.kind === 11 /* JsxText */) {
|
|
return 0;
|
|
}
|
|
if (currentSourceFile && parentNode && !positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(firstChild) && (!firstChild.parent || getOriginalNode(firstChild.parent) === getOriginalNode(parentNode))) {
|
|
if (preserveSourceNewlines) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(
|
|
firstChild.pos,
|
|
parentNode.pos,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (synthesizedNodeStartsOnNewLine(firstChild, format)) {
|
|
return 1;
|
|
}
|
|
}
|
|
return format & 1 /* MultiLine */ ? 1 : 0;
|
|
}
|
|
function getSeparatingLineTerminatorCount(previousNode, nextNode, format) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (previousNode === void 0 || nextNode === void 0) {
|
|
return 0;
|
|
}
|
|
if (nextNode.kind === 11 /* JsxText */) {
|
|
return 0;
|
|
} else if (currentSourceFile && !nodeIsSynthesized(previousNode) && !nodeIsSynthesized(nextNode)) {
|
|
if (preserveSourceNewlines && siblingNodePositionsAreComparable(previousNode, nextNode)) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenRangeEndAndRangeStart(
|
|
previousNode,
|
|
nextNode,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
} else if (!preserveSourceNewlines && originalNodesHaveSameParent(previousNode, nextNode)) {
|
|
return rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
return format & 65536 /* PreferNewLine */ ? 1 : 0;
|
|
} else if (synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format)) {
|
|
return 1;
|
|
}
|
|
} else if (getStartsOnNewLine(nextNode)) {
|
|
return 1;
|
|
}
|
|
return format & 1 /* MultiLine */ ? 1 : 0;
|
|
}
|
|
function getClosingLineTerminatorCount(parentNode, lastChild, format, childrenTextRange) {
|
|
if (format & 2 /* PreserveLines */ || preserveSourceNewlines) {
|
|
if (format & 65536 /* PreferNewLine */) {
|
|
return 1;
|
|
}
|
|
if (lastChild === void 0) {
|
|
return !parentNode || currentSourceFile && rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (currentSourceFile && parentNode && !positionIsSynthesized(parentNode.pos) && !nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) {
|
|
if (preserveSourceNewlines) {
|
|
const end = childrenTextRange && !positionIsSynthesized(childrenTextRange.end) ? childrenTextRange.end : lastChild.end;
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenPositionAndNextNonWhitespaceCharacter(
|
|
end,
|
|
parentNode.end,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1;
|
|
}
|
|
if (synthesizedNodeStartsOnNewLine(lastChild, format)) {
|
|
return 1;
|
|
}
|
|
}
|
|
if (format & 1 /* MultiLine */ && !(format & 131072 /* NoTrailingNewLine */)) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function getEffectiveLines(getLineDifference) {
|
|
Debug.assert(!!preserveSourceNewlines);
|
|
const lines = getLineDifference(true);
|
|
if (lines === 0) {
|
|
return getLineDifference(false);
|
|
}
|
|
return lines;
|
|
}
|
|
function writeLineSeparatorsAndIndentBefore(node, parent2) {
|
|
const leadingNewlines = preserveSourceNewlines && getLeadingLineTerminatorCount(parent2, node, 0 /* None */);
|
|
if (leadingNewlines) {
|
|
writeLinesAndIndent(leadingNewlines, false);
|
|
}
|
|
return !!leadingNewlines;
|
|
}
|
|
function writeLineSeparatorsAfter(node, parent2) {
|
|
const trailingNewlines = preserveSourceNewlines && getClosingLineTerminatorCount(parent2, node, 0 /* None */, void 0);
|
|
if (trailingNewlines) {
|
|
writeLine(trailingNewlines);
|
|
}
|
|
}
|
|
function synthesizedNodeStartsOnNewLine(node, format) {
|
|
if (nodeIsSynthesized(node)) {
|
|
const startsOnNewLine = getStartsOnNewLine(node);
|
|
if (startsOnNewLine === void 0) {
|
|
return (format & 65536 /* PreferNewLine */) !== 0;
|
|
}
|
|
return startsOnNewLine;
|
|
}
|
|
return (format & 65536 /* PreferNewLine */) !== 0;
|
|
}
|
|
function getLinesBetweenNodes(parent2, node1, node2) {
|
|
if (getEmitFlags(parent2) & 262144 /* NoIndentation */) {
|
|
return 0;
|
|
}
|
|
parent2 = skipSynthesizedParentheses(parent2);
|
|
node1 = skipSynthesizedParentheses(node1);
|
|
node2 = skipSynthesizedParentheses(node2);
|
|
if (getStartsOnNewLine(node2)) {
|
|
return 1;
|
|
}
|
|
if (currentSourceFile && !nodeIsSynthesized(parent2) && !nodeIsSynthesized(node1) && !nodeIsSynthesized(node2)) {
|
|
if (preserveSourceNewlines) {
|
|
return getEffectiveLines(
|
|
(includeComments) => getLinesBetweenRangeEndAndRangeStart(
|
|
node1,
|
|
node2,
|
|
currentSourceFile,
|
|
includeComments
|
|
)
|
|
);
|
|
}
|
|
return rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile) ? 0 : 1;
|
|
}
|
|
return 0;
|
|
}
|
|
function isEmptyBlock(block) {
|
|
return block.statements.length === 0 && (!currentSourceFile || rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile));
|
|
}
|
|
function skipSynthesizedParentheses(node) {
|
|
while (node.kind === 214 /* ParenthesizedExpression */ && nodeIsSynthesized(node)) {
|
|
node = node.expression;
|
|
}
|
|
return node;
|
|
}
|
|
function getTextOfNode2(node, includeTrivia) {
|
|
if (isGeneratedIdentifier(node) || isGeneratedPrivateIdentifier(node)) {
|
|
return generateName(node);
|
|
}
|
|
if (isStringLiteral(node) && node.textSourceNode) {
|
|
return getTextOfNode2(node.textSourceNode, includeTrivia);
|
|
}
|
|
const sourceFile = currentSourceFile;
|
|
const canUseSourceFile = !!sourceFile && !!node.parent && !nodeIsSynthesized(node);
|
|
if (isMemberName(node)) {
|
|
if (!canUseSourceFile || getSourceFileOfNode(node) !== getOriginalNode(sourceFile)) {
|
|
return idText(node);
|
|
}
|
|
} else {
|
|
Debug.assertNode(node, isLiteralExpression);
|
|
if (!canUseSourceFile) {
|
|
return node.text;
|
|
}
|
|
}
|
|
return getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia);
|
|
}
|
|
function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) {
|
|
if (node.kind === 10 /* StringLiteral */ && node.textSourceNode) {
|
|
const textSourceNode = node.textSourceNode;
|
|
if (isIdentifier(textSourceNode) || isPrivateIdentifier(textSourceNode) || isNumericLiteral(textSourceNode)) {
|
|
const text = isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode2(textSourceNode);
|
|
return jsxAttributeEscape ? `"${escapeJsxAttributeString(text)}"` : neverAsciiEscape || getEmitFlags(node) & 33554432 /* NoAsciiEscaping */ ? `"${escapeString(text)}"` : `"${escapeNonAsciiString(text)}"`;
|
|
} else {
|
|
return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape);
|
|
}
|
|
}
|
|
const flags = (neverAsciiEscape ? 1 /* NeverAsciiEscape */ : 0) | (jsxAttributeEscape ? 2 /* JsxAttributeEscape */ : 0) | (printerOptions.terminateUnterminatedLiterals ? 4 /* TerminateUnterminatedLiterals */ : 0) | (printerOptions.target && printerOptions.target === 99 /* ESNext */ ? 8 /* AllowNumericSeparator */ : 0);
|
|
return getLiteralText(node, currentSourceFile, flags);
|
|
}
|
|
function pushNameGenerationScope(node) {
|
|
if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
return;
|
|
}
|
|
tempFlagsStack.push(tempFlags);
|
|
tempFlags = TempFlags.Auto;
|
|
privateNameTempFlagsStack.push(privateNameTempFlags);
|
|
privateNameTempFlags = TempFlags.Auto;
|
|
formattedNameTempFlagsStack.push(formattedNameTempFlags);
|
|
formattedNameTempFlags = void 0;
|
|
reservedNamesStack.push(reservedNames);
|
|
}
|
|
function popNameGenerationScope(node) {
|
|
if (node && getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
return;
|
|
}
|
|
tempFlags = tempFlagsStack.pop();
|
|
privateNameTempFlags = privateNameTempFlagsStack.pop();
|
|
formattedNameTempFlags = formattedNameTempFlagsStack.pop();
|
|
reservedNames = reservedNamesStack.pop();
|
|
}
|
|
function reserveNameInNestedScopes(name) {
|
|
if (!reservedNames || reservedNames === lastOrUndefined(reservedNamesStack)) {
|
|
reservedNames = /* @__PURE__ */ new Set();
|
|
}
|
|
reservedNames.add(name);
|
|
}
|
|
function generateNames(node) {
|
|
if (!node)
|
|
return;
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
forEach(node.statements, generateNames);
|
|
break;
|
|
case 253 /* LabeledStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
generateNames(node.statement);
|
|
break;
|
|
case 242 /* IfStatement */:
|
|
generateNames(node.thenStatement);
|
|
generateNames(node.elseStatement);
|
|
break;
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
generateNames(node.initializer);
|
|
generateNames(node.statement);
|
|
break;
|
|
case 252 /* SwitchStatement */:
|
|
generateNames(node.caseBlock);
|
|
break;
|
|
case 266 /* CaseBlock */:
|
|
forEach(node.clauses, generateNames);
|
|
break;
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
forEach(node.statements, generateNames);
|
|
break;
|
|
case 255 /* TryStatement */:
|
|
generateNames(node.tryBlock);
|
|
generateNames(node.catchClause);
|
|
generateNames(node.finallyBlock);
|
|
break;
|
|
case 295 /* CatchClause */:
|
|
generateNames(node.variableDeclaration);
|
|
generateNames(node.block);
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
generateNames(node.declarationList);
|
|
break;
|
|
case 258 /* VariableDeclarationList */:
|
|
forEach(node.declarations, generateNames);
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
generateNameIfNeeded(node.name);
|
|
if (getEmitFlags(node) & 1048576 /* ReuseTempVariableScope */) {
|
|
forEach(node.parameters, generateNames);
|
|
generateNames(node.body);
|
|
}
|
|
break;
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
forEach(node.elements, generateNames);
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
generateNames(node.importClause);
|
|
break;
|
|
case 270 /* ImportClause */:
|
|
generateNameIfNeeded(node.name);
|
|
generateNames(node.namedBindings);
|
|
break;
|
|
case 271 /* NamespaceImport */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 277 /* NamespaceExport */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
forEach(node.elements, generateNames);
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
generateNameIfNeeded(node.propertyName || node.name);
|
|
break;
|
|
}
|
|
}
|
|
function generateMemberNames(node) {
|
|
if (!node)
|
|
return;
|
|
switch (node.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
generateNameIfNeeded(node.name);
|
|
break;
|
|
}
|
|
}
|
|
function generateNameIfNeeded(name) {
|
|
if (name) {
|
|
if (isGeneratedIdentifier(name) || isGeneratedPrivateIdentifier(name)) {
|
|
generateName(name);
|
|
} else if (isBindingPattern(name)) {
|
|
generateNames(name);
|
|
}
|
|
}
|
|
}
|
|
function generateName(name) {
|
|
if ((name.autoGenerateFlags & 7 /* KindMask */) === 4 /* Node */) {
|
|
return generateNameCached(getNodeForGeneratedName(name), isPrivateIdentifier(name), name.autoGenerateFlags, name.autoGeneratePrefix, name.autoGenerateSuffix);
|
|
} else {
|
|
const autoGenerateId = name.autoGenerateId;
|
|
return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = makeName(name));
|
|
}
|
|
}
|
|
function generateNameCached(node, privateName, flags, prefix, suffix) {
|
|
const nodeId = getNodeId(node);
|
|
return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, privateName, flags != null ? flags : 0 /* None */, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
|
|
}
|
|
function isUniqueName(name) {
|
|
return isFileLevelUniqueName2(name) && !generatedNames.has(name) && !(reservedNames && reservedNames.has(name));
|
|
}
|
|
function isFileLevelUniqueName2(name) {
|
|
return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
|
|
}
|
|
function isUniqueLocalName(name, container) {
|
|
for (let node = container; isNodeDescendantOf(node, container); node = node.nextContainer) {
|
|
if (node.locals) {
|
|
const local = node.locals.get(escapeLeadingUnderscores(name));
|
|
if (local && local.flags & (111551 /* Value */ | 1048576 /* ExportValue */ | 2097152 /* Alias */)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getTempFlags(formattedNameKey) {
|
|
var _a2;
|
|
switch (formattedNameKey) {
|
|
case "":
|
|
return tempFlags;
|
|
case "#":
|
|
return privateNameTempFlags;
|
|
default:
|
|
return (_a2 = formattedNameTempFlags == null ? void 0 : formattedNameTempFlags.get(formattedNameKey)) != null ? _a2 : TempFlags.Auto;
|
|
}
|
|
}
|
|
function setTempFlags(formattedNameKey, flags) {
|
|
switch (formattedNameKey) {
|
|
case "":
|
|
tempFlags = flags;
|
|
break;
|
|
case "#":
|
|
privateNameTempFlags = flags;
|
|
break;
|
|
default:
|
|
formattedNameTempFlags != null ? formattedNameTempFlags : formattedNameTempFlags = /* @__PURE__ */ new Map();
|
|
formattedNameTempFlags.set(formattedNameKey, flags);
|
|
break;
|
|
}
|
|
}
|
|
function makeTempVariableName(flags, reservedInNestedScopes, privateName, prefix, suffix) {
|
|
if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* hash */) {
|
|
prefix = prefix.slice(1);
|
|
}
|
|
const key = formatGeneratedName(privateName, prefix, "", suffix);
|
|
let tempFlags2 = getTempFlags(key);
|
|
if (flags && !(tempFlags2 & flags)) {
|
|
const name = flags === TempFlags._i ? "_i" : "_n";
|
|
const fullName = formatGeneratedName(privateName, prefix, name, suffix);
|
|
if (isUniqueName(fullName)) {
|
|
tempFlags2 |= flags;
|
|
if (reservedInNestedScopes) {
|
|
reserveNameInNestedScopes(fullName);
|
|
}
|
|
setTempFlags(key, tempFlags2);
|
|
return fullName;
|
|
}
|
|
}
|
|
while (true) {
|
|
const count = tempFlags2 & TempFlags.CountMask;
|
|
tempFlags2++;
|
|
if (count !== 8 && count !== 13) {
|
|
const name = count < 26 ? "_" + String.fromCharCode(97 /* a */ + count) : "_" + (count - 26);
|
|
const fullName = formatGeneratedName(privateName, prefix, name, suffix);
|
|
if (isUniqueName(fullName)) {
|
|
if (reservedInNestedScopes) {
|
|
reserveNameInNestedScopes(fullName);
|
|
}
|
|
setTempFlags(key, tempFlags2);
|
|
return fullName;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function makeUniqueName2(baseName, checkFn = isUniqueName, optimistic, scoped, privateName, prefix, suffix) {
|
|
if (baseName.length > 0 && baseName.charCodeAt(0) === 35 /* hash */) {
|
|
baseName = baseName.slice(1);
|
|
}
|
|
if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* hash */) {
|
|
prefix = prefix.slice(1);
|
|
}
|
|
if (optimistic) {
|
|
const fullName = formatGeneratedName(privateName, prefix, baseName, suffix);
|
|
if (checkFn(fullName)) {
|
|
if (scoped) {
|
|
reserveNameInNestedScopes(fullName);
|
|
} else {
|
|
generatedNames.add(fullName);
|
|
}
|
|
return fullName;
|
|
}
|
|
}
|
|
if (baseName.charCodeAt(baseName.length - 1) !== 95 /* _ */) {
|
|
baseName += "_";
|
|
}
|
|
let i = 1;
|
|
while (true) {
|
|
const fullName = formatGeneratedName(privateName, prefix, baseName + i, suffix);
|
|
if (checkFn(fullName)) {
|
|
if (scoped) {
|
|
reserveNameInNestedScopes(fullName);
|
|
} else {
|
|
generatedNames.add(fullName);
|
|
}
|
|
return fullName;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
function makeFileLevelOptimisticUniqueName(name) {
|
|
return makeUniqueName2(name, isFileLevelUniqueName2, true, false, false, "", "");
|
|
}
|
|
function generateNameForModuleOrEnum(node) {
|
|
const name = getTextOfNode2(node.name);
|
|
return isUniqueLocalName(name, node) ? name : makeUniqueName2(name, isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForImportOrExportDeclaration(node) {
|
|
const expr = getExternalModuleName(node);
|
|
const baseName = isStringLiteral(expr) ? makeIdentifierFromModuleName(expr.text) : "module";
|
|
return makeUniqueName2(baseName, isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForExportDefault() {
|
|
return makeUniqueName2("default", isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForClassExpression() {
|
|
return makeUniqueName2("class", isUniqueName, false, false, false, "", "");
|
|
}
|
|
function generateNameForMethodOrAccessor(node, privateName, prefix, suffix) {
|
|
if (isIdentifier(node.name)) {
|
|
return generateNameCached(node.name, privateName);
|
|
}
|
|
return makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
|
|
}
|
|
function generateNameForNode(node, privateName, flags, prefix, suffix) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
return makeUniqueName2(
|
|
getTextOfNode2(node),
|
|
isUniqueName,
|
|
!!(flags & 16 /* Optimistic */),
|
|
!!(flags & 8 /* ReservedInNestedScopes */),
|
|
privateName,
|
|
prefix,
|
|
suffix
|
|
);
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForModuleOrEnum(node);
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForImportOrExportDeclaration(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForExportDefault();
|
|
case 228 /* ClassExpression */:
|
|
Debug.assert(!prefix && !suffix && !privateName);
|
|
return generateNameForClassExpression();
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return generateNameForMethodOrAccessor(node, privateName, prefix, suffix);
|
|
case 164 /* ComputedPropertyName */:
|
|
return makeTempVariableName(TempFlags.Auto, true, privateName, prefix, suffix);
|
|
default:
|
|
return makeTempVariableName(TempFlags.Auto, false, privateName, prefix, suffix);
|
|
}
|
|
}
|
|
function makeName(name) {
|
|
const prefix = formatGeneratedNamePart(name.autoGeneratePrefix, generateName);
|
|
const suffix = formatGeneratedNamePart(name.autoGenerateSuffix);
|
|
switch (name.autoGenerateFlags & 7 /* KindMask */) {
|
|
case 1 /* Auto */:
|
|
return makeTempVariableName(TempFlags.Auto, !!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */), isPrivateIdentifier(name), prefix, suffix);
|
|
case 2 /* Loop */:
|
|
Debug.assertNode(name, isIdentifier);
|
|
return makeTempVariableName(TempFlags._i, !!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */), false, prefix, suffix);
|
|
case 3 /* Unique */:
|
|
return makeUniqueName2(
|
|
idText(name),
|
|
name.autoGenerateFlags & 32 /* FileLevel */ ? isFileLevelUniqueName2 : isUniqueName,
|
|
!!(name.autoGenerateFlags & 16 /* Optimistic */),
|
|
!!(name.autoGenerateFlags & 8 /* ReservedInNestedScopes */),
|
|
isPrivateIdentifier(name),
|
|
prefix,
|
|
suffix
|
|
);
|
|
}
|
|
return Debug.fail(`Unsupported GeneratedIdentifierKind: ${Debug.formatEnum(name.autoGenerateFlags & 7 /* KindMask */, GeneratedIdentifierFlags, true)}.`);
|
|
}
|
|
function pipelineEmitWithComments(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(2 /* Comments */, hint, node);
|
|
const savedContainerPos = containerPos;
|
|
const savedContainerEnd = containerEnd;
|
|
const savedDeclarationListContainerEnd = declarationListContainerEnd;
|
|
emitCommentsBeforeNode(node);
|
|
pipelinePhase(hint, node);
|
|
emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
}
|
|
function emitCommentsBeforeNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const commentRange = getCommentRange(node);
|
|
emitLeadingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end);
|
|
if (emitFlags & 4096 /* NoNestedComments */) {
|
|
commentsDisabled = true;
|
|
}
|
|
}
|
|
function emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const commentRange = getCommentRange(node);
|
|
if (emitFlags & 4096 /* NoNestedComments */) {
|
|
commentsDisabled = false;
|
|
}
|
|
emitTrailingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
const typeNode = getTypeNode(node);
|
|
if (typeNode) {
|
|
emitTrailingCommentsOfNode(node, emitFlags, typeNode.pos, typeNode.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd);
|
|
}
|
|
}
|
|
function emitLeadingCommentsOfNode(node, emitFlags, pos, end) {
|
|
enterComment();
|
|
hasWrittenComment = false;
|
|
const skipLeadingComments = pos < 0 || (emitFlags & 1024 /* NoLeadingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
const skipTrailingComments = end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
if ((pos > 0 || end > 0) && pos !== end) {
|
|
if (!skipLeadingComments) {
|
|
emitLeadingComments(pos, node.kind !== 352 /* NotEmittedStatement */);
|
|
}
|
|
if (!skipLeadingComments || pos >= 0 && (emitFlags & 1024 /* NoLeadingComments */) !== 0) {
|
|
containerPos = pos;
|
|
}
|
|
if (!skipTrailingComments || end >= 0 && (emitFlags & 2048 /* NoTrailingComments */) !== 0) {
|
|
containerEnd = end;
|
|
if (node.kind === 258 /* VariableDeclarationList */) {
|
|
declarationListContainerEnd = end;
|
|
}
|
|
}
|
|
}
|
|
forEach(getSyntheticLeadingComments(node), emitLeadingSynthesizedComment);
|
|
exitComment();
|
|
}
|
|
function emitTrailingCommentsOfNode(node, emitFlags, pos, end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) {
|
|
enterComment();
|
|
const skipTrailingComments = end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0 || node.kind === 11 /* JsxText */;
|
|
forEach(getSyntheticTrailingComments(node), emitTrailingSynthesizedComment);
|
|
if ((pos > 0 || end > 0) && pos !== end) {
|
|
containerPos = savedContainerPos;
|
|
containerEnd = savedContainerEnd;
|
|
declarationListContainerEnd = savedDeclarationListContainerEnd;
|
|
if (!skipTrailingComments && node.kind !== 352 /* NotEmittedStatement */) {
|
|
emitTrailingComments(end);
|
|
}
|
|
}
|
|
exitComment();
|
|
}
|
|
function emitLeadingSynthesizedComment(comment) {
|
|
if (comment.hasLeadingNewline || comment.kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
}
|
|
writeSynthesizedComment(comment);
|
|
if (comment.hasTrailingNewLine || comment.kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
} else {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function emitTrailingSynthesizedComment(comment) {
|
|
if (!writer.isAtStartOfLine()) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
writeSynthesizedComment(comment);
|
|
if (comment.hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function writeSynthesizedComment(comment) {
|
|
const text = formatSynthesizedComment(comment);
|
|
const lineMap = comment.kind === 3 /* MultiLineCommentTrivia */ ? computeLineStarts(text) : void 0;
|
|
writeCommentRange(text, lineMap, writer, 0, text.length, newLine);
|
|
}
|
|
function formatSynthesizedComment(comment) {
|
|
return comment.kind === 3 /* MultiLineCommentTrivia */ ? `/*${comment.text}*/` : `//${comment.text}`;
|
|
}
|
|
function emitBodyWithDetachedComments(node, detachedRange, emitCallback) {
|
|
enterComment();
|
|
const { pos, end } = detachedRange;
|
|
const emitFlags = getEmitFlags(node);
|
|
const skipLeadingComments = pos < 0 || (emitFlags & 1024 /* NoLeadingComments */) !== 0;
|
|
const skipTrailingComments = commentsDisabled || end < 0 || (emitFlags & 2048 /* NoTrailingComments */) !== 0;
|
|
if (!skipLeadingComments) {
|
|
emitDetachedCommentsAndUpdateCommentsInfo(detachedRange);
|
|
}
|
|
exitComment();
|
|
if (emitFlags & 4096 /* NoNestedComments */ && !commentsDisabled) {
|
|
commentsDisabled = true;
|
|
emitCallback(node);
|
|
commentsDisabled = false;
|
|
} else {
|
|
emitCallback(node);
|
|
}
|
|
enterComment();
|
|
if (!skipTrailingComments) {
|
|
emitLeadingComments(detachedRange.end, true);
|
|
if (hasWrittenComment && !writer.isAtStartOfLine()) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
exitComment();
|
|
}
|
|
function originalNodesHaveSameParent(nodeA, nodeB) {
|
|
nodeA = getOriginalNode(nodeA);
|
|
return nodeA.parent && nodeA.parent === getOriginalNode(nodeB).parent;
|
|
}
|
|
function siblingNodePositionsAreComparable(previousNode, nextNode) {
|
|
if (nextNode.pos < previousNode.end) {
|
|
return false;
|
|
}
|
|
previousNode = getOriginalNode(previousNode);
|
|
nextNode = getOriginalNode(nextNode);
|
|
const parent2 = previousNode.parent;
|
|
if (!parent2 || parent2 !== nextNode.parent) {
|
|
return false;
|
|
}
|
|
const parentNodeArray = getContainingNodeArray(previousNode);
|
|
const prevNodeIndex = parentNodeArray == null ? void 0 : parentNodeArray.indexOf(previousNode);
|
|
return prevNodeIndex !== void 0 && prevNodeIndex > -1 && parentNodeArray.indexOf(nextNode) === prevNodeIndex + 1;
|
|
}
|
|
function emitLeadingComments(pos, isEmittedNode) {
|
|
hasWrittenComment = false;
|
|
if (isEmittedNode) {
|
|
if (pos === 0 && (currentSourceFile == null ? void 0 : currentSourceFile.isDeclarationFile)) {
|
|
forEachLeadingCommentToEmit(pos, emitNonTripleSlashLeadingComment);
|
|
} else {
|
|
forEachLeadingCommentToEmit(pos, emitLeadingComment);
|
|
}
|
|
} else if (pos === 0) {
|
|
forEachLeadingCommentToEmit(pos, emitTripleSlashLeadingComment);
|
|
}
|
|
}
|
|
function emitTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
|
|
if (isTripleSlashComment(commentPos, commentEnd)) {
|
|
emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos);
|
|
}
|
|
}
|
|
function emitNonTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
|
|
if (!isTripleSlashComment(commentPos, commentEnd)) {
|
|
emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos);
|
|
}
|
|
}
|
|
function shouldWriteComment(text, pos) {
|
|
if (printerOptions.onlyPrintJsDocStyle) {
|
|
return isJSDocLikeText(text, pos) || isPinnedComment(text, pos);
|
|
}
|
|
return true;
|
|
}
|
|
function emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
if (!hasWrittenComment) {
|
|
emitNewLineBeforeLeadingCommentOfPosition(getCurrentLineMap(), writer, rangePos, commentPos);
|
|
hasWrittenComment = true;
|
|
}
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
} else if (kind === 3 /* MultiLineCommentTrivia */) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function emitLeadingCommentsOfPosition(pos) {
|
|
if (commentsDisabled || pos === -1) {
|
|
return;
|
|
}
|
|
emitLeadingComments(pos, true);
|
|
}
|
|
function emitTrailingComments(pos) {
|
|
forEachTrailingCommentToEmit(pos, emitTrailingComment);
|
|
}
|
|
function emitTrailingComment(commentPos, commentEnd, _kind, hasTrailingNewLine) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
if (!writer.isAtStartOfLine()) {
|
|
writer.writeSpace(" ");
|
|
}
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitTrailingCommentsOfPosition(pos, prefixSpace, forceNoNewline) {
|
|
if (commentsDisabled) {
|
|
return;
|
|
}
|
|
enterComment();
|
|
forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : forceNoNewline ? emitTrailingCommentOfPositionNoNewline : emitTrailingCommentOfPosition);
|
|
exitComment();
|
|
}
|
|
function emitTrailingCommentOfPositionNoNewline(commentPos, commentEnd, kind) {
|
|
if (!currentSourceFile)
|
|
return;
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (kind === 2 /* SingleLineCommentTrivia */) {
|
|
writer.writeLine();
|
|
}
|
|
}
|
|
function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) {
|
|
if (!currentSourceFile)
|
|
return;
|
|
emitPos(commentPos);
|
|
writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine);
|
|
emitPos(commentEnd);
|
|
if (hasTrailingNewLine) {
|
|
writer.writeLine();
|
|
} else {
|
|
writer.writeSpace(" ");
|
|
}
|
|
}
|
|
function forEachLeadingCommentToEmit(pos, cb) {
|
|
if (currentSourceFile && (containerPos === -1 || pos !== containerPos)) {
|
|
if (hasDetachedComments(pos)) {
|
|
forEachLeadingCommentWithoutDetachedComments(cb);
|
|
} else {
|
|
forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos);
|
|
}
|
|
}
|
|
}
|
|
function forEachTrailingCommentToEmit(end, cb) {
|
|
if (currentSourceFile && (containerEnd === -1 || end !== containerEnd && end !== declarationListContainerEnd)) {
|
|
forEachTrailingCommentRange(currentSourceFile.text, end, cb);
|
|
}
|
|
}
|
|
function hasDetachedComments(pos) {
|
|
return detachedCommentsInfo !== void 0 && last(detachedCommentsInfo).nodePos === pos;
|
|
}
|
|
function forEachLeadingCommentWithoutDetachedComments(cb) {
|
|
if (!currentSourceFile)
|
|
return;
|
|
const pos = last(detachedCommentsInfo).detachedCommentEndPos;
|
|
if (detachedCommentsInfo.length - 1) {
|
|
detachedCommentsInfo.pop();
|
|
} else {
|
|
detachedCommentsInfo = void 0;
|
|
}
|
|
forEachLeadingCommentRange(currentSourceFile.text, pos, cb, pos);
|
|
}
|
|
function emitDetachedCommentsAndUpdateCommentsInfo(range) {
|
|
const currentDetachedCommentInfo = currentSourceFile && emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled);
|
|
if (currentDetachedCommentInfo) {
|
|
if (detachedCommentsInfo) {
|
|
detachedCommentsInfo.push(currentDetachedCommentInfo);
|
|
} else {
|
|
detachedCommentsInfo = [currentDetachedCommentInfo];
|
|
}
|
|
}
|
|
}
|
|
function emitComment(text, lineMap, writer2, commentPos, commentEnd, newLine2) {
|
|
if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos))
|
|
return;
|
|
emitPos(commentPos);
|
|
writeCommentRange(text, lineMap, writer2, commentPos, commentEnd, newLine2);
|
|
emitPos(commentEnd);
|
|
}
|
|
function isTripleSlashComment(commentPos, commentEnd) {
|
|
return !!currentSourceFile && isRecognizedTripleSlashComment(currentSourceFile.text, commentPos, commentEnd);
|
|
}
|
|
function getParsedSourceMap(node) {
|
|
if (node.parsedSourceMap === void 0 && node.sourceMapText !== void 0) {
|
|
node.parsedSourceMap = tryParseRawSourceMap(node.sourceMapText) || false;
|
|
}
|
|
return node.parsedSourceMap || void 0;
|
|
}
|
|
function pipelineEmitWithSourceMaps(hint, node) {
|
|
const pipelinePhase = getNextPipelinePhase(3 /* SourceMaps */, hint, node);
|
|
emitSourceMapsBeforeNode(node);
|
|
pipelinePhase(hint, node);
|
|
emitSourceMapsAfterNode(node);
|
|
}
|
|
function emitSourceMapsBeforeNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
if (isUnparsedNode(node)) {
|
|
Debug.assertIsDefined(node.parent, "UnparsedNodes must have parent pointers");
|
|
const parsed = getParsedSourceMap(node.parent);
|
|
if (parsed && sourceMapGenerator) {
|
|
sourceMapGenerator.appendSourceMap(
|
|
writer.getLine(),
|
|
writer.getColumn(),
|
|
parsed,
|
|
node.parent.sourceMapPath,
|
|
node.parent.getLineAndCharacterOfPosition(node.pos),
|
|
node.parent.getLineAndCharacterOfPosition(node.end)
|
|
);
|
|
}
|
|
} else {
|
|
const source = sourceMapRange.source || sourceMapSource;
|
|
if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 32 /* NoLeadingSourceMap */) === 0 && sourceMapRange.pos >= 0) {
|
|
emitSourcePos(sourceMapRange.source || sourceMapSource, skipSourceTrivia(source, sourceMapRange.pos));
|
|
}
|
|
if (emitFlags & 128 /* NoNestedSourceMaps */) {
|
|
sourceMapsDisabled = true;
|
|
}
|
|
}
|
|
}
|
|
function emitSourceMapsAfterNode(node) {
|
|
const emitFlags = getEmitFlags(node);
|
|
const sourceMapRange = getSourceMapRange(node);
|
|
if (!isUnparsedNode(node)) {
|
|
if (emitFlags & 128 /* NoNestedSourceMaps */) {
|
|
sourceMapsDisabled = false;
|
|
}
|
|
if (node.kind !== 352 /* NotEmittedStatement */ && (emitFlags & 64 /* NoTrailingSourceMap */) === 0 && sourceMapRange.end >= 0) {
|
|
emitSourcePos(sourceMapRange.source || sourceMapSource, sourceMapRange.end);
|
|
}
|
|
}
|
|
}
|
|
function skipSourceTrivia(source, pos) {
|
|
return source.skipTrivia ? source.skipTrivia(pos) : skipTrivia(source.text, pos);
|
|
}
|
|
function emitPos(pos) {
|
|
if (sourceMapsDisabled || positionIsSynthesized(pos) || isJsonSourceMapSource(sourceMapSource)) {
|
|
return;
|
|
}
|
|
const { line: sourceLine, character: sourceCharacter } = getLineAndCharacterOfPosition(sourceMapSource, pos);
|
|
sourceMapGenerator.addMapping(
|
|
writer.getLine(),
|
|
writer.getColumn(),
|
|
sourceMapSourceIndex,
|
|
sourceLine,
|
|
sourceCharacter,
|
|
void 0
|
|
);
|
|
}
|
|
function emitSourcePos(source, pos) {
|
|
if (source !== sourceMapSource) {
|
|
const savedSourceMapSource = sourceMapSource;
|
|
const savedSourceMapSourceIndex = sourceMapSourceIndex;
|
|
setSourceMapSource(source);
|
|
emitPos(pos);
|
|
resetSourceMapSource(savedSourceMapSource, savedSourceMapSourceIndex);
|
|
} else {
|
|
emitPos(pos);
|
|
}
|
|
}
|
|
function emitTokenWithSourceMap(node, token, writer2, tokenPos, emitCallback) {
|
|
if (sourceMapsDisabled || node && isInJsonFile(node)) {
|
|
return emitCallback(token, writer2, tokenPos);
|
|
}
|
|
const emitNode = node && node.emitNode;
|
|
const emitFlags = emitNode && emitNode.flags || 0 /* None */;
|
|
const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
|
|
const source = range && range.source || sourceMapSource;
|
|
tokenPos = skipSourceTrivia(source, range ? range.pos : tokenPos);
|
|
if ((emitFlags & 256 /* NoTokenLeadingSourceMaps */) === 0 && tokenPos >= 0) {
|
|
emitSourcePos(source, tokenPos);
|
|
}
|
|
tokenPos = emitCallback(token, writer2, tokenPos);
|
|
if (range)
|
|
tokenPos = range.end;
|
|
if ((emitFlags & 512 /* NoTokenTrailingSourceMaps */) === 0 && tokenPos >= 0) {
|
|
emitSourcePos(source, tokenPos);
|
|
}
|
|
return tokenPos;
|
|
}
|
|
function setSourceMapSource(source) {
|
|
if (sourceMapsDisabled) {
|
|
return;
|
|
}
|
|
sourceMapSource = source;
|
|
if (source === mostRecentlyAddedSourceMapSource) {
|
|
sourceMapSourceIndex = mostRecentlyAddedSourceMapSourceIndex;
|
|
return;
|
|
}
|
|
if (isJsonSourceMapSource(source)) {
|
|
return;
|
|
}
|
|
sourceMapSourceIndex = sourceMapGenerator.addSource(source.fileName);
|
|
if (printerOptions.inlineSources) {
|
|
sourceMapGenerator.setSourceContent(sourceMapSourceIndex, source.text);
|
|
}
|
|
mostRecentlyAddedSourceMapSource = source;
|
|
mostRecentlyAddedSourceMapSourceIndex = sourceMapSourceIndex;
|
|
}
|
|
function resetSourceMapSource(source, sourceIndex) {
|
|
sourceMapSource = source;
|
|
sourceMapSourceIndex = sourceIndex;
|
|
}
|
|
function isJsonSourceMapSource(sourceFile) {
|
|
return fileExtensionIs(sourceFile.fileName, ".json" /* Json */);
|
|
}
|
|
}
|
|
function createBracketsMap() {
|
|
const brackets2 = [];
|
|
brackets2[1024 /* Braces */] = ["{", "}"];
|
|
brackets2[2048 /* Parenthesis */] = ["(", ")"];
|
|
brackets2[4096 /* AngleBrackets */] = ["<", ">"];
|
|
brackets2[8192 /* SquareBrackets */] = ["[", "]"];
|
|
return brackets2;
|
|
}
|
|
function getOpeningBracket(format) {
|
|
return brackets[format & 15360 /* BracketsMask */][0];
|
|
}
|
|
function getClosingBracket(format) {
|
|
return brackets[format & 15360 /* BracketsMask */][1];
|
|
}
|
|
var TempFlags = /* @__PURE__ */ ((TempFlags2) => {
|
|
TempFlags2[TempFlags2["Auto"] = 0] = "Auto";
|
|
TempFlags2[TempFlags2["CountMask"] = 268435455] = "CountMask";
|
|
TempFlags2[TempFlags2["_i"] = 268435456] = "_i";
|
|
return TempFlags2;
|
|
})(TempFlags || {});
|
|
function emitListItemNoParenthesizer(node, emit, _parenthesizerRule, _index) {
|
|
emit(node);
|
|
}
|
|
function emitListItemWithParenthesizerRuleSelector(node, emit, parenthesizerRuleSelector, index) {
|
|
emit(node, parenthesizerRuleSelector.select(index));
|
|
}
|
|
function emitListItemWithParenthesizerRule(node, emit, parenthesizerRule, _index) {
|
|
emit(node, parenthesizerRule);
|
|
}
|
|
function getEmitListItem(emit, parenthesizerRule) {
|
|
return emit.length === 1 ? emitListItemNoParenthesizer : typeof parenthesizerRule === "object" ? emitListItemWithParenthesizerRuleSelector : emitListItemWithParenthesizerRule;
|
|
}
|
|
|
|
// src/compiler/watchUtilities.ts
|
|
function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames) {
|
|
if (!host.getDirectories || !host.readDirectory) {
|
|
return void 0;
|
|
}
|
|
const cachedReadDirectoryResult = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
return {
|
|
useCaseSensitiveFileNames,
|
|
fileExists,
|
|
readFile: (path, encoding) => host.readFile(path, encoding),
|
|
directoryExists: host.directoryExists && directoryExists,
|
|
getDirectories,
|
|
readDirectory,
|
|
createDirectory: host.createDirectory && createDirectory,
|
|
writeFile: host.writeFile && writeFile2,
|
|
addOrDeleteFileOrDirectory,
|
|
addOrDeleteFile,
|
|
clearCache,
|
|
realpath: host.realpath && realpath
|
|
};
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function getCachedFileSystemEntries(rootDirPath) {
|
|
return cachedReadDirectoryResult.get(ensureTrailingDirectorySeparator(rootDirPath));
|
|
}
|
|
function getCachedFileSystemEntriesForBaseDir(path) {
|
|
const entries = getCachedFileSystemEntries(getDirectoryPath(path));
|
|
if (!entries) {
|
|
return entries;
|
|
}
|
|
if (!entries.sortedAndCanonicalizedFiles) {
|
|
entries.sortedAndCanonicalizedFiles = entries.files.map(getCanonicalFileName).sort();
|
|
entries.sortedAndCanonicalizedDirectories = entries.directories.map(getCanonicalFileName).sort();
|
|
}
|
|
return entries;
|
|
}
|
|
function getBaseNameOfFileName(fileName) {
|
|
return getBaseFileName(normalizePath(fileName));
|
|
}
|
|
function createCachedFileSystemEntries(rootDir, rootDirPath) {
|
|
var _a2;
|
|
if (!host.realpath || ensureTrailingDirectorySeparator(toPath3(host.realpath(rootDir))) === rootDirPath) {
|
|
const resultFromHost = {
|
|
files: map(host.readDirectory(rootDir, void 0, void 0, ["*.*"]), getBaseNameOfFileName) || [],
|
|
directories: host.getDirectories(rootDir) || []
|
|
};
|
|
cachedReadDirectoryResult.set(ensureTrailingDirectorySeparator(rootDirPath), resultFromHost);
|
|
return resultFromHost;
|
|
}
|
|
if ((_a2 = host.directoryExists) == null ? void 0 : _a2.call(host, rootDir)) {
|
|
cachedReadDirectoryResult.set(rootDirPath, false);
|
|
return false;
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryReadDirectory2(rootDir, rootDirPath) {
|
|
rootDirPath = ensureTrailingDirectorySeparator(rootDirPath);
|
|
const cachedResult = getCachedFileSystemEntries(rootDirPath);
|
|
if (cachedResult) {
|
|
return cachedResult;
|
|
}
|
|
try {
|
|
return createCachedFileSystemEntries(rootDir, rootDirPath);
|
|
} catch (_e) {
|
|
Debug.assert(!cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(rootDirPath)));
|
|
return void 0;
|
|
}
|
|
}
|
|
function hasEntry(entries, name) {
|
|
const index = binarySearch(entries, name, identity, compareStringsCaseSensitive);
|
|
return index >= 0;
|
|
}
|
|
function writeFile2(fileName, data, writeByteOrderMark) {
|
|
const path = toPath3(fileName);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
if (result) {
|
|
updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), true);
|
|
}
|
|
return host.writeFile(fileName, data, writeByteOrderMark);
|
|
}
|
|
function fileExists(fileName) {
|
|
const path = toPath3(fileName);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || host.fileExists(fileName);
|
|
}
|
|
function directoryExists(dirPath) {
|
|
const path = toPath3(dirPath);
|
|
return cachedReadDirectoryResult.has(ensureTrailingDirectorySeparator(path)) || host.directoryExists(dirPath);
|
|
}
|
|
function createDirectory(dirPath) {
|
|
const path = toPath3(dirPath);
|
|
const result = getCachedFileSystemEntriesForBaseDir(path);
|
|
if (result) {
|
|
const baseName = getBaseNameOfFileName(dirPath);
|
|
const canonicalizedBaseName = getCanonicalFileName(baseName);
|
|
const canonicalizedDirectories = result.sortedAndCanonicalizedDirectories;
|
|
if (insertSorted(canonicalizedDirectories, canonicalizedBaseName, compareStringsCaseSensitive)) {
|
|
result.directories.push(baseName);
|
|
}
|
|
}
|
|
host.createDirectory(dirPath);
|
|
}
|
|
function getDirectories(rootDir) {
|
|
const rootDirPath = toPath3(rootDir);
|
|
const result = tryReadDirectory2(rootDir, rootDirPath);
|
|
if (result) {
|
|
return result.directories.slice();
|
|
}
|
|
return host.getDirectories(rootDir);
|
|
}
|
|
function readDirectory(rootDir, extensions, excludes, includes, depth) {
|
|
const rootDirPath = toPath3(rootDir);
|
|
const rootResult = tryReadDirectory2(rootDir, rootDirPath);
|
|
let rootSymLinkResult;
|
|
if (rootResult !== void 0) {
|
|
return matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath);
|
|
}
|
|
return host.readDirectory(rootDir, extensions, excludes, includes, depth);
|
|
function getFileSystemEntries(dir) {
|
|
const path = toPath3(dir);
|
|
if (path === rootDirPath) {
|
|
return rootResult || getFileSystemEntriesFromHost(dir, path);
|
|
}
|
|
const result = tryReadDirectory2(dir, path);
|
|
return result !== void 0 ? result || getFileSystemEntriesFromHost(dir, path) : emptyFileSystemEntries;
|
|
}
|
|
function getFileSystemEntriesFromHost(dir, path) {
|
|
if (rootSymLinkResult && path === rootDirPath)
|
|
return rootSymLinkResult;
|
|
const result = {
|
|
files: map(host.readDirectory(dir, void 0, void 0, ["*.*"]), getBaseNameOfFileName) || emptyArray,
|
|
directories: host.getDirectories(dir) || emptyArray
|
|
};
|
|
if (path === rootDirPath)
|
|
rootSymLinkResult = result;
|
|
return result;
|
|
}
|
|
}
|
|
function realpath(s) {
|
|
return host.realpath ? host.realpath(s) : s;
|
|
}
|
|
function addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath) {
|
|
const existingResult = getCachedFileSystemEntries(fileOrDirectoryPath);
|
|
if (existingResult !== void 0) {
|
|
clearCache();
|
|
return void 0;
|
|
}
|
|
const parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath);
|
|
if (!parentResult) {
|
|
return void 0;
|
|
}
|
|
if (!host.directoryExists) {
|
|
clearCache();
|
|
return void 0;
|
|
}
|
|
const baseName = getBaseNameOfFileName(fileOrDirectory);
|
|
const fsQueryResult = {
|
|
fileExists: host.fileExists(fileOrDirectoryPath),
|
|
directoryExists: host.directoryExists(fileOrDirectoryPath)
|
|
};
|
|
if (fsQueryResult.directoryExists || hasEntry(parentResult.sortedAndCanonicalizedDirectories, getCanonicalFileName(baseName))) {
|
|
clearCache();
|
|
} else {
|
|
updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists);
|
|
}
|
|
return fsQueryResult;
|
|
}
|
|
function addOrDeleteFile(fileName, filePath, eventKind) {
|
|
if (eventKind === 1 /* Changed */) {
|
|
return;
|
|
}
|
|
const parentResult = getCachedFileSystemEntriesForBaseDir(filePath);
|
|
if (parentResult) {
|
|
updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === 0 /* Created */);
|
|
}
|
|
}
|
|
function updateFilesOfFileSystemEntry(parentResult, baseName, fileExists2) {
|
|
const canonicalizedFiles = parentResult.sortedAndCanonicalizedFiles;
|
|
const canonicalizedBaseName = getCanonicalFileName(baseName);
|
|
if (fileExists2) {
|
|
if (insertSorted(canonicalizedFiles, canonicalizedBaseName, compareStringsCaseSensitive)) {
|
|
parentResult.files.push(baseName);
|
|
}
|
|
} else {
|
|
const sortedIndex = binarySearch(canonicalizedFiles, canonicalizedBaseName, identity, compareStringsCaseSensitive);
|
|
if (sortedIndex >= 0) {
|
|
canonicalizedFiles.splice(sortedIndex, 1);
|
|
const unsortedIndex = parentResult.files.findIndex((entry) => getCanonicalFileName(entry) === canonicalizedBaseName);
|
|
parentResult.files.splice(unsortedIndex, 1);
|
|
}
|
|
}
|
|
}
|
|
function clearCache() {
|
|
cachedReadDirectoryResult.clear();
|
|
}
|
|
}
|
|
var ConfigFileProgramReloadLevel = /* @__PURE__ */ ((ConfigFileProgramReloadLevel2) => {
|
|
ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["None"] = 0] = "None";
|
|
ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Partial"] = 1] = "Partial";
|
|
ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Full"] = 2] = "Full";
|
|
return ConfigFileProgramReloadLevel2;
|
|
})(ConfigFileProgramReloadLevel || {});
|
|
function updateSharedExtendedConfigFileWatcher(projectPath, options, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath3) {
|
|
var _a2;
|
|
const extendedConfigs = arrayToMap(((_a2 = options == null ? void 0 : options.configFile) == null ? void 0 : _a2.extendedSourceFiles) || emptyArray, toPath3);
|
|
extendedConfigFilesMap.forEach((watcher, extendedConfigFilePath) => {
|
|
if (!extendedConfigs.has(extendedConfigFilePath)) {
|
|
watcher.projects.delete(projectPath);
|
|
watcher.close();
|
|
}
|
|
});
|
|
extendedConfigs.forEach((extendedConfigFileName, extendedConfigFilePath) => {
|
|
const existing = extendedConfigFilesMap.get(extendedConfigFilePath);
|
|
if (existing) {
|
|
existing.projects.add(projectPath);
|
|
} else {
|
|
extendedConfigFilesMap.set(extendedConfigFilePath, {
|
|
projects: /* @__PURE__ */ new Set([projectPath]),
|
|
watcher: createExtendedConfigFileWatch(extendedConfigFileName, extendedConfigFilePath),
|
|
close: () => {
|
|
const existing2 = extendedConfigFilesMap.get(extendedConfigFilePath);
|
|
if (!existing2 || existing2.projects.size !== 0)
|
|
return;
|
|
existing2.watcher.close();
|
|
extendedConfigFilesMap.delete(extendedConfigFilePath);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function clearSharedExtendedConfigFileWatcher(projectPath, extendedConfigFilesMap) {
|
|
extendedConfigFilesMap.forEach((watcher) => {
|
|
if (watcher.projects.delete(projectPath))
|
|
watcher.close();
|
|
});
|
|
}
|
|
function cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath3) {
|
|
if (!extendedConfigCache.delete(extendedConfigFilePath))
|
|
return;
|
|
extendedConfigCache.forEach(({ extendedResult }, key) => {
|
|
var _a2;
|
|
if ((_a2 = extendedResult.extendedSourceFiles) == null ? void 0 : _a2.some((extendedFile) => toPath3(extendedFile) === extendedConfigFilePath)) {
|
|
cleanExtendedConfigCache(extendedConfigCache, key, toPath3);
|
|
}
|
|
});
|
|
}
|
|
function updatePackageJsonWatch(lookups, packageJsonWatches, createPackageJsonWatch) {
|
|
const newMap = new Map(lookups);
|
|
mutateMap(
|
|
packageJsonWatches,
|
|
newMap,
|
|
{
|
|
createNewValue: createPackageJsonWatch,
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) {
|
|
const missingFilePaths = program.getMissingFilePaths();
|
|
const newMissingFilePathMap = arrayToMap(missingFilePaths, identity, returnTrue);
|
|
mutateMap(
|
|
missingFileWatches,
|
|
newMissingFilePathMap,
|
|
{
|
|
createNewValue: createMissingFileWatch,
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function updateWatchingWildcardDirectories(existingWatchedForWildcards, wildcardDirectories, watchDirectory) {
|
|
mutateMap(
|
|
existingWatchedForWildcards,
|
|
wildcardDirectories,
|
|
{
|
|
createNewValue: createWildcardDirectoryWatcher,
|
|
onDeleteValue: closeFileWatcherOf,
|
|
onExistingValue: updateWildcardDirectoryWatcher
|
|
}
|
|
);
|
|
function createWildcardDirectoryWatcher(directory, flags) {
|
|
return {
|
|
watcher: watchDirectory(directory, flags),
|
|
flags
|
|
};
|
|
}
|
|
function updateWildcardDirectoryWatcher(existingWatcher, flags, directory) {
|
|
if (existingWatcher.flags === flags) {
|
|
return;
|
|
}
|
|
existingWatcher.watcher.close();
|
|
existingWatchedForWildcards.set(directory, createWildcardDirectoryWatcher(directory, flags));
|
|
}
|
|
}
|
|
function isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath,
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName,
|
|
options,
|
|
program,
|
|
extraFileExtensions,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}) {
|
|
const newPath = removeIgnoredPath(fileOrDirectoryPath);
|
|
if (!newPath) {
|
|
writeLog(`Project: ${configFileName} Detected ignored path: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
fileOrDirectoryPath = newPath;
|
|
if (fileOrDirectoryPath === watchedDirPath)
|
|
return false;
|
|
if (hasExtension(fileOrDirectoryPath) && !isSupportedSourceFileName(fileOrDirectory, options, extraFileExtensions)) {
|
|
writeLog(`Project: ${configFileName} Detected file add/remove of non supported extension: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
if (isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) {
|
|
writeLog(`Project: ${configFileName} Detected excluded file: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
if (!program)
|
|
return false;
|
|
if (outFile(options) || options.outDir)
|
|
return false;
|
|
if (isDeclarationFileName(fileOrDirectoryPath)) {
|
|
if (options.declarationDir)
|
|
return false;
|
|
} else if (!fileExtensionIsOneOf(fileOrDirectoryPath, supportedJSExtensionsFlat)) {
|
|
return false;
|
|
}
|
|
const filePathWithoutExtension = removeFileExtension(fileOrDirectoryPath);
|
|
const realProgram = isArray(program) ? void 0 : isBuilderProgram(program) ? program.getProgramOrUndefined() : program;
|
|
const builderProgram = !realProgram && !isArray(program) ? program : void 0;
|
|
if (hasSourceFile(filePathWithoutExtension + ".ts" /* Ts */) || hasSourceFile(filePathWithoutExtension + ".tsx" /* Tsx */)) {
|
|
writeLog(`Project: ${configFileName} Detected output file: ${fileOrDirectory}`);
|
|
return true;
|
|
}
|
|
return false;
|
|
function hasSourceFile(file) {
|
|
return realProgram ? !!realProgram.getSourceFileByPath(file) : builderProgram ? builderProgram.getState().fileInfos.has(file) : !!find(program, (rootFile) => toPath3(rootFile) === file);
|
|
}
|
|
}
|
|
function isBuilderProgram(program) {
|
|
return !!program.getState;
|
|
}
|
|
function isEmittedFileOfProgram(program, file) {
|
|
if (!program) {
|
|
return false;
|
|
}
|
|
return program.isEmittedFile(file);
|
|
}
|
|
var WatchLogLevel = /* @__PURE__ */ ((WatchLogLevel2) => {
|
|
WatchLogLevel2[WatchLogLevel2["None"] = 0] = "None";
|
|
WatchLogLevel2[WatchLogLevel2["TriggerOnly"] = 1] = "TriggerOnly";
|
|
WatchLogLevel2[WatchLogLevel2["Verbose"] = 2] = "Verbose";
|
|
return WatchLogLevel2;
|
|
})(WatchLogLevel || {});
|
|
function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo2) {
|
|
setSysLog(watchLogLevel === 2 /* Verbose */ ? log : noop);
|
|
const plainInvokeFactory = {
|
|
watchFile: (file, callback, pollingInterval, options) => host.watchFile(file, callback, pollingInterval, options),
|
|
watchDirectory: (directory, callback, flags, options) => host.watchDirectory(directory, callback, (flags & 1 /* Recursive */) !== 0, options)
|
|
};
|
|
const triggerInvokingFactory = watchLogLevel !== 0 /* None */ ? {
|
|
watchFile: createTriggerLoggingAddWatch("watchFile"),
|
|
watchDirectory: createTriggerLoggingAddWatch("watchDirectory")
|
|
} : void 0;
|
|
const factory2 = watchLogLevel === 2 /* Verbose */ ? {
|
|
watchFile: createFileWatcherWithLogging,
|
|
watchDirectory: createDirectoryWatcherWithLogging
|
|
} : triggerInvokingFactory || plainInvokeFactory;
|
|
const excludeWatcherFactory = watchLogLevel === 2 /* Verbose */ ? createExcludeWatcherWithLogging : returnNoopFileWatcher;
|
|
return {
|
|
watchFile: createExcludeHandlingAddWatch("watchFile"),
|
|
watchDirectory: createExcludeHandlingAddWatch("watchDirectory")
|
|
};
|
|
function createExcludeHandlingAddWatch(key) {
|
|
return (file, cb, flags, options, detailInfo1, detailInfo2) => {
|
|
var _a2;
|
|
return !matchesExclude(file, key === "watchFile" ? options == null ? void 0 : options.excludeFiles : options == null ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames(), ((_a2 = host.getCurrentDirectory) == null ? void 0 : _a2.call(host)) || "") ? factory2[key].call(void 0, 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, getDetailWatchInfo2)}`);
|
|
return {
|
|
close: () => log(`ExcludeWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`)
|
|
};
|
|
}
|
|
function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
|
|
log(`FileWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`);
|
|
const watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2);
|
|
return {
|
|
close: () => {
|
|
log(`FileWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`);
|
|
watcher.close();
|
|
}
|
|
};
|
|
}
|
|
function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) {
|
|
const watchInfo = `DirectoryWatcher:: Added:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
|
|
log(watchInfo);
|
|
const start2 = timestamp();
|
|
const watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2);
|
|
const elapsed = timestamp() - start2;
|
|
log(`Elapsed:: ${elapsed}ms ${watchInfo}`);
|
|
return {
|
|
close: () => {
|
|
const watchInfo2 = `DirectoryWatcher:: Close:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
|
|
log(watchInfo2);
|
|
const start3 = timestamp();
|
|
watcher.close();
|
|
const elapsed2 = timestamp() - start3;
|
|
log(`Elapsed:: ${elapsed2}ms ${watchInfo2}`);
|
|
}
|
|
};
|
|
}
|
|
function createTriggerLoggingAddWatch(key) {
|
|
return (file, cb, flags, options, detailInfo1, detailInfo2) => plainInvokeFactory[key].call(void 0, file, (...args) => {
|
|
const triggerredInfo = `${key === "watchFile" ? "FileWatcher" : "DirectoryWatcher"}:: Triggered with ${args[0]} ${args[1] !== void 0 ? args[1] : ""}:: ${getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo2)}`;
|
|
log(triggerredInfo);
|
|
const start2 = timestamp();
|
|
cb.call(void 0, ...args);
|
|
const elapsed = timestamp() - start2;
|
|
log(`Elapsed:: ${elapsed}ms ${triggerredInfo}`);
|
|
}, flags, options, detailInfo1, detailInfo2);
|
|
}
|
|
function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo3) {
|
|
return `WatchInfo: ${file} ${flags} ${JSON.stringify(options)} ${getDetailWatchInfo3 ? getDetailWatchInfo3(detailInfo1, detailInfo2) : detailInfo2 === void 0 ? detailInfo1 : `${detailInfo1} ${detailInfo2}`}`;
|
|
}
|
|
}
|
|
function getFallbackOptions(options) {
|
|
const fallbackPolling = options == null ? void 0 : options.fallbackPolling;
|
|
return {
|
|
watchFile: fallbackPolling !== void 0 ? fallbackPolling : 1 /* PriorityPollingInterval */
|
|
};
|
|
}
|
|
function closeFileWatcherOf(objWithWatcher) {
|
|
objWithWatcher.watcher.close();
|
|
}
|
|
|
|
// src/compiler/program.ts
|
|
function findConfigFile(searchPath, fileExists, configName = "tsconfig.json") {
|
|
return forEachAncestorDirectory(searchPath, (ancestor) => {
|
|
const fileName = combinePaths(ancestor, configName);
|
|
return fileExists(fileName) ? fileName : void 0;
|
|
});
|
|
}
|
|
function resolveTripleslashReference(moduleName, containingFile) {
|
|
const basePath = getDirectoryPath(containingFile);
|
|
const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);
|
|
return normalizePath(referencedFileName);
|
|
}
|
|
function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) {
|
|
let commonPathComponents;
|
|
const failed = forEach(fileNames, (sourceFile) => {
|
|
const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory);
|
|
sourcePathComponents.pop();
|
|
if (!commonPathComponents) {
|
|
commonPathComponents = sourcePathComponents;
|
|
return;
|
|
}
|
|
const n = Math.min(commonPathComponents.length, sourcePathComponents.length);
|
|
for (let i = 0; i < n; i++) {
|
|
if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {
|
|
if (i === 0) {
|
|
return true;
|
|
}
|
|
commonPathComponents.length = i;
|
|
break;
|
|
}
|
|
}
|
|
if (sourcePathComponents.length < commonPathComponents.length) {
|
|
commonPathComponents.length = sourcePathComponents.length;
|
|
}
|
|
});
|
|
if (failed) {
|
|
return "";
|
|
}
|
|
if (!commonPathComponents) {
|
|
return currentDirectory;
|
|
}
|
|
return getPathFromPathComponents(commonPathComponents);
|
|
}
|
|
function createCompilerHost(options, setParentNodes) {
|
|
return createCompilerHostWorker(options, setParentNodes);
|
|
}
|
|
function createGetSourceFile(readFile, getCompilerOptions, setParentNodes) {
|
|
return (fileName, languageVersionOrOptions, onError) => {
|
|
let text;
|
|
try {
|
|
mark("beforeIORead");
|
|
text = readFile(fileName, getCompilerOptions().charset);
|
|
mark("afterIORead");
|
|
measure("I/O Read", "beforeIORead", "afterIORead");
|
|
} catch (e) {
|
|
if (onError) {
|
|
onError(e.message);
|
|
}
|
|
text = "";
|
|
}
|
|
return text !== void 0 ? createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : void 0;
|
|
};
|
|
}
|
|
function createWriteFileMeasuringIO(actualWriteFile, createDirectory, directoryExists) {
|
|
return (fileName, data, writeByteOrderMark, onError) => {
|
|
try {
|
|
mark("beforeIOWrite");
|
|
writeFileEnsuringDirectories(
|
|
fileName,
|
|
data,
|
|
writeByteOrderMark,
|
|
actualWriteFile,
|
|
createDirectory,
|
|
directoryExists
|
|
);
|
|
mark("afterIOWrite");
|
|
measure("I/O Write", "beforeIOWrite", "afterIOWrite");
|
|
} catch (e) {
|
|
if (onError) {
|
|
onError(e.message);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function createCompilerHostWorker(options, setParentNodes, system = sys) {
|
|
const existingDirectories = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);
|
|
function directoryExists(directoryPath) {
|
|
if (existingDirectories.has(directoryPath)) {
|
|
return true;
|
|
}
|
|
if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {
|
|
existingDirectories.set(directoryPath, true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getDefaultLibLocation() {
|
|
return getDirectoryPath(normalizePath(system.getExecutingFilePath()));
|
|
}
|
|
const newLine = getNewLineCharacter(options, () => system.newLine);
|
|
const realpath = system.realpath && ((path) => system.realpath(path));
|
|
const compilerHost = {
|
|
getSourceFile: createGetSourceFile((fileName) => compilerHost.readFile(fileName), () => options, setParentNodes),
|
|
getDefaultLibLocation,
|
|
getDefaultLibFileName: (options2) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options2)),
|
|
writeFile: createWriteFileMeasuringIO(
|
|
(path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
|
|
(path) => (compilerHost.createDirectory || system.createDirectory)(path),
|
|
(path) => directoryExists(path)
|
|
),
|
|
getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
|
|
useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
|
|
getCanonicalFileName,
|
|
getNewLine: () => newLine,
|
|
fileExists: (fileName) => system.fileExists(fileName),
|
|
readFile: (fileName) => system.readFile(fileName),
|
|
trace: (s) => system.write(s + newLine),
|
|
directoryExists: (directoryName) => system.directoryExists(directoryName),
|
|
getEnvironmentVariable: (name) => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",
|
|
getDirectories: (path) => system.getDirectories(path),
|
|
realpath,
|
|
readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
|
|
createDirectory: (d) => system.createDirectory(d),
|
|
createHash: maybeBind(system, system.createHash)
|
|
};
|
|
return compilerHost;
|
|
}
|
|
function changeCompilerHostLikeToUseCache(host, toPath3, getSourceFile) {
|
|
const originalReadFile = host.readFile;
|
|
const originalFileExists = host.fileExists;
|
|
const originalDirectoryExists = host.directoryExists;
|
|
const originalCreateDirectory = host.createDirectory;
|
|
const originalWriteFile = host.writeFile;
|
|
const readFileCache = /* @__PURE__ */ new Map();
|
|
const fileExistsCache = /* @__PURE__ */ new Map();
|
|
const directoryExistsCache = /* @__PURE__ */ new Map();
|
|
const sourceFileCache = /* @__PURE__ */ new Map();
|
|
const readFileWithCache = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0)
|
|
return value !== false ? value : void 0;
|
|
return setReadFileCache(key, fileName);
|
|
};
|
|
const setReadFileCache = (key, fileName) => {
|
|
const newValue = originalReadFile.call(host, fileName);
|
|
readFileCache.set(key, newValue !== void 0 ? newValue : false);
|
|
return newValue;
|
|
};
|
|
host.readFile = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0)
|
|
return value !== false ? value : void 0;
|
|
if (!fileExtensionIs(fileName, ".json" /* Json */) && !isBuildInfoFile(fileName)) {
|
|
return originalReadFile.call(host, fileName);
|
|
}
|
|
return setReadFileCache(key, fileName);
|
|
};
|
|
const getSourceFileWithCache = getSourceFile ? (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
|
|
const key = toPath3(fileName);
|
|
const impliedNodeFormat = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : void 0;
|
|
const forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat);
|
|
const value = forImpliedNodeFormat == null ? void 0 : forImpliedNodeFormat.get(key);
|
|
if (value)
|
|
return value;
|
|
const sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
|
|
if (sourceFile && (isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".json" /* Json */))) {
|
|
sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || /* @__PURE__ */ new Map()).set(key, sourceFile));
|
|
}
|
|
return sourceFile;
|
|
} : void 0;
|
|
host.fileExists = (fileName) => {
|
|
const key = toPath3(fileName);
|
|
const value = fileExistsCache.get(key);
|
|
if (value !== void 0)
|
|
return value;
|
|
const newValue = originalFileExists.call(host, fileName);
|
|
fileExistsCache.set(key, !!newValue);
|
|
return newValue;
|
|
};
|
|
if (originalWriteFile) {
|
|
host.writeFile = (fileName, data, ...rest) => {
|
|
const key = toPath3(fileName);
|
|
fileExistsCache.delete(key);
|
|
const value = readFileCache.get(key);
|
|
if (value !== void 0 && value !== data) {
|
|
readFileCache.delete(key);
|
|
sourceFileCache.forEach((map2) => map2.delete(key));
|
|
} else if (getSourceFileWithCache) {
|
|
sourceFileCache.forEach((map2) => {
|
|
const sourceFile = map2.get(key);
|
|
if (sourceFile && sourceFile.text !== data) {
|
|
map2.delete(key);
|
|
}
|
|
});
|
|
}
|
|
originalWriteFile.call(host, fileName, data, ...rest);
|
|
};
|
|
}
|
|
if (originalDirectoryExists) {
|
|
host.directoryExists = (directory) => {
|
|
const key = toPath3(directory);
|
|
const value = directoryExistsCache.get(key);
|
|
if (value !== void 0)
|
|
return value;
|
|
const newValue = originalDirectoryExists.call(host, directory);
|
|
directoryExistsCache.set(key, !!newValue);
|
|
return newValue;
|
|
};
|
|
if (originalCreateDirectory) {
|
|
host.createDirectory = (directory) => {
|
|
const key = toPath3(directory);
|
|
directoryExistsCache.delete(key);
|
|
originalCreateDirectory.call(host, directory);
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
getSourceFileWithCache,
|
|
readFileWithCache
|
|
};
|
|
}
|
|
function getPreEmitDiagnostics(program, sourceFile, cancellationToken) {
|
|
let diagnostics;
|
|
diagnostics = addRange(diagnostics, program.getConfigFileParsingDiagnostics());
|
|
diagnostics = addRange(diagnostics, program.getOptionsDiagnostics(cancellationToken));
|
|
diagnostics = addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile, cancellationToken));
|
|
diagnostics = addRange(diagnostics, program.getGlobalDiagnostics(cancellationToken));
|
|
diagnostics = addRange(diagnostics, program.getSemanticDiagnostics(sourceFile, cancellationToken));
|
|
if (getEmitDeclarations(program.getCompilerOptions())) {
|
|
diagnostics = addRange(diagnostics, program.getDeclarationDiagnostics(sourceFile, cancellationToken));
|
|
}
|
|
return sortAndDeduplicateDiagnostics(diagnostics || emptyArray);
|
|
}
|
|
function formatDiagnostics(diagnostics, host) {
|
|
let output = "";
|
|
for (const diagnostic of diagnostics) {
|
|
output += formatDiagnostic(diagnostic, host);
|
|
}
|
|
return output;
|
|
}
|
|
function formatDiagnostic(diagnostic, host) {
|
|
const errorMessage = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;
|
|
if (diagnostic.file) {
|
|
const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
|
|
const fileName = diagnostic.file.fileName;
|
|
const relativeFileName = convertToRelativePath(fileName, host.getCurrentDirectory(), (fileName2) => host.getCanonicalFileName(fileName2));
|
|
return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage;
|
|
}
|
|
return errorMessage;
|
|
}
|
|
var ForegroundColorEscapeSequences = /* @__PURE__ */ ((ForegroundColorEscapeSequences2) => {
|
|
ForegroundColorEscapeSequences2["Grey"] = "\x1B[90m";
|
|
ForegroundColorEscapeSequences2["Red"] = "\x1B[91m";
|
|
ForegroundColorEscapeSequences2["Yellow"] = "\x1B[93m";
|
|
ForegroundColorEscapeSequences2["Blue"] = "\x1B[94m";
|
|
ForegroundColorEscapeSequences2["Cyan"] = "\x1B[96m";
|
|
return ForegroundColorEscapeSequences2;
|
|
})(ForegroundColorEscapeSequences || {});
|
|
var gutterStyleSequence = "\x1B[7m";
|
|
var gutterSeparator = " ";
|
|
var resetEscapeSequence = "\x1B[0m";
|
|
var ellipsis = "...";
|
|
var halfIndent = " ";
|
|
var indent = " ";
|
|
function getCategoryFormat(category) {
|
|
switch (category) {
|
|
case 1 /* Error */:
|
|
return "\x1B[91m" /* Red */;
|
|
case 0 /* Warning */:
|
|
return "\x1B[93m" /* Yellow */;
|
|
case 2 /* Suggestion */:
|
|
return Debug.fail("Should never get an Info diagnostic on the command line.");
|
|
case 3 /* Message */:
|
|
return "\x1B[94m" /* Blue */;
|
|
}
|
|
}
|
|
function formatColorAndReset(text, formatStyle) {
|
|
return formatStyle + text + resetEscapeSequence;
|
|
}
|
|
function formatCodeSpan(file, start2, length2, indent3, squiggleColor, host) {
|
|
const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start2);
|
|
const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start2 + length2);
|
|
const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;
|
|
const hasMoreThanFiveLines = lastLine - firstLine >= 4;
|
|
let gutterWidth = (lastLine + 1 + "").length;
|
|
if (hasMoreThanFiveLines) {
|
|
gutterWidth = Math.max(ellipsis.length, gutterWidth);
|
|
}
|
|
let context = "";
|
|
for (let i = firstLine; i <= lastLine; i++) {
|
|
context += host.getNewLine();
|
|
if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {
|
|
context += indent3 + formatColorAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine();
|
|
i = lastLine - 1;
|
|
}
|
|
const lineStart = getPositionOfLineAndCharacter(file, i, 0);
|
|
const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;
|
|
let lineContent = file.text.slice(lineStart, lineEnd);
|
|
lineContent = trimStringEnd(lineContent);
|
|
lineContent = lineContent.replace(/\t/g, " ");
|
|
context += indent3 + formatColorAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;
|
|
context += lineContent + host.getNewLine();
|
|
context += indent3 + formatColorAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;
|
|
context += squiggleColor;
|
|
if (i === firstLine) {
|
|
const lastCharForLine = i === lastLine ? lastLineChar : void 0;
|
|
context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
|
|
context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");
|
|
} else if (i === lastLine) {
|
|
context += lineContent.slice(0, lastLineChar).replace(/./g, "~");
|
|
} else {
|
|
context += lineContent.replace(/./g, "~");
|
|
}
|
|
context += resetEscapeSequence;
|
|
}
|
|
return context;
|
|
}
|
|
function formatLocation(file, start2, host, color = formatColorAndReset) {
|
|
const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start2);
|
|
const relativeFileName = host ? convertToRelativePath(file.fileName, host.getCurrentDirectory(), (fileName) => host.getCanonicalFileName(fileName)) : file.fileName;
|
|
let output = "";
|
|
output += color(relativeFileName, "\x1B[96m" /* Cyan */);
|
|
output += ":";
|
|
output += color(`${firstLine + 1}`, "\x1B[93m" /* Yellow */);
|
|
output += ":";
|
|
output += color(`${firstLineChar + 1}`, "\x1B[93m" /* Yellow */);
|
|
return output;
|
|
}
|
|
function formatDiagnosticsWithColorAndContext(diagnostics, host) {
|
|
let output = "";
|
|
for (const diagnostic of diagnostics) {
|
|
if (diagnostic.file) {
|
|
const { file, start: start2 } = diagnostic;
|
|
output += formatLocation(file, start2, host);
|
|
output += " - ";
|
|
}
|
|
output += formatColorAndReset(diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category));
|
|
output += formatColorAndReset(` TS${diagnostic.code}: `, "\x1B[90m" /* Grey */);
|
|
output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine());
|
|
if (diagnostic.file) {
|
|
output += host.getNewLine();
|
|
output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", getCategoryFormat(diagnostic.category), host);
|
|
}
|
|
if (diagnostic.relatedInformation) {
|
|
output += host.getNewLine();
|
|
for (const { file, start: start2, length: length2, messageText } of diagnostic.relatedInformation) {
|
|
if (file) {
|
|
output += host.getNewLine();
|
|
output += halfIndent + formatLocation(file, start2, host);
|
|
output += formatCodeSpan(file, start2, length2, indent, "\x1B[96m" /* Cyan */, host);
|
|
}
|
|
output += host.getNewLine();
|
|
output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine());
|
|
}
|
|
}
|
|
output += host.getNewLine();
|
|
}
|
|
return output;
|
|
}
|
|
function flattenDiagnosticMessageText(diag2, newLine, indent3 = 0) {
|
|
if (isString(diag2)) {
|
|
return diag2;
|
|
} else if (diag2 === void 0) {
|
|
return "";
|
|
}
|
|
let result = "";
|
|
if (indent3) {
|
|
result += newLine;
|
|
for (let i = 0; i < indent3; i++) {
|
|
result += " ";
|
|
}
|
|
}
|
|
result += diag2.messageText;
|
|
indent3++;
|
|
if (diag2.next) {
|
|
for (const kid of diag2.next) {
|
|
result += flattenDiagnosticMessageText(kid, newLine, indent3);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) {
|
|
if (names.length === 0) {
|
|
return [];
|
|
}
|
|
const resolutions = [];
|
|
const cache = /* @__PURE__ */ new Map();
|
|
for (const name of names) {
|
|
let result;
|
|
const mode = getModeForFileReference(name, containingFileMode);
|
|
const strName = getResolutionName(name);
|
|
const cacheKey = mode !== void 0 ? `${mode}|${strName}` : strName;
|
|
if (cache.has(cacheKey)) {
|
|
result = cache.get(cacheKey);
|
|
} else {
|
|
cache.set(cacheKey, result = loader(strName, containingFile, redirectedReference, mode));
|
|
}
|
|
resolutions.push(result);
|
|
}
|
|
return resolutions;
|
|
}
|
|
function getModeForFileReference(ref, containingFileMode) {
|
|
return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;
|
|
}
|
|
function getModeForResolutionAtIndex(file, index) {
|
|
if (file.impliedNodeFormat === void 0)
|
|
return void 0;
|
|
return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index));
|
|
}
|
|
function isExclusivelyTypeOnlyImportOrExport(decl) {
|
|
var _a2;
|
|
if (isExportDeclaration(decl)) {
|
|
return decl.isTypeOnly;
|
|
}
|
|
if ((_a2 = decl.importClause) == null ? void 0 : _a2.isTypeOnly) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getModeForUsageLocation(file, usage) {
|
|
var _a2, _b;
|
|
if (file.impliedNodeFormat === void 0)
|
|
return void 0;
|
|
if (isImportDeclaration(usage.parent) || isExportDeclaration(usage.parent)) {
|
|
const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent);
|
|
if (isTypeOnly) {
|
|
const override = getResolutionModeOverrideForClause(usage.parent.assertClause);
|
|
if (override) {
|
|
return override;
|
|
}
|
|
}
|
|
}
|
|
if (usage.parent.parent && isImportTypeNode(usage.parent.parent)) {
|
|
const override = getResolutionModeOverrideForClause((_a2 = usage.parent.parent.assertions) == null ? void 0 : _a2.assertClause);
|
|
if (override) {
|
|
return override;
|
|
}
|
|
}
|
|
if (file.impliedNodeFormat !== 99 /* ESNext */) {
|
|
return isImportCall(walkUpParenthesizedExpressions(usage.parent)) ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
}
|
|
const exprParentParent = (_b = walkUpParenthesizedExpressions(usage.parent)) == null ? void 0 : _b.parent;
|
|
return exprParentParent && isImportEqualsDeclaration(exprParentParent) ? 1 /* CommonJS */ : 99 /* ESNext */;
|
|
}
|
|
function getResolutionModeOverrideForClause(clause, grammarErrorOnNode) {
|
|
if (!clause)
|
|
return void 0;
|
|
if (length(clause.elements) !== 1) {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(clause, Diagnostics.Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require);
|
|
return void 0;
|
|
}
|
|
const elem = clause.elements[0];
|
|
if (!isStringLiteralLike(elem.name))
|
|
return void 0;
|
|
if (elem.name.text !== "resolution-mode") {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(elem.name, Diagnostics.resolution_mode_is_the_only_valid_key_for_type_import_assertions);
|
|
return void 0;
|
|
}
|
|
if (!isStringLiteralLike(elem.value))
|
|
return void 0;
|
|
if (elem.value.text !== "import" && elem.value.text !== "require") {
|
|
grammarErrorOnNode == null ? void 0 : grammarErrorOnNode(elem.value, Diagnostics.resolution_mode_should_be_either_require_or_import);
|
|
return void 0;
|
|
}
|
|
return elem.value.text === "import" ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
}
|
|
function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, resolutionInfo, loader) {
|
|
if (names.length === 0) {
|
|
return [];
|
|
}
|
|
const resolutions = [];
|
|
const cache = /* @__PURE__ */ new Map();
|
|
let i = 0;
|
|
for (const entry of resolutionInfo ? resolutionInfo.names : names) {
|
|
let result;
|
|
const mode = !isString(entry) ? getModeForUsageLocation(containingFile, entry) : getModeForResolutionAtIndex(containingFile, i);
|
|
i++;
|
|
const name = isString(entry) ? entry : entry.text;
|
|
const cacheKey = mode !== void 0 ? `${mode}|${name}` : name;
|
|
if (cache.has(cacheKey)) {
|
|
result = cache.get(cacheKey);
|
|
} else {
|
|
cache.set(cacheKey, result = loader(name, mode, containingFileName, redirectedReference));
|
|
}
|
|
resolutions.push(result);
|
|
}
|
|
return resolutions;
|
|
}
|
|
function forEachResolvedProjectReference(resolvedProjectReferences, cb) {
|
|
return forEachProjectReference(void 0, resolvedProjectReferences, (resolvedRef, parent2) => resolvedRef && cb(resolvedRef, parent2));
|
|
}
|
|
function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) {
|
|
let seenResolvedRefs;
|
|
return worker(projectReferences, resolvedProjectReferences, void 0);
|
|
function worker(projectReferences2, resolvedProjectReferences2, parent2) {
|
|
if (cbRef) {
|
|
const result = cbRef(projectReferences2, parent2);
|
|
if (result)
|
|
return result;
|
|
}
|
|
return forEach(resolvedProjectReferences2, (resolvedRef, index) => {
|
|
if (resolvedRef && (seenResolvedRefs == null ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) {
|
|
return void 0;
|
|
}
|
|
const result = cbResolvedRef(resolvedRef, parent2, index);
|
|
if (result || !resolvedRef)
|
|
return result;
|
|
(seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Set())).add(resolvedRef.sourceFile.path);
|
|
return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef);
|
|
});
|
|
}
|
|
}
|
|
var inferredTypesContainingFile = "__inferred type names__.ts";
|
|
function isReferencedFile(reason) {
|
|
switch (reason == null ? void 0 : reason.kind) {
|
|
case 3 /* Import */:
|
|
case 4 /* ReferenceFile */:
|
|
case 5 /* TypeReferenceDirective */:
|
|
case 7 /* LibReferenceDirective */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isReferenceFileLocation(location2) {
|
|
return location2.pos !== void 0;
|
|
}
|
|
function getReferencedFileLocation(getSourceFileByPath, ref) {
|
|
var _a2, _b, _c, _d;
|
|
const file = Debug.checkDefined(getSourceFileByPath(ref.file));
|
|
const { kind, index } = ref;
|
|
let pos, end, packageId, resolutionMode;
|
|
switch (kind) {
|
|
case 3 /* Import */:
|
|
const importLiteral = getModuleNameStringLiteralAt(file, index);
|
|
packageId = (_b = (_a2 = file.resolvedModules) == null ? void 0 : _a2.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) == null ? void 0 : _b.packageId;
|
|
if (importLiteral.pos === -1)
|
|
return { file, packageId, text: importLiteral.text };
|
|
pos = skipTrivia(file.text, importLiteral.pos);
|
|
end = importLiteral.end;
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
({ pos, end } = file.referencedFiles[index]);
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
({ pos, end, resolutionMode } = file.typeReferenceDirectives[index]);
|
|
packageId = (_d = (_c = file.resolvedTypeReferenceDirectiveNames) == null ? void 0 : _c.get(toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) == null ? void 0 : _d.packageId;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
({ pos, end } = file.libReferenceDirectives[index]);
|
|
break;
|
|
default:
|
|
return Debug.assertNever(kind);
|
|
}
|
|
return { file, pos, end, packageId };
|
|
}
|
|
function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) {
|
|
if (!program || (hasChangedAutomaticTypeDirectiveNames == null ? void 0 : hasChangedAutomaticTypeDirectiveNames()))
|
|
return false;
|
|
if (!arrayIsEqualTo(program.getRootFileNames(), rootFileNames))
|
|
return false;
|
|
let seenResolvedRefs;
|
|
if (!arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate))
|
|
return false;
|
|
if (program.getSourceFiles().some(sourceFileNotUptoDate))
|
|
return false;
|
|
if (program.getMissingFilePaths().some(fileExists))
|
|
return false;
|
|
const currentOptions = program.getCompilerOptions();
|
|
if (!compareDataObjects(currentOptions, newOptions))
|
|
return false;
|
|
if (currentOptions.configFile && newOptions.configFile)
|
|
return currentOptions.configFile.text === newOptions.configFile.text;
|
|
return true;
|
|
function sourceFileNotUptoDate(sourceFile) {
|
|
return !sourceFileVersionUptoDate(sourceFile) || hasInvalidatedResolutions(sourceFile.path);
|
|
}
|
|
function sourceFileVersionUptoDate(sourceFile) {
|
|
return sourceFile.version === getSourceVersion(sourceFile.resolvedPath, sourceFile.fileName);
|
|
}
|
|
function projectReferenceUptoDate(oldRef, newRef, index) {
|
|
return projectReferenceIsEqualTo(oldRef, newRef) && resolvedProjectReferenceUptoDate(program.getResolvedProjectReferences()[index], oldRef);
|
|
}
|
|
function resolvedProjectReferenceUptoDate(oldResolvedRef, oldRef) {
|
|
if (oldResolvedRef) {
|
|
if (contains(seenResolvedRefs, oldResolvedRef))
|
|
return true;
|
|
const refPath2 = resolveProjectReferencePath(oldRef);
|
|
const newParsedCommandLine = getParsedCommandLine(refPath2);
|
|
if (!newParsedCommandLine)
|
|
return false;
|
|
if (oldResolvedRef.commandLine.options.configFile !== newParsedCommandLine.options.configFile)
|
|
return false;
|
|
if (!arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newParsedCommandLine.fileNames))
|
|
return false;
|
|
(seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef);
|
|
return !forEach(oldResolvedRef.references, (childResolvedRef, index) => !resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences[index]));
|
|
}
|
|
const refPath = resolveProjectReferencePath(oldRef);
|
|
return !getParsedCommandLine(refPath);
|
|
}
|
|
}
|
|
function getConfigFileParsingDiagnostics(configFileParseResult) {
|
|
return configFileParseResult.options.configFile ? [...configFileParseResult.options.configFile.parseDiagnostics, ...configFileParseResult.errors] : configFileParseResult.errors;
|
|
}
|
|
function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) {
|
|
const result = getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options);
|
|
return typeof result === "object" ? result.impliedNodeFormat : result;
|
|
}
|
|
function getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options) {
|
|
switch (getEmitModuleResolutionKind(options)) {
|
|
case 3 /* Node16 */:
|
|
case 99 /* NodeNext */:
|
|
return fileExtensionIsOneOf(fileName, [".d.mts" /* Dmts */, ".mts" /* Mts */, ".mjs" /* Mjs */]) ? 99 /* ESNext */ : fileExtensionIsOneOf(fileName, [".d.cts" /* Dcts */, ".cts" /* Cts */, ".cjs" /* Cjs */]) ? 1 /* CommonJS */ : fileExtensionIsOneOf(fileName, [".d.ts" /* Dts */, ".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */]) ? lookupFromPackageJson() : void 0;
|
|
default:
|
|
return void 0;
|
|
}
|
|
function lookupFromPackageJson() {
|
|
const state = getTemporaryModuleResolutionState(packageJsonInfoCache, host, options);
|
|
const packageJsonLocations = [];
|
|
state.failedLookupLocations = packageJsonLocations;
|
|
state.affectingLocations = packageJsonLocations;
|
|
const packageJsonScope = getPackageScopeForPath(fileName, state);
|
|
const impliedNodeFormat = (packageJsonScope == null ? void 0 : packageJsonScope.contents.packageJsonContent.type) === "module" ? 99 /* ESNext */ : 1 /* CommonJS */;
|
|
return { impliedNodeFormat, packageJsonLocations, packageJsonScope };
|
|
}
|
|
}
|
|
var plainJSErrors = /* @__PURE__ */ new Set([
|
|
Diagnostics.Cannot_redeclare_block_scoped_variable_0.code,
|
|
Diagnostics.A_module_cannot_have_multiple_default_exports.code,
|
|
Diagnostics.Another_export_default_is_here.code,
|
|
Diagnostics.The_first_export_default_is_here.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code,
|
|
Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code,
|
|
Diagnostics.constructor_is_a_reserved_word.code,
|
|
Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode.code,
|
|
Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode.code,
|
|
Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code,
|
|
Diagnostics.Invalid_use_of_0_in_strict_mode.code,
|
|
Diagnostics.A_label_is_not_allowed_here.code,
|
|
Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code,
|
|
Diagnostics.with_statements_are_not_allowed_in_strict_mode.code,
|
|
Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code,
|
|
Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement.code,
|
|
Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name.code,
|
|
Diagnostics.A_class_member_cannot_have_the_0_keyword.code,
|
|
Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name.code,
|
|
Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code,
|
|
Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement.code,
|
|
Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration.code,
|
|
Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context.code,
|
|
Diagnostics.A_destructuring_declaration_must_have_an_initializer.code,
|
|
Diagnostics.A_get_accessor_cannot_have_parameters.code,
|
|
Diagnostics.A_rest_element_cannot_contain_a_binding_pattern.code,
|
|
Diagnostics.A_rest_element_cannot_have_a_property_name.code,
|
|
Diagnostics.A_rest_element_cannot_have_an_initializer.code,
|
|
Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern.code,
|
|
Diagnostics.A_rest_parameter_cannot_have_an_initializer.code,
|
|
Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code,
|
|
Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code,
|
|
Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code,
|
|
Diagnostics.A_set_accessor_cannot_have_rest_parameter.code,
|
|
Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code,
|
|
Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
|
|
Diagnostics.An_export_declaration_cannot_have_modifiers.code,
|
|
Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code,
|
|
Diagnostics.An_import_declaration_cannot_have_modifiers.code,
|
|
Diagnostics.An_object_member_cannot_be_declared_optional.code,
|
|
Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code,
|
|
Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable.code,
|
|
Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause.code,
|
|
Diagnostics.Catch_clause_variable_cannot_have_an_initializer.code,
|
|
Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator.code,
|
|
Diagnostics.Classes_can_only_extend_a_single_class.code,
|
|
Diagnostics.Classes_may_not_have_a_field_named_constructor.code,
|
|
Diagnostics.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.code,
|
|
Diagnostics.Duplicate_label_0.code,
|
|
Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments.code,
|
|
Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block.code,
|
|
Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression.code,
|
|
Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name.code,
|
|
Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array.code,
|
|
Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names.code,
|
|
Diagnostics.Jump_target_cannot_cross_function_boundary.code,
|
|
Diagnostics.Line_terminator_not_permitted_before_arrow.code,
|
|
Diagnostics.Modifiers_cannot_appear_here.code,
|
|
Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement.code,
|
|
Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement.code,
|
|
Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies.code,
|
|
Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code,
|
|
Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier.code,
|
|
Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain.code,
|
|
Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async.code,
|
|
Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer.code,
|
|
Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer.code,
|
|
Diagnostics.Trailing_comma_not_allowed.code,
|
|
Diagnostics.Variable_declaration_list_cannot_be_empty.code,
|
|
Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses.code,
|
|
Diagnostics._0_expected.code,
|
|
Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2.code,
|
|
Diagnostics._0_list_cannot_be_empty.code,
|
|
Diagnostics._0_modifier_already_seen.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_a_parameter.code,
|
|
Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind.code,
|
|
Diagnostics._0_modifier_cannot_be_used_here.code,
|
|
Diagnostics._0_modifier_must_precede_1_modifier.code,
|
|
Diagnostics.const_declarations_can_only_be_declared_inside_a_block.code,
|
|
Diagnostics.const_declarations_must_be_initialized.code,
|
|
Diagnostics.extends_clause_already_seen.code,
|
|
Diagnostics.let_declarations_can_only_be_declared_inside_a_block.code,
|
|
Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
|
|
Diagnostics.Class_constructor_may_not_be_a_generator.code,
|
|
Diagnostics.Class_constructor_may_not_be_an_accessor.code,
|
|
Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code
|
|
]);
|
|
function shouldProgramCreateNewSourceFiles(program, newOptions) {
|
|
if (!program)
|
|
return false;
|
|
return optionsHaveChanges(program.getCompilerOptions(), newOptions, sourceFileAffectingCompilerOptions);
|
|
}
|
|
function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics) {
|
|
return {
|
|
rootNames,
|
|
options,
|
|
host,
|
|
oldProgram,
|
|
configFileParsingDiagnostics
|
|
};
|
|
}
|
|
function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
|
|
const createProgramOptions = isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions;
|
|
const { rootNames, options, configFileParsingDiagnostics, projectReferences } = createProgramOptions;
|
|
let { oldProgram } = createProgramOptions;
|
|
let processingDefaultLibFiles;
|
|
let processingOtherFiles;
|
|
let files;
|
|
let symlinks;
|
|
let commonSourceDirectory;
|
|
let typeChecker;
|
|
let classifiableNames;
|
|
const ambientModuleNameToUnmodifiedFileName = /* @__PURE__ */ new Map();
|
|
let fileReasons = createMultiMap();
|
|
const cachedBindAndCheckDiagnosticsForFile = {};
|
|
const cachedDeclarationDiagnosticsForFile = {};
|
|
let resolvedTypeReferenceDirectives = createModeAwareCache();
|
|
let fileProcessingDiagnostics;
|
|
const maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
|
|
let currentNodeModulesDepth = 0;
|
|
const modulesWithElidedImports = /* @__PURE__ */ new Map();
|
|
const sourceFilesFoundSearchingNodeModules = /* @__PURE__ */ new Map();
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Program, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, true);
|
|
mark("beforeProgram");
|
|
const host = createProgramOptions.host || createCompilerHost(options);
|
|
const configParsingHost = parseConfigHostFromCompilerHostLike(host);
|
|
let skipDefaultLib = options.noLib;
|
|
const getDefaultLibraryFileName = memoize(() => host.getDefaultLibFileName(options));
|
|
const defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : getDirectoryPath(getDefaultLibraryFileName());
|
|
const programDiagnostics = createDiagnosticCollection();
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const supportedExtensions = getSupportedExtensions(options);
|
|
const supportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions);
|
|
const hasEmitBlockingDiagnostics = /* @__PURE__ */ new Map();
|
|
let _compilerOptionsObjectLiteralSyntax;
|
|
let moduleResolutionCache;
|
|
let typeReferenceDirectiveResolutionCache;
|
|
let actualResolveModuleNamesWorker;
|
|
const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
|
|
if (host.resolveModuleNames) {
|
|
actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => {
|
|
var _a3;
|
|
return host.resolveModuleNames(
|
|
moduleNames.map((literal) => literal.text),
|
|
containingFileName,
|
|
(_a3 = resolutionInfo == null ? void 0 : resolutionInfo.reusedNames) == null ? void 0 : _a3.map((literal) => literal.text),
|
|
redirectedReference,
|
|
options,
|
|
containingFile,
|
|
resolutionInfo
|
|
).map((resolved) => {
|
|
if (!resolved || resolved.extension !== void 0) {
|
|
return resolved;
|
|
}
|
|
const withExtension = clone(resolved);
|
|
withExtension.extension = extensionFromPath(resolved.resolvedFileName);
|
|
return withExtension;
|
|
});
|
|
};
|
|
moduleResolutionCache = (_b = host.getModuleResolutionCache) == null ? void 0 : _b.call(host);
|
|
} else {
|
|
moduleResolutionCache = createModuleResolutionCache(currentDirectory, getCanonicalFileName, options);
|
|
const loader = (moduleName, resolverMode, containingFileName, redirectedReference) => resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
|
|
actualResolveModuleNamesWorker = (moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo) => loadWithModeAwareCache(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo, loader);
|
|
}
|
|
let actualResolveTypeReferenceDirectiveNamesWorker;
|
|
if (host.resolveTypeReferenceDirectives) {
|
|
actualResolveTypeReferenceDirectiveNamesWorker = (typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) => host.resolveTypeReferenceDirectives(Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode, resolutionInfo);
|
|
} else {
|
|
typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache());
|
|
const loader = (typesRef, containingFile, redirectedReference, resolutionMode) => resolveTypeReferenceDirective(
|
|
typesRef,
|
|
containingFile,
|
|
options,
|
|
host,
|
|
redirectedReference,
|
|
typeReferenceDirectiveResolutionCache,
|
|
resolutionMode
|
|
).resolvedTypeReferenceDirective;
|
|
actualResolveTypeReferenceDirectiveNamesWorker = (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
|
|
}
|
|
const packageIdToSourceFile = /* @__PURE__ */ new Map();
|
|
let sourceFileToPackageName = /* @__PURE__ */ new Map();
|
|
let redirectTargetsMap = createMultiMap();
|
|
let usesUriStyleNodeCoreModules = false;
|
|
const filesByName = /* @__PURE__ */ new Map();
|
|
let missingFilePaths;
|
|
const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? /* @__PURE__ */ new Map() : void 0;
|
|
let resolvedProjectReferences;
|
|
let projectReferenceRedirects;
|
|
let mapFromFileToProjectReferenceRedirects;
|
|
let mapFromToProjectReferenceRedirectSource;
|
|
const useSourceOfProjectReferenceRedirect = !!((_c = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _c.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
|
|
const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
|
|
compilerHost: host,
|
|
getSymlinkCache,
|
|
useSourceOfProjectReferenceRedirect,
|
|
toPath: toPath3,
|
|
getResolvedProjectReferences,
|
|
getSourceOfProjectReferenceRedirect,
|
|
forEachResolvedProjectReference: forEachResolvedProjectReference2
|
|
});
|
|
const readFile = host.readFile.bind(host);
|
|
(_d = tracing) == null ? void 0 : _d.push(tracing.Phase.Program, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
|
|
const shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
|
|
(_e = tracing) == null ? void 0 : _e.pop();
|
|
let structureIsReused;
|
|
(_f = tracing) == null ? void 0 : _f.push(tracing.Phase.Program, "tryReuseStructureFromOldProgram", {});
|
|
structureIsReused = tryReuseStructureFromOldProgram();
|
|
(_g = tracing) == null ? void 0 : _g.pop();
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
processingDefaultLibFiles = [];
|
|
processingOtherFiles = [];
|
|
if (projectReferences) {
|
|
if (!resolvedProjectReferences) {
|
|
resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
if (rootNames.length) {
|
|
resolvedProjectReferences == null ? void 0 : resolvedProjectReferences.forEach((parsedRef, index) => {
|
|
if (!parsedRef)
|
|
return;
|
|
const out = outFile(parsedRef.commandLine.options);
|
|
if (useSourceOfProjectReferenceRedirect) {
|
|
if (out || getEmitModuleKind(parsedRef.commandLine.options) === 0 /* None */) {
|
|
for (const fileName of parsedRef.commandLine.fileNames) {
|
|
processProjectReferenceFile(fileName, { kind: 1 /* SourceFromProjectReference */, index });
|
|
}
|
|
}
|
|
} else {
|
|
if (out) {
|
|
processProjectReferenceFile(changeExtension(out, ".d.ts"), { kind: 2 /* OutputFromProjectReference */, index });
|
|
} else if (getEmitModuleKind(parsedRef.commandLine.options) === 0 /* None */) {
|
|
const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(parsedRef.commandLine, !host.useCaseSensitiveFileNames()));
|
|
for (const fileName of parsedRef.commandLine.fileNames) {
|
|
if (!isDeclarationFileName(fileName) && !fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
processProjectReferenceFile(getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory3), { kind: 2 /* OutputFromProjectReference */, index });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
(_h = tracing) == null ? void 0 : _h.push(tracing.Phase.Program, "processRootFiles", { count: rootNames.length });
|
|
forEach(rootNames, (name, index) => processRootFile(name, false, false, { kind: 0 /* RootFile */, index }));
|
|
(_i = tracing) == null ? void 0 : _i.pop();
|
|
const typeReferences = rootNames.length ? getAutomaticTypeDirectiveNames(options, host) : emptyArray;
|
|
if (typeReferences.length) {
|
|
(_j = tracing) == null ? void 0 : _j.push(tracing.Phase.Program, "processTypeReferences", { count: typeReferences.length });
|
|
const containingDirectory = options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
|
|
const containingFilename = combinePaths(containingDirectory, inferredTypesContainingFile);
|
|
const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeReferences, containingFilename);
|
|
for (let i = 0; i < typeReferences.length; i++) {
|
|
processTypeReferenceDirective(typeReferences[i], void 0, resolutions[i], { kind: 8 /* AutomaticTypeDirectiveFile */, typeReference: typeReferences[i], packageId: (_k = resolutions[i]) == null ? void 0 : _k.packageId });
|
|
}
|
|
(_l = tracing) == null ? void 0 : _l.pop();
|
|
}
|
|
if (rootNames.length && !skipDefaultLib) {
|
|
const defaultLibraryFileName = getDefaultLibraryFileName();
|
|
if (!options.lib && defaultLibraryFileName) {
|
|
processRootFile(defaultLibraryFileName, true, false, { kind: 6 /* LibFile */ });
|
|
} else {
|
|
forEach(options.lib, (libFileName, index) => {
|
|
processRootFile(pathForLibFile(libFileName), true, false, { kind: 6 /* LibFile */, index });
|
|
});
|
|
}
|
|
}
|
|
missingFilePaths = arrayFrom(mapDefinedIterator(filesByName.entries(), ([path, file]) => file === void 0 ? path : void 0));
|
|
files = stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles);
|
|
processingDefaultLibFiles = void 0;
|
|
processingOtherFiles = void 0;
|
|
}
|
|
Debug.assert(!!missingFilePaths);
|
|
if (oldProgram && host.onReleaseOldSourceFile) {
|
|
const oldSourceFiles = oldProgram.getSourceFiles();
|
|
for (const oldSourceFile of oldSourceFiles) {
|
|
const newFile = getSourceFileByPath(oldSourceFile.resolvedPath);
|
|
if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path) {
|
|
host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path));
|
|
}
|
|
}
|
|
if (!host.getParsedCommandLine) {
|
|
oldProgram.forEachResolvedProjectReference((resolvedProjectReference) => {
|
|
if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
|
|
host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), false);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (oldProgram && host.onReleaseParsedCommandLine) {
|
|
forEachProjectReference(
|
|
oldProgram.getProjectReferences(),
|
|
oldProgram.getResolvedProjectReferences(),
|
|
(oldResolvedRef, parent2, index) => {
|
|
const oldReference = (parent2 == null ? void 0 : parent2.commandLine.projectReferences[index]) || oldProgram.getProjectReferences()[index];
|
|
const oldRefPath = resolveProjectReferencePath(oldReference);
|
|
if (!(projectReferenceRedirects == null ? void 0 : projectReferenceRedirects.has(toPath3(oldRefPath)))) {
|
|
host.onReleaseParsedCommandLine(oldRefPath, oldResolvedRef, oldProgram.getCompilerOptions());
|
|
}
|
|
}
|
|
);
|
|
}
|
|
typeReferenceDirectiveResolutionCache = void 0;
|
|
oldProgram = void 0;
|
|
const program = {
|
|
getRootFileNames: () => rootNames,
|
|
getSourceFile,
|
|
getSourceFileByPath,
|
|
getSourceFiles: () => files,
|
|
getMissingFilePaths: () => missingFilePaths,
|
|
getModuleResolutionCache: () => moduleResolutionCache,
|
|
getFilesByNameMap: () => filesByName,
|
|
getCompilerOptions: () => options,
|
|
getSyntacticDiagnostics,
|
|
getOptionsDiagnostics,
|
|
getGlobalDiagnostics,
|
|
getSemanticDiagnostics,
|
|
getCachedSemanticDiagnostics,
|
|
getSuggestionDiagnostics,
|
|
getDeclarationDiagnostics: getDeclarationDiagnostics2,
|
|
getBindAndCheckDiagnostics,
|
|
getProgramDiagnostics,
|
|
getTypeChecker,
|
|
getClassifiableNames,
|
|
getCommonSourceDirectory: getCommonSourceDirectory2,
|
|
emit,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
getNodeCount: () => getTypeChecker().getNodeCount(),
|
|
getIdentifierCount: () => getTypeChecker().getIdentifierCount(),
|
|
getSymbolCount: () => getTypeChecker().getSymbolCount(),
|
|
getTypeCount: () => getTypeChecker().getTypeCount(),
|
|
getInstantiationCount: () => getTypeChecker().getInstantiationCount(),
|
|
getRelationCacheSizes: () => getTypeChecker().getRelationCacheSizes(),
|
|
getFileProcessingDiagnostics: () => fileProcessingDiagnostics,
|
|
getResolvedTypeReferenceDirectives: () => resolvedTypeReferenceDirectives,
|
|
isSourceFileFromExternalLibrary,
|
|
isSourceFileDefaultLibrary,
|
|
getSourceFileFromReference,
|
|
getLibFileFromReference,
|
|
sourceFileToPackageName,
|
|
redirectTargetsMap,
|
|
usesUriStyleNodeCoreModules,
|
|
isEmittedFile,
|
|
getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics2,
|
|
getResolvedModuleWithFailedLookupLocationsFromCache,
|
|
getProjectReferences,
|
|
getResolvedProjectReferences,
|
|
getProjectReferenceRedirect,
|
|
getResolvedProjectReferenceToRedirect,
|
|
getResolvedProjectReferenceByPath,
|
|
forEachResolvedProjectReference: forEachResolvedProjectReference2,
|
|
isSourceOfProjectReferenceRedirect,
|
|
emitBuildInfo,
|
|
fileExists,
|
|
readFile,
|
|
directoryExists,
|
|
getSymlinkCache,
|
|
realpath: (_m = host.realpath) == null ? void 0 : _m.bind(host),
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getFileIncludeReasons: () => fileReasons,
|
|
structureIsReused,
|
|
writeFile: writeFile2
|
|
};
|
|
onProgramCreateComplete();
|
|
fileProcessingDiagnostics == null ? void 0 : fileProcessingDiagnostics.forEach((diagnostic) => {
|
|
switch (diagnostic.kind) {
|
|
case 1 /* FilePreprocessingFileExplainingDiagnostic */:
|
|
return programDiagnostics.add(createDiagnosticExplainingFile(diagnostic.file && getSourceFileByPath(diagnostic.file), diagnostic.fileProcessingReason, diagnostic.diagnostic, diagnostic.args || emptyArray));
|
|
case 0 /* FilePreprocessingReferencedDiagnostic */:
|
|
const { file, pos, end } = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason);
|
|
return programDiagnostics.add(createFileDiagnostic(file, Debug.checkDefined(pos), Debug.checkDefined(end) - pos, diagnostic.diagnostic, ...diagnostic.args || emptyArray));
|
|
default:
|
|
Debug.assertNever(diagnostic);
|
|
}
|
|
});
|
|
verifyCompilerOptions();
|
|
mark("afterProgram");
|
|
measure("Program", "beforeProgram", "afterProgram");
|
|
(_n = tracing) == null ? void 0 : _n.pop();
|
|
return program;
|
|
function addResolutionDiagnostics(list) {
|
|
if (!list)
|
|
return;
|
|
for (const elem of list) {
|
|
programDiagnostics.add(elem);
|
|
}
|
|
}
|
|
function pullDiagnosticsFromCache(names, containingFile) {
|
|
var _a3;
|
|
if (!moduleResolutionCache)
|
|
return;
|
|
const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
|
|
const containingDir = getDirectoryPath(containingFileName);
|
|
const redirectedReference = getRedirectReferenceForResolution(containingFile);
|
|
for (const n of names) {
|
|
const mode = getResolutionMode(n, containingFile);
|
|
const name = getResolutionName(n);
|
|
if (isExternalModuleNameRelative(name))
|
|
continue;
|
|
const diags = (_a3 = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) == null ? void 0 : _a3.resolutionDiagnostics;
|
|
addResolutionDiagnostics(diags);
|
|
}
|
|
}
|
|
function resolveModuleNamesWorker(moduleNames, containingFile, resolutionInfo) {
|
|
var _a3, _b2;
|
|
if (!moduleNames.length)
|
|
return emptyArray;
|
|
const containingFileName = getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
|
|
const redirectedReference = getRedirectReferenceForResolution(containingFile);
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveModuleNamesWorker", { containingFileName });
|
|
mark("beforeResolveModule");
|
|
const result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, redirectedReference, resolutionInfo);
|
|
mark("afterResolveModule");
|
|
measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
pullDiagnosticsFromCache(moduleNames, containingFile);
|
|
return result;
|
|
}
|
|
function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, resolutionInfo) {
|
|
var _a3, _b2;
|
|
if (!typeDirectiveNames.length)
|
|
return [];
|
|
const containingFileName = !isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
|
|
const redirectedReference = !isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : void 0;
|
|
const containingFileMode = !isString(containingFile) ? containingFile.impliedNodeFormat : void 0;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName });
|
|
mark("beforeResolveTypeReference");
|
|
const result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode, resolutionInfo);
|
|
mark("afterResolveTypeReference");
|
|
measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function getRedirectReferenceForResolution(file) {
|
|
const redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
|
|
if (redirect || !isDeclarationFileName(file.originalFileName))
|
|
return redirect;
|
|
const resultFromDts = getRedirectReferenceForResolutionFromSourceOfProject(file.path);
|
|
if (resultFromDts)
|
|
return resultFromDts;
|
|
if (!host.realpath || !options.preserveSymlinks || !stringContains(file.originalFileName, nodeModulesPathPart))
|
|
return void 0;
|
|
const realDeclarationPath = toPath3(host.realpath(file.originalFileName));
|
|
return realDeclarationPath === file.path ? void 0 : getRedirectReferenceForResolutionFromSourceOfProject(realDeclarationPath);
|
|
}
|
|
function getRedirectReferenceForResolutionFromSourceOfProject(filePath) {
|
|
const source = getSourceOfProjectReferenceRedirect(filePath);
|
|
if (isString(source))
|
|
return getResolvedProjectReferenceToRedirect(source);
|
|
if (!source)
|
|
return void 0;
|
|
return forEachResolvedProjectReference2((resolvedRef) => {
|
|
const out = outFile(resolvedRef.commandLine.options);
|
|
if (!out)
|
|
return void 0;
|
|
return toPath3(out) === filePath ? resolvedRef : void 0;
|
|
});
|
|
}
|
|
function compareDefaultLibFiles(a, b) {
|
|
return compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b));
|
|
}
|
|
function getDefaultLibFilePriority(a) {
|
|
if (containsPath(defaultLibraryPath, a.fileName, false)) {
|
|
const basename = getBaseFileName(a.fileName);
|
|
if (basename === "lib.d.ts" || basename === "lib.es6.d.ts")
|
|
return 0;
|
|
const name = removeSuffix(removePrefix(basename, "lib."), ".d.ts");
|
|
const index = libs.indexOf(name);
|
|
if (index !== -1)
|
|
return index + 1;
|
|
}
|
|
return libs.length + 2;
|
|
}
|
|
function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) {
|
|
return moduleResolutionCache && resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode);
|
|
}
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function getCommonSourceDirectory2() {
|
|
if (commonSourceDirectory === void 0) {
|
|
const emittedFiles = filter(files, (file) => sourceFileMayBeEmitted(file, program));
|
|
commonSourceDirectory = getCommonSourceDirectory(
|
|
options,
|
|
() => mapDefined(emittedFiles, (file) => file.isDeclarationFile ? void 0 : file.fileName),
|
|
currentDirectory,
|
|
getCanonicalFileName,
|
|
(commonSourceDirectory2) => checkSourceFilesBelongToPath(emittedFiles, commonSourceDirectory2)
|
|
);
|
|
}
|
|
return commonSourceDirectory;
|
|
}
|
|
function getClassifiableNames() {
|
|
var _a3;
|
|
if (!classifiableNames) {
|
|
getTypeChecker();
|
|
classifiableNames = /* @__PURE__ */ new Set();
|
|
for (const sourceFile of files) {
|
|
(_a3 = sourceFile.classifiableNames) == null ? void 0 : _a3.forEach((value) => classifiableNames.add(value));
|
|
}
|
|
}
|
|
return classifiableNames;
|
|
}
|
|
function resolveModuleNamesReusingOldState(moduleNames, file) {
|
|
if (structureIsReused === 0 /* Not */ && !file.ambientModuleNames.length) {
|
|
return resolveModuleNamesWorker(moduleNames, file, void 0);
|
|
}
|
|
const oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName);
|
|
if (oldSourceFile !== file && file.resolvedModules) {
|
|
const result2 = [];
|
|
for (const moduleName of moduleNames) {
|
|
const resolvedModule = file.resolvedModules.get(moduleName.text, getModeForUsageLocation(file, moduleName));
|
|
result2.push(resolvedModule);
|
|
}
|
|
return result2;
|
|
}
|
|
let unknownModuleNames;
|
|
let result;
|
|
let reusedNames;
|
|
const predictedToResolveToAmbientModuleMarker = {};
|
|
for (let i = 0; i < moduleNames.length; i++) {
|
|
const moduleName = moduleNames[i];
|
|
if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) {
|
|
const mode = getModeForUsageLocation(file, moduleName);
|
|
const oldResolvedModule = getResolvedModule(oldSourceFile, moduleName.text, mode);
|
|
if (oldResolvedModule) {
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(
|
|
host,
|
|
oldResolvedModule.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
|
|
moduleName.text,
|
|
getNormalizedAbsolutePath(file.originalFileName, currentDirectory),
|
|
oldResolvedModule.resolvedFileName,
|
|
oldResolvedModule.packageId && packageIdToString(oldResolvedModule.packageId)
|
|
);
|
|
}
|
|
(result != null ? result : result = new Array(moduleNames.length))[i] = oldResolvedModule;
|
|
(reusedNames != null ? reusedNames : reusedNames = []).push(moduleName);
|
|
continue;
|
|
}
|
|
}
|
|
let resolvesToAmbientModuleInNonModifiedFile = false;
|
|
if (contains(file.ambientModuleNames, moduleName.text)) {
|
|
resolvesToAmbientModuleInNonModifiedFile = true;
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(host, Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName.text, getNormalizedAbsolutePath(file.originalFileName, currentDirectory));
|
|
}
|
|
} else {
|
|
resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName);
|
|
}
|
|
if (resolvesToAmbientModuleInNonModifiedFile) {
|
|
(result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker;
|
|
} else {
|
|
(unknownModuleNames != null ? unknownModuleNames : unknownModuleNames = []).push(moduleName);
|
|
}
|
|
}
|
|
const resolutions = unknownModuleNames && unknownModuleNames.length ? resolveModuleNamesWorker(unknownModuleNames, file, { names: unknownModuleNames, reusedNames }) : emptyArray;
|
|
if (!result) {
|
|
Debug.assert(resolutions.length === moduleNames.length);
|
|
return resolutions;
|
|
}
|
|
let j = 0;
|
|
for (let i = 0; i < result.length; i++) {
|
|
if (result[i]) {
|
|
if (result[i] === predictedToResolveToAmbientModuleMarker) {
|
|
result[i] = void 0;
|
|
}
|
|
} else {
|
|
result[i] = resolutions[j];
|
|
j++;
|
|
}
|
|
}
|
|
Debug.assert(j === resolutions.length);
|
|
return result;
|
|
function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName) {
|
|
const resolutionToFile = getResolvedModule(oldSourceFile, moduleName.text, getModeForUsageLocation(file, moduleName));
|
|
const resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName);
|
|
if (resolutionToFile && resolvedFile) {
|
|
return false;
|
|
}
|
|
const unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName.text);
|
|
if (!unmodifiedFile) {
|
|
return false;
|
|
}
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(host, Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName.text, unmodifiedFile);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectiveNames, containingFile) {
|
|
if (structureIsReused === 0 /* Not */) {
|
|
return resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile, void 0);
|
|
}
|
|
const oldSourceFile = !isString(containingFile) ? oldProgram && oldProgram.getSourceFile(containingFile.fileName) : void 0;
|
|
if (!isString(containingFile)) {
|
|
if (oldSourceFile !== containingFile && containingFile.resolvedTypeReferenceDirectiveNames) {
|
|
const result2 = [];
|
|
for (const typeDirectiveName of typeDirectiveNames) {
|
|
const resolvedTypeReferenceDirective = containingFile.resolvedTypeReferenceDirectiveNames.get(getResolutionName(typeDirectiveName), typeDirectiveName.resolutionMode || containingFile.impliedNodeFormat);
|
|
result2.push(resolvedTypeReferenceDirective);
|
|
}
|
|
return result2;
|
|
}
|
|
}
|
|
let unknownTypeReferenceDirectiveNames;
|
|
let result;
|
|
let reusedNames;
|
|
const containingSourceFile = !isString(containingFile) ? containingFile : void 0;
|
|
const canReuseResolutions = !isString(containingFile) ? containingFile === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path) : !hasInvalidatedResolutions(toPath3(containingFile));
|
|
for (let i = 0; i < typeDirectiveNames.length; i++) {
|
|
const entry = typeDirectiveNames[i];
|
|
if (canReuseResolutions) {
|
|
const typeDirectiveName = getResolutionName(entry);
|
|
const mode = getModeForFileReference(entry, containingSourceFile == null ? void 0 : containingSourceFile.impliedNodeFormat);
|
|
const oldResolvedTypeReferenceDirective = getResolvedTypeReferenceDirective(oldSourceFile, typeDirectiveName, mode);
|
|
if (oldResolvedTypeReferenceDirective) {
|
|
if (isTraceEnabled(options, host)) {
|
|
trace(
|
|
host,
|
|
oldResolvedTypeReferenceDirective.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2,
|
|
typeDirectiveName,
|
|
!isString(containingFile) ? getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile,
|
|
oldResolvedTypeReferenceDirective.resolvedFileName,
|
|
oldResolvedTypeReferenceDirective.packageId && packageIdToString(oldResolvedTypeReferenceDirective.packageId)
|
|
);
|
|
}
|
|
(result != null ? result : result = new Array(typeDirectiveNames.length))[i] = oldResolvedTypeReferenceDirective;
|
|
(reusedNames != null ? reusedNames : reusedNames = []).push(entry);
|
|
continue;
|
|
}
|
|
}
|
|
(unknownTypeReferenceDirectiveNames != null ? unknownTypeReferenceDirectiveNames : unknownTypeReferenceDirectiveNames = []).push(entry);
|
|
}
|
|
if (!unknownTypeReferenceDirectiveNames)
|
|
return result || emptyArray;
|
|
const resolutions = resolveTypeReferenceDirectiveNamesWorker(
|
|
unknownTypeReferenceDirectiveNames,
|
|
containingFile,
|
|
{ names: unknownTypeReferenceDirectiveNames, reusedNames }
|
|
);
|
|
if (!result) {
|
|
Debug.assert(resolutions.length === typeDirectiveNames.length);
|
|
return resolutions;
|
|
}
|
|
let j = 0;
|
|
for (let i = 0; i < result.length; i++) {
|
|
if (!result[i]) {
|
|
result[i] = resolutions[j];
|
|
j++;
|
|
}
|
|
}
|
|
Debug.assert(j === resolutions.length);
|
|
return result;
|
|
}
|
|
function canReuseProjectReferences() {
|
|
return !forEachProjectReference(
|
|
oldProgram.getProjectReferences(),
|
|
oldProgram.getResolvedProjectReferences(),
|
|
(oldResolvedRef, parent2, index) => {
|
|
const newRef = (parent2 ? parent2.commandLine.projectReferences : projectReferences)[index];
|
|
const newResolvedRef = parseProjectReferenceConfigFile(newRef);
|
|
if (oldResolvedRef) {
|
|
return !newResolvedRef || newResolvedRef.sourceFile !== oldResolvedRef.sourceFile || !arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newResolvedRef.commandLine.fileNames);
|
|
} else {
|
|
return newResolvedRef !== void 0;
|
|
}
|
|
},
|
|
(oldProjectReferences, parent2) => {
|
|
const newReferences = parent2 ? getResolvedProjectReferenceByPath(parent2.sourceFile.path).commandLine.projectReferences : projectReferences;
|
|
return !arrayIsEqualTo(oldProjectReferences, newReferences, projectReferenceIsEqualTo);
|
|
}
|
|
);
|
|
}
|
|
function tryReuseStructureFromOldProgram() {
|
|
var _a3, _b2;
|
|
if (!oldProgram) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldOptions = oldProgram.getCompilerOptions();
|
|
if (changesAffectModuleResolution(oldOptions, options)) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldRootNames = oldProgram.getRootFileNames();
|
|
if (!arrayIsEqualTo(oldRootNames, rootNames)) {
|
|
return 0 /* Not */;
|
|
}
|
|
if (!canReuseProjectReferences()) {
|
|
return 0 /* Not */;
|
|
}
|
|
if (projectReferences) {
|
|
resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
const newSourceFiles = [];
|
|
const modifiedSourceFiles = [];
|
|
structureIsReused = 2 /* Completely */;
|
|
if (oldProgram.getMissingFilePaths().some((missingFilePath) => host.fileExists(missingFilePath))) {
|
|
return 0 /* Not */;
|
|
}
|
|
const oldSourceFiles = oldProgram.getSourceFiles();
|
|
let SeenPackageName;
|
|
((SeenPackageName2) => {
|
|
SeenPackageName2[SeenPackageName2["Exists"] = 0] = "Exists";
|
|
SeenPackageName2[SeenPackageName2["Modified"] = 1] = "Modified";
|
|
})(SeenPackageName || (SeenPackageName = {}));
|
|
const seenPackageNames = /* @__PURE__ */ new Map();
|
|
for (const oldSourceFile of oldSourceFiles) {
|
|
const sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options);
|
|
let newSourceFile = host.getSourceFileByPath ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, void 0, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat) : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, void 0, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat);
|
|
if (!newSourceFile) {
|
|
return 0 /* Not */;
|
|
}
|
|
newSourceFile.packageJsonLocations = ((_a3 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a3.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
newSourceFile.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`");
|
|
let fileChanged;
|
|
if (oldSourceFile.redirectInfo) {
|
|
if (newSourceFile !== oldSourceFile.redirectInfo.unredirected) {
|
|
return 0 /* Not */;
|
|
}
|
|
fileChanged = false;
|
|
newSourceFile = oldSourceFile;
|
|
} else if (oldProgram.redirectTargetsMap.has(oldSourceFile.path)) {
|
|
if (newSourceFile !== oldSourceFile) {
|
|
return 0 /* Not */;
|
|
}
|
|
fileChanged = false;
|
|
} else {
|
|
fileChanged = newSourceFile !== oldSourceFile;
|
|
}
|
|
newSourceFile.path = oldSourceFile.path;
|
|
newSourceFile.originalFileName = oldSourceFile.originalFileName;
|
|
newSourceFile.resolvedPath = oldSourceFile.resolvedPath;
|
|
newSourceFile.fileName = oldSourceFile.fileName;
|
|
const packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path);
|
|
if (packageName !== void 0) {
|
|
const prevKind = seenPackageNames.get(packageName);
|
|
const newKind = fileChanged ? 1 /* Modified */ : 0 /* Exists */;
|
|
if (prevKind !== void 0 && newKind === 1 /* Modified */ || prevKind === 1 /* Modified */) {
|
|
return 0 /* Not */;
|
|
}
|
|
seenPackageNames.set(packageName, newKind);
|
|
}
|
|
if (fileChanged) {
|
|
if (oldSourceFile.impliedNodeFormat !== newSourceFile.impliedNodeFormat) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else {
|
|
collectExternalModuleReferences(newSourceFile);
|
|
if (!arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if ((oldSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* PermanentlySetIncrementalFlags */)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
} else if (!arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
}
|
|
}
|
|
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
|
|
} else if (hasInvalidatedResolutions(oldSourceFile.path)) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile });
|
|
}
|
|
newSourceFiles.push(newSourceFile);
|
|
}
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
return structureIsReused;
|
|
}
|
|
const modifiedFiles = modifiedSourceFiles.map((f) => f.oldFile);
|
|
for (const oldFile of oldSourceFiles) {
|
|
if (!contains(modifiedFiles, oldFile)) {
|
|
for (const moduleName of oldFile.ambientModuleNames) {
|
|
ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName);
|
|
}
|
|
}
|
|
}
|
|
for (const { oldFile: oldSourceFile, newFile: newSourceFile } of modifiedSourceFiles) {
|
|
const moduleNames = getModuleNames(newSourceFile);
|
|
const resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile);
|
|
const resolutionsChanged = hasChangesInResolutions(moduleNames, newSourceFile, resolutions, oldSourceFile.resolvedModules, moduleResolutionIsEqualTo);
|
|
if (resolutionsChanged) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
newSourceFile.resolvedModules = zipToModeAwareCache(newSourceFile, moduleNames, resolutions);
|
|
} else {
|
|
newSourceFile.resolvedModules = oldSourceFile.resolvedModules;
|
|
}
|
|
const typesReferenceDirectives = newSourceFile.typeReferenceDirectives;
|
|
const typeReferenceResolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typesReferenceDirectives, newSourceFile);
|
|
const typeReferenceResolutionsChanged = hasChangesInResolutions(typesReferenceDirectives, newSourceFile, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, typeDirectiveIsEqualTo);
|
|
if (typeReferenceResolutionsChanged) {
|
|
structureIsReused = 1 /* SafeModules */;
|
|
newSourceFile.resolvedTypeReferenceDirectiveNames = zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
|
|
} else {
|
|
newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames;
|
|
}
|
|
}
|
|
if (structureIsReused !== 2 /* Completely */) {
|
|
return structureIsReused;
|
|
}
|
|
if (changesAffectingProgramStructure(oldOptions, options) || ((_b2 = host.hasChangedAutomaticTypeDirectiveNames) == null ? void 0 : _b2.call(host))) {
|
|
return 1 /* SafeModules */;
|
|
}
|
|
missingFilePaths = oldProgram.getMissingFilePaths();
|
|
Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length);
|
|
for (const newSourceFile of newSourceFiles) {
|
|
filesByName.set(newSourceFile.path, newSourceFile);
|
|
}
|
|
const oldFilesByNameMap = oldProgram.getFilesByNameMap();
|
|
oldFilesByNameMap.forEach((oldFile, path) => {
|
|
if (!oldFile) {
|
|
filesByName.set(path, oldFile);
|
|
return;
|
|
}
|
|
if (oldFile.path === path) {
|
|
if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) {
|
|
sourceFilesFoundSearchingNodeModules.set(oldFile.path, true);
|
|
}
|
|
return;
|
|
}
|
|
filesByName.set(path, filesByName.get(oldFile.path));
|
|
});
|
|
files = newSourceFiles;
|
|
fileReasons = oldProgram.getFileIncludeReasons();
|
|
fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();
|
|
resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives();
|
|
sourceFileToPackageName = oldProgram.sourceFileToPackageName;
|
|
redirectTargetsMap = oldProgram.redirectTargetsMap;
|
|
usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules;
|
|
return 2 /* Completely */;
|
|
}
|
|
function getEmitHost(writeFileCallback) {
|
|
return {
|
|
getPrependNodes,
|
|
getCanonicalFileName,
|
|
getCommonSourceDirectory: program.getCommonSourceDirectory,
|
|
getCompilerOptions: program.getCompilerOptions,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
getNewLine: () => host.getNewLine(),
|
|
getSourceFile: program.getSourceFile,
|
|
getSourceFileByPath: program.getSourceFileByPath,
|
|
getSourceFiles: program.getSourceFiles,
|
|
getLibFileFromReference: program.getLibFileFromReference,
|
|
isSourceFileFromExternalLibrary,
|
|
getResolvedProjectReferenceToRedirect,
|
|
getProjectReferenceRedirect,
|
|
isSourceOfProjectReferenceRedirect,
|
|
getSymlinkCache,
|
|
writeFile: writeFileCallback || writeFile2,
|
|
isEmitBlocked,
|
|
readFile: (f) => host.readFile(f),
|
|
fileExists: (f) => {
|
|
const path = toPath3(f);
|
|
if (getSourceFileByPath(path))
|
|
return true;
|
|
if (contains(missingFilePaths, path))
|
|
return false;
|
|
return host.fileExists(f);
|
|
},
|
|
useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
|
|
getBuildInfo: (bundle) => {
|
|
var _a3;
|
|
return (_a3 = program.getBuildInfo) == null ? void 0 : _a3.call(program, bundle);
|
|
},
|
|
getSourceFileFromReference: (file, ref) => program.getSourceFileFromReference(file, ref),
|
|
redirectTargetsMap,
|
|
getFileIncludeReasons: program.getFileIncludeReasons,
|
|
createHash: maybeBind(host, host.createHash)
|
|
};
|
|
}
|
|
function writeFile2(fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
|
|
host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
}
|
|
function emitBuildInfo(writeFileCallback) {
|
|
var _a3, _b2;
|
|
Debug.assert(!outFile(options));
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Emit, "emitBuildInfo", {}, true);
|
|
mark("beforeEmit");
|
|
const emitResult = emitFiles(
|
|
notImplementedResolver,
|
|
getEmitHost(writeFileCallback),
|
|
void 0,
|
|
noTransformers,
|
|
false,
|
|
true
|
|
);
|
|
mark("afterEmit");
|
|
measure("Emit", "beforeEmit", "afterEmit");
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return emitResult;
|
|
}
|
|
function getResolvedProjectReferences() {
|
|
return resolvedProjectReferences;
|
|
}
|
|
function getProjectReferences() {
|
|
return projectReferences;
|
|
}
|
|
function getPrependNodes() {
|
|
return createPrependNodes(
|
|
projectReferences,
|
|
(_ref, index) => {
|
|
var _a3;
|
|
return (_a3 = resolvedProjectReferences[index]) == null ? void 0 : _a3.commandLine;
|
|
},
|
|
(fileName) => {
|
|
const path = toPath3(fileName);
|
|
const sourceFile = getSourceFileByPath(path);
|
|
return sourceFile ? sourceFile.text : filesByName.has(path) ? void 0 : host.readFile(path);
|
|
},
|
|
host
|
|
);
|
|
}
|
|
function isSourceFileFromExternalLibrary(file) {
|
|
return !!sourceFilesFoundSearchingNodeModules.get(file.path);
|
|
}
|
|
function isSourceFileDefaultLibrary(file) {
|
|
if (!file.isDeclarationFile) {
|
|
return false;
|
|
}
|
|
if (file.hasNoDefaultLib) {
|
|
return true;
|
|
}
|
|
if (!options.noLib) {
|
|
return false;
|
|
}
|
|
const equalityComparer = host.useCaseSensitiveFileNames() ? equateStringsCaseSensitive : equateStringsCaseInsensitive;
|
|
if (!options.lib) {
|
|
return equalityComparer(file.fileName, getDefaultLibraryFileName());
|
|
} else {
|
|
return some(options.lib, (libFileName) => equalityComparer(file.fileName, pathForLibFile(libFileName)));
|
|
}
|
|
}
|
|
function getTypeChecker() {
|
|
return typeChecker || (typeChecker = createTypeChecker(program));
|
|
}
|
|
function emit(sourceFile, writeFileCallback, cancellationToken, emitOnly, transformers, forceDtsEmit) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Emit, "emit", { path: sourceFile == null ? void 0 : sourceFile.path }, true);
|
|
const result = runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnly, transformers, forceDtsEmit));
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function isEmitBlocked(emitFileName) {
|
|
return hasEmitBlockingDiagnostics.has(toPath3(emitFileName));
|
|
}
|
|
function emitWorker(program2, sourceFile, writeFileCallback, cancellationToken, emitOnly, customTransformers, forceDtsEmit) {
|
|
if (!forceDtsEmit) {
|
|
const result = handleNoEmitOptions(program2, sourceFile, writeFileCallback, cancellationToken);
|
|
if (result)
|
|
return result;
|
|
}
|
|
const emitResolver = getTypeChecker().getEmitResolver(outFile(options) ? void 0 : sourceFile, cancellationToken);
|
|
mark("beforeEmit");
|
|
const emitResult = emitFiles(
|
|
emitResolver,
|
|
getEmitHost(writeFileCallback),
|
|
sourceFile,
|
|
getTransformers(options, customTransformers, emitOnly),
|
|
emitOnly,
|
|
false,
|
|
forceDtsEmit
|
|
);
|
|
mark("afterEmit");
|
|
measure("Emit", "beforeEmit", "afterEmit");
|
|
return emitResult;
|
|
}
|
|
function getSourceFile(fileName) {
|
|
return getSourceFileByPath(toPath3(fileName));
|
|
}
|
|
function getSourceFileByPath(path) {
|
|
return filesByName.get(path) || void 0;
|
|
}
|
|
function getDiagnosticsHelper(sourceFile, getDiagnostics2, cancellationToken) {
|
|
if (sourceFile) {
|
|
return getDiagnostics2(sourceFile, cancellationToken);
|
|
}
|
|
return sortAndDeduplicateDiagnostics(flatMap(program.getSourceFiles(), (sourceFile2) => {
|
|
if (cancellationToken) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
return getDiagnostics2(sourceFile2, cancellationToken);
|
|
}));
|
|
}
|
|
function getSyntacticDiagnostics(sourceFile, cancellationToken) {
|
|
return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken);
|
|
}
|
|
function getSemanticDiagnostics(sourceFile, cancellationToken) {
|
|
return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);
|
|
}
|
|
function getCachedSemanticDiagnostics(sourceFile) {
|
|
var _a3;
|
|
return sourceFile ? (_a3 = cachedBindAndCheckDiagnosticsForFile.perFile) == null ? void 0 : _a3.get(sourceFile.path) : cachedBindAndCheckDiagnosticsForFile.allDiagnostics;
|
|
}
|
|
function getBindAndCheckDiagnostics(sourceFile, cancellationToken) {
|
|
return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken);
|
|
}
|
|
function getProgramDiagnostics(sourceFile) {
|
|
var _a3;
|
|
if (skipTypeChecking(sourceFile, options, program)) {
|
|
return emptyArray;
|
|
}
|
|
const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);
|
|
if (!((_a3 = sourceFile.commentDirectives) == null ? void 0 : _a3.length)) {
|
|
return programDiagnosticsInFile;
|
|
}
|
|
return getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, programDiagnosticsInFile).diagnostics;
|
|
}
|
|
function getDeclarationDiagnostics2(sourceFile, cancellationToken) {
|
|
const options2 = program.getCompilerOptions();
|
|
if (!sourceFile || outFile(options2)) {
|
|
return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
|
|
} else {
|
|
return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken);
|
|
}
|
|
}
|
|
function getSyntacticDiagnosticsForFile(sourceFile) {
|
|
if (isSourceFileJS(sourceFile)) {
|
|
if (!sourceFile.additionalSyntacticDiagnostics) {
|
|
sourceFile.additionalSyntacticDiagnostics = getJSSyntacticDiagnosticsForFile(sourceFile);
|
|
}
|
|
return concatenate(sourceFile.additionalSyntacticDiagnostics, sourceFile.parseDiagnostics);
|
|
}
|
|
return sourceFile.parseDiagnostics;
|
|
}
|
|
function runWithCancellationToken(func) {
|
|
try {
|
|
return func();
|
|
} catch (e) {
|
|
if (e instanceof OperationCanceledException) {
|
|
typeChecker = void 0;
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return concatenate(
|
|
filterSemanticDiagnostics(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), options),
|
|
getProgramDiagnostics(sourceFile)
|
|
);
|
|
}
|
|
function getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedBindAndCheckDiagnosticsForFile, getBindAndCheckDiagnosticsForFileNoCache);
|
|
}
|
|
function getBindAndCheckDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
if (skipTypeChecking(sourceFile, options, program)) {
|
|
return emptyArray;
|
|
}
|
|
const typeChecker2 = getTypeChecker();
|
|
Debug.assert(!!sourceFile.bindDiagnostics);
|
|
const isJs = sourceFile.scriptKind === 1 /* JS */ || sourceFile.scriptKind === 2 /* JSX */;
|
|
const isCheckJs = isJs && isCheckJsEnabledForFile(sourceFile, options);
|
|
const isPlainJs = isPlainJsFile(sourceFile, options.checkJs);
|
|
const isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false;
|
|
const includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 /* TS */ || sourceFile.scriptKind === 4 /* TSX */ || sourceFile.scriptKind === 5 /* External */ || isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* Deferred */);
|
|
let bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : emptyArray;
|
|
let checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker2.getDiagnostics(sourceFile, cancellationToken) : emptyArray;
|
|
if (isPlainJs) {
|
|
bindDiagnostics = filter(bindDiagnostics, (d) => plainJSErrors.has(d.code));
|
|
checkDiagnostics = filter(checkDiagnostics, (d) => plainJSErrors.has(d.code));
|
|
}
|
|
return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : void 0);
|
|
});
|
|
}
|
|
function getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics, ...allDiagnostics) {
|
|
var _a3;
|
|
const flatDiagnostics = flatten(allDiagnostics);
|
|
if (!includeBindAndCheckDiagnostics || !((_a3 = sourceFile.commentDirectives) == null ? void 0 : _a3.length)) {
|
|
return flatDiagnostics;
|
|
}
|
|
const { diagnostics, directives } = getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, flatDiagnostics);
|
|
for (const errorExpectation of directives.getUnusedExpectations()) {
|
|
diagnostics.push(createDiagnosticForRange(sourceFile, errorExpectation.range, Diagnostics.Unused_ts_expect_error_directive));
|
|
}
|
|
return diagnostics;
|
|
}
|
|
function getDiagnosticsWithPrecedingDirectives(sourceFile, commentDirectives, flatDiagnostics) {
|
|
const directives = createCommentDirectivesMap(sourceFile, commentDirectives);
|
|
const diagnostics = flatDiagnostics.filter((diagnostic) => markPrecedingCommentDirectiveLine(diagnostic, directives) === -1);
|
|
return { diagnostics, directives };
|
|
}
|
|
function getSuggestionDiagnostics(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
return getTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken);
|
|
});
|
|
}
|
|
function markPrecedingCommentDirectiveLine(diagnostic, directives) {
|
|
const { file, start: start2 } = diagnostic;
|
|
if (!file) {
|
|
return -1;
|
|
}
|
|
const lineStarts = getLineStarts(file);
|
|
let line = computeLineAndCharacterOfPosition(lineStarts, start2).line - 1;
|
|
while (line >= 0) {
|
|
if (directives.markUsed(line)) {
|
|
return line;
|
|
}
|
|
const lineText = file.text.slice(lineStarts[line], lineStarts[line + 1]).trim();
|
|
if (lineText !== "" && !/^(\s*)\/\/(.*)$/.test(lineText)) {
|
|
return -1;
|
|
}
|
|
line--;
|
|
}
|
|
return -1;
|
|
}
|
|
function getJSSyntacticDiagnosticsForFile(sourceFile) {
|
|
return runWithCancellationToken(() => {
|
|
const diagnostics = [];
|
|
walk(sourceFile, sourceFile);
|
|
forEachChildRecursively(sourceFile, walk, walkArray);
|
|
return diagnostics;
|
|
function walk(node, parent2) {
|
|
switch (parent2.kind) {
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (parent2.questionToken === node) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
|
|
return "skip";
|
|
}
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
case 257 /* VariableDeclaration */:
|
|
if (parent2.type === node) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 270 /* ImportClause */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(parent2, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "export type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
if (node.isTypeOnly) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, isImportSpecifier(node) ? "import...type" : "export...type"));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.import_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 274 /* ExportAssignment */:
|
|
if (node.isExportEquals) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.export_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 294 /* HeritageClause */:
|
|
const heritageClause = node;
|
|
if (heritageClause.token === 117 /* ImplementsKeyword */) {
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.implements_clauses_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 261 /* InterfaceDeclaration */:
|
|
const interfaceKeyword = tokenToString(118 /* InterfaceKeyword */);
|
|
Debug.assertIsDefined(interfaceKeyword);
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, interfaceKeyword));
|
|
return "skip";
|
|
case 264 /* ModuleDeclaration */:
|
|
const moduleKeyword = node.flags & 16 /* Namespace */ ? tokenToString(143 /* NamespaceKeyword */) : tokenToString(142 /* ModuleKeyword */);
|
|
Debug.assertIsDefined(moduleKeyword);
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, moduleKeyword));
|
|
return "skip";
|
|
case 262 /* TypeAliasDeclaration */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 263 /* EnumDeclaration */:
|
|
const enumKeyword = Debug.checkDefined(tokenToString(92 /* EnumKeyword */));
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, enumKeyword));
|
|
return "skip";
|
|
case 232 /* NonNullExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node, Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 231 /* AsExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node.type, Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 235 /* SatisfiesExpression */:
|
|
diagnostics.push(createDiagnosticForNode2(node.type, Diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
case 213 /* TypeAssertionExpression */:
|
|
Debug.fail();
|
|
}
|
|
}
|
|
function walkArray(nodes, parent2) {
|
|
if (canHaveModifiers(parent2) && parent2.modifiers === nodes && some(nodes, isDecorator) && !options.experimentalDecorators) {
|
|
diagnostics.push(createDiagnosticForNode2(parent2, Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning));
|
|
}
|
|
switch (parent2.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
if (nodes === parent2.typeParameters) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
case 240 /* VariableStatement */:
|
|
if (nodes === parent2.modifiers) {
|
|
checkModifiers(parent2.modifiers, parent2.kind === 240 /* VariableStatement */);
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (nodes === parent2.modifiers) {
|
|
for (const modifier of nodes) {
|
|
if (isModifier(modifier) && modifier.kind !== 124 /* StaticKeyword */ && modifier.kind !== 127 /* AccessorKeyword */) {
|
|
diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
|
|
}
|
|
}
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 166 /* Parameter */:
|
|
if (nodes === parent2.modifiers && some(nodes, isModifier)) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
if (nodes === parent2.typeArguments) {
|
|
diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files));
|
|
return "skip";
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function checkModifiers(modifiers, isConstValid) {
|
|
for (const modifier of modifiers) {
|
|
switch (modifier.kind) {
|
|
case 85 /* ConstKeyword */:
|
|
if (isConstValid) {
|
|
continue;
|
|
}
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 126 /* AbstractKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 145 /* OutKeyword */:
|
|
diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
|
|
break;
|
|
case 124 /* StaticKeyword */:
|
|
case 93 /* ExportKeyword */:
|
|
case 88 /* DefaultKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
}
|
|
}
|
|
}
|
|
function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
|
|
const start2 = nodes.pos;
|
|
return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2);
|
|
}
|
|
function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
|
|
return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
|
|
}
|
|
});
|
|
}
|
|
function getDeclarationDiagnosticsWorker(sourceFile, cancellationToken) {
|
|
return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedDeclarationDiagnosticsForFile, getDeclarationDiagnosticsForFileNoCache);
|
|
}
|
|
function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) {
|
|
return runWithCancellationToken(() => {
|
|
const resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
|
|
return getDeclarationDiagnostics(getEmitHost(noop), resolver, sourceFile) || emptyArray;
|
|
});
|
|
}
|
|
function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics2) {
|
|
var _a3;
|
|
const cachedResult = sourceFile ? (_a3 = cache.perFile) == null ? void 0 : _a3.get(sourceFile.path) : cache.allDiagnostics;
|
|
if (cachedResult) {
|
|
return cachedResult;
|
|
}
|
|
const result = getDiagnostics2(sourceFile, cancellationToken);
|
|
if (sourceFile) {
|
|
(cache.perFile || (cache.perFile = /* @__PURE__ */ new Map())).set(sourceFile.path, result);
|
|
} else {
|
|
cache.allDiagnostics = result;
|
|
}
|
|
return result;
|
|
}
|
|
function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) {
|
|
return sourceFile.isDeclarationFile ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken);
|
|
}
|
|
function getOptionsDiagnostics() {
|
|
return sortAndDeduplicateDiagnostics(concatenate(
|
|
programDiagnostics.getGlobalDiagnostics(),
|
|
getOptionsDiagnosticsOfConfigFile()
|
|
));
|
|
}
|
|
function getOptionsDiagnosticsOfConfigFile() {
|
|
if (!options.configFile)
|
|
return emptyArray;
|
|
let diagnostics = programDiagnostics.getDiagnostics(options.configFile.fileName);
|
|
forEachResolvedProjectReference2((resolvedRef) => {
|
|
diagnostics = concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName));
|
|
});
|
|
return diagnostics;
|
|
}
|
|
function getGlobalDiagnostics() {
|
|
return rootNames.length ? sortAndDeduplicateDiagnostics(getTypeChecker().getGlobalDiagnostics().slice()) : emptyArray;
|
|
}
|
|
function getConfigFileParsingDiagnostics2() {
|
|
return configFileParsingDiagnostics || emptyArray;
|
|
}
|
|
function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason) {
|
|
processSourceFile(normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, void 0, reason);
|
|
}
|
|
function fileReferenceIsEqualTo(a, b) {
|
|
return a.fileName === b.fileName;
|
|
}
|
|
function moduleNameIsEqualTo(a, b) {
|
|
return a.kind === 79 /* Identifier */ ? b.kind === 79 /* Identifier */ && a.escapedText === b.escapedText : b.kind === 10 /* StringLiteral */ && a.text === b.text;
|
|
}
|
|
function createSyntheticImport(text, file) {
|
|
const externalHelpersModuleReference = factory.createStringLiteral(text);
|
|
const importDecl = factory.createImportDeclaration(void 0, void 0, externalHelpersModuleReference, void 0);
|
|
addEmitFlags(importDecl, 134217728 /* NeverApplyImportHelper */);
|
|
setParent(externalHelpersModuleReference, importDecl);
|
|
setParent(importDecl, file);
|
|
externalHelpersModuleReference.flags &= ~8 /* Synthesized */;
|
|
importDecl.flags &= ~8 /* Synthesized */;
|
|
return externalHelpersModuleReference;
|
|
}
|
|
function collectExternalModuleReferences(file) {
|
|
if (file.imports) {
|
|
return;
|
|
}
|
|
const isJavaScriptFile = isSourceFileJS(file);
|
|
const isExternalModuleFile = isExternalModule(file);
|
|
let imports;
|
|
let moduleAugmentations;
|
|
let ambientModules;
|
|
if ((options.isolatedModules || isExternalModuleFile) && !file.isDeclarationFile) {
|
|
if (options.importHelpers) {
|
|
imports = [createSyntheticImport(externalHelpersModuleNameText, file)];
|
|
}
|
|
const jsxImport = getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
|
|
if (jsxImport) {
|
|
(imports || (imports = [])).push(createSyntheticImport(jsxImport, file));
|
|
}
|
|
}
|
|
for (const node of file.statements) {
|
|
collectModuleReferences(node, false);
|
|
}
|
|
if (file.flags & 2097152 /* PossiblyContainsDynamicImport */ || isJavaScriptFile) {
|
|
collectDynamicImportOrRequireCalls(file);
|
|
}
|
|
file.imports = imports || emptyArray;
|
|
file.moduleAugmentations = moduleAugmentations || emptyArray;
|
|
file.ambientModuleNames = ambientModules || emptyArray;
|
|
return;
|
|
function collectModuleReferences(node, inAmbientModule) {
|
|
if (isAnyImportOrReExport(node)) {
|
|
const moduleNameExpr = getExternalModuleName(node);
|
|
if (moduleNameExpr && isStringLiteral(moduleNameExpr) && moduleNameExpr.text && (!inAmbientModule || !isExternalModuleNameRelative(moduleNameExpr.text))) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, moduleNameExpr);
|
|
if (!usesUriStyleNodeCoreModules && currentNodeModulesDepth === 0 && !file.isDeclarationFile) {
|
|
usesUriStyleNodeCoreModules = startsWith(moduleNameExpr.text, "node:");
|
|
}
|
|
}
|
|
} else if (isModuleDeclaration(node)) {
|
|
if (isAmbientModule(node) && (inAmbientModule || hasSyntacticModifier(node, 2 /* Ambient */) || file.isDeclarationFile)) {
|
|
node.name.parent = node;
|
|
const nameText = getTextOfIdentifierOrLiteral(node.name);
|
|
if (isExternalModuleFile || inAmbientModule && !isExternalModuleNameRelative(nameText)) {
|
|
(moduleAugmentations || (moduleAugmentations = [])).push(node.name);
|
|
} else if (!inAmbientModule) {
|
|
if (file.isDeclarationFile) {
|
|
(ambientModules || (ambientModules = [])).push(nameText);
|
|
}
|
|
const body = node.body;
|
|
if (body) {
|
|
for (const statement of body.statements) {
|
|
collectModuleReferences(statement, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function collectDynamicImportOrRequireCalls(file2) {
|
|
const r = /import|require/g;
|
|
while (r.exec(file2.text) !== null) {
|
|
const node = getNodeAtPosition(file2, r.lastIndex);
|
|
if (isJavaScriptFile && isRequireCall(node, true)) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.arguments[0]);
|
|
} else if (isImportCall(node) && node.arguments.length >= 1 && isStringLiteralLike(node.arguments[0])) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.arguments[0]);
|
|
} else if (isLiteralImportTypeNode(node)) {
|
|
setParentRecursive(node, false);
|
|
imports = append(imports, node.argument.literal);
|
|
}
|
|
}
|
|
}
|
|
function getNodeAtPosition(sourceFile, position) {
|
|
let current = sourceFile;
|
|
const getContainingChild = (child) => {
|
|
if (child.pos <= position && (position < child.end || position === child.end && child.kind === 1 /* EndOfFileToken */)) {
|
|
return child;
|
|
}
|
|
};
|
|
while (true) {
|
|
const child = isJavaScriptFile && hasJSDocNodes(current) && forEach(current.jsDoc, getContainingChild) || forEachChild(current, getContainingChild);
|
|
if (!child) {
|
|
return current;
|
|
}
|
|
current = child;
|
|
}
|
|
}
|
|
}
|
|
function getLibFileFromReference(ref) {
|
|
const libName = toFileNameLowerCase(ref.fileName);
|
|
const libFileName = libMap.get(libName);
|
|
if (libFileName) {
|
|
return getSourceFile(pathForLibFile(libFileName));
|
|
}
|
|
}
|
|
function getSourceFileFromReference(referencingFile, ref) {
|
|
return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile);
|
|
}
|
|
function getSourceFileFromReferenceWorker(fileName, getSourceFile2, fail, reason) {
|
|
if (hasExtension(fileName)) {
|
|
const canonicalFileName = host.getCanonicalFileName(fileName);
|
|
if (!options.allowNonTsExtensions && !forEach(flatten(supportedExtensionsWithJsonIfResolveJsonModule), (extension) => fileExtensionIs(canonicalFileName, extension))) {
|
|
if (fail) {
|
|
if (hasJSFileExtension(canonicalFileName)) {
|
|
fail(Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName);
|
|
} else {
|
|
fail(Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
const sourceFile = getSourceFile2(fileName);
|
|
if (fail) {
|
|
if (!sourceFile) {
|
|
const redirect = getProjectReferenceRedirect(fileName);
|
|
if (redirect) {
|
|
fail(Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, fileName);
|
|
} else {
|
|
fail(Diagnostics.File_0_not_found, fileName);
|
|
}
|
|
} else if (isReferencedFile(reason) && canonicalFileName === host.getCanonicalFileName(getSourceFileByPath(reason.file).fileName)) {
|
|
fail(Diagnostics.A_file_cannot_have_a_reference_to_itself);
|
|
}
|
|
}
|
|
return sourceFile;
|
|
} else {
|
|
const sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile2(fileName);
|
|
if (sourceFileNoExtension)
|
|
return sourceFileNoExtension;
|
|
if (fail && options.allowNonTsExtensions) {
|
|
fail(Diagnostics.File_0_not_found, fileName);
|
|
return void 0;
|
|
}
|
|
const sourceFileWithAddedExtension = forEach(supportedExtensions[0], (extension) => getSourceFile2(fileName + extension));
|
|
if (fail && !sourceFileWithAddedExtension)
|
|
fail(Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
|
|
return sourceFileWithAddedExtension;
|
|
}
|
|
}
|
|
function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, reason) {
|
|
getSourceFileFromReferenceWorker(
|
|
fileName,
|
|
(fileName2) => findSourceFile(fileName2, isDefaultLib, ignoreNoDefaultLib, reason, packageId),
|
|
(diagnostic, ...args) => addFilePreprocessingFileExplainingDiagnostic(void 0, reason, diagnostic, args),
|
|
reason
|
|
);
|
|
}
|
|
function processProjectReferenceFile(fileName, reason) {
|
|
return processSourceFile(fileName, false, false, void 0, reason);
|
|
}
|
|
function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason) {
|
|
const hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && some(fileReasons.get(existingFile.path), isReferencedFile);
|
|
if (hasExistingReasonToReportErrorOn) {
|
|
addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [existingFile.fileName, fileName]);
|
|
} else {
|
|
addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, 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, sourceFileOptions) {
|
|
var _a3;
|
|
const redirect = Object.create(redirectTarget);
|
|
redirect.fileName = fileName;
|
|
redirect.path = path;
|
|
redirect.resolvedPath = resolvedPath;
|
|
redirect.originalFileName = originalFileName;
|
|
redirect.redirectInfo = { redirectTarget, unredirected };
|
|
redirect.packageJsonLocations = ((_a3 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _a3.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
redirect.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
|
|
Object.defineProperties(redirect, {
|
|
id: {
|
|
get() {
|
|
return this.redirectInfo.redirectTarget.id;
|
|
},
|
|
set(value) {
|
|
this.redirectInfo.redirectTarget.id = value;
|
|
}
|
|
},
|
|
symbol: {
|
|
get() {
|
|
return this.redirectInfo.redirectTarget.symbol;
|
|
},
|
|
set(value) {
|
|
this.redirectInfo.redirectTarget.symbol = value;
|
|
}
|
|
}
|
|
});
|
|
return redirect;
|
|
}
|
|
function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "findSourceFile", {
|
|
fileName,
|
|
isDefaultLib: isDefaultLib || void 0,
|
|
fileIncludeKind: FileIncludeKind[reason.kind]
|
|
});
|
|
const result = findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
return result;
|
|
}
|
|
function getCreateSourceFileOptions(fileName, moduleResolutionCache2, host2, options2) {
|
|
const result = getImpliedNodeFormatForFileWorker(getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache2 == null ? void 0 : moduleResolutionCache2.getPackageJsonInfoCache(), host2, options2);
|
|
const languageVersion = getEmitScriptTarget(options2);
|
|
const setExternalModuleIndicator2 = getSetExternalModuleIndicator(options2);
|
|
return typeof result === "object" ? { ...result, languageVersion, setExternalModuleIndicator: setExternalModuleIndicator2 } : { languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator2 };
|
|
}
|
|
function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
|
|
var _a3, _b2;
|
|
const path = toPath3(fileName);
|
|
if (useSourceOfProjectReferenceRedirect) {
|
|
let source = getSourceOfProjectReferenceRedirect(path);
|
|
if (!source && host.realpath && options.preserveSymlinks && isDeclarationFileName(fileName) && stringContains(fileName, nodeModulesPathPart)) {
|
|
const realPath2 = toPath3(host.realpath(fileName));
|
|
if (realPath2 !== path)
|
|
source = getSourceOfProjectReferenceRedirect(realPath2);
|
|
}
|
|
if (source) {
|
|
const file2 = isString(source) ? findSourceFile(source, isDefaultLib, ignoreNoDefaultLib, reason, packageId) : void 0;
|
|
if (file2)
|
|
addFileToFilesByName(file2, path, void 0);
|
|
return file2;
|
|
}
|
|
}
|
|
const originalFileName = fileName;
|
|
if (filesByName.has(path)) {
|
|
const file2 = filesByName.get(path);
|
|
addFileIncludeReason(file2 || void 0, reason);
|
|
if (file2 && options.forceConsistentCasingInFileNames) {
|
|
const checkedName = file2.fileName;
|
|
const isRedirect = toPath3(checkedName) !== toPath3(fileName);
|
|
if (isRedirect) {
|
|
fileName = getProjectReferenceRedirect(fileName) || fileName;
|
|
}
|
|
const checkedAbsolutePath = getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory);
|
|
const inputAbsolutePath = getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory);
|
|
if (checkedAbsolutePath !== inputAbsolutePath) {
|
|
reportFileNamesDifferOnlyInCasingError(fileName, file2, reason);
|
|
}
|
|
}
|
|
if (file2 && sourceFilesFoundSearchingNodeModules.get(file2.path) && currentNodeModulesDepth === 0) {
|
|
sourceFilesFoundSearchingNodeModules.set(file2.path, false);
|
|
if (!options.noResolve) {
|
|
processReferencedFiles(file2, isDefaultLib);
|
|
processTypeReferenceDirectives(file2);
|
|
}
|
|
if (!options.noLib) {
|
|
processLibReferenceDirectives(file2);
|
|
}
|
|
modulesWithElidedImports.set(file2.path, false);
|
|
processImportedModules(file2);
|
|
} else if (file2 && modulesWithElidedImports.get(file2.path)) {
|
|
if (currentNodeModulesDepth < maxNodeModuleJsDepth) {
|
|
modulesWithElidedImports.set(file2.path, false);
|
|
processImportedModules(file2);
|
|
}
|
|
}
|
|
return file2 || void 0;
|
|
}
|
|
let redirectedPath;
|
|
if (isReferencedFile(reason) && !useSourceOfProjectReferenceRedirect) {
|
|
const redirectProject = getProjectReferenceRedirectProject(fileName);
|
|
if (redirectProject) {
|
|
if (outFile(redirectProject.commandLine.options)) {
|
|
return void 0;
|
|
}
|
|
const redirect = getProjectReferenceOutputName(redirectProject, fileName);
|
|
fileName = redirect;
|
|
redirectedPath = toPath3(redirect);
|
|
}
|
|
}
|
|
const sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options);
|
|
const file = host.getSourceFile(
|
|
fileName,
|
|
sourceFileOptions,
|
|
(hostErrorMessage) => addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]),
|
|
shouldCreateNewSourceFile || ((_a3 = oldProgram == null ? void 0 : oldProgram.getSourceFileByPath(toPath3(fileName))) == null ? void 0 : _a3.impliedNodeFormat) !== sourceFileOptions.impliedNodeFormat
|
|
);
|
|
if (packageId) {
|
|
const packageIdKey = packageIdToString(packageId);
|
|
const fileFromPackageId = packageIdToSourceFile.get(packageIdKey);
|
|
if (fileFromPackageId) {
|
|
const dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath3(fileName), originalFileName, sourceFileOptions);
|
|
redirectTargetsMap.add(fileFromPackageId.path, fileName);
|
|
addFileToFilesByName(dupFile, path, redirectedPath);
|
|
addFileIncludeReason(dupFile, reason);
|
|
sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
|
|
processingOtherFiles.push(dupFile);
|
|
return dupFile;
|
|
} else if (file) {
|
|
packageIdToSourceFile.set(packageIdKey, file);
|
|
sourceFileToPackageName.set(path, packageIdToPackageName(packageId));
|
|
}
|
|
}
|
|
addFileToFilesByName(file, path, redirectedPath);
|
|
if (file) {
|
|
sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0);
|
|
file.fileName = fileName;
|
|
file.path = path;
|
|
file.resolvedPath = toPath3(fileName);
|
|
file.originalFileName = originalFileName;
|
|
file.packageJsonLocations = ((_b2 = sourceFileOptions.packageJsonLocations) == null ? void 0 : _b2.length) ? sourceFileOptions.packageJsonLocations : void 0;
|
|
file.packageJsonScope = sourceFileOptions.packageJsonScope;
|
|
addFileIncludeReason(file, reason);
|
|
if (host.useCaseSensitiveFileNames()) {
|
|
const pathLowerCase = toFileNameLowerCase(path);
|
|
const existingFile = filesByNameIgnoreCase.get(pathLowerCase);
|
|
if (existingFile) {
|
|
reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason);
|
|
} else {
|
|
filesByNameIgnoreCase.set(pathLowerCase, file);
|
|
}
|
|
}
|
|
skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib && !ignoreNoDefaultLib;
|
|
if (!options.noResolve) {
|
|
processReferencedFiles(file, isDefaultLib);
|
|
processTypeReferenceDirectives(file);
|
|
}
|
|
if (!options.noLib) {
|
|
processLibReferenceDirectives(file);
|
|
}
|
|
processImportedModules(file);
|
|
if (isDefaultLib) {
|
|
processingDefaultLibFiles.push(file);
|
|
} else {
|
|
processingOtherFiles.push(file);
|
|
}
|
|
}
|
|
return file;
|
|
}
|
|
function addFileIncludeReason(file, reason) {
|
|
if (file)
|
|
fileReasons.add(file.path, reason);
|
|
}
|
|
function addFileToFilesByName(file, path, redirectedPath) {
|
|
if (redirectedPath) {
|
|
filesByName.set(redirectedPath, file);
|
|
filesByName.set(path, file || false);
|
|
} else {
|
|
filesByName.set(path, file);
|
|
}
|
|
}
|
|
function getProjectReferenceRedirect(fileName) {
|
|
const referencedProject = getProjectReferenceRedirectProject(fileName);
|
|
return referencedProject && getProjectReferenceOutputName(referencedProject, fileName);
|
|
}
|
|
function getProjectReferenceRedirectProject(fileName) {
|
|
if (!resolvedProjectReferences || !resolvedProjectReferences.length || isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
return void 0;
|
|
}
|
|
return getResolvedProjectReferenceToRedirect(fileName);
|
|
}
|
|
function getProjectReferenceOutputName(referencedProject, fileName) {
|
|
const out = outFile(referencedProject.commandLine.options);
|
|
return out ? changeExtension(out, ".d.ts" /* Dts */) : getOutputDeclarationFileName(fileName, referencedProject.commandLine, !host.useCaseSensitiveFileNames());
|
|
}
|
|
function getResolvedProjectReferenceToRedirect(fileName) {
|
|
if (mapFromFileToProjectReferenceRedirects === void 0) {
|
|
mapFromFileToProjectReferenceRedirects = /* @__PURE__ */ new Map();
|
|
forEachResolvedProjectReference2((referencedProject) => {
|
|
if (toPath3(options.configFilePath) !== referencedProject.sourceFile.path) {
|
|
referencedProject.commandLine.fileNames.forEach((f) => mapFromFileToProjectReferenceRedirects.set(toPath3(f), referencedProject.sourceFile.path));
|
|
}
|
|
});
|
|
}
|
|
const referencedProjectPath = mapFromFileToProjectReferenceRedirects.get(toPath3(fileName));
|
|
return referencedProjectPath && getResolvedProjectReferenceByPath(referencedProjectPath);
|
|
}
|
|
function forEachResolvedProjectReference2(cb) {
|
|
return forEachResolvedProjectReference(resolvedProjectReferences, cb);
|
|
}
|
|
function getSourceOfProjectReferenceRedirect(path) {
|
|
if (!isDeclarationFileName(path))
|
|
return void 0;
|
|
if (mapFromToProjectReferenceRedirectSource === void 0) {
|
|
mapFromToProjectReferenceRedirectSource = /* @__PURE__ */ new Map();
|
|
forEachResolvedProjectReference2((resolvedRef) => {
|
|
const out = outFile(resolvedRef.commandLine.options);
|
|
if (out) {
|
|
const outputDts = changeExtension(out, ".d.ts" /* Dts */);
|
|
mapFromToProjectReferenceRedirectSource.set(toPath3(outputDts), true);
|
|
} else {
|
|
const getCommonSourceDirectory3 = memoize(() => getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()));
|
|
forEach(resolvedRef.commandLine.fileNames, (fileName) => {
|
|
if (!isDeclarationFileName(fileName) && !fileExtensionIs(fileName, ".json" /* Json */)) {
|
|
const outputDts = getOutputDeclarationFileName(fileName, resolvedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory3);
|
|
mapFromToProjectReferenceRedirectSource.set(toPath3(outputDts), fileName);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return mapFromToProjectReferenceRedirectSource.get(path);
|
|
}
|
|
function isSourceOfProjectReferenceRedirect(fileName) {
|
|
return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName);
|
|
}
|
|
function getResolvedProjectReferenceByPath(projectReferencePath) {
|
|
if (!projectReferenceRedirects) {
|
|
return void 0;
|
|
}
|
|
return projectReferenceRedirects.get(projectReferencePath) || void 0;
|
|
}
|
|
function processReferencedFiles(file, isDefaultLib) {
|
|
forEach(file.referencedFiles, (ref, index) => {
|
|
processSourceFile(
|
|
resolveTripleslashReference(ref.fileName, file.fileName),
|
|
isDefaultLib,
|
|
false,
|
|
void 0,
|
|
{ kind: 4 /* ReferenceFile */, file: file.path, index }
|
|
);
|
|
});
|
|
}
|
|
function processTypeReferenceDirectives(file) {
|
|
const typeDirectives = file.typeReferenceDirectives;
|
|
if (!typeDirectives) {
|
|
return;
|
|
}
|
|
const resolutions = resolveTypeReferenceDirectiveNamesReusingOldState(typeDirectives, file);
|
|
for (let index = 0; index < typeDirectives.length; index++) {
|
|
const ref = file.typeReferenceDirectives[index];
|
|
const resolvedTypeReferenceDirective = resolutions[index];
|
|
const fileName = toFileNameLowerCase(ref.fileName);
|
|
setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective, getModeForFileReference(ref, file.impliedNodeFormat));
|
|
const mode = ref.resolutionMode || file.impliedNodeFormat;
|
|
if (mode && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
|
|
programDiagnostics.add(createDiagnosticForRange(file, ref, Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext));
|
|
}
|
|
processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });
|
|
}
|
|
}
|
|
function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
|
|
var _a3, _b2;
|
|
(_a3 = tracing) == null ? void 0 : _a3.push(tracing.Phase.Program, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : void 0 });
|
|
processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason);
|
|
(_b2 = tracing) == null ? void 0 : _b2.pop();
|
|
}
|
|
function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) {
|
|
const previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode);
|
|
if (previousResolution && previousResolution.primary) {
|
|
return;
|
|
}
|
|
let saveResolution = true;
|
|
if (resolvedTypeReferenceDirective) {
|
|
if (resolvedTypeReferenceDirective.isExternalLibraryImport)
|
|
currentNodeModulesDepth++;
|
|
if (resolvedTypeReferenceDirective.primary) {
|
|
processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, reason);
|
|
} else {
|
|
if (previousResolution) {
|
|
if (resolvedTypeReferenceDirective.resolvedFileName !== previousResolution.resolvedFileName) {
|
|
const otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName);
|
|
const existingFile = getSourceFile(previousResolution.resolvedFileName);
|
|
if (otherFileText !== existingFile.text) {
|
|
addFilePreprocessingFileExplainingDiagnostic(
|
|
existingFile,
|
|
reason,
|
|
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]
|
|
);
|
|
}
|
|
}
|
|
saveResolution = false;
|
|
} else {
|
|
processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, false, false, resolvedTypeReferenceDirective.packageId, reason);
|
|
}
|
|
}
|
|
if (resolvedTypeReferenceDirective.isExternalLibraryImport)
|
|
currentNodeModulesDepth--;
|
|
} else {
|
|
addFilePreprocessingFileExplainingDiagnostic(void 0, reason, Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]);
|
|
}
|
|
if (saveResolution) {
|
|
resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective);
|
|
}
|
|
}
|
|
function pathForLibFile(libFileName) {
|
|
const components = libFileName.split(".");
|
|
let path = components[1];
|
|
let i = 2;
|
|
while (components[i] && components[i] !== "d") {
|
|
path += (i === 2 ? "/" : "-") + components[i];
|
|
i++;
|
|
}
|
|
const resolveFrom = combinePaths(currentDirectory, `__lib_node_modules_lookup_${libFileName}__.ts`);
|
|
const localOverrideModuleResult = resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: 2 /* NodeJs */ }, host, moduleResolutionCache);
|
|
if (localOverrideModuleResult == null ? void 0 : localOverrideModuleResult.resolvedModule) {
|
|
return localOverrideModuleResult.resolvedModule.resolvedFileName;
|
|
}
|
|
return combinePaths(defaultLibraryPath, libFileName);
|
|
}
|
|
function processLibReferenceDirectives(file) {
|
|
forEach(file.libReferenceDirectives, (libReference, index) => {
|
|
const libName = toFileNameLowerCase(libReference.fileName);
|
|
const libFileName = libMap.get(libName);
|
|
if (libFileName) {
|
|
processRootFile(pathForLibFile(libFileName), true, true, { kind: 7 /* LibReferenceDirective */, file: file.path, index });
|
|
} else {
|
|
const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
|
|
const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
|
|
const diagnostic = suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0;
|
|
(fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
|
|
kind: 0 /* FilePreprocessingReferencedDiagnostic */,
|
|
reason: { kind: 7 /* LibReferenceDirective */, file: file.path, index },
|
|
diagnostic,
|
|
args: [libName, suggestion]
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function getCanonicalFileName(fileName) {
|
|
return host.getCanonicalFileName(fileName);
|
|
}
|
|
function processImportedModules(file) {
|
|
var _a3;
|
|
collectExternalModuleReferences(file);
|
|
if (file.imports.length || file.moduleAugmentations.length) {
|
|
const moduleNames = getModuleNames(file);
|
|
const resolutions = resolveModuleNamesReusingOldState(moduleNames, file);
|
|
Debug.assert(resolutions.length === moduleNames.length);
|
|
const optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a3 = getRedirectReferenceForResolution(file)) == null ? void 0 : _a3.commandLine.options : void 0) || options;
|
|
for (let index = 0; index < moduleNames.length; index++) {
|
|
const resolution = resolutions[index];
|
|
setResolvedModule(file, moduleNames[index].text, resolution, getModeForUsageLocation(file, moduleNames[index]));
|
|
if (!resolution) {
|
|
continue;
|
|
}
|
|
const isFromNodeModulesSearch = resolution.isExternalLibraryImport;
|
|
const isJsFile = !resolutionExtensionIsTSOrJson(resolution.extension);
|
|
const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
|
|
const resolvedFileName = resolution.resolvedFileName;
|
|
if (isFromNodeModulesSearch) {
|
|
currentNodeModulesDepth++;
|
|
}
|
|
const elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModuleJsDepth;
|
|
const shouldAddFile = resolvedFileName && !getResolutionDiagnostic(optionsForFile, resolution) && !optionsForFile.noResolve && index < file.imports.length && !elideImport && !(isJsFile && !getAllowJSCompilerOption(optionsForFile)) && (isInJSFile(file.imports[index]) || !(file.imports[index].flags & 8388608 /* JSDoc */));
|
|
if (elideImport) {
|
|
modulesWithElidedImports.set(file.path, true);
|
|
} else if (shouldAddFile) {
|
|
findSourceFile(
|
|
resolvedFileName,
|
|
false,
|
|
false,
|
|
{ kind: 3 /* Import */, file: file.path, index },
|
|
resolution.packageId
|
|
);
|
|
}
|
|
if (isFromNodeModulesSearch) {
|
|
currentNodeModulesDepth--;
|
|
}
|
|
}
|
|
} else {
|
|
file.resolvedModules = void 0;
|
|
}
|
|
}
|
|
function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) {
|
|
let allFilesBelongToPath = true;
|
|
const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
|
|
for (const sourceFile of sourceFiles) {
|
|
if (!sourceFile.isDeclarationFile) {
|
|
const absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
|
|
if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
|
|
addProgramDiagnosticExplainingFile(
|
|
sourceFile,
|
|
Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files,
|
|
[sourceFile.fileName, rootDirectory]
|
|
);
|
|
allFilesBelongToPath = false;
|
|
}
|
|
}
|
|
}
|
|
return allFilesBelongToPath;
|
|
}
|
|
function parseProjectReferenceConfigFile(ref) {
|
|
if (!projectReferenceRedirects) {
|
|
projectReferenceRedirects = /* @__PURE__ */ new Map();
|
|
}
|
|
const refPath = resolveProjectReferencePath(ref);
|
|
const sourceFilePath = toPath3(refPath);
|
|
const fromCache = projectReferenceRedirects.get(sourceFilePath);
|
|
if (fromCache !== void 0) {
|
|
return fromCache || void 0;
|
|
}
|
|
let commandLine;
|
|
let sourceFile;
|
|
if (host.getParsedCommandLine) {
|
|
commandLine = host.getParsedCommandLine(refPath);
|
|
if (!commandLine) {
|
|
addFileToFilesByName(void 0, sourceFilePath, void 0);
|
|
projectReferenceRedirects.set(sourceFilePath, false);
|
|
return void 0;
|
|
}
|
|
sourceFile = Debug.checkDefined(commandLine.options.configFile);
|
|
Debug.assert(!sourceFile.path || sourceFile.path === sourceFilePath);
|
|
addFileToFilesByName(sourceFile, sourceFilePath, void 0);
|
|
} else {
|
|
const basePath = getNormalizedAbsolutePath(getDirectoryPath(refPath), host.getCurrentDirectory());
|
|
sourceFile = host.getSourceFile(refPath, 100 /* JSON */);
|
|
addFileToFilesByName(sourceFile, sourceFilePath, void 0);
|
|
if (sourceFile === void 0) {
|
|
projectReferenceRedirects.set(sourceFilePath, false);
|
|
return void 0;
|
|
}
|
|
commandLine = parseJsonSourceFileConfigFileContent(sourceFile, configParsingHost, basePath, void 0, refPath);
|
|
}
|
|
sourceFile.fileName = refPath;
|
|
sourceFile.path = sourceFilePath;
|
|
sourceFile.resolvedPath = sourceFilePath;
|
|
sourceFile.originalFileName = refPath;
|
|
const resolvedRef = { commandLine, sourceFile };
|
|
projectReferenceRedirects.set(sourceFilePath, resolvedRef);
|
|
if (commandLine.projectReferences) {
|
|
resolvedRef.references = commandLine.projectReferences.map(parseProjectReferenceConfigFile);
|
|
}
|
|
return resolvedRef;
|
|
}
|
|
function verifyCompilerOptions() {
|
|
if (options.strictPropertyInitialization && !getStrictOptionValue(options, "strictNullChecks")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
|
|
}
|
|
if (options.exactOptionalPropertyTypes && !getStrictOptionValue(options, "strictNullChecks")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks");
|
|
}
|
|
if (options.isolatedModules) {
|
|
if (options.out) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules");
|
|
}
|
|
if (options.outFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules");
|
|
}
|
|
}
|
|
if (options.inlineSourceMap) {
|
|
if (options.sourceMap) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap");
|
|
}
|
|
if (options.mapRoot) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap");
|
|
}
|
|
}
|
|
if (options.composite) {
|
|
if (options.declaration === false) {
|
|
createDiagnosticForOptionName(Diagnostics.Composite_projects_may_not_disable_declaration_emit, "declaration");
|
|
}
|
|
if (options.incremental === false) {
|
|
createDiagnosticForOptionName(Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration");
|
|
}
|
|
}
|
|
const outputFile = outFile(options);
|
|
if (options.tsBuildInfoFile) {
|
|
if (!isIncrementalCompilation(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "tsBuildInfoFile", "incremental", "composite");
|
|
}
|
|
} else if (options.incremental && !outputFile && !options.configFilePath) {
|
|
programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified));
|
|
}
|
|
verifyProjectReferences();
|
|
if (options.composite) {
|
|
const rootPaths = new Set(rootNames.map(toPath3));
|
|
for (const file of files) {
|
|
if (sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) {
|
|
addProgramDiagnosticExplainingFile(
|
|
file,
|
|
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 || ""]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (options.paths) {
|
|
for (const key in options.paths) {
|
|
if (!hasProperty(options.paths, key)) {
|
|
continue;
|
|
}
|
|
if (!hasZeroOrOneAsteriskCharacter(key)) {
|
|
createDiagnosticForOptionPaths(true, key, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, key);
|
|
}
|
|
if (isArray(options.paths[key])) {
|
|
const len = options.paths[key].length;
|
|
if (len === 0) {
|
|
createDiagnosticForOptionPaths(false, key, Diagnostics.Substitutions_for_pattern_0_shouldn_t_be_an_empty_array, key);
|
|
}
|
|
for (let i = 0; i < len; i++) {
|
|
const subst = options.paths[key][i];
|
|
const typeOfSubst = typeof subst;
|
|
if (typeOfSubst === "string") {
|
|
if (!hasZeroOrOneAsteriskCharacter(subst)) {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, subst, key);
|
|
}
|
|
if (!options.baseUrl && !pathIsRelative(subst) && !pathIsAbsolute(subst)) {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash);
|
|
}
|
|
} else {
|
|
createDiagnosticForOptionPathKeyValue(key, i, Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst);
|
|
}
|
|
}
|
|
} else {
|
|
createDiagnosticForOptionPaths(false, key, Diagnostics.Substitutions_for_pattern_0_should_be_an_array, key);
|
|
}
|
|
}
|
|
}
|
|
if (!options.sourceMap && !options.inlineSourceMap) {
|
|
if (options.inlineSources) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources");
|
|
}
|
|
if (options.sourceRoot) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot");
|
|
}
|
|
}
|
|
if (options.out && options.outFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile");
|
|
}
|
|
if (options.mapRoot && !(options.sourceMap || options.declarationMap)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "mapRoot", "sourceMap", "declarationMap");
|
|
}
|
|
if (options.declarationDir) {
|
|
if (!getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite");
|
|
}
|
|
if (outputFile) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile");
|
|
}
|
|
}
|
|
if (options.declarationMap && !getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationMap", "declaration", "composite");
|
|
}
|
|
if (options.lib && options.noLib) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib");
|
|
}
|
|
if (options.noImplicitUseStrict && getStrictOptionValue(options, "alwaysStrict")) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict");
|
|
}
|
|
const languageVersion = getEmitScriptTarget(options);
|
|
const firstNonAmbientExternalModuleSourceFile = find(files, (f) => isExternalModule(f) && !f.isDeclarationFile);
|
|
if (options.isolatedModules) {
|
|
if (options.module === 0 /* None */ && languageVersion < 2 /* ES2015 */) {
|
|
createDiagnosticForOptionName(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(Diagnostics.Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled, "preserveConstEnums", "isolatedModules");
|
|
}
|
|
for (const file of files) {
|
|
if (!isExternalModule(file) && !isSourceFileJS(file) && !file.isDeclarationFile && file.scriptKind !== 6 /* JSON */) {
|
|
const span = getErrorSpanForNode(file, file);
|
|
programDiagnostics.add(createFileDiagnostic(
|
|
file,
|
|
span.start,
|
|
span.length,
|
|
Diagnostics._0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module,
|
|
getBaseFileName(file.fileName)
|
|
));
|
|
}
|
|
}
|
|
} else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 /* ES2015 */ && options.module === 0 /* None */) {
|
|
const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
|
|
programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none));
|
|
}
|
|
if (outputFile && !options.emitDeclarationOnly) {
|
|
if (options.module && !(options.module === 2 /* AMD */ || options.module === 4 /* System */)) {
|
|
createDiagnosticForOptionName(Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module");
|
|
} else if (options.module === void 0 && firstNonAmbientExternalModuleSourceFile) {
|
|
const span = getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator);
|
|
programDiagnostics.add(createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile"));
|
|
}
|
|
}
|
|
if (options.resolveJsonModule) {
|
|
if (getEmitModuleResolutionKind(options) !== 2 /* NodeJs */ && getEmitModuleResolutionKind(options) !== 3 /* Node16 */ && getEmitModuleResolutionKind(options) !== 99 /* NodeNext */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");
|
|
} else if (!hasJsonModuleEmitEnabled(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext, "resolveJsonModule", "module");
|
|
}
|
|
}
|
|
if (options.outDir || options.rootDir || options.sourceRoot || options.mapRoot) {
|
|
const dir = getCommonSourceDirectory2();
|
|
if (options.outDir && dir === "" && files.some((file) => getRootLength(file.fileName) > 1)) {
|
|
createDiagnosticForOptionName(Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files, "outDir");
|
|
}
|
|
}
|
|
if (options.useDefineForClassFields && languageVersion === 0 /* ES3 */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields");
|
|
}
|
|
if (options.checkJs && !getAllowJSCompilerOption(options)) {
|
|
programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs"));
|
|
}
|
|
if (options.emitDeclarationOnly) {
|
|
if (!getEmitDeclarations(options)) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "emitDeclarationOnly", "declaration", "composite");
|
|
}
|
|
if (options.noEmit) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationOnly", "noEmit");
|
|
}
|
|
}
|
|
if (options.emitDecoratorMetadata && !options.experimentalDecorators) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators");
|
|
}
|
|
if (options.jsxFactory) {
|
|
if (options.reactNamespace) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory");
|
|
}
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFactory", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
if (!parseIsolatedEntityName(options.jsxFactory, languageVersion)) {
|
|
createOptionValueDiagnostic("jsxFactory", Diagnostics.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFactory);
|
|
}
|
|
} else if (options.reactNamespace && !isIdentifierText(options.reactNamespace, languageVersion)) {
|
|
createOptionValueDiagnostic("reactNamespace", Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace);
|
|
}
|
|
if (options.jsxFragmentFactory) {
|
|
if (!options.jsxFactory) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "jsxFragmentFactory", "jsxFactory");
|
|
}
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFragmentFactory", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
if (!parseIsolatedEntityName(options.jsxFragmentFactory, languageVersion)) {
|
|
createOptionValueDiagnostic("jsxFragmentFactory", Diagnostics.Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFragmentFactory);
|
|
}
|
|
}
|
|
if (options.reactNamespace) {
|
|
if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "reactNamespace", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
}
|
|
if (options.jsxImportSource) {
|
|
if (options.jsx === 2 /* React */) {
|
|
createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxImportSource", inverseJsxOptionMap.get("" + options.jsx));
|
|
}
|
|
}
|
|
if (options.preserveValueImports && getEmitModuleKind(options) < 5 /* ES2015 */) {
|
|
createOptionValueDiagnostic("importsNotUsedAsValues", Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later);
|
|
}
|
|
if (!options.noEmit && !options.suppressOutputPathCheck) {
|
|
const emitHost = getEmitHost();
|
|
const emitFilesSeen = /* @__PURE__ */ new Set();
|
|
forEachEmittedFile(emitHost, (emitFileNames) => {
|
|
if (!options.emitDeclarationOnly) {
|
|
verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
|
|
}
|
|
verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen);
|
|
});
|
|
}
|
|
function verifyEmitFilePath(emitFileName, emitFilesSeen) {
|
|
if (emitFileName) {
|
|
const emitFilePath = toPath3(emitFileName);
|
|
if (filesByName.has(emitFilePath)) {
|
|
let chain;
|
|
if (!options.configFilePath) {
|
|
chain = chainDiagnosticMessages(void 0, Diagnostics.Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig);
|
|
}
|
|
chain = chainDiagnosticMessages(chain, Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file, emitFileName);
|
|
blockEmittingOfFile(emitFileName, createCompilerDiagnosticFromMessageChain(chain));
|
|
}
|
|
const emitFileKey = !host.useCaseSensitiveFileNames() ? toFileNameLowerCase(emitFilePath) : emitFilePath;
|
|
if (emitFilesSeen.has(emitFileKey)) {
|
|
blockEmittingOfFile(emitFileName, createCompilerDiagnostic(Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, emitFileName));
|
|
} else {
|
|
emitFilesSeen.add(emitFileKey);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) {
|
|
var _a3;
|
|
let fileIncludeReasons;
|
|
let relatedInfo;
|
|
let locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : void 0;
|
|
if (file)
|
|
(_a3 = fileReasons.get(file.path)) == null ? void 0 : _a3.forEach(processReason);
|
|
if (fileProcessingReason)
|
|
processReason(fileProcessingReason);
|
|
if (locationReason && (fileIncludeReasons == null ? void 0 : fileIncludeReasons.length) === 1)
|
|
fileIncludeReasons = void 0;
|
|
const location2 = locationReason && getReferencedFileLocation(getSourceFileByPath, locationReason);
|
|
const fileIncludeReasonDetails = fileIncludeReasons && chainDiagnosticMessages(fileIncludeReasons, Diagnostics.The_file_is_in_the_program_because_Colon);
|
|
const redirectInfo = file && explainIfFileIsRedirectAndImpliedFormat(file);
|
|
const chain = chainDiagnosticMessages(redirectInfo ? fileIncludeReasonDetails ? [fileIncludeReasonDetails, ...redirectInfo] : redirectInfo : fileIncludeReasonDetails, diagnostic, ...args || emptyArray);
|
|
return location2 && isReferenceFileLocation(location2) ? createFileDiagnosticFromMessageChain(location2.file, location2.pos, location2.end - location2.pos, chain, relatedInfo) : createCompilerDiagnosticFromMessageChain(chain, relatedInfo);
|
|
function processReason(reason) {
|
|
(fileIncludeReasons || (fileIncludeReasons = [])).push(fileIncludeReasonToDiagnostics(program, reason));
|
|
if (!locationReason && isReferencedFile(reason)) {
|
|
locationReason = reason;
|
|
} else if (locationReason !== reason) {
|
|
relatedInfo = append(relatedInfo, fileIncludeReasonToRelatedInformation(reason));
|
|
}
|
|
if (reason === fileProcessingReason)
|
|
fileProcessingReason = void 0;
|
|
}
|
|
}
|
|
function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) {
|
|
(fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
|
|
kind: 1 /* FilePreprocessingFileExplainingDiagnostic */,
|
|
file: file && file.path,
|
|
fileProcessingReason,
|
|
diagnostic,
|
|
args
|
|
});
|
|
}
|
|
function addProgramDiagnosticExplainingFile(file, diagnostic, args) {
|
|
programDiagnostics.add(createDiagnosticExplainingFile(file, void 0, diagnostic, args));
|
|
}
|
|
function fileIncludeReasonToRelatedInformation(reason) {
|
|
if (isReferencedFile(reason)) {
|
|
const referenceLocation = getReferencedFileLocation(getSourceFileByPath, reason);
|
|
let message2;
|
|
switch (reason.kind) {
|
|
case 3 /* Import */:
|
|
message2 = Diagnostics.File_is_included_via_import_here;
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
message2 = Diagnostics.File_is_included_via_reference_here;
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
message2 = Diagnostics.File_is_included_via_type_library_reference_here;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
message2 = Diagnostics.File_is_included_via_library_reference_here;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return isReferenceFileLocation(referenceLocation) ? createFileDiagnostic(
|
|
referenceLocation.file,
|
|
referenceLocation.pos,
|
|
referenceLocation.end - referenceLocation.pos,
|
|
message2
|
|
) : void 0;
|
|
}
|
|
if (!options.configFile)
|
|
return void 0;
|
|
let configFileNode;
|
|
let message;
|
|
switch (reason.kind) {
|
|
case 0 /* RootFile */:
|
|
if (!options.configFile.configFileSpecs)
|
|
return void 0;
|
|
const fileName = getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory);
|
|
const matchedByFiles = getMatchedFileSpec(program, fileName);
|
|
if (matchedByFiles) {
|
|
configFileNode = getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles);
|
|
message = Diagnostics.File_is_matched_by_files_list_specified_here;
|
|
break;
|
|
}
|
|
const matchedByInclude = getMatchedIncludeSpec(program, fileName);
|
|
if (!matchedByInclude || !isString(matchedByInclude))
|
|
return void 0;
|
|
configFileNode = getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude);
|
|
message = Diagnostics.File_is_matched_by_include_pattern_specified_here;
|
|
break;
|
|
case 1 /* SourceFromProjectReference */:
|
|
case 2 /* OutputFromProjectReference */:
|
|
const referencedResolvedRef = Debug.checkDefined(resolvedProjectReferences == null ? void 0 : resolvedProjectReferences[reason.index]);
|
|
const referenceInfo = forEachProjectReference(
|
|
projectReferences,
|
|
resolvedProjectReferences,
|
|
(resolvedRef, parent2, index2) => resolvedRef === referencedResolvedRef ? { sourceFile: (parent2 == null ? void 0 : parent2.sourceFile) || options.configFile, index: index2 } : void 0
|
|
);
|
|
if (!referenceInfo)
|
|
return void 0;
|
|
const { sourceFile, index } = referenceInfo;
|
|
const referencesSyntax = firstDefined(
|
|
getTsConfigPropArray(sourceFile, "references"),
|
|
(property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
|
|
);
|
|
return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
|
|
sourceFile,
|
|
referencesSyntax.elements[index],
|
|
reason.kind === 2 /* OutputFromProjectReference */ ? Diagnostics.File_is_output_from_referenced_project_specified_here : Diagnostics.File_is_source_from_referenced_project_specified_here
|
|
) : void 0;
|
|
case 8 /* AutomaticTypeDirectiveFile */:
|
|
if (!options.types)
|
|
return void 0;
|
|
configFileNode = getOptionsSyntaxByArrayElementValue("types", reason.typeReference);
|
|
message = Diagnostics.File_is_entry_point_of_type_library_specified_here;
|
|
break;
|
|
case 6 /* LibFile */:
|
|
if (reason.index !== void 0) {
|
|
configFileNode = getOptionsSyntaxByArrayElementValue("lib", options.lib[reason.index]);
|
|
message = Diagnostics.File_is_library_specified_here;
|
|
break;
|
|
}
|
|
const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
|
|
configFileNode = target ? getOptionsSyntaxByValue("target", target) : void 0;
|
|
message = Diagnostics.File_is_default_library_for_target_specified_here;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return configFileNode && createDiagnosticForNodeInSourceFile(
|
|
options.configFile,
|
|
configFileNode,
|
|
message
|
|
);
|
|
}
|
|
function verifyProjectReferences() {
|
|
const buildInfoPath = !options.suppressOutputPathCheck ? getTsBuildInfoEmitOutputFilePath(options) : void 0;
|
|
forEachProjectReference(projectReferences, resolvedProjectReferences, (resolvedRef, parent2, index) => {
|
|
const ref = (parent2 ? parent2.commandLine.projectReferences : projectReferences)[index];
|
|
const parentFile = parent2 && parent2.sourceFile;
|
|
if (!resolvedRef) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.File_0_not_found, ref.path);
|
|
return;
|
|
}
|
|
const options2 = resolvedRef.commandLine.options;
|
|
if (!options2.composite || options2.noEmit) {
|
|
const inputs = parent2 ? parent2.commandLine.fileNames : rootNames;
|
|
if (inputs.length) {
|
|
if (!options2.composite)
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path);
|
|
if (options2.noEmit)
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path);
|
|
}
|
|
}
|
|
if (ref.prepend) {
|
|
const out = outFile(options2);
|
|
if (out) {
|
|
if (!host.fileExists(out)) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path);
|
|
}
|
|
} else {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_prepend_project_0_because_it_does_not_have_outFile_set, ref.path);
|
|
}
|
|
}
|
|
if (!parent2 && buildInfoPath && buildInfoPath === getTsBuildInfoEmitOutputFilePath(options2)) {
|
|
createDiagnosticForReference(parentFile, index, Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path);
|
|
hasEmitBlockingDiagnostics.set(toPath3(buildInfoPath), true);
|
|
}
|
|
});
|
|
}
|
|
function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) {
|
|
let needCompilerDiagnostic = true;
|
|
const pathsSyntax = getOptionPathsSyntax();
|
|
for (const pathProp of pathsSyntax) {
|
|
if (isObjectLiteralExpression(pathProp.initializer)) {
|
|
for (const keyProps of getPropertyAssignment(pathProp.initializer, key)) {
|
|
const initializer = keyProps.initializer;
|
|
if (isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, arg0, arg1, arg2));
|
|
needCompilerDiagnostic = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2));
|
|
}
|
|
}
|
|
function createDiagnosticForOptionPaths(onKey, key, message, arg0) {
|
|
let needCompilerDiagnostic = true;
|
|
const pathsSyntax = getOptionPathsSyntax();
|
|
for (const pathProp of pathsSyntax) {
|
|
if (isObjectLiteralExpression(pathProp.initializer) && createOptionDiagnosticInObjectLiteralSyntax(
|
|
pathProp.initializer,
|
|
onKey,
|
|
key,
|
|
void 0,
|
|
message,
|
|
arg0
|
|
)) {
|
|
needCompilerDiagnostic = false;
|
|
}
|
|
}
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0));
|
|
}
|
|
}
|
|
function getOptionsSyntaxByName(name) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
return compilerOptionsObjectLiteralSyntax && getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name);
|
|
}
|
|
function getOptionPathsSyntax() {
|
|
return getOptionsSyntaxByName("paths") || emptyArray;
|
|
}
|
|
function getOptionsSyntaxByValue(name, value) {
|
|
const syntaxByName = getOptionsSyntaxByName(name);
|
|
return syntaxByName && firstDefined(syntaxByName, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
|
|
}
|
|
function getOptionsSyntaxByArrayElementValue(name, value) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
return compilerOptionsObjectLiteralSyntax && getPropertyArrayElementValue(compilerOptionsObjectLiteralSyntax, name, value);
|
|
}
|
|
function createDiagnosticForOptionName(message, option1, option2, option3) {
|
|
createDiagnosticForOption(true, option1, option2, message, option1, option2, option3);
|
|
}
|
|
function createOptionValueDiagnostic(option1, message, arg0, arg1) {
|
|
createDiagnosticForOption(false, option1, void 0, message, arg0, arg1);
|
|
}
|
|
function createDiagnosticForReference(sourceFile, index, message, arg0, arg1) {
|
|
const referencesSyntax = firstDefined(
|
|
getTsConfigPropArray(sourceFile || options.configFile, "references"),
|
|
(property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
|
|
);
|
|
if (referencesSyntax && referencesSyntax.elements.length > index) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, arg0, arg1));
|
|
} else {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1));
|
|
}
|
|
}
|
|
function createDiagnosticForOption(onKey, option1, option2, message, arg0, arg1, arg2) {
|
|
const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
|
|
const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2);
|
|
if (needCompilerDiagnostic) {
|
|
programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2));
|
|
}
|
|
}
|
|
function getCompilerOptionsObjectLiteralSyntax() {
|
|
if (_compilerOptionsObjectLiteralSyntax === void 0) {
|
|
_compilerOptionsObjectLiteralSyntax = false;
|
|
const jsonObjectLiteral = getTsConfigObjectLiteralExpression(options.configFile);
|
|
if (jsonObjectLiteral) {
|
|
for (const prop of getPropertyAssignment(jsonObjectLiteral, "compilerOptions")) {
|
|
if (isObjectLiteralExpression(prop.initializer)) {
|
|
_compilerOptionsObjectLiteralSyntax = prop.initializer;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return _compilerOptionsObjectLiteralSyntax || void 0;
|
|
}
|
|
function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2) {
|
|
const props = getPropertyAssignment(objectLiteral, key1, key2);
|
|
for (const prop of props) {
|
|
programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2));
|
|
}
|
|
return !!props.length;
|
|
}
|
|
function blockEmittingOfFile(emitFileName, diag2) {
|
|
hasEmitBlockingDiagnostics.set(toPath3(emitFileName), true);
|
|
programDiagnostics.add(diag2);
|
|
}
|
|
function isEmittedFile(file) {
|
|
if (options.noEmit) {
|
|
return false;
|
|
}
|
|
const filePath = toPath3(file);
|
|
if (getSourceFileByPath(filePath)) {
|
|
return false;
|
|
}
|
|
const out = outFile(options);
|
|
if (out) {
|
|
return isSameFile(filePath, out) || isSameFile(filePath, removeFileExtension(out) + ".d.ts" /* Dts */);
|
|
}
|
|
if (options.declarationDir && containsPath(options.declarationDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames())) {
|
|
return true;
|
|
}
|
|
if (options.outDir) {
|
|
return containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames());
|
|
}
|
|
if (fileExtensionIsOneOf(filePath, supportedJSExtensionsFlat) || isDeclarationFileName(filePath)) {
|
|
const filePathWithoutExtension = removeFileExtension(filePath);
|
|
return !!getSourceFileByPath(filePathWithoutExtension + ".ts" /* Ts */) || !!getSourceFileByPath(filePathWithoutExtension + ".tsx" /* Tsx */);
|
|
}
|
|
return false;
|
|
}
|
|
function isSameFile(file1, file2) {
|
|
return comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === 0 /* EqualTo */;
|
|
}
|
|
function getSymlinkCache() {
|
|
if (host.getSymlinkCache) {
|
|
return host.getSymlinkCache();
|
|
}
|
|
if (!symlinks) {
|
|
symlinks = createSymlinkCache(currentDirectory, getCanonicalFileName);
|
|
}
|
|
if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) {
|
|
symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives);
|
|
}
|
|
return symlinks;
|
|
}
|
|
}
|
|
function updateHostForUseSourceOfProjectReferenceRedirect(host) {
|
|
let setOfDeclarationDirectories;
|
|
const originalFileExists = host.compilerHost.fileExists;
|
|
const originalDirectoryExists = host.compilerHost.directoryExists;
|
|
const originalGetDirectories = host.compilerHost.getDirectories;
|
|
const originalRealpath = host.compilerHost.realpath;
|
|
if (!host.useSourceOfProjectReferenceRedirect)
|
|
return { onProgramCreateComplete: noop, fileExists };
|
|
host.compilerHost.fileExists = fileExists;
|
|
let directoryExists;
|
|
if (originalDirectoryExists) {
|
|
directoryExists = host.compilerHost.directoryExists = (path) => {
|
|
if (originalDirectoryExists.call(host.compilerHost, path)) {
|
|
handleDirectoryCouldBeSymlink(path);
|
|
return true;
|
|
}
|
|
if (!host.getResolvedProjectReferences())
|
|
return false;
|
|
if (!setOfDeclarationDirectories) {
|
|
setOfDeclarationDirectories = /* @__PURE__ */ new Set();
|
|
host.forEachResolvedProjectReference((ref) => {
|
|
const out = outFile(ref.commandLine.options);
|
|
if (out) {
|
|
setOfDeclarationDirectories.add(getDirectoryPath(host.toPath(out)));
|
|
} else {
|
|
const declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir;
|
|
if (declarationDir) {
|
|
setOfDeclarationDirectories.add(host.toPath(declarationDir));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return fileOrDirectoryExistsUsingSource(path, false);
|
|
};
|
|
}
|
|
if (originalGetDirectories) {
|
|
host.compilerHost.getDirectories = (path) => !host.getResolvedProjectReferences() || originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path) ? originalGetDirectories.call(host.compilerHost, path) : [];
|
|
}
|
|
if (originalRealpath) {
|
|
host.compilerHost.realpath = (s) => {
|
|
var _a2;
|
|
return ((_a2 = host.getSymlinkCache().getSymlinkedFiles()) == null ? void 0 : _a2.get(host.toPath(s))) || originalRealpath.call(host.compilerHost, s);
|
|
};
|
|
}
|
|
return { onProgramCreateComplete, fileExists, directoryExists };
|
|
function onProgramCreateComplete() {
|
|
host.compilerHost.fileExists = originalFileExists;
|
|
host.compilerHost.directoryExists = originalDirectoryExists;
|
|
host.compilerHost.getDirectories = originalGetDirectories;
|
|
}
|
|
function fileExists(file) {
|
|
if (originalFileExists.call(host.compilerHost, file))
|
|
return true;
|
|
if (!host.getResolvedProjectReferences())
|
|
return false;
|
|
if (!isDeclarationFileName(file))
|
|
return false;
|
|
return fileOrDirectoryExistsUsingSource(file, true);
|
|
}
|
|
function fileExistsIfProjectReferenceDts(file) {
|
|
const source = host.getSourceOfProjectReferenceRedirect(host.toPath(file));
|
|
return source !== void 0 ? isString(source) ? originalFileExists.call(host.compilerHost, source) : true : void 0;
|
|
}
|
|
function directoryExistsIfProjectReferenceDeclDir(dir) {
|
|
const dirPath = host.toPath(dir);
|
|
const dirPathWithTrailingDirectorySeparator = `${dirPath}${directorySeparator}`;
|
|
return forEachKey(
|
|
setOfDeclarationDirectories,
|
|
(declDirPath) => dirPath === declDirPath || startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) || startsWith(dirPath, `${declDirPath}/`)
|
|
);
|
|
}
|
|
function handleDirectoryCouldBeSymlink(directory) {
|
|
var _a2;
|
|
if (!host.getResolvedProjectReferences() || containsIgnoredPath(directory))
|
|
return;
|
|
if (!originalRealpath || !stringContains(directory, nodeModulesPathPart))
|
|
return;
|
|
const symlinkCache = host.getSymlinkCache();
|
|
const directoryPath = ensureTrailingDirectorySeparator(host.toPath(directory));
|
|
if ((_a2 = symlinkCache.getSymlinkedDirectories()) == null ? void 0 : _a2.has(directoryPath))
|
|
return;
|
|
const real = normalizePath(originalRealpath.call(host.compilerHost, directory));
|
|
let realPath2;
|
|
if (real === directory || (realPath2 = ensureTrailingDirectorySeparator(host.toPath(real))) === directoryPath) {
|
|
symlinkCache.setSymlinkedDirectory(directoryPath, false);
|
|
return;
|
|
}
|
|
symlinkCache.setSymlinkedDirectory(directory, {
|
|
real: ensureTrailingDirectorySeparator(real),
|
|
realPath: realPath2
|
|
});
|
|
}
|
|
function fileOrDirectoryExistsUsingSource(fileOrDirectory, isFile) {
|
|
var _a2;
|
|
const fileOrDirectoryExistsUsingSource2 = isFile ? (file) => fileExistsIfProjectReferenceDts(file) : (dir) => directoryExistsIfProjectReferenceDeclDir(dir);
|
|
const result = fileOrDirectoryExistsUsingSource2(fileOrDirectory);
|
|
if (result !== void 0)
|
|
return result;
|
|
const symlinkCache = host.getSymlinkCache();
|
|
const symlinkedDirectories = symlinkCache.getSymlinkedDirectories();
|
|
if (!symlinkedDirectories)
|
|
return false;
|
|
const fileOrDirectoryPath = host.toPath(fileOrDirectory);
|
|
if (!stringContains(fileOrDirectoryPath, nodeModulesPathPart))
|
|
return false;
|
|
if (isFile && ((_a2 = symlinkCache.getSymlinkedFiles()) == null ? void 0 : _a2.has(fileOrDirectoryPath)))
|
|
return true;
|
|
return firstDefinedIterator(
|
|
symlinkedDirectories.entries(),
|
|
([directoryPath, symlinkedDirectory]) => {
|
|
if (!symlinkedDirectory || !startsWith(fileOrDirectoryPath, directoryPath))
|
|
return void 0;
|
|
const result2 = fileOrDirectoryExistsUsingSource2(fileOrDirectoryPath.replace(directoryPath, symlinkedDirectory.realPath));
|
|
if (isFile && result2) {
|
|
const absolutePath = getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory());
|
|
symlinkCache.setSymlinkedFile(
|
|
fileOrDirectoryPath,
|
|
`${symlinkedDirectory.real}${absolutePath.replace(new RegExp(directoryPath, "i"), "")}`
|
|
);
|
|
}
|
|
return result2;
|
|
}
|
|
) || false;
|
|
}
|
|
}
|
|
var emitSkippedWithNoDiagnostics = { diagnostics: emptyArray, sourceMaps: void 0, emittedFiles: void 0, emitSkipped: true };
|
|
function handleNoEmitOptions(program, sourceFile, writeFile2, cancellationToken) {
|
|
const options = program.getCompilerOptions();
|
|
if (options.noEmit) {
|
|
program.getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
return sourceFile || outFile(options) ? emitSkippedWithNoDiagnostics : program.emitBuildInfo(writeFile2, cancellationToken);
|
|
}
|
|
if (!options.noEmitOnError)
|
|
return void 0;
|
|
let diagnostics = [
|
|
...program.getOptionsDiagnostics(cancellationToken),
|
|
...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
|
|
...program.getGlobalDiagnostics(cancellationToken),
|
|
...program.getSemanticDiagnostics(sourceFile, cancellationToken)
|
|
];
|
|
if (diagnostics.length === 0 && getEmitDeclarations(program.getCompilerOptions())) {
|
|
diagnostics = program.getDeclarationDiagnostics(void 0, cancellationToken);
|
|
}
|
|
if (!diagnostics.length)
|
|
return void 0;
|
|
let emittedFiles;
|
|
if (!sourceFile && !outFile(options)) {
|
|
const emitResult = program.emitBuildInfo(writeFile2, cancellationToken);
|
|
if (emitResult.diagnostics)
|
|
diagnostics = [...diagnostics, ...emitResult.diagnostics];
|
|
emittedFiles = emitResult.emittedFiles;
|
|
}
|
|
return { diagnostics, sourceMaps: void 0, emittedFiles, emitSkipped: true };
|
|
}
|
|
function filterSemanticDiagnostics(diagnostic, option) {
|
|
return filter(diagnostic, (d) => !d.skippedOn || !option[d.skippedOn]);
|
|
}
|
|
function parseConfigHostFromCompilerHostLike(host, directoryStructureHost = host) {
|
|
return {
|
|
fileExists: (f) => directoryStructureHost.fileExists(f),
|
|
readDirectory(root, extensions, excludes, includes, depth) {
|
|
Debug.assertIsDefined(directoryStructureHost.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'");
|
|
return directoryStructureHost.readDirectory(root, extensions, excludes, includes, depth);
|
|
},
|
|
readFile: (f) => directoryStructureHost.readFile(f),
|
|
useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
onUnRecoverableConfigFileDiagnostic: host.onUnRecoverableConfigFileDiagnostic || returnUndefined,
|
|
trace: host.trace ? (s) => host.trace(s) : void 0
|
|
};
|
|
}
|
|
function createPrependNodes(projectReferences, getCommandLine, readFile, host) {
|
|
if (!projectReferences)
|
|
return emptyArray;
|
|
let nodes;
|
|
for (let i = 0; i < projectReferences.length; i++) {
|
|
const ref = projectReferences[i];
|
|
const resolvedRefOpts = getCommandLine(ref, i);
|
|
if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) {
|
|
const out = outFile(resolvedRefOpts.options);
|
|
if (!out)
|
|
continue;
|
|
const { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath } = getOutputPathsForBundle(resolvedRefOpts.options, true);
|
|
const node = createInputFilesWithFilePaths(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath, host, resolvedRefOpts.options);
|
|
(nodes || (nodes = [])).push(node);
|
|
}
|
|
}
|
|
return nodes || emptyArray;
|
|
}
|
|
function resolveProjectReferencePath(hostOrRef, ref) {
|
|
const passedInRef = ref ? ref : hostOrRef;
|
|
return resolveConfigFileProjectName(passedInRef.path);
|
|
}
|
|
function getResolutionDiagnostic(options, { extension }) {
|
|
switch (extension) {
|
|
case ".ts" /* Ts */:
|
|
case ".d.ts" /* Dts */:
|
|
return void 0;
|
|
case ".tsx" /* Tsx */:
|
|
return needJsx();
|
|
case ".jsx" /* Jsx */:
|
|
return needJsx() || needAllowJs();
|
|
case ".js" /* Js */:
|
|
return needAllowJs();
|
|
case ".json" /* Json */:
|
|
return needResolveJsonModule();
|
|
}
|
|
function needJsx() {
|
|
return options.jsx ? void 0 : Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
|
|
}
|
|
function needAllowJs() {
|
|
return getAllowJSCompilerOption(options) || !getStrictOptionValue(options, "noImplicitAny") ? void 0 : Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type;
|
|
}
|
|
function needResolveJsonModule() {
|
|
return options.resolveJsonModule ? void 0 : Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used;
|
|
}
|
|
}
|
|
function getModuleNames({ imports, moduleAugmentations }) {
|
|
const res = imports.map((i) => i);
|
|
for (const aug of moduleAugmentations) {
|
|
if (aug.kind === 10 /* StringLiteral */) {
|
|
res.push(aug);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function getModuleNameStringLiteralAt({ imports, moduleAugmentations }, index) {
|
|
if (index < imports.length)
|
|
return imports[index];
|
|
let augIndex = imports.length;
|
|
for (const aug of moduleAugmentations) {
|
|
if (aug.kind === 10 /* StringLiteral */) {
|
|
if (index === augIndex)
|
|
return aug;
|
|
augIndex++;
|
|
}
|
|
}
|
|
Debug.fail("should never ask for module name at index higher than possible module name");
|
|
}
|
|
|
|
// src/compiler/builderState.ts
|
|
function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit) {
|
|
const outputFiles = [];
|
|
const { emitSkipped, diagnostics } = program.emit(sourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit);
|
|
return { outputFiles, emitSkipped, diagnostics };
|
|
function writeFile2(fileName, text, writeByteOrderMark) {
|
|
outputFiles.push({ name: fileName, writeByteOrderMark, text });
|
|
}
|
|
}
|
|
var BuilderState;
|
|
((BuilderState2) => {
|
|
function createManyToManyPathMap() {
|
|
function create2(forward, reverse, deleted) {
|
|
const map2 = {
|
|
getKeys: (v) => reverse.get(v),
|
|
getValues: (k) => forward.get(k),
|
|
keys: () => forward.keys(),
|
|
deleteKey: (k) => {
|
|
(deleted || (deleted = /* @__PURE__ */ new Set())).add(k);
|
|
const set = forward.get(k);
|
|
if (!set) {
|
|
return false;
|
|
}
|
|
set.forEach((v) => deleteFromMultimap(reverse, v, k));
|
|
forward.delete(k);
|
|
return true;
|
|
},
|
|
set: (k, vSet) => {
|
|
deleted == null ? void 0 : deleted.delete(k);
|
|
const existingVSet = forward.get(k);
|
|
forward.set(k, vSet);
|
|
existingVSet == null ? void 0 : existingVSet.forEach((v) => {
|
|
if (!vSet.has(v)) {
|
|
deleteFromMultimap(reverse, v, k);
|
|
}
|
|
});
|
|
vSet.forEach((v) => {
|
|
if (!(existingVSet == null ? void 0 : existingVSet.has(v))) {
|
|
addToMultimap(reverse, v, k);
|
|
}
|
|
});
|
|
return map2;
|
|
}
|
|
};
|
|
return map2;
|
|
}
|
|
return create2(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), void 0);
|
|
}
|
|
BuilderState2.createManyToManyPathMap = createManyToManyPathMap;
|
|
function addToMultimap(map2, k, v) {
|
|
let set = map2.get(k);
|
|
if (!set) {
|
|
set = /* @__PURE__ */ new Set();
|
|
map2.set(k, set);
|
|
}
|
|
set.add(v);
|
|
}
|
|
function deleteFromMultimap(map2, k, v) {
|
|
const set = map2.get(k);
|
|
if (set == null ? void 0 : set.delete(v)) {
|
|
if (!set.size) {
|
|
map2.delete(k);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getReferencedFilesFromImportedModuleSymbol(symbol) {
|
|
return mapDefined(symbol.declarations, (declaration) => {
|
|
var _a2;
|
|
return (_a2 = getSourceFileOfNode(declaration)) == null ? void 0 : _a2.resolvedPath;
|
|
});
|
|
}
|
|
function getReferencedFilesFromImportLiteral(checker, importName) {
|
|
const symbol = checker.getSymbolAtLocation(importName);
|
|
return symbol && getReferencedFilesFromImportedModuleSymbol(symbol);
|
|
}
|
|
function getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName) {
|
|
return toPath(program.getProjectReferenceRedirect(fileName) || fileName, sourceFileDirectory, getCanonicalFileName);
|
|
}
|
|
function getReferencedFiles(program, sourceFile, getCanonicalFileName) {
|
|
let referencedFiles;
|
|
if (sourceFile.imports && sourceFile.imports.length > 0) {
|
|
const checker = program.getTypeChecker();
|
|
for (const importName of sourceFile.imports) {
|
|
const declarationSourceFilePaths = getReferencedFilesFromImportLiteral(checker, importName);
|
|
declarationSourceFilePaths == null ? void 0 : declarationSourceFilePaths.forEach(addReferencedFile);
|
|
}
|
|
}
|
|
const sourceFileDirectory = getDirectoryPath(sourceFile.resolvedPath);
|
|
if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) {
|
|
for (const referencedFile of sourceFile.referencedFiles) {
|
|
const referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName);
|
|
addReferencedFile(referencedPath);
|
|
}
|
|
}
|
|
if (sourceFile.resolvedTypeReferenceDirectiveNames) {
|
|
sourceFile.resolvedTypeReferenceDirectiveNames.forEach((resolvedTypeReferenceDirective) => {
|
|
if (!resolvedTypeReferenceDirective) {
|
|
return;
|
|
}
|
|
const fileName = resolvedTypeReferenceDirective.resolvedFileName;
|
|
const typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName);
|
|
addReferencedFile(typeFilePath);
|
|
});
|
|
}
|
|
if (sourceFile.moduleAugmentations.length) {
|
|
const checker = program.getTypeChecker();
|
|
for (const moduleName of sourceFile.moduleAugmentations) {
|
|
if (!isStringLiteral(moduleName))
|
|
continue;
|
|
const symbol = checker.getSymbolAtLocation(moduleName);
|
|
if (!symbol)
|
|
continue;
|
|
addReferenceFromAmbientModule(symbol);
|
|
}
|
|
}
|
|
for (const ambientModule of program.getTypeChecker().getAmbientModules()) {
|
|
if (ambientModule.declarations && ambientModule.declarations.length > 1) {
|
|
addReferenceFromAmbientModule(ambientModule);
|
|
}
|
|
}
|
|
return referencedFiles;
|
|
function addReferenceFromAmbientModule(symbol) {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
for (const declaration of symbol.declarations) {
|
|
const declarationSourceFile = getSourceFileOfNode(declaration);
|
|
if (declarationSourceFile && declarationSourceFile !== sourceFile) {
|
|
addReferencedFile(declarationSourceFile.resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
function addReferencedFile(referencedPath) {
|
|
(referencedFiles || (referencedFiles = /* @__PURE__ */ new Set())).add(referencedPath);
|
|
}
|
|
}
|
|
function canReuseOldState(newReferencedMap, oldState) {
|
|
return oldState && !oldState.referencedMap === !newReferencedMap;
|
|
}
|
|
BuilderState2.canReuseOldState = canReuseOldState;
|
|
function create(newProgram, oldState, disableUseFileVersionAsSignature) {
|
|
var _a2, _b, _c;
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
const options = newProgram.getCompilerOptions();
|
|
const isOutFile = outFile(options);
|
|
const referencedMap = options.module !== 0 /* None */ && !isOutFile ? createManyToManyPathMap() : void 0;
|
|
const exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
|
|
const useOldState = canReuseOldState(referencedMap, oldState);
|
|
const getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames());
|
|
newProgram.getTypeChecker();
|
|
for (const sourceFile of newProgram.getSourceFiles()) {
|
|
const version2 = Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set");
|
|
const oldUncommittedSignature = useOldState ? (_a2 = oldState.oldSignatures) == null ? void 0 : _a2.get(sourceFile.resolvedPath) : void 0;
|
|
const signature = oldUncommittedSignature === void 0 ? useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) == null ? void 0 : _b.signature : void 0 : oldUncommittedSignature || void 0;
|
|
if (referencedMap) {
|
|
const newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName);
|
|
if (newReferences) {
|
|
referencedMap.set(sourceFile.resolvedPath, newReferences);
|
|
}
|
|
if (useOldState) {
|
|
const oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) == null ? void 0 : _c.get(sourceFile.resolvedPath);
|
|
const exportedModules = oldUncommittedExportedModules === void 0 ? oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) : oldUncommittedExportedModules || void 0;
|
|
if (exportedModules) {
|
|
exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
|
|
}
|
|
}
|
|
}
|
|
fileInfos.set(sourceFile.resolvedPath, {
|
|
version: version2,
|
|
signature,
|
|
affectsGlobalScope: !isOutFile ? isFileAffectingGlobalScope(sourceFile) || void 0 : void 0,
|
|
impliedFormat: sourceFile.impliedNodeFormat
|
|
});
|
|
}
|
|
return {
|
|
fileInfos,
|
|
referencedMap,
|
|
exportedModulesMap,
|
|
useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
|
|
};
|
|
}
|
|
BuilderState2.create = create;
|
|
function releaseCache2(state) {
|
|
state.allFilesExcludingDefaultLibraryFile = void 0;
|
|
state.allFileNames = void 0;
|
|
}
|
|
BuilderState2.releaseCache = releaseCache2;
|
|
function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
|
|
var _a2, _b;
|
|
const result = getFilesAffectedByWithOldState(
|
|
state,
|
|
programOfThisState,
|
|
path,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
(_a2 = state.oldSignatures) == null ? void 0 : _a2.clear();
|
|
(_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
|
|
return result;
|
|
}
|
|
BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
|
|
function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, host) {
|
|
const sourceFile = programOfThisState.getSourceFileByPath(path);
|
|
if (!sourceFile) {
|
|
return emptyArray;
|
|
}
|
|
if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host)) {
|
|
return [sourceFile];
|
|
}
|
|
return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, host);
|
|
}
|
|
BuilderState2.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
|
|
function updateSignatureOfFile(state, signature, path) {
|
|
state.fileInfos.get(path).signature = signature;
|
|
(state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(path);
|
|
}
|
|
BuilderState2.updateSignatureOfFile = updateSignatureOfFile;
|
|
function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, host, useFileVersionAsSignature = state.useFileVersionAsSignature) {
|
|
var _a2;
|
|
if ((_a2 = state.hasCalledUpdateShapeSignature) == null ? void 0 : _a2.has(sourceFile.resolvedPath))
|
|
return false;
|
|
const info = state.fileInfos.get(sourceFile.resolvedPath);
|
|
const prevSignature = info.signature;
|
|
let latestSignature;
|
|
if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
|
|
programOfThisState.emit(
|
|
sourceFile,
|
|
(fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) => {
|
|
Debug.assert(isDeclarationFileName(fileName), `File extension for signature expected to be dts: Got:: ${fileName}`);
|
|
latestSignature = computeSignatureWithDiagnostics(
|
|
programOfThisState,
|
|
sourceFile,
|
|
text,
|
|
host,
|
|
data
|
|
);
|
|
if (latestSignature !== prevSignature) {
|
|
updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
|
|
}
|
|
},
|
|
cancellationToken,
|
|
true,
|
|
void 0,
|
|
true
|
|
);
|
|
}
|
|
if (latestSignature === void 0) {
|
|
latestSignature = sourceFile.version;
|
|
if (state.exportedModulesMap && latestSignature !== prevSignature) {
|
|
(state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
|
|
const references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : void 0;
|
|
if (references) {
|
|
state.exportedModulesMap.set(sourceFile.resolvedPath, references);
|
|
} else {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
(state.oldSignatures || (state.oldSignatures = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, prevSignature || false);
|
|
(state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(sourceFile.resolvedPath);
|
|
info.signature = latestSignature;
|
|
return latestSignature !== prevSignature;
|
|
}
|
|
BuilderState2.updateShapeSignature = updateShapeSignature;
|
|
function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
|
|
if (!state.exportedModulesMap)
|
|
return;
|
|
(state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
|
|
if (!exportedModulesFromDeclarationEmit) {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
return;
|
|
}
|
|
let exportedModules;
|
|
exportedModulesFromDeclarationEmit.forEach((symbol) => addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)));
|
|
if (exportedModules) {
|
|
state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
|
|
} else {
|
|
state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
|
|
}
|
|
function addExportedModule(exportedModulePaths) {
|
|
if (exportedModulePaths == null ? void 0 : exportedModulePaths.length) {
|
|
if (!exportedModules) {
|
|
exportedModules = /* @__PURE__ */ new Set();
|
|
}
|
|
exportedModulePaths.forEach((path) => exportedModules.add(path));
|
|
}
|
|
}
|
|
}
|
|
BuilderState2.updateExportedModules = updateExportedModules;
|
|
function getAllDependencies(state, programOfThisState, sourceFile) {
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
return getAllFileNames(state, programOfThisState);
|
|
}
|
|
if (!state.referencedMap || isFileAffectingGlobalScope(sourceFile)) {
|
|
return getAllFileNames(state, programOfThisState);
|
|
}
|
|
const seenMap = /* @__PURE__ */ new Set();
|
|
const queue = [sourceFile.resolvedPath];
|
|
while (queue.length) {
|
|
const path = queue.pop();
|
|
if (!seenMap.has(path)) {
|
|
seenMap.add(path);
|
|
const references = state.referencedMap.getValues(path);
|
|
if (references) {
|
|
const iterator = references.keys();
|
|
for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
|
|
queue.push(iterResult.value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(mapDefinedIterator(seenMap.keys(), (path) => {
|
|
var _a2, _b;
|
|
return (_b = (_a2 = programOfThisState.getSourceFileByPath(path)) == null ? void 0 : _a2.fileName) != null ? _b : path;
|
|
}));
|
|
}
|
|
BuilderState2.getAllDependencies = getAllDependencies;
|
|
function getAllFileNames(state, programOfThisState) {
|
|
if (!state.allFileNames) {
|
|
const sourceFiles = programOfThisState.getSourceFiles();
|
|
state.allFileNames = sourceFiles === emptyArray ? emptyArray : sourceFiles.map((file) => file.fileName);
|
|
}
|
|
return state.allFileNames;
|
|
}
|
|
function getReferencedByPaths(state, referencedFilePath) {
|
|
const keys = state.referencedMap.getKeys(referencedFilePath);
|
|
return keys ? arrayFrom(keys.keys()) : [];
|
|
}
|
|
BuilderState2.getReferencedByPaths = getReferencedByPaths;
|
|
function containsOnlyAmbientModules(sourceFile) {
|
|
for (const statement of sourceFile.statements) {
|
|
if (!isModuleWithStringLiteralName(statement)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function containsGlobalScopeAugmentation(sourceFile) {
|
|
return some(sourceFile.moduleAugmentations, (augmentation) => isGlobalScopeAugmentation(augmentation.parent));
|
|
}
|
|
function isFileAffectingGlobalScope(sourceFile) {
|
|
return containsGlobalScopeAugmentation(sourceFile) || !isExternalOrCommonJsModule(sourceFile) && !isJsonSourceFile(sourceFile) && !containsOnlyAmbientModules(sourceFile);
|
|
}
|
|
function getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, firstSourceFile) {
|
|
if (state.allFilesExcludingDefaultLibraryFile) {
|
|
return state.allFilesExcludingDefaultLibraryFile;
|
|
}
|
|
let result;
|
|
if (firstSourceFile)
|
|
addSourceFile(firstSourceFile);
|
|
for (const sourceFile of programOfThisState.getSourceFiles()) {
|
|
if (sourceFile !== firstSourceFile) {
|
|
addSourceFile(sourceFile);
|
|
}
|
|
}
|
|
state.allFilesExcludingDefaultLibraryFile = result || emptyArray;
|
|
return state.allFilesExcludingDefaultLibraryFile;
|
|
function addSourceFile(sourceFile) {
|
|
if (!programOfThisState.isSourceFileDefaultLibrary(sourceFile)) {
|
|
(result || (result = [])).push(sourceFile);
|
|
}
|
|
}
|
|
}
|
|
BuilderState2.getAllFilesExcludingDefaultLibraryFile = getAllFilesExcludingDefaultLibraryFile;
|
|
function getFilesAffectedByUpdatedShapeWhenNonModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape) {
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (compilerOptions && outFile(compilerOptions)) {
|
|
return [sourceFileWithUpdatedShape];
|
|
}
|
|
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
|
|
}
|
|
function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, host) {
|
|
if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
|
|
return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
|
|
}
|
|
const compilerOptions = programOfThisState.getCompilerOptions();
|
|
if (compilerOptions && (compilerOptions.isolatedModules || outFile(compilerOptions))) {
|
|
return [sourceFileWithUpdatedShape];
|
|
}
|
|
const seenFileNamesMap = /* @__PURE__ */ new Map();
|
|
seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape);
|
|
const queue = getReferencedByPaths(state, sourceFileWithUpdatedShape.resolvedPath);
|
|
while (queue.length > 0) {
|
|
const currentPath = queue.pop();
|
|
if (!seenFileNamesMap.has(currentPath)) {
|
|
const currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
|
|
seenFileNamesMap.set(currentPath, currentSourceFile);
|
|
if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, host)) {
|
|
queue.push(...getReferencedByPaths(state, currentSourceFile.resolvedPath));
|
|
}
|
|
}
|
|
}
|
|
return arrayFrom(mapDefinedIterator(seenFileNamesMap.values(), (value) => value));
|
|
}
|
|
})(BuilderState || (BuilderState = {}));
|
|
|
|
// src/compiler/builder.ts
|
|
var BuilderFileEmit = /* @__PURE__ */ ((BuilderFileEmit2) => {
|
|
BuilderFileEmit2[BuilderFileEmit2["None"] = 0] = "None";
|
|
BuilderFileEmit2[BuilderFileEmit2["Js"] = 1] = "Js";
|
|
BuilderFileEmit2[BuilderFileEmit2["JsMap"] = 2] = "JsMap";
|
|
BuilderFileEmit2[BuilderFileEmit2["JsInlineMap"] = 4] = "JsInlineMap";
|
|
BuilderFileEmit2[BuilderFileEmit2["Dts"] = 8] = "Dts";
|
|
BuilderFileEmit2[BuilderFileEmit2["DtsMap"] = 16] = "DtsMap";
|
|
BuilderFileEmit2[BuilderFileEmit2["AllJs"] = 7] = "AllJs";
|
|
BuilderFileEmit2[BuilderFileEmit2["AllDts"] = 24] = "AllDts";
|
|
BuilderFileEmit2[BuilderFileEmit2["All"] = 31] = "All";
|
|
return BuilderFileEmit2;
|
|
})(BuilderFileEmit || {});
|
|
function getBuilderFileEmit(options) {
|
|
let result = 1 /* Js */;
|
|
if (options.sourceMap)
|
|
result = result | 2 /* JsMap */;
|
|
if (options.inlineSourceMap)
|
|
result = result | 4 /* JsInlineMap */;
|
|
if (getEmitDeclarations(options))
|
|
result = result | 8 /* Dts */;
|
|
if (options.declarationMap)
|
|
result = result | 16 /* DtsMap */;
|
|
if (options.emitDeclarationOnly)
|
|
result = result & 24 /* AllDts */;
|
|
return result;
|
|
}
|
|
function getPendingEmitKind(optionsOrEmitKind, oldOptionsOrEmitKind) {
|
|
const oldEmitKind = oldOptionsOrEmitKind && (isNumber(oldOptionsOrEmitKind) ? oldOptionsOrEmitKind : getBuilderFileEmit(oldOptionsOrEmitKind));
|
|
const emitKind = isNumber(optionsOrEmitKind) ? optionsOrEmitKind : getBuilderFileEmit(optionsOrEmitKind);
|
|
if (oldEmitKind === emitKind)
|
|
return 0 /* None */;
|
|
if (!oldEmitKind || !emitKind)
|
|
return emitKind;
|
|
const diff = oldEmitKind ^ emitKind;
|
|
let result = 0 /* None */;
|
|
if (diff & 7 /* AllJs */)
|
|
result = emitKind & 7 /* AllJs */;
|
|
if (diff & 24 /* AllDts */)
|
|
result = result | emitKind & 24 /* AllDts */;
|
|
return result;
|
|
}
|
|
function hasSameKeys(map1, map2) {
|
|
return map1 === map2 || map1 !== void 0 && map2 !== void 0 && map1.size === map2.size && !forEachKey(map1, (key) => !map2.has(key));
|
|
}
|
|
function createBuilderProgramState(newProgram, oldState, disableUseFileVersionAsSignature) {
|
|
var _a2, _b;
|
|
const state = BuilderState.create(newProgram, oldState, disableUseFileVersionAsSignature);
|
|
state.program = newProgram;
|
|
const compilerOptions = newProgram.getCompilerOptions();
|
|
state.compilerOptions = compilerOptions;
|
|
const outFilePath = outFile(compilerOptions);
|
|
if (!outFilePath) {
|
|
state.semanticDiagnosticsPerFile = /* @__PURE__ */ new Map();
|
|
} else if (compilerOptions.composite && (oldState == null ? void 0 : oldState.outSignature) && outFilePath === outFile(oldState == null ? void 0 : oldState.compilerOptions)) {
|
|
state.outSignature = oldState.outSignature && getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, oldState.outSignature);
|
|
}
|
|
state.changedFilesSet = /* @__PURE__ */ new Set();
|
|
state.latestChangedDtsFile = compilerOptions.composite ? oldState == null ? void 0 : oldState.latestChangedDtsFile : void 0;
|
|
const useOldState = BuilderState.canReuseOldState(state.referencedMap, oldState);
|
|
const oldCompilerOptions = useOldState ? oldState.compilerOptions : void 0;
|
|
const canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile && !compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions);
|
|
const canCopyEmitSignatures = compilerOptions.composite && (oldState == null ? void 0 : oldState.emitSignatures) && !outFilePath && !compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions);
|
|
if (useOldState) {
|
|
(_a2 = oldState.changedFilesSet) == null ? void 0 : _a2.forEach((value) => state.changedFilesSet.add(value));
|
|
if (!outFilePath && ((_b = oldState.affectedFilesPendingEmit) == null ? void 0 : _b.size)) {
|
|
state.affectedFilesPendingEmit = new Map(oldState.affectedFilesPendingEmit);
|
|
state.seenAffectedFiles = /* @__PURE__ */ new Set();
|
|
}
|
|
state.programEmitPending = oldState.programEmitPending;
|
|
} else {
|
|
state.buildInfoEmitPending = true;
|
|
}
|
|
const referencedMap = state.referencedMap;
|
|
const oldReferencedMap = useOldState ? oldState.referencedMap : void 0;
|
|
const copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck;
|
|
const copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck;
|
|
state.fileInfos.forEach((info, sourceFilePath) => {
|
|
var _a3;
|
|
let oldInfo;
|
|
let newReferences;
|
|
if (!useOldState || !(oldInfo = oldState.fileInfos.get(sourceFilePath)) || oldInfo.version !== info.version || oldInfo.impliedFormat !== info.impliedFormat || !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || newReferences && forEachKey(newReferences, (path) => !state.fileInfos.has(path) && oldState.fileInfos.has(path))) {
|
|
addFileToChangeSet(state, sourceFilePath);
|
|
} else if (canCopySemanticDiagnostics) {
|
|
const sourceFile = newProgram.getSourceFileByPath(sourceFilePath);
|
|
if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics)
|
|
return;
|
|
if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics)
|
|
return;
|
|
const diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath);
|
|
if (diagnostics) {
|
|
state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : diagnostics);
|
|
if (!state.semanticDiagnosticsFromOldState) {
|
|
state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set();
|
|
}
|
|
state.semanticDiagnosticsFromOldState.add(sourceFilePath);
|
|
}
|
|
}
|
|
if (canCopyEmitSignatures) {
|
|
const oldEmitSignature = oldState.emitSignatures.get(sourceFilePath);
|
|
if (oldEmitSignature) {
|
|
((_a3 = state.emitSignatures) != null ? _a3 : state.emitSignatures = /* @__PURE__ */ new Map()).set(sourceFilePath, getEmitSignatureFromOldSignature(compilerOptions, oldState.compilerOptions, oldEmitSignature));
|
|
}
|
|
}
|
|
});
|
|
if (useOldState && forEachEntry(oldState.fileInfos, (info, sourceFilePath) => {
|
|
if (state.fileInfos.has(sourceFilePath))
|
|
return false;
|
|
if (outFilePath || info.affectsGlobalScope)
|
|
return true;
|
|
state.buildInfoEmitPending = true;
|
|
return false;
|
|
})) {
|
|
BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, void 0).forEach((file) => addFileToChangeSet(state, file.resolvedPath));
|
|
} else if (oldCompilerOptions) {
|
|
const pendingEmitKind = compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions) ? getBuilderFileEmit(compilerOptions) : getPendingEmitKind(compilerOptions, oldCompilerOptions);
|
|
if (pendingEmitKind !== 0 /* None */) {
|
|
if (!outFilePath) {
|
|
newProgram.getSourceFiles().forEach((f) => {
|
|
if (!state.changedFilesSet.has(f.resolvedPath)) {
|
|
addToAffectedFilesPendingEmit(
|
|
state,
|
|
f.resolvedPath,
|
|
pendingEmitKind
|
|
);
|
|
}
|
|
});
|
|
Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
|
|
state.seenAffectedFiles = state.seenAffectedFiles || /* @__PURE__ */ new Set();
|
|
state.buildInfoEmitPending = true;
|
|
} else {
|
|
state.programEmitPending = state.programEmitPending ? state.programEmitPending | pendingEmitKind : pendingEmitKind;
|
|
}
|
|
}
|
|
}
|
|
if (outFilePath && !state.changedFilesSet.size) {
|
|
if (useOldState)
|
|
state.bundle = oldState.bundle;
|
|
if (some(newProgram.getProjectReferences(), (ref) => !!ref.prepend))
|
|
state.programEmitPending = getBuilderFileEmit(compilerOptions);
|
|
}
|
|
return state;
|
|
}
|
|
function addFileToChangeSet(state, path) {
|
|
state.changedFilesSet.add(path);
|
|
state.buildInfoEmitPending = true;
|
|
state.programEmitPending = void 0;
|
|
}
|
|
function getEmitSignatureFromOldSignature(options, oldOptions, oldEmitSignature) {
|
|
return !!options.declarationMap === !!oldOptions.declarationMap ? oldEmitSignature : isString(oldEmitSignature) ? [oldEmitSignature] : oldEmitSignature[0];
|
|
}
|
|
function convertToDiagnostics(diagnostics, newProgram) {
|
|
if (!diagnostics.length)
|
|
return emptyArray;
|
|
let buildInfoDirectory;
|
|
let getCanonicalFileName;
|
|
return diagnostics.map((diagnostic) => {
|
|
const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3);
|
|
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
|
|
result.reportsDeprecated = diagnostic.reportDeprecated;
|
|
result.source = diagnostic.source;
|
|
result.skippedOn = diagnostic.skippedOn;
|
|
const { relatedInformation } = diagnostic;
|
|
result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPath3)) : [] : void 0;
|
|
return result;
|
|
});
|
|
function toPath3(path) {
|
|
buildInfoDirectory != null ? buildInfoDirectory : buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
|
|
return toPath(path, buildInfoDirectory, getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(newProgram.useCaseSensitiveFileNames()));
|
|
}
|
|
}
|
|
function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3) {
|
|
const { file } = diagnostic;
|
|
return {
|
|
...diagnostic,
|
|
file: file ? newProgram.getSourceFileByPath(toPath3(file)) : void 0
|
|
};
|
|
}
|
|
function releaseCache(state) {
|
|
BuilderState.releaseCache(state);
|
|
state.program = void 0;
|
|
}
|
|
function backupBuilderProgramEmitState(state) {
|
|
const outFilePath = outFile(state.compilerOptions);
|
|
Debug.assert(!state.changedFilesSet.size || outFilePath);
|
|
return {
|
|
affectedFilesPendingEmit: state.affectedFilesPendingEmit && new Map(state.affectedFilesPendingEmit),
|
|
seenEmittedFiles: state.seenEmittedFiles && new Map(state.seenEmittedFiles),
|
|
programEmitPending: state.programEmitPending,
|
|
emitSignatures: state.emitSignatures && new Map(state.emitSignatures),
|
|
outSignature: state.outSignature,
|
|
latestChangedDtsFile: state.latestChangedDtsFile,
|
|
hasChangedEmitSignature: state.hasChangedEmitSignature,
|
|
changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : void 0
|
|
};
|
|
}
|
|
function restoreBuilderProgramEmitState(state, savedEmitState) {
|
|
state.affectedFilesPendingEmit = savedEmitState.affectedFilesPendingEmit;
|
|
state.seenEmittedFiles = savedEmitState.seenEmittedFiles;
|
|
state.programEmitPending = savedEmitState.programEmitPending;
|
|
state.emitSignatures = savedEmitState.emitSignatures;
|
|
state.outSignature = savedEmitState.outSignature;
|
|
state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile;
|
|
state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
|
|
if (savedEmitState.changedFilesSet)
|
|
state.changedFilesSet = savedEmitState.changedFilesSet;
|
|
}
|
|
function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
|
|
Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
|
|
}
|
|
function getNextAffectedFile(state, cancellationToken, host) {
|
|
var _a2, _b;
|
|
while (true) {
|
|
const { affectedFiles } = state;
|
|
if (affectedFiles) {
|
|
const seenAffectedFiles = state.seenAffectedFiles;
|
|
let affectedFilesIndex = state.affectedFilesIndex;
|
|
while (affectedFilesIndex < affectedFiles.length) {
|
|
const affectedFile = affectedFiles[affectedFilesIndex];
|
|
if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
|
|
state.affectedFilesIndex = affectedFilesIndex;
|
|
addToAffectedFilesPendingEmit(state, affectedFile.resolvedPath, getBuilderFileEmit(state.compilerOptions));
|
|
handleDtsMayChangeOfAffectedFile(
|
|
state,
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
return affectedFile;
|
|
}
|
|
affectedFilesIndex++;
|
|
}
|
|
state.changedFilesSet.delete(state.currentChangedFilePath);
|
|
state.currentChangedFilePath = void 0;
|
|
(_a2 = state.oldSignatures) == null ? void 0 : _a2.clear();
|
|
(_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
|
|
state.affectedFiles = void 0;
|
|
}
|
|
const nextKey = state.changedFilesSet.keys().next();
|
|
if (nextKey.done) {
|
|
return void 0;
|
|
}
|
|
const program = Debug.checkDefined(state.program);
|
|
const compilerOptions = program.getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
Debug.assert(!state.semanticDiagnosticsPerFile);
|
|
return program;
|
|
}
|
|
state.affectedFiles = BuilderState.getFilesAffectedByWithOldState(
|
|
state,
|
|
program,
|
|
nextKey.value,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
state.currentChangedFilePath = nextKey.value;
|
|
state.affectedFilesIndex = 0;
|
|
if (!state.seenAffectedFiles)
|
|
state.seenAffectedFiles = /* @__PURE__ */ new Set();
|
|
}
|
|
}
|
|
function clearAffectedFilesPendingEmit(state, emitOnlyDtsFiles) {
|
|
var _a2;
|
|
if (!((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.size))
|
|
return;
|
|
if (!emitOnlyDtsFiles)
|
|
return state.affectedFilesPendingEmit = void 0;
|
|
state.affectedFilesPendingEmit.forEach((emitKind, path) => {
|
|
const pending = emitKind & 7 /* AllJs */;
|
|
if (!pending)
|
|
state.affectedFilesPendingEmit.delete(path);
|
|
else
|
|
state.affectedFilesPendingEmit.set(path, pending);
|
|
});
|
|
}
|
|
function getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles) {
|
|
var _a2;
|
|
if (!((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.size))
|
|
return void 0;
|
|
return forEachEntry(state.affectedFilesPendingEmit, (emitKind, path) => {
|
|
var _a3;
|
|
const affectedFile = state.program.getSourceFileByPath(path);
|
|
if (!affectedFile || !sourceFileMayBeEmitted(affectedFile, state.program)) {
|
|
state.affectedFilesPendingEmit.delete(path);
|
|
return void 0;
|
|
}
|
|
const seenKind = (_a3 = state.seenEmittedFiles) == null ? void 0 : _a3.get(affectedFile.resolvedPath);
|
|
let pendingKind = getPendingEmitKind(emitKind, seenKind);
|
|
if (emitOnlyDtsFiles)
|
|
pendingKind = pendingKind & 24 /* AllDts */;
|
|
if (pendingKind)
|
|
return { affectedFile, emitKind: pendingKind };
|
|
});
|
|
}
|
|
function removeDiagnosticsOfLibraryFiles(state) {
|
|
if (!state.cleanedDiagnosticsOfLibFiles) {
|
|
state.cleanedDiagnosticsOfLibFiles = true;
|
|
const program = Debug.checkDefined(state.program);
|
|
const options = program.getCompilerOptions();
|
|
forEach(
|
|
program.getSourceFiles(),
|
|
(f) => program.isSourceFileDefaultLibrary(f) && !skipTypeChecking(f, options, program) && removeSemanticDiagnosticsOf(state, f.resolvedPath)
|
|
);
|
|
}
|
|
}
|
|
function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, host) {
|
|
removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
|
|
if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
|
|
removeDiagnosticsOfLibraryFiles(state);
|
|
BuilderState.updateShapeSignature(
|
|
state,
|
|
Debug.checkDefined(state.program),
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
return;
|
|
}
|
|
if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
|
|
return;
|
|
handleDtsMayChangeOfReferencingExportOfAffectedFile(
|
|
state,
|
|
affectedFile,
|
|
cancellationToken,
|
|
host
|
|
);
|
|
}
|
|
function handleDtsMayChangeOf(state, path, cancellationToken, host) {
|
|
removeSemanticDiagnosticsOf(state, path);
|
|
if (!state.changedFilesSet.has(path)) {
|
|
const program = Debug.checkDefined(state.program);
|
|
const sourceFile = program.getSourceFileByPath(path);
|
|
if (sourceFile) {
|
|
BuilderState.updateShapeSignature(
|
|
state,
|
|
program,
|
|
sourceFile,
|
|
cancellationToken,
|
|
host,
|
|
!host.disableUseFileVersionAsSignature
|
|
);
|
|
if (getEmitDeclarations(state.compilerOptions)) {
|
|
addToAffectedFilesPendingEmit(state, path, state.compilerOptions.declarationMap ? 24 /* AllDts */ : 8 /* Dts */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function removeSemanticDiagnosticsOf(state, path) {
|
|
if (!state.semanticDiagnosticsFromOldState) {
|
|
return true;
|
|
}
|
|
state.semanticDiagnosticsFromOldState.delete(path);
|
|
state.semanticDiagnosticsPerFile.delete(path);
|
|
return !state.semanticDiagnosticsFromOldState.size;
|
|
}
|
|
function isChangedSignature(state, path) {
|
|
const oldSignature = Debug.checkDefined(state.oldSignatures).get(path) || void 0;
|
|
const newSignature = Debug.checkDefined(state.fileInfos.get(path)).signature;
|
|
return newSignature !== oldSignature;
|
|
}
|
|
function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host) {
|
|
var _a2;
|
|
if (!((_a2 = state.fileInfos.get(filePath)) == null ? void 0 : _a2.affectsGlobalScope))
|
|
return false;
|
|
BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, void 0).forEach((file) => handleDtsMayChangeOf(
|
|
state,
|
|
file.resolvedPath,
|
|
cancellationToken,
|
|
host
|
|
));
|
|
removeDiagnosticsOfLibraryFiles(state);
|
|
return true;
|
|
}
|
|
function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
|
|
var _a2;
|
|
if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
|
|
return;
|
|
if (!isChangedSignature(state, affectedFile.resolvedPath))
|
|
return;
|
|
if (state.compilerOptions.isolatedModules) {
|
|
const seenFileNamesMap = /* @__PURE__ */ new Map();
|
|
seenFileNamesMap.set(affectedFile.resolvedPath, true);
|
|
const queue = BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);
|
|
while (queue.length > 0) {
|
|
const currentPath = queue.pop();
|
|
if (!seenFileNamesMap.has(currentPath)) {
|
|
seenFileNamesMap.set(currentPath, true);
|
|
if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, host))
|
|
return;
|
|
handleDtsMayChangeOf(state, currentPath, cancellationToken, host);
|
|
if (isChangedSignature(state, currentPath)) {
|
|
const currentSourceFile = Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
|
|
queue.push(...BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const seenFileAndExportsOfFile = /* @__PURE__ */ new Set();
|
|
(_a2 = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a2.forEach((exportedFromPath) => {
|
|
if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
|
|
return true;
|
|
const references = state.referencedMap.getKeys(exportedFromPath);
|
|
return references && forEachKey(
|
|
references,
|
|
(filePath) => handleDtsMayChangeOfFileAndExportsOfFile(
|
|
state,
|
|
filePath,
|
|
seenFileAndExportsOfFile,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
});
|
|
}
|
|
function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
|
|
var _a2, _b;
|
|
if (!tryAddToSet(seenFileAndExportsOfFile, filePath))
|
|
return void 0;
|
|
if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
|
|
return true;
|
|
handleDtsMayChangeOf(state, filePath, cancellationToken, host);
|
|
(_a2 = state.exportedModulesMap.getKeys(filePath)) == null ? void 0 : _a2.forEach(
|
|
(exportedFromPath) => handleDtsMayChangeOfFileAndExportsOfFile(
|
|
state,
|
|
exportedFromPath,
|
|
seenFileAndExportsOfFile,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
(_b = state.referencedMap.getKeys(filePath)) == null ? void 0 : _b.forEach(
|
|
(referencingFilePath) => !seenFileAndExportsOfFile.has(referencingFilePath) && handleDtsMayChangeOf(
|
|
state,
|
|
referencingFilePath,
|
|
cancellationToken,
|
|
host
|
|
)
|
|
);
|
|
return void 0;
|
|
}
|
|
function getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken) {
|
|
return concatenate(
|
|
getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken),
|
|
Debug.checkDefined(state.program).getProgramDiagnostics(sourceFile)
|
|
);
|
|
}
|
|
function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken) {
|
|
const path = sourceFile.resolvedPath;
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
const cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path);
|
|
if (cachedDiagnostics) {
|
|
return filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions);
|
|
}
|
|
}
|
|
const diagnostics = Debug.checkDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken);
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
state.semanticDiagnosticsPerFile.set(path, diagnostics);
|
|
}
|
|
return filterSemanticDiagnostics(diagnostics, state.compilerOptions);
|
|
}
|
|
function isProgramBundleEmitBuildInfo(info) {
|
|
return !!outFile(info.options || {});
|
|
}
|
|
function getBuildInfo2(state, bundle) {
|
|
var _a2, _b, _c;
|
|
const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
|
|
const getCanonicalFileName = createGetCanonicalFileName(state.program.useCaseSensitiveFileNames());
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
|
|
const latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : void 0;
|
|
const fileNames = [];
|
|
const fileNameToFileId = /* @__PURE__ */ new Map();
|
|
if (outFile(state.compilerOptions)) {
|
|
const fileInfos2 = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
|
|
toFileId(key);
|
|
return value.impliedFormat ? { version: value.version, impliedFormat: value.impliedFormat, signature: void 0, affectsGlobalScope: void 0 } : value.version;
|
|
});
|
|
const program2 = {
|
|
fileNames,
|
|
fileInfos: fileInfos2,
|
|
options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
|
|
outSignature: state.outSignature,
|
|
latestChangedDtsFile,
|
|
pendingEmit: !state.programEmitPending ? void 0 : state.programEmitPending === getBuilderFileEmit(state.compilerOptions) ? false : state.programEmitPending
|
|
};
|
|
const { js, dts, commonSourceDirectory, sourceFiles } = bundle;
|
|
state.bundle = bundle = {
|
|
commonSourceDirectory,
|
|
sourceFiles,
|
|
js: js || (!state.compilerOptions.emitDeclarationOnly ? (_a2 = state.bundle) == null ? void 0 : _a2.js : void 0),
|
|
dts: dts || (getEmitDeclarations(state.compilerOptions) ? (_b = state.bundle) == null ? void 0 : _b.dts : void 0)
|
|
};
|
|
return createBuildInfo(program2, bundle);
|
|
}
|
|
let fileIdsList;
|
|
let fileNamesToFileIdListId;
|
|
let emitSignatures;
|
|
const fileInfos = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
|
|
var _a3, _b2;
|
|
const fileId = toFileId(key);
|
|
Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key));
|
|
const oldSignature = (_a3 = state.oldSignatures) == null ? void 0 : _a3.get(key);
|
|
const actualSignature = oldSignature !== void 0 ? oldSignature || void 0 : value.signature;
|
|
if (state.compilerOptions.composite) {
|
|
const file = state.program.getSourceFileByPath(key);
|
|
if (!isJsonSourceFile(file) && sourceFileMayBeEmitted(file, state.program)) {
|
|
const emitSignature = (_b2 = state.emitSignatures) == null ? void 0 : _b2.get(key);
|
|
if (emitSignature !== actualSignature) {
|
|
(emitSignatures || (emitSignatures = [])).push(emitSignature === void 0 ? fileId : [fileId, !isString(emitSignature) && emitSignature[0] === actualSignature ? emptyArray : emitSignature]);
|
|
}
|
|
}
|
|
}
|
|
return value.version === actualSignature ? value.affectsGlobalScope || value.impliedFormat ? { version: value.version, signature: void 0, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : value.version : actualSignature !== void 0 ? oldSignature === void 0 ? value : { version: value.version, signature: actualSignature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat };
|
|
});
|
|
let referencedMap;
|
|
if (state.referencedMap) {
|
|
referencedMap = arrayFrom(state.referencedMap.keys()).sort(compareStringsCaseSensitive).map((key) => [
|
|
toFileId(key),
|
|
toFileIdListId(state.referencedMap.getValues(key))
|
|
]);
|
|
}
|
|
let exportedModulesMap;
|
|
if (state.exportedModulesMap) {
|
|
exportedModulesMap = mapDefined(arrayFrom(state.exportedModulesMap.keys()).sort(compareStringsCaseSensitive), (key) => {
|
|
var _a3;
|
|
const oldValue = (_a3 = state.oldExportedModulesMap) == null ? void 0 : _a3.get(key);
|
|
if (oldValue === void 0)
|
|
return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
|
|
if (oldValue)
|
|
return [toFileId(key), toFileIdListId(oldValue)];
|
|
return void 0;
|
|
});
|
|
}
|
|
let semanticDiagnosticsPerFile;
|
|
if (state.semanticDiagnosticsPerFile) {
|
|
for (const key of arrayFrom(state.semanticDiagnosticsPerFile.keys()).sort(compareStringsCaseSensitive)) {
|
|
const value = state.semanticDiagnosticsPerFile.get(key);
|
|
(semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(
|
|
value.length ? [
|
|
toFileId(key),
|
|
convertToReusableDiagnostics(value, relativeToBuildInfo)
|
|
] : toFileId(key)
|
|
);
|
|
}
|
|
}
|
|
let affectedFilesPendingEmit;
|
|
if ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.size) {
|
|
const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
|
|
const seenFiles = /* @__PURE__ */ new Set();
|
|
for (const path of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
|
|
if (tryAddToSet(seenFiles, path)) {
|
|
const file = state.program.getSourceFileByPath(path);
|
|
if (!sourceFileMayBeEmitted(file, state.program))
|
|
continue;
|
|
const fileId = toFileId(path), pendingEmit = state.affectedFilesPendingEmit.get(path);
|
|
(affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push(
|
|
pendingEmit === fullEmitForOptions ? fileId : pendingEmit === 8 /* Dts */ ? [fileId] : [fileId, pendingEmit]
|
|
);
|
|
}
|
|
}
|
|
}
|
|
let changeFileSet;
|
|
if (state.changedFilesSet.size) {
|
|
for (const path of arrayFrom(state.changedFilesSet.keys()).sort(compareStringsCaseSensitive)) {
|
|
(changeFileSet || (changeFileSet = [])).push(toFileId(path));
|
|
}
|
|
}
|
|
const program = {
|
|
fileNames,
|
|
fileInfos,
|
|
options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
|
|
fileIdsList,
|
|
referencedMap,
|
|
exportedModulesMap,
|
|
semanticDiagnosticsPerFile,
|
|
affectedFilesPendingEmit,
|
|
changeFileSet,
|
|
emitSignatures,
|
|
latestChangedDtsFile
|
|
};
|
|
return createBuildInfo(program, bundle);
|
|
function relativeToBuildInfoEnsuringAbsolutePath(path) {
|
|
return relativeToBuildInfo(getNormalizedAbsolutePath(path, currentDirectory));
|
|
}
|
|
function relativeToBuildInfo(path) {
|
|
return ensurePathIsNonModuleName(getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName));
|
|
}
|
|
function toFileId(path) {
|
|
let fileId = fileNameToFileId.get(path);
|
|
if (fileId === void 0) {
|
|
fileNames.push(relativeToBuildInfo(path));
|
|
fileNameToFileId.set(path, fileId = fileNames.length);
|
|
}
|
|
return fileId;
|
|
}
|
|
function toFileIdListId(set) {
|
|
const fileIds = arrayFrom(set.keys(), toFileId).sort(compareValues);
|
|
const key = fileIds.join();
|
|
let fileIdListId = fileNamesToFileIdListId == null ? void 0 : fileNamesToFileIdListId.get(key);
|
|
if (fileIdListId === void 0) {
|
|
(fileIdsList || (fileIdsList = [])).push(fileIds);
|
|
(fileNamesToFileIdListId || (fileNamesToFileIdListId = /* @__PURE__ */ new Map())).set(key, fileIdListId = fileIdsList.length);
|
|
}
|
|
return fileIdListId;
|
|
}
|
|
function convertToProgramBuildInfoCompilerOptions(options) {
|
|
let result;
|
|
const { optionsNameMap } = getOptionsNameMap();
|
|
for (const name of getOwnKeys(options).sort(compareStringsCaseSensitive)) {
|
|
const optionInfo = optionsNameMap.get(name.toLowerCase());
|
|
if (optionInfo == null ? void 0 : optionInfo.affectsBuildInfo) {
|
|
(result || (result = {}))[name] = convertToReusableCompilerOptionValue(
|
|
optionInfo,
|
|
options[name],
|
|
relativeToBuildInfoEnsuringAbsolutePath
|
|
);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) {
|
|
if (option) {
|
|
if (option.type === "list") {
|
|
const values = value;
|
|
if (option.element.isFilePath && values.length) {
|
|
return values.map(relativeToBuildInfo);
|
|
}
|
|
} else if (option.isFilePath) {
|
|
return relativeToBuildInfo(value);
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) {
|
|
Debug.assert(!!diagnostics.length);
|
|
return diagnostics.map((diagnostic) => {
|
|
const result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo);
|
|
result.reportsUnnecessary = diagnostic.reportsUnnecessary;
|
|
result.reportDeprecated = diagnostic.reportsDeprecated;
|
|
result.source = diagnostic.source;
|
|
result.skippedOn = diagnostic.skippedOn;
|
|
const { relatedInformation } = diagnostic;
|
|
result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo)) : [] : void 0;
|
|
return result;
|
|
});
|
|
}
|
|
function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) {
|
|
const { file } = diagnostic;
|
|
return {
|
|
...diagnostic,
|
|
file: file ? relativeToBuildInfo(file.resolvedPath) : void 0
|
|
};
|
|
}
|
|
var BuilderProgramKind = /* @__PURE__ */ ((BuilderProgramKind2) => {
|
|
BuilderProgramKind2[BuilderProgramKind2["SemanticDiagnosticsBuilderProgram"] = 0] = "SemanticDiagnosticsBuilderProgram";
|
|
BuilderProgramKind2[BuilderProgramKind2["EmitAndSemanticDiagnosticsBuilderProgram"] = 1] = "EmitAndSemanticDiagnosticsBuilderProgram";
|
|
return BuilderProgramKind2;
|
|
})(BuilderProgramKind || {});
|
|
function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
let host;
|
|
let newProgram;
|
|
let oldProgram;
|
|
if (newProgramOrRootNames === void 0) {
|
|
Debug.assert(hostOrOptions === void 0);
|
|
host = oldProgramOrHost;
|
|
oldProgram = configFileParsingDiagnosticsOrOldProgram;
|
|
Debug.assert(!!oldProgram);
|
|
newProgram = oldProgram.getProgram();
|
|
} else if (isArray(newProgramOrRootNames)) {
|
|
oldProgram = configFileParsingDiagnosticsOrOldProgram;
|
|
newProgram = createProgram({
|
|
rootNames: newProgramOrRootNames,
|
|
options: hostOrOptions,
|
|
host: oldProgramOrHost,
|
|
oldProgram: oldProgram && oldProgram.getProgramOrUndefined(),
|
|
configFileParsingDiagnostics,
|
|
projectReferences
|
|
});
|
|
host = oldProgramOrHost;
|
|
} else {
|
|
newProgram = newProgramOrRootNames;
|
|
host = hostOrOptions;
|
|
oldProgram = oldProgramOrHost;
|
|
configFileParsingDiagnostics = configFileParsingDiagnosticsOrOldProgram;
|
|
}
|
|
return { host, newProgram, oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || emptyArray };
|
|
}
|
|
function getTextHandlingSourceMapForSignature(text, data) {
|
|
return (data == null ? void 0 : data.sourceMapUrlPos) !== void 0 ? text.substring(0, data.sourceMapUrlPos) : text;
|
|
}
|
|
function computeSignatureWithDiagnostics(program, sourceFile, text, host, data) {
|
|
var _a2, _b;
|
|
let getCanonicalFileName;
|
|
text = getTextHandlingSourceMapForSignature(text, data);
|
|
let sourceFileDirectory;
|
|
if ((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length) {
|
|
text += data.diagnostics.map(
|
|
(diagnostic) => `${locationInfo(diagnostic)}${DiagnosticCategory[diagnostic.category]}${diagnostic.code}: ${flattenDiagnosticMessageText2(diagnostic.messageText)}`
|
|
).join("\n");
|
|
}
|
|
return ((_b = host.createHash) != null ? _b : generateDjb2Hash)(text);
|
|
function flattenDiagnosticMessageText2(diagnostic) {
|
|
return isString(diagnostic) ? diagnostic : diagnostic === void 0 ? "" : !diagnostic.next ? diagnostic.messageText : diagnostic.messageText + diagnostic.next.map(flattenDiagnosticMessageText2).join("\n");
|
|
}
|
|
function locationInfo(diagnostic) {
|
|
if (diagnostic.file.resolvedPath === sourceFile.resolvedPath)
|
|
return `(${diagnostic.start},${diagnostic.length})`;
|
|
if (sourceFileDirectory === void 0)
|
|
sourceFileDirectory = getDirectoryPath(sourceFile.resolvedPath);
|
|
return `${ensurePathIsNonModuleName(getRelativePathFromDirectory(
|
|
sourceFileDirectory,
|
|
diagnostic.file.resolvedPath,
|
|
getCanonicalFileName != null ? getCanonicalFileName : getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames())
|
|
))}(${diagnostic.start},${diagnostic.length})`;
|
|
}
|
|
}
|
|
function computeSignature(text, host, data) {
|
|
var _a2;
|
|
return ((_a2 = host.createHash) != null ? _a2 : generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
|
|
}
|
|
function createBuilderProgram(kind, { newProgram, host, oldProgram, configFileParsingDiagnostics }) {
|
|
let oldState = oldProgram && oldProgram.getState();
|
|
if (oldState && newProgram === oldState.program && configFileParsingDiagnostics === newProgram.getConfigFileParsingDiagnostics()) {
|
|
newProgram = void 0;
|
|
oldState = void 0;
|
|
return oldProgram;
|
|
}
|
|
const state = createBuilderProgramState(newProgram, oldState, host.disableUseFileVersionAsSignature);
|
|
newProgram.getBuildInfo = (bundle) => getBuildInfo2(state, bundle);
|
|
newProgram = void 0;
|
|
oldProgram = void 0;
|
|
oldState = void 0;
|
|
const getState = () => state;
|
|
const builderProgram = createRedirectedBuilderProgram(getState, configFileParsingDiagnostics);
|
|
builderProgram.getState = getState;
|
|
builderProgram.saveEmitState = () => backupBuilderProgramEmitState(state);
|
|
builderProgram.restoreEmitState = (saved) => restoreBuilderProgramEmitState(state, saved);
|
|
builderProgram.hasChangedEmitSignature = () => !!state.hasChangedEmitSignature;
|
|
builderProgram.getAllDependencies = (sourceFile) => BuilderState.getAllDependencies(state, Debug.checkDefined(state.program), sourceFile);
|
|
builderProgram.getSemanticDiagnostics = getSemanticDiagnostics;
|
|
builderProgram.emit = emit;
|
|
builderProgram.releaseProgram = () => releaseCache(state);
|
|
if (kind === 0 /* SemanticDiagnosticsBuilderProgram */) {
|
|
builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
|
|
} else if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
|
|
builderProgram.emitNextAffectedFile = emitNextAffectedFile;
|
|
builderProgram.emitBuildInfo = emitBuildInfo;
|
|
} else {
|
|
notImplemented();
|
|
}
|
|
return builderProgram;
|
|
function emitBuildInfo(writeFile2, cancellationToken) {
|
|
if (state.buildInfoEmitPending) {
|
|
const result = Debug.checkDefined(state.program).emitBuildInfo(writeFile2 || maybeBind(host, host.writeFile), cancellationToken);
|
|
state.buildInfoEmitPending = false;
|
|
return result;
|
|
}
|
|
return emitSkippedWithNoDiagnostics;
|
|
}
|
|
function emitNextAffectedFile(writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
var _a2, _b, _c, _d, _e;
|
|
let affected = getNextAffectedFile(state, cancellationToken, host);
|
|
const programEmitKind = getBuilderFileEmit(state.compilerOptions);
|
|
let emitKind = emitOnlyDtsFiles ? programEmitKind & 24 /* AllDts */ : programEmitKind;
|
|
if (!affected) {
|
|
if (!outFile(state.compilerOptions)) {
|
|
const pendingAffectedFile = getNextAffectedFilePendingEmit(state, emitOnlyDtsFiles);
|
|
if (!pendingAffectedFile) {
|
|
if (!state.buildInfoEmitPending)
|
|
return void 0;
|
|
const affected2 = state.program;
|
|
const result2 = affected2.emitBuildInfo(writeFile2 || maybeBind(host, host.writeFile), cancellationToken);
|
|
state.buildInfoEmitPending = false;
|
|
return { result: result2, affected: affected2 };
|
|
}
|
|
({ affectedFile: affected, emitKind } = pendingAffectedFile);
|
|
} else {
|
|
if (!state.programEmitPending)
|
|
return void 0;
|
|
emitKind = state.programEmitPending;
|
|
if (emitOnlyDtsFiles)
|
|
emitKind = emitKind & 24 /* AllDts */;
|
|
if (!emitKind)
|
|
return void 0;
|
|
affected = state.program;
|
|
}
|
|
}
|
|
let emitOnly;
|
|
if (emitKind & 7 /* AllJs */)
|
|
emitOnly = 0 /* Js */;
|
|
if (emitKind & 24 /* AllDts */)
|
|
emitOnly = emitOnly === void 0 ? 1 /* Dts */ : void 0;
|
|
if (affected === state.program) {
|
|
state.programEmitPending = state.changedFilesSet.size ? getPendingEmitKind(programEmitKind, emitKind) : state.programEmitPending ? getPendingEmitKind(state.programEmitPending, emitKind) : void 0;
|
|
}
|
|
const result = state.program.emit(
|
|
affected === state.program ? void 0 : affected,
|
|
getWriteFileCallback(writeFile2, customTransformers),
|
|
cancellationToken,
|
|
emitOnly,
|
|
customTransformers
|
|
);
|
|
if (affected !== state.program) {
|
|
const affectedSourceFile = affected;
|
|
state.seenAffectedFiles.add(affectedSourceFile.resolvedPath);
|
|
if (state.affectedFilesIndex !== void 0)
|
|
state.affectedFilesIndex++;
|
|
state.buildInfoEmitPending = true;
|
|
const existing = ((_a2 = state.seenEmittedFiles) == null ? void 0 : _a2.get(affectedSourceFile.resolvedPath)) || 0 /* None */;
|
|
((_b = state.seenEmittedFiles) != null ? _b : state.seenEmittedFiles = /* @__PURE__ */ new Map()).set(affectedSourceFile.resolvedPath, emitKind | existing);
|
|
const existingPending = ((_c = state.affectedFilesPendingEmit) == null ? void 0 : _c.get(affectedSourceFile.resolvedPath)) || programEmitKind;
|
|
const pendingKind = getPendingEmitKind(existingPending, emitKind | existing);
|
|
if (pendingKind)
|
|
((_d = state.affectedFilesPendingEmit) != null ? _d : state.affectedFilesPendingEmit = /* @__PURE__ */ new Map()).set(affectedSourceFile.resolvedPath, pendingKind);
|
|
else
|
|
(_e = state.affectedFilesPendingEmit) == null ? void 0 : _e.delete(affectedSourceFile.resolvedPath);
|
|
} else {
|
|
state.changedFilesSet.clear();
|
|
}
|
|
return { result, affected };
|
|
}
|
|
function getWriteFileCallback(writeFile2, customTransformers) {
|
|
if (!getEmitDeclarations(state.compilerOptions))
|
|
return writeFile2 || maybeBind(host, host.writeFile);
|
|
return (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
|
|
var _a2, _b, _c, _d, _e, _f, _g;
|
|
if (isDeclarationFileName(fileName)) {
|
|
if (!outFile(state.compilerOptions)) {
|
|
Debug.assert((sourceFiles == null ? void 0 : sourceFiles.length) === 1);
|
|
let emitSignature;
|
|
if (!customTransformers) {
|
|
const file = sourceFiles[0];
|
|
const info = state.fileInfos.get(file.resolvedPath);
|
|
if (info.signature === file.version) {
|
|
const signature = computeSignatureWithDiagnostics(
|
|
state.program,
|
|
file,
|
|
text,
|
|
host,
|
|
data
|
|
);
|
|
if (!((_a2 = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a2.length))
|
|
emitSignature = signature;
|
|
if (signature !== file.version) {
|
|
if (host.storeFilesChangingSignatureDuringEmit)
|
|
((_b = state.filesChangingSignature) != null ? _b : state.filesChangingSignature = /* @__PURE__ */ new Set()).add(file.resolvedPath);
|
|
if (state.exportedModulesMap)
|
|
BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
|
|
if (state.affectedFiles) {
|
|
const existing = (_c = state.oldSignatures) == null ? void 0 : _c.get(file.resolvedPath);
|
|
if (existing === void 0)
|
|
((_d = state.oldSignatures) != null ? _d : state.oldSignatures = /* @__PURE__ */ new Map()).set(file.resolvedPath, info.signature || false);
|
|
info.signature = signature;
|
|
} else {
|
|
info.signature = signature;
|
|
(_e = state.oldExportedModulesMap) == null ? void 0 : _e.clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (state.compilerOptions.composite) {
|
|
const filePath = sourceFiles[0].resolvedPath;
|
|
emitSignature = handleNewSignature((_f = state.emitSignatures) == null ? void 0 : _f.get(filePath), emitSignature);
|
|
if (!emitSignature)
|
|
return;
|
|
((_g = state.emitSignatures) != null ? _g : state.emitSignatures = /* @__PURE__ */ new Map()).set(filePath, emitSignature);
|
|
}
|
|
} else if (state.compilerOptions.composite) {
|
|
const newSignature = handleNewSignature(state.outSignature, void 0);
|
|
if (!newSignature)
|
|
return;
|
|
state.outSignature = newSignature;
|
|
}
|
|
}
|
|
if (writeFile2)
|
|
writeFile2(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
else if (host.writeFile)
|
|
host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
else
|
|
state.program.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
function handleNewSignature(oldSignatureFormat, newSignature) {
|
|
const oldSignature = !oldSignatureFormat || isString(oldSignatureFormat) ? oldSignatureFormat : oldSignatureFormat[0];
|
|
newSignature != null ? newSignature : newSignature = computeSignature(text, host, data);
|
|
if (newSignature === oldSignature) {
|
|
if (oldSignatureFormat === oldSignature)
|
|
return void 0;
|
|
else if (data)
|
|
data.differsOnlyInMap = true;
|
|
else
|
|
data = { differsOnlyInMap: true };
|
|
} else {
|
|
state.hasChangedEmitSignature = true;
|
|
state.latestChangedDtsFile = fileName;
|
|
}
|
|
return newSignature;
|
|
}
|
|
};
|
|
}
|
|
function emit(targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile);
|
|
}
|
|
const result = handleNoEmitOptions(builderProgram, targetSourceFile, writeFile2, cancellationToken);
|
|
if (result)
|
|
return result;
|
|
if (!targetSourceFile) {
|
|
if (kind === 1 /* EmitAndSemanticDiagnosticsBuilderProgram */) {
|
|
let sourceMaps = [];
|
|
let emitSkipped = false;
|
|
let diagnostics;
|
|
let emittedFiles = [];
|
|
let affectedEmitResult;
|
|
while (affectedEmitResult = emitNextAffectedFile(writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers)) {
|
|
emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped;
|
|
diagnostics = addRange(diagnostics, affectedEmitResult.result.diagnostics);
|
|
emittedFiles = addRange(emittedFiles, affectedEmitResult.result.emittedFiles);
|
|
sourceMaps = addRange(sourceMaps, affectedEmitResult.result.sourceMaps);
|
|
}
|
|
return {
|
|
emitSkipped,
|
|
diagnostics: diagnostics || emptyArray,
|
|
emittedFiles,
|
|
sourceMaps
|
|
};
|
|
} else {
|
|
clearAffectedFilesPendingEmit(state, emitOnlyDtsFiles);
|
|
}
|
|
}
|
|
return Debug.checkDefined(state.program).emit(
|
|
targetSourceFile,
|
|
getWriteFileCallback(writeFile2, customTransformers),
|
|
cancellationToken,
|
|
emitOnlyDtsFiles,
|
|
customTransformers
|
|
);
|
|
}
|
|
function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
|
|
while (true) {
|
|
const affected = getNextAffectedFile(state, cancellationToken, host);
|
|
let result;
|
|
if (!affected)
|
|
return void 0;
|
|
else if (affected !== state.program) {
|
|
const affectedSourceFile = affected;
|
|
if (!ignoreSourceFile || !ignoreSourceFile(affectedSourceFile)) {
|
|
result = getSemanticDiagnosticsOfFile(state, affectedSourceFile, cancellationToken);
|
|
}
|
|
state.seenAffectedFiles.add(affectedSourceFile.resolvedPath);
|
|
state.affectedFilesIndex++;
|
|
state.buildInfoEmitPending = true;
|
|
if (!result)
|
|
continue;
|
|
} else {
|
|
result = state.program.getSemanticDiagnostics(void 0, cancellationToken);
|
|
state.changedFilesSet.clear();
|
|
state.programEmitPending = getBuilderFileEmit(state.compilerOptions);
|
|
}
|
|
return { result, affected };
|
|
}
|
|
}
|
|
function getSemanticDiagnostics(sourceFile, cancellationToken) {
|
|
assertSourceFileOkWithoutNextAffectedCall(state, sourceFile);
|
|
const compilerOptions = Debug.checkDefined(state.program).getCompilerOptions();
|
|
if (outFile(compilerOptions)) {
|
|
Debug.assert(!state.semanticDiagnosticsPerFile);
|
|
return Debug.checkDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
}
|
|
if (sourceFile) {
|
|
return getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken);
|
|
}
|
|
while (getSemanticDiagnosticsOfNextAffectedFile(cancellationToken)) {
|
|
}
|
|
let diagnostics;
|
|
for (const sourceFile2 of Debug.checkDefined(state.program).getSourceFiles()) {
|
|
diagnostics = addRange(diagnostics, getSemanticDiagnosticsOfFile(state, sourceFile2, cancellationToken));
|
|
}
|
|
return diagnostics || emptyArray;
|
|
}
|
|
}
|
|
function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) {
|
|
var _a2, _b;
|
|
const existingKind = ((_a2 = state.affectedFilesPendingEmit) == null ? void 0 : _a2.get(affectedFilePendingEmit)) || 0 /* None */;
|
|
((_b = state.affectedFilesPendingEmit) != null ? _b : state.affectedFilesPendingEmit = /* @__PURE__ */ new Map()).set(affectedFilePendingEmit, existingKind | kind);
|
|
}
|
|
function toBuilderStateFileInfoForMultiEmit(fileInfo) {
|
|
return isString(fileInfo) ? { version: fileInfo, signature: fileInfo, affectsGlobalScope: void 0, impliedFormat: void 0 } : isString(fileInfo.signature) ? fileInfo : { version: fileInfo.version, signature: fileInfo.signature === false ? void 0 : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat };
|
|
}
|
|
function toBuilderFileEmit(value, fullEmitForOptions) {
|
|
return isNumber(value) ? fullEmitForOptions : value[1] || 8 /* Dts */;
|
|
}
|
|
function toProgramEmitPending(value, options) {
|
|
return !value ? getBuilderFileEmit(options || {}) : value;
|
|
}
|
|
function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, host) {
|
|
var _a2, _b, _c, _d;
|
|
const program = buildInfo.program;
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
let state;
|
|
const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPath3);
|
|
let filePathsSetList;
|
|
const latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : void 0;
|
|
if (isProgramBundleEmitBuildInfo(program)) {
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toFilePath(index + 1);
|
|
fileInfos.set(path, isString(fileInfo) ? { version: fileInfo, signature: void 0, affectsGlobalScope: void 0, impliedFormat: void 0 } : fileInfo);
|
|
});
|
|
state = {
|
|
fileInfos,
|
|
compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
|
|
latestChangedDtsFile,
|
|
outSignature: program.outSignature,
|
|
programEmitPending: program.pendingEmit === void 0 ? void 0 : toProgramEmitPending(program.pendingEmit, program.options),
|
|
bundle: buildInfo.bundle
|
|
};
|
|
} else {
|
|
filePathsSetList = (_b = program.fileIdsList) == null ? void 0 : _b.map((fileIds) => new Set(fileIds.map(toFilePath)));
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
const emitSignatures = ((_c = program.options) == null ? void 0 : _c.composite) && !outFile(program.options) ? /* @__PURE__ */ new Map() : void 0;
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toFilePath(index + 1);
|
|
const stateFileInfo = toBuilderStateFileInfoForMultiEmit(fileInfo);
|
|
fileInfos.set(path, stateFileInfo);
|
|
if (emitSignatures && stateFileInfo.signature)
|
|
emitSignatures.set(path, stateFileInfo.signature);
|
|
});
|
|
(_d = program.emitSignatures) == null ? void 0 : _d.forEach((value) => {
|
|
if (isNumber(value))
|
|
emitSignatures.delete(toFilePath(value));
|
|
else {
|
|
const key = toFilePath(value[0]);
|
|
emitSignatures.set(
|
|
key,
|
|
!isString(value[1]) && !value[1].length ? [emitSignatures.get(key)] : value[1]
|
|
);
|
|
}
|
|
});
|
|
const fullEmitForOptions = program.affectedFilesPendingEmit ? getBuilderFileEmit(program.options || {}) : void 0;
|
|
state = {
|
|
fileInfos,
|
|
compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
|
|
referencedMap: toManyToManyPathMap(program.referencedMap),
|
|
exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
|
|
semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && arrayToMap(program.semanticDiagnosticsPerFile, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]),
|
|
hasReusableDiagnostic: true,
|
|
affectedFilesPendingEmit: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => toBuilderFileEmit(value, fullEmitForOptions)),
|
|
changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
|
|
latestChangedDtsFile,
|
|
emitSignatures: (emitSignatures == null ? void 0 : emitSignatures.size) ? emitSignatures : void 0
|
|
};
|
|
}
|
|
return {
|
|
getState: () => state,
|
|
saveEmitState: noop,
|
|
restoreEmitState: noop,
|
|
getProgram: notImplemented,
|
|
getProgramOrUndefined: returnUndefined,
|
|
releaseProgram: noop,
|
|
getCompilerOptions: () => state.compilerOptions,
|
|
getSourceFile: notImplemented,
|
|
getSourceFiles: notImplemented,
|
|
getOptionsDiagnostics: notImplemented,
|
|
getGlobalDiagnostics: notImplemented,
|
|
getConfigFileParsingDiagnostics: notImplemented,
|
|
getSyntacticDiagnostics: notImplemented,
|
|
getDeclarationDiagnostics: notImplemented,
|
|
getSemanticDiagnostics: notImplemented,
|
|
emit: notImplemented,
|
|
getAllDependencies: notImplemented,
|
|
getCurrentDirectory: notImplemented,
|
|
emitNextAffectedFile: notImplemented,
|
|
getSemanticDiagnosticsOfNextAffectedFile: notImplemented,
|
|
emitBuildInfo: notImplemented,
|
|
close: noop,
|
|
hasChangedEmitSignature: returnFalse
|
|
};
|
|
function toPath3(path) {
|
|
return toPath(path, buildInfoDirectory, getCanonicalFileName);
|
|
}
|
|
function toAbsolutePath(path) {
|
|
return getNormalizedAbsolutePath(path, buildInfoDirectory);
|
|
}
|
|
function toFilePath(fileId) {
|
|
return filePaths[fileId - 1];
|
|
}
|
|
function toFilePathsSet(fileIdsListId) {
|
|
return filePathsSetList[fileIdsListId - 1];
|
|
}
|
|
function toManyToManyPathMap(referenceMap) {
|
|
if (!referenceMap) {
|
|
return void 0;
|
|
}
|
|
const map2 = BuilderState.createManyToManyPathMap();
|
|
referenceMap.forEach(
|
|
([fileId, fileIdListId]) => map2.set(toFilePath(fileId), toFilePathsSet(fileIdListId))
|
|
);
|
|
return map2;
|
|
}
|
|
}
|
|
function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
|
|
const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
const fileInfos = /* @__PURE__ */ new Map();
|
|
program.fileInfos.forEach((fileInfo, index) => {
|
|
const path = toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName);
|
|
const version2 = isString(fileInfo) ? fileInfo : fileInfo.version;
|
|
fileInfos.set(path, version2);
|
|
});
|
|
return fileInfos;
|
|
}
|
|
function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) {
|
|
return {
|
|
getState: notImplemented,
|
|
saveEmitState: noop,
|
|
restoreEmitState: noop,
|
|
getProgram,
|
|
getProgramOrUndefined: () => getState().program,
|
|
releaseProgram: () => getState().program = void 0,
|
|
getCompilerOptions: () => getState().compilerOptions,
|
|
getSourceFile: (fileName) => getProgram().getSourceFile(fileName),
|
|
getSourceFiles: () => getProgram().getSourceFiles(),
|
|
getOptionsDiagnostics: (cancellationToken) => getProgram().getOptionsDiagnostics(cancellationToken),
|
|
getGlobalDiagnostics: (cancellationToken) => getProgram().getGlobalDiagnostics(cancellationToken),
|
|
getConfigFileParsingDiagnostics: () => configFileParsingDiagnostics,
|
|
getSyntacticDiagnostics: (sourceFile, cancellationToken) => getProgram().getSyntacticDiagnostics(sourceFile, cancellationToken),
|
|
getDeclarationDiagnostics: (sourceFile, cancellationToken) => getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken),
|
|
getSemanticDiagnostics: (sourceFile, cancellationToken) => getProgram().getSemanticDiagnostics(sourceFile, cancellationToken),
|
|
emit: (sourceFile, writeFile2, cancellationToken, emitOnlyDts, customTransformers) => getProgram().emit(sourceFile, writeFile2, cancellationToken, emitOnlyDts, customTransformers),
|
|
emitBuildInfo: (writeFile2, cancellationToken) => getProgram().emitBuildInfo(writeFile2, cancellationToken),
|
|
getAllDependencies: notImplemented,
|
|
getCurrentDirectory: () => getProgram().getCurrentDirectory(),
|
|
close: noop
|
|
};
|
|
function getProgram() {
|
|
return Debug.checkDefined(getState().program);
|
|
}
|
|
}
|
|
|
|
// src/compiler/builderPublic.ts
|
|
function createSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
return createBuilderProgram(0 /* SemanticDiagnosticsBuilderProgram */, getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences));
|
|
}
|
|
function createEmitAndSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
return createBuilderProgram(1 /* EmitAndSemanticDiagnosticsBuilderProgram */, getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences));
|
|
}
|
|
function createAbstractBuilder(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) {
|
|
const { newProgram, configFileParsingDiagnostics: newConfigFileParsingDiagnostics } = getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences);
|
|
return createRedirectedBuilderProgram(() => ({ program: newProgram, compilerOptions: newProgram.getCompilerOptions() }), newConfigFileParsingDiagnostics);
|
|
}
|
|
|
|
// src/compiler/resolutionCache.ts
|
|
function removeIgnoredPath(path) {
|
|
if (endsWith(path, "/node_modules/.staging")) {
|
|
return removeSuffix(path, "/.staging");
|
|
}
|
|
return some(ignoredPaths, (searchPath) => stringContains(path, searchPath)) ? void 0 : path;
|
|
}
|
|
function canWatchDirectoryOrFile(dirPath) {
|
|
const rootLength = getRootLength(dirPath);
|
|
if (dirPath.length === rootLength) {
|
|
return false;
|
|
}
|
|
let nextDirectorySeparator = dirPath.indexOf(directorySeparator, rootLength);
|
|
if (nextDirectorySeparator === -1) {
|
|
return false;
|
|
}
|
|
let pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1);
|
|
const isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* slash */;
|
|
if (isNonDirectorySeparatorRoot && dirPath.search(/[a-zA-Z]:/) !== 0 && pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) {
|
|
nextDirectorySeparator = dirPath.indexOf(directorySeparator, nextDirectorySeparator + 1);
|
|
if (nextDirectorySeparator === -1) {
|
|
return false;
|
|
}
|
|
pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1);
|
|
}
|
|
if (isNonDirectorySeparatorRoot && pathPartForUserCheck.search(/users\//i) !== 0) {
|
|
return true;
|
|
}
|
|
for (let searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) {
|
|
searchIndex = dirPath.indexOf(directorySeparator, searchIndex) + 1;
|
|
if (searchIndex === 0) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) {
|
|
let filesWithChangedSetOfUnresolvedImports;
|
|
let filesWithInvalidatedResolutions;
|
|
let filesWithInvalidatedNonRelativeUnresolvedImports;
|
|
const nonRelativeExternalModuleResolutions = createMultiMap();
|
|
const resolutionsWithFailedLookups = [];
|
|
const resolutionsWithOnlyAffectingLocations = [];
|
|
const resolvedFileToResolution = createMultiMap();
|
|
const impliedFormatPackageJsons = /* @__PURE__ */ new Map();
|
|
let hasChangedAutomaticTypeDirectiveNames = false;
|
|
let affectingPathChecksForFile;
|
|
let affectingPathChecks;
|
|
let failedLookupChecks;
|
|
let startsWithPathChecks;
|
|
let isInDirectoryChecks;
|
|
const getCurrentDirectory = memoize(() => resolutionHost.getCurrentDirectory());
|
|
const cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost();
|
|
const resolvedModuleNames = /* @__PURE__ */ new Map();
|
|
const perDirectoryResolvedModuleNames = createCacheWithRedirects();
|
|
const nonRelativeModuleNameCache = createCacheWithRedirects();
|
|
const moduleResolutionCache = createModuleResolutionCache(
|
|
getCurrentDirectory(),
|
|
resolutionHost.getCanonicalFileName,
|
|
void 0,
|
|
perDirectoryResolvedModuleNames,
|
|
nonRelativeModuleNameCache
|
|
);
|
|
const resolvedTypeReferenceDirectives = /* @__PURE__ */ new Map();
|
|
const perDirectoryResolvedTypeReferenceDirectives = createCacheWithRedirects();
|
|
const typeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache(
|
|
getCurrentDirectory(),
|
|
resolutionHost.getCanonicalFileName,
|
|
void 0,
|
|
moduleResolutionCache.getPackageJsonInfoCache(),
|
|
perDirectoryResolvedTypeReferenceDirectives
|
|
);
|
|
const failedLookupDefaultExtensions = [".ts" /* Ts */, ".tsx" /* Tsx */, ".js" /* Js */, ".jsx" /* Jsx */, ".json" /* Json */];
|
|
const customFailedLookupPaths = /* @__PURE__ */ new Map();
|
|
const directoryWatchesOfFailedLookups = /* @__PURE__ */ new Map();
|
|
const fileWatchesOfAffectingLocations = /* @__PURE__ */ new Map();
|
|
const rootDir = rootDirForResolution && removeTrailingDirectorySeparator(getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory()));
|
|
const rootPath = rootDir && resolutionHost.toPath(rootDir);
|
|
const rootSplitLength = rootPath !== void 0 ? rootPath.split(directorySeparator).length : 0;
|
|
const typeRootsWatches = /* @__PURE__ */ new Map();
|
|
return {
|
|
getModuleResolutionCache: () => moduleResolutionCache,
|
|
startRecordingFilesWithChangedResolutions,
|
|
finishRecordingFilesWithChangedResolutions,
|
|
startCachingPerDirectoryResolution,
|
|
finishCachingPerDirectoryResolution,
|
|
resolveModuleNames,
|
|
getResolvedModuleWithFailedLookupLocationsFromCache,
|
|
resolveTypeReferenceDirectives,
|
|
removeResolutionsFromProjectReferenceRedirects,
|
|
removeResolutionsOfFile,
|
|
hasChangedAutomaticTypeDirectiveNames: () => hasChangedAutomaticTypeDirectiveNames,
|
|
invalidateResolutionOfFile,
|
|
invalidateResolutionsOfFailedLookupLocations,
|
|
setFilesWithInvalidatedNonRelativeUnresolvedImports,
|
|
createHasInvalidatedResolutions,
|
|
isFileWithInvalidatedNonRelativeUnresolvedImports,
|
|
updateTypeRootsWatch,
|
|
closeTypeRootsWatch,
|
|
clear: clear2
|
|
};
|
|
function getResolvedModule2(resolution) {
|
|
return resolution.resolvedModule;
|
|
}
|
|
function getResolvedTypeReferenceDirective2(resolution) {
|
|
return resolution.resolvedTypeReferenceDirective;
|
|
}
|
|
function isInDirectoryPath(dir, file) {
|
|
if (dir === void 0 || file.length <= dir.length) {
|
|
return false;
|
|
}
|
|
return startsWith(file, dir) && file[dir.length] === directorySeparator;
|
|
}
|
|
function clear2() {
|
|
clearMap(directoryWatchesOfFailedLookups, closeFileWatcherOf);
|
|
clearMap(fileWatchesOfAffectingLocations, closeFileWatcherOf);
|
|
customFailedLookupPaths.clear();
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
closeTypeRootsWatch();
|
|
resolvedModuleNames.clear();
|
|
resolvedTypeReferenceDirectives.clear();
|
|
resolvedFileToResolution.clear();
|
|
resolutionsWithFailedLookups.length = 0;
|
|
resolutionsWithOnlyAffectingLocations.length = 0;
|
|
failedLookupChecks = void 0;
|
|
startsWithPathChecks = void 0;
|
|
isInDirectoryChecks = void 0;
|
|
affectingPathChecks = void 0;
|
|
affectingPathChecksForFile = void 0;
|
|
moduleResolutionCache.clear();
|
|
typeReferenceDirectiveResolutionCache.clear();
|
|
impliedFormatPackageJsons.clear();
|
|
hasChangedAutomaticTypeDirectiveNames = false;
|
|
}
|
|
function startRecordingFilesWithChangedResolutions() {
|
|
filesWithChangedSetOfUnresolvedImports = [];
|
|
}
|
|
function finishRecordingFilesWithChangedResolutions() {
|
|
const collected = filesWithChangedSetOfUnresolvedImports;
|
|
filesWithChangedSetOfUnresolvedImports = void 0;
|
|
return collected;
|
|
}
|
|
function isFileWithInvalidatedNonRelativeUnresolvedImports(path) {
|
|
if (!filesWithInvalidatedNonRelativeUnresolvedImports) {
|
|
return false;
|
|
}
|
|
const value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path);
|
|
return !!value && !!value.length;
|
|
}
|
|
function createHasInvalidatedResolutions(customHasInvalidatedResolutions) {
|
|
invalidateResolutionsOfFailedLookupLocations();
|
|
const collected = filesWithInvalidatedResolutions;
|
|
filesWithInvalidatedResolutions = void 0;
|
|
return (path) => customHasInvalidatedResolutions(path) || !!(collected == null ? void 0 : collected.has(path)) || isFileWithInvalidatedNonRelativeUnresolvedImports(path);
|
|
}
|
|
function startCachingPerDirectoryResolution() {
|
|
moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
|
|
typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
|
|
nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
}
|
|
function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
|
|
filesWithInvalidatedNonRelativeUnresolvedImports = void 0;
|
|
nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
|
|
nonRelativeExternalModuleResolutions.clear();
|
|
if (newProgram !== oldProgram) {
|
|
newProgram == null ? void 0 : newProgram.getSourceFiles().forEach((newFile) => {
|
|
var _a2, _b, _c;
|
|
const expected = isExternalOrCommonJsModule(newFile) ? (_b = (_a2 = newFile.packageJsonLocations) == null ? void 0 : _a2.length) != null ? _b : 0 : 0;
|
|
const existing = (_c = impliedFormatPackageJsons.get(newFile.path)) != null ? _c : emptyArray;
|
|
for (let i = existing.length; i < expected; i++) {
|
|
createFileWatcherOfAffectingLocation(newFile.packageJsonLocations[i], false);
|
|
}
|
|
if (existing.length > expected) {
|
|
for (let i = expected; i < existing.length; i++) {
|
|
fileWatchesOfAffectingLocations.get(existing[i]).files--;
|
|
}
|
|
}
|
|
if (expected)
|
|
impliedFormatPackageJsons.set(newFile.path, newFile.packageJsonLocations);
|
|
else
|
|
impliedFormatPackageJsons.delete(newFile.path);
|
|
});
|
|
impliedFormatPackageJsons.forEach((existing, path) => {
|
|
if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
|
|
existing.forEach((location2) => fileWatchesOfAffectingLocations.get(location2).files--);
|
|
impliedFormatPackageJsons.delete(path);
|
|
}
|
|
});
|
|
}
|
|
directoryWatchesOfFailedLookups.forEach((watcher, path) => {
|
|
if (watcher.refCount === 0) {
|
|
directoryWatchesOfFailedLookups.delete(path);
|
|
watcher.watcher.close();
|
|
}
|
|
});
|
|
fileWatchesOfAffectingLocations.forEach((watcher, path) => {
|
|
if (watcher.files === 0 && watcher.resolutions === 0) {
|
|
fileWatchesOfAffectingLocations.delete(path);
|
|
watcher.watcher.close();
|
|
}
|
|
});
|
|
hasChangedAutomaticTypeDirectiveNames = false;
|
|
}
|
|
function resolveModuleName2(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) {
|
|
const primaryResult = resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode);
|
|
if (!resolutionHost.getGlobalCache) {
|
|
return primaryResult;
|
|
}
|
|
const globalCache = resolutionHost.getGlobalCache();
|
|
if (globalCache !== void 0 && !isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && extensionIsTS(primaryResult.resolvedModule.extension))) {
|
|
const { resolvedModule, failedLookupLocations, affectingLocations } = loadModuleFromGlobalCache(
|
|
Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName),
|
|
resolutionHost.projectName,
|
|
compilerOptions,
|
|
host,
|
|
globalCache,
|
|
moduleResolutionCache
|
|
);
|
|
if (resolvedModule) {
|
|
primaryResult.resolvedModule = resolvedModule;
|
|
primaryResult.failedLookupLocations.push(...failedLookupLocations);
|
|
primaryResult.affectingLocations.push(...affectingLocations);
|
|
return primaryResult;
|
|
}
|
|
}
|
|
return primaryResult;
|
|
}
|
|
function resolveTypeReferenceDirective2(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) {
|
|
return resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode);
|
|
}
|
|
function resolveNamesWithLocalCache({
|
|
names,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache,
|
|
perDirectoryCacheWithRedirects,
|
|
loader,
|
|
getResolutionWithResolvedFileName,
|
|
shouldRetryResolution,
|
|
reusedNames,
|
|
resolutionInfo,
|
|
logChanges,
|
|
containingSourceFile,
|
|
containingSourceFileMode
|
|
}) {
|
|
var _a2, _b, _c, _d;
|
|
const path = resolutionHost.toPath(containingFile);
|
|
const resolutionsInFile = cache.get(path) || cache.set(path, createModeAwareCache()).get(path);
|
|
const dirPath = getDirectoryPath(path);
|
|
const perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference);
|
|
let perDirectoryResolution = perDirectoryCache.get(dirPath);
|
|
if (!perDirectoryResolution) {
|
|
perDirectoryResolution = createModeAwareCache();
|
|
perDirectoryCache.set(dirPath, perDirectoryResolution);
|
|
}
|
|
const resolvedModules = [];
|
|
const compilerOptions = resolutionHost.getCompilationSettings();
|
|
const hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path);
|
|
const program = resolutionHost.getCurrentProgram();
|
|
const oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile);
|
|
const unmatchedRedirects = oldRedirect ? !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : !!redirectedReference;
|
|
const seenNamesInFile = createModeAwareCache();
|
|
let i = 0;
|
|
for (const entry of containingSourceFile && resolutionInfo ? resolutionInfo.names : names) {
|
|
const name = getResolutionName(entry);
|
|
const mode = !isString(entry) ? isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode) : containingSourceFile ? getModeForResolutionAtIndex(containingSourceFile, i) : void 0;
|
|
i++;
|
|
let resolution = resolutionsInFile.get(name, mode);
|
|
if (!seenNamesInFile.has(name, mode) && unmatchedRedirects || !resolution || resolution.isInvalidated || hasInvalidatedNonRelativeUnresolvedImport && !isExternalModuleNameRelative(name) && shouldRetryResolution(resolution)) {
|
|
const existingResolution = resolution;
|
|
const resolutionInDirectory = perDirectoryResolution.get(name, mode);
|
|
if (resolutionInDirectory) {
|
|
resolution = resolutionInDirectory;
|
|
const host = ((_a2 = resolutionHost.getCompilerHost) == null ? void 0 : _a2.call(resolutionHost)) || resolutionHost;
|
|
if (isTraceEnabled(compilerOptions, host)) {
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
trace(
|
|
host,
|
|
loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 : Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved,
|
|
name,
|
|
containingFile,
|
|
getDirectoryPath(containingFile),
|
|
resolved == null ? void 0 : resolved.resolvedFileName,
|
|
(resolved == null ? void 0 : resolved.packageId) && packageIdToString(resolved.packageId)
|
|
);
|
|
}
|
|
} else {
|
|
resolution = loader(name, containingFile, compilerOptions, ((_b = resolutionHost.getCompilerHost) == null ? void 0 : _b.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode);
|
|
perDirectoryResolution.set(name, mode, resolution);
|
|
if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
|
|
resolutionHost.onDiscoveredSymlink();
|
|
}
|
|
}
|
|
resolutionsInFile.set(name, mode, resolution);
|
|
watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
|
|
if (existingResolution) {
|
|
stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
|
|
}
|
|
if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) {
|
|
filesWithChangedSetOfUnresolvedImports.push(path);
|
|
logChanges = false;
|
|
}
|
|
} else {
|
|
const host = ((_c = resolutionHost.getCompilerHost) == null ? void 0 : _c.call(resolutionHost)) || resolutionHost;
|
|
if (isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) {
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
trace(
|
|
host,
|
|
loader === resolveModuleName2 ? (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : (resolved == null ? void 0 : resolved.resolvedFileName) ? resolved.packageId ? Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved,
|
|
name,
|
|
containingFile,
|
|
resolved == null ? void 0 : resolved.resolvedFileName,
|
|
(resolved == null ? void 0 : resolved.packageId) && packageIdToString(resolved.packageId)
|
|
);
|
|
}
|
|
}
|
|
Debug.assert(resolution !== void 0 && !resolution.isInvalidated);
|
|
seenNamesInFile.set(name, mode, true);
|
|
resolvedModules.push(getResolutionWithResolvedFileName(resolution));
|
|
}
|
|
if (resolutionInfo && (loader === resolveTypeReferenceDirective2 || containingSourceFile)) {
|
|
(_d = resolutionInfo.reusedNames) == null ? void 0 : _d.forEach((entry) => seenNamesInFile.set(
|
|
getResolutionName(entry),
|
|
!isString(entry) && isStringLiteralLike(entry) ? getModeForUsageLocation(containingSourceFile, entry) : getModeForFileReference(entry, containingSourceFileMode),
|
|
true
|
|
));
|
|
reusedNames = void 0;
|
|
}
|
|
if (resolutionsInFile.size() !== seenNamesInFile.size()) {
|
|
resolutionsInFile.forEach((resolution, name, mode) => {
|
|
if (!seenNamesInFile.has(name, mode) && !contains(reusedNames, name)) {
|
|
stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName);
|
|
resolutionsInFile.delete(name, mode);
|
|
}
|
|
});
|
|
}
|
|
return resolvedModules;
|
|
function resolutionIsEqualTo(oldResolution, newResolution) {
|
|
if (oldResolution === newResolution) {
|
|
return true;
|
|
}
|
|
if (!oldResolution || !newResolution) {
|
|
return false;
|
|
}
|
|
const oldResult = getResolutionWithResolvedFileName(oldResolution);
|
|
const newResult = getResolutionWithResolvedFileName(newResolution);
|
|
if (oldResult === newResult) {
|
|
return true;
|
|
}
|
|
if (!oldResult || !newResult) {
|
|
return false;
|
|
}
|
|
return oldResult.resolvedFileName === newResult.resolvedFileName;
|
|
}
|
|
}
|
|
function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo) {
|
|
return resolveNamesWithLocalCache({
|
|
names: typeDirectiveNames,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache: resolvedTypeReferenceDirectives,
|
|
perDirectoryCacheWithRedirects: perDirectoryResolvedTypeReferenceDirectives,
|
|
loader: resolveTypeReferenceDirective2,
|
|
getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective2,
|
|
shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
|
|
containingSourceFileMode: containingFileMode,
|
|
resolutionInfo
|
|
});
|
|
}
|
|
function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo) {
|
|
return resolveNamesWithLocalCache({
|
|
names: moduleNames,
|
|
containingFile,
|
|
redirectedReference,
|
|
cache: resolvedModuleNames,
|
|
perDirectoryCacheWithRedirects: perDirectoryResolvedModuleNames,
|
|
loader: resolveModuleName2,
|
|
getResolutionWithResolvedFileName: getResolvedModule2,
|
|
shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
|
|
reusedNames,
|
|
resolutionInfo,
|
|
logChanges: logChangesWhenResolvingModule,
|
|
containingSourceFile
|
|
});
|
|
}
|
|
function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
|
|
const cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile));
|
|
if (!cache)
|
|
return void 0;
|
|
return cache.get(moduleName, resolutionMode);
|
|
}
|
|
function isNodeModulesAtTypesDirectory(dirPath) {
|
|
return endsWith(dirPath, "/node_modules/@types");
|
|
}
|
|
function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath) {
|
|
if (isInDirectoryPath(rootPath, failedLookupLocationPath)) {
|
|
failedLookupLocation = isRootedDiskPath(failedLookupLocation) ? normalizePath(failedLookupLocation) : getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory());
|
|
const failedLookupPathSplit = failedLookupLocationPath.split(directorySeparator);
|
|
const failedLookupSplit = failedLookupLocation.split(directorySeparator);
|
|
Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, `FailedLookup: ${failedLookupLocation} failedLookupLocationPath: ${failedLookupLocationPath}`);
|
|
if (failedLookupPathSplit.length > rootSplitLength + 1) {
|
|
return {
|
|
dir: failedLookupSplit.slice(0, rootSplitLength + 1).join(directorySeparator),
|
|
dirPath: failedLookupPathSplit.slice(0, rootSplitLength + 1).join(directorySeparator)
|
|
};
|
|
} else {
|
|
return {
|
|
dir: rootDir,
|
|
dirPath: rootPath,
|
|
nonRecursive: false
|
|
};
|
|
}
|
|
}
|
|
return getDirectoryToWatchFromFailedLookupLocationDirectory(
|
|
getDirectoryPath(getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())),
|
|
getDirectoryPath(failedLookupLocationPath)
|
|
);
|
|
}
|
|
function getDirectoryToWatchFromFailedLookupLocationDirectory(dir, dirPath) {
|
|
while (pathContainsNodeModules(dirPath)) {
|
|
dir = getDirectoryPath(dir);
|
|
dirPath = getDirectoryPath(dirPath);
|
|
}
|
|
if (isNodeModulesDirectory(dirPath)) {
|
|
return canWatchDirectoryOrFile(getDirectoryPath(dirPath)) ? { dir, dirPath } : void 0;
|
|
}
|
|
let nonRecursive = true;
|
|
let subDirectoryPath, subDirectory;
|
|
if (rootPath !== void 0) {
|
|
while (!isInDirectoryPath(dirPath, rootPath)) {
|
|
const parentPath = getDirectoryPath(dirPath);
|
|
if (parentPath === dirPath) {
|
|
break;
|
|
}
|
|
nonRecursive = false;
|
|
subDirectoryPath = dirPath;
|
|
subDirectory = dir;
|
|
dirPath = parentPath;
|
|
dir = getDirectoryPath(dir);
|
|
}
|
|
}
|
|
return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive } : void 0;
|
|
}
|
|
function isPathWithDefaultFailedLookupExtension(path) {
|
|
return fileExtensionIsOneOf(path, failedLookupDefaultExtensions);
|
|
}
|
|
function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) {
|
|
if (resolution.refCount) {
|
|
resolution.refCount++;
|
|
Debug.assertIsDefined(resolution.files);
|
|
} else {
|
|
resolution.refCount = 1;
|
|
Debug.assert(length(resolution.files) === 0);
|
|
if (isExternalModuleNameRelative(name)) {
|
|
watchFailedLookupLocationOfResolution(resolution);
|
|
} else {
|
|
nonRelativeExternalModuleResolutions.add(name, resolution);
|
|
}
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
if (resolved && resolved.resolvedFileName) {
|
|
resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution);
|
|
}
|
|
}
|
|
(resolution.files || (resolution.files = [])).push(filePath);
|
|
}
|
|
function watchFailedLookupLocationOfResolution(resolution) {
|
|
Debug.assert(!!resolution.refCount);
|
|
const { failedLookupLocations, affectingLocations } = resolution;
|
|
if (!failedLookupLocations.length && !affectingLocations.length)
|
|
return;
|
|
if (failedLookupLocations.length)
|
|
resolutionsWithFailedLookups.push(resolution);
|
|
let setAtRoot = false;
|
|
for (const failedLookupLocation of failedLookupLocations) {
|
|
const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
|
|
const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
|
|
if (toWatch) {
|
|
const { dir, dirPath, nonRecursive } = toWatch;
|
|
if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) {
|
|
const refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0;
|
|
customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1);
|
|
}
|
|
if (dirPath === rootPath) {
|
|
Debug.assert(!nonRecursive);
|
|
setAtRoot = true;
|
|
} else {
|
|
setDirectoryWatcher(dir, dirPath, nonRecursive);
|
|
}
|
|
}
|
|
}
|
|
if (setAtRoot) {
|
|
setDirectoryWatcher(rootDir, rootPath, true);
|
|
}
|
|
watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length);
|
|
}
|
|
function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
|
|
Debug.assert(!!resolution.refCount);
|
|
const { affectingLocations } = resolution;
|
|
if (!affectingLocations.length)
|
|
return;
|
|
if (addToResolutionsWithOnlyAffectingLocations)
|
|
resolutionsWithOnlyAffectingLocations.push(resolution);
|
|
for (const affectingLocation of affectingLocations) {
|
|
createFileWatcherOfAffectingLocation(affectingLocation, true);
|
|
}
|
|
}
|
|
function createFileWatcherOfAffectingLocation(affectingLocation, forResolution) {
|
|
const fileWatcher = fileWatchesOfAffectingLocations.get(affectingLocation);
|
|
if (fileWatcher) {
|
|
if (forResolution)
|
|
fileWatcher.resolutions++;
|
|
else
|
|
fileWatcher.files++;
|
|
return;
|
|
}
|
|
let locationToWatch = affectingLocation;
|
|
if (resolutionHost.realpath) {
|
|
locationToWatch = resolutionHost.realpath(affectingLocation);
|
|
if (affectingLocation !== locationToWatch) {
|
|
const fileWatcher2 = fileWatchesOfAffectingLocations.get(locationToWatch);
|
|
if (fileWatcher2) {
|
|
if (forResolution)
|
|
fileWatcher2.resolutions++;
|
|
else
|
|
fileWatcher2.files++;
|
|
fileWatcher2.paths.add(affectingLocation);
|
|
fileWatchesOfAffectingLocations.set(affectingLocation, fileWatcher2);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
const paths = /* @__PURE__ */ new Set();
|
|
paths.add(locationToWatch);
|
|
let actualWatcher = canWatchDirectoryOrFile(resolutionHost.toPath(locationToWatch)) ? resolutionHost.watchAffectingFileLocation(locationToWatch, (fileName, eventKind) => {
|
|
cachedDirectoryStructureHost == null ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind);
|
|
const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
|
|
paths.forEach((path) => {
|
|
if (watcher.resolutions)
|
|
(affectingPathChecks != null ? affectingPathChecks : affectingPathChecks = /* @__PURE__ */ new Set()).add(path);
|
|
if (watcher.files)
|
|
(affectingPathChecksForFile != null ? affectingPathChecksForFile : affectingPathChecksForFile = /* @__PURE__ */ new Set()).add(path);
|
|
packageJsonMap == null ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path));
|
|
});
|
|
resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
|
|
}) : noopFileWatcher;
|
|
const watcher = {
|
|
watcher: actualWatcher !== noopFileWatcher ? {
|
|
close: () => {
|
|
actualWatcher.close();
|
|
actualWatcher = noopFileWatcher;
|
|
}
|
|
} : actualWatcher,
|
|
resolutions: forResolution ? 1 : 0,
|
|
files: forResolution ? 0 : 1,
|
|
paths
|
|
};
|
|
fileWatchesOfAffectingLocations.set(locationToWatch, watcher);
|
|
if (affectingLocation !== locationToWatch) {
|
|
fileWatchesOfAffectingLocations.set(affectingLocation, watcher);
|
|
paths.add(affectingLocation);
|
|
}
|
|
}
|
|
function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
|
|
const program = resolutionHost.getCurrentProgram();
|
|
if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
|
|
resolutions.forEach(watchFailedLookupLocationOfResolution);
|
|
} else {
|
|
resolutions.forEach((resolution) => watchAffectingLocationsOfResolution(resolution, true));
|
|
}
|
|
}
|
|
function setDirectoryWatcher(dir, dirPath, nonRecursive) {
|
|
const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
|
|
if (dirWatcher) {
|
|
Debug.assert(!!nonRecursive === !!dirWatcher.nonRecursive);
|
|
dirWatcher.refCount++;
|
|
} else {
|
|
directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive });
|
|
}
|
|
}
|
|
function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) {
|
|
unorderedRemoveItem(Debug.checkDefined(resolution.files), filePath);
|
|
resolution.refCount--;
|
|
if (resolution.refCount) {
|
|
return;
|
|
}
|
|
const resolved = getResolutionWithResolvedFileName(resolution);
|
|
if (resolved && resolved.resolvedFileName) {
|
|
resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution);
|
|
}
|
|
const { failedLookupLocations, affectingLocations } = resolution;
|
|
if (unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) {
|
|
let removeAtRoot = false;
|
|
for (const failedLookupLocation of failedLookupLocations) {
|
|
const failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation);
|
|
const toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath);
|
|
if (toWatch) {
|
|
const { dirPath } = toWatch;
|
|
const refCount = customFailedLookupPaths.get(failedLookupLocationPath);
|
|
if (refCount) {
|
|
if (refCount === 1) {
|
|
customFailedLookupPaths.delete(failedLookupLocationPath);
|
|
} else {
|
|
Debug.assert(refCount > 1);
|
|
customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1);
|
|
}
|
|
}
|
|
if (dirPath === rootPath) {
|
|
removeAtRoot = true;
|
|
} else {
|
|
removeDirectoryWatcher(dirPath);
|
|
}
|
|
}
|
|
}
|
|
if (removeAtRoot) {
|
|
removeDirectoryWatcher(rootPath);
|
|
}
|
|
} else if (affectingLocations.length) {
|
|
unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution);
|
|
}
|
|
for (const affectingLocation of affectingLocations) {
|
|
const watcher = fileWatchesOfAffectingLocations.get(affectingLocation);
|
|
watcher.resolutions--;
|
|
}
|
|
}
|
|
function removeDirectoryWatcher(dirPath) {
|
|
const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
|
|
dirWatcher.refCount--;
|
|
}
|
|
function createDirectoryWatcher(directory, dirPath, nonRecursive) {
|
|
return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, (fileOrDirectory) => {
|
|
const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
|
|
}, nonRecursive ? 0 /* None */ : 1 /* Recursive */);
|
|
}
|
|
function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) {
|
|
const resolutions = cache.get(filePath);
|
|
if (resolutions) {
|
|
resolutions.forEach((resolution) => stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName));
|
|
cache.delete(filePath);
|
|
}
|
|
}
|
|
function removeResolutionsFromProjectReferenceRedirects(filePath) {
|
|
if (!fileExtensionIs(filePath, ".json" /* Json */))
|
|
return;
|
|
const program = resolutionHost.getCurrentProgram();
|
|
if (!program)
|
|
return;
|
|
const resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath);
|
|
if (!resolvedProjectReference)
|
|
return;
|
|
resolvedProjectReference.commandLine.fileNames.forEach((f) => removeResolutionsOfFile(resolutionHost.toPath(f)));
|
|
}
|
|
function removeResolutionsOfFile(filePath) {
|
|
removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule2);
|
|
removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective2);
|
|
}
|
|
function invalidateResolutions(resolutions, canInvalidate) {
|
|
if (!resolutions)
|
|
return false;
|
|
let invalidated = false;
|
|
for (const resolution of resolutions) {
|
|
if (resolution.isInvalidated || !canInvalidate(resolution))
|
|
continue;
|
|
resolution.isInvalidated = invalidated = true;
|
|
for (const containingFilePath of Debug.checkDefined(resolution.files)) {
|
|
(filesWithInvalidatedResolutions != null ? filesWithInvalidatedResolutions : filesWithInvalidatedResolutions = /* @__PURE__ */ new Set()).add(containingFilePath);
|
|
hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || endsWith(containingFilePath, inferredTypesContainingFile);
|
|
}
|
|
}
|
|
return invalidated;
|
|
}
|
|
function invalidateResolutionOfFile(filePath) {
|
|
removeResolutionsOfFile(filePath);
|
|
const prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
|
|
if (invalidateResolutions(resolvedFileToResolution.get(filePath), returnTrue) && hasChangedAutomaticTypeDirectiveNames && !prevHasChangedAutomaticTypeDirectiveNames) {
|
|
resolutionHost.onChangedAutomaticTypeDirectiveNames();
|
|
}
|
|
}
|
|
function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) {
|
|
Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === void 0);
|
|
filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
|
|
}
|
|
function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) {
|
|
if (isCreatingWatchedDirectory) {
|
|
(isInDirectoryChecks || (isInDirectoryChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
} else {
|
|
const updatedPath = removeIgnoredPath(fileOrDirectoryPath);
|
|
if (!updatedPath)
|
|
return false;
|
|
fileOrDirectoryPath = updatedPath;
|
|
if (resolutionHost.fileIsOpen(fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
const dirOfFileOrDirectory = getDirectoryPath(fileOrDirectoryPath);
|
|
if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || isNodeModulesDirectory(fileOrDirectoryPath) || isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || isNodeModulesDirectory(dirOfFileOrDirectory)) {
|
|
(failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
(startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
} else {
|
|
if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
if (isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) {
|
|
return false;
|
|
}
|
|
(failedLookupChecks || (failedLookupChecks = /* @__PURE__ */ new Set())).add(fileOrDirectoryPath);
|
|
const packagePath = parseNodeModuleFromPath(fileOrDirectoryPath);
|
|
if (packagePath)
|
|
(startsWithPathChecks || (startsWithPathChecks = /* @__PURE__ */ new Set())).add(packagePath);
|
|
}
|
|
}
|
|
resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations();
|
|
}
|
|
function invalidateResolutionsOfFailedLookupLocations() {
|
|
var _a2;
|
|
let invalidated = false;
|
|
if (affectingPathChecksForFile) {
|
|
(_a2 = resolutionHost.getCurrentProgram()) == null ? void 0 : _a2.getSourceFiles().forEach((f) => {
|
|
if (some(f.packageJsonLocations, (location2) => affectingPathChecksForFile.has(location2))) {
|
|
(filesWithInvalidatedResolutions != null ? filesWithInvalidatedResolutions : filesWithInvalidatedResolutions = /* @__PURE__ */ new Set()).add(f.path);
|
|
invalidated = true;
|
|
}
|
|
});
|
|
affectingPathChecksForFile = void 0;
|
|
}
|
|
if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) {
|
|
return invalidated;
|
|
}
|
|
invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution) || invalidated;
|
|
const packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap();
|
|
if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) {
|
|
packageJsonMap.forEach((_value, path) => isInvalidatedFailedLookup(path) ? packageJsonMap.delete(path) : void 0);
|
|
}
|
|
failedLookupChecks = void 0;
|
|
startsWithPathChecks = void 0;
|
|
isInDirectoryChecks = void 0;
|
|
invalidated = invalidateResolutions(resolutionsWithOnlyAffectingLocations, canInvalidatedFailedLookupResolutionWithAffectingLocation) || invalidated;
|
|
affectingPathChecks = void 0;
|
|
return invalidated;
|
|
}
|
|
function canInvalidateFailedLookupResolution(resolution) {
|
|
if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution))
|
|
return true;
|
|
if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
|
|
return false;
|
|
return resolution.failedLookupLocations.some((location2) => isInvalidatedFailedLookup(resolutionHost.toPath(location2)));
|
|
}
|
|
function isInvalidatedFailedLookup(locationPath) {
|
|
return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || emptyIterator, (fileOrDirectoryPath) => isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : void 0);
|
|
}
|
|
function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) {
|
|
return !!affectingPathChecks && resolution.affectingLocations.some((location2) => affectingPathChecks.has(location2));
|
|
}
|
|
function closeTypeRootsWatch() {
|
|
clearMap(typeRootsWatches, closeFileWatcher);
|
|
}
|
|
function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath) {
|
|
if (isInDirectoryPath(rootPath, typeRootPath)) {
|
|
return rootPath;
|
|
}
|
|
const toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath);
|
|
return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : void 0;
|
|
}
|
|
function createTypeRootsWatch(typeRootPath, typeRoot) {
|
|
return resolutionHost.watchTypeRootsDirectory(typeRoot, (fileOrDirectory) => {
|
|
const fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
hasChangedAutomaticTypeDirectiveNames = true;
|
|
resolutionHost.onChangedAutomaticTypeDirectiveNames();
|
|
const dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath);
|
|
if (dirPath) {
|
|
scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath);
|
|
}
|
|
}, 1 /* Recursive */);
|
|
}
|
|
function updateTypeRootsWatch() {
|
|
const options = resolutionHost.getCompilationSettings();
|
|
if (options.types) {
|
|
closeTypeRootsWatch();
|
|
return;
|
|
}
|
|
const typeRoots = getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory });
|
|
if (typeRoots) {
|
|
mutateMap(
|
|
typeRootsWatches,
|
|
arrayToMap(typeRoots, (tr) => resolutionHost.toPath(tr)),
|
|
{
|
|
createNewValue: createTypeRootsWatch,
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
} else {
|
|
closeTypeRootsWatch();
|
|
}
|
|
}
|
|
function directoryExistsForTypeRootWatch(nodeTypesDirectory) {
|
|
const dir = getDirectoryPath(getDirectoryPath(nodeTypesDirectory));
|
|
const dirPath = resolutionHost.toPath(dir);
|
|
return dirPath === rootPath || canWatchDirectoryOrFile(dirPath);
|
|
}
|
|
}
|
|
function resolutionIsSymlink(resolution) {
|
|
var _a2, _b;
|
|
return !!(((_a2 = resolution.resolvedModule) == null ? void 0 : _a2.originalPath) || ((_b = resolution.resolvedTypeReferenceDirective) == null ? void 0 : _b.originalPath));
|
|
}
|
|
|
|
// src/compiler/watch.ts
|
|
var sysFormatDiagnosticsHost = sys ? {
|
|
getCurrentDirectory: () => sys.getCurrentDirectory(),
|
|
getNewLine: () => sys.newLine,
|
|
getCanonicalFileName: createGetCanonicalFileName(sys.useCaseSensitiveFileNames)
|
|
} : void 0;
|
|
function createDiagnosticReporter(system, pretty) {
|
|
const host = system === sys && sysFormatDiagnosticsHost ? sysFormatDiagnosticsHost : {
|
|
getCurrentDirectory: () => system.getCurrentDirectory(),
|
|
getNewLine: () => system.newLine,
|
|
getCanonicalFileName: createGetCanonicalFileName(system.useCaseSensitiveFileNames)
|
|
};
|
|
if (!pretty) {
|
|
return (diagnostic) => system.write(formatDiagnostic(diagnostic, host));
|
|
}
|
|
const diagnostics = new Array(1);
|
|
return (diagnostic) => {
|
|
diagnostics[0] = diagnostic;
|
|
system.write(formatDiagnosticsWithColorAndContext(diagnostics, host) + host.getNewLine());
|
|
diagnostics[0] = void 0;
|
|
};
|
|
}
|
|
function clearScreenIfNotWatchingForFileChanges(system, diagnostic, options) {
|
|
if (system.clearScreen && !options.preserveWatchOutput && !options.extendedDiagnostics && !options.diagnostics && contains(screenStartingMessageCodes, diagnostic.code)) {
|
|
system.clearScreen();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
var screenStartingMessageCodes = [
|
|
Diagnostics.Starting_compilation_in_watch_mode.code,
|
|
Diagnostics.File_change_detected_Starting_incremental_compilation.code
|
|
];
|
|
function getPlainDiagnosticFollowingNewLines(diagnostic, newLine) {
|
|
return contains(screenStartingMessageCodes, diagnostic.code) ? newLine + newLine : newLine;
|
|
}
|
|
function getLocaleTimeString(system) {
|
|
return !system.now ? new Date().toLocaleTimeString() : system.now().toLocaleTimeString("en-US", { timeZone: "UTC" });
|
|
}
|
|
function createWatchStatusReporter(system, pretty) {
|
|
return pretty ? (diagnostic, newLine, options) => {
|
|
clearScreenIfNotWatchingForFileChanges(system, diagnostic, options);
|
|
let output = `[${formatColorAndReset(getLocaleTimeString(system), "\x1B[90m" /* Grey */)}] `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${newLine + newLine}`;
|
|
system.write(output);
|
|
} : (diagnostic, newLine, options) => {
|
|
let output = "";
|
|
if (!clearScreenIfNotWatchingForFileChanges(system, diagnostic, options)) {
|
|
output += newLine;
|
|
}
|
|
output += `${getLocaleTimeString(system)} - `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${getPlainDiagnosticFollowingNewLines(diagnostic, newLine)}`;
|
|
system.write(output);
|
|
};
|
|
}
|
|
function parseConfigFileWithSystem(configFileName, optionsToExtend, extendedConfigCache, watchOptionsToExtend, system, reportDiagnostic) {
|
|
const host = system;
|
|
host.onUnRecoverableConfigFileDiagnostic = (diagnostic) => reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic);
|
|
const result = getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend);
|
|
host.onUnRecoverableConfigFileDiagnostic = void 0;
|
|
return result;
|
|
}
|
|
function getErrorCountForSummary(diagnostics) {
|
|
return countWhere(diagnostics, (diagnostic) => diagnostic.category === 1 /* Error */);
|
|
}
|
|
function getFilesInErrorForSummary(diagnostics) {
|
|
const filesInError = filter(diagnostics, (diagnostic) => diagnostic.category === 1 /* Error */).map(
|
|
(errorDiagnostic) => {
|
|
if (errorDiagnostic.file === void 0)
|
|
return;
|
|
return `${errorDiagnostic.file.fileName}`;
|
|
}
|
|
);
|
|
return filesInError.map((fileName) => {
|
|
const diagnosticForFileName = find(
|
|
diagnostics,
|
|
(diagnostic) => diagnostic.file !== void 0 && diagnostic.file.fileName === fileName
|
|
);
|
|
if (diagnosticForFileName !== void 0) {
|
|
const { line } = getLineAndCharacterOfPosition(diagnosticForFileName.file, diagnosticForFileName.start);
|
|
return {
|
|
fileName,
|
|
line: line + 1
|
|
};
|
|
}
|
|
});
|
|
}
|
|
function getWatchErrorSummaryDiagnosticMessage(errorCount) {
|
|
return errorCount === 1 ? Diagnostics.Found_1_error_Watching_for_file_changes : Diagnostics.Found_0_errors_Watching_for_file_changes;
|
|
}
|
|
function prettyPathForFileError(error, cwd) {
|
|
const line = formatColorAndReset(":" + error.line, "\x1B[90m" /* Grey */);
|
|
if (pathIsAbsolute(error.fileName) && pathIsAbsolute(cwd)) {
|
|
return getRelativePathFromDirectory(cwd, error.fileName, false) + line;
|
|
}
|
|
return error.fileName + line;
|
|
}
|
|
function getErrorSummaryText(errorCount, filesInError, newLine, host) {
|
|
if (errorCount === 0)
|
|
return "";
|
|
const nonNilFiles = filesInError.filter((fileInError) => fileInError !== void 0);
|
|
const distinctFileNamesWithLines = nonNilFiles.map((fileInError) => `${fileInError.fileName}:${fileInError.line}`).filter((value, index, self2) => self2.indexOf(value) === index);
|
|
const firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory());
|
|
const d = errorCount === 1 ? createCompilerDiagnostic(
|
|
filesInError[0] !== void 0 ? Diagnostics.Found_1_error_in_1 : Diagnostics.Found_1_error,
|
|
errorCount,
|
|
firstFileReference
|
|
) : createCompilerDiagnostic(
|
|
distinctFileNamesWithLines.length === 0 ? Diagnostics.Found_0_errors : distinctFileNamesWithLines.length === 1 ? Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 : Diagnostics.Found_0_errors_in_1_files,
|
|
errorCount,
|
|
distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length
|
|
);
|
|
const suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "";
|
|
return `${newLine}${flattenDiagnosticMessageText(d.messageText, newLine)}${newLine}${newLine}${suffix}`;
|
|
}
|
|
function createTabularErrorsDisplay(filesInError, host) {
|
|
const distinctFiles = filesInError.filter((value, index, self2) => index === self2.findIndex((file) => (file == null ? void 0 : file.fileName) === (value == null ? void 0 : value.fileName)));
|
|
if (distinctFiles.length === 0)
|
|
return "";
|
|
const numberLength = (num) => Math.log(num) * Math.LOG10E + 1;
|
|
const fileToErrorCount = distinctFiles.map((file) => [file, countWhere(filesInError, (fileInError) => fileInError.fileName === file.fileName)]);
|
|
const maxErrors = fileToErrorCount.reduce((acc, value) => Math.max(acc, value[1] || 0), 0);
|
|
const headerRow = Diagnostics.Errors_Files.message;
|
|
const leftColumnHeadingLength = headerRow.split(" ")[0].length;
|
|
const leftPaddingGoal = Math.max(leftColumnHeadingLength, numberLength(maxErrors));
|
|
const headerPadding = Math.max(numberLength(maxErrors) - leftColumnHeadingLength, 0);
|
|
let tabularData = "";
|
|
tabularData += " ".repeat(headerPadding) + headerRow + "\n";
|
|
fileToErrorCount.forEach((row) => {
|
|
const [file, errorCount] = row;
|
|
const errorCountDigitsLength = Math.log(errorCount) * Math.LOG10E + 1 | 0;
|
|
const leftPadding = errorCountDigitsLength < leftPaddingGoal ? " ".repeat(leftPaddingGoal - errorCountDigitsLength) : "";
|
|
const fileRef = prettyPathForFileError(file, host.getCurrentDirectory());
|
|
tabularData += `${leftPadding}${errorCount} ${fileRef}
|
|
`;
|
|
});
|
|
return tabularData;
|
|
}
|
|
function isBuilderProgram2(program) {
|
|
return !!program.getState;
|
|
}
|
|
function listFiles(program, write) {
|
|
const options = program.getCompilerOptions();
|
|
if (options.explainFiles) {
|
|
explainFiles(isBuilderProgram2(program) ? program.getProgram() : program, write);
|
|
} else if (options.listFiles || options.listFilesOnly) {
|
|
forEach(program.getSourceFiles(), (file) => {
|
|
write(file.fileName);
|
|
});
|
|
}
|
|
}
|
|
function explainFiles(program, write) {
|
|
var _a2, _b;
|
|
const reasons = program.getFileIncludeReasons();
|
|
const getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames());
|
|
const relativeFileName = (fileName) => convertToRelativePath(fileName, program.getCurrentDirectory(), getCanonicalFileName);
|
|
for (const file of program.getSourceFiles()) {
|
|
write(`${toFileName(file, relativeFileName)}`);
|
|
(_a2 = reasons.get(file.path)) == null ? void 0 : _a2.forEach((reason) => write(` ${fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText}`));
|
|
(_b = explainIfFileIsRedirectAndImpliedFormat(file, relativeFileName)) == null ? void 0 : _b.forEach((d) => write(` ${d.messageText}`));
|
|
}
|
|
}
|
|
function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) {
|
|
var _a2;
|
|
let result;
|
|
if (file.path !== file.resolvedPath) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_output_of_project_reference_source_0,
|
|
toFileName(file.originalFileName, fileNameConvertor)
|
|
));
|
|
}
|
|
if (file.redirectInfo) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_redirects_to_file_0,
|
|
toFileName(file.redirectInfo.redirectTarget, fileNameConvertor)
|
|
));
|
|
}
|
|
if (isExternalOrCommonJsModule(file)) {
|
|
switch (file.impliedNodeFormat) {
|
|
case 99 /* ESNext */:
|
|
if (file.packageJsonScope) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module,
|
|
toFileName(last(file.packageJsonLocations), fileNameConvertor)
|
|
));
|
|
}
|
|
break;
|
|
case 1 /* CommonJS */:
|
|
if (file.packageJsonScope) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
file.packageJsonScope.contents.packageJsonContent.type ? Diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module : Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type,
|
|
toFileName(last(file.packageJsonLocations), fileNameConvertor)
|
|
));
|
|
} else if ((_a2 = file.packageJsonLocations) == null ? void 0 : _a2.length) {
|
|
(result != null ? result : result = []).push(chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.File_is_CommonJS_module_because_package_json_was_not_found
|
|
));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getMatchedFileSpec(program, fileName) {
|
|
var _a2;
|
|
const configFile = program.getCompilerOptions().configFile;
|
|
if (!((_a2 = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _a2.validatedFilesSpec))
|
|
return void 0;
|
|
const getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames());
|
|
const filePath = getCanonicalFileName(fileName);
|
|
const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
|
|
return find(configFile.configFileSpecs.validatedFilesSpec, (fileSpec) => getCanonicalFileName(getNormalizedAbsolutePath(fileSpec, basePath)) === filePath);
|
|
}
|
|
function getMatchedIncludeSpec(program, fileName) {
|
|
var _a2, _b;
|
|
const configFile = program.getCompilerOptions().configFile;
|
|
if (!((_a2 = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _a2.validatedIncludeSpecs))
|
|
return void 0;
|
|
if (configFile.configFileSpecs.isDefaultIncludeSpec)
|
|
return true;
|
|
const isJsonFile = fileExtensionIs(fileName, ".json" /* Json */);
|
|
const basePath = getDirectoryPath(getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory()));
|
|
const useCaseSensitiveFileNames = program.useCaseSensitiveFileNames();
|
|
return find((_b = configFile == null ? void 0 : configFile.configFileSpecs) == null ? void 0 : _b.validatedIncludeSpecs, (includeSpec) => {
|
|
if (isJsonFile && !endsWith(includeSpec, ".json" /* Json */))
|
|
return false;
|
|
const pattern = getPatternFromSpec(includeSpec, basePath, "files");
|
|
return !!pattern && getRegexFromPattern(`(${pattern})$`, useCaseSensitiveFileNames).test(fileName);
|
|
});
|
|
}
|
|
function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
|
|
var _a2, _b;
|
|
const options = program.getCompilerOptions();
|
|
if (isReferencedFile(reason)) {
|
|
const referenceLocation = getReferencedFileLocation((path) => program.getSourceFileByPath(path), reason);
|
|
const referenceText = isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : `"${referenceLocation.text}"`;
|
|
let message;
|
|
Debug.assert(isReferenceFileLocation(referenceLocation) || reason.kind === 3 /* Import */, "Only synthetic references are imports");
|
|
switch (reason.kind) {
|
|
case 3 /* Import */:
|
|
if (isReferenceFileLocation(referenceLocation)) {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2 : Diagnostics.Imported_via_0_from_file_1;
|
|
} else if (referenceLocation.text === externalHelpersModuleNameText) {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions : Diagnostics.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions;
|
|
} else {
|
|
message = referenceLocation.packageId ? Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions : Diagnostics.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions;
|
|
}
|
|
break;
|
|
case 4 /* ReferenceFile */:
|
|
Debug.assert(!referenceLocation.packageId);
|
|
message = Diagnostics.Referenced_via_0_from_file_1;
|
|
break;
|
|
case 5 /* TypeReferenceDirective */:
|
|
message = referenceLocation.packageId ? Diagnostics.Type_library_referenced_via_0_from_file_1_with_packageId_2 : Diagnostics.Type_library_referenced_via_0_from_file_1;
|
|
break;
|
|
case 7 /* LibReferenceDirective */:
|
|
Debug.assert(!referenceLocation.packageId);
|
|
message = Diagnostics.Library_referenced_via_0_from_file_1;
|
|
break;
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
message,
|
|
referenceText,
|
|
toFileName(referenceLocation.file, fileNameConvertor),
|
|
referenceLocation.packageId && packageIdToString(referenceLocation.packageId)
|
|
);
|
|
}
|
|
switch (reason.kind) {
|
|
case 0 /* RootFile */:
|
|
if (!((_a2 = options.configFile) == null ? void 0 : _a2.configFileSpecs))
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Root_file_specified_for_compilation);
|
|
const fileName = getNormalizedAbsolutePath(program.getRootFileNames()[reason.index], program.getCurrentDirectory());
|
|
const matchedByFiles = getMatchedFileSpec(program, fileName);
|
|
if (matchedByFiles)
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Part_of_files_list_in_tsconfig_json);
|
|
const matchedByInclude = getMatchedIncludeSpec(program, fileName);
|
|
return isString(matchedByInclude) ? chainDiagnosticMessages(
|
|
void 0,
|
|
Diagnostics.Matched_by_include_pattern_0_in_1,
|
|
matchedByInclude,
|
|
toFileName(options.configFile, fileNameConvertor)
|
|
) : chainDiagnosticMessages(
|
|
void 0,
|
|
matchedByInclude ? Diagnostics.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk : Diagnostics.Root_file_specified_for_compilation
|
|
);
|
|
case 1 /* SourceFromProjectReference */:
|
|
case 2 /* OutputFromProjectReference */:
|
|
const isOutput = reason.kind === 2 /* OutputFromProjectReference */;
|
|
const referencedResolvedRef = Debug.checkDefined((_b = program.getResolvedProjectReferences()) == null ? void 0 : _b[reason.index]);
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
outFile(options) ? isOutput ? Diagnostics.Output_from_referenced_project_0_included_because_1_specified : Diagnostics.Source_from_referenced_project_0_included_because_1_specified : isOutput ? Diagnostics.Output_from_referenced_project_0_included_because_module_is_specified_as_none : Diagnostics.Source_from_referenced_project_0_included_because_module_is_specified_as_none,
|
|
toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor),
|
|
options.outFile ? "--outFile" : "--out"
|
|
);
|
|
case 8 /* AutomaticTypeDirectiveFile */:
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
options.types ? reason.packageId ? Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : reason.packageId ? Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : Diagnostics.Entry_point_for_implicit_type_library_0,
|
|
reason.typeReference,
|
|
reason.packageId && packageIdToString(reason.packageId)
|
|
);
|
|
case 6 /* LibFile */:
|
|
if (reason.index !== void 0)
|
|
return chainDiagnosticMessages(void 0, Diagnostics.Library_0_specified_in_compilerOptions, options.lib[reason.index]);
|
|
const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
|
|
return chainDiagnosticMessages(
|
|
void 0,
|
|
target ? Diagnostics.Default_library_for_target_0 : Diagnostics.Default_library,
|
|
target
|
|
);
|
|
default:
|
|
Debug.assertNever(reason);
|
|
}
|
|
}
|
|
function toFileName(file, fileNameConvertor) {
|
|
const fileName = isString(file) ? file : file.fileName;
|
|
return fileNameConvertor ? fileNameConvertor(fileName) : fileName;
|
|
}
|
|
function emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
const isListFilesOnly = !!program.getCompilerOptions().listFilesOnly;
|
|
const allDiagnostics = program.getConfigFileParsingDiagnostics().slice();
|
|
const configFileParsingDiagnosticsLength = allDiagnostics.length;
|
|
addRange(allDiagnostics, program.getSyntacticDiagnostics(void 0, cancellationToken));
|
|
if (allDiagnostics.length === configFileParsingDiagnosticsLength) {
|
|
addRange(allDiagnostics, program.getOptionsDiagnostics(cancellationToken));
|
|
if (!isListFilesOnly) {
|
|
addRange(allDiagnostics, program.getGlobalDiagnostics(cancellationToken));
|
|
if (allDiagnostics.length === configFileParsingDiagnosticsLength) {
|
|
addRange(allDiagnostics, program.getSemanticDiagnostics(void 0, cancellationToken));
|
|
}
|
|
}
|
|
}
|
|
const emitResult = isListFilesOnly ? { emitSkipped: true, diagnostics: emptyArray } : program.emit(void 0, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers);
|
|
const { emittedFiles, diagnostics: emitDiagnostics } = emitResult;
|
|
addRange(allDiagnostics, emitDiagnostics);
|
|
const diagnostics = sortAndDeduplicateDiagnostics(allDiagnostics);
|
|
diagnostics.forEach(reportDiagnostic);
|
|
if (write) {
|
|
const currentDir = program.getCurrentDirectory();
|
|
forEach(emittedFiles, (file) => {
|
|
const filepath = getNormalizedAbsolutePath(file, currentDir);
|
|
write(`TSFILE: ${filepath}`);
|
|
});
|
|
listFiles(program, write);
|
|
}
|
|
if (reportSummary) {
|
|
reportSummary(getErrorCountForSummary(diagnostics), getFilesInErrorForSummary(diagnostics));
|
|
}
|
|
return {
|
|
emitResult,
|
|
diagnostics
|
|
};
|
|
}
|
|
function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, write, reportSummary, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) {
|
|
const { emitResult, diagnostics } = emitFilesAndReportErrors(
|
|
program,
|
|
reportDiagnostic,
|
|
write,
|
|
reportSummary,
|
|
writeFile2,
|
|
cancellationToken,
|
|
emitOnlyDtsFiles,
|
|
customTransformers
|
|
);
|
|
if (emitResult.emitSkipped && diagnostics.length > 0) {
|
|
return 1 /* DiagnosticsPresent_OutputsSkipped */;
|
|
} else if (diagnostics.length > 0) {
|
|
return 2 /* DiagnosticsPresent_OutputsGenerated */;
|
|
}
|
|
return 0 /* Success */;
|
|
}
|
|
var noopFileWatcher = { close: noop };
|
|
var returnNoopFileWatcher = () => noopFileWatcher;
|
|
function createWatchHost(system = sys, reportWatchStatus2) {
|
|
const onWatchStatusChange = reportWatchStatus2 || createWatchStatusReporter(system);
|
|
return {
|
|
onWatchStatusChange,
|
|
watchFile: maybeBind(system, system.watchFile) || returnNoopFileWatcher,
|
|
watchDirectory: maybeBind(system, system.watchDirectory) || returnNoopFileWatcher,
|
|
setTimeout: maybeBind(system, system.setTimeout) || noop,
|
|
clearTimeout: maybeBind(system, system.clearTimeout) || noop
|
|
};
|
|
}
|
|
var WatchType = {
|
|
ConfigFile: "Config file",
|
|
ExtendedConfigFile: "Extended config file",
|
|
SourceFile: "Source file",
|
|
MissingFile: "Missing file",
|
|
WildcardDirectory: "Wild card directory",
|
|
FailedLookupLocations: "Failed Lookup Locations",
|
|
AffectingFileLocation: "File location affecting resolution",
|
|
TypeRoots: "Type roots",
|
|
ConfigFileOfReferencedProject: "Config file of referened project",
|
|
ExtendedConfigOfReferencedProject: "Extended config file of referenced project",
|
|
WildcardDirectoryOfReferencedProject: "Wild card directory of referenced project",
|
|
PackageJson: "package.json file",
|
|
ClosedScriptInfo: "Closed Script info",
|
|
ConfigFileForInferredRoot: "Config file for the inferred project root",
|
|
NodeModules: "node_modules for closed script infos and package.jsons affecting module specifier cache",
|
|
MissingSourceMapFile: "Missing source map file",
|
|
NoopConfigFileForInferredRoot: "Noop Config file for the inferred project root",
|
|
MissingGeneratedFile: "Missing generated file",
|
|
NodeModulesForModuleSpecifierCache: "node_modules for module specifier cache invalidation"
|
|
};
|
|
function createWatchFactory(host, options) {
|
|
const watchLogLevel = host.trace ? options.extendedDiagnostics ? 2 /* Verbose */ : options.diagnostics ? 1 /* TriggerOnly */ : 0 /* None */ : 0 /* None */;
|
|
const writeLog = watchLogLevel !== 0 /* None */ ? (s) => host.trace(s) : noop;
|
|
const result = getWatchFactory(host, watchLogLevel, writeLog);
|
|
result.writeLog = writeLog;
|
|
return result;
|
|
}
|
|
function createCompilerHostFromProgramHost(host, getCompilerOptions, directoryStructureHost = host) {
|
|
const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
|
|
const hostGetNewLine = memoize(() => host.getNewLine());
|
|
return {
|
|
getSourceFile: createGetSourceFile(
|
|
(fileName, encoding) => host.readFile(fileName, encoding),
|
|
getCompilerOptions,
|
|
void 0
|
|
),
|
|
getDefaultLibLocation: maybeBind(host, host.getDefaultLibLocation),
|
|
getDefaultLibFileName: (options) => host.getDefaultLibFileName(options),
|
|
writeFile: createWriteFileMeasuringIO(
|
|
(path, data, writeByteOrderMark) => host.writeFile(path, data, writeByteOrderMark),
|
|
(path) => host.createDirectory(path),
|
|
(path) => host.directoryExists(path)
|
|
),
|
|
getCurrentDirectory: memoize(() => host.getCurrentDirectory()),
|
|
useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
|
|
getCanonicalFileName: createGetCanonicalFileName(useCaseSensitiveFileNames),
|
|
getNewLine: () => getNewLineCharacter(getCompilerOptions(), hostGetNewLine),
|
|
fileExists: (f) => host.fileExists(f),
|
|
readFile: (f) => host.readFile(f),
|
|
trace: maybeBind(host, host.trace),
|
|
directoryExists: maybeBind(directoryStructureHost, directoryStructureHost.directoryExists),
|
|
getDirectories: maybeBind(directoryStructureHost, directoryStructureHost.getDirectories),
|
|
realpath: maybeBind(host, host.realpath),
|
|
getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
|
|
createHash: maybeBind(host, host.createHash),
|
|
readDirectory: maybeBind(host, host.readDirectory),
|
|
disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
|
|
storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
|
|
};
|
|
}
|
|
function getSourceFileVersionAsHashFromText(host, text) {
|
|
if (text.match(sourceMapCommentRegExpDontCareLineStart)) {
|
|
let lineEnd = text.length;
|
|
let lineStart = lineEnd;
|
|
for (let pos = lineEnd - 1; pos >= 0; pos--) {
|
|
const ch = text.charCodeAt(pos);
|
|
switch (ch) {
|
|
case 10 /* lineFeed */:
|
|
if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) {
|
|
pos--;
|
|
}
|
|
case 13 /* carriageReturn */:
|
|
break;
|
|
default:
|
|
if (ch < 127 /* maxAsciiCharacter */ || !isLineBreak(ch)) {
|
|
lineStart = pos;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
const line = text.substring(lineStart, lineEnd);
|
|
if (line.match(sourceMapCommentRegExp)) {
|
|
text = text.substring(0, lineStart);
|
|
break;
|
|
} else if (!line.match(whitespaceOrMapCommentRegExp)) {
|
|
break;
|
|
}
|
|
lineEnd = lineStart;
|
|
}
|
|
}
|
|
return (host.createHash || generateDjb2Hash)(text);
|
|
}
|
|
function setGetSourceFileAsHashVersioned(compilerHost, host) {
|
|
const originalGetSourceFile = compilerHost.getSourceFile;
|
|
compilerHost.getSourceFile = (...args) => {
|
|
const result = originalGetSourceFile.call(compilerHost, ...args);
|
|
if (result) {
|
|
result.version = getSourceFileVersionAsHashFromText(host, result.text);
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
function createProgramHost(system, createProgram2) {
|
|
const getDefaultLibLocation = memoize(() => getDirectoryPath(normalizePath(system.getExecutingFilePath())));
|
|
return {
|
|
useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,
|
|
getNewLine: () => system.newLine,
|
|
getCurrentDirectory: memoize(() => system.getCurrentDirectory()),
|
|
getDefaultLibLocation,
|
|
getDefaultLibFileName: (options) => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
|
|
fileExists: (path) => system.fileExists(path),
|
|
readFile: (path, encoding) => system.readFile(path, encoding),
|
|
directoryExists: (path) => system.directoryExists(path),
|
|
getDirectories: (path) => system.getDirectories(path),
|
|
readDirectory: (path, extensions, exclude, include, depth) => system.readDirectory(path, extensions, exclude, include, depth),
|
|
realpath: maybeBind(system, system.realpath),
|
|
getEnvironmentVariable: maybeBind(system, system.getEnvironmentVariable),
|
|
trace: (s) => system.write(s + system.newLine),
|
|
createDirectory: (path) => system.createDirectory(path),
|
|
writeFile: (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
|
|
createHash: maybeBind(system, system.createHash),
|
|
createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
|
|
disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature,
|
|
storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
|
|
now: maybeBind(system, system.now)
|
|
};
|
|
}
|
|
function createWatchCompilerHost(system = sys, createProgram2, reportDiagnostic, reportWatchStatus2) {
|
|
const write = (s) => system.write(s + system.newLine);
|
|
const result = createProgramHost(system, createProgram2);
|
|
copyProperties(result, createWatchHost(system, reportWatchStatus2));
|
|
result.afterProgramCreate = (builderProgram) => {
|
|
const compilerOptions = builderProgram.getCompilerOptions();
|
|
const newLine = getNewLineCharacter(compilerOptions, () => system.newLine);
|
|
emitFilesAndReportErrors(
|
|
builderProgram,
|
|
reportDiagnostic,
|
|
write,
|
|
(errorCount) => result.onWatchStatusChange(
|
|
createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount),
|
|
newLine,
|
|
compilerOptions,
|
|
errorCount
|
|
)
|
|
);
|
|
};
|
|
return result;
|
|
}
|
|
function reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic) {
|
|
reportDiagnostic(diagnostic);
|
|
system.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
|
|
}
|
|
function createWatchCompilerHostOfConfigFile({
|
|
configFileName,
|
|
optionsToExtend,
|
|
watchOptionsToExtend,
|
|
extraFileExtensions,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
}) {
|
|
const diagnosticReporter = reportDiagnostic || createDiagnosticReporter(system);
|
|
const host = createWatchCompilerHost(system, createProgram2, diagnosticReporter, reportWatchStatus2);
|
|
host.onUnRecoverableConfigFileDiagnostic = (diagnostic) => reportUnrecoverableDiagnostic(system, diagnosticReporter, diagnostic);
|
|
host.configFileName = configFileName;
|
|
host.optionsToExtend = optionsToExtend;
|
|
host.watchOptionsToExtend = watchOptionsToExtend;
|
|
host.extraFileExtensions = extraFileExtensions;
|
|
return host;
|
|
}
|
|
function createWatchCompilerHostOfFilesAndCompilerOptions({
|
|
rootFiles,
|
|
options,
|
|
watchOptions,
|
|
projectReferences,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
}) {
|
|
const host = createWatchCompilerHost(system, createProgram2, reportDiagnostic || createDiagnosticReporter(system), reportWatchStatus2);
|
|
host.rootFiles = rootFiles;
|
|
host.options = options;
|
|
host.watchOptions = watchOptions;
|
|
host.projectReferences = projectReferences;
|
|
return host;
|
|
}
|
|
function performIncrementalCompilation(input) {
|
|
const system = input.system || sys;
|
|
const host = input.host || (input.host = createIncrementalCompilerHost(input.options, system));
|
|
const builderProgram = createIncrementalProgram(input);
|
|
const exitStatus = emitFilesAndReportErrorsAndGetExitStatus(
|
|
builderProgram,
|
|
input.reportDiagnostic || createDiagnosticReporter(system),
|
|
(s) => host.trace && host.trace(s),
|
|
input.reportErrorSummary || input.options.pretty ? (errorCount, filesInError) => system.write(getErrorSummaryText(errorCount, filesInError, system.newLine, host)) : void 0
|
|
);
|
|
if (input.afterProgramEmitAndDiagnostics)
|
|
input.afterProgramEmitAndDiagnostics(builderProgram);
|
|
return exitStatus;
|
|
}
|
|
|
|
// src/compiler/watchPublic.ts
|
|
function readBuilderProgram(compilerOptions, host) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(compilerOptions);
|
|
if (!buildInfoPath)
|
|
return void 0;
|
|
let buildInfo;
|
|
if (host.getBuildInfo) {
|
|
buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath);
|
|
} else {
|
|
const content = host.readFile(buildInfoPath);
|
|
if (!content)
|
|
return void 0;
|
|
buildInfo = getBuildInfo(buildInfoPath, content);
|
|
}
|
|
if (!buildInfo || buildInfo.version !== version || !buildInfo.program)
|
|
return void 0;
|
|
return createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, host);
|
|
}
|
|
function createIncrementalCompilerHost(options, system = sys) {
|
|
const host = createCompilerHostWorker(options, void 0, system);
|
|
host.createHash = maybeBind(system, system.createHash);
|
|
host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
|
|
host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
|
|
setGetSourceFileAsHashVersioned(host, system);
|
|
changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
|
|
return host;
|
|
}
|
|
function createIncrementalProgram({
|
|
rootNames,
|
|
options,
|
|
configFileParsingDiagnostics,
|
|
projectReferences,
|
|
host,
|
|
createProgram: createProgram2
|
|
}) {
|
|
host = host || createIncrementalCompilerHost(options);
|
|
createProgram2 = createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram;
|
|
const oldProgram = readBuilderProgram(options, host);
|
|
return createProgram2(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences);
|
|
}
|
|
function createWatchCompilerHost2(rootFilesOrConfigFileName, options, system, createProgram2, reportDiagnostic, reportWatchStatus2, projectReferencesOrWatchOptionsToExtend, watchOptionsOrExtraFileExtensions) {
|
|
if (isArray(rootFilesOrConfigFileName)) {
|
|
return createWatchCompilerHostOfFilesAndCompilerOptions({
|
|
rootFiles: rootFilesOrConfigFileName,
|
|
options,
|
|
watchOptions: watchOptionsOrExtraFileExtensions,
|
|
projectReferences: projectReferencesOrWatchOptionsToExtend,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
});
|
|
} else {
|
|
return createWatchCompilerHostOfConfigFile({
|
|
configFileName: rootFilesOrConfigFileName,
|
|
optionsToExtend: options,
|
|
watchOptionsToExtend: projectReferencesOrWatchOptionsToExtend,
|
|
extraFileExtensions: watchOptionsOrExtraFileExtensions,
|
|
system,
|
|
createProgram: createProgram2,
|
|
reportDiagnostic,
|
|
reportWatchStatus: reportWatchStatus2
|
|
});
|
|
}
|
|
}
|
|
function createWatchProgram(host) {
|
|
let builderProgram;
|
|
let reloadLevel;
|
|
let missingFilesMap;
|
|
let watchedWildcardDirectories;
|
|
let timerToUpdateProgram;
|
|
let timerToInvalidateFailedLookupResolutions;
|
|
let parsedConfigs;
|
|
let sharedExtendedConfigFileWatchers;
|
|
let extendedConfigCache = host.extendedConfigCache;
|
|
let reportFileChangeDetectedOnCreateProgram = false;
|
|
const sourceFilesCache = /* @__PURE__ */ new Map();
|
|
let missingFilePathsRequestedForRelease;
|
|
let hasChangedCompilerOptions = false;
|
|
const useCaseSensitiveFileNames = host.useCaseSensitiveFileNames();
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const { configFileName, optionsToExtend: optionsToExtendForConfigFile = {}, watchOptionsToExtend, extraFileExtensions, createProgram: createProgram2 } = host;
|
|
let { rootFiles: rootFileNames, options: compilerOptions, watchOptions, projectReferences } = host;
|
|
let wildcardDirectories;
|
|
let configFileParsingDiagnostics;
|
|
let canConfigFileJsonReportNoInputFiles = false;
|
|
let hasChangedConfigFileParsingErrors = false;
|
|
const cachedDirectoryStructureHost = configFileName === void 0 ? void 0 : createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames);
|
|
const directoryStructureHost = cachedDirectoryStructureHost || host;
|
|
const parseConfigFileHost = parseConfigHostFromCompilerHostLike(host, directoryStructureHost);
|
|
let newLine = updateNewLine();
|
|
if (configFileName && host.configFileParsingResult) {
|
|
setConfigFileParsingResult(host.configFileParsingResult);
|
|
newLine = updateNewLine();
|
|
}
|
|
reportWatchDiagnostic(Diagnostics.Starting_compilation_in_watch_mode);
|
|
if (configFileName && !host.configFileParsingResult) {
|
|
newLine = getNewLineCharacter(optionsToExtendForConfigFile, () => host.getNewLine());
|
|
Debug.assert(!rootFileNames);
|
|
parseConfigFile2();
|
|
newLine = updateNewLine();
|
|
}
|
|
const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(host, compilerOptions);
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
writeLog(`Current directory: ${currentDirectory} CaseSensitiveFileNames: ${useCaseSensitiveFileNames}`);
|
|
let configFileWatcher;
|
|
if (configFileName) {
|
|
configFileWatcher = watchFile2(configFileName, scheduleProgramReload, 2e3 /* High */, watchOptions, WatchType.ConfigFile);
|
|
}
|
|
const compilerHost = createCompilerHostFromProgramHost(host, () => compilerOptions, directoryStructureHost);
|
|
setGetSourceFileAsHashVersioned(compilerHost, host);
|
|
const getNewSourceFile = compilerHost.getSourceFile;
|
|
compilerHost.getSourceFile = (fileName, ...args) => getVersionedSourceFileByPath(fileName, toPath3(fileName), ...args);
|
|
compilerHost.getSourceFileByPath = getVersionedSourceFileByPath;
|
|
compilerHost.getNewLine = () => newLine;
|
|
compilerHost.fileExists = fileExists;
|
|
compilerHost.onReleaseOldSourceFile = onReleaseOldSourceFile;
|
|
compilerHost.onReleaseParsedCommandLine = onReleaseParsedCommandLine;
|
|
compilerHost.toPath = toPath3;
|
|
compilerHost.getCompilationSettings = () => compilerOptions;
|
|
compilerHost.useSourceOfProjectReferenceRedirect = maybeBind(host, host.useSourceOfProjectReferenceRedirect);
|
|
compilerHost.watchDirectoryOfFailedLookupLocation = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.FailedLookupLocations);
|
|
compilerHost.watchAffectingFileLocation = (file, cb) => watchFile2(file, cb, 2e3 /* High */, watchOptions, WatchType.AffectingFileLocation);
|
|
compilerHost.watchTypeRootsDirectory = (dir, cb, flags) => watchDirectory(dir, cb, flags, watchOptions, WatchType.TypeRoots);
|
|
compilerHost.getCachedDirectoryStructureHost = () => cachedDirectoryStructureHost;
|
|
compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations;
|
|
compilerHost.onInvalidatedResolution = scheduleProgramUpdate;
|
|
compilerHost.onChangedAutomaticTypeDirectiveNames = scheduleProgramUpdate;
|
|
compilerHost.fileIsOpen = returnFalse;
|
|
compilerHost.getCurrentProgram = getCurrentProgram;
|
|
compilerHost.writeLog = writeLog;
|
|
compilerHost.getParsedCommandLine = getParsedCommandLine;
|
|
const resolutionCache = createResolutionCache(
|
|
compilerHost,
|
|
configFileName ? getDirectoryPath(getNormalizedAbsolutePath(configFileName, currentDirectory)) : currentDirectory,
|
|
false
|
|
);
|
|
compilerHost.resolveModuleNames = host.resolveModuleNames ? (...args) => host.resolveModuleNames(...args) : (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile, resolutionInfo) => resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile, resolutionInfo);
|
|
compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? (...args) => host.resolveTypeReferenceDirectives(...args) : (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) => resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
|
|
compilerHost.getModuleResolutionCache = host.resolveModuleNames ? maybeBind(host, host.getModuleResolutionCache) : () => resolutionCache.getModuleResolutionCache();
|
|
const userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives;
|
|
const customHasInvalidatedResolutions = userProvidedResolution ? maybeBind(host, host.hasInvalidatedResolutions) || returnTrue : returnFalse;
|
|
builderProgram = readBuilderProgram(compilerOptions, compilerHost);
|
|
synchronizeProgram();
|
|
watchConfigFileWildCardDirectories();
|
|
if (configFileName)
|
|
updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
|
|
return configFileName ? { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close: close2 } : { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames, close: close2 };
|
|
function close2() {
|
|
clearInvalidateResolutionsOfFailedLookupLocations();
|
|
resolutionCache.clear();
|
|
clearMap(sourceFilesCache, (value) => {
|
|
if (value && value.fileWatcher) {
|
|
value.fileWatcher.close();
|
|
value.fileWatcher = void 0;
|
|
}
|
|
});
|
|
if (configFileWatcher) {
|
|
configFileWatcher.close();
|
|
configFileWatcher = void 0;
|
|
}
|
|
extendedConfigCache == null ? void 0 : extendedConfigCache.clear();
|
|
extendedConfigCache = void 0;
|
|
if (sharedExtendedConfigFileWatchers) {
|
|
clearMap(sharedExtendedConfigFileWatchers, closeFileWatcherOf);
|
|
sharedExtendedConfigFileWatchers = void 0;
|
|
}
|
|
if (watchedWildcardDirectories) {
|
|
clearMap(watchedWildcardDirectories, closeFileWatcherOf);
|
|
watchedWildcardDirectories = void 0;
|
|
}
|
|
if (missingFilesMap) {
|
|
clearMap(missingFilesMap, closeFileWatcher);
|
|
missingFilesMap = void 0;
|
|
}
|
|
if (parsedConfigs) {
|
|
clearMap(parsedConfigs, (config) => {
|
|
var _a2;
|
|
(_a2 = config.watcher) == null ? void 0 : _a2.close();
|
|
config.watcher = void 0;
|
|
if (config.watchedDirectories)
|
|
clearMap(config.watchedDirectories, closeFileWatcherOf);
|
|
config.watchedDirectories = void 0;
|
|
});
|
|
parsedConfigs = void 0;
|
|
}
|
|
}
|
|
function getCurrentBuilderProgram() {
|
|
return builderProgram;
|
|
}
|
|
function getCurrentProgram() {
|
|
return builderProgram && builderProgram.getProgramOrUndefined();
|
|
}
|
|
function synchronizeProgram() {
|
|
writeLog(`Synchronizing program`);
|
|
clearInvalidateResolutionsOfFailedLookupLocations();
|
|
const program = getCurrentBuilderProgram();
|
|
if (hasChangedCompilerOptions) {
|
|
newLine = updateNewLine();
|
|
if (program && changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) {
|
|
resolutionCache.clear();
|
|
}
|
|
}
|
|
const hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions);
|
|
const {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile
|
|
} = changeCompilerHostLikeToUseCache(compilerHost, toPath3);
|
|
if (isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
|
|
if (hasChangedConfigFileParsingErrors) {
|
|
if (reportFileChangeDetectedOnCreateProgram) {
|
|
reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
|
|
}
|
|
builderProgram = createProgram2(void 0, void 0, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
|
|
hasChangedConfigFileParsingErrors = false;
|
|
}
|
|
} else {
|
|
if (reportFileChangeDetectedOnCreateProgram) {
|
|
reportWatchDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation);
|
|
}
|
|
createNewProgram(hasInvalidatedResolutions);
|
|
}
|
|
reportFileChangeDetectedOnCreateProgram = false;
|
|
if (host.afterProgramCreate && program !== builderProgram) {
|
|
host.afterProgramCreate(builderProgram);
|
|
}
|
|
compilerHost.readFile = originalReadFile;
|
|
compilerHost.fileExists = originalFileExists;
|
|
compilerHost.directoryExists = originalDirectoryExists;
|
|
compilerHost.createDirectory = originalCreateDirectory;
|
|
compilerHost.writeFile = originalWriteFile;
|
|
return builderProgram;
|
|
}
|
|
function createNewProgram(hasInvalidatedResolutions) {
|
|
writeLog("CreatingProgramWith::");
|
|
writeLog(` roots: ${JSON.stringify(rootFileNames)}`);
|
|
writeLog(` options: ${JSON.stringify(compilerOptions)}`);
|
|
if (projectReferences)
|
|
writeLog(` projectReferences: ${JSON.stringify(projectReferences)}`);
|
|
const needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram();
|
|
hasChangedCompilerOptions = false;
|
|
hasChangedConfigFileParsingErrors = false;
|
|
resolutionCache.startCachingPerDirectoryResolution();
|
|
compilerHost.hasInvalidatedResolutions = hasInvalidatedResolutions;
|
|
compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames;
|
|
const oldProgram = getCurrentProgram();
|
|
builderProgram = createProgram2(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
|
|
resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram);
|
|
updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = /* @__PURE__ */ new Map()), watchMissingFilePath);
|
|
if (needsUpdateInTypeRootWatch) {
|
|
resolutionCache.updateTypeRootsWatch();
|
|
}
|
|
if (missingFilePathsRequestedForRelease) {
|
|
for (const missingFilePath of missingFilePathsRequestedForRelease) {
|
|
if (!missingFilesMap.has(missingFilePath)) {
|
|
sourceFilesCache.delete(missingFilePath);
|
|
}
|
|
}
|
|
missingFilePathsRequestedForRelease = void 0;
|
|
}
|
|
}
|
|
function updateRootFileNames(files) {
|
|
Debug.assert(!configFileName, "Cannot update root file names with config file watch mode");
|
|
rootFileNames = files;
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateNewLine() {
|
|
return getNewLineCharacter(compilerOptions || optionsToExtendForConfigFile, () => host.getNewLine());
|
|
}
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function isFileMissingOnHost(hostSourceFile) {
|
|
return typeof hostSourceFile === "boolean";
|
|
}
|
|
function isFilePresenceUnknownOnHost(hostSourceFile) {
|
|
return typeof hostSourceFile.version === "boolean";
|
|
}
|
|
function fileExists(fileName) {
|
|
const path = toPath3(fileName);
|
|
if (isFileMissingOnHost(sourceFilesCache.get(path))) {
|
|
return false;
|
|
}
|
|
return directoryStructureHost.fileExists(fileName);
|
|
}
|
|
function getVersionedSourceFileByPath(fileName, path, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
if (isFileMissingOnHost(hostSourceFile)) {
|
|
return void 0;
|
|
}
|
|
if (hostSourceFile === void 0 || shouldCreateNewSourceFile || isFilePresenceUnknownOnHost(hostSourceFile)) {
|
|
const sourceFile = getNewSourceFile(fileName, languageVersionOrOptions, onError);
|
|
if (hostSourceFile) {
|
|
if (sourceFile) {
|
|
hostSourceFile.sourceFile = sourceFile;
|
|
hostSourceFile.version = sourceFile.version;
|
|
if (!hostSourceFile.fileWatcher) {
|
|
hostSourceFile.fileWatcher = watchFilePath(path, fileName, onSourceFileChange, 250 /* Low */, watchOptions, WatchType.SourceFile);
|
|
}
|
|
} else {
|
|
if (hostSourceFile.fileWatcher) {
|
|
hostSourceFile.fileWatcher.close();
|
|
}
|
|
sourceFilesCache.set(path, false);
|
|
}
|
|
} else {
|
|
if (sourceFile) {
|
|
const fileWatcher = watchFilePath(path, fileName, onSourceFileChange, 250 /* Low */, watchOptions, WatchType.SourceFile);
|
|
sourceFilesCache.set(path, { sourceFile, version: sourceFile.version, fileWatcher });
|
|
} else {
|
|
sourceFilesCache.set(path, false);
|
|
}
|
|
}
|
|
return sourceFile;
|
|
}
|
|
return hostSourceFile.sourceFile;
|
|
}
|
|
function nextSourceFileVersion(path) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
if (hostSourceFile !== void 0) {
|
|
if (isFileMissingOnHost(hostSourceFile)) {
|
|
sourceFilesCache.set(path, { version: false });
|
|
} else {
|
|
hostSourceFile.version = false;
|
|
}
|
|
}
|
|
}
|
|
function getSourceVersion(path) {
|
|
const hostSourceFile = sourceFilesCache.get(path);
|
|
return !hostSourceFile || !hostSourceFile.version ? void 0 : hostSourceFile.version;
|
|
}
|
|
function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) {
|
|
const hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath);
|
|
if (hostSourceFileInfo !== void 0) {
|
|
if (isFileMissingOnHost(hostSourceFileInfo)) {
|
|
(missingFilePathsRequestedForRelease || (missingFilePathsRequestedForRelease = [])).push(oldSourceFile.path);
|
|
} else if (hostSourceFileInfo.sourceFile === oldSourceFile) {
|
|
if (hostSourceFileInfo.fileWatcher) {
|
|
hostSourceFileInfo.fileWatcher.close();
|
|
}
|
|
sourceFilesCache.delete(oldSourceFile.resolvedPath);
|
|
if (!hasSourceFileByPath) {
|
|
resolutionCache.removeResolutionsOfFile(oldSourceFile.path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function reportWatchDiagnostic(message) {
|
|
if (host.onWatchStatusChange) {
|
|
host.onWatchStatusChange(createCompilerDiagnostic(message), newLine, compilerOptions || optionsToExtendForConfigFile);
|
|
}
|
|
}
|
|
function hasChangedAutomaticTypeDirectiveNames() {
|
|
return resolutionCache.hasChangedAutomaticTypeDirectiveNames();
|
|
}
|
|
function clearInvalidateResolutionsOfFailedLookupLocations() {
|
|
if (!timerToInvalidateFailedLookupResolutions)
|
|
return false;
|
|
host.clearTimeout(timerToInvalidateFailedLookupResolutions);
|
|
timerToInvalidateFailedLookupResolutions = void 0;
|
|
return true;
|
|
}
|
|
function scheduleInvalidateResolutionsOfFailedLookupLocations() {
|
|
if (!host.setTimeout || !host.clearTimeout) {
|
|
return resolutionCache.invalidateResolutionsOfFailedLookupLocations();
|
|
}
|
|
const pending = clearInvalidateResolutionsOfFailedLookupLocations();
|
|
writeLog(`Scheduling invalidateFailedLookup${pending ? ", Cancelled earlier one" : ""}`);
|
|
timerToInvalidateFailedLookupResolutions = host.setTimeout(invalidateResolutionsOfFailedLookup, 250);
|
|
}
|
|
function invalidateResolutionsOfFailedLookup() {
|
|
timerToInvalidateFailedLookupResolutions = void 0;
|
|
if (resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {
|
|
scheduleProgramUpdate();
|
|
}
|
|
}
|
|
function scheduleProgramUpdate() {
|
|
if (!host.setTimeout || !host.clearTimeout) {
|
|
return;
|
|
}
|
|
if (timerToUpdateProgram) {
|
|
host.clearTimeout(timerToUpdateProgram);
|
|
}
|
|
writeLog("Scheduling update");
|
|
timerToUpdateProgram = host.setTimeout(updateProgramWithWatchStatus, 250);
|
|
}
|
|
function scheduleProgramReload() {
|
|
Debug.assert(!!configFileName);
|
|
reloadLevel = 2 /* Full */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateProgramWithWatchStatus() {
|
|
timerToUpdateProgram = void 0;
|
|
reportFileChangeDetectedOnCreateProgram = true;
|
|
updateProgram();
|
|
}
|
|
function updateProgram() {
|
|
switch (reloadLevel) {
|
|
case 1 /* Partial */:
|
|
perfLogger.logStartUpdateProgram("PartialConfigReload");
|
|
reloadFileNamesFromConfigFile();
|
|
break;
|
|
case 2 /* Full */:
|
|
perfLogger.logStartUpdateProgram("FullConfigReload");
|
|
reloadConfigFile();
|
|
break;
|
|
default:
|
|
perfLogger.logStartUpdateProgram("SynchronizeProgram");
|
|
synchronizeProgram();
|
|
break;
|
|
}
|
|
perfLogger.logStopUpdateProgram("Done");
|
|
return getCurrentBuilderProgram();
|
|
}
|
|
function reloadFileNamesFromConfigFile() {
|
|
writeLog("Reloading new file names and options");
|
|
reloadLevel = 0 /* None */;
|
|
rootFileNames = getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions);
|
|
if (updateErrorForNoInputFiles(rootFileNames, getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) {
|
|
hasChangedConfigFileParsingErrors = true;
|
|
}
|
|
synchronizeProgram();
|
|
}
|
|
function reloadConfigFile() {
|
|
writeLog(`Reloading config file: ${configFileName}`);
|
|
reloadLevel = 0 /* None */;
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.clearCache();
|
|
}
|
|
parseConfigFile2();
|
|
hasChangedCompilerOptions = true;
|
|
synchronizeProgram();
|
|
watchConfigFileWildCardDirectories();
|
|
updateExtendedConfigFilesWatches(toPath3(configFileName), compilerOptions, watchOptions, WatchType.ExtendedConfigFile);
|
|
}
|
|
function parseConfigFile2() {
|
|
setConfigFileParsingResult(getParsedCommandLineOfConfigFile(
|
|
configFileName,
|
|
optionsToExtendForConfigFile,
|
|
parseConfigFileHost,
|
|
extendedConfigCache || (extendedConfigCache = /* @__PURE__ */ new Map()),
|
|
watchOptionsToExtend,
|
|
extraFileExtensions
|
|
));
|
|
}
|
|
function setConfigFileParsingResult(configFileParseResult) {
|
|
rootFileNames = configFileParseResult.fileNames;
|
|
compilerOptions = configFileParseResult.options;
|
|
watchOptions = configFileParseResult.watchOptions;
|
|
projectReferences = configFileParseResult.projectReferences;
|
|
wildcardDirectories = configFileParseResult.wildcardDirectories;
|
|
configFileParsingDiagnostics = getConfigFileParsingDiagnostics(configFileParseResult).slice();
|
|
canConfigFileJsonReportNoInputFiles = canJsonReportNoInputFiles(configFileParseResult.raw);
|
|
hasChangedConfigFileParsingErrors = true;
|
|
}
|
|
function getParsedCommandLine(configFileName2) {
|
|
const configPath = toPath3(configFileName2);
|
|
let config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (config) {
|
|
if (!config.reloadLevel)
|
|
return config.parsedCommandLine;
|
|
if (config.parsedCommandLine && config.reloadLevel === 1 /* Partial */ && !host.getParsedCommandLine) {
|
|
writeLog("Reloading new file names and options");
|
|
const fileNames = getFileNamesFromConfigSpecs(
|
|
config.parsedCommandLine.options.configFile.configFileSpecs,
|
|
getNormalizedAbsolutePath(getDirectoryPath(configFileName2), currentDirectory),
|
|
compilerOptions,
|
|
parseConfigFileHost
|
|
);
|
|
config.parsedCommandLine = { ...config.parsedCommandLine, fileNames };
|
|
config.reloadLevel = void 0;
|
|
return config.parsedCommandLine;
|
|
}
|
|
}
|
|
writeLog(`Loading config file: ${configFileName2}`);
|
|
const parsedCommandLine = host.getParsedCommandLine ? host.getParsedCommandLine(configFileName2) : getParsedCommandLineFromConfigFileHost(configFileName2);
|
|
if (config) {
|
|
config.parsedCommandLine = parsedCommandLine;
|
|
config.reloadLevel = void 0;
|
|
} else {
|
|
(parsedConfigs || (parsedConfigs = /* @__PURE__ */ new Map())).set(configPath, config = { parsedCommandLine });
|
|
}
|
|
watchReferencedProject(configFileName2, configPath, config);
|
|
return parsedCommandLine;
|
|
}
|
|
function getParsedCommandLineFromConfigFileHost(configFileName2) {
|
|
const onUnRecoverableConfigFileDiagnostic = parseConfigFileHost.onUnRecoverableConfigFileDiagnostic;
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = noop;
|
|
const parsedCommandLine = getParsedCommandLineOfConfigFile(
|
|
configFileName2,
|
|
void 0,
|
|
parseConfigFileHost,
|
|
extendedConfigCache || (extendedConfigCache = /* @__PURE__ */ new Map()),
|
|
watchOptionsToExtend
|
|
);
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = onUnRecoverableConfigFileDiagnostic;
|
|
return parsedCommandLine;
|
|
}
|
|
function onReleaseParsedCommandLine(fileName) {
|
|
var _a2;
|
|
const path = toPath3(fileName);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(path);
|
|
if (!config)
|
|
return;
|
|
parsedConfigs.delete(path);
|
|
if (config.watchedDirectories)
|
|
clearMap(config.watchedDirectories, closeFileWatcherOf);
|
|
(_a2 = config.watcher) == null ? void 0 : _a2.close();
|
|
clearSharedExtendedConfigFileWatcher(path, sharedExtendedConfigFileWatchers);
|
|
}
|
|
function watchFilePath(path, file, callback, pollingInterval, options, watchType) {
|
|
return watchFile2(file, (fileName, eventKind) => callback(fileName, eventKind, path), pollingInterval, options, watchType);
|
|
}
|
|
function onSourceFileChange(fileName, eventKind, path) {
|
|
updateCachedSystemWithFile(fileName, path, eventKind);
|
|
if (eventKind === 2 /* Deleted */ && sourceFilesCache.has(path)) {
|
|
resolutionCache.invalidateResolutionOfFile(path);
|
|
}
|
|
nextSourceFileVersion(path);
|
|
scheduleProgramUpdate();
|
|
}
|
|
function updateCachedSystemWithFile(fileName, path, eventKind) {
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind);
|
|
}
|
|
}
|
|
function watchMissingFilePath(missingFilePath) {
|
|
return (parsedConfigs == null ? void 0 : parsedConfigs.has(missingFilePath)) ? noopFileWatcher : watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, 500 /* Medium */, watchOptions, WatchType.MissingFile);
|
|
}
|
|
function onMissingFileChange(fileName, eventKind, missingFilePath) {
|
|
updateCachedSystemWithFile(fileName, missingFilePath, eventKind);
|
|
if (eventKind === 0 /* Created */ && missingFilesMap.has(missingFilePath)) {
|
|
missingFilesMap.get(missingFilePath).close();
|
|
missingFilesMap.delete(missingFilePath);
|
|
nextSourceFileVersion(missingFilePath);
|
|
scheduleProgramUpdate();
|
|
}
|
|
}
|
|
function watchConfigFileWildCardDirectories() {
|
|
if (wildcardDirectories) {
|
|
updateWatchingWildcardDirectories(
|
|
watchedWildcardDirectories || (watchedWildcardDirectories = /* @__PURE__ */ new Map()),
|
|
new Map(getEntries(wildcardDirectories)),
|
|
watchWildcardDirectory
|
|
);
|
|
} else if (watchedWildcardDirectories) {
|
|
clearMap(watchedWildcardDirectories, closeFileWatcherOf);
|
|
}
|
|
}
|
|
function watchWildcardDirectory(directory, flags) {
|
|
return watchDirectory(
|
|
directory,
|
|
(fileOrDirectory) => {
|
|
Debug.assert(!!configFileName);
|
|
const fileOrDirectoryPath = toPath3(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
nextSourceFileVersion(fileOrDirectoryPath);
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath3(directory),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName,
|
|
extraFileExtensions,
|
|
options: compilerOptions,
|
|
program: getCurrentBuilderProgram() || rootFileNames,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}))
|
|
return;
|
|
if (reloadLevel !== 2 /* Full */) {
|
|
reloadLevel = 1 /* Partial */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
},
|
|
flags,
|
|
watchOptions,
|
|
WatchType.WildcardDirectory
|
|
);
|
|
}
|
|
function updateExtendedConfigFilesWatches(forProjectPath, options, watchOptions2, watchType) {
|
|
updateSharedExtendedConfigFileWatcher(
|
|
forProjectPath,
|
|
options,
|
|
sharedExtendedConfigFileWatchers || (sharedExtendedConfigFileWatchers = /* @__PURE__ */ new Map()),
|
|
(extendedConfigFileName, extendedConfigFilePath) => watchFile2(
|
|
extendedConfigFileName,
|
|
(_fileName, eventKind) => {
|
|
var _a2;
|
|
updateCachedSystemWithFile(extendedConfigFileName, extendedConfigFilePath, eventKind);
|
|
if (extendedConfigCache)
|
|
cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath3);
|
|
const projects = (_a2 = sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a2.projects;
|
|
if (!(projects == null ? void 0 : projects.size))
|
|
return;
|
|
projects.forEach((projectPath) => {
|
|
if (toPath3(configFileName) === projectPath) {
|
|
reloadLevel = 2 /* Full */;
|
|
} else {
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(projectPath);
|
|
if (config)
|
|
config.reloadLevel = 2 /* Full */;
|
|
resolutionCache.removeResolutionsFromProjectReferenceRedirects(projectPath);
|
|
}
|
|
scheduleProgramUpdate();
|
|
});
|
|
},
|
|
2e3 /* High */,
|
|
watchOptions2,
|
|
watchType
|
|
),
|
|
toPath3
|
|
);
|
|
}
|
|
function watchReferencedProject(configFileName2, configPath, commandLine) {
|
|
var _a2, _b, _c, _d, _e;
|
|
commandLine.watcher || (commandLine.watcher = watchFile2(
|
|
configFileName2,
|
|
(_fileName, eventKind) => {
|
|
updateCachedSystemWithFile(configFileName2, configPath, eventKind);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (config)
|
|
config.reloadLevel = 2 /* Full */;
|
|
resolutionCache.removeResolutionsFromProjectReferenceRedirects(configPath);
|
|
scheduleProgramUpdate();
|
|
},
|
|
2e3 /* High */,
|
|
((_a2 = commandLine.parsedCommandLine) == null ? void 0 : _a2.watchOptions) || watchOptions,
|
|
WatchType.ConfigFileOfReferencedProject
|
|
));
|
|
if ((_b = commandLine.parsedCommandLine) == null ? void 0 : _b.wildcardDirectories) {
|
|
updateWatchingWildcardDirectories(
|
|
commandLine.watchedDirectories || (commandLine.watchedDirectories = /* @__PURE__ */ new Map()),
|
|
new Map(getEntries((_c = commandLine.parsedCommandLine) == null ? void 0 : _c.wildcardDirectories)),
|
|
(directory, flags) => {
|
|
var _a3;
|
|
return watchDirectory(
|
|
directory,
|
|
(fileOrDirectory) => {
|
|
const fileOrDirectoryPath = toPath3(fileOrDirectory);
|
|
if (cachedDirectoryStructureHost) {
|
|
cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
}
|
|
nextSourceFileVersion(fileOrDirectoryPath);
|
|
const config = parsedConfigs == null ? void 0 : parsedConfigs.get(configPath);
|
|
if (!(config == null ? void 0 : config.parsedCommandLine))
|
|
return;
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath3(directory),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName: configFileName2,
|
|
options: config.parsedCommandLine.options,
|
|
program: config.parsedCommandLine.fileNames,
|
|
currentDirectory,
|
|
useCaseSensitiveFileNames,
|
|
writeLog,
|
|
toPath: toPath3
|
|
}))
|
|
return;
|
|
if (config.reloadLevel !== 2 /* Full */) {
|
|
config.reloadLevel = 1 /* Partial */;
|
|
scheduleProgramUpdate();
|
|
}
|
|
},
|
|
flags,
|
|
((_a3 = commandLine.parsedCommandLine) == null ? void 0 : _a3.watchOptions) || watchOptions,
|
|
WatchType.WildcardDirectoryOfReferencedProject
|
|
);
|
|
}
|
|
);
|
|
} else if (commandLine.watchedDirectories) {
|
|
clearMap(commandLine.watchedDirectories, closeFileWatcherOf);
|
|
commandLine.watchedDirectories = void 0;
|
|
}
|
|
updateExtendedConfigFilesWatches(
|
|
configPath,
|
|
(_d = commandLine.parsedCommandLine) == null ? void 0 : _d.options,
|
|
((_e = commandLine.parsedCommandLine) == null ? void 0 : _e.watchOptions) || watchOptions,
|
|
WatchType.ExtendedConfigOfReferencedProject
|
|
);
|
|
}
|
|
}
|
|
|
|
// src/compiler/tsbuild.ts
|
|
var UpToDateStatusType = /* @__PURE__ */ ((UpToDateStatusType2) => {
|
|
UpToDateStatusType2[UpToDateStatusType2["Unbuildable"] = 0] = "Unbuildable";
|
|
UpToDateStatusType2[UpToDateStatusType2["UpToDate"] = 1] = "UpToDate";
|
|
UpToDateStatusType2[UpToDateStatusType2["UpToDateWithUpstreamTypes"] = 2] = "UpToDateWithUpstreamTypes";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutOfDateWithPrepend"] = 3] = "OutOfDateWithPrepend";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutputMissing"] = 4] = "OutputMissing";
|
|
UpToDateStatusType2[UpToDateStatusType2["ErrorReadingFile"] = 5] = "ErrorReadingFile";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutOfDateWithSelf"] = 6] = "OutOfDateWithSelf";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutOfDateWithUpstream"] = 7] = "OutOfDateWithUpstream";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutOfDateBuildInfo"] = 8] = "OutOfDateBuildInfo";
|
|
UpToDateStatusType2[UpToDateStatusType2["OutOfDateOptions"] = 9] = "OutOfDateOptions";
|
|
UpToDateStatusType2[UpToDateStatusType2["UpstreamOutOfDate"] = 10] = "UpstreamOutOfDate";
|
|
UpToDateStatusType2[UpToDateStatusType2["UpstreamBlocked"] = 11] = "UpstreamBlocked";
|
|
UpToDateStatusType2[UpToDateStatusType2["ComputingUpstream"] = 12] = "ComputingUpstream";
|
|
UpToDateStatusType2[UpToDateStatusType2["TsVersionOutputOfDate"] = 13] = "TsVersionOutputOfDate";
|
|
UpToDateStatusType2[UpToDateStatusType2["UpToDateWithInputFileText"] = 14] = "UpToDateWithInputFileText";
|
|
UpToDateStatusType2[UpToDateStatusType2["ContainerOnly"] = 15] = "ContainerOnly";
|
|
UpToDateStatusType2[UpToDateStatusType2["ForceBuild"] = 16] = "ForceBuild";
|
|
return UpToDateStatusType2;
|
|
})(UpToDateStatusType || {});
|
|
function resolveConfigFileProjectName(project) {
|
|
if (fileExtensionIs(project, ".json" /* Json */)) {
|
|
return project;
|
|
}
|
|
return combinePaths(project, "tsconfig.json");
|
|
}
|
|
|
|
// src/compiler/tsbuildPublic.ts
|
|
var minimumDate = new Date(-864e13);
|
|
var maximumDate = new Date(864e13);
|
|
function getOrCreateValueFromConfigFileMap(configFileMap, resolved, createT) {
|
|
const existingValue = configFileMap.get(resolved);
|
|
let newValue;
|
|
if (!existingValue) {
|
|
newValue = createT();
|
|
configFileMap.set(resolved, newValue);
|
|
}
|
|
return existingValue || newValue;
|
|
}
|
|
function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) {
|
|
return getOrCreateValueFromConfigFileMap(configFileMap, resolved, () => /* @__PURE__ */ new Map());
|
|
}
|
|
function getCurrentTime(host) {
|
|
return host.now ? host.now() : new Date();
|
|
}
|
|
function isCircularBuildOrder(buildOrder) {
|
|
return !!buildOrder && !!buildOrder.buildOrder;
|
|
}
|
|
function getBuildOrderFromAnyBuildOrder(anyBuildOrder) {
|
|
return isCircularBuildOrder(anyBuildOrder) ? anyBuildOrder.buildOrder : anyBuildOrder;
|
|
}
|
|
function createBuilderStatusReporter(system, pretty) {
|
|
return (diagnostic) => {
|
|
let output = pretty ? `[${formatColorAndReset(getLocaleTimeString(system), "\x1B[90m" /* Grey */)}] ` : `${getLocaleTimeString(system)} - `;
|
|
output += `${flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)}${system.newLine + system.newLine}`;
|
|
system.write(output);
|
|
};
|
|
}
|
|
function createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus) {
|
|
const host = createProgramHost(system, createProgram2);
|
|
host.getModifiedTime = system.getModifiedTime ? (path) => system.getModifiedTime(path) : returnUndefined;
|
|
host.setModifiedTime = system.setModifiedTime ? (path, date) => system.setModifiedTime(path, date) : noop;
|
|
host.deleteFile = system.deleteFile ? (path) => system.deleteFile(path) : noop;
|
|
host.reportDiagnostic = reportDiagnostic || createDiagnosticReporter(system);
|
|
host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system);
|
|
host.now = maybeBind(system, system.now);
|
|
return host;
|
|
}
|
|
function createSolutionBuilderHost(system = sys, createProgram2, reportDiagnostic, reportSolutionBuilderStatus, reportErrorSummary2) {
|
|
const host = createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus);
|
|
host.reportErrorSummary = reportErrorSummary2;
|
|
return host;
|
|
}
|
|
function createSolutionBuilderWithWatchHost(system = sys, createProgram2, reportDiagnostic, reportSolutionBuilderStatus, reportWatchStatus2) {
|
|
const host = createSolutionBuilderHostBase(system, createProgram2, reportDiagnostic, reportSolutionBuilderStatus);
|
|
const watchHost = createWatchHost(system, reportWatchStatus2);
|
|
copyProperties(host, watchHost);
|
|
return host;
|
|
}
|
|
function getCompilerOptionsOfBuildOptions(buildOptions) {
|
|
const result = {};
|
|
commonOptionsWithBuild.forEach((option) => {
|
|
if (hasProperty(buildOptions, option.name))
|
|
result[option.name] = buildOptions[option.name];
|
|
});
|
|
return result;
|
|
}
|
|
function createSolutionBuilder(host, rootNames, defaultOptions) {
|
|
return createSolutionBuilderWorker(false, host, rootNames, defaultOptions);
|
|
}
|
|
function createSolutionBuilderWithWatch(host, rootNames, defaultOptions, baseWatchOptions) {
|
|
return createSolutionBuilderWorker(true, host, rootNames, defaultOptions, baseWatchOptions);
|
|
}
|
|
function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) {
|
|
const host = hostOrHostWithWatch;
|
|
const hostWithWatch = hostOrHostWithWatch;
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
const baseCompilerOptions = getCompilerOptionsOfBuildOptions(options);
|
|
const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);
|
|
setGetSourceFileAsHashVersioned(compilerHost, host);
|
|
compilerHost.getParsedCommandLine = (fileName) => parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName));
|
|
compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
|
|
compilerHost.resolveTypeReferenceDirectives = maybeBind(host, host.resolveTypeReferenceDirectives);
|
|
compilerHost.getModuleResolutionCache = maybeBind(host, host.getModuleResolutionCache);
|
|
const moduleResolutionCache = !compilerHost.resolveModuleNames ? createModuleResolutionCache(currentDirectory, getCanonicalFileName) : void 0;
|
|
const typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, void 0, moduleResolutionCache == null ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : void 0;
|
|
if (!compilerHost.resolveModuleNames) {
|
|
const loader = (moduleName, resolverMode, containingFile, redirectedReference) => resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule;
|
|
compilerHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) => loadWithModeAwareCache(Debug.checkEachDefined(moduleNames), Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, resolutionInfo, loader);
|
|
compilerHost.getModuleResolutionCache = () => moduleResolutionCache;
|
|
}
|
|
if (!compilerHost.resolveTypeReferenceDirectives) {
|
|
const loader = (moduleName, containingFile, redirectedReference, containingFileMode) => resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective;
|
|
compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) => loadWithTypeDirectiveCache(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
|
|
}
|
|
compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo3(state, fileName, toResolvedConfigFilePath(state, configFilePath), void 0);
|
|
const { watchFile: watchFile2, watchDirectory, writeLog } = createWatchFactory(hostWithWatch, options);
|
|
const state = {
|
|
host,
|
|
hostWithWatch,
|
|
currentDirectory,
|
|
getCanonicalFileName,
|
|
parseConfigFileHost: parseConfigHostFromCompilerHostLike(host),
|
|
write: maybeBind(host, host.trace),
|
|
options,
|
|
baseCompilerOptions,
|
|
rootNames,
|
|
baseWatchOptions,
|
|
resolvedConfigFilePaths: /* @__PURE__ */ new Map(),
|
|
configFileCache: /* @__PURE__ */ new Map(),
|
|
projectStatus: /* @__PURE__ */ new Map(),
|
|
extendedConfigCache: /* @__PURE__ */ new Map(),
|
|
buildInfoCache: /* @__PURE__ */ new Map(),
|
|
outputTimeStamps: /* @__PURE__ */ new Map(),
|
|
builderPrograms: /* @__PURE__ */ new Map(),
|
|
diagnostics: /* @__PURE__ */ new Map(),
|
|
projectPendingBuild: /* @__PURE__ */ new Map(),
|
|
projectErrorsReported: /* @__PURE__ */ new Map(),
|
|
compilerHost,
|
|
moduleResolutionCache,
|
|
typeReferenceDirectiveResolutionCache,
|
|
buildOrder: void 0,
|
|
readFileWithCache: (f) => host.readFile(f),
|
|
projectCompilerOptions: baseCompilerOptions,
|
|
cache: void 0,
|
|
allProjectBuildPending: true,
|
|
needsSummary: true,
|
|
watchAllProjectsPending: watch,
|
|
watch,
|
|
allWatchedWildcardDirectories: /* @__PURE__ */ new Map(),
|
|
allWatchedInputFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedConfigFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedExtendedConfigFiles: /* @__PURE__ */ new Map(),
|
|
allWatchedPackageJsonFiles: /* @__PURE__ */ new Map(),
|
|
filesWatched: /* @__PURE__ */ new Map(),
|
|
lastCachedPackageJsonLookups: /* @__PURE__ */ new Map(),
|
|
timerToBuildInvalidatedProject: void 0,
|
|
reportFileChangeDetected: false,
|
|
watchFile: watchFile2,
|
|
watchDirectory,
|
|
writeLog
|
|
};
|
|
return state;
|
|
}
|
|
function toPath2(state, fileName) {
|
|
return toPath(fileName, state.currentDirectory, state.getCanonicalFileName);
|
|
}
|
|
function toResolvedConfigFilePath(state, fileName) {
|
|
const { resolvedConfigFilePaths } = state;
|
|
const path = resolvedConfigFilePaths.get(fileName);
|
|
if (path !== void 0)
|
|
return path;
|
|
const resolvedPath = toPath2(state, fileName);
|
|
resolvedConfigFilePaths.set(fileName, resolvedPath);
|
|
return resolvedPath;
|
|
}
|
|
function isParsedCommandLine(entry) {
|
|
return !!entry.options;
|
|
}
|
|
function getCachedParsedConfigFile(state, configFilePath) {
|
|
const value = state.configFileCache.get(configFilePath);
|
|
return value && isParsedCommandLine(value) ? value : void 0;
|
|
}
|
|
function parseConfigFile(state, configFileName, configFilePath) {
|
|
const { configFileCache } = state;
|
|
const value = configFileCache.get(configFilePath);
|
|
if (value) {
|
|
return isParsedCommandLine(value) ? value : void 0;
|
|
}
|
|
mark("SolutionBuilder::beforeConfigFileParsing");
|
|
let diagnostic;
|
|
const { parseConfigFileHost, baseCompilerOptions, baseWatchOptions, extendedConfigCache, host } = state;
|
|
let parsed;
|
|
if (host.getParsedCommandLine) {
|
|
parsed = host.getParsedCommandLine(configFileName);
|
|
if (!parsed)
|
|
diagnostic = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);
|
|
} else {
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = (d) => diagnostic = d;
|
|
parsed = getParsedCommandLineOfConfigFile(configFileName, baseCompilerOptions, parseConfigFileHost, extendedConfigCache, baseWatchOptions);
|
|
parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = noop;
|
|
}
|
|
configFileCache.set(configFilePath, parsed || diagnostic);
|
|
mark("SolutionBuilder::afterConfigFileParsing");
|
|
measure("SolutionBuilder::Config file parsing", "SolutionBuilder::beforeConfigFileParsing", "SolutionBuilder::afterConfigFileParsing");
|
|
return parsed;
|
|
}
|
|
function resolveProjectName(state, name) {
|
|
return resolveConfigFileProjectName(resolvePath(state.currentDirectory, name));
|
|
}
|
|
function createBuildOrder(state, roots) {
|
|
const temporaryMarks = /* @__PURE__ */ new Map();
|
|
const permanentMarks = /* @__PURE__ */ new Map();
|
|
const circularityReportStack = [];
|
|
let buildOrder;
|
|
let circularDiagnostics;
|
|
for (const root of roots) {
|
|
visit(root);
|
|
}
|
|
return circularDiagnostics ? { buildOrder: buildOrder || emptyArray, circularDiagnostics } : buildOrder || emptyArray;
|
|
function visit(configFileName, inCircularContext) {
|
|
const projPath = toResolvedConfigFilePath(state, configFileName);
|
|
if (permanentMarks.has(projPath))
|
|
return;
|
|
if (temporaryMarks.has(projPath)) {
|
|
if (!inCircularContext) {
|
|
(circularDiagnostics || (circularDiagnostics = [])).push(
|
|
createCompilerDiagnostic(
|
|
Diagnostics.Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0,
|
|
circularityReportStack.join("\r\n")
|
|
)
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
temporaryMarks.set(projPath, true);
|
|
circularityReportStack.push(configFileName);
|
|
const parsed = parseConfigFile(state, configFileName, projPath);
|
|
if (parsed && parsed.projectReferences) {
|
|
for (const ref of parsed.projectReferences) {
|
|
const resolvedRefPath = resolveProjectName(state, ref.path);
|
|
visit(resolvedRefPath, inCircularContext || ref.circular);
|
|
}
|
|
}
|
|
circularityReportStack.pop();
|
|
permanentMarks.set(projPath, true);
|
|
(buildOrder || (buildOrder = [])).push(configFileName);
|
|
}
|
|
}
|
|
function getBuildOrder(state) {
|
|
return state.buildOrder || createStateBuildOrder(state);
|
|
}
|
|
function createStateBuildOrder(state) {
|
|
const buildOrder = createBuildOrder(state, state.rootNames.map((f) => resolveProjectName(state, f)));
|
|
state.resolvedConfigFilePaths.clear();
|
|
const currentProjects = new Map(
|
|
getBuildOrderFromAnyBuildOrder(buildOrder).map(
|
|
(resolved) => [toResolvedConfigFilePath(state, resolved), true]
|
|
)
|
|
);
|
|
const noopOnDelete = { onDeleteValue: noop };
|
|
mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
|
|
mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete);
|
|
if (state.watch) {
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedConfigFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: closeFileWatcher }
|
|
);
|
|
state.allWatchedExtendedConfigFiles.forEach((watcher) => {
|
|
watcher.projects.forEach((project) => {
|
|
if (!currentProjects.has(project)) {
|
|
watcher.projects.delete(project);
|
|
}
|
|
});
|
|
watcher.close();
|
|
});
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedWildcardDirectories,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcherOf) }
|
|
);
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedInputFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcher) }
|
|
);
|
|
mutateMapSkippingNewValues(
|
|
state.allWatchedPackageJsonFiles,
|
|
currentProjects,
|
|
{ onDeleteValue: (existingMap) => existingMap.forEach(closeFileWatcher) }
|
|
);
|
|
}
|
|
return state.buildOrder = buildOrder;
|
|
}
|
|
function getBuildOrderFor(state, project, onlyReferences) {
|
|
const resolvedProject = project && resolveProjectName(state, project);
|
|
const buildOrderFromState = getBuildOrder(state);
|
|
if (isCircularBuildOrder(buildOrderFromState))
|
|
return buildOrderFromState;
|
|
if (resolvedProject) {
|
|
const projectPath = toResolvedConfigFilePath(state, resolvedProject);
|
|
const projectIndex = findIndex(
|
|
buildOrderFromState,
|
|
(configFileName) => toResolvedConfigFilePath(state, configFileName) === projectPath
|
|
);
|
|
if (projectIndex === -1)
|
|
return void 0;
|
|
}
|
|
const buildOrder = resolvedProject ? createBuildOrder(state, [resolvedProject]) : buildOrderFromState;
|
|
Debug.assert(!isCircularBuildOrder(buildOrder));
|
|
Debug.assert(!onlyReferences || resolvedProject !== void 0);
|
|
Debug.assert(!onlyReferences || buildOrder[buildOrder.length - 1] === resolvedProject);
|
|
return onlyReferences ? buildOrder.slice(0, buildOrder.length - 1) : buildOrder;
|
|
}
|
|
function enableCache(state) {
|
|
if (state.cache) {
|
|
disableCache(state);
|
|
}
|
|
const { compilerHost, host } = state;
|
|
const originalReadFileWithCache = state.readFileWithCache;
|
|
const originalGetSourceFile = compilerHost.getSourceFile;
|
|
const {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
getSourceFileWithCache,
|
|
readFileWithCache
|
|
} = changeCompilerHostLikeToUseCache(
|
|
host,
|
|
(fileName) => toPath2(state, fileName),
|
|
(...args) => originalGetSourceFile.call(compilerHost, ...args)
|
|
);
|
|
state.readFileWithCache = readFileWithCache;
|
|
compilerHost.getSourceFile = getSourceFileWithCache;
|
|
state.cache = {
|
|
originalReadFile,
|
|
originalFileExists,
|
|
originalDirectoryExists,
|
|
originalCreateDirectory,
|
|
originalWriteFile,
|
|
originalReadFileWithCache,
|
|
originalGetSourceFile
|
|
};
|
|
}
|
|
function disableCache(state) {
|
|
if (!state.cache)
|
|
return;
|
|
const { cache, host, compilerHost, extendedConfigCache, moduleResolutionCache, typeReferenceDirectiveResolutionCache } = state;
|
|
host.readFile = cache.originalReadFile;
|
|
host.fileExists = cache.originalFileExists;
|
|
host.directoryExists = cache.originalDirectoryExists;
|
|
host.createDirectory = cache.originalCreateDirectory;
|
|
host.writeFile = cache.originalWriteFile;
|
|
compilerHost.getSourceFile = cache.originalGetSourceFile;
|
|
state.readFileWithCache = cache.originalReadFileWithCache;
|
|
extendedConfigCache.clear();
|
|
moduleResolutionCache == null ? void 0 : moduleResolutionCache.clear();
|
|
typeReferenceDirectiveResolutionCache == null ? void 0 : typeReferenceDirectiveResolutionCache.clear();
|
|
state.cache = void 0;
|
|
}
|
|
function clearProjectStatus(state, resolved) {
|
|
state.projectStatus.delete(resolved);
|
|
state.diagnostics.delete(resolved);
|
|
}
|
|
function addProjToQueue({ projectPendingBuild }, proj, reloadLevel) {
|
|
const value = projectPendingBuild.get(proj);
|
|
if (value === void 0) {
|
|
projectPendingBuild.set(proj, reloadLevel);
|
|
} else if (value < reloadLevel) {
|
|
projectPendingBuild.set(proj, reloadLevel);
|
|
}
|
|
}
|
|
function setupInitialBuild(state, cancellationToken) {
|
|
if (!state.allProjectBuildPending)
|
|
return;
|
|
state.allProjectBuildPending = false;
|
|
if (state.options.watch)
|
|
reportWatchStatus(state, Diagnostics.Starting_compilation_in_watch_mode);
|
|
enableCache(state);
|
|
const buildOrder = getBuildOrderFromAnyBuildOrder(getBuildOrder(state));
|
|
buildOrder.forEach(
|
|
(configFileName) => state.projectPendingBuild.set(
|
|
toResolvedConfigFilePath(state, configFileName),
|
|
0 /* None */
|
|
)
|
|
);
|
|
if (cancellationToken) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
var InvalidatedProjectKind = /* @__PURE__ */ ((InvalidatedProjectKind2) => {
|
|
InvalidatedProjectKind2[InvalidatedProjectKind2["Build"] = 0] = "Build";
|
|
InvalidatedProjectKind2[InvalidatedProjectKind2["UpdateBundle"] = 1] = "UpdateBundle";
|
|
InvalidatedProjectKind2[InvalidatedProjectKind2["UpdateOutputFileStamps"] = 2] = "UpdateOutputFileStamps";
|
|
return InvalidatedProjectKind2;
|
|
})(InvalidatedProjectKind || {});
|
|
function doneInvalidatedProject(state, projectPath) {
|
|
state.projectPendingBuild.delete(projectPath);
|
|
return state.diagnostics.has(projectPath) ? 1 /* DiagnosticsPresent_OutputsSkipped */ : 0 /* Success */;
|
|
}
|
|
function createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder) {
|
|
let updateOutputFileStampsPending = true;
|
|
return {
|
|
kind: 2 /* UpdateOutputFileStamps */,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
updateOutputFileStatmps: () => {
|
|
updateOutputTimestamps(state, config, projectPath);
|
|
updateOutputFileStampsPending = false;
|
|
},
|
|
done: () => {
|
|
if (updateOutputFileStampsPending) {
|
|
updateOutputTimestamps(state, config, projectPath);
|
|
}
|
|
mark("SolutionBuilder::Timestamps only updates");
|
|
return doneInvalidatedProject(state, projectPath);
|
|
}
|
|
};
|
|
}
|
|
function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath, projectIndex, config, buildOrder) {
|
|
let step = kind === 0 /* Build */ ? 0 /* CreateProgram */ : 4 /* EmitBundle */;
|
|
let program;
|
|
let buildResult;
|
|
let invalidatedProjectOfBundle;
|
|
return kind === 0 /* Build */ ? {
|
|
kind,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
getBuilderProgram: () => withProgramOrUndefined(identity),
|
|
getProgram: () => withProgramOrUndefined(
|
|
(program2) => program2.getProgramOrUndefined()
|
|
),
|
|
getSourceFile: (fileName) => withProgramOrUndefined(
|
|
(program2) => program2.getSourceFile(fileName)
|
|
),
|
|
getSourceFiles: () => withProgramOrEmptyArray(
|
|
(program2) => program2.getSourceFiles()
|
|
),
|
|
getOptionsDiagnostics: (cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getOptionsDiagnostics(cancellationToken)
|
|
),
|
|
getGlobalDiagnostics: (cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getGlobalDiagnostics(cancellationToken)
|
|
),
|
|
getConfigFileParsingDiagnostics: () => withProgramOrEmptyArray(
|
|
(program2) => program2.getConfigFileParsingDiagnostics()
|
|
),
|
|
getSyntacticDiagnostics: (sourceFile, cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getSyntacticDiagnostics(sourceFile, cancellationToken)
|
|
),
|
|
getAllDependencies: (sourceFile) => withProgramOrEmptyArray(
|
|
(program2) => program2.getAllDependencies(sourceFile)
|
|
),
|
|
getSemanticDiagnostics: (sourceFile, cancellationToken) => withProgramOrEmptyArray(
|
|
(program2) => program2.getSemanticDiagnostics(sourceFile, cancellationToken)
|
|
),
|
|
getSemanticDiagnosticsOfNextAffectedFile: (cancellationToken, ignoreSourceFile) => withProgramOrUndefined(
|
|
(program2) => program2.getSemanticDiagnosticsOfNextAffectedFile && program2.getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile)
|
|
),
|
|
emit: (targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
|
|
if (targetSourceFile || emitOnlyDtsFiles) {
|
|
return withProgramOrUndefined(
|
|
(program2) => {
|
|
var _a2, _b;
|
|
return program2.emit(targetSourceFile, writeFile2, cancellationToken, emitOnlyDtsFiles, customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project)));
|
|
}
|
|
);
|
|
}
|
|
executeSteps(2 /* SemanticDiagnostics */, cancellationToken);
|
|
if (step === 5 /* EmitBuildInfo */) {
|
|
return emitBuildInfo(writeFile2, cancellationToken);
|
|
}
|
|
if (step !== 3 /* Emit */)
|
|
return void 0;
|
|
return emit(writeFile2, cancellationToken, customTransformers);
|
|
},
|
|
done
|
|
} : {
|
|
kind,
|
|
project,
|
|
projectPath,
|
|
buildOrder,
|
|
getCompilerOptions: () => config.options,
|
|
getCurrentDirectory: () => state.currentDirectory,
|
|
emit: (writeFile2, customTransformers) => {
|
|
if (step !== 4 /* EmitBundle */)
|
|
return invalidatedProjectOfBundle;
|
|
return emitBundle(writeFile2, customTransformers);
|
|
},
|
|
done
|
|
};
|
|
function done(cancellationToken, writeFile2, customTransformers) {
|
|
executeSteps(8 /* Done */, cancellationToken, writeFile2, customTransformers);
|
|
if (kind === 0 /* Build */)
|
|
mark("SolutionBuilder::Projects built");
|
|
else
|
|
mark("SolutionBuilder::Bundles updated");
|
|
return doneInvalidatedProject(state, projectPath);
|
|
}
|
|
function withProgramOrUndefined(action) {
|
|
executeSteps(0 /* CreateProgram */);
|
|
return program && action(program);
|
|
}
|
|
function withProgramOrEmptyArray(action) {
|
|
return withProgramOrUndefined(action) || emptyArray;
|
|
}
|
|
function createProgram2() {
|
|
var _a2, _b;
|
|
Debug.assert(program === void 0);
|
|
if (state.options.dry) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_build_project_0, project);
|
|
buildResult = 1 /* Success */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return;
|
|
}
|
|
if (state.options.verbose)
|
|
reportStatus(state, Diagnostics.Building_project_0, project);
|
|
if (config.fileNames.length === 0) {
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
buildResult = 0 /* None */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return;
|
|
}
|
|
const { host, compilerHost } = state;
|
|
state.projectCompilerOptions = config.options;
|
|
(_a2 = state.moduleResolutionCache) == null ? void 0 : _a2.update(config.options);
|
|
(_b = state.typeReferenceDirectiveResolutionCache) == null ? void 0 : _b.update(config.options);
|
|
program = host.createProgram(
|
|
config.fileNames,
|
|
config.options,
|
|
compilerHost,
|
|
getOldProgram(state, projectPath, config),
|
|
getConfigFileParsingDiagnostics(config),
|
|
config.projectReferences
|
|
);
|
|
if (state.watch) {
|
|
state.lastCachedPackageJsonLookups.set(projectPath, state.moduleResolutionCache && map(
|
|
state.moduleResolutionCache.getPackageJsonInfoCache().entries(),
|
|
([path, data]) => [state.host.realpath && data ? toPath2(state, state.host.realpath(path)) : path, data]
|
|
));
|
|
state.builderPrograms.set(projectPath, program);
|
|
}
|
|
step++;
|
|
}
|
|
function handleDiagnostics(diagnostics, errorFlags, errorType) {
|
|
if (diagnostics.length) {
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
diagnostics,
|
|
errorFlags,
|
|
errorType
|
|
));
|
|
} else {
|
|
step++;
|
|
}
|
|
}
|
|
function getSyntaxDiagnostics(cancellationToken) {
|
|
Debug.assertIsDefined(program);
|
|
handleDiagnostics(
|
|
[
|
|
...program.getConfigFileParsingDiagnostics(),
|
|
...program.getOptionsDiagnostics(cancellationToken),
|
|
...program.getGlobalDiagnostics(cancellationToken),
|
|
...program.getSyntacticDiagnostics(void 0, cancellationToken)
|
|
],
|
|
8 /* SyntaxErrors */,
|
|
"Syntactic"
|
|
);
|
|
}
|
|
function getSemanticDiagnostics(cancellationToken) {
|
|
handleDiagnostics(
|
|
Debug.checkDefined(program).getSemanticDiagnostics(void 0, cancellationToken),
|
|
16 /* TypeErrors */,
|
|
"Semantic"
|
|
);
|
|
}
|
|
function emit(writeFileCallback, cancellationToken, customTransformers) {
|
|
var _a2, _b, _c;
|
|
Debug.assertIsDefined(program);
|
|
Debug.assert(step === 3 /* Emit */);
|
|
const saved = program.saveEmitState();
|
|
let declDiagnostics;
|
|
const reportDeclarationDiagnostics = (d) => (declDiagnostics || (declDiagnostics = [])).push(d);
|
|
const outputFiles = [];
|
|
const { emitResult } = emitFilesAndReportErrors(
|
|
program,
|
|
reportDeclarationDiagnostics,
|
|
void 0,
|
|
void 0,
|
|
(name, text, writeByteOrderMark, _onError, _sourceFiles, data) => outputFiles.push({ name, text, writeByteOrderMark, data }),
|
|
cancellationToken,
|
|
false,
|
|
customTransformers || ((_b = (_a2 = state.host).getCustomTransformers) == null ? void 0 : _b.call(_a2, project))
|
|
);
|
|
if (declDiagnostics) {
|
|
program.restoreEmitState(saved);
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
declDiagnostics,
|
|
32 /* DeclarationEmitErrors */,
|
|
"Declaration file"
|
|
));
|
|
return {
|
|
emitSkipped: true,
|
|
diagnostics: emitResult.diagnostics
|
|
};
|
|
}
|
|
const { host, compilerHost } = state;
|
|
const resultFlags = ((_c = program.hasChangedEmitSignature) == null ? void 0 : _c.call(program)) ? 0 /* None */ : 2 /* DeclarationOutputUnchanged */;
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const emittedOutputs = /* @__PURE__ */ new Map();
|
|
const options = program.getCompilerOptions();
|
|
const isIncremental = isIncrementalCompilation(options);
|
|
let outputTimeStampMap;
|
|
let now;
|
|
outputFiles.forEach(({ name, text, writeByteOrderMark, data }) => {
|
|
const path = toPath2(state, name);
|
|
emittedOutputs.set(toPath2(state, name), name);
|
|
if (data == null ? void 0 : data.buildInfo)
|
|
setBuildInfo(state, data.buildInfo, projectPath, options, resultFlags);
|
|
const modifiedTime = (data == null ? void 0 : data.differsOnlyInMap) ? getModifiedTime(state.host, name) : void 0;
|
|
writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
|
|
if (data == null ? void 0 : data.differsOnlyInMap)
|
|
state.host.setModifiedTime(name, modifiedTime);
|
|
else if (!isIncremental && state.watch) {
|
|
(outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host)));
|
|
}
|
|
});
|
|
finishEmit(
|
|
emitterDiagnostics,
|
|
emittedOutputs,
|
|
outputFiles.length ? outputFiles[0].name : getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()),
|
|
resultFlags
|
|
);
|
|
return emitResult;
|
|
}
|
|
function emitBuildInfo(writeFileCallback, cancellationToken) {
|
|
Debug.assertIsDefined(program);
|
|
Debug.assert(step === 5 /* EmitBuildInfo */);
|
|
const emitResult = program.emitBuildInfo((name, text, writeByteOrderMark, onError, sourceFiles, data) => {
|
|
if (data == null ? void 0 : data.buildInfo)
|
|
setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions(), 2 /* DeclarationOutputUnchanged */);
|
|
if (writeFileCallback)
|
|
writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
else
|
|
state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data);
|
|
}, cancellationToken);
|
|
if (emitResult.diagnostics.length) {
|
|
reportErrors(state, emitResult.diagnostics);
|
|
state.diagnostics.set(projectPath, [...state.diagnostics.get(projectPath), ...emitResult.diagnostics]);
|
|
buildResult = 64 /* EmitErrors */ & buildResult;
|
|
}
|
|
if (emitResult.emittedFiles && state.write) {
|
|
emitResult.emittedFiles.forEach((name) => listEmittedFile(state, config, name));
|
|
}
|
|
afterProgramDone(state, program, config);
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return emitResult;
|
|
}
|
|
function finishEmit(emitterDiagnostics, emittedOutputs, oldestOutputFileName, resultFlags) {
|
|
const emitDiagnostics = emitterDiagnostics.getDiagnostics();
|
|
if (emitDiagnostics.length) {
|
|
({ buildResult, step } = buildErrors(
|
|
state,
|
|
projectPath,
|
|
program,
|
|
config,
|
|
emitDiagnostics,
|
|
64 /* EmitErrors */,
|
|
"Emit"
|
|
));
|
|
return emitDiagnostics;
|
|
}
|
|
if (state.write) {
|
|
emittedOutputs.forEach((name) => listEmittedFile(state, config, name));
|
|
}
|
|
updateOutputTimestampsWorker(state, config, projectPath, Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs);
|
|
state.diagnostics.delete(projectPath);
|
|
state.projectStatus.set(projectPath, {
|
|
type: 1 /* UpToDate */,
|
|
oldestOutputFileName
|
|
});
|
|
afterProgramDone(state, program, config);
|
|
step = 7 /* QueueReferencingProjects */;
|
|
buildResult = resultFlags;
|
|
return emitDiagnostics;
|
|
}
|
|
function emitBundle(writeFileCallback, customTransformers) {
|
|
var _a2, _b, _c, _d;
|
|
Debug.assert(kind === 1 /* UpdateBundle */);
|
|
if (state.options.dry) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_update_output_of_project_0, project);
|
|
buildResult = 1 /* Success */;
|
|
step = 7 /* QueueReferencingProjects */;
|
|
return void 0;
|
|
}
|
|
if (state.options.verbose)
|
|
reportStatus(state, Diagnostics.Updating_output_of_project_0, project);
|
|
const { compilerHost } = state;
|
|
state.projectCompilerOptions = config.options;
|
|
(_b = (_a2 = state.host).beforeEmitBundle) == null ? void 0 : _b.call(_a2, config);
|
|
const outputFiles = emitUsingBuildInfo(
|
|
config,
|
|
compilerHost,
|
|
(ref) => {
|
|
const refName = resolveProjectName(state, ref.path);
|
|
return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName));
|
|
},
|
|
customTransformers || ((_d = (_c = state.host).getCustomTransformers) == null ? void 0 : _d.call(_c, project))
|
|
);
|
|
if (isString(outputFiles)) {
|
|
reportStatus(state, Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles));
|
|
step = 6 /* BuildInvalidatedProjectOfBundle */;
|
|
return invalidatedProjectOfBundle = createBuildOrUpdateInvalidedProject(
|
|
0 /* Build */,
|
|
state,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config,
|
|
buildOrder
|
|
);
|
|
}
|
|
Debug.assert(!!outputFiles.length);
|
|
const emitterDiagnostics = createDiagnosticCollection();
|
|
const emittedOutputs = /* @__PURE__ */ new Map();
|
|
let resultFlags = 2 /* DeclarationOutputUnchanged */;
|
|
const existingBuildInfo = state.buildInfoCache.get(projectPath).buildInfo || void 0;
|
|
outputFiles.forEach(({ name, text, writeByteOrderMark, data }) => {
|
|
var _a3, _b2;
|
|
emittedOutputs.set(toPath2(state, name), name);
|
|
if (data == null ? void 0 : data.buildInfo) {
|
|
if (((_a3 = data.buildInfo.program) == null ? void 0 : _a3.outSignature) !== ((_b2 = existingBuildInfo == null ? void 0 : existingBuildInfo.program) == null ? void 0 : _b2.outSignature)) {
|
|
resultFlags &= ~2 /* DeclarationOutputUnchanged */;
|
|
}
|
|
setBuildInfo(state, data.buildInfo, projectPath, config.options, resultFlags);
|
|
}
|
|
writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
|
|
});
|
|
const emitDiagnostics = finishEmit(
|
|
emitterDiagnostics,
|
|
emittedOutputs,
|
|
outputFiles[0].name,
|
|
resultFlags
|
|
);
|
|
return { emitSkipped: false, diagnostics: emitDiagnostics };
|
|
}
|
|
function executeSteps(till, cancellationToken, writeFile2, customTransformers) {
|
|
while (step <= till && step < 8 /* Done */) {
|
|
const currentStep = step;
|
|
switch (step) {
|
|
case 0 /* CreateProgram */:
|
|
createProgram2();
|
|
break;
|
|
case 1 /* SyntaxDiagnostics */:
|
|
getSyntaxDiagnostics(cancellationToken);
|
|
break;
|
|
case 2 /* SemanticDiagnostics */:
|
|
getSemanticDiagnostics(cancellationToken);
|
|
break;
|
|
case 3 /* Emit */:
|
|
emit(writeFile2, cancellationToken, customTransformers);
|
|
break;
|
|
case 5 /* EmitBuildInfo */:
|
|
emitBuildInfo(writeFile2, cancellationToken);
|
|
break;
|
|
case 4 /* EmitBundle */:
|
|
emitBundle(writeFile2, customTransformers);
|
|
break;
|
|
case 6 /* BuildInvalidatedProjectOfBundle */:
|
|
Debug.checkDefined(invalidatedProjectOfBundle).done(cancellationToken, writeFile2, customTransformers);
|
|
step = 8 /* Done */;
|
|
break;
|
|
case 7 /* QueueReferencingProjects */:
|
|
queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
|
|
step++;
|
|
break;
|
|
case 8 /* Done */:
|
|
default:
|
|
assertType(step);
|
|
}
|
|
Debug.assert(step > currentStep);
|
|
}
|
|
}
|
|
}
|
|
function needsBuild({ options }, status, config) {
|
|
if (status.type !== 3 /* OutOfDateWithPrepend */ || options.force)
|
|
return true;
|
|
return config.fileNames.length === 0 || !!getConfigFileParsingDiagnostics(config).length || !isIncrementalCompilation(config.options);
|
|
}
|
|
function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) {
|
|
if (!state.projectPendingBuild.size)
|
|
return void 0;
|
|
if (isCircularBuildOrder(buildOrder))
|
|
return void 0;
|
|
const { options, projectPendingBuild } = state;
|
|
for (let projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) {
|
|
const project = buildOrder[projectIndex];
|
|
const projectPath = toResolvedConfigFilePath(state, project);
|
|
const reloadLevel = state.projectPendingBuild.get(projectPath);
|
|
if (reloadLevel === void 0)
|
|
continue;
|
|
if (reportQueue) {
|
|
reportQueue = false;
|
|
reportBuildQueue(state, buildOrder);
|
|
}
|
|
const config = parseConfigFile(state, project, projectPath);
|
|
if (!config) {
|
|
reportParseConfigFileDiagnostic(state, projectPath);
|
|
projectPendingBuild.delete(projectPath);
|
|
continue;
|
|
}
|
|
if (reloadLevel === 2 /* Full */) {
|
|
watchConfigFile(state, project, projectPath, config);
|
|
watchExtendedConfigFiles(state, projectPath, config);
|
|
watchWildCardDirectories(state, project, projectPath, config);
|
|
watchInputFiles(state, project, projectPath, config);
|
|
watchPackageJsonFiles(state, project, projectPath, config);
|
|
} else if (reloadLevel === 1 /* Partial */) {
|
|
config.fileNames = getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, getDirectoryPath(project), config.options, state.parseConfigFileHost);
|
|
updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, canJsonReportNoInputFiles(config.raw));
|
|
watchInputFiles(state, project, projectPath, config);
|
|
watchPackageJsonFiles(state, project, projectPath, config);
|
|
}
|
|
const status = getUpToDateStatus(state, config, projectPath);
|
|
if (!options.force) {
|
|
if (status.type === 1 /* UpToDate */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
if (options.dry) {
|
|
reportStatus(state, Diagnostics.Project_0_is_up_to_date, project);
|
|
}
|
|
continue;
|
|
}
|
|
if (status.type === 2 /* UpToDateWithUpstreamTypes */ || status.type === 14 /* UpToDateWithInputFileText */) {
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
return {
|
|
kind: 2 /* UpdateOutputFileStamps */,
|
|
status,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config
|
|
};
|
|
}
|
|
}
|
|
if (status.type === 11 /* UpstreamBlocked */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
if (options.verbose) {
|
|
reportStatus(
|
|
state,
|
|
status.upstreamProjectBlocked ? Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_was_not_built : Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_has_errors,
|
|
project,
|
|
status.upstreamProjectName
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
if (status.type === 15 /* ContainerOnly */) {
|
|
verboseReportProjectStatus(state, project, status);
|
|
reportAndStoreErrors(state, projectPath, getConfigFileParsingDiagnostics(config));
|
|
projectPendingBuild.delete(projectPath);
|
|
continue;
|
|
}
|
|
return {
|
|
kind: needsBuild(state, status, config) ? 0 /* Build */ : 1 /* UpdateBundle */,
|
|
status,
|
|
project,
|
|
projectPath,
|
|
projectIndex,
|
|
config
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function createInvalidatedProjectWithInfo(state, info, buildOrder) {
|
|
verboseReportProjectStatus(state, info.project, info.status);
|
|
return info.kind !== 2 /* UpdateOutputFileStamps */ ? createBuildOrUpdateInvalidedProject(
|
|
info.kind,
|
|
state,
|
|
info.project,
|
|
info.projectPath,
|
|
info.projectIndex,
|
|
info.config,
|
|
buildOrder
|
|
) : createUpdateOutputFileStampsProject(
|
|
state,
|
|
info.project,
|
|
info.projectPath,
|
|
info.config,
|
|
buildOrder
|
|
);
|
|
}
|
|
function getNextInvalidatedProject(state, buildOrder, reportQueue) {
|
|
const info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue);
|
|
if (!info)
|
|
return info;
|
|
return createInvalidatedProjectWithInfo(state, info, buildOrder);
|
|
}
|
|
function listEmittedFile({ write }, proj, file) {
|
|
if (write && proj.options.listEmittedFiles) {
|
|
write(`TSFILE: ${file}`);
|
|
}
|
|
}
|
|
function getOldProgram({ options, builderPrograms, compilerHost }, proj, parsed) {
|
|
if (options.force)
|
|
return void 0;
|
|
const value = builderPrograms.get(proj);
|
|
if (value)
|
|
return value;
|
|
return readBuilderProgram(parsed.options, compilerHost);
|
|
}
|
|
function afterProgramDone(state, program, config) {
|
|
if (program) {
|
|
if (state.write)
|
|
listFiles(program, state.write);
|
|
if (state.host.afterProgramEmitAndDiagnostics) {
|
|
state.host.afterProgramEmitAndDiagnostics(program);
|
|
}
|
|
program.releaseProgram();
|
|
} else if (state.host.afterEmitBundle) {
|
|
state.host.afterEmitBundle(config);
|
|
}
|
|
state.projectCompilerOptions = state.baseCompilerOptions;
|
|
}
|
|
function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) {
|
|
const canEmitBuildInfo = program && !outFile(program.getCompilerOptions());
|
|
reportAndStoreErrors(state, resolvedPath, diagnostics);
|
|
state.projectStatus.set(resolvedPath, { type: 0 /* Unbuildable */, reason: `${errorType} errors` });
|
|
if (canEmitBuildInfo)
|
|
return { buildResult, step: 5 /* EmitBuildInfo */ };
|
|
afterProgramDone(state, program, config);
|
|
return { buildResult, step: 7 /* QueueReferencingProjects */ };
|
|
}
|
|
function isFileWatcherWithModifiedTime(value) {
|
|
return !!value.watcher;
|
|
}
|
|
function getModifiedTime2(state, fileName) {
|
|
const path = toPath2(state, fileName);
|
|
const existing = state.filesWatched.get(path);
|
|
if (state.watch && !!existing) {
|
|
if (!isFileWatcherWithModifiedTime(existing))
|
|
return existing;
|
|
if (existing.modifiedTime)
|
|
return existing.modifiedTime;
|
|
}
|
|
const result = getModifiedTime(state.host, fileName);
|
|
if (state.watch) {
|
|
if (existing)
|
|
existing.modifiedTime = result;
|
|
else
|
|
state.filesWatched.set(path, result);
|
|
}
|
|
return result;
|
|
}
|
|
function watchFile(state, file, callback, pollingInterval, options, watchType, project) {
|
|
const path = toPath2(state, file);
|
|
const existing = state.filesWatched.get(path);
|
|
if (existing && isFileWatcherWithModifiedTime(existing)) {
|
|
existing.callbacks.push(callback);
|
|
} else {
|
|
const watcher = state.watchFile(
|
|
file,
|
|
(fileName, eventKind, modifiedTime) => {
|
|
const existing2 = Debug.checkDefined(state.filesWatched.get(path));
|
|
Debug.assert(isFileWatcherWithModifiedTime(existing2));
|
|
existing2.modifiedTime = modifiedTime;
|
|
existing2.callbacks.forEach((cb) => cb(fileName, eventKind, modifiedTime));
|
|
},
|
|
pollingInterval,
|
|
options,
|
|
watchType,
|
|
project
|
|
);
|
|
state.filesWatched.set(path, { callbacks: [callback], watcher, modifiedTime: existing });
|
|
}
|
|
return {
|
|
close: () => {
|
|
const existing2 = Debug.checkDefined(state.filesWatched.get(path));
|
|
Debug.assert(isFileWatcherWithModifiedTime(existing2));
|
|
if (existing2.callbacks.length === 1) {
|
|
state.filesWatched.delete(path);
|
|
closeFileWatcherOf(existing2);
|
|
} else {
|
|
unorderedRemoveItem(existing2.callbacks, callback);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function getOutputTimeStampMap(state, resolvedConfigFilePath) {
|
|
if (!state.watch)
|
|
return void 0;
|
|
let result = state.outputTimeStamps.get(resolvedConfigFilePath);
|
|
if (!result)
|
|
state.outputTimeStamps.set(resolvedConfigFilePath, result = /* @__PURE__ */ new Map());
|
|
return result;
|
|
}
|
|
function setBuildInfo(state, buildInfo, resolvedConfigPath, options, resultFlags) {
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options);
|
|
const existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
|
|
const modifiedTime = getCurrentTime(state.host);
|
|
if (existing) {
|
|
existing.buildInfo = buildInfo;
|
|
existing.modifiedTime = modifiedTime;
|
|
if (!(resultFlags & 2 /* DeclarationOutputUnchanged */))
|
|
existing.latestChangedDtsTime = modifiedTime;
|
|
} else {
|
|
state.buildInfoCache.set(resolvedConfigPath, {
|
|
path: toPath2(state, buildInfoPath),
|
|
buildInfo,
|
|
modifiedTime,
|
|
latestChangedDtsTime: resultFlags & 2 /* DeclarationOutputUnchanged */ ? void 0 : modifiedTime
|
|
});
|
|
}
|
|
}
|
|
function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) {
|
|
const path = toPath2(state, buildInfoPath);
|
|
const existing = state.buildInfoCache.get(resolvedConfigPath);
|
|
return (existing == null ? void 0 : existing.path) === path ? existing : void 0;
|
|
}
|
|
function getBuildInfo3(state, buildInfoPath, resolvedConfigPath, modifiedTime) {
|
|
const path = toPath2(state, buildInfoPath);
|
|
const existing = state.buildInfoCache.get(resolvedConfigPath);
|
|
if (existing !== void 0 && existing.path === path) {
|
|
return existing.buildInfo || void 0;
|
|
}
|
|
const value = state.readFileWithCache(buildInfoPath);
|
|
const buildInfo = value ? getBuildInfo(buildInfoPath, value) : void 0;
|
|
state.buildInfoCache.set(resolvedConfigPath, { path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
|
|
return buildInfo;
|
|
}
|
|
function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) {
|
|
const tsconfigTime = getModifiedTime2(state, configFile);
|
|
if (oldestOutputFileTime < tsconfigTime) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerInputFileName: configFile
|
|
};
|
|
}
|
|
}
|
|
function getUpToDateStatusWorker(state, project, resolvedPath) {
|
|
var _a2, _b;
|
|
if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
|
|
return {
|
|
type: 15 /* ContainerOnly */
|
|
};
|
|
}
|
|
let referenceStatuses;
|
|
const force = !!state.options.force;
|
|
if (project.projectReferences) {
|
|
state.projectStatus.set(resolvedPath, { type: 12 /* ComputingUpstream */ });
|
|
for (const ref of project.projectReferences) {
|
|
const resolvedRef = resolveProjectReferencePath(ref);
|
|
const resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
|
|
const resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath);
|
|
const refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath);
|
|
if (refStatus.type === 12 /* ComputingUpstream */ || refStatus.type === 15 /* ContainerOnly */) {
|
|
continue;
|
|
}
|
|
if (refStatus.type === 0 /* Unbuildable */ || refStatus.type === 11 /* UpstreamBlocked */) {
|
|
return {
|
|
type: 11 /* UpstreamBlocked */,
|
|
upstreamProjectName: ref.path,
|
|
upstreamProjectBlocked: refStatus.type === 11 /* UpstreamBlocked */
|
|
};
|
|
}
|
|
if (refStatus.type !== 1 /* UpToDate */) {
|
|
return {
|
|
type: 10 /* UpstreamOutOfDate */,
|
|
upstreamProjectName: ref.path
|
|
};
|
|
}
|
|
if (!force)
|
|
(referenceStatuses || (referenceStatuses = [])).push({ ref, refStatus, resolvedRefPath, resolvedConfig });
|
|
}
|
|
}
|
|
if (force)
|
|
return { type: 16 /* ForceBuild */ };
|
|
const { host } = state;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(project.options);
|
|
let oldestOutputFileName;
|
|
let oldestOutputFileTime = maximumDate;
|
|
let buildInfoTime;
|
|
let buildInfoProgram;
|
|
let buildInfoVersionMap;
|
|
if (buildInfoPath) {
|
|
const buildInfoCacheEntry2 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
|
|
buildInfoTime = (buildInfoCacheEntry2 == null ? void 0 : buildInfoCacheEntry2.modifiedTime) || getModifiedTime(host, buildInfoPath);
|
|
if (buildInfoTime === missingFileModifiedTime) {
|
|
if (!buildInfoCacheEntry2) {
|
|
state.buildInfoCache.set(resolvedPath, {
|
|
path: toPath2(state, buildInfoPath),
|
|
buildInfo: false,
|
|
modifiedTime: buildInfoTime
|
|
});
|
|
}
|
|
return {
|
|
type: 4 /* OutputMissing */,
|
|
missingOutputFileName: buildInfoPath
|
|
};
|
|
}
|
|
const buildInfo = getBuildInfo3(state, buildInfoPath, resolvedPath, buildInfoTime);
|
|
if (!buildInfo) {
|
|
return {
|
|
type: 5 /* ErrorReadingFile */,
|
|
fileName: buildInfoPath
|
|
};
|
|
}
|
|
if ((buildInfo.bundle || buildInfo.program) && buildInfo.version !== version) {
|
|
return {
|
|
type: 13 /* TsVersionOutputOfDate */,
|
|
version: buildInfo.version
|
|
};
|
|
}
|
|
if (buildInfo.program) {
|
|
if (((_a2 = buildInfo.program.changeFileSet) == null ? void 0 : _a2.length) || (!project.options.noEmit ? (_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
|
|
return {
|
|
type: 8 /* OutOfDateBuildInfo */,
|
|
buildInfoFile: buildInfoPath
|
|
};
|
|
}
|
|
if (!project.options.noEmit && getPendingEmitKind(project.options, buildInfo.program.options || {})) {
|
|
return {
|
|
type: 9 /* OutOfDateOptions */,
|
|
buildInfoFile: buildInfoPath
|
|
};
|
|
}
|
|
buildInfoProgram = buildInfo.program;
|
|
}
|
|
oldestOutputFileTime = buildInfoTime;
|
|
oldestOutputFileName = buildInfoPath;
|
|
}
|
|
let newestInputFileName = void 0;
|
|
let newestInputFileTime = minimumDate;
|
|
let pseudoInputUpToDate = false;
|
|
for (const inputFile of project.fileNames) {
|
|
const inputTime = getModifiedTime2(state, inputFile);
|
|
if (inputTime === missingFileModifiedTime) {
|
|
return {
|
|
type: 0 /* Unbuildable */,
|
|
reason: `${inputFile} does not exist`
|
|
};
|
|
}
|
|
if (buildInfoTime && buildInfoTime < inputTime) {
|
|
let version2;
|
|
let currentVersion;
|
|
if (buildInfoProgram) {
|
|
if (!buildInfoVersionMap)
|
|
buildInfoVersionMap = getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host);
|
|
version2 = buildInfoVersionMap.get(toPath2(state, inputFile));
|
|
const text = version2 ? state.readFileWithCache(inputFile) : void 0;
|
|
currentVersion = text && getSourceFileVersionAsHashFromText(host, text);
|
|
if (version2 && version2 === currentVersion)
|
|
pseudoInputUpToDate = true;
|
|
}
|
|
if (!version2 || version2 !== currentVersion) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: buildInfoPath,
|
|
newerInputFileName: inputFile
|
|
};
|
|
}
|
|
}
|
|
if (inputTime > newestInputFileTime) {
|
|
newestInputFileName = inputFile;
|
|
newestInputFileTime = inputTime;
|
|
}
|
|
}
|
|
if (!buildInfoPath) {
|
|
const outputs = getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
|
|
const outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath);
|
|
for (const output of outputs) {
|
|
const path = toPath2(state, output);
|
|
let outputTime = outputTimeStampMap == null ? void 0 : outputTimeStampMap.get(path);
|
|
if (!outputTime) {
|
|
outputTime = getModifiedTime(state.host, output);
|
|
outputTimeStampMap == null ? void 0 : outputTimeStampMap.set(path, outputTime);
|
|
}
|
|
if (outputTime === missingFileModifiedTime) {
|
|
return {
|
|
type: 4 /* OutputMissing */,
|
|
missingOutputFileName: output
|
|
};
|
|
}
|
|
if (outputTime < newestInputFileTime) {
|
|
return {
|
|
type: 6 /* OutOfDateWithSelf */,
|
|
outOfDateOutputFileName: output,
|
|
newerInputFileName: newestInputFileName
|
|
};
|
|
}
|
|
if (outputTime < oldestOutputFileTime) {
|
|
oldestOutputFileTime = outputTime;
|
|
oldestOutputFileName = output;
|
|
}
|
|
}
|
|
}
|
|
const buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath);
|
|
let pseudoUpToDate = false;
|
|
let usesPrepend = false;
|
|
let upstreamChangedProject;
|
|
if (referenceStatuses) {
|
|
for (const { ref, refStatus, resolvedConfig, resolvedRefPath } of referenceStatuses) {
|
|
usesPrepend = usesPrepend || !!ref.prepend;
|
|
if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
|
|
continue;
|
|
}
|
|
if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath)) {
|
|
return {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: buildInfoPath,
|
|
newerProjectName: ref.path
|
|
};
|
|
}
|
|
const newestDeclarationFileContentChangedTime = getLatestChangedDtsTime(state, resolvedConfig.options, resolvedRefPath);
|
|
if (newestDeclarationFileContentChangedTime && newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
|
|
pseudoUpToDate = true;
|
|
upstreamChangedProject = ref.path;
|
|
continue;
|
|
}
|
|
Debug.assert(oldestOutputFileName !== void 0, "Should have an oldest output filename here");
|
|
return {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerProjectName: ref.path
|
|
};
|
|
}
|
|
}
|
|
const configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName);
|
|
if (configStatus)
|
|
return configStatus;
|
|
const extendedConfigStatus = forEach(project.options.configFile.extendedSourceFiles || emptyArray, (configFile) => checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName));
|
|
if (extendedConfigStatus)
|
|
return extendedConfigStatus;
|
|
const dependentPackageFileStatus = forEach(
|
|
state.lastCachedPackageJsonLookups.get(resolvedPath) || emptyArray,
|
|
([path]) => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName)
|
|
);
|
|
if (dependentPackageFileStatus)
|
|
return dependentPackageFileStatus;
|
|
if (usesPrepend && pseudoUpToDate) {
|
|
return {
|
|
type: 3 /* OutOfDateWithPrepend */,
|
|
outOfDateOutputFileName: oldestOutputFileName,
|
|
newerProjectName: upstreamChangedProject
|
|
};
|
|
}
|
|
return {
|
|
type: pseudoUpToDate ? 2 /* UpToDateWithUpstreamTypes */ : pseudoInputUpToDate ? 14 /* UpToDateWithInputFileText */ : 1 /* UpToDate */,
|
|
newestInputFileTime,
|
|
newestInputFileName,
|
|
oldestOutputFileName
|
|
};
|
|
}
|
|
function hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath) {
|
|
const refBuildInfo = state.buildInfoCache.get(resolvedRefPath);
|
|
return refBuildInfo.path === buildInfoCacheEntry.path;
|
|
}
|
|
function getUpToDateStatus(state, project, resolvedPath) {
|
|
if (project === void 0) {
|
|
return { type: 0 /* Unbuildable */, reason: "File deleted mid-build" };
|
|
}
|
|
const prior = state.projectStatus.get(resolvedPath);
|
|
if (prior !== void 0) {
|
|
return prior;
|
|
}
|
|
mark("SolutionBuilder::beforeUpToDateCheck");
|
|
const actual = getUpToDateStatusWorker(state, project, resolvedPath);
|
|
mark("SolutionBuilder::afterUpToDateCheck");
|
|
measure("SolutionBuilder::Up-to-date check", "SolutionBuilder::beforeUpToDateCheck", "SolutionBuilder::afterUpToDateCheck");
|
|
state.projectStatus.set(resolvedPath, actual);
|
|
return actual;
|
|
}
|
|
function updateOutputTimestampsWorker(state, proj, projectPath, verboseMessage, skipOutputs) {
|
|
if (proj.options.noEmit)
|
|
return;
|
|
let now;
|
|
const buildInfoPath = getTsBuildInfoEmitOutputFilePath(proj.options);
|
|
if (buildInfoPath) {
|
|
if (!(skipOutputs == null ? void 0 : skipOutputs.has(toPath2(state, buildInfoPath)))) {
|
|
if (!!state.options.verbose)
|
|
reportStatus(state, verboseMessage, proj.options.configFilePath);
|
|
state.host.setModifiedTime(buildInfoPath, now = getCurrentTime(state.host));
|
|
getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now;
|
|
}
|
|
state.outputTimeStamps.delete(projectPath);
|
|
return;
|
|
}
|
|
const { host } = state;
|
|
const outputs = getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
|
|
const outputTimeStampMap = getOutputTimeStampMap(state, projectPath);
|
|
const modifiedOutputs = outputTimeStampMap ? /* @__PURE__ */ new Set() : void 0;
|
|
if (!skipOutputs || outputs.length !== skipOutputs.size) {
|
|
let reportVerbose = !!state.options.verbose;
|
|
for (const file of outputs) {
|
|
const path = toPath2(state, file);
|
|
if (skipOutputs == null ? void 0 : skipOutputs.has(path))
|
|
continue;
|
|
if (reportVerbose) {
|
|
reportVerbose = false;
|
|
reportStatus(state, verboseMessage, proj.options.configFilePath);
|
|
}
|
|
host.setModifiedTime(file, now || (now = getCurrentTime(state.host)));
|
|
if (outputTimeStampMap) {
|
|
outputTimeStampMap.set(path, now);
|
|
modifiedOutputs.add(path);
|
|
}
|
|
}
|
|
}
|
|
outputTimeStampMap == null ? void 0 : outputTimeStampMap.forEach((_value, key) => {
|
|
if (!(skipOutputs == null ? void 0 : skipOutputs.has(key)) && !modifiedOutputs.has(key))
|
|
outputTimeStampMap.delete(key);
|
|
});
|
|
}
|
|
function getLatestChangedDtsTime(state, options, resolvedConfigPath) {
|
|
if (!options.composite)
|
|
return void 0;
|
|
const entry = Debug.checkDefined(state.buildInfoCache.get(resolvedConfigPath));
|
|
if (entry.latestChangedDtsTime !== void 0)
|
|
return entry.latestChangedDtsTime || void 0;
|
|
const latestChangedDtsTime = entry.buildInfo && entry.buildInfo.program && entry.buildInfo.program.latestChangedDtsFile ? state.host.getModifiedTime(getNormalizedAbsolutePath(entry.buildInfo.program.latestChangedDtsFile, getDirectoryPath(entry.path))) : void 0;
|
|
entry.latestChangedDtsTime = latestChangedDtsTime || false;
|
|
return latestChangedDtsTime;
|
|
}
|
|
function updateOutputTimestamps(state, proj, resolvedPath) {
|
|
if (state.options.dry) {
|
|
return reportStatus(state, Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath);
|
|
}
|
|
updateOutputTimestampsWorker(state, proj, resolvedPath, Diagnostics.Updating_output_timestamps_of_project_0);
|
|
state.projectStatus.set(resolvedPath, {
|
|
type: 1 /* UpToDate */,
|
|
oldestOutputFileName: getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
|
|
});
|
|
}
|
|
function queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, buildResult) {
|
|
if (buildResult & 124 /* AnyErrors */)
|
|
return;
|
|
if (!config.options.composite)
|
|
return;
|
|
for (let index = projectIndex + 1; index < buildOrder.length; index++) {
|
|
const nextProject = buildOrder[index];
|
|
const nextProjectPath = toResolvedConfigFilePath(state, nextProject);
|
|
if (state.projectPendingBuild.has(nextProjectPath))
|
|
continue;
|
|
const nextProjectConfig = parseConfigFile(state, nextProject, nextProjectPath);
|
|
if (!nextProjectConfig || !nextProjectConfig.projectReferences)
|
|
continue;
|
|
for (const ref of nextProjectConfig.projectReferences) {
|
|
const resolvedRefPath = resolveProjectName(state, ref.path);
|
|
if (toResolvedConfigFilePath(state, resolvedRefPath) !== projectPath)
|
|
continue;
|
|
const status = state.projectStatus.get(nextProjectPath);
|
|
if (status) {
|
|
switch (status.type) {
|
|
case 1 /* UpToDate */:
|
|
if (buildResult & 2 /* DeclarationOutputUnchanged */) {
|
|
if (ref.prepend) {
|
|
state.projectStatus.set(nextProjectPath, {
|
|
type: 3 /* OutOfDateWithPrepend */,
|
|
outOfDateOutputFileName: status.oldestOutputFileName,
|
|
newerProjectName: project
|
|
});
|
|
} else {
|
|
status.type = 2 /* UpToDateWithUpstreamTypes */;
|
|
}
|
|
break;
|
|
}
|
|
case 14 /* UpToDateWithInputFileText */:
|
|
case 2 /* UpToDateWithUpstreamTypes */:
|
|
case 3 /* OutOfDateWithPrepend */:
|
|
if (!(buildResult & 2 /* DeclarationOutputUnchanged */)) {
|
|
state.projectStatus.set(nextProjectPath, {
|
|
type: 7 /* OutOfDateWithUpstream */,
|
|
outOfDateOutputFileName: status.type === 3 /* OutOfDateWithPrepend */ ? status.outOfDateOutputFileName : status.oldestOutputFileName,
|
|
newerProjectName: project
|
|
});
|
|
}
|
|
break;
|
|
case 11 /* UpstreamBlocked */:
|
|
if (toResolvedConfigFilePath(state, resolveProjectName(state, status.upstreamProjectName)) === projectPath) {
|
|
clearProjectStatus(state, nextProjectPath);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
addProjToQueue(state, nextProjectPath, 0 /* None */);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function build(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences) {
|
|
mark("SolutionBuilder::beforeBuild");
|
|
const result = buildWorker(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences);
|
|
mark("SolutionBuilder::afterBuild");
|
|
measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
|
|
return result;
|
|
}
|
|
function buildWorker(state, project, cancellationToken, writeFile2, getCustomTransformers, onlyReferences) {
|
|
const buildOrder = getBuildOrderFor(state, project, onlyReferences);
|
|
if (!buildOrder)
|
|
return 3 /* InvalidProject_OutputsSkipped */;
|
|
setupInitialBuild(state, cancellationToken);
|
|
let reportQueue = true;
|
|
let successfulProjects = 0;
|
|
while (true) {
|
|
const invalidatedProject = getNextInvalidatedProject(state, buildOrder, reportQueue);
|
|
if (!invalidatedProject)
|
|
break;
|
|
reportQueue = false;
|
|
invalidatedProject.done(cancellationToken, writeFile2, getCustomTransformers == null ? void 0 : getCustomTransformers(invalidatedProject.project));
|
|
if (!state.diagnostics.has(invalidatedProject.projectPath))
|
|
successfulProjects++;
|
|
}
|
|
disableCache(state);
|
|
reportErrorSummary(state, buildOrder);
|
|
startWatching(state, buildOrder);
|
|
return isCircularBuildOrder(buildOrder) ? 4 /* ProjectReferenceCycle_OutputsSkipped */ : !buildOrder.some((p) => state.diagnostics.has(toResolvedConfigFilePath(state, p))) ? 0 /* Success */ : successfulProjects ? 2 /* DiagnosticsPresent_OutputsGenerated */ : 1 /* DiagnosticsPresent_OutputsSkipped */;
|
|
}
|
|
function clean(state, project, onlyReferences) {
|
|
mark("SolutionBuilder::beforeClean");
|
|
const result = cleanWorker(state, project, onlyReferences);
|
|
mark("SolutionBuilder::afterClean");
|
|
measure("SolutionBuilder::Clean", "SolutionBuilder::beforeClean", "SolutionBuilder::afterClean");
|
|
return result;
|
|
}
|
|
function cleanWorker(state, project, onlyReferences) {
|
|
const buildOrder = getBuildOrderFor(state, project, onlyReferences);
|
|
if (!buildOrder)
|
|
return 3 /* InvalidProject_OutputsSkipped */;
|
|
if (isCircularBuildOrder(buildOrder)) {
|
|
reportErrors(state, buildOrder.circularDiagnostics);
|
|
return 4 /* ProjectReferenceCycle_OutputsSkipped */;
|
|
}
|
|
const { options, host } = state;
|
|
const filesToDelete = options.dry ? [] : void 0;
|
|
for (const proj of buildOrder) {
|
|
const resolvedPath = toResolvedConfigFilePath(state, proj);
|
|
const parsed = parseConfigFile(state, proj, resolvedPath);
|
|
if (parsed === void 0) {
|
|
reportParseConfigFileDiagnostic(state, resolvedPath);
|
|
continue;
|
|
}
|
|
const outputs = getAllProjectOutputs(parsed, !host.useCaseSensitiveFileNames());
|
|
if (!outputs.length)
|
|
continue;
|
|
const inputFileNames = new Set(parsed.fileNames.map((f) => toPath2(state, f)));
|
|
for (const output of outputs) {
|
|
if (inputFileNames.has(toPath2(state, output)))
|
|
continue;
|
|
if (host.fileExists(output)) {
|
|
if (filesToDelete) {
|
|
filesToDelete.push(output);
|
|
} else {
|
|
host.deleteFile(output);
|
|
invalidateProject(state, resolvedPath, 0 /* None */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (filesToDelete) {
|
|
reportStatus(state, Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map((f) => `\r
|
|
* ${f}`).join(""));
|
|
}
|
|
return 0 /* Success */;
|
|
}
|
|
function invalidateProject(state, resolved, reloadLevel) {
|
|
if (state.host.getParsedCommandLine && reloadLevel === 1 /* Partial */) {
|
|
reloadLevel = 2 /* Full */;
|
|
}
|
|
if (reloadLevel === 2 /* Full */) {
|
|
state.configFileCache.delete(resolved);
|
|
state.buildOrder = void 0;
|
|
}
|
|
state.needsSummary = true;
|
|
clearProjectStatus(state, resolved);
|
|
addProjToQueue(state, resolved, reloadLevel);
|
|
enableCache(state);
|
|
}
|
|
function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) {
|
|
state.reportFileChangeDetected = true;
|
|
invalidateProject(state, resolvedPath, reloadLevel);
|
|
scheduleBuildInvalidatedProject(state, 250, true);
|
|
}
|
|
function scheduleBuildInvalidatedProject(state, time, changeDetected) {
|
|
const { hostWithWatch } = state;
|
|
if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) {
|
|
return;
|
|
}
|
|
if (state.timerToBuildInvalidatedProject) {
|
|
hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject);
|
|
}
|
|
state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected);
|
|
}
|
|
function buildNextInvalidatedProject(state, changeDetected) {
|
|
mark("SolutionBuilder::beforeBuild");
|
|
const buildOrder = buildNextInvalidatedProjectWorker(state, changeDetected);
|
|
mark("SolutionBuilder::afterBuild");
|
|
measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild");
|
|
if (buildOrder)
|
|
reportErrorSummary(state, buildOrder);
|
|
}
|
|
function buildNextInvalidatedProjectWorker(state, changeDetected) {
|
|
state.timerToBuildInvalidatedProject = void 0;
|
|
if (state.reportFileChangeDetected) {
|
|
state.reportFileChangeDetected = false;
|
|
state.projectErrorsReported.clear();
|
|
reportWatchStatus(state, Diagnostics.File_change_detected_Starting_incremental_compilation);
|
|
}
|
|
let projectsBuilt = 0;
|
|
const buildOrder = getBuildOrder(state);
|
|
const invalidatedProject = getNextInvalidatedProject(state, buildOrder, false);
|
|
if (invalidatedProject) {
|
|
invalidatedProject.done();
|
|
projectsBuilt++;
|
|
while (state.projectPendingBuild.size) {
|
|
if (state.timerToBuildInvalidatedProject)
|
|
return;
|
|
const info = getNextInvalidatedProjectCreateInfo(state, buildOrder, false);
|
|
if (!info)
|
|
break;
|
|
if (info.kind !== 2 /* UpdateOutputFileStamps */ && (changeDetected || projectsBuilt === 5)) {
|
|
scheduleBuildInvalidatedProject(state, 100, false);
|
|
return;
|
|
}
|
|
const project = createInvalidatedProjectWithInfo(state, info, buildOrder);
|
|
project.done();
|
|
if (info.kind !== 2 /* UpdateOutputFileStamps */)
|
|
projectsBuilt++;
|
|
}
|
|
}
|
|
disableCache(state);
|
|
return buildOrder;
|
|
}
|
|
function watchConfigFile(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath))
|
|
return;
|
|
state.allWatchedConfigFiles.set(resolvedPath, watchFile(
|
|
state,
|
|
resolved,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 2 /* Full */),
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.ConfigFile,
|
|
resolved
|
|
));
|
|
}
|
|
function watchExtendedConfigFiles(state, resolvedPath, parsed) {
|
|
updateSharedExtendedConfigFileWatcher(
|
|
resolvedPath,
|
|
parsed == null ? void 0 : parsed.options,
|
|
state.allWatchedExtendedConfigFiles,
|
|
(extendedConfigFileName, extendedConfigFilePath) => watchFile(
|
|
state,
|
|
extendedConfigFileName,
|
|
() => {
|
|
var _a2;
|
|
return (_a2 = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) == null ? void 0 : _a2.projects.forEach((projectConfigFilePath) => invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, 2 /* Full */));
|
|
},
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.ExtendedConfigFile
|
|
),
|
|
(fileName) => toPath2(state, fileName)
|
|
);
|
|
}
|
|
function watchWildCardDirectories(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch)
|
|
return;
|
|
updateWatchingWildcardDirectories(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath),
|
|
new Map(getEntries(parsed.wildcardDirectories)),
|
|
(dir, flags) => state.watchDirectory(
|
|
dir,
|
|
(fileOrDirectory) => {
|
|
var _a2;
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: toPath2(state, dir),
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath: toPath2(state, fileOrDirectory),
|
|
configFileName: resolved,
|
|
currentDirectory: state.currentDirectory,
|
|
options: parsed.options,
|
|
program: state.builderPrograms.get(resolvedPath) || ((_a2 = getCachedParsedConfigFile(state, resolvedPath)) == null ? void 0 : _a2.fileNames),
|
|
useCaseSensitiveFileNames: state.parseConfigFileHost.useCaseSensitiveFileNames,
|
|
writeLog: (s) => state.writeLog(s),
|
|
toPath: (fileName) => toPath2(state, fileName)
|
|
}))
|
|
return;
|
|
invalidateProjectAndScheduleBuilds(state, resolvedPath, 1 /* Partial */);
|
|
},
|
|
flags,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.WildcardDirectory,
|
|
resolved
|
|
)
|
|
);
|
|
}
|
|
function watchInputFiles(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch)
|
|
return;
|
|
mutateMap(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath),
|
|
arrayToMap(parsed.fileNames, (fileName) => toPath2(state, fileName)),
|
|
{
|
|
createNewValue: (_path, input) => watchFile(
|
|
state,
|
|
input,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* None */),
|
|
250 /* Low */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.SourceFile,
|
|
resolved
|
|
),
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function watchPackageJsonFiles(state, resolved, resolvedPath, parsed) {
|
|
if (!state.watch || !state.lastCachedPackageJsonLookups)
|
|
return;
|
|
mutateMap(
|
|
getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath),
|
|
new Map(state.lastCachedPackageJsonLookups.get(resolvedPath)),
|
|
{
|
|
createNewValue: (path, _input) => watchFile(
|
|
state,
|
|
path,
|
|
() => invalidateProjectAndScheduleBuilds(state, resolvedPath, 0 /* None */),
|
|
2e3 /* High */,
|
|
parsed == null ? void 0 : parsed.watchOptions,
|
|
WatchType.PackageJson,
|
|
resolved
|
|
),
|
|
onDeleteValue: closeFileWatcher
|
|
}
|
|
);
|
|
}
|
|
function startWatching(state, buildOrder) {
|
|
if (!state.watchAllProjectsPending)
|
|
return;
|
|
mark("SolutionBuilder::beforeWatcherCreation");
|
|
state.watchAllProjectsPending = false;
|
|
for (const resolved of getBuildOrderFromAnyBuildOrder(buildOrder)) {
|
|
const resolvedPath = toResolvedConfigFilePath(state, resolved);
|
|
const cfg = parseConfigFile(state, resolved, resolvedPath);
|
|
watchConfigFile(state, resolved, resolvedPath, cfg);
|
|
watchExtendedConfigFiles(state, resolvedPath, cfg);
|
|
if (cfg) {
|
|
watchWildCardDirectories(state, resolved, resolvedPath, cfg);
|
|
watchInputFiles(state, resolved, resolvedPath, cfg);
|
|
watchPackageJsonFiles(state, resolved, resolvedPath, cfg);
|
|
}
|
|
}
|
|
mark("SolutionBuilder::afterWatcherCreation");
|
|
measure("SolutionBuilder::Watcher creation", "SolutionBuilder::beforeWatcherCreation", "SolutionBuilder::afterWatcherCreation");
|
|
}
|
|
function stopWatching(state) {
|
|
clearMap(state.allWatchedConfigFiles, closeFileWatcher);
|
|
clearMap(state.allWatchedExtendedConfigFiles, closeFileWatcherOf);
|
|
clearMap(state.allWatchedWildcardDirectories, (watchedWildcardDirectories) => clearMap(watchedWildcardDirectories, closeFileWatcherOf));
|
|
clearMap(state.allWatchedInputFiles, (watchedWildcardDirectories) => clearMap(watchedWildcardDirectories, closeFileWatcher));
|
|
clearMap(state.allWatchedPackageJsonFiles, (watchedPacageJsonFiles) => clearMap(watchedPacageJsonFiles, closeFileWatcher));
|
|
}
|
|
function createSolutionBuilderWorker(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) {
|
|
const state = createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions);
|
|
return {
|
|
build: (project, cancellationToken, writeFile2, getCustomTransformers) => build(state, project, cancellationToken, writeFile2, getCustomTransformers),
|
|
clean: (project) => clean(state, project),
|
|
buildReferences: (project, cancellationToken, writeFile2, getCustomTransformers) => build(state, project, cancellationToken, writeFile2, getCustomTransformers, true),
|
|
cleanReferences: (project) => clean(state, project, true),
|
|
getNextInvalidatedProject: (cancellationToken) => {
|
|
setupInitialBuild(state, cancellationToken);
|
|
return getNextInvalidatedProject(state, getBuildOrder(state), false);
|
|
},
|
|
getBuildOrder: () => getBuildOrder(state),
|
|
getUpToDateStatusOfProject: (project) => {
|
|
const configFileName = resolveProjectName(state, project);
|
|
const configFilePath = toResolvedConfigFilePath(state, configFileName);
|
|
return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath);
|
|
},
|
|
invalidateProject: (configFilePath, reloadLevel) => invalidateProject(state, configFilePath, reloadLevel || 0 /* None */),
|
|
close: () => stopWatching(state)
|
|
};
|
|
}
|
|
function relName(state, path) {
|
|
return convertToRelativePath(path, state.currentDirectory, (f) => state.getCanonicalFileName(f));
|
|
}
|
|
function reportStatus(state, message, ...args) {
|
|
state.host.reportSolutionBuilderStatus(createCompilerDiagnostic(message, ...args));
|
|
}
|
|
function reportWatchStatus(state, message, ...args) {
|
|
var _a2, _b;
|
|
(_b = (_a2 = state.hostWithWatch).onWatchStatusChange) == null ? void 0 : _b.call(_a2, createCompilerDiagnostic(message, ...args), state.host.getNewLine(), state.baseCompilerOptions);
|
|
}
|
|
function reportErrors({ host }, errors) {
|
|
errors.forEach((err) => host.reportDiagnostic(err));
|
|
}
|
|
function reportAndStoreErrors(state, proj, errors) {
|
|
reportErrors(state, errors);
|
|
state.projectErrorsReported.set(proj, true);
|
|
if (errors.length) {
|
|
state.diagnostics.set(proj, errors);
|
|
}
|
|
}
|
|
function reportParseConfigFileDiagnostic(state, proj) {
|
|
reportAndStoreErrors(state, proj, [state.configFileCache.get(proj)]);
|
|
}
|
|
function reportErrorSummary(state, buildOrder) {
|
|
if (!state.needsSummary)
|
|
return;
|
|
state.needsSummary = false;
|
|
const canReportSummary = state.watch || !!state.host.reportErrorSummary;
|
|
const { diagnostics } = state;
|
|
let totalErrors = 0;
|
|
let filesInError = [];
|
|
if (isCircularBuildOrder(buildOrder)) {
|
|
reportBuildQueue(state, buildOrder.buildOrder);
|
|
reportErrors(state, buildOrder.circularDiagnostics);
|
|
if (canReportSummary)
|
|
totalErrors += getErrorCountForSummary(buildOrder.circularDiagnostics);
|
|
if (canReportSummary)
|
|
filesInError = [...filesInError, ...getFilesInErrorForSummary(buildOrder.circularDiagnostics)];
|
|
} else {
|
|
buildOrder.forEach((project) => {
|
|
const projectPath = toResolvedConfigFilePath(state, project);
|
|
if (!state.projectErrorsReported.has(projectPath)) {
|
|
reportErrors(state, diagnostics.get(projectPath) || emptyArray);
|
|
}
|
|
});
|
|
if (canReportSummary)
|
|
diagnostics.forEach((singleProjectErrors) => totalErrors += getErrorCountForSummary(singleProjectErrors));
|
|
if (canReportSummary)
|
|
diagnostics.forEach((singleProjectErrors) => [...filesInError, ...getFilesInErrorForSummary(singleProjectErrors)]);
|
|
}
|
|
if (state.watch) {
|
|
reportWatchStatus(state, getWatchErrorSummaryDiagnosticMessage(totalErrors), totalErrors);
|
|
} else if (state.host.reportErrorSummary) {
|
|
state.host.reportErrorSummary(totalErrors, filesInError);
|
|
}
|
|
}
|
|
function reportBuildQueue(state, buildQueue) {
|
|
if (state.options.verbose) {
|
|
reportStatus(state, Diagnostics.Projects_in_this_build_Colon_0, buildQueue.map((s) => "\r\n * " + relName(state, s)).join(""));
|
|
}
|
|
}
|
|
function reportUpToDateStatus(state, configFileName, status) {
|
|
switch (status.type) {
|
|
case 6 /* OutOfDateWithSelf */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2,
|
|
relName(state, configFileName),
|
|
relName(state, status.outOfDateOutputFileName),
|
|
relName(state, status.newerInputFileName)
|
|
);
|
|
case 7 /* OutOfDateWithUpstream */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2,
|
|
relName(state, configFileName),
|
|
relName(state, status.outOfDateOutputFileName),
|
|
relName(state, status.newerProjectName)
|
|
);
|
|
case 4 /* OutputMissing */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist,
|
|
relName(state, configFileName),
|
|
relName(state, status.missingOutputFileName)
|
|
);
|
|
case 5 /* ErrorReadingFile */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_there_was_error_reading_file_1,
|
|
relName(state, configFileName),
|
|
relName(state, status.fileName)
|
|
);
|
|
case 8 /* OutOfDateBuildInfo */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted,
|
|
relName(state, configFileName),
|
|
relName(state, status.buildInfoFile)
|
|
);
|
|
case 9 /* OutOfDateOptions */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_there_is_change_in_compilerOptions,
|
|
relName(state, configFileName),
|
|
relName(state, status.buildInfoFile)
|
|
);
|
|
case 1 /* UpToDate */:
|
|
if (status.newestInputFileTime !== void 0) {
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2,
|
|
relName(state, configFileName),
|
|
relName(state, status.newestInputFileName || ""),
|
|
relName(state, status.oldestOutputFileName || "")
|
|
);
|
|
}
|
|
break;
|
|
case 3 /* OutOfDateWithPrepend */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed,
|
|
relName(state, configFileName),
|
|
relName(state, status.newerProjectName)
|
|
);
|
|
case 2 /* UpToDateWithUpstreamTypes */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies,
|
|
relName(state, configFileName)
|
|
);
|
|
case 14 /* UpToDateWithInputFileText */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files,
|
|
relName(state, configFileName)
|
|
);
|
|
case 10 /* UpstreamOutOfDate */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date,
|
|
relName(state, configFileName),
|
|
relName(state, status.upstreamProjectName)
|
|
);
|
|
case 11 /* UpstreamBlocked */:
|
|
return reportStatus(
|
|
state,
|
|
status.upstreamProjectBlocked ? Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_was_not_built : Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_has_errors,
|
|
relName(state, configFileName),
|
|
relName(state, status.upstreamProjectName)
|
|
);
|
|
case 0 /* Unbuildable */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Failed_to_parse_file_0_Colon_1,
|
|
relName(state, configFileName),
|
|
status.reason
|
|
);
|
|
case 13 /* TsVersionOutputOfDate */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2,
|
|
relName(state, configFileName),
|
|
status.version,
|
|
version
|
|
);
|
|
case 16 /* ForceBuild */:
|
|
return reportStatus(
|
|
state,
|
|
Diagnostics.Project_0_is_being_forcibly_rebuilt,
|
|
relName(state, configFileName)
|
|
);
|
|
case 15 /* ContainerOnly */:
|
|
case 12 /* ComputingUpstream */:
|
|
break;
|
|
default:
|
|
assertType(status);
|
|
}
|
|
}
|
|
function verboseReportProjectStatus(state, configFileName, status) {
|
|
if (state.options.verbose) {
|
|
reportUpToDateStatus(state, configFileName, status);
|
|
}
|
|
}
|
|
|
|
// src/jsTyping/_namespaces/ts.JsTyping.ts
|
|
var ts_JsTyping_exports = {};
|
|
__export(ts_JsTyping_exports, {
|
|
NameValidationResult: () => NameValidationResult,
|
|
discoverTypings: () => discoverTypings,
|
|
isTypingUpToDate: () => isTypingUpToDate,
|
|
loadSafeList: () => loadSafeList,
|
|
loadTypesMap: () => loadTypesMap,
|
|
nodeCoreModuleList: () => nodeCoreModuleList,
|
|
nodeCoreModules: () => nodeCoreModules,
|
|
nonRelativeModuleNameForTypingCache: () => nonRelativeModuleNameForTypingCache,
|
|
prefixedNodeCoreModuleList: () => prefixedNodeCoreModuleList,
|
|
renderPackageNameValidationFailure: () => renderPackageNameValidationFailure,
|
|
validatePackageName: () => validatePackageName
|
|
});
|
|
|
|
// src/jsTyping/jsTyping.ts
|
|
function isTypingUpToDate(cachedTyping, availableTypingVersions) {
|
|
const availableVersion = new Version(getProperty(availableTypingVersions, `ts${versionMajorMinor}`) || getProperty(availableTypingVersions, "latest"));
|
|
return availableVersion.compareTo(cachedTyping.version) <= 0;
|
|
}
|
|
var unprefixedNodeCoreModuleList = [
|
|
"assert",
|
|
"assert/strict",
|
|
"async_hooks",
|
|
"buffer",
|
|
"child_process",
|
|
"cluster",
|
|
"console",
|
|
"constants",
|
|
"crypto",
|
|
"dgram",
|
|
"diagnostics_channel",
|
|
"dns",
|
|
"dns/promises",
|
|
"domain",
|
|
"events",
|
|
"fs",
|
|
"fs/promises",
|
|
"http",
|
|
"https",
|
|
"http2",
|
|
"inspector",
|
|
"module",
|
|
"net",
|
|
"os",
|
|
"path",
|
|
"perf_hooks",
|
|
"process",
|
|
"punycode",
|
|
"querystring",
|
|
"readline",
|
|
"repl",
|
|
"stream",
|
|
"stream/promises",
|
|
"string_decoder",
|
|
"timers",
|
|
"timers/promises",
|
|
"tls",
|
|
"trace_events",
|
|
"tty",
|
|
"url",
|
|
"util",
|
|
"util/types",
|
|
"v8",
|
|
"vm",
|
|
"wasi",
|
|
"worker_threads",
|
|
"zlib"
|
|
];
|
|
var prefixedNodeCoreModuleList = unprefixedNodeCoreModuleList.map((name) => `node:${name}`);
|
|
var nodeCoreModuleList = [...unprefixedNodeCoreModuleList, ...prefixedNodeCoreModuleList];
|
|
var nodeCoreModules = new Set(nodeCoreModuleList);
|
|
function nonRelativeModuleNameForTypingCache(moduleName) {
|
|
return nodeCoreModules.has(moduleName) ? "node" : moduleName;
|
|
}
|
|
function loadSafeList(host, safeListPath) {
|
|
const result = readConfigFile(safeListPath, (path) => host.readFile(path));
|
|
return new Map(getEntries(result.config));
|
|
}
|
|
function loadTypesMap(host, typesMapPath) {
|
|
const result = readConfigFile(typesMapPath, (path) => host.readFile(path));
|
|
if (result.config) {
|
|
return new Map(getEntries(result.config.simpleMap));
|
|
}
|
|
return void 0;
|
|
}
|
|
function discoverTypings(host, log, fileNames, projectRootPath, safeList, packageNameToTypingLocation, typeAcquisition, unresolvedImports, typesRegistry, compilerOptions) {
|
|
if (!typeAcquisition || !typeAcquisition.enable) {
|
|
return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] };
|
|
}
|
|
const inferredTypings = /* @__PURE__ */ new Map();
|
|
fileNames = mapDefined(fileNames, (fileName) => {
|
|
const path = normalizePath(fileName);
|
|
if (hasJSFileExtension(path)) {
|
|
return path;
|
|
}
|
|
});
|
|
const filesToWatch = [];
|
|
if (typeAcquisition.include)
|
|
addInferredTypings(typeAcquisition.include, "Explicitly included types");
|
|
const exclude = typeAcquisition.exclude || [];
|
|
if (!compilerOptions.types) {
|
|
const possibleSearchDirs = new Set(fileNames.map(getDirectoryPath));
|
|
possibleSearchDirs.add(projectRootPath);
|
|
possibleSearchDirs.forEach((searchDir) => {
|
|
getTypingNames(searchDir, "bower.json", "bower_components", filesToWatch);
|
|
getTypingNames(searchDir, "package.json", "node_modules", filesToWatch);
|
|
});
|
|
}
|
|
if (!typeAcquisition.disableFilenameBasedTypeAcquisition) {
|
|
getTypingNamesFromSourceFileNames(fileNames);
|
|
}
|
|
if (unresolvedImports) {
|
|
const module2 = deduplicate(
|
|
unresolvedImports.map(nonRelativeModuleNameForTypingCache),
|
|
equateStringsCaseSensitive,
|
|
compareStringsCaseSensitive
|
|
);
|
|
addInferredTypings(module2, "Inferred typings from unresolved imports");
|
|
}
|
|
packageNameToTypingLocation.forEach((typing, name) => {
|
|
const registryEntry = typesRegistry.get(name);
|
|
if (inferredTypings.has(name) && inferredTypings.get(name) === void 0 && registryEntry !== void 0 && isTypingUpToDate(typing, registryEntry)) {
|
|
inferredTypings.set(name, typing.typingLocation);
|
|
}
|
|
});
|
|
for (const excludeTypingName of exclude) {
|
|
const didDelete = inferredTypings.delete(excludeTypingName);
|
|
if (didDelete && log)
|
|
log(`Typing for ${excludeTypingName} is in exclude list, will be ignored.`);
|
|
}
|
|
const newTypingNames = [];
|
|
const cachedTypingPaths = [];
|
|
inferredTypings.forEach((inferred, typing) => {
|
|
if (inferred !== void 0) {
|
|
cachedTypingPaths.push(inferred);
|
|
} else {
|
|
newTypingNames.push(typing);
|
|
}
|
|
});
|
|
const result = { cachedTypingPaths, newTypingNames, filesToWatch };
|
|
if (log)
|
|
log(`Result: ${JSON.stringify(result)}`);
|
|
return result;
|
|
function addInferredTyping(typingName) {
|
|
if (!inferredTypings.has(typingName)) {
|
|
inferredTypings.set(typingName, void 0);
|
|
}
|
|
}
|
|
function addInferredTypings(typingNames, message) {
|
|
if (log)
|
|
log(`${message}: ${JSON.stringify(typingNames)}`);
|
|
forEach(typingNames, addInferredTyping);
|
|
}
|
|
function getTypingNames(projectRootPath2, manifestName, modulesDirName, filesToWatch2) {
|
|
const manifestPath = combinePaths(projectRootPath2, manifestName);
|
|
let manifest;
|
|
let manifestTypingNames;
|
|
if (host.fileExists(manifestPath)) {
|
|
filesToWatch2.push(manifestPath);
|
|
manifest = readConfigFile(manifestPath, (path) => host.readFile(path)).config;
|
|
manifestTypingNames = flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], getOwnKeys);
|
|
addInferredTypings(manifestTypingNames, `Typing names in '${manifestPath}' dependencies`);
|
|
}
|
|
const packagesFolderPath = combinePaths(projectRootPath2, modulesDirName);
|
|
filesToWatch2.push(packagesFolderPath);
|
|
if (!host.directoryExists(packagesFolderPath)) {
|
|
return;
|
|
}
|
|
const packageNames = [];
|
|
const dependencyManifestNames = manifestTypingNames ? manifestTypingNames.map((typingName) => combinePaths(packagesFolderPath, typingName, manifestName)) : host.readDirectory(packagesFolderPath, [".json" /* Json */], void 0, void 0, 3).filter((manifestPath2) => {
|
|
if (getBaseFileName(manifestPath2) !== manifestName) {
|
|
return false;
|
|
}
|
|
const pathComponents2 = getPathComponents(normalizePath(manifestPath2));
|
|
const isScoped = pathComponents2[pathComponents2.length - 3][0] === "@";
|
|
return isScoped && toFileNameLowerCase(pathComponents2[pathComponents2.length - 4]) === modulesDirName || !isScoped && toFileNameLowerCase(pathComponents2[pathComponents2.length - 3]) === modulesDirName;
|
|
});
|
|
if (log)
|
|
log(`Searching for typing names in ${packagesFolderPath}; all files: ${JSON.stringify(dependencyManifestNames)}`);
|
|
for (const manifestPath2 of dependencyManifestNames) {
|
|
const normalizedFileName = normalizePath(manifestPath2);
|
|
const result2 = readConfigFile(normalizedFileName, (path) => host.readFile(path));
|
|
const manifest2 = result2.config;
|
|
if (!manifest2.name) {
|
|
continue;
|
|
}
|
|
const ownTypes = manifest2.types || manifest2.typings;
|
|
if (ownTypes) {
|
|
const absolutePath = getNormalizedAbsolutePath(ownTypes, getDirectoryPath(normalizedFileName));
|
|
if (host.fileExists(absolutePath)) {
|
|
if (log)
|
|
log(` Package '${manifest2.name}' provides its own types.`);
|
|
inferredTypings.set(manifest2.name, absolutePath);
|
|
} else {
|
|
if (log)
|
|
log(` Package '${manifest2.name}' provides its own types but they are missing.`);
|
|
}
|
|
} else {
|
|
packageNames.push(manifest2.name);
|
|
}
|
|
}
|
|
addInferredTypings(packageNames, " Found package names");
|
|
}
|
|
function getTypingNamesFromSourceFileNames(fileNames2) {
|
|
const fromFileNames = mapDefined(fileNames2, (j) => {
|
|
if (!hasJSFileExtension(j))
|
|
return void 0;
|
|
const inferredTypingName = removeFileExtension(toFileNameLowerCase(getBaseFileName(j)));
|
|
const cleanedTypingName = removeMinAndVersionNumbers(inferredTypingName);
|
|
return safeList.get(cleanedTypingName);
|
|
});
|
|
if (fromFileNames.length) {
|
|
addInferredTypings(fromFileNames, "Inferred typings from file names");
|
|
}
|
|
const hasJsxFile = some(fileNames2, (f) => fileExtensionIs(f, ".jsx" /* Jsx */));
|
|
if (hasJsxFile) {
|
|
if (log)
|
|
log(`Inferred 'react' typings due to presence of '.jsx' extension`);
|
|
addInferredTyping("react");
|
|
}
|
|
}
|
|
}
|
|
var NameValidationResult = /* @__PURE__ */ ((NameValidationResult2) => {
|
|
NameValidationResult2[NameValidationResult2["Ok"] = 0] = "Ok";
|
|
NameValidationResult2[NameValidationResult2["EmptyName"] = 1] = "EmptyName";
|
|
NameValidationResult2[NameValidationResult2["NameTooLong"] = 2] = "NameTooLong";
|
|
NameValidationResult2[NameValidationResult2["NameStartsWithDot"] = 3] = "NameStartsWithDot";
|
|
NameValidationResult2[NameValidationResult2["NameStartsWithUnderscore"] = 4] = "NameStartsWithUnderscore";
|
|
NameValidationResult2[NameValidationResult2["NameContainsNonURISafeCharacters"] = 5] = "NameContainsNonURISafeCharacters";
|
|
return NameValidationResult2;
|
|
})(NameValidationResult || {});
|
|
var maxPackageNameLength = 214;
|
|
function validatePackageName(packageName) {
|
|
return validatePackageNameWorker(packageName, true);
|
|
}
|
|
function validatePackageNameWorker(packageName, supportScopedPackage) {
|
|
if (!packageName) {
|
|
return 1 /* EmptyName */;
|
|
}
|
|
if (packageName.length > maxPackageNameLength) {
|
|
return 2 /* NameTooLong */;
|
|
}
|
|
if (packageName.charCodeAt(0) === 46 /* dot */) {
|
|
return 3 /* NameStartsWithDot */;
|
|
}
|
|
if (packageName.charCodeAt(0) === 95 /* _ */) {
|
|
return 4 /* NameStartsWithUnderscore */;
|
|
}
|
|
if (supportScopedPackage) {
|
|
const matches = /^@([^/]+)\/([^/]+)$/.exec(packageName);
|
|
if (matches) {
|
|
const scopeResult = validatePackageNameWorker(matches[1], false);
|
|
if (scopeResult !== 0 /* Ok */) {
|
|
return { name: matches[1], isScopeName: true, result: scopeResult };
|
|
}
|
|
const packageResult = validatePackageNameWorker(matches[2], false);
|
|
if (packageResult !== 0 /* Ok */) {
|
|
return { name: matches[2], isScopeName: false, result: packageResult };
|
|
}
|
|
return 0 /* Ok */;
|
|
}
|
|
}
|
|
if (encodeURIComponent(packageName) !== packageName) {
|
|
return 5 /* NameContainsNonURISafeCharacters */;
|
|
}
|
|
return 0 /* Ok */;
|
|
}
|
|
function renderPackageNameValidationFailure(result, typing) {
|
|
return typeof result === "object" ? renderPackageNameValidationFailureWorker(typing, result.result, result.name, result.isScopeName) : renderPackageNameValidationFailureWorker(typing, result, typing, false);
|
|
}
|
|
function renderPackageNameValidationFailureWorker(typing, result, name, isScopeName) {
|
|
const kind = isScopeName ? "Scope" : "Package";
|
|
switch (result) {
|
|
case 1 /* EmptyName */:
|
|
return `'${typing}':: ${kind} name '${name}' cannot be empty`;
|
|
case 2 /* NameTooLong */:
|
|
return `'${typing}':: ${kind} name '${name}' should be less than ${maxPackageNameLength} characters`;
|
|
case 3 /* NameStartsWithDot */:
|
|
return `'${typing}':: ${kind} name '${name}' cannot start with '.'`;
|
|
case 4 /* NameStartsWithUnderscore */:
|
|
return `'${typing}':: ${kind} name '${name}' cannot start with '_'`;
|
|
case 5 /* NameContainsNonURISafeCharacters */:
|
|
return `'${typing}':: ${kind} name '${name}' contains non URI safe characters`;
|
|
case 0 /* Ok */:
|
|
return Debug.fail();
|
|
default:
|
|
throw Debug.assertNever(result);
|
|
}
|
|
}
|
|
|
|
// src/jsTyping/shared.ts
|
|
var ActionSet = "action::set";
|
|
var ActionInvalidate = "action::invalidate";
|
|
var ActionPackageInstalled = "action::packageInstalled";
|
|
var EventTypesRegistry = "event::typesRegistry";
|
|
var EventBeginInstallTypes = "event::beginInstallTypes";
|
|
var EventEndInstallTypes = "event::endInstallTypes";
|
|
var EventInitializationFailed = "event::initializationFailed";
|
|
var Arguments;
|
|
((Arguments2) => {
|
|
Arguments2.GlobalCacheLocation = "--globalTypingsCacheLocation";
|
|
Arguments2.LogFile = "--logFile";
|
|
Arguments2.EnableTelemetry = "--enableTelemetry";
|
|
Arguments2.TypingSafeListLocation = "--typingSafeListLocation";
|
|
Arguments2.TypesMapLocation = "--typesMapLocation";
|
|
Arguments2.NpmLocation = "--npmLocation";
|
|
Arguments2.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation";
|
|
})(Arguments || (Arguments = {}));
|
|
function hasArgument(argumentName) {
|
|
return sys.args.indexOf(argumentName) >= 0;
|
|
}
|
|
function findArgument(argumentName) {
|
|
const index = sys.args.indexOf(argumentName);
|
|
return index >= 0 && index < sys.args.length - 1 ? sys.args[index + 1] : void 0;
|
|
}
|
|
function nowString() {
|
|
const d = new Date();
|
|
return `${padLeft(d.getHours().toString(), 2, "0")}:${padLeft(d.getMinutes().toString(), 2, "0")}:${padLeft(d.getSeconds().toString(), 2, "0")}.${padLeft(d.getMilliseconds().toString(), 3, "0")}`;
|
|
}
|
|
|
|
// src/server/_namespaces/ts.server.ts
|
|
var ts_server_exports2 = {};
|
|
__export(ts_server_exports2, {
|
|
ActionInvalidate: () => ActionInvalidate,
|
|
ActionPackageInstalled: () => ActionPackageInstalled,
|
|
ActionSet: () => ActionSet,
|
|
Arguments: () => Arguments,
|
|
AutoImportProviderProject: () => AutoImportProviderProject,
|
|
CharRangeSection: () => CharRangeSection,
|
|
CommandNames: () => CommandNames,
|
|
ConfigFileDiagEvent: () => ConfigFileDiagEvent,
|
|
ConfiguredProject: () => ConfiguredProject2,
|
|
Errors: () => Errors,
|
|
EventBeginInstallTypes: () => EventBeginInstallTypes,
|
|
EventEndInstallTypes: () => EventEndInstallTypes,
|
|
EventInitializationFailed: () => EventInitializationFailed,
|
|
EventTypesRegistry: () => EventTypesRegistry,
|
|
ExternalProject: () => ExternalProject2,
|
|
GcTimer: () => GcTimer,
|
|
InferredProject: () => InferredProject2,
|
|
LargeFileReferencedEvent: () => LargeFileReferencedEvent,
|
|
LineIndex: () => LineIndex,
|
|
LineLeaf: () => LineLeaf,
|
|
LineNode: () => LineNode,
|
|
LogLevel: () => LogLevel2,
|
|
Msg: () => Msg,
|
|
OpenFileInfoTelemetryEvent: () => OpenFileInfoTelemetryEvent,
|
|
Project: () => Project3,
|
|
ProjectInfoTelemetryEvent: () => ProjectInfoTelemetryEvent,
|
|
ProjectKind: () => ProjectKind,
|
|
ProjectLanguageServiceStateEvent: () => ProjectLanguageServiceStateEvent,
|
|
ProjectLoadingFinishEvent: () => ProjectLoadingFinishEvent,
|
|
ProjectLoadingStartEvent: () => ProjectLoadingStartEvent,
|
|
ProjectReferenceProjectLoadKind: () => ProjectReferenceProjectLoadKind,
|
|
ProjectService: () => ProjectService3,
|
|
ProjectsUpdatedInBackgroundEvent: () => ProjectsUpdatedInBackgroundEvent,
|
|
ScriptInfo: () => ScriptInfo,
|
|
ScriptVersionCache: () => ScriptVersionCache,
|
|
Session: () => Session3,
|
|
TextStorage: () => TextStorage,
|
|
ThrottledOperations: () => ThrottledOperations,
|
|
TypingsCache: () => TypingsCache,
|
|
allFilesAreJsOrDts: () => allFilesAreJsOrDts,
|
|
allRootFilesAreJsOrDts: () => allRootFilesAreJsOrDts,
|
|
asNormalizedPath: () => asNormalizedPath,
|
|
convertCompilerOptions: () => convertCompilerOptions,
|
|
convertFormatOptions: () => convertFormatOptions,
|
|
convertScriptKindName: () => convertScriptKindName,
|
|
convertTypeAcquisition: () => convertTypeAcquisition,
|
|
convertUserPreferences: () => convertUserPreferences,
|
|
convertWatchOptions: () => convertWatchOptions,
|
|
countEachFileTypes: () => countEachFileTypes,
|
|
createInstallTypingsRequest: () => createInstallTypingsRequest,
|
|
createModuleSpecifierCache: () => createModuleSpecifierCache,
|
|
createNormalizedPathMap: () => createNormalizedPathMap,
|
|
createPackageJsonCache: () => createPackageJsonCache,
|
|
createSortedArray: () => createSortedArray2,
|
|
emptyArray: () => emptyArray2,
|
|
findArgument: () => findArgument,
|
|
forEachResolvedProjectReferenceProject: () => forEachResolvedProjectReferenceProject,
|
|
formatMessage: () => formatMessage2,
|
|
getBaseConfigFileName: () => getBaseConfigFileName,
|
|
getLocationInNewDocument: () => getLocationInNewDocument,
|
|
hasArgument: () => hasArgument,
|
|
hasNoTypeScriptSource: () => hasNoTypeScriptSource,
|
|
indent: () => indent2,
|
|
isConfigFile: () => isConfigFile,
|
|
isConfiguredProject: () => isConfiguredProject,
|
|
isDynamicFileName: () => isDynamicFileName,
|
|
isExternalProject: () => isExternalProject,
|
|
isInferredProject: () => isInferredProject,
|
|
isInferredProjectName: () => isInferredProjectName,
|
|
makeAutoImportProviderProjectName: () => makeAutoImportProviderProjectName,
|
|
makeAuxiliaryProjectName: () => makeAuxiliaryProjectName,
|
|
makeInferredProjectName: () => makeInferredProjectName,
|
|
maxFileSize: () => maxFileSize,
|
|
maxProgramSizeForNonTsFiles: () => maxProgramSizeForNonTsFiles,
|
|
normalizedPathToPath: () => normalizedPathToPath,
|
|
nowString: () => nowString,
|
|
nullCancellationToken: () => nullCancellationToken,
|
|
nullTypingsInstaller: () => nullTypingsInstaller,
|
|
projectContainsInfoDirectly: () => projectContainsInfoDirectly,
|
|
protocol: () => ts_server_protocol_exports,
|
|
removeSorted: () => removeSorted,
|
|
stringifyIndented: () => stringifyIndented,
|
|
toEvent: () => toEvent,
|
|
toNormalizedPath: () => toNormalizedPath,
|
|
tryConvertScriptKindName: () => tryConvertScriptKindName,
|
|
updateProjectIfDirty: () => updateProjectIfDirty
|
|
});
|
|
|
|
// src/server/_namespaces/ts.ts
|
|
var ts_exports3 = {};
|
|
__export(ts_exports3, {
|
|
ANONYMOUS: () => ANONYMOUS,
|
|
AccessFlags: () => AccessFlags,
|
|
AssertionLevel: () => AssertionLevel,
|
|
AssignmentDeclarationKind: () => AssignmentDeclarationKind,
|
|
AssignmentKind: () => AssignmentKind,
|
|
Associativity: () => Associativity,
|
|
BreakpointResolver: () => ts_BreakpointResolver_exports,
|
|
BuilderFileEmit: () => BuilderFileEmit,
|
|
BuilderProgramKind: () => BuilderProgramKind,
|
|
BuilderState: () => BuilderState,
|
|
BundleFileSectionKind: () => BundleFileSectionKind,
|
|
CallHierarchy: () => ts_CallHierarchy_exports,
|
|
CharacterCodes: () => CharacterCodes,
|
|
CheckFlags: () => CheckFlags,
|
|
CheckMode: () => CheckMode,
|
|
ClassificationType: () => ClassificationType,
|
|
ClassificationTypeNames: () => ClassificationTypeNames,
|
|
CommentDirectiveType: () => CommentDirectiveType,
|
|
Comparison: () => Comparison,
|
|
CompletionInfoFlags: () => CompletionInfoFlags,
|
|
CompletionTriggerKind: () => CompletionTriggerKind,
|
|
Completions: () => ts_Completions_exports,
|
|
ConfigFileProgramReloadLevel: () => ConfigFileProgramReloadLevel,
|
|
ContextFlags: () => ContextFlags,
|
|
CoreServicesShimHostAdapter: () => CoreServicesShimHostAdapter,
|
|
Debug: () => Debug,
|
|
DiagnosticCategory: () => DiagnosticCategory,
|
|
Diagnostics: () => Diagnostics,
|
|
DocumentHighlights: () => DocumentHighlights,
|
|
ElementFlags: () => ElementFlags,
|
|
EmitFlags: () => EmitFlags,
|
|
EmitHint: () => EmitHint,
|
|
EmitOnly: () => EmitOnly,
|
|
EndOfLineState: () => EndOfLineState,
|
|
EnumKind: () => EnumKind,
|
|
ExitStatus: () => ExitStatus,
|
|
ExportKind: () => ExportKind,
|
|
Extension: () => Extension,
|
|
ExternalEmitHelpers: () => ExternalEmitHelpers,
|
|
FileIncludeKind: () => FileIncludeKind,
|
|
FilePreprocessingDiagnosticsKind: () => FilePreprocessingDiagnosticsKind,
|
|
FileSystemEntryKind: () => FileSystemEntryKind,
|
|
FileWatcherEventKind: () => FileWatcherEventKind,
|
|
FindAllReferences: () => ts_FindAllReferences_exports,
|
|
FlattenLevel: () => FlattenLevel,
|
|
FlowFlags: () => FlowFlags,
|
|
ForegroundColorEscapeSequences: () => ForegroundColorEscapeSequences,
|
|
FunctionFlags: () => FunctionFlags,
|
|
GeneratedIdentifierFlags: () => GeneratedIdentifierFlags,
|
|
GetLiteralTextFlags: () => GetLiteralTextFlags,
|
|
GoToDefinition: () => ts_GoToDefinition_exports,
|
|
HighlightSpanKind: () => HighlightSpanKind,
|
|
ImportKind: () => ImportKind,
|
|
ImportsNotUsedAsValues: () => ImportsNotUsedAsValues,
|
|
IndentStyle: () => IndentStyle,
|
|
IndexKind: () => IndexKind,
|
|
InferenceFlags: () => InferenceFlags,
|
|
InferencePriority: () => InferencePriority,
|
|
InlayHintKind: () => InlayHintKind,
|
|
InlayHints: () => ts_InlayHints_exports,
|
|
InternalSymbolName: () => InternalSymbolName,
|
|
InvalidatedProjectKind: () => InvalidatedProjectKind,
|
|
JsDoc: () => ts_JsDoc_exports,
|
|
JsTyping: () => ts_JsTyping_exports,
|
|
JsxEmit: () => JsxEmit,
|
|
JsxFlags: () => JsxFlags,
|
|
JsxReferenceKind: () => JsxReferenceKind,
|
|
LanguageServiceMode: () => LanguageServiceMode,
|
|
LanguageServiceShimHostAdapter: () => LanguageServiceShimHostAdapter,
|
|
LanguageVariant: () => LanguageVariant,
|
|
LexicalEnvironmentFlags: () => LexicalEnvironmentFlags,
|
|
ListFormat: () => ListFormat,
|
|
LogLevel: () => LogLevel,
|
|
MemberOverrideStatus: () => MemberOverrideStatus,
|
|
ModifierFlags: () => ModifierFlags,
|
|
ModuleDetectionKind: () => ModuleDetectionKind,
|
|
ModuleInstanceState: () => ModuleInstanceState,
|
|
ModuleKind: () => ModuleKind,
|
|
ModuleResolutionKind: () => ModuleResolutionKind,
|
|
NavigateTo: () => ts_NavigateTo_exports,
|
|
NavigationBar: () => ts_NavigationBar_exports,
|
|
NewLineKind: () => NewLineKind,
|
|
NodeBuilderFlags: () => NodeBuilderFlags,
|
|
NodeCheckFlags: () => NodeCheckFlags,
|
|
NodeFactoryFlags: () => NodeFactoryFlags,
|
|
NodeFlags: () => NodeFlags,
|
|
NodeResolutionFeatures: () => NodeResolutionFeatures,
|
|
ObjectFlags: () => ObjectFlags,
|
|
OperationCanceledException: () => OperationCanceledException,
|
|
OperatorPrecedence: () => OperatorPrecedence,
|
|
OrganizeImports: () => ts_OrganizeImports_exports,
|
|
OrganizeImportsMode: () => OrganizeImportsMode,
|
|
OuterExpressionKinds: () => OuterExpressionKinds,
|
|
OutliningElementsCollector: () => ts_OutliningElementsCollector_exports,
|
|
OutliningSpanKind: () => OutliningSpanKind,
|
|
OutputFileType: () => OutputFileType,
|
|
PackageJsonAutoImportPreference: () => PackageJsonAutoImportPreference,
|
|
PackageJsonDependencyGroup: () => PackageJsonDependencyGroup,
|
|
PatternMatchKind: () => PatternMatchKind,
|
|
PollingInterval: () => PollingInterval,
|
|
PollingWatchKind: () => PollingWatchKind,
|
|
PragmaKindFlags: () => PragmaKindFlags,
|
|
PrivateIdentifierKind: () => PrivateIdentifierKind2,
|
|
ProcessLevel: () => ProcessLevel,
|
|
QuotePreference: () => QuotePreference,
|
|
RelationComparisonResult: () => RelationComparisonResult,
|
|
Rename: () => ts_Rename_exports,
|
|
ScriptElementKind: () => ScriptElementKind,
|
|
ScriptElementKindModifier: () => ScriptElementKindModifier,
|
|
ScriptKind: () => ScriptKind,
|
|
ScriptSnapshot: () => ScriptSnapshot,
|
|
ScriptTarget: () => ScriptTarget,
|
|
SemanticClassificationFormat: () => SemanticClassificationFormat,
|
|
SemanticMeaning: () => SemanticMeaning,
|
|
SemicolonPreference: () => SemicolonPreference,
|
|
SignatureCheckMode: () => SignatureCheckMode,
|
|
SignatureFlags: () => SignatureFlags,
|
|
SignatureHelp: () => ts_SignatureHelp_exports,
|
|
SignatureKind: () => SignatureKind,
|
|
SmartSelectionRange: () => ts_SmartSelectionRange_exports,
|
|
SnippetKind: () => SnippetKind,
|
|
StructureIsReused: () => StructureIsReused,
|
|
SymbolAccessibility: () => SymbolAccessibility,
|
|
SymbolDisplay: () => ts_SymbolDisplay_exports,
|
|
SymbolDisplayPartKind: () => SymbolDisplayPartKind,
|
|
SymbolFlags: () => SymbolFlags,
|
|
SymbolFormatFlags: () => SymbolFormatFlags,
|
|
SyntaxKind: () => SyntaxKind,
|
|
SyntheticSymbolKind: () => SyntheticSymbolKind,
|
|
Ternary: () => Ternary,
|
|
ThrottledCancellationToken: () => ThrottledCancellationToken,
|
|
TokenClass: () => TokenClass,
|
|
TokenFlags: () => TokenFlags,
|
|
TransformFlags: () => TransformFlags,
|
|
TypeFacts: () => TypeFacts,
|
|
TypeFlags: () => TypeFlags,
|
|
TypeFormatFlags: () => TypeFormatFlags,
|
|
TypeMapKind: () => TypeMapKind,
|
|
TypePredicateKind: () => TypePredicateKind,
|
|
TypeReferenceSerializationKind: () => TypeReferenceSerializationKind,
|
|
TypeScriptServicesFactory: () => TypeScriptServicesFactory,
|
|
UnionReduction: () => UnionReduction,
|
|
UpToDateStatusType: () => UpToDateStatusType,
|
|
VarianceFlags: () => VarianceFlags,
|
|
Version: () => Version,
|
|
VersionRange: () => VersionRange,
|
|
WatchDirectoryFlags: () => WatchDirectoryFlags,
|
|
WatchDirectoryKind: () => WatchDirectoryKind,
|
|
WatchFileKind: () => WatchFileKind,
|
|
WatchLogLevel: () => WatchLogLevel,
|
|
WatchType: () => WatchType,
|
|
addEmitFlags: () => addEmitFlags,
|
|
addEmitHelper: () => addEmitHelper,
|
|
addEmitHelpers: () => addEmitHelpers,
|
|
addNodeFactoryPatcher: () => addNodeFactoryPatcher,
|
|
addRange: () => addRange,
|
|
addRelatedInfo: () => addRelatedInfo,
|
|
addSyntheticLeadingComment: () => addSyntheticLeadingComment,
|
|
addSyntheticTrailingComment: () => addSyntheticTrailingComment,
|
|
addToSeen: () => addToSeen,
|
|
advancedAsyncSuperHelper: () => advancedAsyncSuperHelper,
|
|
affectsDeclarationPathOptionDeclarations: () => affectsDeclarationPathOptionDeclarations,
|
|
affectsEmitOptionDeclarations: () => affectsEmitOptionDeclarations,
|
|
allKeysStartWithDot: () => allKeysStartWithDot,
|
|
altDirectorySeparator: () => altDirectorySeparator,
|
|
and: () => and,
|
|
append: () => append,
|
|
appendIfUnique: () => appendIfUnique,
|
|
arrayFrom: () => arrayFrom,
|
|
arrayIsEqualTo: () => arrayIsEqualTo,
|
|
arrayIsHomogeneous: () => arrayIsHomogeneous,
|
|
arrayIsSorted: () => arrayIsSorted,
|
|
arrayIterator: () => arrayIterator,
|
|
arrayOf: () => arrayOf,
|
|
arrayReverseIterator: () => arrayReverseIterator,
|
|
arrayToMap: () => arrayToMap,
|
|
arrayToMultiMap: () => arrayToMultiMap,
|
|
arrayToNumericMap: () => arrayToNumericMap,
|
|
arraysEqual: () => arraysEqual,
|
|
assertType: () => assertType,
|
|
assign: () => assign,
|
|
assignHelper: () => assignHelper,
|
|
asyncDelegator: () => asyncDelegator,
|
|
asyncGeneratorHelper: () => asyncGeneratorHelper,
|
|
asyncSuperHelper: () => asyncSuperHelper,
|
|
asyncValues: () => asyncValues,
|
|
attachFileToDiagnostics: () => attachFileToDiagnostics,
|
|
awaitHelper: () => awaitHelper,
|
|
awaiterHelper: () => awaiterHelper,
|
|
base64decode: () => base64decode,
|
|
base64encode: () => base64encode,
|
|
binarySearch: () => binarySearch,
|
|
binarySearchKey: () => binarySearchKey,
|
|
bindSourceFile: () => bindSourceFile,
|
|
breakIntoCharacterSpans: () => breakIntoCharacterSpans,
|
|
breakIntoWordSpans: () => breakIntoWordSpans,
|
|
buildLinkParts: () => buildLinkParts,
|
|
buildOpts: () => buildOpts,
|
|
buildOverload: () => buildOverload,
|
|
canBeConvertedToAsync: () => canBeConvertedToAsync,
|
|
canHaveDecorators: () => canHaveDecorators,
|
|
canHaveExportModifier: () => canHaveExportModifier,
|
|
canHaveIllegalDecorators: () => canHaveIllegalDecorators,
|
|
canHaveIllegalModifiers: () => canHaveIllegalModifiers,
|
|
canHaveIllegalType: () => canHaveIllegalType,
|
|
canHaveIllegalTypeParameters: () => canHaveIllegalTypeParameters,
|
|
canHaveModifiers: () => canHaveModifiers,
|
|
canJsonReportNoInputFiles: () => canJsonReportNoInputFiles,
|
|
canProduceDiagnostics: () => canProduceDiagnostics,
|
|
canWatchDirectoryOrFile: () => canWatchDirectoryOrFile,
|
|
cartesianProduct: () => cartesianProduct,
|
|
cast: () => cast,
|
|
chainBundle: () => chainBundle,
|
|
chainDiagnosticMessages: () => chainDiagnosticMessages,
|
|
changeAnyExtension: () => changeAnyExtension,
|
|
changeCompilerHostLikeToUseCache: () => changeCompilerHostLikeToUseCache,
|
|
changeExtension: () => changeExtension,
|
|
changesAffectModuleResolution: () => changesAffectModuleResolution,
|
|
changesAffectingProgramStructure: () => changesAffectingProgramStructure,
|
|
childIsDecorated: () => childIsDecorated,
|
|
classOrConstructorParameterIsDecorated: () => classOrConstructorParameterIsDecorated,
|
|
classPrivateFieldGetHelper: () => classPrivateFieldGetHelper,
|
|
classPrivateFieldInHelper: () => classPrivateFieldInHelper,
|
|
classPrivateFieldSetHelper: () => classPrivateFieldSetHelper,
|
|
classicNameResolver: () => classicNameResolver,
|
|
classifier: () => ts_classifier_exports,
|
|
cleanExtendedConfigCache: () => cleanExtendedConfigCache,
|
|
clear: () => clear,
|
|
clearMap: () => clearMap,
|
|
clearSharedExtendedConfigFileWatcher: () => clearSharedExtendedConfigFileWatcher,
|
|
climbPastPropertyAccess: () => climbPastPropertyAccess,
|
|
climbPastPropertyOrElementAccess: () => climbPastPropertyOrElementAccess,
|
|
clone: () => clone,
|
|
cloneCompilerOptions: () => cloneCompilerOptions,
|
|
closeFileWatcher: () => closeFileWatcher,
|
|
closeFileWatcherOf: () => closeFileWatcherOf,
|
|
codefix: () => ts_codefix_exports,
|
|
collapseTextChangeRangesAcrossMultipleVersions: () => collapseTextChangeRangesAcrossMultipleVersions,
|
|
collectExternalModuleInfo: () => collectExternalModuleInfo,
|
|
combine: () => combine,
|
|
combinePaths: () => combinePaths,
|
|
commentPragmas: () => commentPragmas,
|
|
commonOptionsWithBuild: () => commonOptionsWithBuild,
|
|
commonPackageFolders: () => commonPackageFolders,
|
|
compact: () => compact,
|
|
compareBooleans: () => compareBooleans,
|
|
compareDataObjects: () => compareDataObjects,
|
|
compareDiagnostics: () => compareDiagnostics,
|
|
compareDiagnosticsSkipRelatedInformation: () => compareDiagnosticsSkipRelatedInformation,
|
|
compareEmitHelpers: () => compareEmitHelpers,
|
|
compareNumberOfDirectorySeparators: () => compareNumberOfDirectorySeparators,
|
|
comparePaths: () => comparePaths,
|
|
comparePathsCaseInsensitive: () => comparePathsCaseInsensitive,
|
|
comparePathsCaseSensitive: () => comparePathsCaseSensitive,
|
|
comparePatternKeys: () => comparePatternKeys,
|
|
compareProperties: () => compareProperties,
|
|
compareStringsCaseInsensitive: () => compareStringsCaseInsensitive,
|
|
compareStringsCaseSensitive: () => compareStringsCaseSensitive,
|
|
compareStringsCaseSensitiveUI: () => compareStringsCaseSensitiveUI,
|
|
compareTextSpans: () => compareTextSpans,
|
|
compareValues: () => compareValues,
|
|
compileOnSaveCommandLineOption: () => compileOnSaveCommandLineOption,
|
|
compilerOptionsAffectDeclarationPath: () => compilerOptionsAffectDeclarationPath,
|
|
compilerOptionsAffectEmit: () => compilerOptionsAffectEmit,
|
|
compilerOptionsAffectSemanticDiagnostics: () => compilerOptionsAffectSemanticDiagnostics,
|
|
compilerOptionsDidYouMeanDiagnostics: () => compilerOptionsDidYouMeanDiagnostics,
|
|
compilerOptionsIndicateEsModules: () => compilerOptionsIndicateEsModules,
|
|
compose: () => compose,
|
|
computeCommonSourceDirectoryOfFilenames: () => computeCommonSourceDirectoryOfFilenames,
|
|
computeLineAndCharacterOfPosition: () => computeLineAndCharacterOfPosition,
|
|
computeLineOfPosition: () => computeLineOfPosition,
|
|
computeLineStarts: () => computeLineStarts,
|
|
computePositionOfLineAndCharacter: () => computePositionOfLineAndCharacter,
|
|
computeSignature: () => computeSignature,
|
|
computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
|
|
computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
|
|
concatenate: () => concatenate,
|
|
concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
|
|
consumesNodeCoreModules: () => consumesNodeCoreModules,
|
|
contains: () => contains,
|
|
containsIgnoredPath: () => containsIgnoredPath,
|
|
containsParseError: () => containsParseError,
|
|
containsPath: () => containsPath,
|
|
convertCompilerOptionsForTelemetry: () => convertCompilerOptionsForTelemetry,
|
|
convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
|
|
convertEnableAutoDiscoveryToEnable: () => convertEnableAutoDiscoveryToEnable,
|
|
convertJsonOption: () => convertJsonOption,
|
|
convertToBase64: () => convertToBase64,
|
|
convertToObject: () => convertToObject,
|
|
convertToObjectWorker: () => convertToObjectWorker,
|
|
convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
|
|
convertToRelativePath: () => convertToRelativePath,
|
|
convertToTSConfig: () => convertToTSConfig,
|
|
convertTypeAcquisitionFromJson: () => convertTypeAcquisitionFromJson,
|
|
copyComments: () => copyComments,
|
|
copyEntries: () => copyEntries,
|
|
copyLeadingComments: () => copyLeadingComments,
|
|
copyProperties: () => copyProperties,
|
|
copyTrailingAsLeadingComments: () => copyTrailingAsLeadingComments,
|
|
copyTrailingComments: () => copyTrailingComments,
|
|
couldStartTrivia: () => couldStartTrivia,
|
|
countWhere: () => countWhere,
|
|
createAbstractBuilder: () => createAbstractBuilder,
|
|
createAccessorPropertyBackingField: () => createAccessorPropertyBackingField,
|
|
createAccessorPropertyGetRedirector: () => createAccessorPropertyGetRedirector,
|
|
createAccessorPropertySetRedirector: () => createAccessorPropertySetRedirector,
|
|
createAdd: () => createAdd,
|
|
createArrayBindingPattern: () => createArrayBindingPattern,
|
|
createArrayLiteral: () => createArrayLiteral,
|
|
createArrayTypeNode: () => createArrayTypeNode,
|
|
createArrowFunction: () => createArrowFunction,
|
|
createAsExpression: () => createAsExpression,
|
|
createAssignment: () => createAssignment,
|
|
createAwait: () => createAwait,
|
|
createBaseNodeFactory: () => createBaseNodeFactory,
|
|
createBigIntLiteral: () => createBigIntLiteral,
|
|
createBinary: () => createBinary,
|
|
createBinaryExpressionTrampoline: () => createBinaryExpressionTrampoline,
|
|
createBindingElement: () => createBindingElement,
|
|
createBindingHelper: () => createBindingHelper,
|
|
createBlock: () => createBlock,
|
|
createBreak: () => createBreak,
|
|
createBuildInfo: () => createBuildInfo,
|
|
createBuilderProgram: () => createBuilderProgram,
|
|
createBuilderProgramUsingProgramBuildInfo: () => createBuilderProgramUsingProgramBuildInfo,
|
|
createBuilderStatusReporter: () => createBuilderStatusReporter,
|
|
createBundle: () => createBundle,
|
|
createCacheWithRedirects: () => createCacheWithRedirects,
|
|
createCacheableExportInfoMap: () => createCacheableExportInfoMap,
|
|
createCachedDirectoryStructureHost: () => createCachedDirectoryStructureHost,
|
|
createCall: () => createCall,
|
|
createCallChain: () => createCallChain,
|
|
createCallSignature: () => createCallSignature,
|
|
createCaseBlock: () => createCaseBlock,
|
|
createCaseClause: () => createCaseClause,
|
|
createCatchClause: () => createCatchClause,
|
|
createClassDeclaration: () => createClassDeclaration,
|
|
createClassExpression: () => createClassExpression,
|
|
createClassifier: () => createClassifier,
|
|
createComma: () => createComma,
|
|
createCommaList: () => createCommaList,
|
|
createCommentDirectivesMap: () => createCommentDirectivesMap,
|
|
createCompilerDiagnostic: () => createCompilerDiagnostic,
|
|
createCompilerDiagnosticForInvalidCustomType: () => createCompilerDiagnosticForInvalidCustomType,
|
|
createCompilerDiagnosticFromMessageChain: () => createCompilerDiagnosticFromMessageChain,
|
|
createCompilerHost: () => createCompilerHost,
|
|
createCompilerHostFromProgramHost: () => createCompilerHostFromProgramHost,
|
|
createCompilerHostWorker: () => createCompilerHostWorker,
|
|
createComputedPropertyName: () => createComputedPropertyName,
|
|
createConditional: () => createConditional,
|
|
createConditionalTypeNode: () => createConditionalTypeNode,
|
|
createConstructSignature: () => createConstructSignature,
|
|
createConstructor: () => createConstructor,
|
|
createConstructorTypeNode: () => createConstructorTypeNode,
|
|
createContinue: () => createContinue,
|
|
createDebuggerStatement: () => createDebuggerStatement,
|
|
createDecorator: () => createDecorator,
|
|
createDefaultClause: () => createDefaultClause,
|
|
createDelete: () => createDelete,
|
|
createDetachedDiagnostic: () => createDetachedDiagnostic,
|
|
createDiagnosticCollection: () => createDiagnosticCollection,
|
|
createDiagnosticForFileFromMessageChain: () => createDiagnosticForFileFromMessageChain,
|
|
createDiagnosticForNode: () => createDiagnosticForNode,
|
|
createDiagnosticForNodeArray: () => createDiagnosticForNodeArray,
|
|
createDiagnosticForNodeFromMessageChain: () => createDiagnosticForNodeFromMessageChain,
|
|
createDiagnosticForNodeInSourceFile: () => createDiagnosticForNodeInSourceFile,
|
|
createDiagnosticForRange: () => createDiagnosticForRange,
|
|
createDiagnosticMessageChainFromDiagnostic: () => createDiagnosticMessageChainFromDiagnostic,
|
|
createDiagnosticReporter: () => createDiagnosticReporter,
|
|
createDo: () => createDo,
|
|
createDocumentPositionMapper: () => createDocumentPositionMapper,
|
|
createDocumentRegistry: () => createDocumentRegistry,
|
|
createDocumentRegistryInternal: () => createDocumentRegistryInternal,
|
|
createElementAccess: () => createElementAccess,
|
|
createElementAccessChain: () => createElementAccessChain,
|
|
createEmitAndSemanticDiagnosticsBuilderProgram: () => createEmitAndSemanticDiagnosticsBuilderProgram,
|
|
createEmitHelperFactory: () => createEmitHelperFactory,
|
|
createEmptyExports: () => createEmptyExports,
|
|
createEmptyStatement: () => createEmptyStatement,
|
|
createEnumDeclaration: () => createEnumDeclaration,
|
|
createEnumMember: () => createEnumMember,
|
|
createExportAssignment: () => createExportAssignment2,
|
|
createExportDeclaration: () => createExportDeclaration,
|
|
createExportDefault: () => createExportDefault,
|
|
createExportSpecifier: () => createExportSpecifier,
|
|
createExpressionForJsxElement: () => createExpressionForJsxElement,
|
|
createExpressionForJsxFragment: () => createExpressionForJsxFragment,
|
|
createExpressionForObjectLiteralElementLike: () => createExpressionForObjectLiteralElementLike,
|
|
createExpressionForPropertyName: () => createExpressionForPropertyName,
|
|
createExpressionFromEntityName: () => createExpressionFromEntityName,
|
|
createExpressionStatement: () => createExpressionStatement,
|
|
createExpressionWithTypeArguments: () => createExpressionWithTypeArguments,
|
|
createExternalHelpersImportDeclarationIfNeeded: () => createExternalHelpersImportDeclarationIfNeeded,
|
|
createExternalModuleExport: () => createExternalModuleExport,
|
|
createExternalModuleReference: () => createExternalModuleReference,
|
|
createFalse: () => createFalse,
|
|
createFileDiagnostic: () => createFileDiagnostic,
|
|
createFileDiagnosticFromMessageChain: () => createFileDiagnosticFromMessageChain,
|
|
createFileLevelUniqueName: () => createFileLevelUniqueName,
|
|
createFor: () => createFor,
|
|
createForIn: () => createForIn,
|
|
createForOf: () => createForOf,
|
|
createForOfBindingStatement: () => createForOfBindingStatement,
|
|
createFunctionDeclaration: () => createFunctionDeclaration,
|
|
createFunctionExpression: () => createFunctionExpression,
|
|
createFunctionTypeNode: () => createFunctionTypeNode,
|
|
createGetAccessor: () => createGetAccessor,
|
|
createGetCanonicalFileName: () => createGetCanonicalFileName,
|
|
createGetSourceFile: () => createGetSourceFile,
|
|
createGetSymbolAccessibilityDiagnosticForNode: () => createGetSymbolAccessibilityDiagnosticForNode,
|
|
createGetSymbolAccessibilityDiagnosticForNodeName: () => createGetSymbolAccessibilityDiagnosticForNodeName,
|
|
createGetSymbolWalker: () => createGetSymbolWalker,
|
|
createHeritageClause: () => createHeritageClause,
|
|
createIdentifier: () => createIdentifier,
|
|
createIf: () => createIf,
|
|
createImmediatelyInvokedArrowFunction: () => createImmediatelyInvokedArrowFunction,
|
|
createImmediatelyInvokedFunctionExpression: () => createImmediatelyInvokedFunctionExpression,
|
|
createImportClause: () => createImportClause,
|
|
createImportDeclaration: () => createImportDeclaration,
|
|
createImportEqualsDeclaration: () => createImportEqualsDeclaration,
|
|
createImportSpecifier: () => createImportSpecifier,
|
|
createImportTypeNode: () => createImportTypeNode,
|
|
createIncrementalCompilerHost: () => createIncrementalCompilerHost,
|
|
createIncrementalProgram: () => createIncrementalProgram,
|
|
createIndexSignature: () => createIndexSignature,
|
|
createIndexedAccessTypeNode: () => createIndexedAccessTypeNode,
|
|
createInferTypeNode: () => createInferTypeNode,
|
|
createInputFiles: () => createInputFiles,
|
|
createInputFilesWithFilePaths: () => createInputFilesWithFilePaths,
|
|
createInputFilesWithFileTexts: () => createInputFilesWithFileTexts,
|
|
createInterfaceDeclaration: () => createInterfaceDeclaration,
|
|
createIntersectionTypeNode: () => createIntersectionTypeNode,
|
|
createJSDocAugmentsTag: () => createJSDocAugmentsTag,
|
|
createJSDocAuthorTag: () => createJSDocAuthorTag,
|
|
createJSDocCallbackTag: () => createJSDocCallbackTag,
|
|
createJSDocClassTag: () => createJSDocClassTag,
|
|
createJSDocComment: () => createJSDocComment,
|
|
createJSDocEnumTag: () => createJSDocEnumTag,
|
|
createJSDocImplementsTag: () => createJSDocImplementsTag,
|
|
createJSDocParamTag: () => createJSDocParamTag,
|
|
createJSDocParameterTag: () => createJSDocParameterTag,
|
|
createJSDocPrivateTag: () => createJSDocPrivateTag,
|
|
createJSDocPropertyTag: () => createJSDocPropertyTag,
|
|
createJSDocProtectedTag: () => createJSDocProtectedTag,
|
|
createJSDocPublicTag: () => createJSDocPublicTag,
|
|
createJSDocReadonlyTag: () => createJSDocReadonlyTag,
|
|
createJSDocReturnTag: () => createJSDocReturnTag,
|
|
createJSDocSignature: () => createJSDocSignature,
|
|
createJSDocTag: () => createJSDocTag,
|
|
createJSDocTemplateTag: () => createJSDocTemplateTag,
|
|
createJSDocThisTag: () => createJSDocThisTag,
|
|
createJSDocTypeExpression: () => createJSDocTypeExpression,
|
|
createJSDocTypeLiteral: () => createJSDocTypeLiteral,
|
|
createJSDocTypeTag: () => createJSDocTypeTag,
|
|
createJSDocTypedefTag: () => createJSDocTypedefTag,
|
|
createJsxAttribute: () => createJsxAttribute,
|
|
createJsxAttributes: () => createJsxAttributes,
|
|
createJsxClosingElement: () => createJsxClosingElement,
|
|
createJsxElement: () => createJsxElement,
|
|
createJsxExpression: () => createJsxExpression,
|
|
createJsxFactoryExpression: () => createJsxFactoryExpression,
|
|
createJsxFragment: () => createJsxFragment,
|
|
createJsxJsxClosingFragment: () => createJsxJsxClosingFragment,
|
|
createJsxOpeningElement: () => createJsxOpeningElement,
|
|
createJsxOpeningFragment: () => createJsxOpeningFragment,
|
|
createJsxSelfClosingElement: () => createJsxSelfClosingElement,
|
|
createJsxSpreadAttribute: () => createJsxSpreadAttribute,
|
|
createJsxText: () => createJsxText,
|
|
createKeywordTypeNode: () => createKeywordTypeNode,
|
|
createLabel: () => createLabel,
|
|
createLanguageService: () => createLanguageService,
|
|
createLanguageServiceSourceFile: () => createLanguageServiceSourceFile,
|
|
createLessThan: () => createLessThan,
|
|
createLiteral: () => createLiteral,
|
|
createLiteralTypeNode: () => createLiteralTypeNode,
|
|
createLogicalAnd: () => createLogicalAnd,
|
|
createLogicalNot: () => createLogicalNot,
|
|
createLogicalOr: () => createLogicalOr,
|
|
createLoopVariable: () => createLoopVariable,
|
|
createMappedTypeNode: () => createMappedTypeNode,
|
|
createMemberAccessForPropertyName: () => createMemberAccessForPropertyName,
|
|
createMetaProperty: () => createMetaProperty,
|
|
createMethod: () => createMethod,
|
|
createMethodSignature: () => createMethodSignature,
|
|
createModeAwareCache: () => createModeAwareCache,
|
|
createModifier: () => createModifier,
|
|
createModifiersFromModifierFlags: () => createModifiersFromModifierFlags,
|
|
createModuleBlock: () => createModuleBlock,
|
|
createModuleDeclaration: () => createModuleDeclaration,
|
|
createModuleResolutionCache: () => createModuleResolutionCache,
|
|
createModuleSpecifierResolutionHost: () => createModuleSpecifierResolutionHost,
|
|
createMultiMap: () => createMultiMap,
|
|
createNamedExports: () => createNamedExports,
|
|
createNamedImports: () => createNamedImports,
|
|
createNamespaceExport: () => createNamespaceExport,
|
|
createNamespaceExportDeclaration: () => createNamespaceExportDeclaration,
|
|
createNamespaceImport: () => createNamespaceImport,
|
|
createNew: () => createNew,
|
|
createNoSubstitutionTemplateLiteral: () => createNoSubstitutionTemplateLiteral,
|
|
createNode: () => createNode2,
|
|
createNodeArray: () => createNodeArray,
|
|
createNodeConverters: () => createNodeConverters,
|
|
createNodeFactory: () => createNodeFactory,
|
|
createNonNullChain: () => createNonNullChain,
|
|
createNonNullExpression: () => createNonNullExpression,
|
|
createNotEmittedStatement: () => createNotEmittedStatement,
|
|
createNull: () => createNull,
|
|
createNumericLiteral: () => createNumericLiteral,
|
|
createObjectBindingPattern: () => createObjectBindingPattern,
|
|
createObjectLiteral: () => createObjectLiteral,
|
|
createOmittedExpression: () => createOmittedExpression,
|
|
createOptimisticUniqueName: () => createOptimisticUniqueName,
|
|
createOptionNameMap: () => createOptionNameMap,
|
|
createOptionalTypeNode: () => createOptionalTypeNode,
|
|
createOverload: () => createOverload,
|
|
createPackageJsonImportFilter: () => createPackageJsonImportFilter,
|
|
createPackageJsonInfo: () => createPackageJsonInfo,
|
|
createParameter: () => createParameter,
|
|
createParen: () => createParen,
|
|
createParenthesizedType: () => createParenthesizedType,
|
|
createParenthesizerRules: () => createParenthesizerRules,
|
|
createPartiallyEmittedExpression: () => createPartiallyEmittedExpression,
|
|
createPatternMatcher: () => createPatternMatcher,
|
|
createPostfix: () => createPostfix,
|
|
createPostfixIncrement: () => createPostfixIncrement,
|
|
createPrefix: () => createPrefix,
|
|
createPrependNodes: () => createPrependNodes,
|
|
createPrinter: () => createPrinter,
|
|
createPrivateIdentifier: () => createPrivateIdentifier,
|
|
createProgram: () => createProgram,
|
|
createProgramHost: () => createProgramHost,
|
|
createProperty: () => createProperty,
|
|
createPropertyAccess: () => createPropertyAccess,
|
|
createPropertyAccessChain: () => createPropertyAccessChain,
|
|
createPropertyAssignment: () => createPropertyAssignment,
|
|
createPropertyNameNodeForIdentifierOrLiteral: () => createPropertyNameNodeForIdentifierOrLiteral,
|
|
createPropertySignature: () => createPropertySignature,
|
|
createQualifiedName: () => createQualifiedName,
|
|
createQueue: () => createQueue,
|
|
createRange: () => createRange,
|
|
createRedirectedBuilderProgram: () => createRedirectedBuilderProgram,
|
|
createRegularExpressionLiteral: () => createRegularExpressionLiteral,
|
|
createResolutionCache: () => createResolutionCache,
|
|
createRestTypeNode: () => createRestTypeNode,
|
|
createReturn: () => createReturn,
|
|
createRuntimeTypeSerializer: () => createRuntimeTypeSerializer,
|
|
createScanner: () => createScanner,
|
|
createSemanticDiagnosticsBuilderProgram: () => createSemanticDiagnosticsBuilderProgram,
|
|
createSemicolonClassElement: () => createSemicolonClassElement,
|
|
createSet: () => createSet,
|
|
createSetAccessor: () => createSetAccessor,
|
|
createShorthandPropertyAssignment: () => createShorthandPropertyAssignment,
|
|
createSolutionBuilder: () => createSolutionBuilder,
|
|
createSolutionBuilderHost: () => createSolutionBuilderHost,
|
|
createSolutionBuilderWithWatch: () => createSolutionBuilderWithWatch,
|
|
createSolutionBuilderWithWatchHost: () => createSolutionBuilderWithWatchHost,
|
|
createSortedArray: () => createSortedArray,
|
|
createSourceFile: () => createSourceFile,
|
|
createSourceMapGenerator: () => createSourceMapGenerator,
|
|
createSourceMapSource: () => createSourceMapSource,
|
|
createSpread: () => createSpread,
|
|
createSpreadAssignment: () => createSpreadAssignment,
|
|
createStatement: () => createStatement,
|
|
createStrictEquality: () => createStrictEquality,
|
|
createStrictInequality: () => createStrictInequality,
|
|
createStringLiteral: () => createStringLiteral,
|
|
createStringLiteralFromNode: () => createStringLiteralFromNode,
|
|
createSubtract: () => createSubtract,
|
|
createSuper: () => createSuper,
|
|
createSuperAccessVariableStatement: () => createSuperAccessVariableStatement,
|
|
createSwitch: () => createSwitch,
|
|
createSymbolTable: () => createSymbolTable,
|
|
createSymlinkCache: () => createSymlinkCache,
|
|
createSystemWatchFunctions: () => createSystemWatchFunctions,
|
|
createTaggedTemplate: () => createTaggedTemplate,
|
|
createTempVariable: () => createTempVariable,
|
|
createTemplateExpression: () => createTemplateExpression,
|
|
createTemplateHead: () => createTemplateHead,
|
|
createTemplateMiddle: () => createTemplateMiddle,
|
|
createTemplateSpan: () => createTemplateSpan,
|
|
createTemplateTail: () => createTemplateTail,
|
|
createTextChange: () => createTextChange,
|
|
createTextChangeFromStartLength: () => createTextChangeFromStartLength,
|
|
createTextChangeRange: () => createTextChangeRange,
|
|
createTextRangeFromNode: () => createTextRangeFromNode,
|
|
createTextRangeFromSpan: () => createTextRangeFromSpan,
|
|
createTextSpan: () => createTextSpan,
|
|
createTextSpanFromBounds: () => createTextSpanFromBounds,
|
|
createTextSpanFromNode: () => createTextSpanFromNode,
|
|
createTextSpanFromRange: () => createTextSpanFromRange,
|
|
createTextSpanFromStringLiteralLikeContent: () => createTextSpanFromStringLiteralLikeContent,
|
|
createTextWriter: () => createTextWriter,
|
|
createThis: () => createThis,
|
|
createThisTypeNode: () => createThisTypeNode,
|
|
createThrow: () => createThrow,
|
|
createToken: () => createToken,
|
|
createTokenRange: () => createTokenRange,
|
|
createTrue: () => createTrue,
|
|
createTry: () => createTry,
|
|
createTupleTypeNode: () => createTupleTypeNode,
|
|
createTypeAliasDeclaration: () => createTypeAliasDeclaration,
|
|
createTypeAssertion: () => createTypeAssertion,
|
|
createTypeChecker: () => createTypeChecker,
|
|
createTypeLiteralNode: () => createTypeLiteralNode,
|
|
createTypeOf: () => createTypeOf,
|
|
createTypeOperatorNode: () => createTypeOperatorNode,
|
|
createTypeParameterDeclaration: () => createTypeParameterDeclaration,
|
|
createTypePredicateNode: () => createTypePredicateNode,
|
|
createTypePredicateNodeWithModifier: () => createTypePredicateNodeWithModifier,
|
|
createTypeQueryNode: () => createTypeQueryNode,
|
|
createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
|
|
createTypeReferenceNode: () => createTypeReferenceNode,
|
|
createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
|
|
createUnionTypeNode: () => createUnionTypeNode,
|
|
createUniqueName: () => createUniqueName,
|
|
createUnparsedSourceFile: () => createUnparsedSourceFile,
|
|
createVariableDeclaration: () => createVariableDeclaration,
|
|
createVariableDeclarationList: () => createVariableDeclarationList,
|
|
createVariableStatement: () => createVariableStatement,
|
|
createVoid: () => createVoid,
|
|
createVoidZero: () => createVoidZero,
|
|
createWatchCompilerHost: () => createWatchCompilerHost2,
|
|
createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,
|
|
createWatchCompilerHostOfFilesAndCompilerOptions: () => createWatchCompilerHostOfFilesAndCompilerOptions,
|
|
createWatchFactory: () => createWatchFactory,
|
|
createWatchHost: () => createWatchHost,
|
|
createWatchProgram: () => createWatchProgram,
|
|
createWatchStatusReporter: () => createWatchStatusReporter,
|
|
createWhile: () => createWhile,
|
|
createWith: () => createWith,
|
|
createWriteFileMeasuringIO: () => createWriteFileMeasuringIO,
|
|
createYield: () => createYield,
|
|
declarationNameToString: () => declarationNameToString,
|
|
decodeMappings: () => decodeMappings,
|
|
decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith,
|
|
decorateHelper: () => decorateHelper,
|
|
deduplicate: () => deduplicate,
|
|
defaultIncludeSpec: () => defaultIncludeSpec,
|
|
defaultInitCompilerOptions: () => defaultInitCompilerOptions,
|
|
defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
|
|
diagnosticCategoryName: () => diagnosticCategoryName,
|
|
diagnosticToString: () => diagnosticToString,
|
|
directoryProbablyExists: () => directoryProbablyExists,
|
|
directorySeparator: () => directorySeparator,
|
|
displayPart: () => displayPart,
|
|
displayPartsToString: () => displayPartsToString,
|
|
disposeEmitNodes: () => disposeEmitNodes,
|
|
documentSpansEqual: () => documentSpansEqual,
|
|
dumpTracingLegend: () => dumpTracingLegend,
|
|
elementAt: () => elementAt,
|
|
elideNodes: () => elideNodes,
|
|
emitComments: () => emitComments,
|
|
emitDetachedComments: () => emitDetachedComments,
|
|
emitFiles: () => emitFiles,
|
|
emitFilesAndReportErrors: () => emitFilesAndReportErrors,
|
|
emitFilesAndReportErrorsAndGetExitStatus: () => emitFilesAndReportErrorsAndGetExitStatus,
|
|
emitNewLineBeforeLeadingCommentOfPosition: () => emitNewLineBeforeLeadingCommentOfPosition,
|
|
emitNewLineBeforeLeadingComments: () => emitNewLineBeforeLeadingComments,
|
|
emitNewLineBeforeLeadingCommentsOfPosition: () => emitNewLineBeforeLeadingCommentsOfPosition,
|
|
emitSkippedWithNoDiagnostics: () => emitSkippedWithNoDiagnostics,
|
|
emitUsingBuildInfo: () => emitUsingBuildInfo,
|
|
emptyArray: () => emptyArray,
|
|
emptyFileSystemEntries: () => emptyFileSystemEntries,
|
|
emptyIterator: () => emptyIterator,
|
|
emptyMap: () => emptyMap,
|
|
emptyOptions: () => emptyOptions,
|
|
emptySet: () => emptySet,
|
|
endsWith: () => endsWith,
|
|
ensurePathIsNonModuleName: () => ensurePathIsNonModuleName,
|
|
ensureScriptKind: () => ensureScriptKind,
|
|
ensureTrailingDirectorySeparator: () => ensureTrailingDirectorySeparator,
|
|
entityNameToString: () => entityNameToString,
|
|
enumerateInsertsAndDeletes: () => enumerateInsertsAndDeletes,
|
|
equalOwnProperties: () => equalOwnProperties,
|
|
equateStringsCaseInsensitive: () => equateStringsCaseInsensitive,
|
|
equateStringsCaseSensitive: () => equateStringsCaseSensitive,
|
|
equateValues: () => equateValues,
|
|
escapeJsxAttributeString: () => escapeJsxAttributeString,
|
|
escapeLeadingUnderscores: () => escapeLeadingUnderscores,
|
|
escapeNonAsciiString: () => escapeNonAsciiString,
|
|
escapeSnippetText: () => escapeSnippetText,
|
|
escapeString: () => escapeString,
|
|
every: () => every,
|
|
expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
|
|
explainFiles: () => explainFiles,
|
|
explainIfFileIsRedirectAndImpliedFormat: () => explainIfFileIsRedirectAndImpliedFormat,
|
|
exportAssignmentIsAlias: () => exportAssignmentIsAlias,
|
|
exportStarHelper: () => exportStarHelper,
|
|
expressionResultIsUnused: () => expressionResultIsUnused,
|
|
extend: () => extend,
|
|
extendsHelper: () => extendsHelper,
|
|
extensionFromPath: () => extensionFromPath,
|
|
extensionIsTS: () => extensionIsTS,
|
|
externalHelpersModuleNameText: () => externalHelpersModuleNameText,
|
|
factory: () => factory,
|
|
fileExtensionIs: () => fileExtensionIs,
|
|
fileExtensionIsOneOf: () => fileExtensionIsOneOf,
|
|
fileIncludeReasonToDiagnostics: () => fileIncludeReasonToDiagnostics,
|
|
fill: () => fill,
|
|
filter: () => filter,
|
|
filterMutate: () => filterMutate,
|
|
filterSemanticDiagnostics: () => filterSemanticDiagnostics,
|
|
find: () => find,
|
|
findAncestor: () => findAncestor,
|
|
findBestPatternMatch: () => findBestPatternMatch,
|
|
findChildOfKind: () => findChildOfKind,
|
|
findConfigFile: () => findConfigFile,
|
|
findContainingList: () => findContainingList,
|
|
findDiagnosticForNode: () => findDiagnosticForNode,
|
|
findFirstNonJsxWhitespaceToken: () => findFirstNonJsxWhitespaceToken,
|
|
findIndex: () => findIndex,
|
|
findLast: () => findLast,
|
|
findLastIndex: () => findLastIndex,
|
|
findListItemInfo: () => findListItemInfo,
|
|
findMap: () => findMap,
|
|
findModifier: () => findModifier,
|
|
findNextToken: () => findNextToken,
|
|
findPackageJson: () => findPackageJson,
|
|
findPackageJsons: () => findPackageJsons,
|
|
findPrecedingMatchingToken: () => findPrecedingMatchingToken,
|
|
findPrecedingToken: () => findPrecedingToken,
|
|
findSuperStatementIndex: () => findSuperStatementIndex,
|
|
findTokenOnLeftOfPosition: () => findTokenOnLeftOfPosition,
|
|
findUseStrictPrologue: () => findUseStrictPrologue,
|
|
first: () => first,
|
|
firstDefined: () => firstDefined,
|
|
firstDefinedIterator: () => firstDefinedIterator,
|
|
firstOrOnly: () => firstOrOnly,
|
|
firstOrUndefined: () => firstOrUndefined,
|
|
fixupCompilerOptions: () => fixupCompilerOptions,
|
|
flatMap: () => flatMap,
|
|
flatMapIterator: () => flatMapIterator,
|
|
flatMapToMutable: () => flatMapToMutable,
|
|
flatten: () => flatten,
|
|
flattenDestructuringAssignment: () => flattenDestructuringAssignment,
|
|
flattenDestructuringBinding: () => flattenDestructuringBinding,
|
|
flattenDiagnosticMessageText: () => flattenDiagnosticMessageText,
|
|
forEach: () => forEach,
|
|
forEachAncestor: () => forEachAncestor,
|
|
forEachAncestorDirectory: () => forEachAncestorDirectory,
|
|
forEachChild: () => forEachChild,
|
|
forEachChildRecursively: () => forEachChildRecursively,
|
|
forEachEmittedFile: () => forEachEmittedFile,
|
|
forEachEnclosingBlockScopeContainer: () => forEachEnclosingBlockScopeContainer,
|
|
forEachEntry: () => forEachEntry,
|
|
forEachExternalModuleToImportFrom: () => forEachExternalModuleToImportFrom,
|
|
forEachImportClauseDeclaration: () => forEachImportClauseDeclaration,
|
|
forEachKey: () => forEachKey,
|
|
forEachLeadingCommentRange: () => forEachLeadingCommentRange,
|
|
forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
|
|
forEachResolvedProjectReference: () => forEachResolvedProjectReference,
|
|
forEachReturnStatement: () => forEachReturnStatement,
|
|
forEachRight: () => forEachRight,
|
|
forEachTrailingCommentRange: () => forEachTrailingCommentRange,
|
|
forEachUnique: () => forEachUnique,
|
|
forEachYieldExpression: () => forEachYieldExpression,
|
|
forSomeAncestorDirectory: () => forSomeAncestorDirectory,
|
|
formatColorAndReset: () => formatColorAndReset,
|
|
formatDiagnostic: () => formatDiagnostic,
|
|
formatDiagnostics: () => formatDiagnostics,
|
|
formatDiagnosticsWithColorAndContext: () => formatDiagnosticsWithColorAndContext,
|
|
formatGeneratedName: () => formatGeneratedName,
|
|
formatGeneratedNamePart: () => formatGeneratedNamePart,
|
|
formatLocation: () => formatLocation,
|
|
formatMessage: () => formatMessage,
|
|
formatStringFromArgs: () => formatStringFromArgs,
|
|
formatting: () => ts_formatting_exports,
|
|
fullTripleSlashAMDReferencePathRegEx: () => fullTripleSlashAMDReferencePathRegEx,
|
|
fullTripleSlashReferencePathRegEx: () => fullTripleSlashReferencePathRegEx,
|
|
generateDjb2Hash: () => generateDjb2Hash,
|
|
generateTSConfig: () => generateTSConfig,
|
|
generatorHelper: () => generatorHelper,
|
|
getAdjustedReferenceLocation: () => getAdjustedReferenceLocation,
|
|
getAdjustedRenameLocation: () => getAdjustedRenameLocation,
|
|
getAliasDeclarationFromName: () => getAliasDeclarationFromName,
|
|
getAllAccessorDeclarations: () => getAllAccessorDeclarations,
|
|
getAllDecoratorsOfClass: () => getAllDecoratorsOfClass,
|
|
getAllDecoratorsOfClassElement: () => getAllDecoratorsOfClassElement,
|
|
getAllJSDocTags: () => getAllJSDocTags,
|
|
getAllJSDocTagsOfKind: () => getAllJSDocTagsOfKind,
|
|
getAllKeys: () => getAllKeys,
|
|
getAllProjectOutputs: () => getAllProjectOutputs,
|
|
getAllSuperTypeNodes: () => getAllSuperTypeNodes,
|
|
getAllUnscopedEmitHelpers: () => getAllUnscopedEmitHelpers,
|
|
getAllowJSCompilerOption: () => getAllowJSCompilerOption,
|
|
getAllowSyntheticDefaultImports: () => getAllowSyntheticDefaultImports,
|
|
getAncestor: () => getAncestor,
|
|
getAnyExtensionFromPath: () => getAnyExtensionFromPath,
|
|
getAreDeclarationMapsEnabled: () => getAreDeclarationMapsEnabled,
|
|
getAssignedExpandoInitializer: () => getAssignedExpandoInitializer,
|
|
getAssignedName: () => getAssignedName,
|
|
getAssignmentDeclarationKind: () => getAssignmentDeclarationKind,
|
|
getAssignmentDeclarationPropertyAccessKind: () => getAssignmentDeclarationPropertyAccessKind,
|
|
getAssignmentTargetKind: () => getAssignmentTargetKind,
|
|
getAutomaticTypeDirectiveNames: () => getAutomaticTypeDirectiveNames,
|
|
getBaseFileName: () => getBaseFileName,
|
|
getBinaryOperatorPrecedence: () => getBinaryOperatorPrecedence,
|
|
getBuildInfo: () => getBuildInfo,
|
|
getBuildInfoFileVersionMap: () => getBuildInfoFileVersionMap,
|
|
getBuildInfoText: () => getBuildInfoText,
|
|
getBuildOrderFromAnyBuildOrder: () => getBuildOrderFromAnyBuildOrder,
|
|
getBuilderCreationParameters: () => getBuilderCreationParameters,
|
|
getBuilderFileEmit: () => getBuilderFileEmit,
|
|
getCheckFlags: () => getCheckFlags,
|
|
getClassExtendsHeritageElement: () => getClassExtendsHeritageElement,
|
|
getClassLikeDeclarationOfSymbol: () => getClassLikeDeclarationOfSymbol,
|
|
getCombinedLocalAndExportSymbolFlags: () => getCombinedLocalAndExportSymbolFlags,
|
|
getCombinedModifierFlags: () => getCombinedModifierFlags,
|
|
getCombinedNodeFlags: () => getCombinedNodeFlags,
|
|
getCombinedNodeFlagsAlwaysIncludeJSDoc: () => getCombinedNodeFlagsAlwaysIncludeJSDoc,
|
|
getCommentRange: () => getCommentRange,
|
|
getCommonSourceDirectory: () => getCommonSourceDirectory,
|
|
getCommonSourceDirectoryOfConfig: () => getCommonSourceDirectoryOfConfig,
|
|
getCompilerOptionValue: () => getCompilerOptionValue,
|
|
getCompilerOptionsDiffValue: () => getCompilerOptionsDiffValue,
|
|
getConfigFileParsingDiagnostics: () => getConfigFileParsingDiagnostics,
|
|
getConstantValue: () => getConstantValue,
|
|
getContainerNode: () => getContainerNode,
|
|
getContainingClass: () => getContainingClass,
|
|
getContainingClassStaticBlock: () => getContainingClassStaticBlock,
|
|
getContainingFunction: () => getContainingFunction,
|
|
getContainingFunctionDeclaration: () => getContainingFunctionDeclaration,
|
|
getContainingFunctionOrClassStaticBlock: () => getContainingFunctionOrClassStaticBlock,
|
|
getContainingNodeArray: () => getContainingNodeArray,
|
|
getContainingObjectLiteralElement: () => getContainingObjectLiteralElement,
|
|
getContextualTypeFromParent: () => getContextualTypeFromParent,
|
|
getContextualTypeFromParentOrAncestorTypeNode: () => getContextualTypeFromParentOrAncestorTypeNode,
|
|
getCurrentTime: () => getCurrentTime,
|
|
getDeclarationDiagnostics: () => getDeclarationDiagnostics,
|
|
getDeclarationEmitExtensionForPath: () => getDeclarationEmitExtensionForPath,
|
|
getDeclarationEmitOutputFilePath: () => getDeclarationEmitOutputFilePath,
|
|
getDeclarationEmitOutputFilePathWorker: () => getDeclarationEmitOutputFilePathWorker,
|
|
getDeclarationFromName: () => getDeclarationFromName,
|
|
getDeclarationModifierFlagsFromSymbol: () => getDeclarationModifierFlagsFromSymbol,
|
|
getDeclarationOfKind: () => getDeclarationOfKind,
|
|
getDeclarationsOfKind: () => getDeclarationsOfKind,
|
|
getDeclaredExpandoInitializer: () => getDeclaredExpandoInitializer,
|
|
getDecorators: () => getDecorators,
|
|
getDefaultCompilerOptions: () => getDefaultCompilerOptions2,
|
|
getDefaultFormatCodeSettings: () => getDefaultFormatCodeSettings,
|
|
getDefaultLibFileName: () => getDefaultLibFileName,
|
|
getDefaultLibFilePath: () => getDefaultLibFilePath,
|
|
getDefaultLikeExportInfo: () => getDefaultLikeExportInfo,
|
|
getDiagnosticText: () => getDiagnosticText,
|
|
getDiagnosticsWithinSpan: () => getDiagnosticsWithinSpan,
|
|
getDirectoryPath: () => getDirectoryPath,
|
|
getDocumentPositionMapper: () => getDocumentPositionMapper,
|
|
getESModuleInterop: () => getESModuleInterop,
|
|
getEditsForFileRename: () => getEditsForFileRename,
|
|
getEffectiveBaseTypeNode: () => getEffectiveBaseTypeNode,
|
|
getEffectiveConstraintOfTypeParameter: () => getEffectiveConstraintOfTypeParameter,
|
|
getEffectiveContainerForJSDocTemplateTag: () => getEffectiveContainerForJSDocTemplateTag,
|
|
getEffectiveImplementsTypeNodes: () => getEffectiveImplementsTypeNodes,
|
|
getEffectiveInitializer: () => getEffectiveInitializer,
|
|
getEffectiveJSDocHost: () => getEffectiveJSDocHost,
|
|
getEffectiveModifierFlags: () => getEffectiveModifierFlags,
|
|
getEffectiveModifierFlagsAlwaysIncludeJSDoc: () => getEffectiveModifierFlagsAlwaysIncludeJSDoc,
|
|
getEffectiveModifierFlagsNoCache: () => getEffectiveModifierFlagsNoCache,
|
|
getEffectiveReturnTypeNode: () => getEffectiveReturnTypeNode,
|
|
getEffectiveSetAccessorTypeAnnotationNode: () => getEffectiveSetAccessorTypeAnnotationNode,
|
|
getEffectiveTypeAnnotationNode: () => getEffectiveTypeAnnotationNode,
|
|
getEffectiveTypeParameterDeclarations: () => getEffectiveTypeParameterDeclarations,
|
|
getEffectiveTypeRoots: () => getEffectiveTypeRoots,
|
|
getElementOrPropertyAccessArgumentExpressionOrName: () => getElementOrPropertyAccessArgumentExpressionOrName,
|
|
getElementOrPropertyAccessName: () => getElementOrPropertyAccessName,
|
|
getElementsOfBindingOrAssignmentPattern: () => getElementsOfBindingOrAssignmentPattern,
|
|
getEmitDeclarations: () => getEmitDeclarations,
|
|
getEmitFlags: () => getEmitFlags,
|
|
getEmitHelpers: () => getEmitHelpers,
|
|
getEmitModuleDetectionKind: () => getEmitModuleDetectionKind,
|
|
getEmitModuleKind: () => getEmitModuleKind,
|
|
getEmitModuleResolutionKind: () => getEmitModuleResolutionKind,
|
|
getEmitScriptTarget: () => getEmitScriptTarget,
|
|
getEnclosingBlockScopeContainer: () => getEnclosingBlockScopeContainer,
|
|
getEncodedSemanticClassifications: () => getEncodedSemanticClassifications,
|
|
getEncodedSyntacticClassifications: () => getEncodedSyntacticClassifications,
|
|
getEndLinePosition: () => getEndLinePosition,
|
|
getEntityNameFromTypeNode: () => getEntityNameFromTypeNode,
|
|
getEntries: () => getEntries,
|
|
getEntrypointsFromPackageJsonInfo: () => getEntrypointsFromPackageJsonInfo,
|
|
getErrorCountForSummary: () => getErrorCountForSummary,
|
|
getErrorSpanForNode: () => getErrorSpanForNode,
|
|
getErrorSummaryText: () => getErrorSummaryText,
|
|
getEscapedTextOfIdentifierOrLiteral: () => getEscapedTextOfIdentifierOrLiteral,
|
|
getExpandoInitializer: () => getExpandoInitializer,
|
|
getExportAssignmentExpression: () => getExportAssignmentExpression,
|
|
getExportInfoMap: () => getExportInfoMap,
|
|
getExportNeedsImportStarHelper: () => getExportNeedsImportStarHelper,
|
|
getExpressionAssociativity: () => getExpressionAssociativity,
|
|
getExpressionPrecedence: () => getExpressionPrecedence,
|
|
getExternalHelpersModuleName: () => getExternalHelpersModuleName,
|
|
getExternalModuleImportEqualsDeclarationExpression: () => getExternalModuleImportEqualsDeclarationExpression,
|
|
getExternalModuleName: () => getExternalModuleName,
|
|
getExternalModuleNameFromDeclaration: () => getExternalModuleNameFromDeclaration,
|
|
getExternalModuleNameFromPath: () => getExternalModuleNameFromPath,
|
|
getExternalModuleNameLiteral: () => getExternalModuleNameLiteral,
|
|
getExternalModuleRequireArgument: () => getExternalModuleRequireArgument,
|
|
getFallbackOptions: () => getFallbackOptions,
|
|
getFileEmitOutput: () => getFileEmitOutput,
|
|
getFileMatcherPatterns: () => getFileMatcherPatterns,
|
|
getFileNamesFromConfigSpecs: () => getFileNamesFromConfigSpecs,
|
|
getFileWatcherEventKind: () => getFileWatcherEventKind,
|
|
getFilesInErrorForSummary: () => getFilesInErrorForSummary,
|
|
getFirstConstructorWithBody: () => getFirstConstructorWithBody,
|
|
getFirstIdentifier: () => getFirstIdentifier,
|
|
getFirstNonSpaceCharacterPosition: () => getFirstNonSpaceCharacterPosition,
|
|
getFirstProjectOutput: () => getFirstProjectOutput,
|
|
getFixableErrorSpanExpression: () => getFixableErrorSpanExpression,
|
|
getFormatCodeSettingsForWriting: () => getFormatCodeSettingsForWriting,
|
|
getFullWidth: () => getFullWidth,
|
|
getFunctionFlags: () => getFunctionFlags,
|
|
getGeneratedNameForNode: () => getGeneratedNameForNode,
|
|
getHeritageClause: () => getHeritageClause,
|
|
getHostSignatureFromJSDoc: () => getHostSignatureFromJSDoc,
|
|
getImmediatelyInvokedFunctionExpression: () => getImmediatelyInvokedFunctionExpression,
|
|
getImpliedNodeFormatForFile: () => getImpliedNodeFormatForFile,
|
|
getImpliedNodeFormatForFileWorker: () => getImpliedNodeFormatForFileWorker,
|
|
getImportNeedsImportDefaultHelper: () => getImportNeedsImportDefaultHelper,
|
|
getImportNeedsImportStarHelper: () => getImportNeedsImportStarHelper,
|
|
getIndentSize: () => getIndentSize,
|
|
getIndentString: () => getIndentString,
|
|
getInitializedVariables: () => getInitializedVariables,
|
|
getInitializerOfBinaryExpression: () => getInitializerOfBinaryExpression,
|
|
getInitializerOfBindingOrAssignmentElement: () => getInitializerOfBindingOrAssignmentElement,
|
|
getInterfaceBaseTypeNodes: () => getInterfaceBaseTypeNodes,
|
|
getInvokedExpression: () => getInvokedExpression,
|
|
getIterator: () => getIterator,
|
|
getJSDocAugmentsTag: () => getJSDocAugmentsTag,
|
|
getJSDocClassTag: () => getJSDocClassTag,
|
|
getJSDocCommentRanges: () => getJSDocCommentRanges,
|
|
getJSDocCommentsAndTags: () => getJSDocCommentsAndTags,
|
|
getJSDocDeprecatedTag: () => getJSDocDeprecatedTag,
|
|
getJSDocDeprecatedTagNoCache: () => getJSDocDeprecatedTagNoCache,
|
|
getJSDocEnumTag: () => getJSDocEnumTag,
|
|
getJSDocHost: () => getJSDocHost,
|
|
getJSDocImplementsTags: () => getJSDocImplementsTags,
|
|
getJSDocOverrideTagNoCache: () => getJSDocOverrideTagNoCache,
|
|
getJSDocParameterTags: () => getJSDocParameterTags,
|
|
getJSDocParameterTagsNoCache: () => getJSDocParameterTagsNoCache,
|
|
getJSDocPrivateTag: () => getJSDocPrivateTag,
|
|
getJSDocPrivateTagNoCache: () => getJSDocPrivateTagNoCache,
|
|
getJSDocProtectedTag: () => getJSDocProtectedTag,
|
|
getJSDocProtectedTagNoCache: () => getJSDocProtectedTagNoCache,
|
|
getJSDocPublicTag: () => getJSDocPublicTag,
|
|
getJSDocPublicTagNoCache: () => getJSDocPublicTagNoCache,
|
|
getJSDocReadonlyTag: () => getJSDocReadonlyTag,
|
|
getJSDocReadonlyTagNoCache: () => getJSDocReadonlyTagNoCache,
|
|
getJSDocReturnTag: () => getJSDocReturnTag,
|
|
getJSDocReturnType: () => getJSDocReturnType,
|
|
getJSDocRoot: () => getJSDocRoot,
|
|
getJSDocTags: () => getJSDocTags,
|
|
getJSDocTagsNoCache: () => getJSDocTagsNoCache,
|
|
getJSDocTemplateTag: () => getJSDocTemplateTag,
|
|
getJSDocThisTag: () => getJSDocThisTag,
|
|
getJSDocType: () => getJSDocType,
|
|
getJSDocTypeAliasName: () => getJSDocTypeAliasName,
|
|
getJSDocTypeAssertionType: () => getJSDocTypeAssertionType,
|
|
getJSDocTypeParameterDeclarations: () => getJSDocTypeParameterDeclarations,
|
|
getJSDocTypeParameterTags: () => getJSDocTypeParameterTags,
|
|
getJSDocTypeParameterTagsNoCache: () => getJSDocTypeParameterTagsNoCache,
|
|
getJSDocTypeTag: () => getJSDocTypeTag,
|
|
getJSXImplicitImportBase: () => getJSXImplicitImportBase,
|
|
getJSXRuntimeImport: () => getJSXRuntimeImport,
|
|
getJSXTransformEnabled: () => getJSXTransformEnabled,
|
|
getLanguageVariant: () => getLanguageVariant,
|
|
getLastChild: () => getLastChild,
|
|
getLeadingCommentRanges: () => getLeadingCommentRanges,
|
|
getLeadingCommentRangesOfNode: () => getLeadingCommentRangesOfNode,
|
|
getLeftmostAccessExpression: () => getLeftmostAccessExpression,
|
|
getLeftmostExpression: () => getLeftmostExpression,
|
|
getLineAndCharacterOfPosition: () => getLineAndCharacterOfPosition,
|
|
getLineInfo: () => getLineInfo,
|
|
getLineOfLocalPosition: () => getLineOfLocalPosition,
|
|
getLineOfLocalPositionFromLineMap: () => getLineOfLocalPositionFromLineMap,
|
|
getLineStartPositionForPosition: () => getLineStartPositionForPosition,
|
|
getLineStarts: () => getLineStarts,
|
|
getLinesBetweenPositionAndNextNonWhitespaceCharacter: () => getLinesBetweenPositionAndNextNonWhitespaceCharacter,
|
|
getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter: () => getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter,
|
|
getLinesBetweenPositions: () => getLinesBetweenPositions,
|
|
getLinesBetweenRangeEndAndRangeStart: () => getLinesBetweenRangeEndAndRangeStart,
|
|
getLinesBetweenRangeEndPositions: () => getLinesBetweenRangeEndPositions,
|
|
getLiteralText: () => getLiteralText,
|
|
getLocalNameForExternalImport: () => getLocalNameForExternalImport,
|
|
getLocalSymbolForExportDefault: () => getLocalSymbolForExportDefault,
|
|
getLocaleSpecificMessage: () => getLocaleSpecificMessage,
|
|
getLocaleTimeString: () => getLocaleTimeString,
|
|
getMappedContextSpan: () => getMappedContextSpan,
|
|
getMappedDocumentSpan: () => getMappedDocumentSpan,
|
|
getMappedLocation: () => getMappedLocation,
|
|
getMatchedFileSpec: () => getMatchedFileSpec,
|
|
getMatchedIncludeSpec: () => getMatchedIncludeSpec,
|
|
getMeaningFromDeclaration: () => getMeaningFromDeclaration,
|
|
getMeaningFromLocation: () => getMeaningFromLocation,
|
|
getMembersOfDeclaration: () => getMembersOfDeclaration,
|
|
getModeForFileReference: () => getModeForFileReference,
|
|
getModeForResolutionAtIndex: () => getModeForResolutionAtIndex,
|
|
getModeForUsageLocation: () => getModeForUsageLocation,
|
|
getModifiedTime: () => getModifiedTime,
|
|
getModifiers: () => getModifiers,
|
|
getModuleInstanceState: () => getModuleInstanceState,
|
|
getModuleNameStringLiteralAt: () => getModuleNameStringLiteralAt,
|
|
getModuleSpecifierResolverHost: () => getModuleSpecifierResolverHost,
|
|
getMutableClone: () => getMutableClone,
|
|
getNameForExportedSymbol: () => getNameForExportedSymbol,
|
|
getNameFromIndexInfo: () => getNameFromIndexInfo,
|
|
getNameFromPropertyName: () => getNameFromPropertyName,
|
|
getNameOfAccessExpression: () => getNameOfAccessExpression,
|
|
getNameOfCompilerOptionValue: () => getNameOfCompilerOptionValue,
|
|
getNameOfDeclaration: () => getNameOfDeclaration,
|
|
getNameOfExpando: () => getNameOfExpando,
|
|
getNameOfJSDocTypedef: () => getNameOfJSDocTypedef,
|
|
getNameOrArgument: () => getNameOrArgument,
|
|
getNameTable: () => getNameTable,
|
|
getNamesForExportedSymbol: () => getNamesForExportedSymbol,
|
|
getNamespaceDeclarationNode: () => getNamespaceDeclarationNode,
|
|
getNewLineCharacter: () => getNewLineCharacter,
|
|
getNewLineKind: () => getNewLineKind,
|
|
getNewLineOrDefaultFromHost: () => getNewLineOrDefaultFromHost,
|
|
getNewTargetContainer: () => getNewTargetContainer,
|
|
getNextJSDocCommentLocation: () => getNextJSDocCommentLocation,
|
|
getNodeForGeneratedName: () => getNodeForGeneratedName,
|
|
getNodeId: () => getNodeId,
|
|
getNodeKind: () => getNodeKind,
|
|
getNodeMajorVersion: () => getNodeMajorVersion,
|
|
getNodeModifiers: () => getNodeModifiers,
|
|
getNodeModulePathParts: () => getNodeModulePathParts,
|
|
getNonAssignedNameOfDeclaration: () => getNonAssignedNameOfDeclaration,
|
|
getNonAssignmentOperatorForCompoundAssignment: () => getNonAssignmentOperatorForCompoundAssignment,
|
|
getNonAugmentationDeclaration: () => getNonAugmentationDeclaration,
|
|
getNonDecoratorTokenPosOfNode: () => getNonDecoratorTokenPosOfNode,
|
|
getNormalizedAbsolutePath: () => getNormalizedAbsolutePath,
|
|
getNormalizedAbsolutePathWithoutRoot: () => getNormalizedAbsolutePathWithoutRoot,
|
|
getNormalizedPathComponents: () => getNormalizedPathComponents,
|
|
getObjectFlags: () => getObjectFlags,
|
|
getOperator: () => getOperator,
|
|
getOperatorAssociativity: () => getOperatorAssociativity,
|
|
getOperatorPrecedence: () => getOperatorPrecedence,
|
|
getOptionFromName: () => getOptionFromName,
|
|
getOptionsNameMap: () => getOptionsNameMap,
|
|
getOrCreateEmitNode: () => getOrCreateEmitNode,
|
|
getOrCreateExternalHelpersModuleNameIfNeeded: () => getOrCreateExternalHelpersModuleNameIfNeeded,
|
|
getOrUpdate: () => getOrUpdate,
|
|
getOriginalNode: () => getOriginalNode,
|
|
getOriginalNodeId: () => getOriginalNodeId,
|
|
getOriginalSourceFile: () => getOriginalSourceFile,
|
|
getOutputDeclarationFileName: () => getOutputDeclarationFileName,
|
|
getOutputExtension: () => getOutputExtension,
|
|
getOutputFileNames: () => getOutputFileNames,
|
|
getOutputPathsFor: () => getOutputPathsFor,
|
|
getOutputPathsForBundle: () => getOutputPathsForBundle,
|
|
getOwnEmitOutputFilePath: () => getOwnEmitOutputFilePath,
|
|
getOwnKeys: () => getOwnKeys,
|
|
getOwnValues: () => getOwnValues,
|
|
getPackageJsonInfo: () => getPackageJsonInfo,
|
|
getPackageJsonTypesVersionsPaths: () => getPackageJsonTypesVersionsPaths,
|
|
getPackageJsonsVisibleToFile: () => getPackageJsonsVisibleToFile,
|
|
getPackageNameFromTypesPackageName: () => getPackageNameFromTypesPackageName,
|
|
getPackageScopeForPath: () => getPackageScopeForPath,
|
|
getParameterSymbolFromJSDoc: () => getParameterSymbolFromJSDoc,
|
|
getParameterTypeNode: () => getParameterTypeNode,
|
|
getParentNodeInSpan: () => getParentNodeInSpan,
|
|
getParseTreeNode: () => getParseTreeNode,
|
|
getParsedCommandLineOfConfigFile: () => getParsedCommandLineOfConfigFile,
|
|
getPathComponents: () => getPathComponents,
|
|
getPathComponentsRelativeTo: () => getPathComponentsRelativeTo,
|
|
getPathFromPathComponents: () => getPathFromPathComponents,
|
|
getPathUpdater: () => getPathUpdater,
|
|
getPathsBasePath: () => getPathsBasePath,
|
|
getPatternFromSpec: () => getPatternFromSpec,
|
|
getPendingEmitKind: () => getPendingEmitKind,
|
|
getPositionOfLineAndCharacter: () => getPositionOfLineAndCharacter,
|
|
getPossibleGenericSignatures: () => getPossibleGenericSignatures,
|
|
getPossibleOriginalInputExtensionForExtension: () => getPossibleOriginalInputExtensionForExtension,
|
|
getPossibleTypeArgumentsInfo: () => getPossibleTypeArgumentsInfo,
|
|
getPreEmitDiagnostics: () => getPreEmitDiagnostics,
|
|
getPrecedingNonSpaceCharacterPosition: () => getPrecedingNonSpaceCharacterPosition,
|
|
getProperties: () => getProperties,
|
|
getProperty: () => getProperty,
|
|
getPropertyArrayElementValue: () => getPropertyArrayElementValue,
|
|
getPropertyAssignment: () => getPropertyAssignment,
|
|
getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
|
|
getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
|
|
getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
|
|
getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
|
|
getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
|
|
getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
|
|
getQuoteFromPreference: () => getQuoteFromPreference,
|
|
getQuotePreference: () => getQuotePreference,
|
|
getRangesWhere: () => getRangesWhere,
|
|
getRefactorContextSpan: () => getRefactorContextSpan,
|
|
getReferencedFileLocation: () => getReferencedFileLocation,
|
|
getRegexFromPattern: () => getRegexFromPattern,
|
|
getRegularExpressionForWildcard: () => getRegularExpressionForWildcard,
|
|
getRegularExpressionsForWildcards: () => getRegularExpressionsForWildcards,
|
|
getRelativePathFromDirectory: () => getRelativePathFromDirectory,
|
|
getRelativePathFromFile: () => getRelativePathFromFile,
|
|
getRelativePathToDirectoryOrUrl: () => getRelativePathToDirectoryOrUrl,
|
|
getRenameLocation: () => getRenameLocation,
|
|
getReplacementSpanForContextToken: () => getReplacementSpanForContextToken,
|
|
getResolutionDiagnostic: () => getResolutionDiagnostic,
|
|
getResolutionMode: () => getResolutionMode,
|
|
getResolutionModeOverrideForClause: () => getResolutionModeOverrideForClause,
|
|
getResolutionName: () => getResolutionName,
|
|
getResolvedExternalModuleName: () => getResolvedExternalModuleName,
|
|
getResolvedModule: () => getResolvedModule,
|
|
getResolvedTypeReferenceDirective: () => getResolvedTypeReferenceDirective,
|
|
getRestIndicatorOfBindingOrAssignmentElement: () => getRestIndicatorOfBindingOrAssignmentElement,
|
|
getRestParameterElementType: () => getRestParameterElementType,
|
|
getRightMostAssignedExpression: () => getRightMostAssignedExpression,
|
|
getRootDeclaration: () => getRootDeclaration,
|
|
getRootLength: () => getRootLength,
|
|
getScriptKind: () => getScriptKind,
|
|
getScriptKindFromFileName: () => getScriptKindFromFileName,
|
|
getScriptTargetFeatures: () => getScriptTargetFeatures,
|
|
getSelectedEffectiveModifierFlags: () => getSelectedEffectiveModifierFlags,
|
|
getSelectedSyntacticModifierFlags: () => getSelectedSyntacticModifierFlags,
|
|
getSemanticClassifications: () => getSemanticClassifications,
|
|
getSemanticJsxChildren: () => getSemanticJsxChildren,
|
|
getSetAccessorTypeAnnotationNode: () => getSetAccessorTypeAnnotationNode,
|
|
getSetAccessorValueParameter: () => getSetAccessorValueParameter,
|
|
getSetExternalModuleIndicator: () => getSetExternalModuleIndicator,
|
|
getShebang: () => getShebang,
|
|
getSingleInitializerOfVariableStatementOrPropertyDeclaration: () => getSingleInitializerOfVariableStatementOrPropertyDeclaration,
|
|
getSingleVariableOfVariableStatement: () => getSingleVariableOfVariableStatement,
|
|
getSnapshotText: () => getSnapshotText,
|
|
getSnippetElement: () => getSnippetElement,
|
|
getSourceFileOfModule: () => getSourceFileOfModule,
|
|
getSourceFileOfNode: () => getSourceFileOfNode,
|
|
getSourceFilePathInNewDir: () => getSourceFilePathInNewDir,
|
|
getSourceFilePathInNewDirWorker: () => getSourceFilePathInNewDirWorker,
|
|
getSourceFileVersionAsHashFromText: () => getSourceFileVersionAsHashFromText,
|
|
getSourceFilesToEmit: () => getSourceFilesToEmit,
|
|
getSourceMapRange: () => getSourceMapRange,
|
|
getSourceMapper: () => getSourceMapper,
|
|
getSourceTextOfNodeFromSourceFile: () => getSourceTextOfNodeFromSourceFile,
|
|
getSpanOfTokenAtPosition: () => getSpanOfTokenAtPosition,
|
|
getSpellingSuggestion: () => getSpellingSuggestion,
|
|
getStartPositionOfLine: () => getStartPositionOfLine,
|
|
getStartPositionOfRange: () => getStartPositionOfRange,
|
|
getStartsOnNewLine: () => getStartsOnNewLine,
|
|
getStaticPropertiesAndClassStaticBlock: () => getStaticPropertiesAndClassStaticBlock,
|
|
getStrictOptionValue: () => getStrictOptionValue,
|
|
getStringComparer: () => getStringComparer,
|
|
getSuperCallFromStatement: () => getSuperCallFromStatement,
|
|
getSuperContainer: () => getSuperContainer,
|
|
getSupportedCodeFixes: () => getSupportedCodeFixes,
|
|
getSupportedExtensions: () => getSupportedExtensions,
|
|
getSupportedExtensionsWithJsonIfResolveJsonModule: () => getSupportedExtensionsWithJsonIfResolveJsonModule,
|
|
getSwitchedType: () => getSwitchedType,
|
|
getSymbolId: () => getSymbolId,
|
|
getSymbolNameForPrivateIdentifier: () => getSymbolNameForPrivateIdentifier,
|
|
getSymbolTarget: () => getSymbolTarget,
|
|
getSyntacticClassifications: () => getSyntacticClassifications,
|
|
getSyntacticModifierFlags: () => getSyntacticModifierFlags,
|
|
getSyntacticModifierFlagsNoCache: () => getSyntacticModifierFlagsNoCache,
|
|
getSynthesizedDeepClone: () => getSynthesizedDeepClone,
|
|
getSynthesizedDeepCloneWithReplacements: () => getSynthesizedDeepCloneWithReplacements,
|
|
getSynthesizedDeepClones: () => getSynthesizedDeepClones,
|
|
getSynthesizedDeepClonesWithReplacements: () => getSynthesizedDeepClonesWithReplacements,
|
|
getSyntheticLeadingComments: () => getSyntheticLeadingComments,
|
|
getSyntheticTrailingComments: () => getSyntheticTrailingComments,
|
|
getTargetLabel: () => getTargetLabel,
|
|
getTargetOfBindingOrAssignmentElement: () => getTargetOfBindingOrAssignmentElement,
|
|
getTemporaryModuleResolutionState: () => getTemporaryModuleResolutionState,
|
|
getTextOfConstantValue: () => getTextOfConstantValue,
|
|
getTextOfIdentifierOrLiteral: () => getTextOfIdentifierOrLiteral,
|
|
getTextOfJSDocComment: () => getTextOfJSDocComment,
|
|
getTextOfNode: () => getTextOfNode,
|
|
getTextOfNodeFromSourceText: () => getTextOfNodeFromSourceText,
|
|
getTextOfPropertyName: () => getTextOfPropertyName,
|
|
getThisContainer: () => getThisContainer,
|
|
getThisParameter: () => getThisParameter,
|
|
getTokenAtPosition: () => getTokenAtPosition,
|
|
getTokenPosOfNode: () => getTokenPosOfNode,
|
|
getTokenSourceMapRange: () => getTokenSourceMapRange,
|
|
getTouchingPropertyName: () => getTouchingPropertyName,
|
|
getTouchingToken: () => getTouchingToken,
|
|
getTrailingCommentRanges: () => getTrailingCommentRanges,
|
|
getTrailingSemicolonDeferringWriter: () => getTrailingSemicolonDeferringWriter,
|
|
getTransformFlagsSubtreeExclusions: () => getTransformFlagsSubtreeExclusions,
|
|
getTransformers: () => getTransformers,
|
|
getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath,
|
|
getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression,
|
|
getTsConfigPropArray: () => getTsConfigPropArray,
|
|
getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue,
|
|
getTypeAnnotationNode: () => getTypeAnnotationNode,
|
|
getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList,
|
|
getTypeKeywordOfTypeOnlyImport: () => getTypeKeywordOfTypeOnlyImport,
|
|
getTypeNode: () => getTypeNode,
|
|
getTypeNodeIfAccessible: () => getTypeNodeIfAccessible,
|
|
getTypeParameterFromJsDoc: () => getTypeParameterFromJsDoc,
|
|
getTypeParameterOwner: () => getTypeParameterOwner,
|
|
getTypesPackageName: () => getTypesPackageName,
|
|
getUILocale: () => getUILocale,
|
|
getUniqueName: () => getUniqueName,
|
|
getUniqueSymbolId: () => getUniqueSymbolId,
|
|
getUseDefineForClassFields: () => getUseDefineForClassFields,
|
|
getWatchErrorSummaryDiagnosticMessage: () => getWatchErrorSummaryDiagnosticMessage,
|
|
getWatchFactory: () => getWatchFactory,
|
|
group: () => group,
|
|
guessIndentation: () => guessIndentation,
|
|
handleNoEmitOptions: () => handleNoEmitOptions,
|
|
hasAbstractModifier: () => hasAbstractModifier,
|
|
hasAccessorModifier: () => hasAccessorModifier,
|
|
hasAmbientModifier: () => hasAmbientModifier,
|
|
hasChangesInResolutions: () => hasChangesInResolutions,
|
|
hasChildOfKind: () => hasChildOfKind,
|
|
hasContextSensitiveParameters: () => hasContextSensitiveParameters,
|
|
hasDecorators: () => hasDecorators,
|
|
hasDocComment: () => hasDocComment,
|
|
hasDynamicName: () => hasDynamicName,
|
|
hasEffectiveModifier: () => hasEffectiveModifier,
|
|
hasEffectiveModifiers: () => hasEffectiveModifiers,
|
|
hasEffectiveReadonlyModifier: () => hasEffectiveReadonlyModifier,
|
|
hasExtension: () => hasExtension,
|
|
hasIndexSignature: () => hasIndexSignature,
|
|
hasInitializer: () => hasInitializer,
|
|
hasInvalidEscape: () => hasInvalidEscape,
|
|
hasJSDocNodes: () => hasJSDocNodes,
|
|
hasJSDocParameterTags: () => hasJSDocParameterTags,
|
|
hasJSFileExtension: () => hasJSFileExtension,
|
|
hasJsonModuleEmitEnabled: () => hasJsonModuleEmitEnabled,
|
|
hasOnlyExpressionInitializer: () => hasOnlyExpressionInitializer,
|
|
hasOverrideModifier: () => hasOverrideModifier,
|
|
hasPossibleExternalModuleReference: () => hasPossibleExternalModuleReference,
|
|
hasProperty: () => hasProperty,
|
|
hasPropertyAccessExpressionWithName: () => hasPropertyAccessExpressionWithName,
|
|
hasQuestionToken: () => hasQuestionToken,
|
|
hasRecordedExternalHelpers: () => hasRecordedExternalHelpers,
|
|
hasRestParameter: () => hasRestParameter,
|
|
hasScopeMarker: () => hasScopeMarker,
|
|
hasStaticModifier: () => hasStaticModifier,
|
|
hasSyntacticModifier: () => hasSyntacticModifier,
|
|
hasSyntacticModifiers: () => hasSyntacticModifiers,
|
|
hasTSFileExtension: () => hasTSFileExtension,
|
|
hasTrailingDirectorySeparator: () => hasTrailingDirectorySeparator,
|
|
hasType: () => hasType,
|
|
hasTypeArguments: () => hasTypeArguments,
|
|
hasZeroOrOneAsteriskCharacter: () => hasZeroOrOneAsteriskCharacter,
|
|
helperString: () => helperString,
|
|
hostGetCanonicalFileName: () => hostGetCanonicalFileName,
|
|
hostUsesCaseSensitiveFileNames: () => hostUsesCaseSensitiveFileNames,
|
|
idText: () => idText,
|
|
identifierIsThisKeyword: () => identifierIsThisKeyword,
|
|
identity: () => identity,
|
|
identitySourceMapConsumer: () => identitySourceMapConsumer,
|
|
ignoreSourceNewlines: () => ignoreSourceNewlines,
|
|
ignoredPaths: () => ignoredPaths,
|
|
importDefaultHelper: () => importDefaultHelper,
|
|
importFromModuleSpecifier: () => importFromModuleSpecifier,
|
|
importStarHelper: () => importStarHelper,
|
|
indexOfAnyCharCode: () => indexOfAnyCharCode,
|
|
indexOfNode: () => indexOfNode,
|
|
indicesOf: () => indicesOf,
|
|
inferredTypesContainingFile: () => inferredTypesContainingFile,
|
|
insertImports: () => insertImports,
|
|
insertLeadingStatement: () => insertLeadingStatement,
|
|
insertSorted: () => insertSorted,
|
|
insertStatementAfterCustomPrologue: () => insertStatementAfterCustomPrologue,
|
|
insertStatementAfterStandardPrologue: () => insertStatementAfterStandardPrologue,
|
|
insertStatementsAfterCustomPrologue: () => insertStatementsAfterCustomPrologue,
|
|
insertStatementsAfterStandardPrologue: () => insertStatementsAfterStandardPrologue,
|
|
intersperse: () => intersperse,
|
|
introducesArgumentsExoticObject: () => introducesArgumentsExoticObject,
|
|
inverseJsxOptionMap: () => inverseJsxOptionMap,
|
|
isAbstractConstructorSymbol: () => isAbstractConstructorSymbol,
|
|
isAbstractModifier: () => isAbstractModifier,
|
|
isAccessExpression: () => isAccessExpression,
|
|
isAccessibilityModifier: () => isAccessibilityModifier,
|
|
isAccessor: () => isAccessor,
|
|
isAccessorModifier: () => isAccessorModifier,
|
|
isAliasSymbolDeclaration: () => isAliasSymbolDeclaration,
|
|
isAliasableExpression: () => isAliasableExpression,
|
|
isAmbientModule: () => isAmbientModule,
|
|
isAmbientPropertyDeclaration: () => isAmbientPropertyDeclaration,
|
|
isAnyDirectorySeparator: () => isAnyDirectorySeparator,
|
|
isAnyImportOrBareOrAccessedRequire: () => isAnyImportOrBareOrAccessedRequire,
|
|
isAnyImportOrReExport: () => isAnyImportOrReExport,
|
|
isAnyImportSyntax: () => isAnyImportSyntax,
|
|
isAnySupportedFileExtension: () => isAnySupportedFileExtension,
|
|
isApplicableVersionedTypesKey: () => isApplicableVersionedTypesKey,
|
|
isArgumentExpressionOfElementAccess: () => isArgumentExpressionOfElementAccess,
|
|
isArray: () => isArray,
|
|
isArrayBindingElement: () => isArrayBindingElement,
|
|
isArrayBindingOrAssignmentPattern: () => isArrayBindingOrAssignmentPattern,
|
|
isArrayBindingPattern: () => isArrayBindingPattern,
|
|
isArrayLiteralExpression: () => isArrayLiteralExpression,
|
|
isArrayLiteralOrObjectLiteralDestructuringPattern: () => isArrayLiteralOrObjectLiteralDestructuringPattern,
|
|
isArrayTypeNode: () => isArrayTypeNode,
|
|
isArrowFunction: () => isArrowFunction,
|
|
isAsExpression: () => isAsExpression,
|
|
isAssertClause: () => isAssertClause,
|
|
isAssertEntry: () => isAssertEntry,
|
|
isAssertionExpression: () => isAssertionExpression,
|
|
isAssertionKey: () => isAssertionKey,
|
|
isAssertsKeyword: () => isAssertsKeyword,
|
|
isAssignmentDeclaration: () => isAssignmentDeclaration,
|
|
isAssignmentExpression: () => isAssignmentExpression,
|
|
isAssignmentOperator: () => isAssignmentOperator,
|
|
isAssignmentPattern: () => isAssignmentPattern,
|
|
isAssignmentTarget: () => isAssignmentTarget,
|
|
isAsteriskToken: () => isAsteriskToken,
|
|
isAsyncFunction: () => isAsyncFunction,
|
|
isAsyncModifier: () => isAsyncModifier,
|
|
isAutoAccessorPropertyDeclaration: () => isAutoAccessorPropertyDeclaration,
|
|
isAwaitExpression: () => isAwaitExpression,
|
|
isAwaitKeyword: () => isAwaitKeyword,
|
|
isBigIntLiteral: () => isBigIntLiteral,
|
|
isBinaryExpression: () => isBinaryExpression,
|
|
isBinaryOperatorToken: () => isBinaryOperatorToken,
|
|
isBindableObjectDefinePropertyCall: () => isBindableObjectDefinePropertyCall,
|
|
isBindableStaticAccessExpression: () => isBindableStaticAccessExpression,
|
|
isBindableStaticElementAccessExpression: () => isBindableStaticElementAccessExpression,
|
|
isBindableStaticNameExpression: () => isBindableStaticNameExpression,
|
|
isBindingElement: () => isBindingElement,
|
|
isBindingName: () => isBindingName,
|
|
isBindingOrAssignmentPattern: () => isBindingOrAssignmentPattern,
|
|
isBindingPattern: () => isBindingPattern,
|
|
isBlock: () => isBlock,
|
|
isBlockOrCatchScoped: () => isBlockOrCatchScoped,
|
|
isBlockScope: () => isBlockScope,
|
|
isBlockScopedContainerTopLevel: () => isBlockScopedContainerTopLevel,
|
|
isBooleanLiteral: () => isBooleanLiteral,
|
|
isBreakOrContinueStatement: () => isBreakOrContinueStatement,
|
|
isBreakStatement: () => isBreakStatement,
|
|
isBuildInfoFile: () => isBuildInfoFile,
|
|
isBuilderProgram: () => isBuilderProgram2,
|
|
isBundle: () => isBundle,
|
|
isBundleFileTextLike: () => isBundleFileTextLike,
|
|
isCallChain: () => isCallChain,
|
|
isCallExpression: () => isCallExpression,
|
|
isCallExpressionTarget: () => isCallExpressionTarget,
|
|
isCallLikeExpression: () => isCallLikeExpression,
|
|
isCallOrNewExpression: () => isCallOrNewExpression,
|
|
isCallOrNewExpressionTarget: () => isCallOrNewExpressionTarget,
|
|
isCallSignatureDeclaration: () => isCallSignatureDeclaration,
|
|
isCallToHelper: () => isCallToHelper,
|
|
isCaseBlock: () => isCaseBlock,
|
|
isCaseClause: () => isCaseClause,
|
|
isCaseOrDefaultClause: () => isCaseOrDefaultClause,
|
|
isCatchClause: () => isCatchClause,
|
|
isCatchClauseVariableDeclaration: () => isCatchClauseVariableDeclaration,
|
|
isCatchClauseVariableDeclarationOrBindingElement: () => isCatchClauseVariableDeclarationOrBindingElement,
|
|
isCheckJsEnabledForFile: () => isCheckJsEnabledForFile,
|
|
isChildOfNodeWithKind: () => isChildOfNodeWithKind,
|
|
isCircularBuildOrder: () => isCircularBuildOrder,
|
|
isClassDeclaration: () => isClassDeclaration,
|
|
isClassElement: () => isClassElement,
|
|
isClassExpression: () => isClassExpression,
|
|
isClassLike: () => isClassLike,
|
|
isClassMemberModifier: () => isClassMemberModifier,
|
|
isClassOrTypeElement: () => isClassOrTypeElement,
|
|
isClassStaticBlockDeclaration: () => isClassStaticBlockDeclaration,
|
|
isCollapsedRange: () => isCollapsedRange,
|
|
isColonToken: () => isColonToken,
|
|
isCommaListExpression: () => isCommaListExpression,
|
|
isCommaSequence: () => isCommaSequence,
|
|
isCommaToken: () => isCommaToken,
|
|
isComment: () => isComment,
|
|
isCommonJsExportPropertyAssignment: () => isCommonJsExportPropertyAssignment,
|
|
isCommonJsExportedExpression: () => isCommonJsExportedExpression,
|
|
isCompoundAssignment: () => isCompoundAssignment,
|
|
isComputedNonLiteralName: () => isComputedNonLiteralName,
|
|
isComputedPropertyName: () => isComputedPropertyName,
|
|
isConciseBody: () => isConciseBody,
|
|
isConditionalExpression: () => isConditionalExpression,
|
|
isConditionalTypeNode: () => isConditionalTypeNode,
|
|
isConstTypeReference: () => isConstTypeReference,
|
|
isConstructSignatureDeclaration: () => isConstructSignatureDeclaration,
|
|
isConstructorDeclaration: () => isConstructorDeclaration,
|
|
isConstructorTypeNode: () => isConstructorTypeNode,
|
|
isContextualKeyword: () => isContextualKeyword,
|
|
isContinueStatement: () => isContinueStatement,
|
|
isCustomPrologue: () => isCustomPrologue,
|
|
isDebuggerStatement: () => isDebuggerStatement,
|
|
isDeclaration: () => isDeclaration,
|
|
isDeclarationBindingElement: () => isDeclarationBindingElement,
|
|
isDeclarationFileName: () => isDeclarationFileName,
|
|
isDeclarationName: () => isDeclarationName,
|
|
isDeclarationNameOfEnumOrNamespace: () => isDeclarationNameOfEnumOrNamespace,
|
|
isDeclarationReadonly: () => isDeclarationReadonly,
|
|
isDeclarationStatement: () => isDeclarationStatement,
|
|
isDeclarationWithTypeParameterChildren: () => isDeclarationWithTypeParameterChildren,
|
|
isDeclarationWithTypeParameters: () => isDeclarationWithTypeParameters,
|
|
isDecorator: () => isDecorator,
|
|
isDecoratorTarget: () => isDecoratorTarget,
|
|
isDefaultClause: () => isDefaultClause,
|
|
isDefaultImport: () => isDefaultImport,
|
|
isDefaultedExpandoInitializer: () => isDefaultedExpandoInitializer,
|
|
isDeleteExpression: () => isDeleteExpression,
|
|
isDeleteTarget: () => isDeleteTarget,
|
|
isDeprecatedDeclaration: () => isDeprecatedDeclaration,
|
|
isDestructuringAssignment: () => isDestructuringAssignment,
|
|
isDiagnosticWithLocation: () => isDiagnosticWithLocation,
|
|
isDiskPathRoot: () => isDiskPathRoot,
|
|
isDoStatement: () => isDoStatement,
|
|
isDotDotDotToken: () => isDotDotDotToken,
|
|
isDottedName: () => isDottedName,
|
|
isDynamicName: () => isDynamicName,
|
|
isESSymbolIdentifier: () => isESSymbolIdentifier,
|
|
isEffectiveExternalModule: () => isEffectiveExternalModule,
|
|
isEffectiveModuleDeclaration: () => isEffectiveModuleDeclaration,
|
|
isEffectiveStrictModeSourceFile: () => isEffectiveStrictModeSourceFile,
|
|
isElementAccessChain: () => isElementAccessChain,
|
|
isElementAccessExpression: () => isElementAccessExpression,
|
|
isEmittedFileOfProgram: () => isEmittedFileOfProgram,
|
|
isEmptyArrayLiteral: () => isEmptyArrayLiteral,
|
|
isEmptyBindingElement: () => isEmptyBindingElement,
|
|
isEmptyBindingPattern: () => isEmptyBindingPattern,
|
|
isEmptyObjectLiteral: () => isEmptyObjectLiteral,
|
|
isEmptyStatement: () => isEmptyStatement,
|
|
isEndOfDeclarationMarker: () => isEndOfDeclarationMarker,
|
|
isEntityName: () => isEntityName,
|
|
isEntityNameExpression: () => isEntityNameExpression,
|
|
isEnumConst: () => isEnumConst,
|
|
isEnumDeclaration: () => isEnumDeclaration,
|
|
isEnumMember: () => isEnumMember,
|
|
isEqualityOperatorKind: () => isEqualityOperatorKind,
|
|
isEqualsGreaterThanToken: () => isEqualsGreaterThanToken,
|
|
isExclamationToken: () => isExclamationToken,
|
|
isExcludedFile: () => isExcludedFile,
|
|
isExclusivelyTypeOnlyImportOrExport: () => isExclusivelyTypeOnlyImportOrExport,
|
|
isExportAssignment: () => isExportAssignment,
|
|
isExportDeclaration: () => isExportDeclaration,
|
|
isExportModifier: () => isExportModifier,
|
|
isExportName: () => isExportName,
|
|
isExportNamespaceAsDefaultDeclaration: () => isExportNamespaceAsDefaultDeclaration,
|
|
isExportSpecifier: () => isExportSpecifier,
|
|
isExportsIdentifier: () => isExportsIdentifier,
|
|
isExportsOrModuleExportsOrAlias: () => isExportsOrModuleExportsOrAlias,
|
|
isExpression: () => isExpression,
|
|
isExpressionNode: () => isExpressionNode,
|
|
isExpressionOfExternalModuleImportEqualsDeclaration: () => isExpressionOfExternalModuleImportEqualsDeclaration,
|
|
isExpressionOfOptionalChainRoot: () => isExpressionOfOptionalChainRoot,
|
|
isExpressionStatement: () => isExpressionStatement,
|
|
isExpressionWithTypeArguments: () => isExpressionWithTypeArguments,
|
|
isExpressionWithTypeArgumentsInClassExtendsClause: () => isExpressionWithTypeArgumentsInClassExtendsClause,
|
|
isExternalModule: () => isExternalModule,
|
|
isExternalModuleAugmentation: () => isExternalModuleAugmentation,
|
|
isExternalModuleImportEqualsDeclaration: () => isExternalModuleImportEqualsDeclaration,
|
|
isExternalModuleIndicator: () => isExternalModuleIndicator,
|
|
isExternalModuleNameRelative: () => isExternalModuleNameRelative,
|
|
isExternalModuleReference: () => isExternalModuleReference,
|
|
isExternalModuleSymbol: () => isExternalModuleSymbol,
|
|
isExternalOrCommonJsModule: () => isExternalOrCommonJsModule,
|
|
isFileLevelUniqueName: () => isFileLevelUniqueName,
|
|
isFileProbablyExternalModule: () => isFileProbablyExternalModule,
|
|
isFirstDeclarationOfSymbolParameter: () => isFirstDeclarationOfSymbolParameter,
|
|
isFixablePromiseHandler: () => isFixablePromiseHandler,
|
|
isForInOrOfStatement: () => isForInOrOfStatement,
|
|
isForInStatement: () => isForInStatement,
|
|
isForInitializer: () => isForInitializer,
|
|
isForOfStatement: () => isForOfStatement,
|
|
isForStatement: () => isForStatement,
|
|
isFunctionBlock: () => isFunctionBlock,
|
|
isFunctionBody: () => isFunctionBody,
|
|
isFunctionDeclaration: () => isFunctionDeclaration,
|
|
isFunctionExpression: () => isFunctionExpression,
|
|
isFunctionExpressionOrArrowFunction: () => isFunctionExpressionOrArrowFunction,
|
|
isFunctionLike: () => isFunctionLike,
|
|
isFunctionLikeDeclaration: () => isFunctionLikeDeclaration,
|
|
isFunctionLikeKind: () => isFunctionLikeKind,
|
|
isFunctionLikeOrClassStaticBlockDeclaration: () => isFunctionLikeOrClassStaticBlockDeclaration,
|
|
isFunctionOrConstructorTypeNode: () => isFunctionOrConstructorTypeNode,
|
|
isFunctionOrModuleBlock: () => isFunctionOrModuleBlock,
|
|
isFunctionSymbol: () => isFunctionSymbol,
|
|
isFunctionTypeNode: () => isFunctionTypeNode,
|
|
isFutureReservedKeyword: () => isFutureReservedKeyword,
|
|
isGeneratedIdentifier: () => isGeneratedIdentifier,
|
|
isGeneratedPrivateIdentifier: () => isGeneratedPrivateIdentifier,
|
|
isGetAccessor: () => isGetAccessor,
|
|
isGetAccessorDeclaration: () => isGetAccessorDeclaration,
|
|
isGetOrSetAccessorDeclaration: () => isGetOrSetAccessorDeclaration,
|
|
isGlobalDeclaration: () => isGlobalDeclaration,
|
|
isGlobalScopeAugmentation: () => isGlobalScopeAugmentation,
|
|
isHeritageClause: () => isHeritageClause,
|
|
isHoistedFunction: () => isHoistedFunction,
|
|
isHoistedVariableStatement: () => isHoistedVariableStatement,
|
|
isIdentifier: () => isIdentifier,
|
|
isIdentifierANonContextualKeyword: () => isIdentifierANonContextualKeyword,
|
|
isIdentifierName: () => isIdentifierName,
|
|
isIdentifierOrPrivateIdentifier: () => isIdentifierOrPrivateIdentifier,
|
|
isIdentifierOrThisTypeNode: () => isIdentifierOrThisTypeNode,
|
|
isIdentifierPart: () => isIdentifierPart,
|
|
isIdentifierStart: () => isIdentifierStart,
|
|
isIdentifierText: () => isIdentifierText,
|
|
isIdentifierTypePredicate: () => isIdentifierTypePredicate,
|
|
isIdentifierTypeReference: () => isIdentifierTypeReference,
|
|
isIfStatement: () => isIfStatement,
|
|
isIgnoredFileFromWildCardWatching: () => isIgnoredFileFromWildCardWatching,
|
|
isImplicitGlob: () => isImplicitGlob,
|
|
isImportCall: () => isImportCall,
|
|
isImportClause: () => isImportClause,
|
|
isImportDeclaration: () => isImportDeclaration,
|
|
isImportEqualsDeclaration: () => isImportEqualsDeclaration,
|
|
isImportKeyword: () => isImportKeyword,
|
|
isImportMeta: () => isImportMeta,
|
|
isImportOrExportSpecifier: () => isImportOrExportSpecifier,
|
|
isImportOrExportSpecifierName: () => isImportOrExportSpecifierName,
|
|
isImportSpecifier: () => isImportSpecifier,
|
|
isImportTypeAssertionContainer: () => isImportTypeAssertionContainer,
|
|
isImportTypeNode: () => isImportTypeNode,
|
|
isImportableFile: () => isImportableFile,
|
|
isInComment: () => isInComment,
|
|
isInExpressionContext: () => isInExpressionContext,
|
|
isInJSDoc: () => isInJSDoc,
|
|
isInJSFile: () => isInJSFile,
|
|
isInJSXText: () => isInJSXText,
|
|
isInJsonFile: () => isInJsonFile,
|
|
isInNonReferenceComment: () => isInNonReferenceComment,
|
|
isInReferenceComment: () => isInReferenceComment,
|
|
isInRightSideOfInternalImportEqualsDeclaration: () => isInRightSideOfInternalImportEqualsDeclaration,
|
|
isInString: () => isInString,
|
|
isInTemplateString: () => isInTemplateString,
|
|
isInTopLevelContext: () => isInTopLevelContext,
|
|
isIncrementalCompilation: () => isIncrementalCompilation,
|
|
isIndexSignatureDeclaration: () => isIndexSignatureDeclaration,
|
|
isIndexedAccessTypeNode: () => isIndexedAccessTypeNode,
|
|
isInferTypeNode: () => isInferTypeNode,
|
|
isInfinityOrNaNString: () => isInfinityOrNaNString,
|
|
isInitializedProperty: () => isInitializedProperty,
|
|
isInsideJsxElement: () => isInsideJsxElement,
|
|
isInsideJsxElementOrAttribute: () => isInsideJsxElementOrAttribute,
|
|
isInsideNodeModules: () => isInsideNodeModules,
|
|
isInsideTemplateLiteral: () => isInsideTemplateLiteral,
|
|
isInstantiatedModule: () => isInstantiatedModule,
|
|
isInterfaceDeclaration: () => isInterfaceDeclaration,
|
|
isInternalDeclaration: () => isInternalDeclaration,
|
|
isInternalModuleImportEqualsDeclaration: () => isInternalModuleImportEqualsDeclaration,
|
|
isInternalName: () => isInternalName,
|
|
isIntersectionTypeNode: () => isIntersectionTypeNode,
|
|
isIntrinsicJsxName: () => isIntrinsicJsxName,
|
|
isIterationStatement: () => isIterationStatement,
|
|
isJSDoc: () => isJSDoc,
|
|
isJSDocAllType: () => isJSDocAllType,
|
|
isJSDocAugmentsTag: () => isJSDocAugmentsTag,
|
|
isJSDocAuthorTag: () => isJSDocAuthorTag,
|
|
isJSDocCallbackTag: () => isJSDocCallbackTag,
|
|
isJSDocClassTag: () => isJSDocClassTag,
|
|
isJSDocCommentContainingNode: () => isJSDocCommentContainingNode,
|
|
isJSDocConstructSignature: () => isJSDocConstructSignature,
|
|
isJSDocDeprecatedTag: () => isJSDocDeprecatedTag,
|
|
isJSDocEnumTag: () => isJSDocEnumTag,
|
|
isJSDocFunctionType: () => isJSDocFunctionType,
|
|
isJSDocImplementsTag: () => isJSDocImplementsTag,
|
|
isJSDocIndexSignature: () => isJSDocIndexSignature,
|
|
isJSDocLikeText: () => isJSDocLikeText,
|
|
isJSDocLink: () => isJSDocLink,
|
|
isJSDocLinkCode: () => isJSDocLinkCode,
|
|
isJSDocLinkLike: () => isJSDocLinkLike,
|
|
isJSDocLinkPlain: () => isJSDocLinkPlain,
|
|
isJSDocMemberName: () => isJSDocMemberName,
|
|
isJSDocNameReference: () => isJSDocNameReference,
|
|
isJSDocNamepathType: () => isJSDocNamepathType,
|
|
isJSDocNamespaceBody: () => isJSDocNamespaceBody,
|
|
isJSDocNode: () => isJSDocNode,
|
|
isJSDocNonNullableType: () => isJSDocNonNullableType,
|
|
isJSDocNullableType: () => isJSDocNullableType,
|
|
isJSDocOptionalType: () => isJSDocOptionalType,
|
|
isJSDocOverrideTag: () => isJSDocOverrideTag,
|
|
isJSDocParameterTag: () => isJSDocParameterTag,
|
|
isJSDocPrivateTag: () => isJSDocPrivateTag,
|
|
isJSDocPropertyLikeTag: () => isJSDocPropertyLikeTag,
|
|
isJSDocPropertyTag: () => isJSDocPropertyTag,
|
|
isJSDocProtectedTag: () => isJSDocProtectedTag,
|
|
isJSDocPublicTag: () => isJSDocPublicTag,
|
|
isJSDocReadonlyTag: () => isJSDocReadonlyTag,
|
|
isJSDocReturnTag: () => isJSDocReturnTag,
|
|
isJSDocSeeTag: () => isJSDocSeeTag,
|
|
isJSDocSignature: () => isJSDocSignature,
|
|
isJSDocTag: () => isJSDocTag,
|
|
isJSDocTemplateTag: () => isJSDocTemplateTag,
|
|
isJSDocThisTag: () => isJSDocThisTag,
|
|
isJSDocTypeAlias: () => isJSDocTypeAlias,
|
|
isJSDocTypeAssertion: () => isJSDocTypeAssertion,
|
|
isJSDocTypeExpression: () => isJSDocTypeExpression,
|
|
isJSDocTypeLiteral: () => isJSDocTypeLiteral,
|
|
isJSDocTypeTag: () => isJSDocTypeTag,
|
|
isJSDocTypedefTag: () => isJSDocTypedefTag,
|
|
isJSDocUnknownTag: () => isJSDocUnknownTag,
|
|
isJSDocUnknownType: () => isJSDocUnknownType,
|
|
isJSDocVariadicType: () => isJSDocVariadicType,
|
|
isJSXTagName: () => isJSXTagName,
|
|
isJsonEqual: () => isJsonEqual,
|
|
isJsonSourceFile: () => isJsonSourceFile,
|
|
isJsxAttribute: () => isJsxAttribute,
|
|
isJsxAttributeLike: () => isJsxAttributeLike,
|
|
isJsxAttributes: () => isJsxAttributes,
|
|
isJsxChild: () => isJsxChild,
|
|
isJsxClosingElement: () => isJsxClosingElement,
|
|
isJsxClosingFragment: () => isJsxClosingFragment,
|
|
isJsxElement: () => isJsxElement,
|
|
isJsxExpression: () => isJsxExpression,
|
|
isJsxFragment: () => isJsxFragment,
|
|
isJsxOpeningElement: () => isJsxOpeningElement,
|
|
isJsxOpeningFragment: () => isJsxOpeningFragment,
|
|
isJsxOpeningLikeElement: () => isJsxOpeningLikeElement,
|
|
isJsxOpeningLikeElementTagName: () => isJsxOpeningLikeElementTagName,
|
|
isJsxSelfClosingElement: () => isJsxSelfClosingElement,
|
|
isJsxSpreadAttribute: () => isJsxSpreadAttribute,
|
|
isJsxTagNameExpression: () => isJsxTagNameExpression,
|
|
isJsxText: () => isJsxText,
|
|
isJumpStatementTarget: () => isJumpStatementTarget,
|
|
isKeyword: () => isKeyword,
|
|
isKnownSymbol: () => isKnownSymbol,
|
|
isLabelName: () => isLabelName,
|
|
isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
|
|
isLabeledStatement: () => isLabeledStatement,
|
|
isLateVisibilityPaintedStatement: () => isLateVisibilityPaintedStatement,
|
|
isLeftHandSideExpression: () => isLeftHandSideExpression,
|
|
isLeftHandSideOfAssignment: () => isLeftHandSideOfAssignment,
|
|
isLet: () => isLet,
|
|
isLineBreak: () => isLineBreak,
|
|
isLiteralComputedPropertyDeclarationName: () => isLiteralComputedPropertyDeclarationName,
|
|
isLiteralExpression: () => isLiteralExpression,
|
|
isLiteralExpressionOfObject: () => isLiteralExpressionOfObject,
|
|
isLiteralImportTypeNode: () => isLiteralImportTypeNode,
|
|
isLiteralKind: () => isLiteralKind,
|
|
isLiteralLikeAccess: () => isLiteralLikeAccess,
|
|
isLiteralLikeElementAccess: () => isLiteralLikeElementAccess,
|
|
isLiteralNameOfPropertyDeclarationOrIndexAccess: () => isLiteralNameOfPropertyDeclarationOrIndexAccess,
|
|
isLiteralTypeLikeExpression: () => isLiteralTypeLikeExpression,
|
|
isLiteralTypeNode: () => isLiteralTypeNode,
|
|
isLocalName: () => isLocalName,
|
|
isLogicalOperator: () => isLogicalOperator,
|
|
isLogicalOrCoalescingAssignmentExpression: () => isLogicalOrCoalescingAssignmentExpression,
|
|
isLogicalOrCoalescingAssignmentOperator: () => isLogicalOrCoalescingAssignmentOperator,
|
|
isMappedTypeNode: () => isMappedTypeNode,
|
|
isMemberName: () => isMemberName,
|
|
isMergeDeclarationMarker: () => isMergeDeclarationMarker,
|
|
isMetaProperty: () => isMetaProperty,
|
|
isMethodDeclaration: () => isMethodDeclaration,
|
|
isMethodOrAccessor: () => isMethodOrAccessor,
|
|
isMethodSignature: () => isMethodSignature,
|
|
isMinusToken: () => isMinusToken,
|
|
isMissingDeclaration: () => isMissingDeclaration,
|
|
isModifier: () => isModifier,
|
|
isModifierKind: () => isModifierKind,
|
|
isModifierLike: () => isModifierLike,
|
|
isModuleAugmentationExternal: () => isModuleAugmentationExternal,
|
|
isModuleBlock: () => isModuleBlock,
|
|
isModuleBody: () => isModuleBody,
|
|
isModuleDeclaration: () => isModuleDeclaration,
|
|
isModuleExportsAccessExpression: () => isModuleExportsAccessExpression,
|
|
isModuleIdentifier: () => isModuleIdentifier,
|
|
isModuleName: () => isModuleName,
|
|
isModuleOrEnumDeclaration: () => isModuleOrEnumDeclaration,
|
|
isModuleReference: () => isModuleReference,
|
|
isModuleSpecifierLike: () => isModuleSpecifierLike,
|
|
isModuleWithStringLiteralName: () => isModuleWithStringLiteralName,
|
|
isNameOfFunctionDeclaration: () => isNameOfFunctionDeclaration,
|
|
isNameOfModuleDeclaration: () => isNameOfModuleDeclaration,
|
|
isNamedClassElement: () => isNamedClassElement,
|
|
isNamedDeclaration: () => isNamedDeclaration,
|
|
isNamedExportBindings: () => isNamedExportBindings,
|
|
isNamedExports: () => isNamedExports,
|
|
isNamedImportBindings: () => isNamedImportBindings,
|
|
isNamedImports: () => isNamedImports,
|
|
isNamedImportsOrExports: () => isNamedImportsOrExports,
|
|
isNamedTupleMember: () => isNamedTupleMember,
|
|
isNamespaceBody: () => isNamespaceBody,
|
|
isNamespaceExport: () => isNamespaceExport,
|
|
isNamespaceExportDeclaration: () => isNamespaceExportDeclaration,
|
|
isNamespaceImport: () => isNamespaceImport,
|
|
isNamespaceReexportDeclaration: () => isNamespaceReexportDeclaration,
|
|
isNewExpression: () => isNewExpression,
|
|
isNewExpressionTarget: () => isNewExpressionTarget,
|
|
isNightly: () => isNightly,
|
|
isNoSubstitutionTemplateLiteral: () => isNoSubstitutionTemplateLiteral,
|
|
isNode: () => isNode,
|
|
isNodeArray: () => isNodeArray,
|
|
isNodeArrayMultiLine: () => isNodeArrayMultiLine,
|
|
isNodeDescendantOf: () => isNodeDescendantOf,
|
|
isNodeKind: () => isNodeKind,
|
|
isNodeLikeSystem: () => isNodeLikeSystem,
|
|
isNodeModulesDirectory: () => isNodeModulesDirectory,
|
|
isNodeWithPossibleHoistedDeclaration: () => isNodeWithPossibleHoistedDeclaration,
|
|
isNonContextualKeyword: () => isNonContextualKeyword,
|
|
isNonGlobalAmbientModule: () => isNonGlobalAmbientModule,
|
|
isNonGlobalDeclaration: () => isNonGlobalDeclaration,
|
|
isNonNullChain: () => isNonNullChain,
|
|
isNonNullExpression: () => isNonNullExpression,
|
|
isNonStaticMethodOrAccessorWithPrivateName: () => isNonStaticMethodOrAccessorWithPrivateName,
|
|
isNotEmittedOrPartiallyEmittedNode: () => isNotEmittedOrPartiallyEmittedNode,
|
|
isNotEmittedStatement: () => isNotEmittedStatement,
|
|
isNullishCoalesce: () => isNullishCoalesce,
|
|
isNumber: () => isNumber,
|
|
isNumericLiteral: () => isNumericLiteral,
|
|
isNumericLiteralName: () => isNumericLiteralName,
|
|
isObjectBindingElementWithoutPropertyName: () => isObjectBindingElementWithoutPropertyName,
|
|
isObjectBindingOrAssignmentElement: () => isObjectBindingOrAssignmentElement,
|
|
isObjectBindingOrAssignmentPattern: () => isObjectBindingOrAssignmentPattern,
|
|
isObjectBindingPattern: () => isObjectBindingPattern,
|
|
isObjectLiteralElement: () => isObjectLiteralElement,
|
|
isObjectLiteralElementLike: () => isObjectLiteralElementLike,
|
|
isObjectLiteralExpression: () => isObjectLiteralExpression,
|
|
isObjectLiteralMethod: () => isObjectLiteralMethod,
|
|
isObjectLiteralOrClassExpressionMethodOrAccessor: () => isObjectLiteralOrClassExpressionMethodOrAccessor,
|
|
isObjectTypeDeclaration: () => isObjectTypeDeclaration,
|
|
isOctalDigit: () => isOctalDigit,
|
|
isOmittedExpression: () => isOmittedExpression,
|
|
isOptionalChain: () => isOptionalChain,
|
|
isOptionalChainRoot: () => isOptionalChainRoot,
|
|
isOptionalJSDocPropertyLikeTag: () => isOptionalJSDocPropertyLikeTag,
|
|
isOptionalTypeNode: () => isOptionalTypeNode,
|
|
isOuterExpression: () => isOuterExpression,
|
|
isOutermostOptionalChain: () => isOutermostOptionalChain,
|
|
isOverrideModifier: () => isOverrideModifier,
|
|
isPackedArrayLiteral: () => isPackedArrayLiteral,
|
|
isParameter: () => isParameter,
|
|
isParameterDeclaration: () => isParameterDeclaration,
|
|
isParameterOrCatchClauseVariable: () => isParameterOrCatchClauseVariable,
|
|
isParameterPropertyDeclaration: () => isParameterPropertyDeclaration,
|
|
isParameterPropertyModifier: () => isParameterPropertyModifier,
|
|
isParenthesizedExpression: () => isParenthesizedExpression,
|
|
isParenthesizedTypeNode: () => isParenthesizedTypeNode,
|
|
isParseTreeNode: () => isParseTreeNode,
|
|
isPartOfTypeNode: () => isPartOfTypeNode,
|
|
isPartOfTypeQuery: () => isPartOfTypeQuery,
|
|
isPartiallyEmittedExpression: () => isPartiallyEmittedExpression,
|
|
isPatternMatch: () => isPatternMatch,
|
|
isPinnedComment: () => isPinnedComment,
|
|
isPlainJsFile: () => isPlainJsFile,
|
|
isPlusToken: () => isPlusToken,
|
|
isPossiblyTypeArgumentPosition: () => isPossiblyTypeArgumentPosition,
|
|
isPostfixUnaryExpression: () => isPostfixUnaryExpression,
|
|
isPrefixUnaryExpression: () => isPrefixUnaryExpression,
|
|
isPrivateIdentifier: () => isPrivateIdentifier,
|
|
isPrivateIdentifierClassElementDeclaration: () => isPrivateIdentifierClassElementDeclaration,
|
|
isPrivateIdentifierPropertyAccessExpression: () => isPrivateIdentifierPropertyAccessExpression,
|
|
isPrivateIdentifierSymbol: () => isPrivateIdentifierSymbol,
|
|
isProgramBundleEmitBuildInfo: () => isProgramBundleEmitBuildInfo,
|
|
isProgramUptoDate: () => isProgramUptoDate,
|
|
isPrologueDirective: () => isPrologueDirective,
|
|
isPropertyAccessChain: () => isPropertyAccessChain,
|
|
isPropertyAccessEntityNameExpression: () => isPropertyAccessEntityNameExpression,
|
|
isPropertyAccessExpression: () => isPropertyAccessExpression,
|
|
isPropertyAccessOrQualifiedName: () => isPropertyAccessOrQualifiedName,
|
|
isPropertyAccessOrQualifiedNameOrImportTypeNode: () => isPropertyAccessOrQualifiedNameOrImportTypeNode,
|
|
isPropertyAssignment: () => isPropertyAssignment,
|
|
isPropertyDeclaration: () => isPropertyDeclaration,
|
|
isPropertyName: () => isPropertyName,
|
|
isPropertyNameLiteral: () => isPropertyNameLiteral,
|
|
isPropertySignature: () => isPropertySignature,
|
|
isPrototypeAccess: () => isPrototypeAccess,
|
|
isPrototypePropertyAssignment: () => isPrototypePropertyAssignment,
|
|
isPunctuation: () => isPunctuation,
|
|
isPushOrUnshiftIdentifier: () => isPushOrUnshiftIdentifier,
|
|
isQualifiedName: () => isQualifiedName,
|
|
isQuestionDotToken: () => isQuestionDotToken,
|
|
isQuestionOrExclamationToken: () => isQuestionOrExclamationToken,
|
|
isQuestionOrPlusOrMinusToken: () => isQuestionOrPlusOrMinusToken,
|
|
isQuestionToken: () => isQuestionToken,
|
|
isRawSourceMap: () => isRawSourceMap,
|
|
isReadonlyKeyword: () => isReadonlyKeyword,
|
|
isReadonlyKeywordOrPlusOrMinusToken: () => isReadonlyKeywordOrPlusOrMinusToken,
|
|
isRecognizedTripleSlashComment: () => isRecognizedTripleSlashComment,
|
|
isReferenceFileLocation: () => isReferenceFileLocation,
|
|
isReferencedFile: () => isReferencedFile,
|
|
isRegularExpressionLiteral: () => isRegularExpressionLiteral,
|
|
isRequireCall: () => isRequireCall,
|
|
isRequireVariableStatement: () => isRequireVariableStatement,
|
|
isRestParameter: () => isRestParameter,
|
|
isRestTypeNode: () => isRestTypeNode,
|
|
isReturnStatement: () => isReturnStatement,
|
|
isReturnStatementWithFixablePromiseHandler: () => isReturnStatementWithFixablePromiseHandler,
|
|
isRightSideOfAccessExpression: () => isRightSideOfAccessExpression,
|
|
isRightSideOfPropertyAccess: () => isRightSideOfPropertyAccess,
|
|
isRightSideOfQualifiedName: () => isRightSideOfQualifiedName,
|
|
isRightSideOfQualifiedNameOrPropertyAccess: () => isRightSideOfQualifiedNameOrPropertyAccess,
|
|
isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName: () => isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName,
|
|
isRootedDiskPath: () => isRootedDiskPath,
|
|
isSameEntityName: () => isSameEntityName,
|
|
isSatisfiesExpression: () => isSatisfiesExpression,
|
|
isScopeMarker: () => isScopeMarker,
|
|
isSemicolonClassElement: () => isSemicolonClassElement,
|
|
isSetAccessor: () => isSetAccessor,
|
|
isSetAccessorDeclaration: () => isSetAccessorDeclaration,
|
|
isShebangTrivia: () => isShebangTrivia,
|
|
isShorthandAmbientModuleSymbol: () => isShorthandAmbientModuleSymbol,
|
|
isShorthandPropertyAssignment: () => isShorthandPropertyAssignment,
|
|
isSignedNumericLiteral: () => isSignedNumericLiteral,
|
|
isSimpleCopiableExpression: () => isSimpleCopiableExpression,
|
|
isSimpleInlineableExpression: () => isSimpleInlineableExpression,
|
|
isSingleOrDoubleQuote: () => isSingleOrDoubleQuote,
|
|
isSourceFile: () => isSourceFile,
|
|
isSourceFileFromLibrary: () => isSourceFileFromLibrary,
|
|
isSourceFileJS: () => isSourceFileJS,
|
|
isSourceFileNotJS: () => isSourceFileNotJS,
|
|
isSourceFileNotJson: () => isSourceFileNotJson,
|
|
isSourceMapping: () => isSourceMapping,
|
|
isSpecialPropertyDeclaration: () => isSpecialPropertyDeclaration,
|
|
isSpreadAssignment: () => isSpreadAssignment,
|
|
isSpreadElement: () => isSpreadElement,
|
|
isStatement: () => isStatement,
|
|
isStatementButNotDeclaration: () => isStatementButNotDeclaration,
|
|
isStatementOrBlock: () => isStatementOrBlock,
|
|
isStatementWithLocals: () => isStatementWithLocals,
|
|
isStatic: () => isStatic,
|
|
isStaticModifier: () => isStaticModifier,
|
|
isString: () => isString,
|
|
isStringAKeyword: () => isStringAKeyword,
|
|
isStringANonContextualKeyword: () => isStringANonContextualKeyword,
|
|
isStringDoubleQuoted: () => isStringDoubleQuoted,
|
|
isStringLiteral: () => isStringLiteral,
|
|
isStringLiteralLike: () => isStringLiteralLike,
|
|
isStringLiteralOrJsxExpression: () => isStringLiteralOrJsxExpression,
|
|
isStringLiteralOrTemplate: () => isStringLiteralOrTemplate,
|
|
isStringOrNumericLiteralLike: () => isStringOrNumericLiteralLike,
|
|
isStringOrRegularExpressionOrTemplateLiteral: () => isStringOrRegularExpressionOrTemplateLiteral,
|
|
isStringTextContainingNode: () => isStringTextContainingNode,
|
|
isSuperCall: () => isSuperCall,
|
|
isSuperKeyword: () => isSuperKeyword,
|
|
isSuperOrSuperProperty: () => isSuperOrSuperProperty,
|
|
isSuperProperty: () => isSuperProperty,
|
|
isSupportedSourceFileName: () => isSupportedSourceFileName,
|
|
isSwitchStatement: () => isSwitchStatement,
|
|
isSyntaxList: () => isSyntaxList,
|
|
isSyntheticExpression: () => isSyntheticExpression,
|
|
isSyntheticReference: () => isSyntheticReference,
|
|
isTagName: () => isTagName,
|
|
isTaggedTemplateExpression: () => isTaggedTemplateExpression,
|
|
isTaggedTemplateTag: () => isTaggedTemplateTag,
|
|
isTemplateExpression: () => isTemplateExpression,
|
|
isTemplateHead: () => isTemplateHead,
|
|
isTemplateLiteral: () => isTemplateLiteral,
|
|
isTemplateLiteralKind: () => isTemplateLiteralKind,
|
|
isTemplateLiteralToken: () => isTemplateLiteralToken,
|
|
isTemplateLiteralTypeNode: () => isTemplateLiteralTypeNode,
|
|
isTemplateLiteralTypeSpan: () => isTemplateLiteralTypeSpan,
|
|
isTemplateMiddle: () => isTemplateMiddle,
|
|
isTemplateMiddleOrTemplateTail: () => isTemplateMiddleOrTemplateTail,
|
|
isTemplateSpan: () => isTemplateSpan,
|
|
isTemplateTail: () => isTemplateTail,
|
|
isTextWhiteSpaceLike: () => isTextWhiteSpaceLike,
|
|
isThis: () => isThis,
|
|
isThisContainerOrFunctionBlock: () => isThisContainerOrFunctionBlock,
|
|
isThisIdentifier: () => isThisIdentifier,
|
|
isThisInTypeQuery: () => isThisInTypeQuery,
|
|
isThisInitializedDeclaration: () => isThisInitializedDeclaration,
|
|
isThisInitializedObjectBindingExpression: () => isThisInitializedObjectBindingExpression,
|
|
isThisProperty: () => isThisProperty,
|
|
isThisTypeNode: () => isThisTypeNode,
|
|
isThisTypeParameter: () => isThisTypeParameter,
|
|
isThisTypePredicate: () => isThisTypePredicate,
|
|
isThrowStatement: () => isThrowStatement,
|
|
isToken: () => isToken,
|
|
isTokenKind: () => isTokenKind,
|
|
isTraceEnabled: () => isTraceEnabled,
|
|
isTransientSymbol: () => isTransientSymbol,
|
|
isTrivia: () => isTrivia,
|
|
isTryStatement: () => isTryStatement,
|
|
isTupleTypeNode: () => isTupleTypeNode,
|
|
isTypeAlias: () => isTypeAlias,
|
|
isTypeAliasDeclaration: () => isTypeAliasDeclaration,
|
|
isTypeAssertion: () => isTypeAssertion,
|
|
isTypeAssertionExpression: () => isTypeAssertionExpression,
|
|
isTypeDeclaration: () => isTypeDeclaration,
|
|
isTypeElement: () => isTypeElement,
|
|
isTypeKeyword: () => isTypeKeyword,
|
|
isTypeKeywordToken: () => isTypeKeywordToken,
|
|
isTypeKeywordTokenOrIdentifier: () => isTypeKeywordTokenOrIdentifier,
|
|
isTypeLiteralNode: () => isTypeLiteralNode,
|
|
isTypeNode: () => isTypeNode,
|
|
isTypeNodeKind: () => isTypeNodeKind,
|
|
isTypeNodeOrTypeParameterDeclaration: () => isTypeNodeOrTypeParameterDeclaration,
|
|
isTypeOfExpression: () => isTypeOfExpression,
|
|
isTypeOnlyImportOrExportDeclaration: () => isTypeOnlyImportOrExportDeclaration,
|
|
isTypeOperatorNode: () => isTypeOperatorNode,
|
|
isTypeParameterDeclaration: () => isTypeParameterDeclaration,
|
|
isTypePredicateNode: () => isTypePredicateNode,
|
|
isTypeQueryNode: () => isTypeQueryNode,
|
|
isTypeReferenceNode: () => isTypeReferenceNode,
|
|
isTypeReferenceType: () => isTypeReferenceType,
|
|
isUMDExportSymbol: () => isUMDExportSymbol,
|
|
isUnaryExpression: () => isUnaryExpression,
|
|
isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
|
|
isUnicodeIdentifierStart: () => isUnicodeIdentifierStart,
|
|
isUnionTypeNode: () => isUnionTypeNode,
|
|
isUnparsedNode: () => isUnparsedNode,
|
|
isUnparsedPrepend: () => isUnparsedPrepend,
|
|
isUnparsedSource: () => isUnparsedSource,
|
|
isUnparsedTextLike: () => isUnparsedTextLike,
|
|
isUrl: () => isUrl,
|
|
isValidESSymbolDeclaration: () => isValidESSymbolDeclaration,
|
|
isValidTypeOnlyAliasUseSite: () => isValidTypeOnlyAliasUseSite,
|
|
isValueSignatureDeclaration: () => isValueSignatureDeclaration,
|
|
isVarConst: () => isVarConst,
|
|
isVariableDeclaration: () => isVariableDeclaration,
|
|
isVariableDeclarationInVariableStatement: () => isVariableDeclarationInVariableStatement,
|
|
isVariableDeclarationInitializedToBareOrAccessedRequire: () => isVariableDeclarationInitializedToBareOrAccessedRequire,
|
|
isVariableDeclarationInitializedToRequire: () => isVariableDeclarationInitializedToRequire,
|
|
isVariableDeclarationList: () => isVariableDeclarationList,
|
|
isVariableLike: () => isVariableLike,
|
|
isVariableLikeOrAccessor: () => isVariableLikeOrAccessor,
|
|
isVariableStatement: () => isVariableStatement,
|
|
isVoidExpression: () => isVoidExpression,
|
|
isWatchSet: () => isWatchSet,
|
|
isWhileStatement: () => isWhileStatement,
|
|
isWhiteSpaceLike: () => isWhiteSpaceLike,
|
|
isWhiteSpaceSingleLine: () => isWhiteSpaceSingleLine,
|
|
isWithStatement: () => isWithStatement,
|
|
isWriteAccess: () => isWriteAccess,
|
|
isWriteOnlyAccess: () => isWriteOnlyAccess,
|
|
isYieldExpression: () => isYieldExpression,
|
|
jsxModeNeedsExplicitImport: () => jsxModeNeedsExplicitImport,
|
|
keywordPart: () => keywordPart,
|
|
last: () => last,
|
|
lastOrUndefined: () => lastOrUndefined,
|
|
length: () => length,
|
|
libMap: () => libMap,
|
|
libs: () => libs,
|
|
lineBreakPart: () => lineBreakPart,
|
|
linkNamePart: () => linkNamePart,
|
|
linkPart: () => linkPart,
|
|
linkTextPart: () => linkTextPart,
|
|
listFiles: () => listFiles,
|
|
loadModuleFromGlobalCache: () => loadModuleFromGlobalCache,
|
|
loadWithModeAwareCache: () => loadWithModeAwareCache,
|
|
loadWithTypeDirectiveCache: () => loadWithTypeDirectiveCache,
|
|
makeIdentifierFromModuleName: () => makeIdentifierFromModuleName,
|
|
makeImport: () => makeImport,
|
|
makeImportIfNecessary: () => makeImportIfNecessary,
|
|
makeStringLiteral: () => makeStringLiteral,
|
|
mangleScopedPackageName: () => mangleScopedPackageName,
|
|
map: () => map,
|
|
mapAllOrFail: () => mapAllOrFail,
|
|
mapDefined: () => mapDefined,
|
|
mapDefinedEntries: () => mapDefinedEntries,
|
|
mapDefinedIterator: () => mapDefinedIterator,
|
|
mapDefinedValues: () => mapDefinedValues,
|
|
mapEntries: () => mapEntries,
|
|
mapIterator: () => mapIterator,
|
|
mapOneOrMany: () => mapOneOrMany,
|
|
mapToDisplayParts: () => mapToDisplayParts,
|
|
matchFiles: () => matchFiles,
|
|
matchPatternOrExact: () => matchPatternOrExact,
|
|
matchedText: () => matchedText,
|
|
matchesExclude: () => matchesExclude,
|
|
maybeBind: () => maybeBind,
|
|
maybeSetLocalizedDiagnosticMessages: () => maybeSetLocalizedDiagnosticMessages,
|
|
memoize: () => memoize,
|
|
memoizeOne: () => memoizeOne,
|
|
metadataHelper: () => metadataHelper,
|
|
min: () => min,
|
|
minAndMax: () => minAndMax,
|
|
missingFileModifiedTime: () => missingFileModifiedTime,
|
|
modifierToFlag: () => modifierToFlag,
|
|
modifiersToFlags: () => modifiersToFlags,
|
|
moduleOptionDeclaration: () => moduleOptionDeclaration,
|
|
moduleResolutionIsEqualTo: () => moduleResolutionIsEqualTo,
|
|
moduleResolutionOptionDeclarations: () => moduleResolutionOptionDeclarations,
|
|
moduleResolutionRespectsExports: () => moduleResolutionRespectsExports,
|
|
moduleResolutionUsesNodeModules: () => moduleResolutionUsesNodeModules,
|
|
moduleSpecifiers: () => ts_moduleSpecifiers_exports,
|
|
moveEmitHelpers: () => moveEmitHelpers,
|
|
moveRangeEnd: () => moveRangeEnd,
|
|
moveRangePastDecorators: () => moveRangePastDecorators,
|
|
moveRangePastModifiers: () => moveRangePastModifiers,
|
|
moveRangePos: () => moveRangePos,
|
|
moveSyntheticComments: () => moveSyntheticComments,
|
|
mutateMap: () => mutateMap,
|
|
mutateMapSkippingNewValues: () => mutateMapSkippingNewValues,
|
|
needsParentheses: () => needsParentheses,
|
|
needsScopeMarker: () => needsScopeMarker,
|
|
noEmitNotification: () => noEmitNotification,
|
|
noEmitSubstitution: () => noEmitSubstitution,
|
|
noTransformers: () => noTransformers,
|
|
noTruncationMaximumTruncationLength: () => noTruncationMaximumTruncationLength,
|
|
nodeCanBeDecorated: () => nodeCanBeDecorated,
|
|
nodeHasName: () => nodeHasName,
|
|
nodeIsDecorated: () => nodeIsDecorated,
|
|
nodeIsMissing: () => nodeIsMissing,
|
|
nodeIsPresent: () => nodeIsPresent,
|
|
nodeIsSynthesized: () => nodeIsSynthesized,
|
|
nodeModuleNameResolver: () => nodeModuleNameResolver,
|
|
nodeModulesPathPart: () => nodeModulesPathPart,
|
|
nodeOrChildIsDecorated: () => nodeOrChildIsDecorated,
|
|
nodeOverlapsWithStartEnd: () => nodeOverlapsWithStartEnd,
|
|
nodePosToString: () => nodePosToString,
|
|
nodeSeenTracker: () => nodeSeenTracker,
|
|
nodeStartsNewLexicalEnvironment: () => nodeStartsNewLexicalEnvironment,
|
|
nodeToDisplayParts: () => nodeToDisplayParts,
|
|
noop: () => noop,
|
|
noopFileWatcher: () => noopFileWatcher,
|
|
noopPush: () => noopPush,
|
|
normalizePath: () => normalizePath,
|
|
normalizeSlashes: () => normalizeSlashes,
|
|
not: () => not,
|
|
notImplemented: () => notImplemented,
|
|
notImplementedResolver: () => notImplementedResolver,
|
|
nullNodeConverters: () => nullNodeConverters,
|
|
nullParenthesizerRules: () => nullParenthesizerRules,
|
|
nullTransformationContext: () => nullTransformationContext,
|
|
objectAllocator: () => objectAllocator,
|
|
operatorPart: () => operatorPart,
|
|
optionDeclarations: () => optionDeclarations,
|
|
optionMapToObject: () => optionMapToObject,
|
|
optionsAffectingProgramStructure: () => optionsAffectingProgramStructure,
|
|
optionsForBuild: () => optionsForBuild,
|
|
optionsForWatch: () => optionsForWatch,
|
|
optionsHaveChanges: () => optionsHaveChanges,
|
|
optionsHaveModuleResolutionChanges: () => optionsHaveModuleResolutionChanges,
|
|
or: () => or,
|
|
orderedRemoveItem: () => orderedRemoveItem,
|
|
orderedRemoveItemAt: () => orderedRemoveItemAt,
|
|
outFile: () => outFile,
|
|
packageIdToPackageName: () => packageIdToPackageName,
|
|
packageIdToString: () => packageIdToString,
|
|
padLeft: () => padLeft,
|
|
padRight: () => padRight,
|
|
paramHelper: () => paramHelper,
|
|
parameterIsThisKeyword: () => parameterIsThisKeyword,
|
|
parameterNamePart: () => parameterNamePart,
|
|
parseBaseNodeFactory: () => parseBaseNodeFactory,
|
|
parseBuildCommand: () => parseBuildCommand,
|
|
parseCommandLine: () => parseCommandLine,
|
|
parseCommandLineWorker: () => parseCommandLineWorker,
|
|
parseConfigFileTextToJson: () => parseConfigFileTextToJson,
|
|
parseConfigFileWithSystem: () => parseConfigFileWithSystem,
|
|
parseConfigHostFromCompilerHostLike: () => parseConfigHostFromCompilerHostLike,
|
|
parseCustomTypeOption: () => parseCustomTypeOption,
|
|
parseIsolatedEntityName: () => parseIsolatedEntityName,
|
|
parseIsolatedJSDocComment: () => parseIsolatedJSDocComment,
|
|
parseJSDocTypeExpressionForTests: () => parseJSDocTypeExpressionForTests,
|
|
parseJsonConfigFileContent: () => parseJsonConfigFileContent,
|
|
parseJsonSourceFileConfigFileContent: () => parseJsonSourceFileConfigFileContent,
|
|
parseJsonText: () => parseJsonText,
|
|
parseListTypeOption: () => parseListTypeOption,
|
|
parseNodeFactory: () => parseNodeFactory,
|
|
parseNodeModuleFromPath: () => parseNodeModuleFromPath,
|
|
parsePackageName: () => parsePackageName,
|
|
parsePseudoBigInt: () => parsePseudoBigInt,
|
|
patchWriteFileEnsuringDirectory: () => patchWriteFileEnsuringDirectory,
|
|
pathContainsNodeModules: () => pathContainsNodeModules,
|
|
pathIsAbsolute: () => pathIsAbsolute,
|
|
pathIsBareSpecifier: () => pathIsBareSpecifier,
|
|
pathIsRelative: () => pathIsRelative,
|
|
patternText: () => patternText,
|
|
perfLogger: () => perfLogger,
|
|
performIncrementalCompilation: () => performIncrementalCompilation,
|
|
performance: () => ts_performance_exports,
|
|
plainJSErrors: () => plainJSErrors,
|
|
positionBelongsToNode: () => positionBelongsToNode,
|
|
positionIsASICandidate: () => positionIsASICandidate,
|
|
positionIsSynthesized: () => positionIsSynthesized,
|
|
positionsAreOnSameLine: () => positionsAreOnSameLine,
|
|
preProcessFile: () => preProcessFile,
|
|
probablyUsesSemicolons: () => probablyUsesSemicolons,
|
|
processCommentPragmas: () => processCommentPragmas,
|
|
processPragmasIntoFields: () => processPragmasIntoFields,
|
|
processTaggedTemplateExpression: () => processTaggedTemplateExpression,
|
|
programContainsEsModules: () => programContainsEsModules,
|
|
programContainsModules: () => programContainsModules,
|
|
projectReferenceIsEqualTo: () => projectReferenceIsEqualTo,
|
|
propertyNamePart: () => propertyNamePart,
|
|
pseudoBigIntToString: () => pseudoBigIntToString,
|
|
punctuationPart: () => punctuationPart,
|
|
pushIfUnique: () => pushIfUnique,
|
|
quote: () => quote,
|
|
quotePreferenceFromString: () => quotePreferenceFromString,
|
|
rangeContainsPosition: () => rangeContainsPosition,
|
|
rangeContainsPositionExclusive: () => rangeContainsPositionExclusive,
|
|
rangeContainsRange: () => rangeContainsRange,
|
|
rangeContainsRangeExclusive: () => rangeContainsRangeExclusive,
|
|
rangeContainsStartEnd: () => rangeContainsStartEnd,
|
|
rangeEndIsOnSameLineAsRangeStart: () => rangeEndIsOnSameLineAsRangeStart,
|
|
rangeEndPositionsAreOnSameLine: () => rangeEndPositionsAreOnSameLine,
|
|
rangeEquals: () => rangeEquals,
|
|
rangeIsOnSingleLine: () => rangeIsOnSingleLine,
|
|
rangeOfNode: () => rangeOfNode,
|
|
rangeOfTypeParameters: () => rangeOfTypeParameters,
|
|
rangeOverlapsWithStartEnd: () => rangeOverlapsWithStartEnd,
|
|
rangeStartIsOnSameLineAsRangeEnd: () => rangeStartIsOnSameLineAsRangeEnd,
|
|
rangeStartPositionsAreOnSameLine: () => rangeStartPositionsAreOnSameLine,
|
|
readBuilderProgram: () => readBuilderProgram,
|
|
readConfigFile: () => readConfigFile,
|
|
readHelper: () => readHelper,
|
|
readJson: () => readJson,
|
|
readJsonConfigFile: () => readJsonConfigFile,
|
|
readJsonOrUndefined: () => readJsonOrUndefined,
|
|
realizeDiagnostics: () => realizeDiagnostics,
|
|
reduceEachLeadingCommentRange: () => reduceEachLeadingCommentRange,
|
|
reduceEachTrailingCommentRange: () => reduceEachTrailingCommentRange,
|
|
reduceLeft: () => reduceLeft,
|
|
reduceLeftIterator: () => reduceLeftIterator,
|
|
reducePathComponents: () => reducePathComponents,
|
|
refactor: () => ts_refactor_exports,
|
|
regExpEscape: () => regExpEscape,
|
|
relativeComplement: () => relativeComplement,
|
|
removeAllComments: () => removeAllComments,
|
|
removeEmitHelper: () => removeEmitHelper,
|
|
removeExtension: () => removeExtension,
|
|
removeFileExtension: () => removeFileExtension,
|
|
removeIgnoredPath: () => removeIgnoredPath,
|
|
removeMinAndVersionNumbers: () => removeMinAndVersionNumbers,
|
|
removeOptionality: () => removeOptionality,
|
|
removePrefix: () => removePrefix,
|
|
removeSuffix: () => removeSuffix,
|
|
removeTrailingDirectorySeparator: () => removeTrailingDirectorySeparator,
|
|
repeatString: () => repeatString,
|
|
replaceElement: () => replaceElement,
|
|
resolutionExtensionIsTSOrJson: () => resolutionExtensionIsTSOrJson,
|
|
resolveConfigFileProjectName: () => resolveConfigFileProjectName,
|
|
resolveJSModule: () => resolveJSModule,
|
|
resolveModuleName: () => resolveModuleName,
|
|
resolveModuleNameFromCache: () => resolveModuleNameFromCache,
|
|
resolvePackageNameToPackageJson: () => resolvePackageNameToPackageJson,
|
|
resolvePath: () => resolvePath,
|
|
resolveProjectReferencePath: () => resolveProjectReferencePath,
|
|
resolveTripleslashReference: () => resolveTripleslashReference,
|
|
resolveTypeReferenceDirective: () => resolveTypeReferenceDirective,
|
|
resolvingEmptyArray: () => resolvingEmptyArray,
|
|
restHelper: () => restHelper,
|
|
returnFalse: () => returnFalse,
|
|
returnNoopFileWatcher: () => returnNoopFileWatcher,
|
|
returnTrue: () => returnTrue,
|
|
returnUndefined: () => returnUndefined,
|
|
returnsPromise: () => returnsPromise,
|
|
sameFlatMap: () => sameFlatMap,
|
|
sameMap: () => sameMap,
|
|
sameMapping: () => sameMapping,
|
|
scanShebangTrivia: () => scanShebangTrivia,
|
|
scanner: () => scanner,
|
|
screenStartingMessageCodes: () => screenStartingMessageCodes,
|
|
semanticDiagnosticsOptionDeclarations: () => semanticDiagnosticsOptionDeclarations,
|
|
serializeCompilerOptions: () => serializeCompilerOptions,
|
|
server: () => ts_server_exports2,
|
|
servicesVersion: () => servicesVersion,
|
|
setCommentRange: () => setCommentRange,
|
|
setConfigFileInOptions: () => setConfigFileInOptions,
|
|
setConstantValue: () => setConstantValue,
|
|
setEachParent: () => setEachParent,
|
|
setEmitFlags: () => setEmitFlags,
|
|
setGetSourceFileAsHashVersioned: () => setGetSourceFileAsHashVersioned,
|
|
setLocalizedDiagnosticMessages: () => setLocalizedDiagnosticMessages,
|
|
setModuleDefaultHelper: () => setModuleDefaultHelper,
|
|
setNodeFlags: () => setNodeFlags,
|
|
setObjectAllocator: () => setObjectAllocator,
|
|
setOriginalNode: () => setOriginalNode,
|
|
setParent: () => setParent,
|
|
setParentRecursive: () => setParentRecursive,
|
|
setResolvedModule: () => setResolvedModule,
|
|
setResolvedTypeReferenceDirective: () => setResolvedTypeReferenceDirective,
|
|
setSnippetElement: () => setSnippetElement,
|
|
setSourceMapRange: () => setSourceMapRange,
|
|
setStackTraceLimit: () => setStackTraceLimit,
|
|
setStartsOnNewLine: () => setStartsOnNewLine,
|
|
setSyntheticLeadingComments: () => setSyntheticLeadingComments,
|
|
setSyntheticTrailingComments: () => setSyntheticTrailingComments,
|
|
setSys: () => setSys,
|
|
setSysLog: () => setSysLog,
|
|
setTextRange: () => setTextRange,
|
|
setTextRangeEnd: () => setTextRangeEnd,
|
|
setTextRangePos: () => setTextRangePos,
|
|
setTextRangePosEnd: () => setTextRangePosEnd,
|
|
setTextRangePosWidth: () => setTextRangePosWidth,
|
|
setTokenSourceMapRange: () => setTokenSourceMapRange,
|
|
setTypeNode: () => setTypeNode,
|
|
setUILocale: () => setUILocale,
|
|
setValueDeclaration: () => setValueDeclaration,
|
|
shouldPreserveConstEnums: () => shouldPreserveConstEnums,
|
|
shouldUseUriStyleNodeCoreModules: () => shouldUseUriStyleNodeCoreModules,
|
|
showModuleSpecifier: () => showModuleSpecifier,
|
|
signatureHasLiteralTypes: () => signatureHasLiteralTypes,
|
|
signatureHasRestParameter: () => signatureHasRestParameter,
|
|
signatureToDisplayParts: () => signatureToDisplayParts,
|
|
single: () => single,
|
|
singleElementArray: () => singleElementArray,
|
|
singleIterator: () => singleIterator,
|
|
singleOrMany: () => singleOrMany,
|
|
singleOrUndefined: () => singleOrUndefined,
|
|
skipAlias: () => skipAlias,
|
|
skipAssertions: () => skipAssertions,
|
|
skipConstraint: () => skipConstraint,
|
|
skipOuterExpressions: () => skipOuterExpressions,
|
|
skipParentheses: () => skipParentheses,
|
|
skipPartiallyEmittedExpressions: () => skipPartiallyEmittedExpressions,
|
|
skipTrivia: () => skipTrivia,
|
|
skipTypeChecking: () => skipTypeChecking,
|
|
skipTypeParentheses: () => skipTypeParentheses,
|
|
sliceAfter: () => sliceAfter,
|
|
some: () => some,
|
|
sort: () => sort,
|
|
sortAndDeduplicate: () => sortAndDeduplicate,
|
|
sortAndDeduplicateDiagnostics: () => sortAndDeduplicateDiagnostics,
|
|
sourceFileAffectingCompilerOptions: () => sourceFileAffectingCompilerOptions,
|
|
sourceFileMayBeEmitted: () => sourceFileMayBeEmitted,
|
|
sourceMapCommentRegExp: () => sourceMapCommentRegExp,
|
|
sourceMapCommentRegExpDontCareLineStart: () => sourceMapCommentRegExpDontCareLineStart,
|
|
spacePart: () => spacePart,
|
|
spanMap: () => spanMap,
|
|
spreadArrayHelper: () => spreadArrayHelper,
|
|
stableSort: () => stableSort,
|
|
startEndContainsRange: () => startEndContainsRange,
|
|
startEndOverlapsWithStartEnd: () => startEndOverlapsWithStartEnd,
|
|
startOnNewLine: () => startOnNewLine,
|
|
startTracing: () => startTracing,
|
|
startsWith: () => startsWith,
|
|
startsWithDirectory: () => startsWithDirectory,
|
|
startsWithUnderscore: () => startsWithUnderscore,
|
|
startsWithUseStrict: () => startsWithUseStrict,
|
|
stringContains: () => stringContains,
|
|
stringContainsAt: () => stringContainsAt,
|
|
stringToToken: () => stringToToken,
|
|
stripQuotes: () => stripQuotes,
|
|
sum: () => sum,
|
|
supportedDeclarationExtensions: () => supportedDeclarationExtensions,
|
|
supportedJSExtensions: () => supportedJSExtensions,
|
|
supportedJSExtensionsFlat: () => supportedJSExtensionsFlat,
|
|
supportedLocaleDirectories: () => supportedLocaleDirectories,
|
|
supportedTSExtensions: () => supportedTSExtensions,
|
|
supportedTSExtensionsFlat: () => supportedTSExtensionsFlat,
|
|
supportedTSImplementationExtensions: () => supportedTSImplementationExtensions,
|
|
suppressLeadingAndTrailingTrivia: () => suppressLeadingAndTrailingTrivia,
|
|
suppressLeadingTrivia: () => suppressLeadingTrivia,
|
|
suppressTrailingTrivia: () => suppressTrailingTrivia,
|
|
symbolEscapedNameNoDefault: () => symbolEscapedNameNoDefault,
|
|
symbolName: () => symbolName,
|
|
symbolNameNoDefault: () => symbolNameNoDefault,
|
|
symbolPart: () => symbolPart,
|
|
symbolToDisplayParts: () => symbolToDisplayParts,
|
|
syntaxMayBeASICandidate: () => syntaxMayBeASICandidate,
|
|
syntaxRequiresTrailingSemicolonOrASI: () => syntaxRequiresTrailingSemicolonOrASI,
|
|
sys: () => sys,
|
|
sysLog: () => sysLog,
|
|
tagNamesAreEquivalent: () => tagNamesAreEquivalent,
|
|
takeWhile: () => takeWhile,
|
|
targetOptionDeclaration: () => targetOptionDeclaration,
|
|
templateObjectHelper: () => templateObjectHelper,
|
|
testFormatSettings: () => testFormatSettings,
|
|
textChangeRangeIsUnchanged: () => textChangeRangeIsUnchanged,
|
|
textChangeRangeNewSpan: () => textChangeRangeNewSpan,
|
|
textChanges: () => ts_textChanges_exports,
|
|
textOrKeywordPart: () => textOrKeywordPart,
|
|
textPart: () => textPart,
|
|
textRangeContainsPositionInclusive: () => textRangeContainsPositionInclusive,
|
|
textSpanContainsPosition: () => textSpanContainsPosition,
|
|
textSpanContainsTextSpan: () => textSpanContainsTextSpan,
|
|
textSpanEnd: () => textSpanEnd,
|
|
textSpanIntersection: () => textSpanIntersection,
|
|
textSpanIntersectsWith: () => textSpanIntersectsWith,
|
|
textSpanIntersectsWithPosition: () => textSpanIntersectsWithPosition,
|
|
textSpanIntersectsWithTextSpan: () => textSpanIntersectsWithTextSpan,
|
|
textSpanIsEmpty: () => textSpanIsEmpty,
|
|
textSpanOverlap: () => textSpanOverlap,
|
|
textSpanOverlapsWith: () => textSpanOverlapsWith,
|
|
textSpansEqual: () => textSpansEqual,
|
|
textToKeywordObj: () => textToKeywordObj,
|
|
timestamp: () => timestamp,
|
|
toArray: () => toArray,
|
|
toBuilderFileEmit: () => toBuilderFileEmit,
|
|
toBuilderStateFileInfoForMultiEmit: () => toBuilderStateFileInfoForMultiEmit,
|
|
toEditorSettings: () => toEditorSettings,
|
|
toFileNameLowerCase: () => toFileNameLowerCase,
|
|
toLowerCase: () => toLowerCase,
|
|
toPath: () => toPath,
|
|
toProgramEmitPending: () => toProgramEmitPending,
|
|
tokenIsIdentifierOrKeyword: () => tokenIsIdentifierOrKeyword,
|
|
tokenIsIdentifierOrKeywordOrGreaterThan: () => tokenIsIdentifierOrKeywordOrGreaterThan,
|
|
tokenToString: () => tokenToString,
|
|
trace: () => trace,
|
|
tracing: () => tracing,
|
|
tracingEnabled: () => tracingEnabled,
|
|
transform: () => transform,
|
|
transformClassFields: () => transformClassFields,
|
|
transformDeclarations: () => transformDeclarations,
|
|
transformECMAScriptModule: () => transformECMAScriptModule,
|
|
transformES2015: () => transformES2015,
|
|
transformES2016: () => transformES2016,
|
|
transformES2017: () => transformES2017,
|
|
transformES2018: () => transformES2018,
|
|
transformES2019: () => transformES2019,
|
|
transformES2020: () => transformES2020,
|
|
transformES2021: () => transformES2021,
|
|
transformES5: () => transformES5,
|
|
transformESNext: () => transformESNext,
|
|
transformGenerators: () => transformGenerators,
|
|
transformJsx: () => transformJsx,
|
|
transformLegacyDecorators: () => transformLegacyDecorators,
|
|
transformModule: () => transformModule,
|
|
transformNodeModule: () => transformNodeModule,
|
|
transformNodes: () => transformNodes,
|
|
transformSystemModule: () => transformSystemModule,
|
|
transformTypeScript: () => transformTypeScript,
|
|
transpile: () => transpile,
|
|
transpileModule: () => transpileModule,
|
|
transpileOptionValueCompilerOptions: () => transpileOptionValueCompilerOptions,
|
|
trimString: () => trimString,
|
|
trimStringEnd: () => trimStringEnd,
|
|
trimStringStart: () => trimStringStart,
|
|
tryAddToSet: () => tryAddToSet,
|
|
tryAndIgnoreErrors: () => tryAndIgnoreErrors,
|
|
tryCast: () => tryCast,
|
|
tryDirectoryExists: () => tryDirectoryExists,
|
|
tryExtractTSExtension: () => tryExtractTSExtension,
|
|
tryFileExists: () => tryFileExists,
|
|
tryGetClassExtendingExpressionWithTypeArguments: () => tryGetClassExtendingExpressionWithTypeArguments,
|
|
tryGetClassImplementingOrExtendingExpressionWithTypeArguments: () => tryGetClassImplementingOrExtendingExpressionWithTypeArguments,
|
|
tryGetDirectories: () => tryGetDirectories,
|
|
tryGetExtensionFromPath: () => tryGetExtensionFromPath2,
|
|
tryGetImportFromModuleSpecifier: () => tryGetImportFromModuleSpecifier,
|
|
tryGetModuleNameFromFile: () => tryGetModuleNameFromFile,
|
|
tryGetModuleSpecifierFromDeclaration: () => tryGetModuleSpecifierFromDeclaration,
|
|
tryGetNativePerformanceHooks: () => tryGetNativePerformanceHooks,
|
|
tryGetPropertyAccessOrIdentifierToString: () => tryGetPropertyAccessOrIdentifierToString,
|
|
tryGetPropertyNameOfBindingOrAssignmentElement: () => tryGetPropertyNameOfBindingOrAssignmentElement,
|
|
tryGetSourceMappingURL: () => tryGetSourceMappingURL,
|
|
tryGetTextOfPropertyName: () => tryGetTextOfPropertyName,
|
|
tryIOAndConsumeErrors: () => tryIOAndConsumeErrors,
|
|
tryParsePattern: () => tryParsePattern,
|
|
tryParsePatterns: () => tryParsePatterns,
|
|
tryParseRawSourceMap: () => tryParseRawSourceMap,
|
|
tryReadDirectory: () => tryReadDirectory,
|
|
tryReadFile: () => tryReadFile,
|
|
tryRemoveDirectoryPrefix: () => tryRemoveDirectoryPrefix,
|
|
tryRemoveExtension: () => tryRemoveExtension,
|
|
tryRemovePrefix: () => tryRemovePrefix,
|
|
tryRemoveSuffix: () => tryRemoveSuffix,
|
|
typeAcquisitionDeclarations: () => typeAcquisitionDeclarations,
|
|
typeAliasNamePart: () => typeAliasNamePart,
|
|
typeDirectiveIsEqualTo: () => typeDirectiveIsEqualTo,
|
|
typeHasCallOrConstructSignatures: () => typeHasCallOrConstructSignatures,
|
|
typeKeywords: () => typeKeywords,
|
|
typeParameterNamePart: () => typeParameterNamePart,
|
|
typeToDisplayParts: () => typeToDisplayParts,
|
|
unchangedPollThresholds: () => unchangedPollThresholds,
|
|
unchangedTextChangeRange: () => unchangedTextChangeRange,
|
|
unescapeLeadingUnderscores: () => unescapeLeadingUnderscores,
|
|
unmangleScopedPackageName: () => unmangleScopedPackageName,
|
|
unorderedRemoveItem: () => unorderedRemoveItem,
|
|
unorderedRemoveItemAt: () => unorderedRemoveItemAt,
|
|
unreachableCodeIsError: () => unreachableCodeIsError,
|
|
unusedLabelIsError: () => unusedLabelIsError,
|
|
unwrapInnermostStatementOfLabel: () => unwrapInnermostStatementOfLabel,
|
|
updateArrayBindingPattern: () => updateArrayBindingPattern,
|
|
updateArrayLiteral: () => updateArrayLiteral,
|
|
updateArrayTypeNode: () => updateArrayTypeNode,
|
|
updateArrowFunction: () => updateArrowFunction,
|
|
updateAsExpression: () => updateAsExpression,
|
|
updateAwait: () => updateAwait,
|
|
updateBinary: () => updateBinary,
|
|
updateBindingElement: () => updateBindingElement,
|
|
updateBlock: () => updateBlock,
|
|
updateBreak: () => updateBreak,
|
|
updateBundle: () => updateBundle,
|
|
updateCall: () => updateCall,
|
|
updateCallChain: () => updateCallChain,
|
|
updateCallSignature: () => updateCallSignature,
|
|
updateCaseBlock: () => updateCaseBlock,
|
|
updateCaseClause: () => updateCaseClause,
|
|
updateCatchClause: () => updateCatchClause,
|
|
updateClassDeclaration: () => updateClassDeclaration,
|
|
updateClassExpression: () => updateClassExpression,
|
|
updateCommaList: () => updateCommaList,
|
|
updateComputedPropertyName: () => updateComputedPropertyName,
|
|
updateConditional: () => updateConditional,
|
|
updateConditionalTypeNode: () => updateConditionalTypeNode,
|
|
updateConstructSignature: () => updateConstructSignature,
|
|
updateConstructor: () => updateConstructor,
|
|
updateConstructorTypeNode: () => updateConstructorTypeNode,
|
|
updateContinue: () => updateContinue,
|
|
updateDecorator: () => updateDecorator,
|
|
updateDefaultClause: () => updateDefaultClause,
|
|
updateDelete: () => updateDelete,
|
|
updateDo: () => updateDo,
|
|
updateElementAccess: () => updateElementAccess,
|
|
updateElementAccessChain: () => updateElementAccessChain,
|
|
updateEnumDeclaration: () => updateEnumDeclaration,
|
|
updateEnumMember: () => updateEnumMember,
|
|
updateErrorForNoInputFiles: () => updateErrorForNoInputFiles,
|
|
updateExportAssignment: () => updateExportAssignment,
|
|
updateExportDeclaration: () => updateExportDeclaration,
|
|
updateExportSpecifier: () => updateExportSpecifier,
|
|
updateExpressionStatement: () => updateExpressionStatement,
|
|
updateExpressionWithTypeArguments: () => updateExpressionWithTypeArguments,
|
|
updateExternalModuleReference: () => updateExternalModuleReference,
|
|
updateFor: () => updateFor,
|
|
updateForIn: () => updateForIn,
|
|
updateForOf: () => updateForOf,
|
|
updateFunctionDeclaration: () => updateFunctionDeclaration,
|
|
updateFunctionExpression: () => updateFunctionExpression,
|
|
updateFunctionTypeNode: () => updateFunctionTypeNode,
|
|
updateGetAccessor: () => updateGetAccessor,
|
|
updateHeritageClause: () => updateHeritageClause,
|
|
updateIf: () => updateIf,
|
|
updateImportClause: () => updateImportClause,
|
|
updateImportDeclaration: () => updateImportDeclaration,
|
|
updateImportEqualsDeclaration: () => updateImportEqualsDeclaration,
|
|
updateImportSpecifier: () => updateImportSpecifier,
|
|
updateImportTypeNode: () => updateImportTypeNode,
|
|
updateIndexSignature: () => updateIndexSignature,
|
|
updateIndexedAccessTypeNode: () => updateIndexedAccessTypeNode,
|
|
updateInferTypeNode: () => updateInferTypeNode,
|
|
updateInterfaceDeclaration: () => updateInterfaceDeclaration,
|
|
updateIntersectionTypeNode: () => updateIntersectionTypeNode,
|
|
updateJsxAttribute: () => updateJsxAttribute,
|
|
updateJsxAttributes: () => updateJsxAttributes,
|
|
updateJsxClosingElement: () => updateJsxClosingElement,
|
|
updateJsxElement: () => updateJsxElement,
|
|
updateJsxExpression: () => updateJsxExpression,
|
|
updateJsxFragment: () => updateJsxFragment,
|
|
updateJsxOpeningElement: () => updateJsxOpeningElement,
|
|
updateJsxSelfClosingElement: () => updateJsxSelfClosingElement,
|
|
updateJsxSpreadAttribute: () => updateJsxSpreadAttribute,
|
|
updateJsxText: () => updateJsxText,
|
|
updateLabel: () => updateLabel,
|
|
updateLanguageServiceSourceFile: () => updateLanguageServiceSourceFile,
|
|
updateLiteralTypeNode: () => updateLiteralTypeNode,
|
|
updateMappedTypeNode: () => updateMappedTypeNode,
|
|
updateMetaProperty: () => updateMetaProperty,
|
|
updateMethod: () => updateMethod,
|
|
updateMethodSignature: () => updateMethodSignature,
|
|
updateMissingFilePathsWatch: () => updateMissingFilePathsWatch,
|
|
updateModuleBlock: () => updateModuleBlock,
|
|
updateModuleDeclaration: () => updateModuleDeclaration,
|
|
updateNamedExports: () => updateNamedExports,
|
|
updateNamedImports: () => updateNamedImports,
|
|
updateNamespaceExport: () => updateNamespaceExport,
|
|
updateNamespaceExportDeclaration: () => updateNamespaceExportDeclaration,
|
|
updateNamespaceImport: () => updateNamespaceImport,
|
|
updateNew: () => updateNew,
|
|
updateNonNullChain: () => updateNonNullChain,
|
|
updateNonNullExpression: () => updateNonNullExpression,
|
|
updateObjectBindingPattern: () => updateObjectBindingPattern,
|
|
updateObjectLiteral: () => updateObjectLiteral,
|
|
updateOptionalTypeNode: () => updateOptionalTypeNode,
|
|
updatePackageJsonWatch: () => updatePackageJsonWatch,
|
|
updateParameter: () => updateParameter,
|
|
updateParen: () => updateParen,
|
|
updateParenthesizedType: () => updateParenthesizedType,
|
|
updatePartiallyEmittedExpression: () => updatePartiallyEmittedExpression,
|
|
updatePostfix: () => updatePostfix,
|
|
updatePrefix: () => updatePrefix,
|
|
updateProperty: () => updateProperty,
|
|
updatePropertyAccess: () => updatePropertyAccess,
|
|
updatePropertyAccessChain: () => updatePropertyAccessChain,
|
|
updatePropertyAssignment: () => updatePropertyAssignment,
|
|
updatePropertySignature: () => updatePropertySignature,
|
|
updateQualifiedName: () => updateQualifiedName,
|
|
updateRestTypeNode: () => updateRestTypeNode,
|
|
updateReturn: () => updateReturn,
|
|
updateSetAccessor: () => updateSetAccessor,
|
|
updateSharedExtendedConfigFileWatcher: () => updateSharedExtendedConfigFileWatcher,
|
|
updateShorthandPropertyAssignment: () => updateShorthandPropertyAssignment,
|
|
updateSourceFile: () => updateSourceFile,
|
|
updateSourceFileNode: () => updateSourceFileNode,
|
|
updateSpread: () => updateSpread,
|
|
updateSpreadAssignment: () => updateSpreadAssignment,
|
|
updateStatement: () => updateStatement,
|
|
updateSwitch: () => updateSwitch,
|
|
updateTaggedTemplate: () => updateTaggedTemplate,
|
|
updateTemplateExpression: () => updateTemplateExpression,
|
|
updateTemplateSpan: () => updateTemplateSpan,
|
|
updateThrow: () => updateThrow,
|
|
updateTry: () => updateTry,
|
|
updateTupleTypeNode: () => updateTupleTypeNode,
|
|
updateTypeAliasDeclaration: () => updateTypeAliasDeclaration,
|
|
updateTypeAssertion: () => updateTypeAssertion,
|
|
updateTypeLiteralNode: () => updateTypeLiteralNode,
|
|
updateTypeOf: () => updateTypeOf,
|
|
updateTypeOperatorNode: () => updateTypeOperatorNode,
|
|
updateTypeParameterDeclaration: () => updateTypeParameterDeclaration,
|
|
updateTypePredicateNode: () => updateTypePredicateNode,
|
|
updateTypePredicateNodeWithModifier: () => updateTypePredicateNodeWithModifier,
|
|
updateTypeQueryNode: () => updateTypeQueryNode,
|
|
updateTypeReferenceNode: () => updateTypeReferenceNode,
|
|
updateUnionTypeNode: () => updateUnionTypeNode,
|
|
updateVariableDeclaration: () => updateVariableDeclaration,
|
|
updateVariableDeclarationList: () => updateVariableDeclarationList,
|
|
updateVariableStatement: () => updateVariableStatement,
|
|
updateVoid: () => updateVoid,
|
|
updateWatchingWildcardDirectories: () => updateWatchingWildcardDirectories,
|
|
updateWhile: () => updateWhile,
|
|
updateWith: () => updateWith,
|
|
updateYield: () => updateYield,
|
|
usingSingleLineStringWriter: () => usingSingleLineStringWriter,
|
|
utf16EncodeAsString: () => utf16EncodeAsString,
|
|
validateLocaleAndSetLanguage: () => validateLocaleAndSetLanguage,
|
|
valuesHelper: () => valuesHelper,
|
|
version: () => version,
|
|
versionMajorMinor: () => versionMajorMinor,
|
|
visitArray: () => visitArray,
|
|
visitEachChild: () => visitEachChild,
|
|
visitFunctionBody: () => visitFunctionBody,
|
|
visitIterationBody: () => visitIterationBody,
|
|
visitLexicalEnvironment: () => visitLexicalEnvironment,
|
|
visitNode: () => visitNode,
|
|
visitNodes: () => visitNodes2,
|
|
visitParameterList: () => visitParameterList,
|
|
walkUpBindingElementsAndPatterns: () => walkUpBindingElementsAndPatterns,
|
|
walkUpParenthesizedExpressions: () => walkUpParenthesizedExpressions,
|
|
walkUpParenthesizedTypes: () => walkUpParenthesizedTypes,
|
|
walkUpParenthesizedTypesAndGetParentAndChild: () => walkUpParenthesizedTypesAndGetParentAndChild,
|
|
whitespaceOrMapCommentRegExp: () => whitespaceOrMapCommentRegExp,
|
|
writeCommentRange: () => writeCommentRange,
|
|
writeFile: () => writeFile,
|
|
writeFileEnsuringDirectories: () => writeFileEnsuringDirectories,
|
|
zipToIterator: () => zipToIterator,
|
|
zipToMap: () => zipToMap,
|
|
zipToModeAwareCache: () => zipToModeAwareCache,
|
|
zipWith: () => zipWith
|
|
});
|
|
|
|
// src/services/types.ts
|
|
var ScriptSnapshot;
|
|
((ScriptSnapshot2) => {
|
|
class StringScriptSnapshot {
|
|
constructor(text) {
|
|
this.text = text;
|
|
}
|
|
getText(start2, end) {
|
|
return start2 === 0 && end === this.text.length ? this.text : this.text.substring(start2, end);
|
|
}
|
|
getLength() {
|
|
return this.text.length;
|
|
}
|
|
getChangeRange() {
|
|
return void 0;
|
|
}
|
|
}
|
|
function fromString(text) {
|
|
return new StringScriptSnapshot(text);
|
|
}
|
|
ScriptSnapshot2.fromString = fromString;
|
|
})(ScriptSnapshot || (ScriptSnapshot = {}));
|
|
var PackageJsonDependencyGroup = /* @__PURE__ */ ((PackageJsonDependencyGroup2) => {
|
|
PackageJsonDependencyGroup2[PackageJsonDependencyGroup2["Dependencies"] = 1] = "Dependencies";
|
|
PackageJsonDependencyGroup2[PackageJsonDependencyGroup2["DevDependencies"] = 2] = "DevDependencies";
|
|
PackageJsonDependencyGroup2[PackageJsonDependencyGroup2["PeerDependencies"] = 4] = "PeerDependencies";
|
|
PackageJsonDependencyGroup2[PackageJsonDependencyGroup2["OptionalDependencies"] = 8] = "OptionalDependencies";
|
|
PackageJsonDependencyGroup2[PackageJsonDependencyGroup2["All"] = 15] = "All";
|
|
return PackageJsonDependencyGroup2;
|
|
})(PackageJsonDependencyGroup || {});
|
|
var PackageJsonAutoImportPreference = /* @__PURE__ */ ((PackageJsonAutoImportPreference2) => {
|
|
PackageJsonAutoImportPreference2[PackageJsonAutoImportPreference2["Off"] = 0] = "Off";
|
|
PackageJsonAutoImportPreference2[PackageJsonAutoImportPreference2["On"] = 1] = "On";
|
|
PackageJsonAutoImportPreference2[PackageJsonAutoImportPreference2["Auto"] = 2] = "Auto";
|
|
return PackageJsonAutoImportPreference2;
|
|
})(PackageJsonAutoImportPreference || {});
|
|
var LanguageServiceMode = /* @__PURE__ */ ((LanguageServiceMode2) => {
|
|
LanguageServiceMode2[LanguageServiceMode2["Semantic"] = 0] = "Semantic";
|
|
LanguageServiceMode2[LanguageServiceMode2["PartialSemantic"] = 1] = "PartialSemantic";
|
|
LanguageServiceMode2[LanguageServiceMode2["Syntactic"] = 2] = "Syntactic";
|
|
return LanguageServiceMode2;
|
|
})(LanguageServiceMode || {});
|
|
var emptyOptions = {};
|
|
var SemanticClassificationFormat = /* @__PURE__ */ ((SemanticClassificationFormat3) => {
|
|
SemanticClassificationFormat3["Original"] = "original";
|
|
SemanticClassificationFormat3["TwentyTwenty"] = "2020";
|
|
return SemanticClassificationFormat3;
|
|
})(SemanticClassificationFormat || {});
|
|
var OrganizeImportsMode = /* @__PURE__ */ ((OrganizeImportsMode3) => {
|
|
OrganizeImportsMode3["All"] = "All";
|
|
OrganizeImportsMode3["SortAndCombine"] = "SortAndCombine";
|
|
OrganizeImportsMode3["RemoveUnused"] = "RemoveUnused";
|
|
return OrganizeImportsMode3;
|
|
})(OrganizeImportsMode || {});
|
|
var CompletionTriggerKind = /* @__PURE__ */ ((CompletionTriggerKind4) => {
|
|
CompletionTriggerKind4[CompletionTriggerKind4["Invoked"] = 1] = "Invoked";
|
|
CompletionTriggerKind4[CompletionTriggerKind4["TriggerCharacter"] = 2] = "TriggerCharacter";
|
|
CompletionTriggerKind4[CompletionTriggerKind4["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
|
|
return CompletionTriggerKind4;
|
|
})(CompletionTriggerKind || {});
|
|
var InlayHintKind = /* @__PURE__ */ ((InlayHintKind2) => {
|
|
InlayHintKind2["Type"] = "Type";
|
|
InlayHintKind2["Parameter"] = "Parameter";
|
|
InlayHintKind2["Enum"] = "Enum";
|
|
return InlayHintKind2;
|
|
})(InlayHintKind || {});
|
|
var HighlightSpanKind = /* @__PURE__ */ ((HighlightSpanKind2) => {
|
|
HighlightSpanKind2["none"] = "none";
|
|
HighlightSpanKind2["definition"] = "definition";
|
|
HighlightSpanKind2["reference"] = "reference";
|
|
HighlightSpanKind2["writtenReference"] = "writtenReference";
|
|
return HighlightSpanKind2;
|
|
})(HighlightSpanKind || {});
|
|
var IndentStyle = /* @__PURE__ */ ((IndentStyle3) => {
|
|
IndentStyle3[IndentStyle3["None"] = 0] = "None";
|
|
IndentStyle3[IndentStyle3["Block"] = 1] = "Block";
|
|
IndentStyle3[IndentStyle3["Smart"] = 2] = "Smart";
|
|
return IndentStyle3;
|
|
})(IndentStyle || {});
|
|
var SemicolonPreference = /* @__PURE__ */ ((SemicolonPreference3) => {
|
|
SemicolonPreference3["Ignore"] = "ignore";
|
|
SemicolonPreference3["Insert"] = "insert";
|
|
SemicolonPreference3["Remove"] = "remove";
|
|
return SemicolonPreference3;
|
|
})(SemicolonPreference || {});
|
|
function getDefaultFormatCodeSettings(newLineCharacter) {
|
|
return {
|
|
indentSize: 4,
|
|
tabSize: 4,
|
|
newLineCharacter: newLineCharacter || "\n",
|
|
convertTabsToSpaces: true,
|
|
indentStyle: 2 /* Smart */,
|
|
insertSpaceAfterConstructor: false,
|
|
insertSpaceAfterCommaDelimiter: true,
|
|
insertSpaceAfterSemicolonInForStatements: true,
|
|
insertSpaceBeforeAndAfterBinaryOperators: true,
|
|
insertSpaceAfterKeywordsInControlFlowStatements: true,
|
|
insertSpaceAfterFunctionKeywordForAnonymousFunctions: false,
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
|
|
insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true,
|
|
insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
|
|
insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
|
|
insertSpaceBeforeFunctionParenthesis: false,
|
|
placeOpenBraceOnNewLineForFunctions: false,
|
|
placeOpenBraceOnNewLineForControlBlocks: false,
|
|
semicolons: "ignore" /* Ignore */,
|
|
trimTrailingWhitespace: true
|
|
};
|
|
}
|
|
var testFormatSettings = getDefaultFormatCodeSettings("\n");
|
|
var SymbolDisplayPartKind = /* @__PURE__ */ ((SymbolDisplayPartKind2) => {
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["aliasName"] = 0] = "aliasName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["className"] = 1] = "className";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["enumName"] = 2] = "enumName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["fieldName"] = 3] = "fieldName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["interfaceName"] = 4] = "interfaceName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["keyword"] = 5] = "keyword";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["lineBreak"] = 6] = "lineBreak";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["numericLiteral"] = 7] = "numericLiteral";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["stringLiteral"] = 8] = "stringLiteral";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["localName"] = 9] = "localName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["methodName"] = 10] = "methodName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["moduleName"] = 11] = "moduleName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["operator"] = 12] = "operator";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["parameterName"] = 13] = "parameterName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["propertyName"] = 14] = "propertyName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["punctuation"] = 15] = "punctuation";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["space"] = 16] = "space";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["text"] = 17] = "text";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["typeParameterName"] = 18] = "typeParameterName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["enumMemberName"] = 19] = "enumMemberName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["functionName"] = 20] = "functionName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["regularExpressionLiteral"] = 21] = "regularExpressionLiteral";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["link"] = 22] = "link";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["linkName"] = 23] = "linkName";
|
|
SymbolDisplayPartKind2[SymbolDisplayPartKind2["linkText"] = 24] = "linkText";
|
|
return SymbolDisplayPartKind2;
|
|
})(SymbolDisplayPartKind || {});
|
|
var CompletionInfoFlags = /* @__PURE__ */ ((CompletionInfoFlags2) => {
|
|
CompletionInfoFlags2[CompletionInfoFlags2["None"] = 0] = "None";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["MayIncludeAutoImports"] = 1] = "MayIncludeAutoImports";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["IsImportStatementCompletion"] = 2] = "IsImportStatementCompletion";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["IsContinuation"] = 4] = "IsContinuation";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["ResolvedModuleSpecifiers"] = 8] = "ResolvedModuleSpecifiers";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["ResolvedModuleSpecifiersBeyondLimit"] = 16] = "ResolvedModuleSpecifiersBeyondLimit";
|
|
CompletionInfoFlags2[CompletionInfoFlags2["MayIncludeMethodSnippets"] = 32] = "MayIncludeMethodSnippets";
|
|
return CompletionInfoFlags2;
|
|
})(CompletionInfoFlags || {});
|
|
var OutliningSpanKind = /* @__PURE__ */ ((OutliningSpanKind2) => {
|
|
OutliningSpanKind2["Comment"] = "comment";
|
|
OutliningSpanKind2["Region"] = "region";
|
|
OutliningSpanKind2["Code"] = "code";
|
|
OutliningSpanKind2["Imports"] = "imports";
|
|
return OutliningSpanKind2;
|
|
})(OutliningSpanKind || {});
|
|
var OutputFileType = /* @__PURE__ */ ((OutputFileType2) => {
|
|
OutputFileType2[OutputFileType2["JavaScript"] = 0] = "JavaScript";
|
|
OutputFileType2[OutputFileType2["SourceMap"] = 1] = "SourceMap";
|
|
OutputFileType2[OutputFileType2["Declaration"] = 2] = "Declaration";
|
|
return OutputFileType2;
|
|
})(OutputFileType || {});
|
|
var EndOfLineState = /* @__PURE__ */ ((EndOfLineState3) => {
|
|
EndOfLineState3[EndOfLineState3["None"] = 0] = "None";
|
|
EndOfLineState3[EndOfLineState3["InMultiLineCommentTrivia"] = 1] = "InMultiLineCommentTrivia";
|
|
EndOfLineState3[EndOfLineState3["InSingleQuoteStringLiteral"] = 2] = "InSingleQuoteStringLiteral";
|
|
EndOfLineState3[EndOfLineState3["InDoubleQuoteStringLiteral"] = 3] = "InDoubleQuoteStringLiteral";
|
|
EndOfLineState3[EndOfLineState3["InTemplateHeadOrNoSubstitutionTemplate"] = 4] = "InTemplateHeadOrNoSubstitutionTemplate";
|
|
EndOfLineState3[EndOfLineState3["InTemplateMiddleOrTail"] = 5] = "InTemplateMiddleOrTail";
|
|
EndOfLineState3[EndOfLineState3["InTemplateSubstitutionPosition"] = 6] = "InTemplateSubstitutionPosition";
|
|
return EndOfLineState3;
|
|
})(EndOfLineState || {});
|
|
var TokenClass = /* @__PURE__ */ ((TokenClass2) => {
|
|
TokenClass2[TokenClass2["Punctuation"] = 0] = "Punctuation";
|
|
TokenClass2[TokenClass2["Keyword"] = 1] = "Keyword";
|
|
TokenClass2[TokenClass2["Operator"] = 2] = "Operator";
|
|
TokenClass2[TokenClass2["Comment"] = 3] = "Comment";
|
|
TokenClass2[TokenClass2["Whitespace"] = 4] = "Whitespace";
|
|
TokenClass2[TokenClass2["Identifier"] = 5] = "Identifier";
|
|
TokenClass2[TokenClass2["NumberLiteral"] = 6] = "NumberLiteral";
|
|
TokenClass2[TokenClass2["BigIntLiteral"] = 7] = "BigIntLiteral";
|
|
TokenClass2[TokenClass2["StringLiteral"] = 8] = "StringLiteral";
|
|
TokenClass2[TokenClass2["RegExpLiteral"] = 9] = "RegExpLiteral";
|
|
return TokenClass2;
|
|
})(TokenClass || {});
|
|
var ScriptElementKind = /* @__PURE__ */ ((ScriptElementKind2) => {
|
|
ScriptElementKind2["unknown"] = "";
|
|
ScriptElementKind2["warning"] = "warning";
|
|
ScriptElementKind2["keyword"] = "keyword";
|
|
ScriptElementKind2["scriptElement"] = "script";
|
|
ScriptElementKind2["moduleElement"] = "module";
|
|
ScriptElementKind2["classElement"] = "class";
|
|
ScriptElementKind2["localClassElement"] = "local class";
|
|
ScriptElementKind2["interfaceElement"] = "interface";
|
|
ScriptElementKind2["typeElement"] = "type";
|
|
ScriptElementKind2["enumElement"] = "enum";
|
|
ScriptElementKind2["enumMemberElement"] = "enum member";
|
|
ScriptElementKind2["variableElement"] = "var";
|
|
ScriptElementKind2["localVariableElement"] = "local var";
|
|
ScriptElementKind2["functionElement"] = "function";
|
|
ScriptElementKind2["localFunctionElement"] = "local function";
|
|
ScriptElementKind2["memberFunctionElement"] = "method";
|
|
ScriptElementKind2["memberGetAccessorElement"] = "getter";
|
|
ScriptElementKind2["memberSetAccessorElement"] = "setter";
|
|
ScriptElementKind2["memberVariableElement"] = "property";
|
|
ScriptElementKind2["memberAccessorVariableElement"] = "accessor";
|
|
ScriptElementKind2["constructorImplementationElement"] = "constructor";
|
|
ScriptElementKind2["callSignatureElement"] = "call";
|
|
ScriptElementKind2["indexSignatureElement"] = "index";
|
|
ScriptElementKind2["constructSignatureElement"] = "construct";
|
|
ScriptElementKind2["parameterElement"] = "parameter";
|
|
ScriptElementKind2["typeParameterElement"] = "type parameter";
|
|
ScriptElementKind2["primitiveType"] = "primitive type";
|
|
ScriptElementKind2["label"] = "label";
|
|
ScriptElementKind2["alias"] = "alias";
|
|
ScriptElementKind2["constElement"] = "const";
|
|
ScriptElementKind2["letElement"] = "let";
|
|
ScriptElementKind2["directory"] = "directory";
|
|
ScriptElementKind2["externalModuleName"] = "external module name";
|
|
ScriptElementKind2["jsxAttribute"] = "JSX attribute";
|
|
ScriptElementKind2["string"] = "string";
|
|
ScriptElementKind2["link"] = "link";
|
|
ScriptElementKind2["linkName"] = "link name";
|
|
ScriptElementKind2["linkText"] = "link text";
|
|
return ScriptElementKind2;
|
|
})(ScriptElementKind || {});
|
|
var ScriptElementKindModifier = /* @__PURE__ */ ((ScriptElementKindModifier2) => {
|
|
ScriptElementKindModifier2["none"] = "";
|
|
ScriptElementKindModifier2["publicMemberModifier"] = "public";
|
|
ScriptElementKindModifier2["privateMemberModifier"] = "private";
|
|
ScriptElementKindModifier2["protectedMemberModifier"] = "protected";
|
|
ScriptElementKindModifier2["exportedModifier"] = "export";
|
|
ScriptElementKindModifier2["ambientModifier"] = "declare";
|
|
ScriptElementKindModifier2["staticModifier"] = "static";
|
|
ScriptElementKindModifier2["abstractModifier"] = "abstract";
|
|
ScriptElementKindModifier2["optionalModifier"] = "optional";
|
|
ScriptElementKindModifier2["deprecatedModifier"] = "deprecated";
|
|
ScriptElementKindModifier2["dtsModifier"] = ".d.ts";
|
|
ScriptElementKindModifier2["tsModifier"] = ".ts";
|
|
ScriptElementKindModifier2["tsxModifier"] = ".tsx";
|
|
ScriptElementKindModifier2["jsModifier"] = ".js";
|
|
ScriptElementKindModifier2["jsxModifier"] = ".jsx";
|
|
ScriptElementKindModifier2["jsonModifier"] = ".json";
|
|
ScriptElementKindModifier2["dmtsModifier"] = ".d.mts";
|
|
ScriptElementKindModifier2["mtsModifier"] = ".mts";
|
|
ScriptElementKindModifier2["mjsModifier"] = ".mjs";
|
|
ScriptElementKindModifier2["dctsModifier"] = ".d.cts";
|
|
ScriptElementKindModifier2["ctsModifier"] = ".cts";
|
|
ScriptElementKindModifier2["cjsModifier"] = ".cjs";
|
|
return ScriptElementKindModifier2;
|
|
})(ScriptElementKindModifier || {});
|
|
var ClassificationTypeNames = /* @__PURE__ */ ((ClassificationTypeNames2) => {
|
|
ClassificationTypeNames2["comment"] = "comment";
|
|
ClassificationTypeNames2["identifier"] = "identifier";
|
|
ClassificationTypeNames2["keyword"] = "keyword";
|
|
ClassificationTypeNames2["numericLiteral"] = "number";
|
|
ClassificationTypeNames2["bigintLiteral"] = "bigint";
|
|
ClassificationTypeNames2["operator"] = "operator";
|
|
ClassificationTypeNames2["stringLiteral"] = "string";
|
|
ClassificationTypeNames2["whiteSpace"] = "whitespace";
|
|
ClassificationTypeNames2["text"] = "text";
|
|
ClassificationTypeNames2["punctuation"] = "punctuation";
|
|
ClassificationTypeNames2["className"] = "class name";
|
|
ClassificationTypeNames2["enumName"] = "enum name";
|
|
ClassificationTypeNames2["interfaceName"] = "interface name";
|
|
ClassificationTypeNames2["moduleName"] = "module name";
|
|
ClassificationTypeNames2["typeParameterName"] = "type parameter name";
|
|
ClassificationTypeNames2["typeAliasName"] = "type alias name";
|
|
ClassificationTypeNames2["parameterName"] = "parameter name";
|
|
ClassificationTypeNames2["docCommentTagName"] = "doc comment tag name";
|
|
ClassificationTypeNames2["jsxOpenTagName"] = "jsx open tag name";
|
|
ClassificationTypeNames2["jsxCloseTagName"] = "jsx close tag name";
|
|
ClassificationTypeNames2["jsxSelfClosingTagName"] = "jsx self closing tag name";
|
|
ClassificationTypeNames2["jsxAttribute"] = "jsx attribute";
|
|
ClassificationTypeNames2["jsxText"] = "jsx text";
|
|
ClassificationTypeNames2["jsxAttributeStringLiteralValue"] = "jsx attribute string literal value";
|
|
return ClassificationTypeNames2;
|
|
})(ClassificationTypeNames || {});
|
|
var ClassificationType = /* @__PURE__ */ ((ClassificationType3) => {
|
|
ClassificationType3[ClassificationType3["comment"] = 1] = "comment";
|
|
ClassificationType3[ClassificationType3["identifier"] = 2] = "identifier";
|
|
ClassificationType3[ClassificationType3["keyword"] = 3] = "keyword";
|
|
ClassificationType3[ClassificationType3["numericLiteral"] = 4] = "numericLiteral";
|
|
ClassificationType3[ClassificationType3["operator"] = 5] = "operator";
|
|
ClassificationType3[ClassificationType3["stringLiteral"] = 6] = "stringLiteral";
|
|
ClassificationType3[ClassificationType3["regularExpressionLiteral"] = 7] = "regularExpressionLiteral";
|
|
ClassificationType3[ClassificationType3["whiteSpace"] = 8] = "whiteSpace";
|
|
ClassificationType3[ClassificationType3["text"] = 9] = "text";
|
|
ClassificationType3[ClassificationType3["punctuation"] = 10] = "punctuation";
|
|
ClassificationType3[ClassificationType3["className"] = 11] = "className";
|
|
ClassificationType3[ClassificationType3["enumName"] = 12] = "enumName";
|
|
ClassificationType3[ClassificationType3["interfaceName"] = 13] = "interfaceName";
|
|
ClassificationType3[ClassificationType3["moduleName"] = 14] = "moduleName";
|
|
ClassificationType3[ClassificationType3["typeParameterName"] = 15] = "typeParameterName";
|
|
ClassificationType3[ClassificationType3["typeAliasName"] = 16] = "typeAliasName";
|
|
ClassificationType3[ClassificationType3["parameterName"] = 17] = "parameterName";
|
|
ClassificationType3[ClassificationType3["docCommentTagName"] = 18] = "docCommentTagName";
|
|
ClassificationType3[ClassificationType3["jsxOpenTagName"] = 19] = "jsxOpenTagName";
|
|
ClassificationType3[ClassificationType3["jsxCloseTagName"] = 20] = "jsxCloseTagName";
|
|
ClassificationType3[ClassificationType3["jsxSelfClosingTagName"] = 21] = "jsxSelfClosingTagName";
|
|
ClassificationType3[ClassificationType3["jsxAttribute"] = 22] = "jsxAttribute";
|
|
ClassificationType3[ClassificationType3["jsxText"] = 23] = "jsxText";
|
|
ClassificationType3[ClassificationType3["jsxAttributeStringLiteralValue"] = 24] = "jsxAttributeStringLiteralValue";
|
|
ClassificationType3[ClassificationType3["bigintLiteral"] = 25] = "bigintLiteral";
|
|
return ClassificationType3;
|
|
})(ClassificationType || {});
|
|
|
|
// src/services/utilities.ts
|
|
var scanner = createScanner(99 /* Latest */, true);
|
|
var SemanticMeaning = /* @__PURE__ */ ((SemanticMeaning3) => {
|
|
SemanticMeaning3[SemanticMeaning3["None"] = 0] = "None";
|
|
SemanticMeaning3[SemanticMeaning3["Value"] = 1] = "Value";
|
|
SemanticMeaning3[SemanticMeaning3["Type"] = 2] = "Type";
|
|
SemanticMeaning3[SemanticMeaning3["Namespace"] = 4] = "Namespace";
|
|
SemanticMeaning3[SemanticMeaning3["All"] = 7] = "All";
|
|
return SemanticMeaning3;
|
|
})(SemanticMeaning || {});
|
|
function getMeaningFromDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return isInJSFile(node) && getJSDocEnumTag(node) ? 7 /* All */ : 1 /* Value */;
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 295 /* CatchClause */:
|
|
case 288 /* JsxAttribute */:
|
|
return 1 /* Value */;
|
|
case 165 /* TypeParameter */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 184 /* TypeLiteral */:
|
|
return 2 /* Type */;
|
|
case 348 /* JSDocTypedefTag */:
|
|
return node.name === void 0 ? 1 /* Value */ | 2 /* Type */ : 2 /* Type */;
|
|
case 302 /* EnumMember */:
|
|
case 260 /* ClassDeclaration */:
|
|
return 1 /* Value */ | 2 /* Type */;
|
|
case 264 /* ModuleDeclaration */:
|
|
if (isAmbientModule(node)) {
|
|
return 4 /* Namespace */ | 1 /* Value */;
|
|
} else if (getModuleInstanceState(node) === 1 /* Instantiated */) {
|
|
return 4 /* Namespace */ | 1 /* Value */;
|
|
} else {
|
|
return 4 /* Namespace */;
|
|
}
|
|
case 263 /* EnumDeclaration */:
|
|
case 272 /* NamedImports */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 275 /* ExportDeclaration */:
|
|
return 7 /* All */;
|
|
case 308 /* SourceFile */:
|
|
return 4 /* Namespace */ | 1 /* Value */;
|
|
}
|
|
return 7 /* All */;
|
|
}
|
|
function getMeaningFromLocation(node) {
|
|
node = getAdjustedReferenceLocation(node);
|
|
const parent2 = node.parent;
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return 1 /* Value */;
|
|
} else if (isExportAssignment(parent2) || isExportSpecifier(parent2) || isExternalModuleReference(parent2) || isImportSpecifier(parent2) || isImportClause(parent2) || isImportEqualsDeclaration(parent2) && node === parent2.name) {
|
|
return 7 /* All */;
|
|
} else if (isInRightSideOfInternalImportEqualsDeclaration(node)) {
|
|
return getMeaningFromRightHandSideOfImportEquals(node);
|
|
} else if (isDeclarationName(node)) {
|
|
return getMeaningFromDeclaration(parent2);
|
|
} else if (isEntityName(node) && findAncestor(node, or(isJSDocNameReference, isJSDocLinkLike, isJSDocMemberName))) {
|
|
return 7 /* All */;
|
|
} else if (isTypeReference(node)) {
|
|
return 2 /* Type */;
|
|
} else if (isNamespaceReference(node)) {
|
|
return 4 /* Namespace */;
|
|
} else if (isTypeParameterDeclaration(parent2)) {
|
|
Debug.assert(isJSDocTemplateTag(parent2.parent));
|
|
return 2 /* Type */;
|
|
} else if (isLiteralTypeNode(parent2)) {
|
|
return 2 /* Type */ | 1 /* Value */;
|
|
} else {
|
|
return 1 /* Value */;
|
|
}
|
|
}
|
|
function getMeaningFromRightHandSideOfImportEquals(node) {
|
|
const name = node.kind === 163 /* QualifiedName */ ? node : isQualifiedName(node.parent) && node.parent.right === node ? node.parent : void 0;
|
|
return name && name.parent.kind === 268 /* ImportEqualsDeclaration */ ? 7 /* All */ : 4 /* Namespace */;
|
|
}
|
|
function isInRightSideOfInternalImportEqualsDeclaration(node) {
|
|
while (node.parent.kind === 163 /* QualifiedName */) {
|
|
node = node.parent;
|
|
}
|
|
return isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node;
|
|
}
|
|
function isNamespaceReference(node) {
|
|
return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
|
|
}
|
|
function isQualifiedNameNamespaceReference(node) {
|
|
let root = node;
|
|
let isLastClause = true;
|
|
if (root.parent.kind === 163 /* QualifiedName */) {
|
|
while (root.parent && root.parent.kind === 163 /* QualifiedName */) {
|
|
root = root.parent;
|
|
}
|
|
isLastClause = root.right === node;
|
|
}
|
|
return root.parent.kind === 180 /* TypeReference */ && !isLastClause;
|
|
}
|
|
function isPropertyAccessNamespaceReference(node) {
|
|
let root = node;
|
|
let isLastClause = true;
|
|
if (root.parent.kind === 208 /* PropertyAccessExpression */) {
|
|
while (root.parent && root.parent.kind === 208 /* PropertyAccessExpression */) {
|
|
root = root.parent;
|
|
}
|
|
isLastClause = root.name === node;
|
|
}
|
|
if (!isLastClause && root.parent.kind === 230 /* ExpressionWithTypeArguments */ && root.parent.parent.kind === 294 /* HeritageClause */) {
|
|
const decl = root.parent.parent.parent;
|
|
return decl.kind === 260 /* ClassDeclaration */ && root.parent.parent.token === 117 /* ImplementsKeyword */ || decl.kind === 261 /* InterfaceDeclaration */ && root.parent.parent.token === 94 /* ExtendsKeyword */;
|
|
}
|
|
return false;
|
|
}
|
|
function isTypeReference(node) {
|
|
if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
|
|
node = node.parent;
|
|
}
|
|
switch (node.kind) {
|
|
case 108 /* ThisKeyword */:
|
|
return !isExpressionNode(node);
|
|
case 194 /* ThisType */:
|
|
return true;
|
|
}
|
|
switch (node.parent.kind) {
|
|
case 180 /* TypeReference */:
|
|
return true;
|
|
case 202 /* ImportType */:
|
|
return !node.parent.isTypeOf;
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return isPartOfTypeNode(node.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function isCallExpressionTarget(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isCallExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function isNewExpressionTarget(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isNewExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function isCallOrNewExpressionTarget(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isCallOrNewExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function isTaggedTemplateTag(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isTaggedTemplateExpression, selectTagOfTaggedTemplateExpression, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function isDecoratorTarget(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isDecorator, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function isJsxOpeningLikeElementTagName(node, includeElementAccess = false, skipPastOuterExpressions = false) {
|
|
return isCalleeWorker(node, isJsxOpeningLikeElement, selectTagNameOfJsxOpeningLikeElement, includeElementAccess, skipPastOuterExpressions);
|
|
}
|
|
function selectExpressionOfCallOrNewExpressionOrDecorator(node) {
|
|
return node.expression;
|
|
}
|
|
function selectTagOfTaggedTemplateExpression(node) {
|
|
return node.tag;
|
|
}
|
|
function selectTagNameOfJsxOpeningLikeElement(node) {
|
|
return node.tagName;
|
|
}
|
|
function isCalleeWorker(node, pred, calleeSelector, includeElementAccess, skipPastOuterExpressions) {
|
|
let target = includeElementAccess ? climbPastPropertyOrElementAccess(node) : climbPastPropertyAccess(node);
|
|
if (skipPastOuterExpressions) {
|
|
target = skipOuterExpressions(target);
|
|
}
|
|
return !!target && !!target.parent && pred(target.parent) && calleeSelector(target.parent) === target;
|
|
}
|
|
function climbPastPropertyAccess(node) {
|
|
return isRightSideOfPropertyAccess(node) ? node.parent : node;
|
|
}
|
|
function climbPastPropertyOrElementAccess(node) {
|
|
return isRightSideOfPropertyAccess(node) || isArgumentExpressionOfElementAccess(node) ? node.parent : node;
|
|
}
|
|
function getTargetLabel(referenceNode, labelName) {
|
|
while (referenceNode) {
|
|
if (referenceNode.kind === 253 /* LabeledStatement */ && referenceNode.label.escapedText === labelName) {
|
|
return referenceNode.label;
|
|
}
|
|
referenceNode = referenceNode.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function hasPropertyAccessExpressionWithName(node, funcName) {
|
|
if (!isPropertyAccessExpression(node.expression)) {
|
|
return false;
|
|
}
|
|
return node.expression.name.text === funcName;
|
|
}
|
|
function isJumpStatementTarget(node) {
|
|
var _a2;
|
|
return isIdentifier(node) && ((_a2 = tryCast(node.parent, isBreakOrContinueStatement)) == null ? void 0 : _a2.label) === node;
|
|
}
|
|
function isLabelOfLabeledStatement(node) {
|
|
var _a2;
|
|
return isIdentifier(node) && ((_a2 = tryCast(node.parent, isLabeledStatement)) == null ? void 0 : _a2.label) === node;
|
|
}
|
|
function isLabelName(node) {
|
|
return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node);
|
|
}
|
|
function isTagName(node) {
|
|
var _a2;
|
|
return ((_a2 = tryCast(node.parent, isJSDocTag)) == null ? void 0 : _a2.tagName) === node;
|
|
}
|
|
function isRightSideOfQualifiedName(node) {
|
|
var _a2;
|
|
return ((_a2 = tryCast(node.parent, isQualifiedName)) == null ? void 0 : _a2.right) === node;
|
|
}
|
|
function isRightSideOfPropertyAccess(node) {
|
|
var _a2;
|
|
return ((_a2 = tryCast(node.parent, isPropertyAccessExpression)) == null ? void 0 : _a2.name) === node;
|
|
}
|
|
function isArgumentExpressionOfElementAccess(node) {
|
|
var _a2;
|
|
return ((_a2 = tryCast(node.parent, isElementAccessExpression)) == null ? void 0 : _a2.argumentExpression) === node;
|
|
}
|
|
function isNameOfModuleDeclaration(node) {
|
|
var _a2;
|
|
return ((_a2 = tryCast(node.parent, isModuleDeclaration)) == null ? void 0 : _a2.name) === node;
|
|
}
|
|
function isNameOfFunctionDeclaration(node) {
|
|
var _a2;
|
|
return isIdentifier(node) && ((_a2 = tryCast(node.parent, isFunctionLike)) == null ? void 0 : _a2.name) === node;
|
|
}
|
|
function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) {
|
|
switch (node.parent.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 302 /* EnumMember */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return getNameOfDeclaration(node.parent) === node;
|
|
case 209 /* ElementAccessExpression */:
|
|
return node.parent.argumentExpression === node;
|
|
case 164 /* ComputedPropertyName */:
|
|
return true;
|
|
case 198 /* LiteralType */:
|
|
return node.parent.parent.kind === 196 /* IndexedAccessType */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isExpressionOfExternalModuleImportEqualsDeclaration(node) {
|
|
return isExternalModuleImportEqualsDeclaration(node.parent.parent) && getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node;
|
|
}
|
|
function getContainerNode(node) {
|
|
if (isJSDocTypeAlias(node)) {
|
|
node = node.parent.parent;
|
|
}
|
|
while (true) {
|
|
node = node.parent;
|
|
if (!node) {
|
|
return void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return node;
|
|
}
|
|
}
|
|
}
|
|
function getNodeKind(node) {
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
return isExternalModule(node) ? "module" /* moduleElement */ : "script" /* scriptElement */;
|
|
case 264 /* ModuleDeclaration */:
|
|
return "module" /* moduleElement */;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return "class" /* classElement */;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return "interface" /* interfaceElement */;
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
return "type" /* typeElement */;
|
|
case 263 /* EnumDeclaration */:
|
|
return "enum" /* enumElement */;
|
|
case 257 /* VariableDeclaration */:
|
|
return getKindOfVariableDeclaration(node);
|
|
case 205 /* BindingElement */:
|
|
return getKindOfVariableDeclaration(getRootDeclaration(node));
|
|
case 216 /* ArrowFunction */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return "function" /* functionElement */;
|
|
case 174 /* GetAccessor */:
|
|
return "getter" /* memberGetAccessorElement */;
|
|
case 175 /* SetAccessor */:
|
|
return "setter" /* memberSetAccessorElement */;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return "method" /* memberFunctionElement */;
|
|
case 299 /* PropertyAssignment */:
|
|
const { initializer } = node;
|
|
return isFunctionLike(initializer) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */;
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return "property" /* memberVariableElement */;
|
|
case 178 /* IndexSignature */:
|
|
return "index" /* indexSignatureElement */;
|
|
case 177 /* ConstructSignature */:
|
|
return "construct" /* constructSignatureElement */;
|
|
case 176 /* CallSignature */:
|
|
return "call" /* callSignatureElement */;
|
|
case 173 /* Constructor */:
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
return "constructor" /* constructorImplementationElement */;
|
|
case 165 /* TypeParameter */:
|
|
return "type parameter" /* typeParameterElement */;
|
|
case 302 /* EnumMember */:
|
|
return "enum member" /* enumMemberElement */;
|
|
case 166 /* Parameter */:
|
|
return hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */) ? "property" /* memberVariableElement */ : "parameter" /* parameterElement */;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 271 /* NamespaceImport */:
|
|
case 277 /* NamespaceExport */:
|
|
return "alias" /* alias */;
|
|
case 223 /* BinaryExpression */:
|
|
const kind = getAssignmentDeclarationKind(node);
|
|
const { right } = node;
|
|
switch (kind) {
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
case 9 /* ObjectDefinePrototypeProperty */:
|
|
case 0 /* None */:
|
|
return "" /* unknown */;
|
|
case 1 /* ExportsProperty */:
|
|
case 2 /* ModuleExports */:
|
|
const rightKind = getNodeKind(right);
|
|
return rightKind === "" /* unknown */ ? "const" /* constElement */ : rightKind;
|
|
case 3 /* PrototypeProperty */:
|
|
return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */;
|
|
case 4 /* ThisProperty */:
|
|
return "property" /* memberVariableElement */;
|
|
case 5 /* Property */:
|
|
return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */;
|
|
case 6 /* Prototype */:
|
|
return "local class" /* localClassElement */;
|
|
default: {
|
|
assertType(kind);
|
|
return "" /* unknown */;
|
|
}
|
|
}
|
|
case 79 /* Identifier */:
|
|
return isImportClause(node.parent) ? "alias" /* alias */ : "" /* unknown */;
|
|
case 274 /* ExportAssignment */:
|
|
const scriptKind = getNodeKind(node.expression);
|
|
return scriptKind === "" /* unknown */ ? "const" /* constElement */ : scriptKind;
|
|
default:
|
|
return "" /* unknown */;
|
|
}
|
|
function getKindOfVariableDeclaration(v) {
|
|
return isVarConst(v) ? "const" /* constElement */ : isLet(v) ? "let" /* letElement */ : "var" /* variableElement */;
|
|
}
|
|
}
|
|
function isThis(node) {
|
|
switch (node.kind) {
|
|
case 108 /* ThisKeyword */:
|
|
return true;
|
|
case 79 /* Identifier */:
|
|
return identifierIsThisKeyword(node) && node.parent.kind === 166 /* Parameter */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
var tripleSlashDirectivePrefixRegex = /^\/\/\/\s*</;
|
|
function getLineStartPositionForPosition(position, sourceFile) {
|
|
const lineStarts = getLineStarts(sourceFile);
|
|
const line = sourceFile.getLineAndCharacterOfPosition(position).line;
|
|
return lineStarts[line];
|
|
}
|
|
function rangeContainsRange(r1, r2) {
|
|
return startEndContainsRange(r1.pos, r1.end, r2);
|
|
}
|
|
function rangeContainsRangeExclusive(r1, r2) {
|
|
return rangeContainsPositionExclusive(r1, r2.pos) && rangeContainsPositionExclusive(r1, r2.end);
|
|
}
|
|
function rangeContainsPosition(r, pos) {
|
|
return r.pos <= pos && pos <= r.end;
|
|
}
|
|
function rangeContainsPositionExclusive(r, pos) {
|
|
return r.pos < pos && pos < r.end;
|
|
}
|
|
function startEndContainsRange(start2, end, range) {
|
|
return start2 <= range.pos && end >= range.end;
|
|
}
|
|
function rangeContainsStartEnd(range, start2, end) {
|
|
return range.pos <= start2 && range.end >= end;
|
|
}
|
|
function rangeOverlapsWithStartEnd(r1, start2, end) {
|
|
return startEndOverlapsWithStartEnd(r1.pos, r1.end, start2, end);
|
|
}
|
|
function nodeOverlapsWithStartEnd(node, sourceFile, start2, end) {
|
|
return startEndOverlapsWithStartEnd(node.getStart(sourceFile), node.end, start2, end);
|
|
}
|
|
function startEndOverlapsWithStartEnd(start1, end1, start2, end2) {
|
|
const start3 = Math.max(start1, start2);
|
|
const end = Math.min(end1, end2);
|
|
return start3 < end;
|
|
}
|
|
function positionBelongsToNode(candidate, position, sourceFile) {
|
|
Debug.assert(candidate.pos <= position);
|
|
return position < candidate.end || !isCompletedNode(candidate, sourceFile);
|
|
}
|
|
function isCompletedNode(n, sourceFile) {
|
|
if (n === void 0 || nodeIsMissing(n)) {
|
|
return false;
|
|
}
|
|
switch (n.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 184 /* TypeLiteral */:
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
case 266 /* CaseBlock */:
|
|
case 272 /* NamedImports */:
|
|
case 276 /* NamedExports */:
|
|
return nodeEndsWith(n, 19 /* CloseBraceToken */, sourceFile);
|
|
case 295 /* CatchClause */:
|
|
return isCompletedNode(n.block, sourceFile);
|
|
case 211 /* NewExpression */:
|
|
if (!n.arguments) {
|
|
return true;
|
|
}
|
|
case 210 /* CallExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 193 /* ParenthesizedType */:
|
|
return nodeEndsWith(n, 21 /* CloseParenToken */, sourceFile);
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
return isCompletedNode(n.type, sourceFile);
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 216 /* ArrowFunction */:
|
|
if (n.body) {
|
|
return isCompletedNode(n.body, sourceFile);
|
|
}
|
|
if (n.type) {
|
|
return isCompletedNode(n.type, sourceFile);
|
|
}
|
|
return hasChildOfKind(n, 21 /* CloseParenToken */, sourceFile);
|
|
case 264 /* ModuleDeclaration */:
|
|
return !!n.body && isCompletedNode(n.body, sourceFile);
|
|
case 242 /* IfStatement */:
|
|
if (n.elseStatement) {
|
|
return isCompletedNode(n.elseStatement, sourceFile);
|
|
}
|
|
return isCompletedNode(n.thenStatement, sourceFile);
|
|
case 241 /* ExpressionStatement */:
|
|
return isCompletedNode(n.expression, sourceFile) || hasChildOfKind(n, 26 /* SemicolonToken */, sourceFile);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 209 /* ElementAccessExpression */:
|
|
case 164 /* ComputedPropertyName */:
|
|
case 186 /* TupleType */:
|
|
return nodeEndsWith(n, 23 /* CloseBracketToken */, sourceFile);
|
|
case 178 /* IndexSignature */:
|
|
if (n.type) {
|
|
return isCompletedNode(n.type, sourceFile);
|
|
}
|
|
return hasChildOfKind(n, 23 /* CloseBracketToken */, sourceFile);
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
return false;
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return isCompletedNode(n.statement, sourceFile);
|
|
case 243 /* DoStatement */:
|
|
return hasChildOfKind(n, 115 /* WhileKeyword */, sourceFile) ? nodeEndsWith(n, 21 /* CloseParenToken */, sourceFile) : isCompletedNode(n.statement, sourceFile);
|
|
case 183 /* TypeQuery */:
|
|
return isCompletedNode(n.exprName, sourceFile);
|
|
case 218 /* TypeOfExpression */:
|
|
case 217 /* DeleteExpression */:
|
|
case 219 /* VoidExpression */:
|
|
case 226 /* YieldExpression */:
|
|
case 227 /* SpreadElement */:
|
|
const unaryWordExpression = n;
|
|
return isCompletedNode(unaryWordExpression.expression, sourceFile);
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return isCompletedNode(n.template, sourceFile);
|
|
case 225 /* TemplateExpression */:
|
|
const lastSpan = lastOrUndefined(n.templateSpans);
|
|
return isCompletedNode(lastSpan, sourceFile);
|
|
case 236 /* TemplateSpan */:
|
|
return nodeIsPresent(n.literal);
|
|
case 275 /* ExportDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
return nodeIsPresent(n.moduleSpecifier);
|
|
case 221 /* PrefixUnaryExpression */:
|
|
return isCompletedNode(n.operand, sourceFile);
|
|
case 223 /* BinaryExpression */:
|
|
return isCompletedNode(n.right, sourceFile);
|
|
case 224 /* ConditionalExpression */:
|
|
return isCompletedNode(n.whenFalse, sourceFile);
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function nodeEndsWith(n, expectedLastToken, sourceFile) {
|
|
const children = n.getChildren(sourceFile);
|
|
if (children.length) {
|
|
const lastChild = last(children);
|
|
if (lastChild.kind === expectedLastToken) {
|
|
return true;
|
|
} else if (lastChild.kind === 26 /* SemicolonToken */ && children.length !== 1) {
|
|
return children[children.length - 2].kind === expectedLastToken;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function findListItemInfo(node) {
|
|
const list = findContainingList(node);
|
|
if (!list) {
|
|
return void 0;
|
|
}
|
|
const children = list.getChildren();
|
|
const listItemIndex = indexOfNode(children, node);
|
|
return {
|
|
listItemIndex,
|
|
list
|
|
};
|
|
}
|
|
function hasChildOfKind(n, kind, sourceFile) {
|
|
return !!findChildOfKind(n, kind, sourceFile);
|
|
}
|
|
function findChildOfKind(n, kind, sourceFile) {
|
|
return find(n.getChildren(sourceFile), (c) => c.kind === kind);
|
|
}
|
|
function findContainingList(node) {
|
|
const syntaxList = find(node.parent.getChildren(), (c) => isSyntaxList(c) && rangeContainsRange(c, node));
|
|
Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node));
|
|
return syntaxList;
|
|
}
|
|
function isDefaultModifier(node) {
|
|
return node.kind === 88 /* DefaultKeyword */;
|
|
}
|
|
function isClassKeyword(node) {
|
|
return node.kind === 84 /* ClassKeyword */;
|
|
}
|
|
function isFunctionKeyword(node) {
|
|
return node.kind === 98 /* FunctionKeyword */;
|
|
}
|
|
function getAdjustedLocationForClass(node) {
|
|
if (isNamedDeclaration(node)) {
|
|
return node.name;
|
|
}
|
|
if (isClassDeclaration(node)) {
|
|
const defaultModifier = node.modifiers && find(node.modifiers, isDefaultModifier);
|
|
if (defaultModifier)
|
|
return defaultModifier;
|
|
}
|
|
if (isClassExpression(node)) {
|
|
const classKeyword = find(node.getChildren(), isClassKeyword);
|
|
if (classKeyword)
|
|
return classKeyword;
|
|
}
|
|
}
|
|
function getAdjustedLocationForFunction(node) {
|
|
if (isNamedDeclaration(node)) {
|
|
return node.name;
|
|
}
|
|
if (isFunctionDeclaration(node)) {
|
|
const defaultModifier = find(node.modifiers, isDefaultModifier);
|
|
if (defaultModifier)
|
|
return defaultModifier;
|
|
}
|
|
if (isFunctionExpression(node)) {
|
|
const functionKeyword = find(node.getChildren(), isFunctionKeyword);
|
|
if (functionKeyword)
|
|
return functionKeyword;
|
|
}
|
|
}
|
|
function getAncestorTypeNode(node) {
|
|
let lastTypeNode;
|
|
findAncestor(node, (a) => {
|
|
if (isTypeNode(a)) {
|
|
lastTypeNode = a;
|
|
}
|
|
return !isQualifiedName(a.parent) && !isTypeNode(a.parent) && !isTypeElement(a.parent);
|
|
});
|
|
return lastTypeNode;
|
|
}
|
|
function getContextualTypeFromParentOrAncestorTypeNode(node, checker) {
|
|
if (node.flags & (8388608 /* JSDoc */ & ~262144 /* JavaScriptFile */))
|
|
return void 0;
|
|
const contextualType = getContextualTypeFromParent(node, checker);
|
|
if (contextualType)
|
|
return contextualType;
|
|
const ancestorTypeNode = getAncestorTypeNode(node);
|
|
return ancestorTypeNode && checker.getTypeAtLocation(ancestorTypeNode);
|
|
}
|
|
function getAdjustedLocationForDeclaration(node, forRename) {
|
|
if (!forRename) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
return getAdjustedLocationForClass(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return getAdjustedLocationForFunction(node);
|
|
case 173 /* Constructor */:
|
|
return node;
|
|
}
|
|
}
|
|
if (isNamedDeclaration(node)) {
|
|
return node.name;
|
|
}
|
|
}
|
|
function getAdjustedLocationForImportDeclaration(node, forRename) {
|
|
if (node.importClause) {
|
|
if (node.importClause.name && node.importClause.namedBindings) {
|
|
return;
|
|
}
|
|
if (node.importClause.name) {
|
|
return node.importClause.name;
|
|
}
|
|
if (node.importClause.namedBindings) {
|
|
if (isNamedImports(node.importClause.namedBindings)) {
|
|
const onlyBinding = singleOrUndefined(node.importClause.namedBindings.elements);
|
|
if (!onlyBinding) {
|
|
return;
|
|
}
|
|
return onlyBinding.name;
|
|
} else if (isNamespaceImport(node.importClause.namedBindings)) {
|
|
return node.importClause.namedBindings.name;
|
|
}
|
|
}
|
|
}
|
|
if (!forRename) {
|
|
return node.moduleSpecifier;
|
|
}
|
|
}
|
|
function getAdjustedLocationForExportDeclaration(node, forRename) {
|
|
if (node.exportClause) {
|
|
if (isNamedExports(node.exportClause)) {
|
|
const onlyBinding = singleOrUndefined(node.exportClause.elements);
|
|
if (!onlyBinding) {
|
|
return;
|
|
}
|
|
return node.exportClause.elements[0].name;
|
|
} else if (isNamespaceExport(node.exportClause)) {
|
|
return node.exportClause.name;
|
|
}
|
|
}
|
|
if (!forRename) {
|
|
return node.moduleSpecifier;
|
|
}
|
|
}
|
|
function getAdjustedLocationForHeritageClause(node) {
|
|
if (node.types.length === 1) {
|
|
return node.types[0].expression;
|
|
}
|
|
}
|
|
function getAdjustedLocation(node, forRename) {
|
|
const { parent: parent2 } = node;
|
|
if (isModifier(node) && (forRename || node.kind !== 88 /* DefaultKeyword */) ? canHaveModifiers(parent2) && contains(parent2.modifiers, node) : node.kind === 84 /* ClassKeyword */ ? isClassDeclaration(parent2) || isClassExpression(node) : node.kind === 98 /* FunctionKeyword */ ? isFunctionDeclaration(parent2) || isFunctionExpression(node) : node.kind === 118 /* InterfaceKeyword */ ? isInterfaceDeclaration(parent2) : node.kind === 92 /* EnumKeyword */ ? isEnumDeclaration(parent2) : node.kind === 154 /* TypeKeyword */ ? isTypeAliasDeclaration(parent2) : node.kind === 143 /* NamespaceKeyword */ || node.kind === 142 /* ModuleKeyword */ ? isModuleDeclaration(parent2) : node.kind === 100 /* ImportKeyword */ ? isImportEqualsDeclaration(parent2) : node.kind === 137 /* GetKeyword */ ? isGetAccessorDeclaration(parent2) : node.kind === 151 /* SetKeyword */ && isSetAccessorDeclaration(parent2)) {
|
|
const location2 = getAdjustedLocationForDeclaration(parent2, forRename);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
if ((node.kind === 113 /* VarKeyword */ || node.kind === 85 /* ConstKeyword */ || node.kind === 119 /* LetKeyword */) && isVariableDeclarationList(parent2) && parent2.declarations.length === 1) {
|
|
const decl = parent2.declarations[0];
|
|
if (isIdentifier(decl.name)) {
|
|
return decl.name;
|
|
}
|
|
}
|
|
if (node.kind === 154 /* TypeKeyword */) {
|
|
if (isImportClause(parent2) && parent2.isTypeOnly) {
|
|
const location2 = getAdjustedLocationForImportDeclaration(parent2.parent, forRename);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
if (isExportDeclaration(parent2) && parent2.isTypeOnly) {
|
|
const location2 = getAdjustedLocationForExportDeclaration(parent2, forRename);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
}
|
|
if (node.kind === 128 /* AsKeyword */) {
|
|
if (isImportSpecifier(parent2) && parent2.propertyName || isExportSpecifier(parent2) && parent2.propertyName || isNamespaceImport(parent2) || isNamespaceExport(parent2)) {
|
|
return parent2.name;
|
|
}
|
|
if (isExportDeclaration(parent2) && parent2.exportClause && isNamespaceExport(parent2.exportClause)) {
|
|
return parent2.exportClause.name;
|
|
}
|
|
}
|
|
if (node.kind === 100 /* ImportKeyword */ && isImportDeclaration(parent2)) {
|
|
const location2 = getAdjustedLocationForImportDeclaration(parent2, forRename);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
if (node.kind === 93 /* ExportKeyword */) {
|
|
if (isExportDeclaration(parent2)) {
|
|
const location2 = getAdjustedLocationForExportDeclaration(parent2, forRename);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
if (isExportAssignment(parent2)) {
|
|
return skipOuterExpressions(parent2.expression);
|
|
}
|
|
}
|
|
if (node.kind === 147 /* RequireKeyword */ && isExternalModuleReference(parent2)) {
|
|
return parent2.expression;
|
|
}
|
|
if (node.kind === 158 /* FromKeyword */ && (isImportDeclaration(parent2) || isExportDeclaration(parent2)) && parent2.moduleSpecifier) {
|
|
return parent2.moduleSpecifier;
|
|
}
|
|
if ((node.kind === 94 /* ExtendsKeyword */ || node.kind === 117 /* ImplementsKeyword */) && isHeritageClause(parent2) && parent2.token === node.kind) {
|
|
const location2 = getAdjustedLocationForHeritageClause(parent2);
|
|
if (location2) {
|
|
return location2;
|
|
}
|
|
}
|
|
if (node.kind === 94 /* ExtendsKeyword */) {
|
|
if (isTypeParameterDeclaration(parent2) && parent2.constraint && isTypeReferenceNode(parent2.constraint)) {
|
|
return parent2.constraint.typeName;
|
|
}
|
|
if (isConditionalTypeNode(parent2) && isTypeReferenceNode(parent2.extendsType)) {
|
|
return parent2.extendsType.typeName;
|
|
}
|
|
}
|
|
if (node.kind === 138 /* InferKeyword */ && isInferTypeNode(parent2)) {
|
|
return parent2.typeParameter.name;
|
|
}
|
|
if (node.kind === 101 /* InKeyword */ && isTypeParameterDeclaration(parent2) && isMappedTypeNode(parent2.parent)) {
|
|
return parent2.name;
|
|
}
|
|
if (node.kind === 141 /* KeyOfKeyword */ && isTypeOperatorNode(parent2) && parent2.operator === 141 /* KeyOfKeyword */ && isTypeReferenceNode(parent2.type)) {
|
|
return parent2.type.typeName;
|
|
}
|
|
if (node.kind === 146 /* ReadonlyKeyword */ && isTypeOperatorNode(parent2) && parent2.operator === 146 /* ReadonlyKeyword */ && isArrayTypeNode(parent2.type) && isTypeReferenceNode(parent2.type.elementType)) {
|
|
return parent2.type.elementType.typeName;
|
|
}
|
|
if (!forRename) {
|
|
if (node.kind === 103 /* NewKeyword */ && isNewExpression(parent2) || node.kind === 114 /* VoidKeyword */ && isVoidExpression(parent2) || node.kind === 112 /* TypeOfKeyword */ && isTypeOfExpression(parent2) || node.kind === 133 /* AwaitKeyword */ && isAwaitExpression(parent2) || node.kind === 125 /* YieldKeyword */ && isYieldExpression(parent2) || node.kind === 89 /* DeleteKeyword */ && isDeleteExpression(parent2)) {
|
|
if (parent2.expression) {
|
|
return skipOuterExpressions(parent2.expression);
|
|
}
|
|
}
|
|
if ((node.kind === 101 /* InKeyword */ || node.kind === 102 /* InstanceOfKeyword */) && isBinaryExpression(parent2) && parent2.operatorToken === node) {
|
|
return skipOuterExpressions(parent2.right);
|
|
}
|
|
if (node.kind === 128 /* AsKeyword */ && isAsExpression(parent2) && isTypeReferenceNode(parent2.type)) {
|
|
return parent2.type.typeName;
|
|
}
|
|
if (node.kind === 101 /* InKeyword */ && isForInStatement(parent2) || node.kind === 162 /* OfKeyword */ && isForOfStatement(parent2)) {
|
|
return skipOuterExpressions(parent2.expression);
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
function getAdjustedReferenceLocation(node) {
|
|
return getAdjustedLocation(node, false);
|
|
}
|
|
function getAdjustedRenameLocation(node) {
|
|
return getAdjustedLocation(node, true);
|
|
}
|
|
function getTouchingPropertyName(sourceFile, position) {
|
|
return getTouchingToken(sourceFile, position, (n) => isPropertyNameLiteral(n) || isKeyword(n.kind) || isPrivateIdentifier(n));
|
|
}
|
|
function getTouchingToken(sourceFile, position, includePrecedingTokenAtEndPosition) {
|
|
return getTokenAtPositionWorker(sourceFile, position, false, includePrecedingTokenAtEndPosition, false);
|
|
}
|
|
function getTokenAtPosition(sourceFile, position) {
|
|
return getTokenAtPositionWorker(sourceFile, position, true, void 0, false);
|
|
}
|
|
function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includePrecedingTokenAtEndPosition, includeEndPosition) {
|
|
let current = sourceFile;
|
|
let foundToken;
|
|
outer:
|
|
while (true) {
|
|
const children = current.getChildren(sourceFile);
|
|
const i = binarySearchKey(children, position, (_, i2) => i2, (middle, _) => {
|
|
const end = children[middle].getEnd();
|
|
if (end < position) {
|
|
return -1 /* LessThan */;
|
|
}
|
|
const start2 = allowPositionInLeadingTrivia ? children[middle].getFullStart() : children[middle].getStart(sourceFile, true);
|
|
if (start2 > position) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
if (nodeContainsPosition(children[middle], start2, end)) {
|
|
if (children[middle - 1]) {
|
|
if (nodeContainsPosition(children[middle - 1])) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
}
|
|
return 0 /* EqualTo */;
|
|
}
|
|
if (includePrecedingTokenAtEndPosition && start2 === position && children[middle - 1] && children[middle - 1].getEnd() === position && nodeContainsPosition(children[middle - 1])) {
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
return -1 /* LessThan */;
|
|
});
|
|
if (foundToken) {
|
|
return foundToken;
|
|
}
|
|
if (i >= 0 && children[i]) {
|
|
current = children[i];
|
|
continue outer;
|
|
}
|
|
return current;
|
|
}
|
|
function nodeContainsPosition(node, start2, end) {
|
|
end != null ? end : end = node.getEnd();
|
|
if (end < position) {
|
|
return false;
|
|
}
|
|
start2 != null ? start2 : start2 = allowPositionInLeadingTrivia ? node.getFullStart() : node.getStart(sourceFile, true);
|
|
if (start2 > position) {
|
|
return false;
|
|
}
|
|
if (position < end || position === end && (node.kind === 1 /* EndOfFileToken */ || includeEndPosition)) {
|
|
return true;
|
|
} else if (includePrecedingTokenAtEndPosition && end === position) {
|
|
const previousToken = findPrecedingToken(position, sourceFile, node);
|
|
if (previousToken && includePrecedingTokenAtEndPosition(previousToken)) {
|
|
foundToken = previousToken;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
function findFirstNonJsxWhitespaceToken(sourceFile, position) {
|
|
let tokenAtPosition = getTokenAtPosition(sourceFile, position);
|
|
while (isWhiteSpaceOnlyJsxText(tokenAtPosition)) {
|
|
const nextToken = findNextToken(tokenAtPosition, tokenAtPosition.parent, sourceFile);
|
|
if (!nextToken)
|
|
return;
|
|
tokenAtPosition = nextToken;
|
|
}
|
|
return tokenAtPosition;
|
|
}
|
|
function findTokenOnLeftOfPosition(file, position) {
|
|
const tokenAtPosition = getTokenAtPosition(file, position);
|
|
if (isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) {
|
|
return tokenAtPosition;
|
|
}
|
|
return findPrecedingToken(position, file);
|
|
}
|
|
function findNextToken(previousToken, parent2, sourceFile) {
|
|
return find2(parent2);
|
|
function find2(n) {
|
|
if (isToken(n) && n.pos === previousToken.end) {
|
|
return n;
|
|
}
|
|
return firstDefined(n.getChildren(sourceFile), (child) => {
|
|
const shouldDiveInChildNode = child.pos <= previousToken.pos && child.end > previousToken.end || child.pos === previousToken.end;
|
|
return shouldDiveInChildNode && nodeHasTokens(child, sourceFile) ? find2(child) : void 0;
|
|
});
|
|
}
|
|
}
|
|
function findPrecedingToken(position, sourceFile, startNode2, excludeJsdoc) {
|
|
const result = find2(startNode2 || sourceFile);
|
|
Debug.assert(!(result && isWhiteSpaceOnlyJsxText(result)));
|
|
return result;
|
|
function find2(n) {
|
|
if (isNonWhitespaceToken(n) && n.kind !== 1 /* EndOfFileToken */) {
|
|
return n;
|
|
}
|
|
const children = n.getChildren(sourceFile);
|
|
const i = binarySearchKey(children, position, (_, i2) => i2, (middle, _) => {
|
|
if (position < children[middle].end) {
|
|
if (!children[middle - 1] || position >= children[middle - 1].end) {
|
|
return 0 /* EqualTo */;
|
|
}
|
|
return 1 /* GreaterThan */;
|
|
}
|
|
return -1 /* LessThan */;
|
|
});
|
|
if (i >= 0 && children[i]) {
|
|
const child = children[i];
|
|
if (position < child.end) {
|
|
const start2 = child.getStart(sourceFile, !excludeJsdoc);
|
|
const lookInPreviousChild = start2 >= position || !nodeHasTokens(child, sourceFile) || isWhiteSpaceOnlyJsxText(child);
|
|
if (lookInPreviousChild) {
|
|
const candidate2 = findRightmostChildNodeWithTokens(children, i, sourceFile, n.kind);
|
|
return candidate2 && findRightmostToken(candidate2, sourceFile);
|
|
} else {
|
|
return find2(child);
|
|
}
|
|
}
|
|
}
|
|
Debug.assert(startNode2 !== void 0 || n.kind === 308 /* SourceFile */ || n.kind === 1 /* EndOfFileToken */ || isJSDocCommentContainingNode(n));
|
|
const candidate = findRightmostChildNodeWithTokens(children, children.length, sourceFile, n.kind);
|
|
return candidate && findRightmostToken(candidate, sourceFile);
|
|
}
|
|
}
|
|
function isNonWhitespaceToken(n) {
|
|
return isToken(n) && !isWhiteSpaceOnlyJsxText(n);
|
|
}
|
|
function findRightmostToken(n, sourceFile) {
|
|
if (isNonWhitespaceToken(n)) {
|
|
return n;
|
|
}
|
|
const children = n.getChildren(sourceFile);
|
|
if (children.length === 0) {
|
|
return n;
|
|
}
|
|
const candidate = findRightmostChildNodeWithTokens(children, children.length, sourceFile, n.kind);
|
|
return candidate && findRightmostToken(candidate, sourceFile);
|
|
}
|
|
function findRightmostChildNodeWithTokens(children, exclusiveStartPosition, sourceFile, parentKind) {
|
|
for (let i = exclusiveStartPosition - 1; i >= 0; i--) {
|
|
const child = children[i];
|
|
if (isWhiteSpaceOnlyJsxText(child)) {
|
|
if (i === 0 && (parentKind === 11 /* JsxText */ || parentKind === 282 /* JsxSelfClosingElement */)) {
|
|
Debug.fail("`JsxText` tokens should not be the first child of `JsxElement | JsxSelfClosingElement`");
|
|
}
|
|
} else if (nodeHasTokens(children[i], sourceFile)) {
|
|
return children[i];
|
|
}
|
|
}
|
|
}
|
|
function isInString(sourceFile, position, previousToken = findPrecedingToken(position, sourceFile)) {
|
|
if (previousToken && isStringTextContainingNode(previousToken)) {
|
|
const start2 = previousToken.getStart(sourceFile);
|
|
const end = previousToken.getEnd();
|
|
if (start2 < position && position < end) {
|
|
return true;
|
|
}
|
|
if (position === end) {
|
|
return !!previousToken.isUnterminated;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInsideJsxElementOrAttribute(sourceFile, position) {
|
|
const token = getTokenAtPosition(sourceFile, position);
|
|
if (!token) {
|
|
return false;
|
|
}
|
|
if (token.kind === 11 /* JsxText */) {
|
|
return true;
|
|
}
|
|
if (token.kind === 29 /* LessThanToken */ && token.parent.kind === 11 /* JsxText */) {
|
|
return true;
|
|
}
|
|
if (token.kind === 29 /* LessThanToken */ && token.parent.kind === 291 /* JsxExpression */) {
|
|
return true;
|
|
}
|
|
if (token && token.kind === 19 /* CloseBraceToken */ && token.parent.kind === 291 /* JsxExpression */) {
|
|
return true;
|
|
}
|
|
if (token.kind === 29 /* LessThanToken */ && token.parent.kind === 284 /* JsxClosingElement */) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isWhiteSpaceOnlyJsxText(node) {
|
|
return isJsxText(node) && node.containsOnlyTriviaWhiteSpaces;
|
|
}
|
|
function isInTemplateString(sourceFile, position) {
|
|
const token = getTokenAtPosition(sourceFile, position);
|
|
return isTemplateLiteralKind(token.kind) && position > token.getStart(sourceFile);
|
|
}
|
|
function isInJSXText(sourceFile, position) {
|
|
const token = getTokenAtPosition(sourceFile, position);
|
|
if (isJsxText(token)) {
|
|
return true;
|
|
}
|
|
if (token.kind === 18 /* OpenBraceToken */ && isJsxExpression(token.parent) && isJsxElement(token.parent.parent)) {
|
|
return true;
|
|
}
|
|
if (token.kind === 29 /* LessThanToken */ && isJsxOpeningLikeElement(token.parent) && isJsxElement(token.parent.parent)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isInsideJsxElement(sourceFile, position) {
|
|
function isInsideJsxElementTraversal(node) {
|
|
while (node) {
|
|
if (node.kind >= 282 /* JsxSelfClosingElement */ && node.kind <= 291 /* JsxExpression */ || node.kind === 11 /* JsxText */ || node.kind === 29 /* LessThanToken */ || node.kind === 31 /* GreaterThanToken */ || node.kind === 79 /* Identifier */ || node.kind === 19 /* CloseBraceToken */ || node.kind === 18 /* OpenBraceToken */ || node.kind === 43 /* SlashToken */) {
|
|
node = node.parent;
|
|
} else if (node.kind === 281 /* JsxElement */) {
|
|
if (position > node.getStart(sourceFile))
|
|
return true;
|
|
node = node.parent;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
return isInsideJsxElementTraversal(getTokenAtPosition(sourceFile, position));
|
|
}
|
|
function findPrecedingMatchingToken(token, matchingTokenKind, sourceFile) {
|
|
const closeTokenText = tokenToString(token.kind);
|
|
const matchingTokenText = tokenToString(matchingTokenKind);
|
|
const tokenFullStart = token.getFullStart();
|
|
const bestGuessIndex = sourceFile.text.lastIndexOf(matchingTokenText, tokenFullStart);
|
|
if (bestGuessIndex === -1) {
|
|
return void 0;
|
|
}
|
|
if (sourceFile.text.lastIndexOf(closeTokenText, tokenFullStart - 1) < bestGuessIndex) {
|
|
const nodeAtGuess = findPrecedingToken(bestGuessIndex + 1, sourceFile);
|
|
if (nodeAtGuess && nodeAtGuess.kind === matchingTokenKind) {
|
|
return nodeAtGuess;
|
|
}
|
|
}
|
|
const tokenKind = token.kind;
|
|
let remainingMatchingTokens = 0;
|
|
while (true) {
|
|
const preceding = findPrecedingToken(token.getFullStart(), sourceFile);
|
|
if (!preceding) {
|
|
return void 0;
|
|
}
|
|
token = preceding;
|
|
if (token.kind === matchingTokenKind) {
|
|
if (remainingMatchingTokens === 0) {
|
|
return token;
|
|
}
|
|
remainingMatchingTokens--;
|
|
} else if (token.kind === tokenKind) {
|
|
remainingMatchingTokens++;
|
|
}
|
|
}
|
|
}
|
|
function removeOptionality(type, isOptionalExpression, isOptionalChain2) {
|
|
return isOptionalExpression ? type.getNonNullableType() : isOptionalChain2 ? type.getNonOptionalType() : type;
|
|
}
|
|
function isPossiblyTypeArgumentPosition(token, sourceFile, checker) {
|
|
const info = getPossibleTypeArgumentsInfo(token, sourceFile);
|
|
return info !== void 0 && (isPartOfTypeNode(info.called) || getPossibleGenericSignatures(info.called, info.nTypeArguments, checker).length !== 0 || isPossiblyTypeArgumentPosition(info.called, sourceFile, checker));
|
|
}
|
|
function getPossibleGenericSignatures(called, typeArgumentCount, checker) {
|
|
let type = checker.getTypeAtLocation(called);
|
|
if (isOptionalChain(called.parent)) {
|
|
type = removeOptionality(type, isOptionalChainRoot(called.parent), true);
|
|
}
|
|
const signatures = isNewExpression(called.parent) ? type.getConstructSignatures() : type.getCallSignatures();
|
|
return signatures.filter((candidate) => !!candidate.typeParameters && candidate.typeParameters.length >= typeArgumentCount);
|
|
}
|
|
function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) {
|
|
if (sourceFile.text.lastIndexOf("<", tokenIn ? tokenIn.pos : sourceFile.text.length) === -1) {
|
|
return void 0;
|
|
}
|
|
let token = tokenIn;
|
|
let remainingLessThanTokens = 0;
|
|
let nTypeArguments = 0;
|
|
while (token) {
|
|
switch (token.kind) {
|
|
case 29 /* LessThanToken */:
|
|
token = findPrecedingToken(token.getFullStart(), sourceFile);
|
|
if (token && token.kind === 28 /* QuestionDotToken */) {
|
|
token = findPrecedingToken(token.getFullStart(), sourceFile);
|
|
}
|
|
if (!token || !isIdentifier(token))
|
|
return void 0;
|
|
if (!remainingLessThanTokens) {
|
|
return isDeclarationName(token) ? void 0 : { called: token, nTypeArguments };
|
|
}
|
|
remainingLessThanTokens--;
|
|
break;
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
remainingLessThanTokens = 3;
|
|
break;
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
remainingLessThanTokens = 2;
|
|
break;
|
|
case 31 /* GreaterThanToken */:
|
|
remainingLessThanTokens++;
|
|
break;
|
|
case 19 /* CloseBraceToken */:
|
|
token = findPrecedingMatchingToken(token, 18 /* OpenBraceToken */, sourceFile);
|
|
if (!token)
|
|
return void 0;
|
|
break;
|
|
case 21 /* CloseParenToken */:
|
|
token = findPrecedingMatchingToken(token, 20 /* OpenParenToken */, sourceFile);
|
|
if (!token)
|
|
return void 0;
|
|
break;
|
|
case 23 /* CloseBracketToken */:
|
|
token = findPrecedingMatchingToken(token, 22 /* OpenBracketToken */, sourceFile);
|
|
if (!token)
|
|
return void 0;
|
|
break;
|
|
case 27 /* CommaToken */:
|
|
nTypeArguments++;
|
|
break;
|
|
case 38 /* EqualsGreaterThanToken */:
|
|
case 79 /* Identifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
case 9 /* BigIntLiteral */:
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 112 /* TypeOfKeyword */:
|
|
case 94 /* ExtendsKeyword */:
|
|
case 141 /* KeyOfKeyword */:
|
|
case 24 /* DotToken */:
|
|
case 51 /* BarToken */:
|
|
case 57 /* QuestionToken */:
|
|
case 58 /* ColonToken */:
|
|
break;
|
|
default:
|
|
if (isTypeNode(token)) {
|
|
break;
|
|
}
|
|
return void 0;
|
|
}
|
|
token = findPrecedingToken(token.getFullStart(), sourceFile);
|
|
}
|
|
return void 0;
|
|
}
|
|
function isInComment(sourceFile, position, tokenAtPosition) {
|
|
return ts_formatting_exports.getRangeOfEnclosingComment(sourceFile, position, void 0, tokenAtPosition);
|
|
}
|
|
function hasDocComment(sourceFile, position) {
|
|
const token = getTokenAtPosition(sourceFile, position);
|
|
return !!findAncestor(token, isJSDoc);
|
|
}
|
|
function nodeHasTokens(n, sourceFile) {
|
|
return n.kind === 1 /* EndOfFileToken */ ? !!n.jsDoc : n.getWidth(sourceFile) !== 0;
|
|
}
|
|
function getNodeModifiers(node, excludeFlags = 0 /* None */) {
|
|
const result = [];
|
|
const flags = isDeclaration(node) ? getCombinedNodeFlagsAlwaysIncludeJSDoc(node) & ~excludeFlags : 0 /* None */;
|
|
if (flags & 8 /* Private */)
|
|
result.push("private" /* privateMemberModifier */);
|
|
if (flags & 16 /* Protected */)
|
|
result.push("protected" /* protectedMemberModifier */);
|
|
if (flags & 4 /* Public */)
|
|
result.push("public" /* publicMemberModifier */);
|
|
if (flags & 32 /* Static */ || isClassStaticBlockDeclaration(node))
|
|
result.push("static" /* staticModifier */);
|
|
if (flags & 256 /* Abstract */)
|
|
result.push("abstract" /* abstractModifier */);
|
|
if (flags & 1 /* Export */)
|
|
result.push("export" /* exportedModifier */);
|
|
if (flags & 8192 /* Deprecated */)
|
|
result.push("deprecated" /* deprecatedModifier */);
|
|
if (node.flags & 16777216 /* Ambient */)
|
|
result.push("declare" /* ambientModifier */);
|
|
if (node.kind === 274 /* ExportAssignment */)
|
|
result.push("export" /* exportedModifier */);
|
|
return result.length > 0 ? result.join(",") : "" /* none */;
|
|
}
|
|
function getTypeArgumentOrTypeParameterList(node) {
|
|
if (node.kind === 180 /* TypeReference */ || node.kind === 210 /* CallExpression */) {
|
|
return node.typeArguments;
|
|
}
|
|
if (isFunctionLike(node) || node.kind === 260 /* ClassDeclaration */ || node.kind === 261 /* InterfaceDeclaration */) {
|
|
return node.typeParameters;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isComment(kind) {
|
|
return kind === 2 /* SingleLineCommentTrivia */ || kind === 3 /* MultiLineCommentTrivia */;
|
|
}
|
|
function isStringOrRegularExpressionOrTemplateLiteral(kind) {
|
|
if (kind === 10 /* StringLiteral */ || kind === 13 /* RegularExpressionLiteral */ || isTemplateLiteralKind(kind)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isPunctuation(kind) {
|
|
return 18 /* FirstPunctuation */ <= kind && kind <= 78 /* LastPunctuation */;
|
|
}
|
|
function isInsideTemplateLiteral(node, position, sourceFile) {
|
|
return isTemplateLiteralKind(node.kind) && (node.getStart(sourceFile) < position && position < node.end) || !!node.isUnterminated && position === node.end;
|
|
}
|
|
function isAccessibilityModifier(kind) {
|
|
switch (kind) {
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function cloneCompilerOptions(options) {
|
|
const result = clone(options);
|
|
setConfigFileInOptions(result, options && options.configFile);
|
|
return result;
|
|
}
|
|
function isArrayLiteralOrObjectLiteralDestructuringPattern(node) {
|
|
if (node.kind === 206 /* ArrayLiteralExpression */ || node.kind === 207 /* ObjectLiteralExpression */) {
|
|
if (node.parent.kind === 223 /* BinaryExpression */ && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
return true;
|
|
}
|
|
if (node.parent.kind === 247 /* ForOfStatement */ && node.parent.initializer === node) {
|
|
return true;
|
|
}
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.kind === 299 /* PropertyAssignment */ ? node.parent.parent : node.parent)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInReferenceComment(sourceFile, position) {
|
|
return isInReferenceCommentWorker(sourceFile, position, true);
|
|
}
|
|
function isInNonReferenceComment(sourceFile, position) {
|
|
return isInReferenceCommentWorker(sourceFile, position, false);
|
|
}
|
|
function isInReferenceCommentWorker(sourceFile, position, shouldBeReference) {
|
|
const range = isInComment(sourceFile, position, void 0);
|
|
return !!range && shouldBeReference === tripleSlashDirectivePrefixRegex.test(sourceFile.text.substring(range.pos, range.end));
|
|
}
|
|
function getReplacementSpanForContextToken(contextToken) {
|
|
if (!contextToken)
|
|
return void 0;
|
|
switch (contextToken.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return createTextSpanFromStringLiteralLikeContent(contextToken);
|
|
default:
|
|
return createTextSpanFromNode(contextToken);
|
|
}
|
|
}
|
|
function createTextSpanFromNode(node, sourceFile, endNode2) {
|
|
return createTextSpanFromBounds(node.getStart(sourceFile), (endNode2 || node).getEnd());
|
|
}
|
|
function createTextSpanFromStringLiteralLikeContent(node) {
|
|
if (node.isUnterminated)
|
|
return void 0;
|
|
return createTextSpanFromBounds(node.getStart() + 1, node.getEnd() - 1);
|
|
}
|
|
function createTextRangeFromNode(node, sourceFile) {
|
|
return createRange(node.getStart(sourceFile), node.end);
|
|
}
|
|
function createTextSpanFromRange(range) {
|
|
return createTextSpanFromBounds(range.pos, range.end);
|
|
}
|
|
function createTextRangeFromSpan(span) {
|
|
return createRange(span.start, span.start + span.length);
|
|
}
|
|
function createTextChangeFromStartLength(start2, length2, newText) {
|
|
return createTextChange(createTextSpan(start2, length2), newText);
|
|
}
|
|
function createTextChange(span, newText) {
|
|
return { span, newText };
|
|
}
|
|
var typeKeywords = [
|
|
131 /* AnyKeyword */,
|
|
129 /* AssertsKeyword */,
|
|
160 /* BigIntKeyword */,
|
|
134 /* BooleanKeyword */,
|
|
95 /* FalseKeyword */,
|
|
138 /* InferKeyword */,
|
|
141 /* KeyOfKeyword */,
|
|
144 /* NeverKeyword */,
|
|
104 /* NullKeyword */,
|
|
148 /* NumberKeyword */,
|
|
149 /* ObjectKeyword */,
|
|
146 /* ReadonlyKeyword */,
|
|
152 /* StringKeyword */,
|
|
153 /* SymbolKeyword */,
|
|
110 /* TrueKeyword */,
|
|
114 /* VoidKeyword */,
|
|
155 /* UndefinedKeyword */,
|
|
156 /* UniqueKeyword */,
|
|
157 /* UnknownKeyword */
|
|
];
|
|
function isTypeKeyword(kind) {
|
|
return contains(typeKeywords, kind);
|
|
}
|
|
function isTypeKeywordToken(node) {
|
|
return node.kind === 154 /* TypeKeyword */;
|
|
}
|
|
function isTypeKeywordTokenOrIdentifier(node) {
|
|
return isTypeKeywordToken(node) || isIdentifier(node) && node.text === "type";
|
|
}
|
|
function isExternalModuleSymbol(moduleSymbol) {
|
|
return !!(moduleSymbol.flags & 1536 /* Module */) && moduleSymbol.name.charCodeAt(0) === 34 /* doubleQuote */;
|
|
}
|
|
function nodeSeenTracker() {
|
|
const seen = [];
|
|
return (node) => {
|
|
const id = getNodeId(node);
|
|
return !seen[id] && (seen[id] = true);
|
|
};
|
|
}
|
|
function getSnapshotText(snap) {
|
|
return snap.getText(0, snap.getLength());
|
|
}
|
|
function repeatString(str, count) {
|
|
let result = "";
|
|
for (let i = 0; i < count; i++) {
|
|
result += str;
|
|
}
|
|
return result;
|
|
}
|
|
function skipConstraint(type) {
|
|
return type.isTypeParameter() ? type.getConstraint() || type : type;
|
|
}
|
|
function getNameFromPropertyName(name) {
|
|
return name.kind === 164 /* ComputedPropertyName */ ? isStringOrNumericLiteralLike(name.expression) ? name.expression.text : void 0 : isPrivateIdentifier(name) ? idText(name) : getTextOfIdentifierOrLiteral(name);
|
|
}
|
|
function programContainsModules(program) {
|
|
return program.getSourceFiles().some((s) => !s.isDeclarationFile && !program.isSourceFileFromExternalLibrary(s) && !!(s.externalModuleIndicator || s.commonJsModuleIndicator));
|
|
}
|
|
function programContainsEsModules(program) {
|
|
return program.getSourceFiles().some((s) => !s.isDeclarationFile && !program.isSourceFileFromExternalLibrary(s) && !!s.externalModuleIndicator);
|
|
}
|
|
function compilerOptionsIndicateEsModules(compilerOptions) {
|
|
return !!compilerOptions.module || getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ || !!compilerOptions.noEmit;
|
|
}
|
|
function createModuleSpecifierResolutionHost(program, host) {
|
|
return {
|
|
fileExists: (fileName) => program.fileExists(fileName),
|
|
getCurrentDirectory: () => host.getCurrentDirectory(),
|
|
readFile: maybeBind(host, host.readFile),
|
|
useCaseSensitiveFileNames: maybeBind(host, host.useCaseSensitiveFileNames),
|
|
getSymlinkCache: maybeBind(host, host.getSymlinkCache) || program.getSymlinkCache,
|
|
getModuleSpecifierCache: maybeBind(host, host.getModuleSpecifierCache),
|
|
getPackageJsonInfoCache: () => {
|
|
var _a2;
|
|
return (_a2 = program.getModuleResolutionCache()) == null ? void 0 : _a2.getPackageJsonInfoCache();
|
|
},
|
|
getGlobalTypingsCacheLocation: maybeBind(host, host.getGlobalTypingsCacheLocation),
|
|
redirectTargetsMap: program.redirectTargetsMap,
|
|
getProjectReferenceRedirect: (fileName) => program.getProjectReferenceRedirect(fileName),
|
|
isSourceOfProjectReferenceRedirect: (fileName) => program.isSourceOfProjectReferenceRedirect(fileName),
|
|
getNearestAncestorDirectoryWithPackageJson: maybeBind(host, host.getNearestAncestorDirectoryWithPackageJson),
|
|
getFileIncludeReasons: () => program.getFileIncludeReasons()
|
|
};
|
|
}
|
|
function getModuleSpecifierResolverHost(program, host) {
|
|
return {
|
|
...createModuleSpecifierResolutionHost(program, host),
|
|
getCommonSourceDirectory: () => program.getCommonSourceDirectory()
|
|
};
|
|
}
|
|
function moduleResolutionRespectsExports(moduleResolution) {
|
|
return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */;
|
|
}
|
|
function moduleResolutionUsesNodeModules(moduleResolution) {
|
|
return moduleResolution === 2 /* NodeJs */ || moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */;
|
|
}
|
|
function makeImportIfNecessary(defaultImport, namedImports, moduleSpecifier, quotePreference) {
|
|
return defaultImport || namedImports && namedImports.length ? makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference) : void 0;
|
|
}
|
|
function makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference, isTypeOnly) {
|
|
return factory.createImportDeclaration(
|
|
void 0,
|
|
defaultImport || namedImports ? factory.createImportClause(!!isTypeOnly, defaultImport, namedImports && namedImports.length ? factory.createNamedImports(namedImports) : void 0) : void 0,
|
|
typeof moduleSpecifier === "string" ? makeStringLiteral(moduleSpecifier, quotePreference) : moduleSpecifier,
|
|
void 0
|
|
);
|
|
}
|
|
function makeStringLiteral(text, quotePreference) {
|
|
return factory.createStringLiteral(text, quotePreference === QuotePreference.Single);
|
|
}
|
|
var QuotePreference = /* @__PURE__ */ ((QuotePreference4) => {
|
|
QuotePreference4[QuotePreference4["Single"] = 0] = "Single";
|
|
QuotePreference4[QuotePreference4["Double"] = 1] = "Double";
|
|
return QuotePreference4;
|
|
})(QuotePreference || {});
|
|
function quotePreferenceFromString(str, sourceFile) {
|
|
return isStringDoubleQuoted(str, sourceFile) ? 1 /* Double */ : 0 /* Single */;
|
|
}
|
|
function getQuotePreference(sourceFile, preferences) {
|
|
if (preferences.quotePreference && preferences.quotePreference !== "auto") {
|
|
return preferences.quotePreference === "single" ? 0 /* Single */ : 1 /* Double */;
|
|
} else {
|
|
const firstModuleSpecifier = sourceFile.imports && find(sourceFile.imports, (n) => isStringLiteral(n) && !nodeIsSynthesized(n.parent));
|
|
return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : 1 /* Double */;
|
|
}
|
|
}
|
|
function getQuoteFromPreference(qp) {
|
|
switch (qp) {
|
|
case 0 /* Single */:
|
|
return "'";
|
|
case 1 /* Double */:
|
|
return '"';
|
|
default:
|
|
return Debug.assertNever(qp);
|
|
}
|
|
}
|
|
function symbolNameNoDefault(symbol) {
|
|
const escaped = symbolEscapedNameNoDefault(symbol);
|
|
return escaped === void 0 ? void 0 : unescapeLeadingUnderscores(escaped);
|
|
}
|
|
function symbolEscapedNameNoDefault(symbol) {
|
|
if (symbol.escapedName !== "default" /* Default */) {
|
|
return symbol.escapedName;
|
|
}
|
|
return firstDefined(symbol.declarations, (decl) => {
|
|
const name = getNameOfDeclaration(decl);
|
|
return name && name.kind === 79 /* Identifier */ ? name.escapedText : void 0;
|
|
});
|
|
}
|
|
function isModuleSpecifierLike(node) {
|
|
return isStringLiteralLike(node) && (isExternalModuleReference(node.parent) || isImportDeclaration(node.parent) || isRequireCall(node.parent, false) && node.parent.arguments[0] === node || isImportCall(node.parent) && node.parent.arguments[0] === node);
|
|
}
|
|
function isObjectBindingElementWithoutPropertyName(bindingElement) {
|
|
return isBindingElement(bindingElement) && isObjectBindingPattern(bindingElement.parent) && isIdentifier(bindingElement.name) && !bindingElement.propertyName;
|
|
}
|
|
function getPropertySymbolFromBindingElement(checker, bindingElement) {
|
|
const typeOfPattern = checker.getTypeAtLocation(bindingElement.parent);
|
|
return typeOfPattern && checker.getPropertyOfType(typeOfPattern, bindingElement.name.text);
|
|
}
|
|
function getParentNodeInSpan(node, file, span) {
|
|
if (!node)
|
|
return void 0;
|
|
while (node.parent) {
|
|
if (isSourceFile(node.parent) || !spanContainsNode(span, node.parent, file)) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
}
|
|
function spanContainsNode(span, node, file) {
|
|
return textSpanContainsPosition(span, node.getStart(file)) && node.getEnd() <= textSpanEnd(span);
|
|
}
|
|
function findModifier(node, kind) {
|
|
return canHaveModifiers(node) ? find(node.modifiers, (m) => m.kind === kind) : void 0;
|
|
}
|
|
function insertImports(changes, sourceFile, imports, blankLineBetween) {
|
|
const decl = isArray(imports) ? imports[0] : imports;
|
|
const importKindPredicate = decl.kind === 240 /* VariableStatement */ ? isRequireVariableStatement : isAnyImportSyntax;
|
|
const existingImportStatements = filter(sourceFile.statements, importKindPredicate);
|
|
const sortedNewImports = isArray(imports) ? stableSort(imports, ts_OrganizeImports_exports.compareImportsOrRequireStatements) : [imports];
|
|
if (!existingImportStatements.length) {
|
|
changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween);
|
|
} else if (existingImportStatements && ts_OrganizeImports_exports.importsAreSorted(existingImportStatements)) {
|
|
for (const newImport of sortedNewImports) {
|
|
const insertionIndex = ts_OrganizeImports_exports.getImportDeclarationInsertionIndex(existingImportStatements, newImport);
|
|
if (insertionIndex === 0) {
|
|
const options = existingImportStatements[0] === sourceFile.statements[0] ? { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude } : {};
|
|
changes.insertNodeBefore(sourceFile, existingImportStatements[0], newImport, false, options);
|
|
} else {
|
|
const prevImport = existingImportStatements[insertionIndex - 1];
|
|
changes.insertNodeAfter(sourceFile, prevImport, newImport);
|
|
}
|
|
}
|
|
} else {
|
|
const lastExistingImport = lastOrUndefined(existingImportStatements);
|
|
if (lastExistingImport) {
|
|
changes.insertNodesAfter(sourceFile, lastExistingImport, sortedNewImports);
|
|
} else {
|
|
changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween);
|
|
}
|
|
}
|
|
}
|
|
function getTypeKeywordOfTypeOnlyImport(importClause, sourceFile) {
|
|
Debug.assert(importClause.isTypeOnly);
|
|
return cast(importClause.getChildAt(0, sourceFile), isTypeKeywordToken);
|
|
}
|
|
function textSpansEqual(a, b) {
|
|
return !!a && !!b && a.start === b.start && a.length === b.length;
|
|
}
|
|
function documentSpansEqual(a, b) {
|
|
return a.fileName === b.fileName && textSpansEqual(a.textSpan, b.textSpan);
|
|
}
|
|
function forEachUnique(array, callback) {
|
|
if (array) {
|
|
for (let i = 0; i < array.length; i++) {
|
|
if (array.indexOf(array[i]) === i) {
|
|
const result = callback(array[i], i);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isTextWhiteSpaceLike(text, startPos, endPos) {
|
|
for (let i = startPos; i < endPos; i++) {
|
|
if (!isWhiteSpaceLike(text.charCodeAt(i))) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getMappedLocation(location2, sourceMapper, fileExists) {
|
|
const mapsTo = sourceMapper.tryGetSourcePosition(location2);
|
|
return mapsTo && (!fileExists || fileExists(normalizePath(mapsTo.fileName)) ? mapsTo : void 0);
|
|
}
|
|
function getMappedDocumentSpan(documentSpan, sourceMapper, fileExists) {
|
|
const { fileName, textSpan } = documentSpan;
|
|
const newPosition = getMappedLocation({ fileName, pos: textSpan.start }, sourceMapper, fileExists);
|
|
if (!newPosition)
|
|
return void 0;
|
|
const newEndPosition = getMappedLocation({ fileName, pos: textSpan.start + textSpan.length }, sourceMapper, fileExists);
|
|
const newLength = newEndPosition ? newEndPosition.pos - newPosition.pos : textSpan.length;
|
|
return {
|
|
fileName: newPosition.fileName,
|
|
textSpan: {
|
|
start: newPosition.pos,
|
|
length: newLength
|
|
},
|
|
originalFileName: documentSpan.fileName,
|
|
originalTextSpan: documentSpan.textSpan,
|
|
contextSpan: getMappedContextSpan(documentSpan, sourceMapper, fileExists),
|
|
originalContextSpan: documentSpan.contextSpan
|
|
};
|
|
}
|
|
function getMappedContextSpan(documentSpan, sourceMapper, fileExists) {
|
|
const contextSpanStart = documentSpan.contextSpan && getMappedLocation(
|
|
{ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start },
|
|
sourceMapper,
|
|
fileExists
|
|
);
|
|
const contextSpanEnd = documentSpan.contextSpan && getMappedLocation(
|
|
{ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start + documentSpan.contextSpan.length },
|
|
sourceMapper,
|
|
fileExists
|
|
);
|
|
return contextSpanStart && contextSpanEnd ? { start: contextSpanStart.pos, length: contextSpanEnd.pos - contextSpanStart.pos } : void 0;
|
|
}
|
|
function isFirstDeclarationOfSymbolParameter(symbol) {
|
|
const declaration = symbol.declarations ? firstOrUndefined(symbol.declarations) : void 0;
|
|
return !!findAncestor(declaration, (n) => isParameter(n) ? true : isBindingElement(n) || isObjectBindingPattern(n) || isArrayBindingPattern(n) ? false : "quit");
|
|
}
|
|
var displayPartWriter = getDisplayPartWriter();
|
|
function getDisplayPartWriter() {
|
|
const absoluteMaximumLength = defaultMaximumTruncationLength * 10;
|
|
let displayParts;
|
|
let lineStart;
|
|
let indent3;
|
|
let length2;
|
|
resetWriter();
|
|
const unknownWrite = (text) => writeKind(text, 17 /* text */);
|
|
return {
|
|
displayParts: () => {
|
|
const finalText = displayParts.length && displayParts[displayParts.length - 1].text;
|
|
if (length2 > absoluteMaximumLength && finalText && finalText !== "...") {
|
|
if (!isWhiteSpaceLike(finalText.charCodeAt(finalText.length - 1))) {
|
|
displayParts.push(displayPart(" ", 16 /* space */));
|
|
}
|
|
displayParts.push(displayPart("...", 15 /* punctuation */));
|
|
}
|
|
return displayParts;
|
|
},
|
|
writeKeyword: (text) => writeKind(text, 5 /* keyword */),
|
|
writeOperator: (text) => writeKind(text, 12 /* operator */),
|
|
writePunctuation: (text) => writeKind(text, 15 /* punctuation */),
|
|
writeTrailingSemicolon: (text) => writeKind(text, 15 /* punctuation */),
|
|
writeSpace: (text) => writeKind(text, 16 /* space */),
|
|
writeStringLiteral: (text) => writeKind(text, 8 /* stringLiteral */),
|
|
writeParameter: (text) => writeKind(text, 13 /* parameterName */),
|
|
writeProperty: (text) => writeKind(text, 14 /* propertyName */),
|
|
writeLiteral: (text) => writeKind(text, 8 /* stringLiteral */),
|
|
writeSymbol,
|
|
writeLine,
|
|
write: unknownWrite,
|
|
writeComment: unknownWrite,
|
|
getText: () => "",
|
|
getTextPos: () => 0,
|
|
getColumn: () => 0,
|
|
getLine: () => 0,
|
|
isAtStartOfLine: () => false,
|
|
hasTrailingWhitespace: () => false,
|
|
hasTrailingComment: () => false,
|
|
rawWrite: notImplemented,
|
|
getIndent: () => indent3,
|
|
increaseIndent: () => {
|
|
indent3++;
|
|
},
|
|
decreaseIndent: () => {
|
|
indent3--;
|
|
},
|
|
clear: resetWriter,
|
|
trackSymbol: () => false,
|
|
reportInaccessibleThisError: noop,
|
|
reportInaccessibleUniqueSymbolError: noop,
|
|
reportPrivateInBaseOfClassExpression: noop
|
|
};
|
|
function writeIndent() {
|
|
if (length2 > absoluteMaximumLength)
|
|
return;
|
|
if (lineStart) {
|
|
const indentString = getIndentString(indent3);
|
|
if (indentString) {
|
|
length2 += indentString.length;
|
|
displayParts.push(displayPart(indentString, 16 /* space */));
|
|
}
|
|
lineStart = false;
|
|
}
|
|
}
|
|
function writeKind(text, kind) {
|
|
if (length2 > absoluteMaximumLength)
|
|
return;
|
|
writeIndent();
|
|
length2 += text.length;
|
|
displayParts.push(displayPart(text, kind));
|
|
}
|
|
function writeSymbol(text, symbol) {
|
|
if (length2 > absoluteMaximumLength)
|
|
return;
|
|
writeIndent();
|
|
length2 += text.length;
|
|
displayParts.push(symbolPart(text, symbol));
|
|
}
|
|
function writeLine() {
|
|
if (length2 > absoluteMaximumLength)
|
|
return;
|
|
length2 += 1;
|
|
displayParts.push(lineBreakPart());
|
|
lineStart = true;
|
|
}
|
|
function resetWriter() {
|
|
displayParts = [];
|
|
lineStart = true;
|
|
indent3 = 0;
|
|
length2 = 0;
|
|
}
|
|
}
|
|
function symbolPart(text, symbol) {
|
|
return displayPart(text, displayPartKind(symbol));
|
|
function displayPartKind(symbol2) {
|
|
const flags = symbol2.flags;
|
|
if (flags & 3 /* Variable */) {
|
|
return isFirstDeclarationOfSymbolParameter(symbol2) ? 13 /* parameterName */ : 9 /* localName */;
|
|
}
|
|
if (flags & 4 /* Property */)
|
|
return 14 /* propertyName */;
|
|
if (flags & 32768 /* GetAccessor */)
|
|
return 14 /* propertyName */;
|
|
if (flags & 65536 /* SetAccessor */)
|
|
return 14 /* propertyName */;
|
|
if (flags & 8 /* EnumMember */)
|
|
return 19 /* enumMemberName */;
|
|
if (flags & 16 /* Function */)
|
|
return 20 /* functionName */;
|
|
if (flags & 32 /* Class */)
|
|
return 1 /* className */;
|
|
if (flags & 64 /* Interface */)
|
|
return 4 /* interfaceName */;
|
|
if (flags & 384 /* Enum */)
|
|
return 2 /* enumName */;
|
|
if (flags & 1536 /* Module */)
|
|
return 11 /* moduleName */;
|
|
if (flags & 8192 /* Method */)
|
|
return 10 /* methodName */;
|
|
if (flags & 262144 /* TypeParameter */)
|
|
return 18 /* typeParameterName */;
|
|
if (flags & 524288 /* TypeAlias */)
|
|
return 0 /* aliasName */;
|
|
if (flags & 2097152 /* Alias */)
|
|
return 0 /* aliasName */;
|
|
return 17 /* text */;
|
|
}
|
|
}
|
|
function displayPart(text, kind) {
|
|
return { text, kind: SymbolDisplayPartKind[kind] };
|
|
}
|
|
function spacePart() {
|
|
return displayPart(" ", 16 /* space */);
|
|
}
|
|
function keywordPart(kind) {
|
|
return displayPart(tokenToString(kind), 5 /* keyword */);
|
|
}
|
|
function punctuationPart(kind) {
|
|
return displayPart(tokenToString(kind), 15 /* punctuation */);
|
|
}
|
|
function operatorPart(kind) {
|
|
return displayPart(tokenToString(kind), 12 /* operator */);
|
|
}
|
|
function parameterNamePart(text) {
|
|
return displayPart(text, 13 /* parameterName */);
|
|
}
|
|
function propertyNamePart(text) {
|
|
return displayPart(text, 14 /* propertyName */);
|
|
}
|
|
function textOrKeywordPart(text) {
|
|
const kind = stringToToken(text);
|
|
return kind === void 0 ? textPart(text) : keywordPart(kind);
|
|
}
|
|
function textPart(text) {
|
|
return displayPart(text, 17 /* text */);
|
|
}
|
|
function typeAliasNamePart(text) {
|
|
return displayPart(text, 0 /* aliasName */);
|
|
}
|
|
function typeParameterNamePart(text) {
|
|
return displayPart(text, 18 /* typeParameterName */);
|
|
}
|
|
function linkTextPart(text) {
|
|
return displayPart(text, 24 /* linkText */);
|
|
}
|
|
function linkNamePart(text, target) {
|
|
return {
|
|
text,
|
|
kind: SymbolDisplayPartKind[23 /* linkName */],
|
|
target: {
|
|
fileName: getSourceFileOfNode(target).fileName,
|
|
textSpan: createTextSpanFromNode(target)
|
|
}
|
|
};
|
|
}
|
|
function linkPart(text) {
|
|
return displayPart(text, 22 /* link */);
|
|
}
|
|
function buildLinkParts(link, checker) {
|
|
var _a2;
|
|
const prefix = isJSDocLink(link) ? "link" : isJSDocLinkCode(link) ? "linkcode" : "linkplain";
|
|
const parts = [linkPart(`{@${prefix} `)];
|
|
if (!link.name) {
|
|
if (link.text) {
|
|
parts.push(linkTextPart(link.text));
|
|
}
|
|
} else {
|
|
const symbol = checker == null ? void 0 : checker.getSymbolAtLocation(link.name);
|
|
const suffix = findLinkNameEnd(link.text);
|
|
const name = getTextOfNode(link.name) + link.text.slice(0, suffix);
|
|
const text = skipSeparatorFromLinkText(link.text.slice(suffix));
|
|
const decl = (symbol == null ? void 0 : symbol.valueDeclaration) || ((_a2 = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a2[0]);
|
|
if (decl) {
|
|
parts.push(linkNamePart(name, decl));
|
|
if (text)
|
|
parts.push(linkTextPart(text));
|
|
} else {
|
|
parts.push(linkTextPart(name + (suffix || text.indexOf("://") === 0 ? "" : " ") + text));
|
|
}
|
|
}
|
|
parts.push(linkPart("}"));
|
|
return parts;
|
|
}
|
|
function skipSeparatorFromLinkText(text) {
|
|
let pos = 0;
|
|
if (text.charCodeAt(pos++) === 124 /* bar */) {
|
|
while (pos < text.length && text.charCodeAt(pos) === 32 /* space */)
|
|
pos++;
|
|
return text.slice(pos);
|
|
}
|
|
return text;
|
|
}
|
|
function findLinkNameEnd(text) {
|
|
if (text.indexOf("()") === 0)
|
|
return 2;
|
|
if (text[0] !== "<")
|
|
return 0;
|
|
let brackets2 = 0;
|
|
let i = 0;
|
|
while (i < text.length) {
|
|
if (text[i] === "<")
|
|
brackets2++;
|
|
if (text[i] === ">")
|
|
brackets2--;
|
|
i++;
|
|
if (!brackets2)
|
|
return i;
|
|
}
|
|
return 0;
|
|
}
|
|
var carriageReturnLineFeed2 = "\r\n";
|
|
function getNewLineOrDefaultFromHost(host, formatSettings) {
|
|
var _a2;
|
|
return (formatSettings == null ? void 0 : formatSettings.newLineCharacter) || ((_a2 = host.getNewLine) == null ? void 0 : _a2.call(host)) || carriageReturnLineFeed2;
|
|
}
|
|
function lineBreakPart() {
|
|
return displayPart("\n", 6 /* lineBreak */);
|
|
}
|
|
function mapToDisplayParts(writeDisplayParts) {
|
|
try {
|
|
writeDisplayParts(displayPartWriter);
|
|
return displayPartWriter.displayParts();
|
|
} finally {
|
|
displayPartWriter.clear();
|
|
}
|
|
}
|
|
function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags = 0 /* None */) {
|
|
return mapToDisplayParts((writer) => {
|
|
typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */ | 16384 /* UseAliasDefinedOutsideCurrentScope */, writer);
|
|
});
|
|
}
|
|
function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags = 0 /* None */) {
|
|
return mapToDisplayParts((writer) => {
|
|
typeChecker.writeSymbol(symbol, enclosingDeclaration, meaning, flags | 8 /* UseAliasDefinedOutsideCurrentScope */, writer);
|
|
});
|
|
}
|
|
function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags = 0 /* None */) {
|
|
flags |= 16384 /* UseAliasDefinedOutsideCurrentScope */ | 1024 /* MultilineObjectLiterals */ | 32 /* WriteTypeArgumentsOfSignature */ | 8192 /* OmitParameterModifiers */;
|
|
return mapToDisplayParts((writer) => {
|
|
typechecker.writeSignature(signature, enclosingDeclaration, flags, void 0, writer);
|
|
});
|
|
}
|
|
function nodeToDisplayParts(node, enclosingDeclaration) {
|
|
const file = enclosingDeclaration.getSourceFile();
|
|
return mapToDisplayParts((writer) => {
|
|
const printer = createPrinter({ removeComments: true, omitTrailingSemicolon: true });
|
|
printer.writeNode(4 /* Unspecified */, node, file, writer);
|
|
});
|
|
}
|
|
function isImportOrExportSpecifierName(location2) {
|
|
return !!location2.parent && isImportOrExportSpecifier(location2.parent) && location2.parent.propertyName === location2;
|
|
}
|
|
function getScriptKind(fileName, host) {
|
|
return ensureScriptKind(fileName, host.getScriptKind && host.getScriptKind(fileName));
|
|
}
|
|
function getSymbolTarget(symbol, checker) {
|
|
let next = symbol;
|
|
while (isAliasSymbol(next) || isTransientSymbol2(next) && next.target) {
|
|
if (isTransientSymbol2(next) && next.target) {
|
|
next = next.target;
|
|
} else {
|
|
next = skipAlias(next, checker);
|
|
}
|
|
}
|
|
return next;
|
|
}
|
|
function isTransientSymbol2(symbol) {
|
|
return (symbol.flags & 33554432 /* Transient */) !== 0;
|
|
}
|
|
function isAliasSymbol(symbol) {
|
|
return (symbol.flags & 2097152 /* Alias */) !== 0;
|
|
}
|
|
function getUniqueSymbolId(symbol, checker) {
|
|
return getSymbolId(skipAlias(symbol, checker));
|
|
}
|
|
function getFirstNonSpaceCharacterPosition(text, position) {
|
|
while (isWhiteSpaceLike(text.charCodeAt(position))) {
|
|
position += 1;
|
|
}
|
|
return position;
|
|
}
|
|
function getPrecedingNonSpaceCharacterPosition(text, position) {
|
|
while (position > -1 && isWhiteSpaceSingleLine(text.charCodeAt(position))) {
|
|
position -= 1;
|
|
}
|
|
return position + 1;
|
|
}
|
|
function getSynthesizedDeepClone(node, includeTrivia = true) {
|
|
const clone2 = node && getSynthesizedDeepCloneWorker(node);
|
|
if (clone2 && !includeTrivia)
|
|
suppressLeadingAndTrailingTrivia(clone2);
|
|
return clone2;
|
|
}
|
|
function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) {
|
|
let clone2 = replaceNode(node);
|
|
if (clone2) {
|
|
setOriginalNode(clone2, node);
|
|
} else {
|
|
clone2 = getSynthesizedDeepCloneWorker(node, replaceNode);
|
|
}
|
|
if (clone2 && !includeTrivia)
|
|
suppressLeadingAndTrailingTrivia(clone2);
|
|
return clone2;
|
|
}
|
|
function getSynthesizedDeepCloneWorker(node, replaceNode) {
|
|
const nodeClone = replaceNode ? (n) => getSynthesizedDeepCloneWithReplacements(n, true, replaceNode) : getSynthesizedDeepClone;
|
|
const nodesClone = replaceNode ? (ns) => ns && getSynthesizedDeepClonesWithReplacements(ns, true, replaceNode) : (ns) => ns && getSynthesizedDeepClones(ns);
|
|
const visited = visitEachChild(node, nodeClone, nullTransformationContext, nodesClone, nodeClone);
|
|
if (visited === node) {
|
|
const clone2 = isStringLiteral(node) ? setOriginalNode(factory.createStringLiteralFromNode(node), node) : isNumericLiteral(node) ? setOriginalNode(factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : factory.cloneNode(node);
|
|
return setTextRange(clone2, node);
|
|
}
|
|
visited.parent = void 0;
|
|
return visited;
|
|
}
|
|
function getSynthesizedDeepClones(nodes, includeTrivia = true) {
|
|
return nodes && factory.createNodeArray(nodes.map((n) => getSynthesizedDeepClone(n, includeTrivia)), nodes.hasTrailingComma);
|
|
}
|
|
function getSynthesizedDeepClonesWithReplacements(nodes, includeTrivia, replaceNode) {
|
|
return factory.createNodeArray(nodes.map((n) => getSynthesizedDeepCloneWithReplacements(n, includeTrivia, replaceNode)), nodes.hasTrailingComma);
|
|
}
|
|
function suppressLeadingAndTrailingTrivia(node) {
|
|
suppressLeadingTrivia(node);
|
|
suppressTrailingTrivia(node);
|
|
}
|
|
function suppressLeadingTrivia(node) {
|
|
addEmitFlagsRecursively(node, 1024 /* NoLeadingComments */, getFirstChild);
|
|
}
|
|
function suppressTrailingTrivia(node) {
|
|
addEmitFlagsRecursively(node, 2048 /* NoTrailingComments */, getLastChild);
|
|
}
|
|
function copyComments(sourceNode, targetNode) {
|
|
const sourceFile = sourceNode.getSourceFile();
|
|
const text = sourceFile.text;
|
|
if (hasLeadingLineBreak(sourceNode, text)) {
|
|
copyLeadingComments(sourceNode, targetNode, sourceFile);
|
|
} else {
|
|
copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile);
|
|
}
|
|
copyTrailingComments(sourceNode, targetNode, sourceFile);
|
|
}
|
|
function hasLeadingLineBreak(node, text) {
|
|
const start2 = node.getFullStart();
|
|
const end = node.getStart();
|
|
for (let i = start2; i < end; i++) {
|
|
if (text.charCodeAt(i) === 10 /* lineFeed */)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function addEmitFlagsRecursively(node, flag, getChild) {
|
|
addEmitFlags(node, flag);
|
|
const child = getChild(node);
|
|
if (child)
|
|
addEmitFlagsRecursively(child, flag, getChild);
|
|
}
|
|
function getFirstChild(node) {
|
|
return node.forEachChild((child) => child);
|
|
}
|
|
function getUniqueName(baseName, sourceFile) {
|
|
let nameText = baseName;
|
|
for (let i = 1; !isFileLevelUniqueName(sourceFile, nameText); i++) {
|
|
nameText = `${baseName}_${i}`;
|
|
}
|
|
return nameText;
|
|
}
|
|
function getRenameLocation(edits, renameFilename, name, preferLastLocation) {
|
|
let delta = 0;
|
|
let lastPos = -1;
|
|
for (const { fileName, textChanges: textChanges2 } of edits) {
|
|
Debug.assert(fileName === renameFilename);
|
|
for (const change of textChanges2) {
|
|
const { span, newText } = change;
|
|
const index = indexInTextChange(newText, escapeString(name));
|
|
if (index !== -1) {
|
|
lastPos = span.start + delta + index;
|
|
if (!preferLastLocation) {
|
|
return lastPos;
|
|
}
|
|
}
|
|
delta += newText.length - span.length;
|
|
}
|
|
}
|
|
Debug.assert(preferLastLocation);
|
|
Debug.assert(lastPos >= 0);
|
|
return lastPos;
|
|
}
|
|
function copyLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
|
|
forEachLeadingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticLeadingComment));
|
|
}
|
|
function copyTrailingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
|
|
forEachTrailingCommentRange(sourceFile.text, sourceNode.end, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticTrailingComment));
|
|
}
|
|
function copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) {
|
|
forEachTrailingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, addSyntheticLeadingComment));
|
|
}
|
|
function getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, cb) {
|
|
return (pos, end, kind, htnl) => {
|
|
if (kind === 3 /* MultiLineCommentTrivia */) {
|
|
pos += 2;
|
|
end -= 2;
|
|
} else {
|
|
pos += 2;
|
|
}
|
|
cb(targetNode, commentKind || kind, sourceFile.text.slice(pos, end), hasTrailingNewLine !== void 0 ? hasTrailingNewLine : htnl);
|
|
};
|
|
}
|
|
function indexInTextChange(change, name) {
|
|
if (startsWith(change, name))
|
|
return 0;
|
|
let idx = change.indexOf(" " + name);
|
|
if (idx === -1)
|
|
idx = change.indexOf("." + name);
|
|
if (idx === -1)
|
|
idx = change.indexOf('"' + name);
|
|
return idx === -1 ? -1 : idx + 1;
|
|
}
|
|
function needsParentheses(expression) {
|
|
return isBinaryExpression(expression) && expression.operatorToken.kind === 27 /* CommaToken */ || isObjectLiteralExpression(expression) || isAsExpression(expression) && isObjectLiteralExpression(expression.expression);
|
|
}
|
|
function getContextualTypeFromParent(node, checker) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 211 /* NewExpression */:
|
|
return checker.getContextualType(parent2);
|
|
case 223 /* BinaryExpression */: {
|
|
const { left, operatorToken, right } = parent2;
|
|
return isEqualityOperatorKind(operatorToken.kind) ? checker.getTypeAtLocation(node === right ? left : right) : checker.getContextualType(node);
|
|
}
|
|
case 292 /* CaseClause */:
|
|
return parent2.expression === node ? getSwitchedType(parent2, checker) : void 0;
|
|
default:
|
|
return checker.getContextualType(node);
|
|
}
|
|
}
|
|
function quote(sourceFile, preferences, text) {
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
const quoted = JSON.stringify(text);
|
|
return quotePreference === 0 /* Single */ ? `'${stripQuotes(quoted).replace(/'/g, "\\'").replace(/\\"/g, '"')}'` : quoted;
|
|
}
|
|
function isEqualityOperatorKind(kind) {
|
|
switch (kind) {
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isStringLiteralOrTemplate(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function hasIndexSignature(type) {
|
|
return !!type.getStringIndexType() || !!type.getNumberIndexType();
|
|
}
|
|
function getSwitchedType(caseClause, checker) {
|
|
return checker.getTypeAtLocation(caseClause.parent.parent.expression);
|
|
}
|
|
var ANONYMOUS = "anonymous function";
|
|
function getTypeNodeIfAccessible(type, enclosingScope, program, host) {
|
|
const checker = program.getTypeChecker();
|
|
let typeIsAccessible = true;
|
|
const notAccessible = () => typeIsAccessible = false;
|
|
const res = checker.typeToTypeNode(type, enclosingScope, 1 /* NoTruncation */, {
|
|
trackSymbol: (symbol, declaration, meaning) => {
|
|
typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(symbol, declaration, meaning, false).accessibility === 0 /* Accessible */;
|
|
return !typeIsAccessible;
|
|
},
|
|
reportInaccessibleThisError: notAccessible,
|
|
reportPrivateInBaseOfClassExpression: notAccessible,
|
|
reportInaccessibleUniqueSymbolError: notAccessible,
|
|
moduleResolverHost: getModuleSpecifierResolverHost(program, host)
|
|
});
|
|
return typeIsAccessible ? res : void 0;
|
|
}
|
|
function syntaxRequiresTrailingCommaOrSemicolonOrASI(kind) {
|
|
return kind === 176 /* CallSignature */ || kind === 177 /* ConstructSignature */ || kind === 178 /* IndexSignature */ || kind === 168 /* PropertySignature */ || kind === 170 /* MethodSignature */;
|
|
}
|
|
function syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI(kind) {
|
|
return kind === 259 /* FunctionDeclaration */ || kind === 173 /* Constructor */ || kind === 171 /* MethodDeclaration */ || kind === 174 /* GetAccessor */ || kind === 175 /* SetAccessor */;
|
|
}
|
|
function syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(kind) {
|
|
return kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function syntaxRequiresTrailingSemicolonOrASI(kind) {
|
|
return kind === 240 /* VariableStatement */ || kind === 241 /* ExpressionStatement */ || kind === 243 /* DoStatement */ || kind === 248 /* ContinueStatement */ || kind === 249 /* BreakStatement */ || kind === 250 /* ReturnStatement */ || kind === 254 /* ThrowStatement */ || kind === 256 /* DebuggerStatement */ || kind === 169 /* PropertyDeclaration */ || kind === 262 /* TypeAliasDeclaration */ || kind === 269 /* ImportDeclaration */ || kind === 268 /* ImportEqualsDeclaration */ || kind === 275 /* ExportDeclaration */ || kind === 267 /* NamespaceExportDeclaration */ || kind === 274 /* ExportAssignment */;
|
|
}
|
|
var syntaxMayBeASICandidate = or(
|
|
syntaxRequiresTrailingCommaOrSemicolonOrASI,
|
|
syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI,
|
|
syntaxRequiresTrailingModuleBlockOrSemicolonOrASI,
|
|
syntaxRequiresTrailingSemicolonOrASI
|
|
);
|
|
function nodeIsASICandidate(node, sourceFile) {
|
|
const lastToken = node.getLastToken(sourceFile);
|
|
if (lastToken && lastToken.kind === 26 /* SemicolonToken */) {
|
|
return false;
|
|
}
|
|
if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) {
|
|
if (lastToken && lastToken.kind === 27 /* CommaToken */) {
|
|
return false;
|
|
}
|
|
} else if (syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(node.kind)) {
|
|
const lastChild = last(node.getChildren(sourceFile));
|
|
if (lastChild && isModuleBlock(lastChild)) {
|
|
return false;
|
|
}
|
|
} else if (syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI(node.kind)) {
|
|
const lastChild = last(node.getChildren(sourceFile));
|
|
if (lastChild && isFunctionBlock(lastChild)) {
|
|
return false;
|
|
}
|
|
} else if (!syntaxRequiresTrailingSemicolonOrASI(node.kind)) {
|
|
return false;
|
|
}
|
|
if (node.kind === 243 /* DoStatement */) {
|
|
return true;
|
|
}
|
|
const topNode = findAncestor(node, (ancestor) => !ancestor.parent);
|
|
const nextToken = findNextToken(node, topNode, sourceFile);
|
|
if (!nextToken || nextToken.kind === 19 /* CloseBraceToken */) {
|
|
return true;
|
|
}
|
|
const startLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
|
|
const endLine = sourceFile.getLineAndCharacterOfPosition(nextToken.getStart(sourceFile)).line;
|
|
return startLine !== endLine;
|
|
}
|
|
function positionIsASICandidate(pos, context, sourceFile) {
|
|
const contextAncestor = findAncestor(context, (ancestor) => {
|
|
if (ancestor.end !== pos) {
|
|
return "quit";
|
|
}
|
|
return syntaxMayBeASICandidate(ancestor.kind);
|
|
});
|
|
return !!contextAncestor && nodeIsASICandidate(contextAncestor, sourceFile);
|
|
}
|
|
function probablyUsesSemicolons(sourceFile) {
|
|
let withSemicolon = 0;
|
|
let withoutSemicolon = 0;
|
|
const nStatementsToObserve = 5;
|
|
forEachChild(sourceFile, function visit(node) {
|
|
if (syntaxRequiresTrailingSemicolonOrASI(node.kind)) {
|
|
const lastToken = node.getLastToken(sourceFile);
|
|
if ((lastToken == null ? void 0 : lastToken.kind) === 26 /* SemicolonToken */) {
|
|
withSemicolon++;
|
|
} else {
|
|
withoutSemicolon++;
|
|
}
|
|
} else if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) {
|
|
const lastToken = node.getLastToken(sourceFile);
|
|
if ((lastToken == null ? void 0 : lastToken.kind) === 26 /* SemicolonToken */) {
|
|
withSemicolon++;
|
|
} else if (lastToken && lastToken.kind !== 27 /* CommaToken */) {
|
|
const lastTokenLine = getLineAndCharacterOfPosition(sourceFile, lastToken.getStart(sourceFile)).line;
|
|
const nextTokenLine = getLineAndCharacterOfPosition(sourceFile, getSpanOfTokenAtPosition(sourceFile, lastToken.end).start).line;
|
|
if (lastTokenLine !== nextTokenLine) {
|
|
withoutSemicolon++;
|
|
}
|
|
}
|
|
}
|
|
if (withSemicolon + withoutSemicolon >= nStatementsToObserve) {
|
|
return true;
|
|
}
|
|
return forEachChild(node, visit);
|
|
});
|
|
if (withSemicolon === 0 && withoutSemicolon <= 1) {
|
|
return true;
|
|
}
|
|
return withSemicolon / withoutSemicolon > 1 / nStatementsToObserve;
|
|
}
|
|
function tryGetDirectories(host, directoryName) {
|
|
return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || [];
|
|
}
|
|
function tryReadDirectory(host, path, extensions, exclude, include) {
|
|
return tryIOAndConsumeErrors(host, host.readDirectory, path, extensions, exclude, include) || emptyArray;
|
|
}
|
|
function tryFileExists(host, path) {
|
|
return tryIOAndConsumeErrors(host, host.fileExists, path);
|
|
}
|
|
function tryDirectoryExists(host, path) {
|
|
return tryAndIgnoreErrors(() => directoryProbablyExists(path, host)) || false;
|
|
}
|
|
function tryAndIgnoreErrors(cb) {
|
|
try {
|
|
return cb();
|
|
} catch (e) {
|
|
return void 0;
|
|
}
|
|
}
|
|
function tryIOAndConsumeErrors(host, toApply, ...args) {
|
|
return tryAndIgnoreErrors(() => toApply && toApply.apply(host, args));
|
|
}
|
|
function findPackageJsons(startDirectory, host, stopDirectory) {
|
|
const paths = [];
|
|
forEachAncestorDirectory(startDirectory, (ancestor) => {
|
|
if (ancestor === stopDirectory) {
|
|
return true;
|
|
}
|
|
const currentConfigPath = combinePaths(ancestor, "package.json");
|
|
if (tryFileExists(host, currentConfigPath)) {
|
|
paths.push(currentConfigPath);
|
|
}
|
|
});
|
|
return paths;
|
|
}
|
|
function findPackageJson(directory, host) {
|
|
let packageJson;
|
|
forEachAncestorDirectory(directory, (ancestor) => {
|
|
if (ancestor === "node_modules")
|
|
return true;
|
|
packageJson = findConfigFile(ancestor, (f) => tryFileExists(host, f), "package.json");
|
|
if (packageJson) {
|
|
return true;
|
|
}
|
|
});
|
|
return packageJson;
|
|
}
|
|
function getPackageJsonsVisibleToFile(fileName, host) {
|
|
if (!host.fileExists) {
|
|
return [];
|
|
}
|
|
const packageJsons = [];
|
|
forEachAncestorDirectory(getDirectoryPath(fileName), (ancestor) => {
|
|
const packageJsonFileName = combinePaths(ancestor, "package.json");
|
|
if (host.fileExists(packageJsonFileName)) {
|
|
const info = createPackageJsonInfo(packageJsonFileName, host);
|
|
if (info) {
|
|
packageJsons.push(info);
|
|
}
|
|
}
|
|
});
|
|
return packageJsons;
|
|
}
|
|
function createPackageJsonInfo(fileName, host) {
|
|
if (!host.readFile) {
|
|
return void 0;
|
|
}
|
|
const dependencyKeys = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
|
|
const stringContent = host.readFile(fileName) || "";
|
|
const content = tryParseJson(stringContent);
|
|
const info = {};
|
|
if (content) {
|
|
for (const key of dependencyKeys) {
|
|
const dependencies = content[key];
|
|
if (!dependencies) {
|
|
continue;
|
|
}
|
|
const dependencyMap = /* @__PURE__ */ new Map();
|
|
for (const packageName in dependencies) {
|
|
dependencyMap.set(packageName, dependencies[packageName]);
|
|
}
|
|
info[key] = dependencyMap;
|
|
}
|
|
}
|
|
const dependencyGroups = [
|
|
[1 /* Dependencies */, info.dependencies],
|
|
[2 /* DevDependencies */, info.devDependencies],
|
|
[8 /* OptionalDependencies */, info.optionalDependencies],
|
|
[4 /* PeerDependencies */, info.peerDependencies]
|
|
];
|
|
return {
|
|
...info,
|
|
parseable: !!content,
|
|
fileName,
|
|
get,
|
|
has(dependencyName, inGroups) {
|
|
return !!get(dependencyName, inGroups);
|
|
}
|
|
};
|
|
function get(dependencyName, inGroups = 15 /* All */) {
|
|
for (const [group2, deps] of dependencyGroups) {
|
|
if (deps && inGroups & group2) {
|
|
const dep = deps.get(dependencyName);
|
|
if (dep !== void 0) {
|
|
return dep;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createPackageJsonImportFilter(fromFile, preferences, host) {
|
|
const packageJsons = (host.getPackageJsonsVisibleToFile && host.getPackageJsonsVisibleToFile(fromFile.fileName) || getPackageJsonsVisibleToFile(fromFile.fileName, host)).filter((p) => p.parseable);
|
|
let usesNodeCoreModules;
|
|
return { allowsImportingAmbientModule, allowsImportingSourceFile, allowsImportingSpecifier };
|
|
function moduleSpecifierIsCoveredByPackageJson(specifier) {
|
|
const packageName = getNodeModuleRootSpecifier(specifier);
|
|
for (const packageJson of packageJsons) {
|
|
if (packageJson.has(packageName) || packageJson.has(getTypesPackageName(packageName))) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost) {
|
|
if (!packageJsons.length || !moduleSymbol.valueDeclaration) {
|
|
return true;
|
|
}
|
|
const declaringSourceFile = moduleSymbol.valueDeclaration.getSourceFile();
|
|
const declaringNodeModuleName = getNodeModulesPackageNameFromFileName(declaringSourceFile.fileName, moduleSpecifierResolutionHost);
|
|
if (typeof declaringNodeModuleName === "undefined") {
|
|
return true;
|
|
}
|
|
const declaredModuleSpecifier = stripQuotes(moduleSymbol.getName());
|
|
if (isAllowedCoreNodeModulesImport(declaredModuleSpecifier)) {
|
|
return true;
|
|
}
|
|
return moduleSpecifierIsCoveredByPackageJson(declaringNodeModuleName) || moduleSpecifierIsCoveredByPackageJson(declaredModuleSpecifier);
|
|
}
|
|
function allowsImportingSourceFile(sourceFile, moduleSpecifierResolutionHost) {
|
|
if (!packageJsons.length) {
|
|
return true;
|
|
}
|
|
const moduleSpecifier = getNodeModulesPackageNameFromFileName(sourceFile.fileName, moduleSpecifierResolutionHost);
|
|
if (!moduleSpecifier) {
|
|
return true;
|
|
}
|
|
return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier);
|
|
}
|
|
function allowsImportingSpecifier(moduleSpecifier) {
|
|
if (!packageJsons.length || isAllowedCoreNodeModulesImport(moduleSpecifier)) {
|
|
return true;
|
|
}
|
|
if (pathIsRelative(moduleSpecifier) || isRootedDiskPath(moduleSpecifier)) {
|
|
return true;
|
|
}
|
|
return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier);
|
|
}
|
|
function isAllowedCoreNodeModulesImport(moduleSpecifier) {
|
|
if (isSourceFileJS(fromFile) && ts_JsTyping_exports.nodeCoreModules.has(moduleSpecifier)) {
|
|
if (usesNodeCoreModules === void 0) {
|
|
usesNodeCoreModules = consumesNodeCoreModules(fromFile);
|
|
}
|
|
if (usesNodeCoreModules) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) {
|
|
if (!stringContains(importedFileName, "node_modules")) {
|
|
return void 0;
|
|
}
|
|
const specifier = ts_moduleSpecifiers_exports.getNodeModulesPackageName(
|
|
host.getCompilationSettings(),
|
|
fromFile,
|
|
importedFileName,
|
|
moduleSpecifierResolutionHost,
|
|
preferences
|
|
);
|
|
if (!specifier) {
|
|
return void 0;
|
|
}
|
|
if (!pathIsRelative(specifier) && !isRootedDiskPath(specifier)) {
|
|
return getNodeModuleRootSpecifier(specifier);
|
|
}
|
|
}
|
|
function getNodeModuleRootSpecifier(fullSpecifier) {
|
|
const components = getPathComponents(getPackageNameFromTypesPackageName(fullSpecifier)).slice(1);
|
|
if (startsWith(components[0], "@")) {
|
|
return `${components[0]}/${components[1]}`;
|
|
}
|
|
return components[0];
|
|
}
|
|
}
|
|
function tryParseJson(text) {
|
|
try {
|
|
return JSON.parse(text);
|
|
} catch (e) {
|
|
return void 0;
|
|
}
|
|
}
|
|
function consumesNodeCoreModules(sourceFile) {
|
|
return some(sourceFile.imports, ({ text }) => ts_JsTyping_exports.nodeCoreModules.has(text));
|
|
}
|
|
function isInsideNodeModules(fileOrDirectory) {
|
|
return contains(getPathComponents(fileOrDirectory), "node_modules");
|
|
}
|
|
function isDiagnosticWithLocation(diagnostic) {
|
|
return diagnostic.file !== void 0 && diagnostic.start !== void 0 && diagnostic.length !== void 0;
|
|
}
|
|
function findDiagnosticForNode(node, sortedFileDiagnostics) {
|
|
const span = createTextSpanFromNode(node);
|
|
const index = binarySearchKey(sortedFileDiagnostics, span, identity, compareTextSpans);
|
|
if (index >= 0) {
|
|
const diagnostic = sortedFileDiagnostics[index];
|
|
Debug.assertEqual(diagnostic.file, node.getSourceFile(), "Diagnostics proided to 'findDiagnosticForNode' must be from a single SourceFile");
|
|
return cast(diagnostic, isDiagnosticWithLocation);
|
|
}
|
|
}
|
|
function getDiagnosticsWithinSpan(span, sortedFileDiagnostics) {
|
|
var _a2;
|
|
let index = binarySearchKey(sortedFileDiagnostics, span.start, (diag2) => diag2.start, compareValues);
|
|
if (index < 0) {
|
|
index = ~index;
|
|
}
|
|
while (((_a2 = sortedFileDiagnostics[index - 1]) == null ? void 0 : _a2.start) === span.start) {
|
|
index--;
|
|
}
|
|
const result = [];
|
|
const end = textSpanEnd(span);
|
|
while (true) {
|
|
const diagnostic = tryCast(sortedFileDiagnostics[index], isDiagnosticWithLocation);
|
|
if (!diagnostic || diagnostic.start > end) {
|
|
break;
|
|
}
|
|
if (textSpanContainsTextSpan(span, diagnostic)) {
|
|
result.push(diagnostic);
|
|
}
|
|
index++;
|
|
}
|
|
return result;
|
|
}
|
|
function getRefactorContextSpan({ startPosition, endPosition }) {
|
|
return createTextSpanFromBounds(startPosition, endPosition === void 0 ? startPosition : endPosition);
|
|
}
|
|
function getFixableErrorSpanExpression(sourceFile, span) {
|
|
const token = getTokenAtPosition(sourceFile, span.start);
|
|
const expression = findAncestor(token, (node) => {
|
|
if (node.getStart(sourceFile) < span.start || node.getEnd() > textSpanEnd(span)) {
|
|
return "quit";
|
|
}
|
|
return isExpression(node) && textSpansEqual(span, createTextSpanFromNode(node, sourceFile));
|
|
});
|
|
return expression;
|
|
}
|
|
function mapOneOrMany(valueOrArray, f, resultSelector = identity) {
|
|
return valueOrArray ? isArray(valueOrArray) ? resultSelector(map(valueOrArray, f)) : f(valueOrArray, 0) : void 0;
|
|
}
|
|
function firstOrOnly(valueOrArray) {
|
|
return isArray(valueOrArray) ? first(valueOrArray) : valueOrArray;
|
|
}
|
|
function getNamesForExportedSymbol(symbol, scriptTarget) {
|
|
if (needsNameFromDeclaration(symbol)) {
|
|
const fromDeclaration = getDefaultLikeExportNameFromDeclaration(symbol);
|
|
if (fromDeclaration)
|
|
return fromDeclaration;
|
|
const fileNameCase = ts_codefix_exports.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, false);
|
|
const capitalized = ts_codefix_exports.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, true);
|
|
if (fileNameCase === capitalized)
|
|
return fileNameCase;
|
|
return [fileNameCase, capitalized];
|
|
}
|
|
return symbol.name;
|
|
}
|
|
function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) {
|
|
if (needsNameFromDeclaration(symbol)) {
|
|
return getDefaultLikeExportNameFromDeclaration(symbol) || ts_codefix_exports.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized);
|
|
}
|
|
return symbol.name;
|
|
}
|
|
function needsNameFromDeclaration(symbol) {
|
|
return !(symbol.flags & 33554432 /* Transient */) && (symbol.escapedName === "export=" /* ExportEquals */ || symbol.escapedName === "default" /* Default */);
|
|
}
|
|
function getDefaultLikeExportNameFromDeclaration(symbol) {
|
|
return firstDefined(symbol.declarations, (d) => {
|
|
var _a2;
|
|
return isExportAssignment(d) ? (_a2 = tryCast(skipOuterExpressions(d.expression), isIdentifier)) == null ? void 0 : _a2.text : void 0;
|
|
});
|
|
}
|
|
function getSymbolParentOrFail(symbol) {
|
|
var _a2;
|
|
return Debug.checkDefined(
|
|
symbol.parent,
|
|
`Symbol parent was undefined. Flags: ${Debug.formatSymbolFlags(symbol.flags)}. Declarations: ${(_a2 = symbol.declarations) == null ? void 0 : _a2.map((d) => {
|
|
const kind = Debug.formatSyntaxKind(d.kind);
|
|
const inJS = isInJSFile(d);
|
|
const { expression } = d;
|
|
return (inJS ? "[JS]" : "") + kind + (expression ? ` (expression: ${Debug.formatSyntaxKind(expression.kind)})` : "");
|
|
}).join(", ")}.`
|
|
);
|
|
}
|
|
function stringContainsAt(haystack, needle, startIndex) {
|
|
const needleLength = needle.length;
|
|
if (needleLength + startIndex > haystack.length) {
|
|
return false;
|
|
}
|
|
for (let i = 0; i < needleLength; i++) {
|
|
if (needle.charCodeAt(i) !== haystack.charCodeAt(i + startIndex))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function startsWithUnderscore(name) {
|
|
return name.charCodeAt(0) === 95 /* _ */;
|
|
}
|
|
function isGlobalDeclaration(declaration) {
|
|
return !isNonGlobalDeclaration(declaration);
|
|
}
|
|
function isNonGlobalDeclaration(declaration) {
|
|
const sourceFile = declaration.getSourceFile();
|
|
if (!sourceFile.externalModuleIndicator && !sourceFile.commonJsModuleIndicator) {
|
|
return false;
|
|
}
|
|
return isInJSFile(declaration) || !findAncestor(declaration, isGlobalScopeAugmentation);
|
|
}
|
|
function isDeprecatedDeclaration(decl) {
|
|
return !!(getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 8192 /* Deprecated */);
|
|
}
|
|
function shouldUseUriStyleNodeCoreModules(file, program) {
|
|
const decisionFromFile = firstDefined(file.imports, (node) => {
|
|
if (ts_JsTyping_exports.nodeCoreModules.has(node.text)) {
|
|
return startsWith(node.text, "node:");
|
|
}
|
|
});
|
|
return decisionFromFile != null ? decisionFromFile : program.usesUriStyleNodeCoreModules;
|
|
}
|
|
function getNewLineKind(newLineCharacter) {
|
|
return newLineCharacter === "\n" ? 1 /* LineFeed */ : 0 /* CarriageReturnLineFeed */;
|
|
}
|
|
function diagnosticToString(diag2) {
|
|
return isArray(diag2) ? formatStringFromArgs(getLocaleSpecificMessage(diag2[0]), diag2.slice(1)) : getLocaleSpecificMessage(diag2);
|
|
}
|
|
function getFormatCodeSettingsForWriting({ options }, sourceFile) {
|
|
const shouldAutoDetectSemicolonPreference = !options.semicolons || options.semicolons === "ignore" /* Ignore */;
|
|
const shouldRemoveSemicolons = options.semicolons === "remove" /* Remove */ || shouldAutoDetectSemicolonPreference && !probablyUsesSemicolons(sourceFile);
|
|
return {
|
|
...options,
|
|
semicolons: shouldRemoveSemicolons ? "remove" /* Remove */ : "ignore" /* Ignore */
|
|
};
|
|
}
|
|
function jsxModeNeedsExplicitImport(jsx) {
|
|
return jsx === 2 /* React */ || jsx === 3 /* ReactNative */;
|
|
}
|
|
function isSourceFileFromLibrary(program, node) {
|
|
return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
|
|
}
|
|
|
|
// src/services/exportInfoMap.ts
|
|
var ImportKind = /* @__PURE__ */ ((ImportKind2) => {
|
|
ImportKind2[ImportKind2["Named"] = 0] = "Named";
|
|
ImportKind2[ImportKind2["Default"] = 1] = "Default";
|
|
ImportKind2[ImportKind2["Namespace"] = 2] = "Namespace";
|
|
ImportKind2[ImportKind2["CommonJS"] = 3] = "CommonJS";
|
|
return ImportKind2;
|
|
})(ImportKind || {});
|
|
var ExportKind = /* @__PURE__ */ ((ExportKind3) => {
|
|
ExportKind3[ExportKind3["Named"] = 0] = "Named";
|
|
ExportKind3[ExportKind3["Default"] = 1] = "Default";
|
|
ExportKind3[ExportKind3["ExportEquals"] = 2] = "ExportEquals";
|
|
ExportKind3[ExportKind3["UMD"] = 3] = "UMD";
|
|
return ExportKind3;
|
|
})(ExportKind || {});
|
|
function createCacheableExportInfoMap(host) {
|
|
let exportInfoId = 1;
|
|
const exportInfo = createMultiMap();
|
|
const symbols = /* @__PURE__ */ new Map();
|
|
const packages = /* @__PURE__ */ new Map();
|
|
let usableByFileName;
|
|
const cache = {
|
|
isUsableByFile: (importingFile) => importingFile === usableByFileName,
|
|
isEmpty: () => !exportInfo.size,
|
|
clear: () => {
|
|
exportInfo.clear();
|
|
symbols.clear();
|
|
usableByFileName = void 0;
|
|
},
|
|
add: (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, checker) => {
|
|
if (importingFile !== usableByFileName) {
|
|
cache.clear();
|
|
usableByFileName = importingFile;
|
|
}
|
|
let packageName;
|
|
if (moduleFile) {
|
|
const nodeModulesPathParts = getNodeModulePathParts(moduleFile.fileName);
|
|
if (nodeModulesPathParts) {
|
|
const { topLevelNodeModulesIndex, topLevelPackageNameIndex, packageRootIndex } = nodeModulesPathParts;
|
|
packageName = unmangleScopedPackageName(getPackageNameFromTypesPackageName(moduleFile.fileName.substring(topLevelPackageNameIndex + 1, packageRootIndex)));
|
|
if (startsWith(importingFile, moduleFile.path.substring(0, topLevelNodeModulesIndex))) {
|
|
const prevDeepestNodeModulesPath = packages.get(packageName);
|
|
const nodeModulesPath = moduleFile.fileName.substring(0, topLevelPackageNameIndex + 1);
|
|
if (prevDeepestNodeModulesPath) {
|
|
const prevDeepestNodeModulesIndex = prevDeepestNodeModulesPath.indexOf(nodeModulesPathPart);
|
|
if (topLevelNodeModulesIndex > prevDeepestNodeModulesIndex) {
|
|
packages.set(packageName, nodeModulesPath);
|
|
}
|
|
} else {
|
|
packages.set(packageName, nodeModulesPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const isDefault = exportKind === 1 /* Default */;
|
|
const namedSymbol = isDefault && getLocalSymbolForExportDefault(symbol) || symbol;
|
|
const names = exportKind === 0 /* Named */ || isExternalModuleSymbol(namedSymbol) ? unescapeLeadingUnderscores(symbolTableKey) : getNamesForExportedSymbol(namedSymbol, void 0);
|
|
const symbolName2 = typeof names === "string" ? names : names[0];
|
|
const capitalizedSymbolName = typeof names === "string" ? void 0 : names[1];
|
|
const moduleName = stripQuotes(moduleSymbol.name);
|
|
const id = exportInfoId++;
|
|
const target = skipAlias(symbol, checker);
|
|
const storedSymbol = symbol.flags & 33554432 /* Transient */ ? void 0 : symbol;
|
|
const storedModuleSymbol = moduleSymbol.flags & 33554432 /* Transient */ ? void 0 : moduleSymbol;
|
|
if (!storedSymbol || !storedModuleSymbol)
|
|
symbols.set(id, [symbol, moduleSymbol]);
|
|
exportInfo.add(key(symbolName2, symbol, isExternalModuleNameRelative(moduleName) ? void 0 : moduleName, checker), {
|
|
id,
|
|
symbolTableKey,
|
|
symbolName: symbolName2,
|
|
capitalizedSymbolName,
|
|
moduleName,
|
|
moduleFile,
|
|
moduleFileName: moduleFile == null ? void 0 : moduleFile.fileName,
|
|
packageName,
|
|
exportKind,
|
|
targetFlags: target.flags,
|
|
isFromPackageJson,
|
|
symbol: storedSymbol,
|
|
moduleSymbol: storedModuleSymbol
|
|
});
|
|
},
|
|
get: (importingFile, key2) => {
|
|
if (importingFile !== usableByFileName)
|
|
return;
|
|
const result = exportInfo.get(key2);
|
|
return result == null ? void 0 : result.map(rehydrateCachedInfo);
|
|
},
|
|
search: (importingFile, preferCapitalized, matches, action) => {
|
|
if (importingFile !== usableByFileName)
|
|
return;
|
|
return forEachEntry(exportInfo, (info, key2) => {
|
|
const { symbolName: symbolName2, ambientModuleName } = parseKey(key2);
|
|
const name = preferCapitalized && info[0].capitalizedSymbolName || symbolName2;
|
|
if (matches(name, info[0].targetFlags)) {
|
|
const rehydrated = info.map(rehydrateCachedInfo);
|
|
const filtered = rehydrated.filter((r, i) => isNotShadowedByDeeperNodeModulesPackage(r, info[i].packageName));
|
|
if (filtered.length) {
|
|
const res = action(filtered, name, !!ambientModuleName, key2);
|
|
if (res !== void 0)
|
|
return res;
|
|
}
|
|
}
|
|
});
|
|
},
|
|
releaseSymbols: () => {
|
|
symbols.clear();
|
|
},
|
|
onFileChanged: (oldSourceFile, newSourceFile, typeAcquisitionEnabled) => {
|
|
if (fileIsGlobalOnly(oldSourceFile) && fileIsGlobalOnly(newSourceFile)) {
|
|
return false;
|
|
}
|
|
if (usableByFileName && usableByFileName !== newSourceFile.path || typeAcquisitionEnabled && consumesNodeCoreModules(oldSourceFile) !== consumesNodeCoreModules(newSourceFile) || !arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations) || !ambientModuleDeclarationsAreEqual(oldSourceFile, newSourceFile)) {
|
|
cache.clear();
|
|
return true;
|
|
}
|
|
usableByFileName = newSourceFile.path;
|
|
return false;
|
|
}
|
|
};
|
|
if (Debug.isDebugging) {
|
|
Object.defineProperty(cache, "__cache", { get: () => exportInfo });
|
|
}
|
|
return cache;
|
|
function rehydrateCachedInfo(info) {
|
|
if (info.symbol && info.moduleSymbol)
|
|
return info;
|
|
const { id, exportKind, targetFlags, isFromPackageJson, moduleFileName } = info;
|
|
const [cachedSymbol, cachedModuleSymbol] = symbols.get(id) || emptyArray;
|
|
if (cachedSymbol && cachedModuleSymbol) {
|
|
return {
|
|
symbol: cachedSymbol,
|
|
moduleSymbol: cachedModuleSymbol,
|
|
moduleFileName,
|
|
exportKind,
|
|
targetFlags,
|
|
isFromPackageJson
|
|
};
|
|
}
|
|
const checker = (isFromPackageJson ? host.getPackageJsonAutoImportProvider() : host.getCurrentProgram()).getTypeChecker();
|
|
const moduleSymbol = info.moduleSymbol || cachedModuleSymbol || Debug.checkDefined(info.moduleFile ? checker.getMergedSymbol(info.moduleFile.symbol) : checker.tryFindAmbientModule(info.moduleName));
|
|
const symbol = info.symbol || cachedSymbol || Debug.checkDefined(
|
|
exportKind === 2 /* ExportEquals */ ? checker.resolveExternalModuleSymbol(moduleSymbol) : checker.tryGetMemberInModuleExportsAndProperties(unescapeLeadingUnderscores(info.symbolTableKey), moduleSymbol),
|
|
`Could not find symbol '${info.symbolName}' by key '${info.symbolTableKey}' in module ${moduleSymbol.name}`
|
|
);
|
|
symbols.set(id, [symbol, moduleSymbol]);
|
|
return {
|
|
symbol,
|
|
moduleSymbol,
|
|
moduleFileName,
|
|
exportKind,
|
|
targetFlags,
|
|
isFromPackageJson
|
|
};
|
|
}
|
|
function key(importedName, symbol, ambientModuleName, checker) {
|
|
const moduleKey = ambientModuleName || "";
|
|
return `${importedName}|${getSymbolId(skipAlias(symbol, checker))}|${moduleKey}`;
|
|
}
|
|
function parseKey(key2) {
|
|
const symbolName2 = key2.substring(0, key2.indexOf("|"));
|
|
const moduleKey = key2.substring(key2.lastIndexOf("|") + 1);
|
|
const ambientModuleName = moduleKey === "" ? void 0 : moduleKey;
|
|
return { symbolName: symbolName2, ambientModuleName };
|
|
}
|
|
function fileIsGlobalOnly(file) {
|
|
return !file.commonJsModuleIndicator && !file.externalModuleIndicator && !file.moduleAugmentations && !file.ambientModuleNames;
|
|
}
|
|
function ambientModuleDeclarationsAreEqual(oldSourceFile, newSourceFile) {
|
|
if (!arrayIsEqualTo(oldSourceFile.ambientModuleNames, newSourceFile.ambientModuleNames)) {
|
|
return false;
|
|
}
|
|
let oldFileStatementIndex = -1;
|
|
let newFileStatementIndex = -1;
|
|
for (const ambientModuleName of newSourceFile.ambientModuleNames) {
|
|
const isMatchingModuleDeclaration = (node) => isNonGlobalAmbientModule(node) && node.name.text === ambientModuleName;
|
|
oldFileStatementIndex = findIndex(oldSourceFile.statements, isMatchingModuleDeclaration, oldFileStatementIndex + 1);
|
|
newFileStatementIndex = findIndex(newSourceFile.statements, isMatchingModuleDeclaration, newFileStatementIndex + 1);
|
|
if (oldSourceFile.statements[oldFileStatementIndex] !== newSourceFile.statements[newFileStatementIndex]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isNotShadowedByDeeperNodeModulesPackage(info, packageName) {
|
|
if (!packageName || !info.moduleFileName)
|
|
return true;
|
|
const typingsCacheLocation = host.getGlobalTypingsCacheLocation();
|
|
if (typingsCacheLocation && startsWith(info.moduleFileName, typingsCacheLocation))
|
|
return true;
|
|
const packageDeepestNodeModulesPath = packages.get(packageName);
|
|
return !packageDeepestNodeModulesPath || startsWith(info.moduleFileName, packageDeepestNodeModulesPath);
|
|
}
|
|
}
|
|
function isImportableFile(program, from, to, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) {
|
|
var _a2;
|
|
if (from === to)
|
|
return false;
|
|
const cachedResult = moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.get(from.path, to.path, preferences, {});
|
|
if ((cachedResult == null ? void 0 : cachedResult.isBlockedByPackageJsonDependencies) !== void 0) {
|
|
return !cachedResult.isBlockedByPackageJsonDependencies;
|
|
}
|
|
const getCanonicalFileName = hostGetCanonicalFileName(moduleSpecifierResolutionHost);
|
|
const globalTypingsCache = (_a2 = moduleSpecifierResolutionHost.getGlobalTypingsCacheLocation) == null ? void 0 : _a2.call(moduleSpecifierResolutionHost);
|
|
const hasImportablePath = !!ts_moduleSpecifiers_exports.forEachFileNameOfModule(
|
|
from.fileName,
|
|
to.fileName,
|
|
moduleSpecifierResolutionHost,
|
|
false,
|
|
(toPath3) => {
|
|
const toFile = program.getSourceFile(toPath3);
|
|
return (toFile === to || !toFile) && isImportablePath(from.fileName, toPath3, getCanonicalFileName, globalTypingsCache);
|
|
}
|
|
);
|
|
if (packageJsonFilter) {
|
|
const isAutoImportable = hasImportablePath && packageJsonFilter.allowsImportingSourceFile(to, moduleSpecifierResolutionHost);
|
|
moduleSpecifierCache == null ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(from.path, to.path, preferences, {}, !isAutoImportable);
|
|
return isAutoImportable;
|
|
}
|
|
return hasImportablePath;
|
|
}
|
|
function isImportablePath(fromPath, toPath3, getCanonicalFileName, globalCachePath) {
|
|
const toNodeModules = forEachAncestorDirectory(toPath3, (ancestor) => getBaseFileName(ancestor) === "node_modules" ? ancestor : void 0);
|
|
const toNodeModulesParent = toNodeModules && getDirectoryPath(getCanonicalFileName(toNodeModules));
|
|
return toNodeModulesParent === void 0 || startsWith(getCanonicalFileName(fromPath), toNodeModulesParent) || !!globalCachePath && startsWith(getCanonicalFileName(globalCachePath), toNodeModulesParent);
|
|
}
|
|
function forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, cb) {
|
|
var _a2, _b;
|
|
const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
|
|
const excludePatterns = preferences.autoImportFileExcludePatterns && mapDefined(preferences.autoImportFileExcludePatterns, (spec) => {
|
|
const pattern = getPatternFromSpec(spec, "", "exclude");
|
|
return pattern ? getRegexFromPattern(pattern, useCaseSensitiveFileNames) : void 0;
|
|
});
|
|
forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), excludePatterns, (module2, file) => cb(module2, file, program, false));
|
|
const autoImportProvider = useAutoImportProvider && ((_a2 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host));
|
|
if (autoImportProvider) {
|
|
const start2 = timestamp();
|
|
forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, (module2, file) => cb(module2, file, autoImportProvider, true));
|
|
(_b = host.log) == null ? void 0 : _b.call(host, `forEachExternalModuleToImportFrom autoImportProvider: ${timestamp() - start2}`);
|
|
}
|
|
}
|
|
function forEachExternalModule(checker, allSourceFiles, excludePatterns, cb) {
|
|
var _a2;
|
|
const isExcluded = (fileName) => excludePatterns == null ? void 0 : excludePatterns.some((p) => p.test(fileName));
|
|
for (const ambient of checker.getAmbientModules()) {
|
|
if (!stringContains(ambient.name, "*") && !(excludePatterns && ((_a2 = ambient.declarations) == null ? void 0 : _a2.every((d) => isExcluded(d.getSourceFile().fileName))))) {
|
|
cb(ambient, void 0);
|
|
}
|
|
}
|
|
for (const sourceFile of allSourceFiles) {
|
|
if (isExternalOrCommonJsModule(sourceFile) && !isExcluded(sourceFile.fileName)) {
|
|
cb(checker.getMergedSymbol(sourceFile.symbol), sourceFile);
|
|
}
|
|
}
|
|
}
|
|
function getExportInfoMap(importingFile, host, program, preferences, cancellationToken) {
|
|
var _a2, _b, _c, _d, _e;
|
|
const start2 = timestamp();
|
|
(_a2 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host);
|
|
const cache = ((_b = host.getCachedExportInfoMap) == null ? void 0 : _b.call(host)) || createCacheableExportInfoMap({
|
|
getCurrentProgram: () => program,
|
|
getPackageJsonAutoImportProvider: () => {
|
|
var _a3;
|
|
return (_a3 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a3.call(host);
|
|
},
|
|
getGlobalTypingsCacheLocation: () => {
|
|
var _a3;
|
|
return (_a3 = host.getGlobalTypingsCacheLocation) == null ? void 0 : _a3.call(host);
|
|
}
|
|
});
|
|
if (cache.isUsableByFile(importingFile.path)) {
|
|
(_c = host.log) == null ? void 0 : _c.call(host, "getExportInfoMap: cache hit");
|
|
return cache;
|
|
}
|
|
(_d = host.log) == null ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results");
|
|
const compilerOptions = program.getCompilerOptions();
|
|
let moduleCount = 0;
|
|
try {
|
|
forEachExternalModuleToImportFrom(program, host, preferences, true, (moduleSymbol, moduleFile, program2, isFromPackageJson) => {
|
|
if (++moduleCount % 100 === 0)
|
|
cancellationToken == null ? void 0 : cancellationToken.throwIfCancellationRequested();
|
|
const seenExports = /* @__PURE__ */ new Map();
|
|
const checker = program2.getTypeChecker();
|
|
const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
|
|
if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) {
|
|
cache.add(
|
|
importingFile.path,
|
|
defaultInfo.symbol,
|
|
defaultInfo.exportKind === 1 /* Default */ ? "default" /* Default */ : "export=" /* ExportEquals */,
|
|
moduleSymbol,
|
|
moduleFile,
|
|
defaultInfo.exportKind,
|
|
isFromPackageJson,
|
|
checker
|
|
);
|
|
}
|
|
checker.forEachExportAndPropertyOfModule(moduleSymbol, (exported, key) => {
|
|
if (exported !== (defaultInfo == null ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && addToSeen(seenExports, key)) {
|
|
cache.add(
|
|
importingFile.path,
|
|
exported,
|
|
key,
|
|
moduleSymbol,
|
|
moduleFile,
|
|
0 /* Named */,
|
|
isFromPackageJson,
|
|
checker
|
|
);
|
|
}
|
|
});
|
|
});
|
|
} catch (err) {
|
|
cache.clear();
|
|
throw err;
|
|
}
|
|
(_e = host.log) == null ? void 0 : _e.call(host, `getExportInfoMap: done in ${timestamp() - start2} ms`);
|
|
return cache;
|
|
}
|
|
function getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions) {
|
|
const exported = getDefaultLikeExportWorker(moduleSymbol, checker);
|
|
if (!exported)
|
|
return void 0;
|
|
const { symbol, exportKind } = exported;
|
|
const info = getDefaultExportInfoWorker(symbol, checker, compilerOptions);
|
|
return info && { symbol, exportKind, ...info };
|
|
}
|
|
function isImportableSymbol(symbol, checker) {
|
|
return !checker.isUndefinedSymbol(symbol) && !checker.isUnknownSymbol(symbol) && !isKnownSymbol(symbol) && !isPrivateIdentifierSymbol(symbol);
|
|
}
|
|
function getDefaultLikeExportWorker(moduleSymbol, checker) {
|
|
const exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol);
|
|
if (exportEquals !== moduleSymbol)
|
|
return { symbol: exportEquals, exportKind: 2 /* ExportEquals */ };
|
|
const defaultExport = checker.tryGetMemberInModuleExports("default" /* Default */, moduleSymbol);
|
|
if (defaultExport)
|
|
return { symbol: defaultExport, exportKind: 1 /* Default */ };
|
|
}
|
|
function getDefaultExportInfoWorker(defaultExport, checker, compilerOptions) {
|
|
const localSymbol = getLocalSymbolForExportDefault(defaultExport);
|
|
if (localSymbol)
|
|
return { symbolForMeaning: localSymbol, name: localSymbol.name };
|
|
const name = getNameForExportDefault(defaultExport);
|
|
if (name !== void 0)
|
|
return { symbolForMeaning: defaultExport, name };
|
|
if (defaultExport.flags & 2097152 /* Alias */) {
|
|
const aliased = checker.getImmediateAliasedSymbol(defaultExport);
|
|
if (aliased && aliased.parent) {
|
|
return getDefaultExportInfoWorker(aliased, checker, compilerOptions);
|
|
}
|
|
}
|
|
if (defaultExport.escapedName !== "default" /* Default */ && defaultExport.escapedName !== "export=" /* ExportEquals */) {
|
|
return { symbolForMeaning: defaultExport, name: defaultExport.getName() };
|
|
}
|
|
return { symbolForMeaning: defaultExport, name: getNameForExportedSymbol(defaultExport, compilerOptions.target) };
|
|
}
|
|
function getNameForExportDefault(symbol) {
|
|
return symbol.declarations && firstDefined(symbol.declarations, (declaration) => {
|
|
var _a2;
|
|
if (isExportAssignment(declaration)) {
|
|
return (_a2 = tryCast(skipOuterExpressions(declaration.expression), isIdentifier)) == null ? void 0 : _a2.text;
|
|
} else if (isExportSpecifier(declaration)) {
|
|
Debug.assert(declaration.name.text === "default" /* Default */, "Expected the specifier to be a default export");
|
|
return declaration.propertyName && declaration.propertyName.text;
|
|
}
|
|
});
|
|
}
|
|
|
|
// src/services/classifier.ts
|
|
function createClassifier() {
|
|
const scanner2 = createScanner(99 /* Latest */, false);
|
|
function getClassificationsForLine(text, lexState, syntacticClassifierAbsent) {
|
|
return convertClassificationsToResult(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text);
|
|
}
|
|
function getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent) {
|
|
let token = 0 /* Unknown */;
|
|
let lastNonTriviaToken = 0 /* Unknown */;
|
|
const templateStack = [];
|
|
const { prefix, pushTemplate } = getPrefixFromLexState(lexState);
|
|
text = prefix + text;
|
|
const offset = prefix.length;
|
|
if (pushTemplate) {
|
|
templateStack.push(15 /* TemplateHead */);
|
|
}
|
|
scanner2.setText(text);
|
|
let endOfLineState = 0 /* None */;
|
|
const spans = [];
|
|
let angleBracketStack = 0;
|
|
do {
|
|
token = scanner2.scan();
|
|
if (!isTrivia(token)) {
|
|
handleToken();
|
|
lastNonTriviaToken = token;
|
|
}
|
|
const end = scanner2.getTextPos();
|
|
pushEncodedClassification(scanner2.getTokenPos(), end, offset, classFromKind(token), spans);
|
|
if (end >= text.length) {
|
|
const end2 = getNewEndOfLineState(scanner2, token, lastOrUndefined(templateStack));
|
|
if (end2 !== void 0) {
|
|
endOfLineState = end2;
|
|
}
|
|
}
|
|
} while (token !== 1 /* EndOfFileToken */);
|
|
function handleToken() {
|
|
switch (token) {
|
|
case 43 /* SlashToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
if (!noRegexTable[lastNonTriviaToken] && scanner2.reScanSlashToken() === 13 /* RegularExpressionLiteral */) {
|
|
token = 13 /* RegularExpressionLiteral */;
|
|
}
|
|
break;
|
|
case 29 /* LessThanToken */:
|
|
if (lastNonTriviaToken === 79 /* Identifier */) {
|
|
angleBracketStack++;
|
|
}
|
|
break;
|
|
case 31 /* GreaterThanToken */:
|
|
if (angleBracketStack > 0) {
|
|
angleBracketStack--;
|
|
}
|
|
break;
|
|
case 131 /* AnyKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
if (angleBracketStack > 0 && !syntacticClassifierAbsent) {
|
|
token = 79 /* Identifier */;
|
|
}
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
templateStack.push(token);
|
|
break;
|
|
case 18 /* OpenBraceToken */:
|
|
if (templateStack.length > 0) {
|
|
templateStack.push(token);
|
|
}
|
|
break;
|
|
case 19 /* CloseBraceToken */:
|
|
if (templateStack.length > 0) {
|
|
const lastTemplateStackToken = lastOrUndefined(templateStack);
|
|
if (lastTemplateStackToken === 15 /* TemplateHead */) {
|
|
token = scanner2.reScanTemplateToken(false);
|
|
if (token === 17 /* TemplateTail */) {
|
|
templateStack.pop();
|
|
} else {
|
|
Debug.assertEqual(token, 16 /* TemplateMiddle */, "Should have been a template middle.");
|
|
}
|
|
} else {
|
|
Debug.assertEqual(lastTemplateStackToken, 18 /* OpenBraceToken */, "Should have been an open brace");
|
|
templateStack.pop();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if (!isKeyword(token)) {
|
|
break;
|
|
}
|
|
if (lastNonTriviaToken === 24 /* DotToken */) {
|
|
token = 79 /* Identifier */;
|
|
} else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) {
|
|
token = 79 /* Identifier */;
|
|
}
|
|
}
|
|
}
|
|
return { endOfLineState, spans };
|
|
}
|
|
return { getClassificationsForLine, getEncodedLexicalClassifications };
|
|
}
|
|
var noRegexTable = arrayToNumericMap([
|
|
79 /* Identifier */,
|
|
10 /* StringLiteral */,
|
|
8 /* NumericLiteral */,
|
|
9 /* BigIntLiteral */,
|
|
13 /* RegularExpressionLiteral */,
|
|
108 /* ThisKeyword */,
|
|
45 /* PlusPlusToken */,
|
|
46 /* MinusMinusToken */,
|
|
21 /* CloseParenToken */,
|
|
23 /* CloseBracketToken */,
|
|
19 /* CloseBraceToken */,
|
|
110 /* TrueKeyword */,
|
|
95 /* FalseKeyword */
|
|
], (token) => token, () => true);
|
|
function getNewEndOfLineState(scanner2, token, lastOnTemplateStack) {
|
|
switch (token) {
|
|
case 10 /* StringLiteral */: {
|
|
if (!scanner2.isUnterminated())
|
|
return void 0;
|
|
const tokenText = scanner2.getTokenText();
|
|
const lastCharIndex = tokenText.length - 1;
|
|
let numBackslashes = 0;
|
|
while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92 /* backslash */) {
|
|
numBackslashes++;
|
|
}
|
|
if ((numBackslashes & 1) === 0)
|
|
return void 0;
|
|
return tokenText.charCodeAt(0) === 34 /* doubleQuote */ ? 3 /* InDoubleQuoteStringLiteral */ : 2 /* InSingleQuoteStringLiteral */;
|
|
}
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
return scanner2.isUnterminated() ? 1 /* InMultiLineCommentTrivia */ : void 0;
|
|
default:
|
|
if (isTemplateLiteralKind(token)) {
|
|
if (!scanner2.isUnterminated()) {
|
|
return void 0;
|
|
}
|
|
switch (token) {
|
|
case 17 /* TemplateTail */:
|
|
return 5 /* InTemplateMiddleOrTail */;
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return 4 /* InTemplateHeadOrNoSubstitutionTemplate */;
|
|
default:
|
|
return Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token);
|
|
}
|
|
}
|
|
return lastOnTemplateStack === 15 /* TemplateHead */ ? 6 /* InTemplateSubstitutionPosition */ : void 0;
|
|
}
|
|
}
|
|
function pushEncodedClassification(start2, end, offset, classification, result) {
|
|
if (classification === 8 /* whiteSpace */) {
|
|
return;
|
|
}
|
|
if (start2 === 0 && offset > 0) {
|
|
start2 += offset;
|
|
}
|
|
const length2 = end - start2;
|
|
if (length2 > 0) {
|
|
result.push(start2 - offset, length2, classification);
|
|
}
|
|
}
|
|
function convertClassificationsToResult(classifications, text) {
|
|
const entries = [];
|
|
const dense = classifications.spans;
|
|
let lastEnd = 0;
|
|
for (let i = 0; i < dense.length; i += 3) {
|
|
const start2 = dense[i];
|
|
const length2 = dense[i + 1];
|
|
const type = dense[i + 2];
|
|
if (lastEnd >= 0) {
|
|
const whitespaceLength2 = start2 - lastEnd;
|
|
if (whitespaceLength2 > 0) {
|
|
entries.push({ length: whitespaceLength2, classification: 4 /* Whitespace */ });
|
|
}
|
|
}
|
|
entries.push({ length: length2, classification: convertClassification(type) });
|
|
lastEnd = start2 + length2;
|
|
}
|
|
const whitespaceLength = text.length - lastEnd;
|
|
if (whitespaceLength > 0) {
|
|
entries.push({ length: whitespaceLength, classification: 4 /* Whitespace */ });
|
|
}
|
|
return { entries, finalLexState: classifications.endOfLineState };
|
|
}
|
|
function convertClassification(type) {
|
|
switch (type) {
|
|
case 1 /* comment */:
|
|
return 3 /* Comment */;
|
|
case 3 /* keyword */:
|
|
return 1 /* Keyword */;
|
|
case 4 /* numericLiteral */:
|
|
return 6 /* NumberLiteral */;
|
|
case 25 /* bigintLiteral */:
|
|
return 7 /* BigIntLiteral */;
|
|
case 5 /* operator */:
|
|
return 2 /* Operator */;
|
|
case 6 /* stringLiteral */:
|
|
return 8 /* StringLiteral */;
|
|
case 8 /* whiteSpace */:
|
|
return 4 /* Whitespace */;
|
|
case 10 /* punctuation */:
|
|
return 0 /* Punctuation */;
|
|
case 2 /* identifier */:
|
|
case 11 /* className */:
|
|
case 12 /* enumName */:
|
|
case 13 /* interfaceName */:
|
|
case 14 /* moduleName */:
|
|
case 15 /* typeParameterName */:
|
|
case 16 /* typeAliasName */:
|
|
case 9 /* text */:
|
|
case 17 /* parameterName */:
|
|
return 5 /* Identifier */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function canFollow(keyword1, keyword2) {
|
|
if (!isAccessibilityModifier(keyword1)) {
|
|
return true;
|
|
}
|
|
switch (keyword2) {
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
case 135 /* ConstructorKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getPrefixFromLexState(lexState) {
|
|
switch (lexState) {
|
|
case 3 /* InDoubleQuoteStringLiteral */:
|
|
return { prefix: '"\\\n' };
|
|
case 2 /* InSingleQuoteStringLiteral */:
|
|
return { prefix: "'\\\n" };
|
|
case 1 /* InMultiLineCommentTrivia */:
|
|
return { prefix: "/*\n" };
|
|
case 4 /* InTemplateHeadOrNoSubstitutionTemplate */:
|
|
return { prefix: "`\n" };
|
|
case 5 /* InTemplateMiddleOrTail */:
|
|
return { prefix: "}\n", pushTemplate: true };
|
|
case 6 /* InTemplateSubstitutionPosition */:
|
|
return { prefix: "", pushTemplate: true };
|
|
case 0 /* None */:
|
|
return { prefix: "" };
|
|
default:
|
|
return Debug.assertNever(lexState);
|
|
}
|
|
}
|
|
function isBinaryExpressionOperatorToken(token) {
|
|
switch (token) {
|
|
case 41 /* AsteriskToken */:
|
|
case 43 /* SlashToken */:
|
|
case 44 /* PercentToken */:
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
case 102 /* InstanceOfKeyword */:
|
|
case 101 /* InKeyword */:
|
|
case 128 /* AsKeyword */:
|
|
case 150 /* SatisfiesKeyword */:
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 52 /* CaretToken */:
|
|
case 51 /* BarToken */:
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 56 /* BarBarToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 64 /* PlusEqualsToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 63 /* EqualsToken */:
|
|
case 27 /* CommaToken */:
|
|
case 60 /* QuestionQuestionToken */:
|
|
case 75 /* BarBarEqualsToken */:
|
|
case 76 /* AmpersandAmpersandEqualsToken */:
|
|
case 77 /* QuestionQuestionEqualsToken */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isPrefixUnaryExpressionOperatorToken(token) {
|
|
switch (token) {
|
|
case 39 /* PlusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
case 53 /* ExclamationToken */:
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function classFromKind(token) {
|
|
if (isKeyword(token)) {
|
|
return 3 /* keyword */;
|
|
} else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) {
|
|
return 5 /* operator */;
|
|
} else if (token >= 18 /* FirstPunctuation */ && token <= 78 /* LastPunctuation */) {
|
|
return 10 /* punctuation */;
|
|
}
|
|
switch (token) {
|
|
case 8 /* NumericLiteral */:
|
|
return 4 /* numericLiteral */;
|
|
case 9 /* BigIntLiteral */:
|
|
return 25 /* bigintLiteral */;
|
|
case 10 /* StringLiteral */:
|
|
return 6 /* stringLiteral */;
|
|
case 13 /* RegularExpressionLiteral */:
|
|
return 7 /* regularExpressionLiteral */;
|
|
case 7 /* ConflictMarkerTrivia */:
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
case 2 /* SingleLineCommentTrivia */:
|
|
return 1 /* comment */;
|
|
case 5 /* WhitespaceTrivia */:
|
|
case 4 /* NewLineTrivia */:
|
|
return 8 /* whiteSpace */;
|
|
case 79 /* Identifier */:
|
|
default:
|
|
if (isTemplateLiteralKind(token)) {
|
|
return 6 /* stringLiteral */;
|
|
}
|
|
return 2 /* identifier */;
|
|
}
|
|
}
|
|
function getSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) {
|
|
return convertClassificationsToSpans(getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span));
|
|
}
|
|
function checkForClassificationCancellation(cancellationToken, kind) {
|
|
switch (kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
}
|
|
function getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) {
|
|
const spans = [];
|
|
sourceFile.forEachChild(function cb(node) {
|
|
if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth())) {
|
|
return;
|
|
}
|
|
checkForClassificationCancellation(cancellationToken, node.kind);
|
|
if (isIdentifier(node) && !nodeIsMissing(node) && classifiableNames.has(node.escapedText)) {
|
|
const symbol = typeChecker.getSymbolAtLocation(node);
|
|
const type = symbol && classifySymbol(symbol, getMeaningFromLocation(node), typeChecker);
|
|
if (type) {
|
|
pushClassification(node.getStart(sourceFile), node.getEnd(), type);
|
|
}
|
|
}
|
|
node.forEachChild(cb);
|
|
});
|
|
return { spans, endOfLineState: 0 /* None */ };
|
|
function pushClassification(start2, end, type) {
|
|
const length2 = end - start2;
|
|
Debug.assert(length2 > 0, `Classification had non-positive length of ${length2}`);
|
|
spans.push(start2);
|
|
spans.push(length2);
|
|
spans.push(type);
|
|
}
|
|
}
|
|
function classifySymbol(symbol, meaningAtPosition, checker) {
|
|
const flags = symbol.getFlags();
|
|
if ((flags & 2885600 /* Classifiable */) === 0 /* None */) {
|
|
return void 0;
|
|
} else if (flags & 32 /* Class */) {
|
|
return 11 /* className */;
|
|
} else if (flags & 384 /* Enum */) {
|
|
return 12 /* enumName */;
|
|
} else if (flags & 524288 /* TypeAlias */) {
|
|
return 16 /* typeAliasName */;
|
|
} else if (flags & 1536 /* Module */) {
|
|
return meaningAtPosition & 4 /* Namespace */ || meaningAtPosition & 1 /* Value */ && hasValueSideModule(symbol) ? 14 /* moduleName */ : void 0;
|
|
} else if (flags & 2097152 /* Alias */) {
|
|
return classifySymbol(checker.getAliasedSymbol(symbol), meaningAtPosition, checker);
|
|
} else if (meaningAtPosition & 2 /* Type */) {
|
|
return flags & 64 /* Interface */ ? 13 /* interfaceName */ : flags & 262144 /* TypeParameter */ ? 15 /* typeParameterName */ : void 0;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
function hasValueSideModule(symbol) {
|
|
return some(symbol.declarations, (declaration) => isModuleDeclaration(declaration) && getModuleInstanceState(declaration) === 1 /* Instantiated */);
|
|
}
|
|
function getClassificationTypeName(type) {
|
|
switch (type) {
|
|
case 1 /* comment */:
|
|
return "comment" /* comment */;
|
|
case 2 /* identifier */:
|
|
return "identifier" /* identifier */;
|
|
case 3 /* keyword */:
|
|
return "keyword" /* keyword */;
|
|
case 4 /* numericLiteral */:
|
|
return "number" /* numericLiteral */;
|
|
case 25 /* bigintLiteral */:
|
|
return "bigint" /* bigintLiteral */;
|
|
case 5 /* operator */:
|
|
return "operator" /* operator */;
|
|
case 6 /* stringLiteral */:
|
|
return "string" /* stringLiteral */;
|
|
case 8 /* whiteSpace */:
|
|
return "whitespace" /* whiteSpace */;
|
|
case 9 /* text */:
|
|
return "text" /* text */;
|
|
case 10 /* punctuation */:
|
|
return "punctuation" /* punctuation */;
|
|
case 11 /* className */:
|
|
return "class name" /* className */;
|
|
case 12 /* enumName */:
|
|
return "enum name" /* enumName */;
|
|
case 13 /* interfaceName */:
|
|
return "interface name" /* interfaceName */;
|
|
case 14 /* moduleName */:
|
|
return "module name" /* moduleName */;
|
|
case 15 /* typeParameterName */:
|
|
return "type parameter name" /* typeParameterName */;
|
|
case 16 /* typeAliasName */:
|
|
return "type alias name" /* typeAliasName */;
|
|
case 17 /* parameterName */:
|
|
return "parameter name" /* parameterName */;
|
|
case 18 /* docCommentTagName */:
|
|
return "doc comment tag name" /* docCommentTagName */;
|
|
case 19 /* jsxOpenTagName */:
|
|
return "jsx open tag name" /* jsxOpenTagName */;
|
|
case 20 /* jsxCloseTagName */:
|
|
return "jsx close tag name" /* jsxCloseTagName */;
|
|
case 21 /* jsxSelfClosingTagName */:
|
|
return "jsx self closing tag name" /* jsxSelfClosingTagName */;
|
|
case 22 /* jsxAttribute */:
|
|
return "jsx attribute" /* jsxAttribute */;
|
|
case 23 /* jsxText */:
|
|
return "jsx text" /* jsxText */;
|
|
case 24 /* jsxAttributeStringLiteralValue */:
|
|
return "jsx attribute string literal value" /* jsxAttributeStringLiteralValue */;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function convertClassificationsToSpans(classifications) {
|
|
Debug.assert(classifications.spans.length % 3 === 0);
|
|
const dense = classifications.spans;
|
|
const result = [];
|
|
for (let i = 0; i < dense.length; i += 3) {
|
|
result.push({
|
|
textSpan: createTextSpan(dense[i], dense[i + 1]),
|
|
classificationType: getClassificationTypeName(dense[i + 2])
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function getSyntacticClassifications(cancellationToken, sourceFile, span) {
|
|
return convertClassificationsToSpans(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span));
|
|
}
|
|
function getEncodedSyntacticClassifications(cancellationToken, sourceFile, span) {
|
|
const spanStart = span.start;
|
|
const spanLength = span.length;
|
|
const triviaScanner = createScanner(99 /* Latest */, false, sourceFile.languageVariant, sourceFile.text);
|
|
const mergeConflictScanner = createScanner(99 /* Latest */, false, sourceFile.languageVariant, sourceFile.text);
|
|
const result = [];
|
|
processElement(sourceFile);
|
|
return { spans: result, endOfLineState: 0 /* None */ };
|
|
function pushClassification(start2, length2, type) {
|
|
result.push(start2);
|
|
result.push(length2);
|
|
result.push(type);
|
|
}
|
|
function classifyLeadingTriviaAndGetTokenStart(token) {
|
|
triviaScanner.setTextPos(token.pos);
|
|
while (true) {
|
|
const start2 = triviaScanner.getTextPos();
|
|
if (!couldStartTrivia(sourceFile.text, start2)) {
|
|
return start2;
|
|
}
|
|
const kind = triviaScanner.scan();
|
|
const end = triviaScanner.getTextPos();
|
|
const width = end - start2;
|
|
if (!isTrivia(kind)) {
|
|
return start2;
|
|
}
|
|
switch (kind) {
|
|
case 4 /* NewLineTrivia */:
|
|
case 5 /* WhitespaceTrivia */:
|
|
continue;
|
|
case 2 /* SingleLineCommentTrivia */:
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
classifyComment(token, kind, start2, width);
|
|
triviaScanner.setTextPos(end);
|
|
continue;
|
|
case 7 /* ConflictMarkerTrivia */:
|
|
const text = sourceFile.text;
|
|
const ch = text.charCodeAt(start2);
|
|
if (ch === 60 /* lessThan */ || ch === 62 /* greaterThan */) {
|
|
pushClassification(start2, width, 1 /* comment */);
|
|
continue;
|
|
}
|
|
Debug.assert(ch === 124 /* bar */ || ch === 61 /* equals */);
|
|
classifyDisabledMergeCode(text, start2, end);
|
|
break;
|
|
case 6 /* ShebangTrivia */:
|
|
break;
|
|
default:
|
|
Debug.assertNever(kind);
|
|
}
|
|
}
|
|
}
|
|
function classifyComment(token, kind, start2, width) {
|
|
if (kind === 3 /* MultiLineCommentTrivia */) {
|
|
const docCommentAndDiagnostics = parseIsolatedJSDocComment(sourceFile.text, start2, width);
|
|
if (docCommentAndDiagnostics && docCommentAndDiagnostics.jsDoc) {
|
|
setParent(docCommentAndDiagnostics.jsDoc, token);
|
|
classifyJSDocComment(docCommentAndDiagnostics.jsDoc);
|
|
return;
|
|
}
|
|
} else if (kind === 2 /* SingleLineCommentTrivia */) {
|
|
if (tryClassifyTripleSlashComment(start2, width)) {
|
|
return;
|
|
}
|
|
}
|
|
pushCommentRange(start2, width);
|
|
}
|
|
function pushCommentRange(start2, width) {
|
|
pushClassification(start2, width, 1 /* comment */);
|
|
}
|
|
function classifyJSDocComment(docComment) {
|
|
var _a2, _b, _c, _d, _e, _f, _g;
|
|
let pos = docComment.pos;
|
|
if (docComment.tags) {
|
|
for (const tag of docComment.tags) {
|
|
if (tag.pos !== pos) {
|
|
pushCommentRange(pos, tag.pos - pos);
|
|
}
|
|
pushClassification(tag.pos, 1, 10 /* punctuation */);
|
|
pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18 /* docCommentTagName */);
|
|
pos = tag.tagName.end;
|
|
let commentStart = tag.tagName.end;
|
|
switch (tag.kind) {
|
|
case 343 /* JSDocParameterTag */:
|
|
const param = tag;
|
|
processJSDocParameterTag(param);
|
|
commentStart = param.isNameFirst && ((_a2 = param.typeExpression) == null ? void 0 : _a2.end) || param.name.end;
|
|
break;
|
|
case 350 /* JSDocPropertyTag */:
|
|
const prop = tag;
|
|
commentStart = prop.isNameFirst && ((_b = prop.typeExpression) == null ? void 0 : _b.end) || prop.name.end;
|
|
break;
|
|
case 347 /* JSDocTemplateTag */:
|
|
processJSDocTemplateTag(tag);
|
|
pos = tag.end;
|
|
commentStart = tag.typeParameters.end;
|
|
break;
|
|
case 348 /* JSDocTypedefTag */:
|
|
const type = tag;
|
|
commentStart = ((_c = type.typeExpression) == null ? void 0 : _c.kind) === 312 /* JSDocTypeExpression */ && ((_d = type.fullName) == null ? void 0 : _d.end) || ((_e = type.typeExpression) == null ? void 0 : _e.end) || commentStart;
|
|
break;
|
|
case 341 /* JSDocCallbackTag */:
|
|
commentStart = tag.typeExpression.end;
|
|
break;
|
|
case 346 /* JSDocTypeTag */:
|
|
processElement(tag.typeExpression);
|
|
pos = tag.end;
|
|
commentStart = tag.typeExpression.end;
|
|
break;
|
|
case 345 /* JSDocThisTag */:
|
|
case 342 /* JSDocEnumTag */:
|
|
commentStart = tag.typeExpression.end;
|
|
break;
|
|
case 344 /* JSDocReturnTag */:
|
|
processElement(tag.typeExpression);
|
|
pos = tag.end;
|
|
commentStart = ((_f = tag.typeExpression) == null ? void 0 : _f.end) || commentStart;
|
|
break;
|
|
case 349 /* JSDocSeeTag */:
|
|
commentStart = ((_g = tag.name) == null ? void 0 : _g.end) || commentStart;
|
|
break;
|
|
case 331 /* JSDocAugmentsTag */:
|
|
case 332 /* JSDocImplementsTag */:
|
|
commentStart = tag.class.end;
|
|
break;
|
|
}
|
|
if (typeof tag.comment === "object") {
|
|
pushCommentRange(tag.comment.pos, tag.comment.end - tag.comment.pos);
|
|
} else if (typeof tag.comment === "string") {
|
|
pushCommentRange(commentStart, tag.end - commentStart);
|
|
}
|
|
}
|
|
}
|
|
if (pos !== docComment.end) {
|
|
pushCommentRange(pos, docComment.end - pos);
|
|
}
|
|
return;
|
|
function processJSDocParameterTag(tag) {
|
|
if (tag.isNameFirst) {
|
|
pushCommentRange(pos, tag.name.pos - pos);
|
|
pushClassification(tag.name.pos, tag.name.end - tag.name.pos, 17 /* parameterName */);
|
|
pos = tag.name.end;
|
|
}
|
|
if (tag.typeExpression) {
|
|
pushCommentRange(pos, tag.typeExpression.pos - pos);
|
|
processElement(tag.typeExpression);
|
|
pos = tag.typeExpression.end;
|
|
}
|
|
if (!tag.isNameFirst) {
|
|
pushCommentRange(pos, tag.name.pos - pos);
|
|
pushClassification(tag.name.pos, tag.name.end - tag.name.pos, 17 /* parameterName */);
|
|
pos = tag.name.end;
|
|
}
|
|
}
|
|
}
|
|
function tryClassifyTripleSlashComment(start2, width) {
|
|
const tripleSlashXMLCommentRegEx = /^(\/\/\/\s*)(<)(?:(\S+)((?:[^/]|\/[^>])*)(\/>)?)?/im;
|
|
const attributeRegex = /(\s)(\S+)(\s*)(=)(\s*)('[^']+'|"[^"]+")/img;
|
|
const text = sourceFile.text.substr(start2, width);
|
|
const match = tripleSlashXMLCommentRegEx.exec(text);
|
|
if (!match) {
|
|
return false;
|
|
}
|
|
if (!match[3] || !(match[3] in commentPragmas)) {
|
|
return false;
|
|
}
|
|
let pos = start2;
|
|
pushCommentRange(pos, match[1].length);
|
|
pos += match[1].length;
|
|
pushClassification(pos, match[2].length, 10 /* punctuation */);
|
|
pos += match[2].length;
|
|
pushClassification(pos, match[3].length, 21 /* jsxSelfClosingTagName */);
|
|
pos += match[3].length;
|
|
const attrText = match[4];
|
|
let attrPos = pos;
|
|
while (true) {
|
|
const attrMatch = attributeRegex.exec(attrText);
|
|
if (!attrMatch) {
|
|
break;
|
|
}
|
|
const newAttrPos = pos + attrMatch.index + attrMatch[1].length;
|
|
if (newAttrPos > attrPos) {
|
|
pushCommentRange(attrPos, newAttrPos - attrPos);
|
|
attrPos = newAttrPos;
|
|
}
|
|
pushClassification(attrPos, attrMatch[2].length, 22 /* jsxAttribute */);
|
|
attrPos += attrMatch[2].length;
|
|
if (attrMatch[3].length) {
|
|
pushCommentRange(attrPos, attrMatch[3].length);
|
|
attrPos += attrMatch[3].length;
|
|
}
|
|
pushClassification(attrPos, attrMatch[4].length, 5 /* operator */);
|
|
attrPos += attrMatch[4].length;
|
|
if (attrMatch[5].length) {
|
|
pushCommentRange(attrPos, attrMatch[5].length);
|
|
attrPos += attrMatch[5].length;
|
|
}
|
|
pushClassification(attrPos, attrMatch[6].length, 24 /* jsxAttributeStringLiteralValue */);
|
|
attrPos += attrMatch[6].length;
|
|
}
|
|
pos += match[4].length;
|
|
if (pos > attrPos) {
|
|
pushCommentRange(attrPos, pos - attrPos);
|
|
}
|
|
if (match[5]) {
|
|
pushClassification(pos, match[5].length, 10 /* punctuation */);
|
|
pos += match[5].length;
|
|
}
|
|
const end = start2 + width;
|
|
if (pos < end) {
|
|
pushCommentRange(pos, end - pos);
|
|
}
|
|
return true;
|
|
}
|
|
function processJSDocTemplateTag(tag) {
|
|
for (const child of tag.getChildren()) {
|
|
processElement(child);
|
|
}
|
|
}
|
|
function classifyDisabledMergeCode(text, start2, end) {
|
|
let i;
|
|
for (i = start2; i < end; i++) {
|
|
if (isLineBreak(text.charCodeAt(i))) {
|
|
break;
|
|
}
|
|
}
|
|
pushClassification(start2, i - start2, 1 /* comment */);
|
|
mergeConflictScanner.setTextPos(i);
|
|
while (mergeConflictScanner.getTextPos() < end) {
|
|
classifyDisabledCodeToken();
|
|
}
|
|
}
|
|
function classifyDisabledCodeToken() {
|
|
const start2 = mergeConflictScanner.getTextPos();
|
|
const tokenKind = mergeConflictScanner.scan();
|
|
const end = mergeConflictScanner.getTextPos();
|
|
const type = classifyTokenType(tokenKind);
|
|
if (type) {
|
|
pushClassification(start2, end - start2, type);
|
|
}
|
|
}
|
|
function tryClassifyNode(node) {
|
|
if (isJSDoc(node)) {
|
|
return true;
|
|
}
|
|
if (nodeIsMissing(node)) {
|
|
return true;
|
|
}
|
|
const classifiedElementName = tryClassifyJsxElementName(node);
|
|
if (!isToken(node) && node.kind !== 11 /* JsxText */ && classifiedElementName === void 0) {
|
|
return false;
|
|
}
|
|
const tokenStart = node.kind === 11 /* JsxText */ ? node.pos : classifyLeadingTriviaAndGetTokenStart(node);
|
|
const tokenWidth = node.end - tokenStart;
|
|
Debug.assert(tokenWidth >= 0);
|
|
if (tokenWidth > 0) {
|
|
const type = classifiedElementName || classifyTokenType(node.kind, node);
|
|
if (type) {
|
|
pushClassification(tokenStart, tokenWidth, type);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function tryClassifyJsxElementName(token) {
|
|
switch (token.parent && token.parent.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
if (token.parent.tagName === token) {
|
|
return 19 /* jsxOpenTagName */;
|
|
}
|
|
break;
|
|
case 284 /* JsxClosingElement */:
|
|
if (token.parent.tagName === token) {
|
|
return 20 /* jsxCloseTagName */;
|
|
}
|
|
break;
|
|
case 282 /* JsxSelfClosingElement */:
|
|
if (token.parent.tagName === token) {
|
|
return 21 /* jsxSelfClosingTagName */;
|
|
}
|
|
break;
|
|
case 288 /* JsxAttribute */:
|
|
if (token.parent.name === token) {
|
|
return 22 /* jsxAttribute */;
|
|
}
|
|
break;
|
|
}
|
|
return void 0;
|
|
}
|
|
function classifyTokenType(tokenKind, token) {
|
|
if (isKeyword(tokenKind)) {
|
|
return 3 /* keyword */;
|
|
}
|
|
if (tokenKind === 29 /* LessThanToken */ || tokenKind === 31 /* GreaterThanToken */) {
|
|
if (token && getTypeArgumentOrTypeParameterList(token.parent)) {
|
|
return 10 /* punctuation */;
|
|
}
|
|
}
|
|
if (isPunctuation(tokenKind)) {
|
|
if (token) {
|
|
const parent2 = token.parent;
|
|
if (tokenKind === 63 /* EqualsToken */) {
|
|
if (parent2.kind === 257 /* VariableDeclaration */ || parent2.kind === 169 /* PropertyDeclaration */ || parent2.kind === 166 /* Parameter */ || parent2.kind === 288 /* JsxAttribute */) {
|
|
return 5 /* operator */;
|
|
}
|
|
}
|
|
if (parent2.kind === 223 /* BinaryExpression */ || parent2.kind === 221 /* PrefixUnaryExpression */ || parent2.kind === 222 /* PostfixUnaryExpression */ || parent2.kind === 224 /* ConditionalExpression */) {
|
|
return 5 /* operator */;
|
|
}
|
|
}
|
|
return 10 /* punctuation */;
|
|
} else if (tokenKind === 8 /* NumericLiteral */) {
|
|
return 4 /* numericLiteral */;
|
|
} else if (tokenKind === 9 /* BigIntLiteral */) {
|
|
return 25 /* bigintLiteral */;
|
|
} else if (tokenKind === 10 /* StringLiteral */) {
|
|
return token && token.parent.kind === 288 /* JsxAttribute */ ? 24 /* jsxAttributeStringLiteralValue */ : 6 /* stringLiteral */;
|
|
} else if (tokenKind === 13 /* RegularExpressionLiteral */) {
|
|
return 6 /* stringLiteral */;
|
|
} else if (isTemplateLiteralKind(tokenKind)) {
|
|
return 6 /* stringLiteral */;
|
|
} else if (tokenKind === 11 /* JsxText */) {
|
|
return 23 /* jsxText */;
|
|
} else if (tokenKind === 79 /* Identifier */) {
|
|
if (token) {
|
|
switch (token.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
if (token.parent.name === token) {
|
|
return 11 /* className */;
|
|
}
|
|
return;
|
|
case 165 /* TypeParameter */:
|
|
if (token.parent.name === token) {
|
|
return 15 /* typeParameterName */;
|
|
}
|
|
return;
|
|
case 261 /* InterfaceDeclaration */:
|
|
if (token.parent.name === token) {
|
|
return 13 /* interfaceName */;
|
|
}
|
|
return;
|
|
case 263 /* EnumDeclaration */:
|
|
if (token.parent.name === token) {
|
|
return 12 /* enumName */;
|
|
}
|
|
return;
|
|
case 264 /* ModuleDeclaration */:
|
|
if (token.parent.name === token) {
|
|
return 14 /* moduleName */;
|
|
}
|
|
return;
|
|
case 166 /* Parameter */:
|
|
if (token.parent.name === token) {
|
|
return isThisIdentifier(token) ? 3 /* keyword */ : 17 /* parameterName */;
|
|
}
|
|
return;
|
|
}
|
|
if (isConstTypeReference(token.parent)) {
|
|
return 3 /* keyword */;
|
|
}
|
|
}
|
|
return 2 /* identifier */;
|
|
}
|
|
}
|
|
function processElement(element) {
|
|
if (!element) {
|
|
return;
|
|
}
|
|
if (decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
|
|
checkForClassificationCancellation(cancellationToken, element.kind);
|
|
for (const child of element.getChildren(sourceFile)) {
|
|
if (!tryClassifyNode(child)) {
|
|
processElement(child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/documentHighlights.ts
|
|
var DocumentHighlights;
|
|
((DocumentHighlights3) => {
|
|
function getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch) {
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
if (node.parent && (isJsxOpeningElement(node.parent) && node.parent.tagName === node || isJsxClosingElement(node.parent))) {
|
|
const { openingElement, closingElement } = node.parent.parent;
|
|
const highlightSpans = [openingElement, closingElement].map(({ tagName }) => getHighlightSpanForNode(tagName, sourceFile));
|
|
return [{ fileName: sourceFile.fileName, highlightSpans }];
|
|
}
|
|
return getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) || getSyntacticDocumentHighlights(node, sourceFile);
|
|
}
|
|
DocumentHighlights3.getDocumentHighlights = getDocumentHighlights;
|
|
function getHighlightSpanForNode(node, sourceFile) {
|
|
return {
|
|
fileName: sourceFile.fileName,
|
|
textSpan: createTextSpanFromNode(node, sourceFile),
|
|
kind: "none" /* none */
|
|
};
|
|
}
|
|
function getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) {
|
|
const sourceFilesSet = new Set(sourceFilesToSearch.map((f) => f.fileName));
|
|
const referenceEntries = ts_FindAllReferences_exports.getReferenceEntriesForNode(position, node, program, sourceFilesToSearch, cancellationToken, void 0, sourceFilesSet);
|
|
if (!referenceEntries)
|
|
return void 0;
|
|
const map2 = arrayToMultiMap(referenceEntries.map(ts_FindAllReferences_exports.toHighlightSpan), (e) => e.fileName, (e) => e.span);
|
|
const getCanonicalFileName = createGetCanonicalFileName(program.useCaseSensitiveFileNames());
|
|
return mapDefined(arrayFrom(map2.entries()), ([fileName, highlightSpans]) => {
|
|
if (!sourceFilesSet.has(fileName)) {
|
|
if (!program.redirectTargetsMap.has(toPath(fileName, program.getCurrentDirectory(), getCanonicalFileName))) {
|
|
return void 0;
|
|
}
|
|
const redirectTarget = program.getSourceFile(fileName);
|
|
const redirect = find(sourceFilesToSearch, (f) => !!f.redirectInfo && f.redirectInfo.redirectTarget === redirectTarget);
|
|
fileName = redirect.fileName;
|
|
Debug.assert(sourceFilesSet.has(fileName));
|
|
}
|
|
return { fileName, highlightSpans };
|
|
});
|
|
}
|
|
function getSyntacticDocumentHighlights(node, sourceFile) {
|
|
const highlightSpans = getHighlightSpans(node, sourceFile);
|
|
return highlightSpans && [{ fileName: sourceFile.fileName, highlightSpans }];
|
|
}
|
|
function getHighlightSpans(node, sourceFile) {
|
|
switch (node.kind) {
|
|
case 99 /* IfKeyword */:
|
|
case 91 /* ElseKeyword */:
|
|
return isIfStatement(node.parent) ? getIfElseOccurrences(node.parent, sourceFile) : void 0;
|
|
case 105 /* ReturnKeyword */:
|
|
return useParent(node.parent, isReturnStatement, getReturnOccurrences);
|
|
case 109 /* ThrowKeyword */:
|
|
return useParent(node.parent, isThrowStatement, getThrowOccurrences);
|
|
case 111 /* TryKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
const tryStatement = node.kind === 83 /* CatchKeyword */ ? node.parent.parent : node.parent;
|
|
return useParent(tryStatement, isTryStatement, getTryCatchFinallyOccurrences);
|
|
case 107 /* SwitchKeyword */:
|
|
return useParent(node.parent, isSwitchStatement, getSwitchCaseDefaultOccurrences);
|
|
case 82 /* CaseKeyword */:
|
|
case 88 /* DefaultKeyword */: {
|
|
if (isDefaultClause(node.parent) || isCaseClause(node.parent)) {
|
|
return useParent(node.parent.parent.parent, isSwitchStatement, getSwitchCaseDefaultOccurrences);
|
|
}
|
|
return void 0;
|
|
}
|
|
case 81 /* BreakKeyword */:
|
|
case 86 /* ContinueKeyword */:
|
|
return useParent(node.parent, isBreakOrContinueStatement, getBreakOrContinueStatementOccurrences);
|
|
case 97 /* ForKeyword */:
|
|
case 115 /* WhileKeyword */:
|
|
case 90 /* DoKeyword */:
|
|
return useParent(node.parent, (n) => isIterationStatement(n, true), getLoopBreakContinueOccurrences);
|
|
case 135 /* ConstructorKeyword */:
|
|
return getFromAllDeclarations(isConstructorDeclaration, [135 /* ConstructorKeyword */]);
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
return getFromAllDeclarations(isAccessor, [137 /* GetKeyword */, 151 /* SetKeyword */]);
|
|
case 133 /* AwaitKeyword */:
|
|
return useParent(node.parent, isAwaitExpression, getAsyncAndAwaitOccurrences);
|
|
case 132 /* AsyncKeyword */:
|
|
return highlightSpans(getAsyncAndAwaitOccurrences(node));
|
|
case 125 /* YieldKeyword */:
|
|
return highlightSpans(getYieldOccurrences(node));
|
|
case 101 /* InKeyword */:
|
|
return void 0;
|
|
default:
|
|
return isModifierKind(node.kind) && (isDeclaration(node.parent) || isVariableStatement(node.parent)) ? highlightSpans(getModifierOccurrences(node.kind, node.parent)) : void 0;
|
|
}
|
|
function getFromAllDeclarations(nodeTest, keywords) {
|
|
return useParent(node.parent, nodeTest, (decl) => mapDefined(decl.symbol.declarations, (d) => nodeTest(d) ? find(d.getChildren(sourceFile), (c) => contains(keywords, c.kind)) : void 0));
|
|
}
|
|
function useParent(node2, nodeTest, getNodes4) {
|
|
return nodeTest(node2) ? highlightSpans(getNodes4(node2, sourceFile)) : void 0;
|
|
}
|
|
function highlightSpans(nodes) {
|
|
return nodes && nodes.map((node2) => getHighlightSpanForNode(node2, sourceFile));
|
|
}
|
|
}
|
|
function aggregateOwnedThrowStatements(node) {
|
|
if (isThrowStatement(node)) {
|
|
return [node];
|
|
} else if (isTryStatement(node)) {
|
|
return concatenate(
|
|
node.catchClause ? aggregateOwnedThrowStatements(node.catchClause) : node.tryBlock && aggregateOwnedThrowStatements(node.tryBlock),
|
|
node.finallyBlock && aggregateOwnedThrowStatements(node.finallyBlock)
|
|
);
|
|
}
|
|
return isFunctionLike(node) ? void 0 : flatMapChildren(node, aggregateOwnedThrowStatements);
|
|
}
|
|
function getThrowStatementOwner(throwStatement) {
|
|
let child = throwStatement;
|
|
while (child.parent) {
|
|
const parent2 = child.parent;
|
|
if (isFunctionBlock(parent2) || parent2.kind === 308 /* SourceFile */) {
|
|
return parent2;
|
|
}
|
|
if (isTryStatement(parent2) && parent2.tryBlock === child && parent2.catchClause) {
|
|
return child;
|
|
}
|
|
child = parent2;
|
|
}
|
|
return void 0;
|
|
}
|
|
function aggregateAllBreakAndContinueStatements(node) {
|
|
return isBreakOrContinueStatement(node) ? [node] : isFunctionLike(node) ? void 0 : flatMapChildren(node, aggregateAllBreakAndContinueStatements);
|
|
}
|
|
function flatMapChildren(node, cb) {
|
|
const result = [];
|
|
node.forEachChild((child) => {
|
|
const value = cb(child);
|
|
if (value !== void 0) {
|
|
result.push(...toArray(value));
|
|
}
|
|
});
|
|
return result;
|
|
}
|
|
function ownsBreakOrContinueStatement(owner, statement) {
|
|
const actualOwner = getBreakOrContinueOwner(statement);
|
|
return !!actualOwner && actualOwner === owner;
|
|
}
|
|
function getBreakOrContinueOwner(statement) {
|
|
return findAncestor(statement, (node) => {
|
|
switch (node.kind) {
|
|
case 252 /* SwitchStatement */:
|
|
if (statement.kind === 248 /* ContinueStatement */) {
|
|
return false;
|
|
}
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 243 /* DoStatement */:
|
|
return !statement.label || isLabeledBy(node, statement.label.escapedText);
|
|
default:
|
|
return isFunctionLike(node) && "quit";
|
|
}
|
|
});
|
|
}
|
|
function getModifierOccurrences(modifier, declaration) {
|
|
return mapDefined(getNodesToSearchForModifier(declaration, modifierToFlag(modifier)), (node) => findModifier(node, modifier));
|
|
}
|
|
function getNodesToSearchForModifier(declaration, modifierFlag) {
|
|
const container = declaration.parent;
|
|
switch (container.kind) {
|
|
case 265 /* ModuleBlock */:
|
|
case 308 /* SourceFile */:
|
|
case 238 /* Block */:
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
if (modifierFlag & 256 /* Abstract */ && isClassDeclaration(declaration)) {
|
|
return [...declaration.members, declaration];
|
|
} else {
|
|
return container.statements;
|
|
}
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return [...container.parameters, ...isClassLike(container.parent) ? container.parent.members : []];
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 184 /* TypeLiteral */:
|
|
const nodes = container.members;
|
|
if (modifierFlag & (28 /* AccessibilityModifier */ | 64 /* Readonly */)) {
|
|
const constructor = find(container.members, isConstructorDeclaration);
|
|
if (constructor) {
|
|
return [...nodes, ...constructor.parameters];
|
|
}
|
|
} else if (modifierFlag & 256 /* Abstract */) {
|
|
return [...nodes, container];
|
|
}
|
|
return nodes;
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return void 0;
|
|
default:
|
|
Debug.assertNever(container, "Invalid container kind.");
|
|
}
|
|
}
|
|
function pushKeywordIf(keywordList, token, ...expected) {
|
|
if (token && contains(expected, token.kind)) {
|
|
keywordList.push(token);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getLoopBreakContinueOccurrences(loopNode) {
|
|
const keywords = [];
|
|
if (pushKeywordIf(keywords, loopNode.getFirstToken(), 97 /* ForKeyword */, 115 /* WhileKeyword */, 90 /* DoKeyword */)) {
|
|
if (loopNode.kind === 243 /* DoStatement */) {
|
|
const loopTokens = loopNode.getChildren();
|
|
for (let i = loopTokens.length - 1; i >= 0; i--) {
|
|
if (pushKeywordIf(keywords, loopTokens[i], 115 /* WhileKeyword */)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
forEach(aggregateAllBreakAndContinueStatements(loopNode.statement), (statement) => {
|
|
if (ownsBreakOrContinueStatement(loopNode, statement)) {
|
|
pushKeywordIf(keywords, statement.getFirstToken(), 81 /* BreakKeyword */, 86 /* ContinueKeyword */);
|
|
}
|
|
});
|
|
return keywords;
|
|
}
|
|
function getBreakOrContinueStatementOccurrences(breakOrContinueStatement) {
|
|
const owner = getBreakOrContinueOwner(breakOrContinueStatement);
|
|
if (owner) {
|
|
switch (owner.kind) {
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return getLoopBreakContinueOccurrences(owner);
|
|
case 252 /* SwitchStatement */:
|
|
return getSwitchCaseDefaultOccurrences(owner);
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSwitchCaseDefaultOccurrences(switchStatement) {
|
|
const keywords = [];
|
|
pushKeywordIf(keywords, switchStatement.getFirstToken(), 107 /* SwitchKeyword */);
|
|
forEach(switchStatement.caseBlock.clauses, (clause) => {
|
|
pushKeywordIf(keywords, clause.getFirstToken(), 82 /* CaseKeyword */, 88 /* DefaultKeyword */);
|
|
forEach(aggregateAllBreakAndContinueStatements(clause), (statement) => {
|
|
if (ownsBreakOrContinueStatement(switchStatement, statement)) {
|
|
pushKeywordIf(keywords, statement.getFirstToken(), 81 /* BreakKeyword */);
|
|
}
|
|
});
|
|
});
|
|
return keywords;
|
|
}
|
|
function getTryCatchFinallyOccurrences(tryStatement, sourceFile) {
|
|
const keywords = [];
|
|
pushKeywordIf(keywords, tryStatement.getFirstToken(), 111 /* TryKeyword */);
|
|
if (tryStatement.catchClause) {
|
|
pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 83 /* CatchKeyword */);
|
|
}
|
|
if (tryStatement.finallyBlock) {
|
|
const finallyKeyword = findChildOfKind(tryStatement, 96 /* FinallyKeyword */, sourceFile);
|
|
pushKeywordIf(keywords, finallyKeyword, 96 /* FinallyKeyword */);
|
|
}
|
|
return keywords;
|
|
}
|
|
function getThrowOccurrences(throwStatement, sourceFile) {
|
|
const owner = getThrowStatementOwner(throwStatement);
|
|
if (!owner) {
|
|
return void 0;
|
|
}
|
|
const keywords = [];
|
|
forEach(aggregateOwnedThrowStatements(owner), (throwStatement2) => {
|
|
keywords.push(findChildOfKind(throwStatement2, 109 /* ThrowKeyword */, sourceFile));
|
|
});
|
|
if (isFunctionBlock(owner)) {
|
|
forEachReturnStatement(owner, (returnStatement) => {
|
|
keywords.push(findChildOfKind(returnStatement, 105 /* ReturnKeyword */, sourceFile));
|
|
});
|
|
}
|
|
return keywords;
|
|
}
|
|
function getReturnOccurrences(returnStatement, sourceFile) {
|
|
const func = getContainingFunction(returnStatement);
|
|
if (!func) {
|
|
return void 0;
|
|
}
|
|
const keywords = [];
|
|
forEachReturnStatement(cast(func.body, isBlock), (returnStatement2) => {
|
|
keywords.push(findChildOfKind(returnStatement2, 105 /* ReturnKeyword */, sourceFile));
|
|
});
|
|
forEach(aggregateOwnedThrowStatements(func.body), (throwStatement) => {
|
|
keywords.push(findChildOfKind(throwStatement, 109 /* ThrowKeyword */, sourceFile));
|
|
});
|
|
return keywords;
|
|
}
|
|
function getAsyncAndAwaitOccurrences(node) {
|
|
const func = getContainingFunction(node);
|
|
if (!func) {
|
|
return void 0;
|
|
}
|
|
const keywords = [];
|
|
if (func.modifiers) {
|
|
func.modifiers.forEach((modifier) => {
|
|
pushKeywordIf(keywords, modifier, 132 /* AsyncKeyword */);
|
|
});
|
|
}
|
|
forEachChild(func, (child) => {
|
|
traverseWithoutCrossingFunction(child, (node2) => {
|
|
if (isAwaitExpression(node2)) {
|
|
pushKeywordIf(keywords, node2.getFirstToken(), 133 /* AwaitKeyword */);
|
|
}
|
|
});
|
|
});
|
|
return keywords;
|
|
}
|
|
function getYieldOccurrences(node) {
|
|
const func = getContainingFunction(node);
|
|
if (!func) {
|
|
return void 0;
|
|
}
|
|
const keywords = [];
|
|
forEachChild(func, (child) => {
|
|
traverseWithoutCrossingFunction(child, (node2) => {
|
|
if (isYieldExpression(node2)) {
|
|
pushKeywordIf(keywords, node2.getFirstToken(), 125 /* YieldKeyword */);
|
|
}
|
|
});
|
|
});
|
|
return keywords;
|
|
}
|
|
function traverseWithoutCrossingFunction(node, cb) {
|
|
cb(node);
|
|
if (!isFunctionLike(node) && !isClassLike(node) && !isInterfaceDeclaration(node) && !isModuleDeclaration(node) && !isTypeAliasDeclaration(node) && !isTypeNode(node)) {
|
|
forEachChild(node, (child) => traverseWithoutCrossingFunction(child, cb));
|
|
}
|
|
}
|
|
function getIfElseOccurrences(ifStatement, sourceFile) {
|
|
const keywords = getIfElseKeywords(ifStatement, sourceFile);
|
|
const result = [];
|
|
for (let i = 0; i < keywords.length; i++) {
|
|
if (keywords[i].kind === 91 /* ElseKeyword */ && i < keywords.length - 1) {
|
|
const elseKeyword = keywords[i];
|
|
const ifKeyword = keywords[i + 1];
|
|
let shouldCombineElseAndIf = true;
|
|
for (let j = ifKeyword.getStart(sourceFile) - 1; j >= elseKeyword.end; j--) {
|
|
if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
|
|
shouldCombineElseAndIf = false;
|
|
break;
|
|
}
|
|
}
|
|
if (shouldCombineElseAndIf) {
|
|
result.push({
|
|
fileName: sourceFile.fileName,
|
|
textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
|
|
kind: "reference" /* reference */
|
|
});
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
result.push(getHighlightSpanForNode(keywords[i], sourceFile));
|
|
}
|
|
return result;
|
|
}
|
|
function getIfElseKeywords(ifStatement, sourceFile) {
|
|
const keywords = [];
|
|
while (isIfStatement(ifStatement.parent) && ifStatement.parent.elseStatement === ifStatement) {
|
|
ifStatement = ifStatement.parent;
|
|
}
|
|
while (true) {
|
|
const children = ifStatement.getChildren(sourceFile);
|
|
pushKeywordIf(keywords, children[0], 99 /* IfKeyword */);
|
|
for (let i = children.length - 1; i >= 0; i--) {
|
|
if (pushKeywordIf(keywords, children[i], 91 /* ElseKeyword */)) {
|
|
break;
|
|
}
|
|
}
|
|
if (!ifStatement.elseStatement || !isIfStatement(ifStatement.elseStatement)) {
|
|
break;
|
|
}
|
|
ifStatement = ifStatement.elseStatement;
|
|
}
|
|
return keywords;
|
|
}
|
|
function isLabeledBy(node, labelName) {
|
|
return !!findAncestor(node.parent, (owner) => !isLabeledStatement(owner) ? "quit" : owner.label.escapedText === labelName);
|
|
}
|
|
})(DocumentHighlights || (DocumentHighlights = {}));
|
|
|
|
// src/services/documentRegistry.ts
|
|
function isDocumentRegistryEntry(entry) {
|
|
return !!entry.sourceFile;
|
|
}
|
|
function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) {
|
|
return createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory);
|
|
}
|
|
function createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory = "", externalCache) {
|
|
const buckets = /* @__PURE__ */ new Map();
|
|
const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
|
|
function reportStats() {
|
|
const bucketInfoArray = arrayFrom(buckets.keys()).filter((name) => name && name.charAt(0) === "_").map((name) => {
|
|
const entries = buckets.get(name);
|
|
const sourceFiles = [];
|
|
entries.forEach((entry, name2) => {
|
|
if (isDocumentRegistryEntry(entry)) {
|
|
sourceFiles.push({
|
|
name: name2,
|
|
scriptKind: entry.sourceFile.scriptKind,
|
|
refCount: entry.languageServiceRefCount
|
|
});
|
|
} else {
|
|
entry.forEach((value, scriptKind) => sourceFiles.push({ name: name2, scriptKind, refCount: value.languageServiceRefCount }));
|
|
}
|
|
});
|
|
sourceFiles.sort((x, y) => y.refCount - x.refCount);
|
|
return {
|
|
bucket: name,
|
|
sourceFiles
|
|
};
|
|
});
|
|
return JSON.stringify(bucketInfoArray, void 0, 2);
|
|
}
|
|
function getCompilationSettings(settingsOrHost) {
|
|
if (typeof settingsOrHost.getCompilationSettings === "function") {
|
|
return settingsOrHost.getCompilationSettings();
|
|
}
|
|
return settingsOrHost;
|
|
}
|
|
function acquireDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
|
|
const path = toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
|
|
return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
|
|
}
|
|
function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
|
|
return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version2, true, scriptKind, languageVersionOrOptions);
|
|
}
|
|
function updateDocument(fileName, compilationSettings, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
|
|
const path = toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
const key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings));
|
|
return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions);
|
|
}
|
|
function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version2, scriptKind, languageVersionOrOptions) {
|
|
return acquireOrUpdateDocument(fileName, path, getCompilationSettings(compilationSettings), key, scriptSnapshot, version2, false, scriptKind, languageVersionOrOptions);
|
|
}
|
|
function getDocumentRegistryEntry(bucketEntry, scriptKind) {
|
|
const entry = isDocumentRegistryEntry(bucketEntry) ? bucketEntry : bucketEntry.get(Debug.checkDefined(scriptKind, "If there are more than one scriptKind's for same document the scriptKind should be provided"));
|
|
Debug.assert(scriptKind === void 0 || !entry || entry.sourceFile.scriptKind === scriptKind, `Script kind should match provided ScriptKind:${scriptKind} and sourceFile.scriptKind: ${entry == null ? void 0 : entry.sourceFile.scriptKind}, !entry: ${!entry}`);
|
|
return entry;
|
|
}
|
|
function acquireOrUpdateDocument(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version2, acquiring, scriptKind, languageVersionOrOptions) {
|
|
var _a2, _b, _c, _d;
|
|
scriptKind = ensureScriptKind(fileName, scriptKind);
|
|
const compilationSettings = getCompilationSettings(compilationSettingsOrHost);
|
|
const host = compilationSettingsOrHost === compilationSettings ? void 0 : compilationSettingsOrHost;
|
|
const scriptTarget = scriptKind === 6 /* JSON */ ? 100 /* JSON */ : getEmitScriptTarget(compilationSettings);
|
|
const sourceFileOptions = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : {
|
|
languageVersion: scriptTarget,
|
|
impliedNodeFormat: host && getImpliedNodeFormatForFile(path, (_d = (_c = (_b = (_a2 = host.getCompilerHost) == null ? void 0 : _a2.call(host)) == null ? void 0 : _b.getModuleResolutionCache) == null ? void 0 : _c.call(_b)) == null ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings),
|
|
setExternalModuleIndicator: getSetExternalModuleIndicator(compilationSettings)
|
|
};
|
|
sourceFileOptions.languageVersion = scriptTarget;
|
|
const oldBucketCount = buckets.size;
|
|
const keyWithMode = getDocumentRegistryBucketKeyWithMode(key, sourceFileOptions.impliedNodeFormat);
|
|
const bucket = getOrUpdate(buckets, keyWithMode, () => /* @__PURE__ */ new Map());
|
|
if (tracing) {
|
|
if (buckets.size > oldBucketCount) {
|
|
tracing.instant(tracing.Phase.Session, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode });
|
|
}
|
|
const otherBucketKey = !isDeclarationFileName(path) && forEachEntry(buckets, (bucket2, bucketKey) => bucketKey !== keyWithMode && bucket2.has(path) && bucketKey);
|
|
if (otherBucketKey) {
|
|
tracing.instant(tracing.Phase.Session, "documentRegistryBucketOverlap", { path, key1: otherBucketKey, key2: keyWithMode });
|
|
}
|
|
}
|
|
const bucketEntry = bucket.get(path);
|
|
let entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
|
|
if (!entry && externalCache) {
|
|
const sourceFile = externalCache.getDocument(keyWithMode, path);
|
|
if (sourceFile) {
|
|
Debug.assert(acquiring);
|
|
entry = {
|
|
sourceFile,
|
|
languageServiceRefCount: 0
|
|
};
|
|
setBucketEntry();
|
|
}
|
|
}
|
|
if (!entry) {
|
|
const sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, sourceFileOptions, version2, false, scriptKind);
|
|
if (externalCache) {
|
|
externalCache.setDocument(keyWithMode, path, sourceFile);
|
|
}
|
|
entry = {
|
|
sourceFile,
|
|
languageServiceRefCount: 1
|
|
};
|
|
setBucketEntry();
|
|
} else {
|
|
if (entry.sourceFile.version !== version2) {
|
|
entry.sourceFile = updateLanguageServiceSourceFile(
|
|
entry.sourceFile,
|
|
scriptSnapshot,
|
|
version2,
|
|
scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot)
|
|
);
|
|
if (externalCache) {
|
|
externalCache.setDocument(keyWithMode, path, entry.sourceFile);
|
|
}
|
|
}
|
|
if (acquiring) {
|
|
entry.languageServiceRefCount++;
|
|
}
|
|
}
|
|
Debug.assert(entry.languageServiceRefCount !== 0);
|
|
return entry.sourceFile;
|
|
function setBucketEntry() {
|
|
if (!bucketEntry) {
|
|
bucket.set(path, entry);
|
|
} else if (isDocumentRegistryEntry(bucketEntry)) {
|
|
const scriptKindMap = /* @__PURE__ */ new Map();
|
|
scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry);
|
|
scriptKindMap.set(scriptKind, entry);
|
|
bucket.set(path, scriptKindMap);
|
|
} else {
|
|
bucketEntry.set(scriptKind, entry);
|
|
}
|
|
}
|
|
}
|
|
function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) {
|
|
const path = toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
const key = getKeyForCompilationSettings(compilationSettings);
|
|
return releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat);
|
|
}
|
|
function releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat) {
|
|
const bucket = Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat)));
|
|
const bucketEntry = bucket.get(path);
|
|
const entry = getDocumentRegistryEntry(bucketEntry, scriptKind);
|
|
entry.languageServiceRefCount--;
|
|
Debug.assert(entry.languageServiceRefCount >= 0);
|
|
if (entry.languageServiceRefCount === 0) {
|
|
if (isDocumentRegistryEntry(bucketEntry)) {
|
|
bucket.delete(path);
|
|
} else {
|
|
bucketEntry.delete(scriptKind);
|
|
if (bucketEntry.size === 1) {
|
|
bucket.set(path, firstDefinedIterator(bucketEntry.values(), identity));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getLanguageServiceRefCounts(path, scriptKind) {
|
|
return arrayFrom(buckets.entries(), ([key, bucket]) => {
|
|
const bucketEntry = bucket.get(path);
|
|
const entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind);
|
|
return [key, entry && entry.languageServiceRefCount];
|
|
});
|
|
}
|
|
return {
|
|
acquireDocument,
|
|
acquireDocumentWithKey,
|
|
updateDocument,
|
|
updateDocumentWithKey,
|
|
releaseDocument,
|
|
releaseDocumentWithKey,
|
|
getLanguageServiceRefCounts,
|
|
reportStats,
|
|
getKeyForCompilationSettings
|
|
};
|
|
}
|
|
function compilerOptionValueToString(value) {
|
|
var _a2;
|
|
if (value === null || typeof value !== "object") {
|
|
return "" + value;
|
|
}
|
|
if (isArray(value)) {
|
|
return `[${(_a2 = map(value, (e) => compilerOptionValueToString(e))) == null ? void 0 : _a2.join(",")}]`;
|
|
}
|
|
let str = "{";
|
|
for (const key in value) {
|
|
if (hasProperty(value, key)) {
|
|
str += `${key}: ${compilerOptionValueToString(value[key])}`;
|
|
}
|
|
}
|
|
return str + "}";
|
|
}
|
|
function getKeyForCompilationSettings(settings) {
|
|
return sourceFileAffectingCompilerOptions.map((option) => compilerOptionValueToString(getCompilerOptionValue(settings, option))).join("|") + (settings.pathsBasePath ? `|${settings.pathsBasePath}` : void 0);
|
|
}
|
|
function getDocumentRegistryBucketKeyWithMode(key, mode) {
|
|
return mode ? `${key}|${mode}` : key;
|
|
}
|
|
|
|
// src/services/getEditsForFileRename.ts
|
|
function getEditsForFileRename(program, oldFileOrDirPath, newFileOrDirPath, host, formatContext, preferences, sourceMapper) {
|
|
const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
const oldToNew = getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper);
|
|
const newToOld = getPathUpdater(newFileOrDirPath, oldFileOrDirPath, getCanonicalFileName, sourceMapper);
|
|
return ts_textChanges_exports.ChangeTracker.with({ host, formatContext, preferences }, (changeTracker) => {
|
|
updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, host.getCurrentDirectory(), useCaseSensitiveFileNames);
|
|
updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName);
|
|
});
|
|
}
|
|
function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) {
|
|
const canonicalOldPath = getCanonicalFileName(oldFileOrDirPath);
|
|
return (path) => {
|
|
const originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path, pos: 0 });
|
|
const updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path);
|
|
return originalPath ? updatedPath === void 0 ? void 0 : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path, getCanonicalFileName) : updatedPath;
|
|
};
|
|
function getUpdatedPath(pathToUpdate) {
|
|
if (getCanonicalFileName(pathToUpdate) === canonicalOldPath)
|
|
return newFileOrDirPath;
|
|
const suffix = tryRemoveDirectoryPrefix(pathToUpdate, canonicalOldPath, getCanonicalFileName);
|
|
return suffix === void 0 ? void 0 : newFileOrDirPath + "/" + suffix;
|
|
}
|
|
}
|
|
function makeCorrespondingRelativeChange(a0, b0, a1, getCanonicalFileName) {
|
|
const rel = getRelativePathFromFile(a0, b0, getCanonicalFileName);
|
|
return combinePathsSafe(getDirectoryPath(a1), rel);
|
|
}
|
|
function updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, currentDirectory, useCaseSensitiveFileNames) {
|
|
const { configFile } = program.getCompilerOptions();
|
|
if (!configFile)
|
|
return;
|
|
const configDir = getDirectoryPath(configFile.fileName);
|
|
const jsonObjectLiteral = getTsConfigObjectLiteralExpression(configFile);
|
|
if (!jsonObjectLiteral)
|
|
return;
|
|
forEachProperty(jsonObjectLiteral, (property, propertyName) => {
|
|
switch (propertyName) {
|
|
case "files":
|
|
case "include":
|
|
case "exclude": {
|
|
const foundExactMatch = updatePaths(property);
|
|
if (foundExactMatch || propertyName !== "include" || !isArrayLiteralExpression(property.initializer))
|
|
return;
|
|
const includes = mapDefined(property.initializer.elements, (e) => isStringLiteral(e) ? e.text : void 0);
|
|
if (includes.length === 0)
|
|
return;
|
|
const matchers = getFileMatcherPatterns(configDir, [], includes, useCaseSensitiveFileNames, currentDirectory);
|
|
if (getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(oldFileOrDirPath) && !getRegexFromPattern(Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(newFileOrDirPath)) {
|
|
changeTracker.insertNodeAfter(configFile, last(property.initializer.elements), factory.createStringLiteral(relativePath(newFileOrDirPath)));
|
|
}
|
|
return;
|
|
}
|
|
case "compilerOptions":
|
|
forEachProperty(property.initializer, (property2, propertyName2) => {
|
|
const option = getOptionFromName(propertyName2);
|
|
if (option && (option.isFilePath || option.type === "list" && option.element.isFilePath)) {
|
|
updatePaths(property2);
|
|
} else if (propertyName2 === "paths") {
|
|
forEachProperty(property2.initializer, (pathsProperty) => {
|
|
if (!isArrayLiteralExpression(pathsProperty.initializer))
|
|
return;
|
|
for (const e of pathsProperty.initializer.elements) {
|
|
tryUpdateString(e);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
});
|
|
function updatePaths(property) {
|
|
const elements = isArrayLiteralExpression(property.initializer) ? property.initializer.elements : [property.initializer];
|
|
let foundExactMatch = false;
|
|
for (const element of elements) {
|
|
foundExactMatch = tryUpdateString(element) || foundExactMatch;
|
|
}
|
|
return foundExactMatch;
|
|
}
|
|
function tryUpdateString(element) {
|
|
if (!isStringLiteral(element))
|
|
return false;
|
|
const elementFileName = combinePathsSafe(configDir, element.text);
|
|
const updated = oldToNew(elementFileName);
|
|
if (updated !== void 0) {
|
|
changeTracker.replaceRangeWithText(configFile, createStringRange(element, configFile), relativePath(updated));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function relativePath(path) {
|
|
return getRelativePathFromDirectory(configDir, path, !useCaseSensitiveFileNames);
|
|
}
|
|
}
|
|
function updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName) {
|
|
const allFiles = program.getSourceFiles();
|
|
for (const sourceFile of allFiles) {
|
|
const newFromOld = oldToNew(sourceFile.fileName);
|
|
const newImportFromPath = newFromOld != null ? newFromOld : sourceFile.fileName;
|
|
const newImportFromDirectory = getDirectoryPath(newImportFromPath);
|
|
const oldFromNew = newToOld(sourceFile.fileName);
|
|
const oldImportFromPath = oldFromNew || sourceFile.fileName;
|
|
const oldImportFromDirectory = getDirectoryPath(oldImportFromPath);
|
|
const importingSourceFileMoved = newFromOld !== void 0 || oldFromNew !== void 0;
|
|
updateImportsWorker(
|
|
sourceFile,
|
|
changeTracker,
|
|
(referenceText) => {
|
|
if (!pathIsRelative(referenceText))
|
|
return void 0;
|
|
const oldAbsolute = combinePathsSafe(oldImportFromDirectory, referenceText);
|
|
const newAbsolute = oldToNew(oldAbsolute);
|
|
return newAbsolute === void 0 ? void 0 : ensurePathIsNonModuleName(getRelativePathFromDirectory(newImportFromDirectory, newAbsolute, getCanonicalFileName));
|
|
},
|
|
(importLiteral) => {
|
|
const importedModuleSymbol = program.getTypeChecker().getSymbolAtLocation(importLiteral);
|
|
if ((importedModuleSymbol == null ? void 0 : importedModuleSymbol.declarations) && importedModuleSymbol.declarations.some((d) => isAmbientModule(d)))
|
|
return void 0;
|
|
const toImport = oldFromNew !== void 0 ? getSourceFileToImportFromResolved(
|
|
importLiteral,
|
|
resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host),
|
|
oldToNew,
|
|
allFiles
|
|
) : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew);
|
|
return toImport !== void 0 && (toImport.updated || importingSourceFileMoved && pathIsRelative(importLiteral.text)) ? ts_moduleSpecifiers_exports.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, createModuleSpecifierResolutionHost(program, host), importLiteral.text) : void 0;
|
|
}
|
|
);
|
|
}
|
|
}
|
|
function combineNormal(pathA, pathB) {
|
|
return normalizePath(combinePaths(pathA, pathB));
|
|
}
|
|
function combinePathsSafe(pathA, pathB) {
|
|
return ensurePathIsNonModuleName(combineNormal(pathA, pathB));
|
|
}
|
|
function getSourceFileToImport(importedModuleSymbol, importLiteral, importingSourceFile, program, host, oldToNew) {
|
|
if (importedModuleSymbol) {
|
|
const oldFileName = find(importedModuleSymbol.declarations, isSourceFile).fileName;
|
|
const newFileName = oldToNew(oldFileName);
|
|
return newFileName === void 0 ? { newFileName: oldFileName, updated: false } : { newFileName, updated: true };
|
|
} else {
|
|
const mode = getModeForUsageLocation(importingSourceFile, importLiteral);
|
|
const resolved = host.resolveModuleNames ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode) : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode);
|
|
return getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, program.getSourceFiles());
|
|
}
|
|
}
|
|
function getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, sourceFiles) {
|
|
if (!resolved)
|
|
return void 0;
|
|
if (resolved.resolvedModule) {
|
|
const result2 = tryChange(resolved.resolvedModule.resolvedFileName);
|
|
if (result2)
|
|
return result2;
|
|
}
|
|
const result = forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJsonExisting) || pathIsRelative(importLiteral.text) && forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJson);
|
|
if (result)
|
|
return result;
|
|
return resolved.resolvedModule && { newFileName: resolved.resolvedModule.resolvedFileName, updated: false };
|
|
function tryChangeWithIgnoringPackageJsonExisting(oldFileName) {
|
|
const newFileName = oldToNew(oldFileName);
|
|
return newFileName && find(sourceFiles, (src) => src.fileName === newFileName) ? tryChangeWithIgnoringPackageJson(oldFileName) : void 0;
|
|
}
|
|
function tryChangeWithIgnoringPackageJson(oldFileName) {
|
|
return !endsWith(oldFileName, "/package.json") ? tryChange(oldFileName) : void 0;
|
|
}
|
|
function tryChange(oldFileName) {
|
|
const newFileName = oldToNew(oldFileName);
|
|
return newFileName && { newFileName, updated: true };
|
|
}
|
|
}
|
|
function updateImportsWorker(sourceFile, changeTracker, updateRef, updateImport2) {
|
|
for (const ref of sourceFile.referencedFiles || emptyArray) {
|
|
const updated = updateRef(ref.fileName);
|
|
if (updated !== void 0 && updated !== sourceFile.text.slice(ref.pos, ref.end))
|
|
changeTracker.replaceRangeWithText(sourceFile, ref, updated);
|
|
}
|
|
for (const importStringLiteral of sourceFile.imports) {
|
|
const updated = updateImport2(importStringLiteral);
|
|
if (updated !== void 0 && updated !== importStringLiteral.text)
|
|
changeTracker.replaceRangeWithText(sourceFile, createStringRange(importStringLiteral, sourceFile), updated);
|
|
}
|
|
}
|
|
function createStringRange(node, sourceFile) {
|
|
return createRange(node.getStart(sourceFile) + 1, node.end - 1);
|
|
}
|
|
function forEachProperty(objectLiteral, cb) {
|
|
if (!isObjectLiteralExpression(objectLiteral))
|
|
return;
|
|
for (const property of objectLiteral.properties) {
|
|
if (isPropertyAssignment(property) && isStringLiteral(property.name)) {
|
|
cb(property, property.name.text);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/patternMatcher.ts
|
|
var PatternMatchKind = /* @__PURE__ */ ((PatternMatchKind2) => {
|
|
PatternMatchKind2[PatternMatchKind2["exact"] = 0] = "exact";
|
|
PatternMatchKind2[PatternMatchKind2["prefix"] = 1] = "prefix";
|
|
PatternMatchKind2[PatternMatchKind2["substring"] = 2] = "substring";
|
|
PatternMatchKind2[PatternMatchKind2["camelCase"] = 3] = "camelCase";
|
|
return PatternMatchKind2;
|
|
})(PatternMatchKind || {});
|
|
function createPatternMatch(kind, isCaseSensitive) {
|
|
return {
|
|
kind,
|
|
isCaseSensitive
|
|
};
|
|
}
|
|
function createPatternMatcher(pattern) {
|
|
const stringToWordSpans = /* @__PURE__ */ new Map();
|
|
const dotSeparatedSegments = pattern.trim().split(".").map((p) => createSegment(p.trim()));
|
|
if (dotSeparatedSegments.some((segment) => !segment.subWordTextChunks.length))
|
|
return void 0;
|
|
return {
|
|
getFullMatch: (containers, candidate) => getFullMatch(containers, candidate, dotSeparatedSegments, stringToWordSpans),
|
|
getMatchForLastSegmentOfPattern: (candidate) => matchSegment(candidate, last(dotSeparatedSegments), stringToWordSpans),
|
|
patternContainsDots: dotSeparatedSegments.length > 1
|
|
};
|
|
}
|
|
function getFullMatch(candidateContainers, candidate, dotSeparatedSegments, stringToWordSpans) {
|
|
const candidateMatch = matchSegment(candidate, last(dotSeparatedSegments), stringToWordSpans);
|
|
if (!candidateMatch) {
|
|
return void 0;
|
|
}
|
|
if (dotSeparatedSegments.length - 1 > candidateContainers.length) {
|
|
return void 0;
|
|
}
|
|
let bestMatch;
|
|
for (let i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i -= 1, j -= 1) {
|
|
bestMatch = betterMatch(bestMatch, matchSegment(candidateContainers[j], dotSeparatedSegments[i], stringToWordSpans));
|
|
}
|
|
return bestMatch;
|
|
}
|
|
function getWordSpans(word, stringToWordSpans) {
|
|
let spans = stringToWordSpans.get(word);
|
|
if (!spans) {
|
|
stringToWordSpans.set(word, spans = breakIntoWordSpans(word));
|
|
}
|
|
return spans;
|
|
}
|
|
function matchTextChunk(candidate, chunk, stringToWordSpans) {
|
|
const index = indexOfIgnoringCase(candidate, chunk.textLowerCase);
|
|
if (index === 0) {
|
|
return createPatternMatch(chunk.text.length === candidate.length ? 0 /* exact */ : 1 /* prefix */, startsWith(candidate, chunk.text));
|
|
}
|
|
if (chunk.isLowerCase) {
|
|
if (index === -1)
|
|
return void 0;
|
|
const wordSpans = getWordSpans(candidate, stringToWordSpans);
|
|
for (const span of wordSpans) {
|
|
if (partStartsWith(candidate, span, chunk.text, true)) {
|
|
return createPatternMatch(2 /* substring */, partStartsWith(candidate, span, chunk.text, false));
|
|
}
|
|
}
|
|
if (chunk.text.length < candidate.length && isUpperCaseLetter(candidate.charCodeAt(index))) {
|
|
return createPatternMatch(2 /* substring */, false);
|
|
}
|
|
} else {
|
|
if (candidate.indexOf(chunk.text) > 0) {
|
|
return createPatternMatch(2 /* substring */, true);
|
|
}
|
|
if (chunk.characterSpans.length > 0) {
|
|
const candidateParts = getWordSpans(candidate, stringToWordSpans);
|
|
const isCaseSensitive = tryCamelCaseMatch(candidate, candidateParts, chunk, false) ? true : tryCamelCaseMatch(candidate, candidateParts, chunk, true) ? false : void 0;
|
|
if (isCaseSensitive !== void 0) {
|
|
return createPatternMatch(3 /* camelCase */, isCaseSensitive);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function matchSegment(candidate, segment, stringToWordSpans) {
|
|
if (every2(segment.totalTextChunk.text, (ch) => ch !== 32 /* space */ && ch !== 42 /* asterisk */)) {
|
|
const match = matchTextChunk(candidate, segment.totalTextChunk, stringToWordSpans);
|
|
if (match)
|
|
return match;
|
|
}
|
|
const subWordTextChunks = segment.subWordTextChunks;
|
|
let bestMatch;
|
|
for (const subWordTextChunk of subWordTextChunks) {
|
|
bestMatch = betterMatch(bestMatch, matchTextChunk(candidate, subWordTextChunk, stringToWordSpans));
|
|
}
|
|
return bestMatch;
|
|
}
|
|
function betterMatch(a, b) {
|
|
return min([a, b], compareMatches);
|
|
}
|
|
function compareMatches(a, b) {
|
|
return a === void 0 ? 1 /* GreaterThan */ : b === void 0 ? -1 /* LessThan */ : compareValues(a.kind, b.kind) || compareBooleans(!a.isCaseSensitive, !b.isCaseSensitive);
|
|
}
|
|
function partStartsWith(candidate, candidateSpan, pattern, ignoreCase, patternSpan = { start: 0, length: pattern.length }) {
|
|
return patternSpan.length <= candidateSpan.length && everyInRange(0, patternSpan.length, (i) => equalChars(pattern.charCodeAt(patternSpan.start + i), candidate.charCodeAt(candidateSpan.start + i), ignoreCase));
|
|
}
|
|
function equalChars(ch1, ch2, ignoreCase) {
|
|
return ignoreCase ? toLowerCase2(ch1) === toLowerCase2(ch2) : ch1 === ch2;
|
|
}
|
|
function tryCamelCaseMatch(candidate, candidateParts, chunk, ignoreCase) {
|
|
const chunkCharacterSpans = chunk.characterSpans;
|
|
let currentCandidate = 0;
|
|
let currentChunkSpan = 0;
|
|
let firstMatch;
|
|
let contiguous;
|
|
while (true) {
|
|
if (currentChunkSpan === chunkCharacterSpans.length) {
|
|
return true;
|
|
} else if (currentCandidate === candidateParts.length) {
|
|
return false;
|
|
}
|
|
let candidatePart = candidateParts[currentCandidate];
|
|
let gotOneMatchThisCandidate = false;
|
|
for (; currentChunkSpan < chunkCharacterSpans.length; currentChunkSpan++) {
|
|
const chunkCharacterSpan = chunkCharacterSpans[currentChunkSpan];
|
|
if (gotOneMatchThisCandidate) {
|
|
if (!isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan - 1].start)) || !isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan].start))) {
|
|
break;
|
|
}
|
|
}
|
|
if (!partStartsWith(candidate, candidatePart, chunk.text, ignoreCase, chunkCharacterSpan)) {
|
|
break;
|
|
}
|
|
gotOneMatchThisCandidate = true;
|
|
firstMatch = firstMatch === void 0 ? currentCandidate : firstMatch;
|
|
contiguous = contiguous === void 0 ? true : contiguous;
|
|
candidatePart = createTextSpan(candidatePart.start + chunkCharacterSpan.length, candidatePart.length - chunkCharacterSpan.length);
|
|
}
|
|
if (!gotOneMatchThisCandidate && contiguous !== void 0) {
|
|
contiguous = false;
|
|
}
|
|
currentCandidate++;
|
|
}
|
|
}
|
|
function createSegment(text) {
|
|
return {
|
|
totalTextChunk: createTextChunk(text),
|
|
subWordTextChunks: breakPatternIntoTextChunks(text)
|
|
};
|
|
}
|
|
function isUpperCaseLetter(ch) {
|
|
if (ch >= 65 /* A */ && ch <= 90 /* Z */) {
|
|
return true;
|
|
}
|
|
if (ch < 127 /* maxAsciiCharacter */ || !isUnicodeIdentifierStart(ch, 99 /* Latest */)) {
|
|
return false;
|
|
}
|
|
const str = String.fromCharCode(ch);
|
|
return str === str.toUpperCase();
|
|
}
|
|
function isLowerCaseLetter(ch) {
|
|
if (ch >= 97 /* a */ && ch <= 122 /* z */) {
|
|
return true;
|
|
}
|
|
if (ch < 127 /* maxAsciiCharacter */ || !isUnicodeIdentifierStart(ch, 99 /* Latest */)) {
|
|
return false;
|
|
}
|
|
const str = String.fromCharCode(ch);
|
|
return str === str.toLowerCase();
|
|
}
|
|
function indexOfIgnoringCase(str, value) {
|
|
const n = str.length - value.length;
|
|
for (let start2 = 0; start2 <= n; start2++) {
|
|
if (every2(value, (valueChar, i) => toLowerCase2(str.charCodeAt(i + start2)) === valueChar)) {
|
|
return start2;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
function toLowerCase2(ch) {
|
|
if (ch >= 65 /* A */ && ch <= 90 /* Z */) {
|
|
return 97 /* a */ + (ch - 65 /* A */);
|
|
}
|
|
if (ch < 127 /* maxAsciiCharacter */) {
|
|
return ch;
|
|
}
|
|
return String.fromCharCode(ch).toLowerCase().charCodeAt(0);
|
|
}
|
|
function isDigit2(ch) {
|
|
return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;
|
|
}
|
|
function isWordChar(ch) {
|
|
return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit2(ch) || ch === 95 /* _ */ || ch === 36 /* $ */;
|
|
}
|
|
function breakPatternIntoTextChunks(pattern) {
|
|
const result = [];
|
|
let wordStart = 0;
|
|
let wordLength = 0;
|
|
for (let i = 0; i < pattern.length; i++) {
|
|
const ch = pattern.charCodeAt(i);
|
|
if (isWordChar(ch)) {
|
|
if (wordLength === 0) {
|
|
wordStart = i;
|
|
}
|
|
wordLength++;
|
|
} else {
|
|
if (wordLength > 0) {
|
|
result.push(createTextChunk(pattern.substr(wordStart, wordLength)));
|
|
wordLength = 0;
|
|
}
|
|
}
|
|
}
|
|
if (wordLength > 0) {
|
|
result.push(createTextChunk(pattern.substr(wordStart, wordLength)));
|
|
}
|
|
return result;
|
|
}
|
|
function createTextChunk(text) {
|
|
const textLowerCase = text.toLowerCase();
|
|
return {
|
|
text,
|
|
textLowerCase,
|
|
isLowerCase: text === textLowerCase,
|
|
characterSpans: breakIntoCharacterSpans(text)
|
|
};
|
|
}
|
|
function breakIntoCharacterSpans(identifier) {
|
|
return breakIntoSpans(identifier, false);
|
|
}
|
|
function breakIntoWordSpans(identifier) {
|
|
return breakIntoSpans(identifier, true);
|
|
}
|
|
function breakIntoSpans(identifier, word) {
|
|
const result = [];
|
|
let wordStart = 0;
|
|
for (let i = 1; i < identifier.length; i++) {
|
|
const lastIsDigit = isDigit2(identifier.charCodeAt(i - 1));
|
|
const currentIsDigit = isDigit2(identifier.charCodeAt(i));
|
|
const hasTransitionFromLowerToUpper = transitionFromLowerToUpper(identifier, word, i);
|
|
const hasTransitionFromUpperToLower = word && transitionFromUpperToLower(identifier, i, wordStart);
|
|
if (charIsPunctuation(identifier.charCodeAt(i - 1)) || charIsPunctuation(identifier.charCodeAt(i)) || lastIsDigit !== currentIsDigit || hasTransitionFromLowerToUpper || hasTransitionFromUpperToLower) {
|
|
if (!isAllPunctuation(identifier, wordStart, i)) {
|
|
result.push(createTextSpan(wordStart, i - wordStart));
|
|
}
|
|
wordStart = i;
|
|
}
|
|
}
|
|
if (!isAllPunctuation(identifier, wordStart, identifier.length)) {
|
|
result.push(createTextSpan(wordStart, identifier.length - wordStart));
|
|
}
|
|
return result;
|
|
}
|
|
function charIsPunctuation(ch) {
|
|
switch (ch) {
|
|
case 33 /* exclamation */:
|
|
case 34 /* doubleQuote */:
|
|
case 35 /* hash */:
|
|
case 37 /* percent */:
|
|
case 38 /* ampersand */:
|
|
case 39 /* singleQuote */:
|
|
case 40 /* openParen */:
|
|
case 41 /* closeParen */:
|
|
case 42 /* asterisk */:
|
|
case 44 /* comma */:
|
|
case 45 /* minus */:
|
|
case 46 /* dot */:
|
|
case 47 /* slash */:
|
|
case 58 /* colon */:
|
|
case 59 /* semicolon */:
|
|
case 63 /* question */:
|
|
case 64 /* at */:
|
|
case 91 /* openBracket */:
|
|
case 92 /* backslash */:
|
|
case 93 /* closeBracket */:
|
|
case 95 /* _ */:
|
|
case 123 /* openBrace */:
|
|
case 125 /* closeBrace */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isAllPunctuation(identifier, start2, end) {
|
|
return every2(identifier, (ch) => charIsPunctuation(ch) && ch !== 95 /* _ */, start2, end);
|
|
}
|
|
function transitionFromUpperToLower(identifier, index, wordStart) {
|
|
return index !== wordStart && index + 1 < identifier.length && isUpperCaseLetter(identifier.charCodeAt(index)) && isLowerCaseLetter(identifier.charCodeAt(index + 1)) && every2(identifier, isUpperCaseLetter, wordStart, index);
|
|
}
|
|
function transitionFromLowerToUpper(identifier, word, index) {
|
|
const lastIsUpper = isUpperCaseLetter(identifier.charCodeAt(index - 1));
|
|
const currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index));
|
|
return currentIsUpper && (!word || !lastIsUpper);
|
|
}
|
|
function everyInRange(start2, end, pred) {
|
|
for (let i = start2; i < end; i++) {
|
|
if (!pred(i)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function every2(s, pred, start2 = 0, end = s.length) {
|
|
return everyInRange(start2, end, (i) => pred(s.charCodeAt(i), i));
|
|
}
|
|
|
|
// src/services/preProcess.ts
|
|
function preProcessFile(sourceText, readImportFiles = true, detectJavaScriptImports = false) {
|
|
const pragmaContext = {
|
|
languageVersion: 1 /* ES5 */,
|
|
pragmas: void 0,
|
|
checkJsDirective: void 0,
|
|
referencedFiles: [],
|
|
typeReferenceDirectives: [],
|
|
libReferenceDirectives: [],
|
|
amdDependencies: [],
|
|
hasNoDefaultLib: void 0,
|
|
moduleName: void 0
|
|
};
|
|
const importedFiles = [];
|
|
let ambientExternalModules;
|
|
let lastToken;
|
|
let currentToken;
|
|
let braceNesting = 0;
|
|
let externalModule = false;
|
|
function nextToken() {
|
|
lastToken = currentToken;
|
|
currentToken = scanner.scan();
|
|
if (currentToken === 18 /* OpenBraceToken */) {
|
|
braceNesting++;
|
|
} else if (currentToken === 19 /* CloseBraceToken */) {
|
|
braceNesting--;
|
|
}
|
|
return currentToken;
|
|
}
|
|
function getFileReference() {
|
|
const fileName = scanner.getTokenValue();
|
|
const pos = scanner.getTokenPos();
|
|
return { fileName, pos, end: pos + fileName.length };
|
|
}
|
|
function recordAmbientExternalModule() {
|
|
if (!ambientExternalModules) {
|
|
ambientExternalModules = [];
|
|
}
|
|
ambientExternalModules.push({ ref: getFileReference(), depth: braceNesting });
|
|
}
|
|
function recordModuleName() {
|
|
importedFiles.push(getFileReference());
|
|
markAsExternalModuleIfTopLevel();
|
|
}
|
|
function markAsExternalModuleIfTopLevel() {
|
|
if (braceNesting === 0) {
|
|
externalModule = true;
|
|
}
|
|
}
|
|
function tryConsumeDeclare() {
|
|
let token = scanner.getToken();
|
|
if (token === 136 /* DeclareKeyword */) {
|
|
token = nextToken();
|
|
if (token === 142 /* ModuleKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordAmbientExternalModule();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function tryConsumeImport() {
|
|
if (lastToken === 24 /* DotToken */) {
|
|
return false;
|
|
}
|
|
let token = scanner.getToken();
|
|
if (token === 100 /* ImportKeyword */) {
|
|
token = nextToken();
|
|
if (token === 20 /* OpenParenToken */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */ || token === 14 /* NoSubstitutionTemplateLiteral */) {
|
|
recordModuleName();
|
|
return true;
|
|
}
|
|
} else if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
return true;
|
|
} else {
|
|
if (token === 154 /* TypeKeyword */) {
|
|
const skipTypeKeyword = scanner.lookAhead(() => {
|
|
const token2 = scanner.scan();
|
|
return token2 !== 158 /* FromKeyword */ && (token2 === 41 /* AsteriskToken */ || token2 === 18 /* OpenBraceToken */ || token2 === 79 /* Identifier */ || isKeyword(token2));
|
|
});
|
|
if (skipTypeKeyword) {
|
|
token = nextToken();
|
|
}
|
|
}
|
|
if (token === 79 /* Identifier */ || isKeyword(token)) {
|
|
token = nextToken();
|
|
if (token === 158 /* FromKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
return true;
|
|
}
|
|
} else if (token === 63 /* EqualsToken */) {
|
|
if (tryConsumeRequireCall(true)) {
|
|
return true;
|
|
}
|
|
} else if (token === 27 /* CommaToken */) {
|
|
token = nextToken();
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
if (token === 18 /* OpenBraceToken */) {
|
|
token = nextToken();
|
|
while (token !== 19 /* CloseBraceToken */ && token !== 1 /* EndOfFileToken */) {
|
|
token = nextToken();
|
|
}
|
|
if (token === 19 /* CloseBraceToken */) {
|
|
token = nextToken();
|
|
if (token === 158 /* FromKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
}
|
|
}
|
|
} else if (token === 41 /* AsteriskToken */) {
|
|
token = nextToken();
|
|
if (token === 128 /* AsKeyword */) {
|
|
token = nextToken();
|
|
if (token === 79 /* Identifier */ || isKeyword(token)) {
|
|
token = nextToken();
|
|
if (token === 158 /* FromKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function tryConsumeExport() {
|
|
let token = scanner.getToken();
|
|
if (token === 93 /* ExportKeyword */) {
|
|
markAsExternalModuleIfTopLevel();
|
|
token = nextToken();
|
|
if (token === 154 /* TypeKeyword */) {
|
|
const skipTypeKeyword = scanner.lookAhead(() => {
|
|
const token2 = scanner.scan();
|
|
return token2 === 41 /* AsteriskToken */ || token2 === 18 /* OpenBraceToken */;
|
|
});
|
|
if (skipTypeKeyword) {
|
|
token = nextToken();
|
|
}
|
|
}
|
|
if (token === 18 /* OpenBraceToken */) {
|
|
token = nextToken();
|
|
while (token !== 19 /* CloseBraceToken */ && token !== 1 /* EndOfFileToken */) {
|
|
token = nextToken();
|
|
}
|
|
if (token === 19 /* CloseBraceToken */) {
|
|
token = nextToken();
|
|
if (token === 158 /* FromKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
}
|
|
}
|
|
} else if (token === 41 /* AsteriskToken */) {
|
|
token = nextToken();
|
|
if (token === 158 /* FromKeyword */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
}
|
|
} else if (token === 100 /* ImportKeyword */) {
|
|
token = nextToken();
|
|
if (token === 154 /* TypeKeyword */) {
|
|
const skipTypeKeyword = scanner.lookAhead(() => {
|
|
const token2 = scanner.scan();
|
|
return token2 === 79 /* Identifier */ || isKeyword(token2);
|
|
});
|
|
if (skipTypeKeyword) {
|
|
token = nextToken();
|
|
}
|
|
}
|
|
if (token === 79 /* Identifier */ || isKeyword(token)) {
|
|
token = nextToken();
|
|
if (token === 63 /* EqualsToken */) {
|
|
if (tryConsumeRequireCall(true)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function tryConsumeRequireCall(skipCurrentToken, allowTemplateLiterals = false) {
|
|
let token = skipCurrentToken ? nextToken() : scanner.getToken();
|
|
if (token === 147 /* RequireKeyword */) {
|
|
token = nextToken();
|
|
if (token === 20 /* OpenParenToken */) {
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */ || allowTemplateLiterals && token === 14 /* NoSubstitutionTemplateLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function tryConsumeDefine() {
|
|
let token = scanner.getToken();
|
|
if (token === 79 /* Identifier */ && scanner.getTokenValue() === "define") {
|
|
token = nextToken();
|
|
if (token !== 20 /* OpenParenToken */) {
|
|
return true;
|
|
}
|
|
token = nextToken();
|
|
if (token === 10 /* StringLiteral */ || token === 14 /* NoSubstitutionTemplateLiteral */) {
|
|
token = nextToken();
|
|
if (token === 27 /* CommaToken */) {
|
|
token = nextToken();
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
if (token !== 22 /* OpenBracketToken */) {
|
|
return true;
|
|
}
|
|
token = nextToken();
|
|
while (token !== 23 /* CloseBracketToken */ && token !== 1 /* EndOfFileToken */) {
|
|
if (token === 10 /* StringLiteral */ || token === 14 /* NoSubstitutionTemplateLiteral */) {
|
|
recordModuleName();
|
|
}
|
|
token = nextToken();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function processImports() {
|
|
scanner.setText(sourceText);
|
|
nextToken();
|
|
while (true) {
|
|
if (scanner.getToken() === 1 /* EndOfFileToken */) {
|
|
break;
|
|
}
|
|
if (scanner.getToken() === 15 /* TemplateHead */) {
|
|
const stack = [scanner.getToken()];
|
|
loop:
|
|
while (length(stack)) {
|
|
const token = scanner.scan();
|
|
switch (token) {
|
|
case 1 /* EndOfFileToken */:
|
|
break loop;
|
|
case 100 /* ImportKeyword */:
|
|
tryConsumeImport();
|
|
break;
|
|
case 15 /* TemplateHead */:
|
|
stack.push(token);
|
|
break;
|
|
case 18 /* OpenBraceToken */:
|
|
if (length(stack)) {
|
|
stack.push(token);
|
|
}
|
|
break;
|
|
case 19 /* CloseBraceToken */:
|
|
if (length(stack)) {
|
|
if (lastOrUndefined(stack) === 15 /* TemplateHead */) {
|
|
if (scanner.reScanTemplateToken(false) === 17 /* TemplateTail */) {
|
|
stack.pop();
|
|
}
|
|
} else {
|
|
stack.pop();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
nextToken();
|
|
}
|
|
if (tryConsumeDeclare() || tryConsumeImport() || tryConsumeExport() || detectJavaScriptImports && (tryConsumeRequireCall(false, true) || tryConsumeDefine())) {
|
|
continue;
|
|
} else {
|
|
nextToken();
|
|
}
|
|
}
|
|
scanner.setText(void 0);
|
|
}
|
|
if (readImportFiles) {
|
|
processImports();
|
|
}
|
|
processCommentPragmas(pragmaContext, sourceText);
|
|
processPragmasIntoFields(pragmaContext, noop);
|
|
if (externalModule) {
|
|
if (ambientExternalModules) {
|
|
for (const decl of ambientExternalModules) {
|
|
importedFiles.push(decl.ref);
|
|
}
|
|
}
|
|
return { referencedFiles: pragmaContext.referencedFiles, typeReferenceDirectives: pragmaContext.typeReferenceDirectives, libReferenceDirectives: pragmaContext.libReferenceDirectives, importedFiles, isLibFile: !!pragmaContext.hasNoDefaultLib, ambientExternalModules: void 0 };
|
|
} else {
|
|
let ambientModuleNames;
|
|
if (ambientExternalModules) {
|
|
for (const decl of ambientExternalModules) {
|
|
if (decl.depth === 0) {
|
|
if (!ambientModuleNames) {
|
|
ambientModuleNames = [];
|
|
}
|
|
ambientModuleNames.push(decl.ref.fileName);
|
|
} else {
|
|
importedFiles.push(decl.ref);
|
|
}
|
|
}
|
|
}
|
|
return { referencedFiles: pragmaContext.referencedFiles, typeReferenceDirectives: pragmaContext.typeReferenceDirectives, libReferenceDirectives: pragmaContext.libReferenceDirectives, importedFiles, isLibFile: !!pragmaContext.hasNoDefaultLib, ambientExternalModules: ambientModuleNames };
|
|
}
|
|
}
|
|
|
|
// src/services/sourcemaps.ts
|
|
var base64UrlRegExp = /^data:(?:application\/json(?:;charset=[uU][tT][fF]-8);base64,([A-Za-z0-9+\/=]+)$)?/;
|
|
function getSourceMapper(host) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
const sourceFileLike = /* @__PURE__ */ new Map();
|
|
const documentPositionMappers = /* @__PURE__ */ new Map();
|
|
return { tryGetSourcePosition, tryGetGeneratedPosition, toLineColumnOffset, clearCache };
|
|
function toPath3(fileName) {
|
|
return toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
}
|
|
function getDocumentPositionMapper2(generatedFileName, sourceFileName) {
|
|
const path = toPath3(generatedFileName);
|
|
const value = documentPositionMappers.get(path);
|
|
if (value)
|
|
return value;
|
|
let mapper;
|
|
if (host.getDocumentPositionMapper) {
|
|
mapper = host.getDocumentPositionMapper(generatedFileName, sourceFileName);
|
|
} else if (host.readFile) {
|
|
const file = getSourceFileLike(generatedFileName);
|
|
mapper = file && getDocumentPositionMapper(
|
|
{ getSourceFileLike, getCanonicalFileName, log: (s) => host.log(s) },
|
|
generatedFileName,
|
|
getLineInfo(file.text, getLineStarts(file)),
|
|
(f) => !host.fileExists || host.fileExists(f) ? host.readFile(f) : void 0
|
|
);
|
|
}
|
|
documentPositionMappers.set(path, mapper || identitySourceMapConsumer);
|
|
return mapper || identitySourceMapConsumer;
|
|
}
|
|
function tryGetSourcePosition(info) {
|
|
if (!isDeclarationFileName(info.fileName))
|
|
return void 0;
|
|
const file = getSourceFile(info.fileName);
|
|
if (!file)
|
|
return void 0;
|
|
const newLoc = getDocumentPositionMapper2(info.fileName).getSourcePosition(info);
|
|
return !newLoc || newLoc === info ? void 0 : tryGetSourcePosition(newLoc) || newLoc;
|
|
}
|
|
function tryGetGeneratedPosition(info) {
|
|
if (isDeclarationFileName(info.fileName))
|
|
return void 0;
|
|
const sourceFile = getSourceFile(info.fileName);
|
|
if (!sourceFile)
|
|
return void 0;
|
|
const program = host.getProgram();
|
|
if (program.isSourceOfProjectReferenceRedirect(sourceFile.fileName)) {
|
|
return void 0;
|
|
}
|
|
const options = program.getCompilerOptions();
|
|
const outPath = outFile(options);
|
|
const declarationPath = outPath ? removeFileExtension(outPath) + ".d.ts" /* Dts */ : getDeclarationEmitOutputFilePathWorker(info.fileName, program.getCompilerOptions(), currentDirectory, program.getCommonSourceDirectory(), getCanonicalFileName);
|
|
if (declarationPath === void 0)
|
|
return void 0;
|
|
const newLoc = getDocumentPositionMapper2(declarationPath, info.fileName).getGeneratedPosition(info);
|
|
return newLoc === info ? void 0 : newLoc;
|
|
}
|
|
function getSourceFile(fileName) {
|
|
const program = host.getProgram();
|
|
if (!program)
|
|
return void 0;
|
|
const path = toPath3(fileName);
|
|
const file = program.getSourceFileByPath(path);
|
|
return file && file.resolvedPath === path ? file : void 0;
|
|
}
|
|
function getOrCreateSourceFileLike(fileName) {
|
|
const path = toPath3(fileName);
|
|
const fileFromCache = sourceFileLike.get(path);
|
|
if (fileFromCache !== void 0)
|
|
return fileFromCache ? fileFromCache : void 0;
|
|
if (!host.readFile || host.fileExists && !host.fileExists(path)) {
|
|
sourceFileLike.set(path, false);
|
|
return void 0;
|
|
}
|
|
const text = host.readFile(path);
|
|
const file = text ? createSourceFileLike(text) : false;
|
|
sourceFileLike.set(path, file);
|
|
return file ? file : void 0;
|
|
}
|
|
function getSourceFileLike(fileName) {
|
|
return !host.getSourceFileLike ? getSourceFile(fileName) || getOrCreateSourceFileLike(fileName) : host.getSourceFileLike(fileName);
|
|
}
|
|
function toLineColumnOffset(fileName, position) {
|
|
const file = getSourceFileLike(fileName);
|
|
return file.getLineAndCharacterOfPosition(position);
|
|
}
|
|
function clearCache() {
|
|
sourceFileLike.clear();
|
|
documentPositionMappers.clear();
|
|
}
|
|
}
|
|
function getDocumentPositionMapper(host, generatedFileName, generatedFileLineInfo, readMapFile) {
|
|
let mapFileName = tryGetSourceMappingURL(generatedFileLineInfo);
|
|
if (mapFileName) {
|
|
const match = base64UrlRegExp.exec(mapFileName);
|
|
if (match) {
|
|
if (match[1]) {
|
|
const base64Object = match[1];
|
|
return convertDocumentToSourceMapper(host, base64decode(sys, base64Object), generatedFileName);
|
|
}
|
|
mapFileName = void 0;
|
|
}
|
|
}
|
|
const possibleMapLocations = [];
|
|
if (mapFileName) {
|
|
possibleMapLocations.push(mapFileName);
|
|
}
|
|
possibleMapLocations.push(generatedFileName + ".map");
|
|
const originalMapFileName = mapFileName && getNormalizedAbsolutePath(mapFileName, getDirectoryPath(generatedFileName));
|
|
for (const location2 of possibleMapLocations) {
|
|
const mapFileName2 = getNormalizedAbsolutePath(location2, getDirectoryPath(generatedFileName));
|
|
const mapFileContents = readMapFile(mapFileName2, originalMapFileName);
|
|
if (isString(mapFileContents)) {
|
|
return convertDocumentToSourceMapper(host, mapFileContents, mapFileName2);
|
|
}
|
|
if (mapFileContents !== void 0) {
|
|
return mapFileContents || void 0;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function convertDocumentToSourceMapper(host, contents, mapFileName) {
|
|
const map2 = tryParseRawSourceMap(contents);
|
|
if (!map2 || !map2.sources || !map2.file || !map2.mappings) {
|
|
return void 0;
|
|
}
|
|
if (map2.sourcesContent && map2.sourcesContent.some(isString))
|
|
return void 0;
|
|
return createDocumentPositionMapper(host, map2, mapFileName);
|
|
}
|
|
function createSourceFileLike(text, lineMap) {
|
|
return {
|
|
text,
|
|
lineMap,
|
|
getLineAndCharacterOfPosition(pos) {
|
|
return computeLineAndCharacterOfPosition(getLineStarts(this), pos);
|
|
}
|
|
};
|
|
}
|
|
|
|
// src/services/suggestionDiagnostics.ts
|
|
var visitedNestedConvertibleFunctions = /* @__PURE__ */ new Map();
|
|
function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) {
|
|
program.getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
const diags = [];
|
|
const checker = program.getTypeChecker();
|
|
const isCommonJSFile = sourceFile.impliedNodeFormat === 1 /* CommonJS */ || fileExtensionIsOneOf(sourceFile.fileName, [".cts" /* Cts */, ".cjs" /* Cjs */]);
|
|
if (!isCommonJSFile && sourceFile.commonJsModuleIndicator && (programContainsEsModules(program) || compilerOptionsIndicateEsModules(program.getCompilerOptions())) && containsTopLevelCommonjs(sourceFile)) {
|
|
diags.push(createDiagnosticForNode(getErrorNodeFromCommonJsIndicator(sourceFile.commonJsModuleIndicator), Diagnostics.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module));
|
|
}
|
|
const isJsFile = isSourceFileJS(sourceFile);
|
|
visitedNestedConvertibleFunctions.clear();
|
|
check(sourceFile);
|
|
if (getAllowSyntheticDefaultImports(program.getCompilerOptions())) {
|
|
for (const moduleSpecifier of sourceFile.imports) {
|
|
const importNode = importFromModuleSpecifier(moduleSpecifier);
|
|
const name = importNameForConvertToDefaultImport(importNode);
|
|
if (!name)
|
|
continue;
|
|
const module2 = getResolvedModule(sourceFile, moduleSpecifier.text, getModeForUsageLocation(sourceFile, moduleSpecifier));
|
|
const resolvedFile = module2 && program.getSourceFile(module2.resolvedFileName);
|
|
if (resolvedFile && resolvedFile.externalModuleIndicator && resolvedFile.externalModuleIndicator !== true && isExportAssignment(resolvedFile.externalModuleIndicator) && resolvedFile.externalModuleIndicator.isExportEquals) {
|
|
diags.push(createDiagnosticForNode(name, Diagnostics.Import_may_be_converted_to_a_default_import));
|
|
}
|
|
}
|
|
}
|
|
addRange(diags, sourceFile.bindSuggestionDiagnostics);
|
|
addRange(diags, program.getSuggestionDiagnostics(sourceFile, cancellationToken));
|
|
return diags.sort((d1, d2) => d1.start - d2.start);
|
|
function check(node) {
|
|
if (isJsFile) {
|
|
if (canBeConvertedToClass(node, checker)) {
|
|
diags.push(createDiagnosticForNode(isVariableDeclaration(node.parent) ? node.parent.name : node, Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration));
|
|
}
|
|
} else {
|
|
if (isVariableStatement(node) && node.parent === sourceFile && node.declarationList.flags & 2 /* Const */ && node.declarationList.declarations.length === 1) {
|
|
const init = node.declarationList.declarations[0].initializer;
|
|
if (init && isRequireCall(init, true)) {
|
|
diags.push(createDiagnosticForNode(init, Diagnostics.require_call_may_be_converted_to_an_import));
|
|
}
|
|
}
|
|
if (ts_codefix_exports.parameterShouldGetTypeFromJSDoc(node)) {
|
|
diags.push(createDiagnosticForNode(node.name || node, Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types));
|
|
}
|
|
}
|
|
if (canBeConvertedToAsync(node)) {
|
|
addConvertToAsyncFunctionDiagnostics(node, checker, diags);
|
|
}
|
|
node.forEachChild(check);
|
|
}
|
|
}
|
|
function containsTopLevelCommonjs(sourceFile) {
|
|
return sourceFile.statements.some((statement) => {
|
|
switch (statement.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return statement.declarationList.declarations.some((decl) => !!decl.initializer && isRequireCall(propertyAccessLeftHandSide(decl.initializer), true));
|
|
case 241 /* ExpressionStatement */: {
|
|
const { expression } = statement;
|
|
if (!isBinaryExpression(expression))
|
|
return isRequireCall(expression, true);
|
|
const kind = getAssignmentDeclarationKind(expression);
|
|
return kind === 1 /* ExportsProperty */ || kind === 2 /* ModuleExports */;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
});
|
|
}
|
|
function propertyAccessLeftHandSide(node) {
|
|
return isPropertyAccessExpression(node) ? propertyAccessLeftHandSide(node.expression) : node;
|
|
}
|
|
function importNameForConvertToDefaultImport(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
const { importClause, moduleSpecifier } = node;
|
|
return importClause && !importClause.name && importClause.namedBindings && importClause.namedBindings.kind === 271 /* NamespaceImport */ && isStringLiteral(moduleSpecifier) ? importClause.namedBindings.name : void 0;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.name;
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function addConvertToAsyncFunctionDiagnostics(node, checker, diags) {
|
|
if (isConvertibleFunction(node, checker) && !visitedNestedConvertibleFunctions.has(getKeyFromNode(node))) {
|
|
diags.push(createDiagnosticForNode(
|
|
!node.name && isVariableDeclaration(node.parent) && isIdentifier(node.parent.name) ? node.parent.name : node,
|
|
Diagnostics.This_may_be_converted_to_an_async_function
|
|
));
|
|
}
|
|
}
|
|
function isConvertibleFunction(node, checker) {
|
|
return !isAsyncFunction(node) && node.body && isBlock(node.body) && hasReturnStatementWithPromiseHandler(node.body, checker) && returnsPromise(node, checker);
|
|
}
|
|
function returnsPromise(node, checker) {
|
|
const signature = checker.getSignatureFromDeclaration(node);
|
|
const returnType = signature ? checker.getReturnTypeOfSignature(signature) : void 0;
|
|
return !!returnType && !!checker.getPromisedTypeOfPromise(returnType);
|
|
}
|
|
function getErrorNodeFromCommonJsIndicator(commonJsModuleIndicator) {
|
|
return isBinaryExpression(commonJsModuleIndicator) ? commonJsModuleIndicator.left : commonJsModuleIndicator;
|
|
}
|
|
function hasReturnStatementWithPromiseHandler(body, checker) {
|
|
return !!forEachReturnStatement(body, (statement) => isReturnStatementWithFixablePromiseHandler(statement, checker));
|
|
}
|
|
function isReturnStatementWithFixablePromiseHandler(node, checker) {
|
|
return isReturnStatement(node) && !!node.expression && isFixablePromiseHandler(node.expression, checker);
|
|
}
|
|
function isFixablePromiseHandler(node, checker) {
|
|
if (!isPromiseHandler(node) || !hasSupportedNumberOfArguments(node) || !node.arguments.every((arg) => isFixablePromiseArgument(arg, checker))) {
|
|
return false;
|
|
}
|
|
let currentNode = node.expression.expression;
|
|
while (isPromiseHandler(currentNode) || isPropertyAccessExpression(currentNode)) {
|
|
if (isCallExpression(currentNode)) {
|
|
if (!hasSupportedNumberOfArguments(currentNode) || !currentNode.arguments.every((arg) => isFixablePromiseArgument(arg, checker))) {
|
|
return false;
|
|
}
|
|
currentNode = currentNode.expression.expression;
|
|
} else {
|
|
currentNode = currentNode.expression;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function isPromiseHandler(node) {
|
|
return isCallExpression(node) && (hasPropertyAccessExpressionWithName(node, "then") || hasPropertyAccessExpressionWithName(node, "catch") || hasPropertyAccessExpressionWithName(node, "finally"));
|
|
}
|
|
function hasSupportedNumberOfArguments(node) {
|
|
const name = node.expression.name.text;
|
|
const maxArguments = name === "then" ? 2 : name === "catch" ? 1 : name === "finally" ? 1 : 0;
|
|
if (node.arguments.length > maxArguments)
|
|
return false;
|
|
if (node.arguments.length < maxArguments)
|
|
return true;
|
|
return maxArguments === 1 || some(node.arguments, (arg) => {
|
|
return arg.kind === 104 /* NullKeyword */ || isIdentifier(arg) && arg.text === "undefined";
|
|
});
|
|
}
|
|
function isFixablePromiseArgument(arg, checker) {
|
|
switch (arg.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
const functionFlags = getFunctionFlags(arg);
|
|
if (functionFlags & 1 /* Generator */) {
|
|
return false;
|
|
}
|
|
case 216 /* ArrowFunction */:
|
|
visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true);
|
|
case 104 /* NullKeyword */:
|
|
return true;
|
|
case 79 /* Identifier */:
|
|
case 208 /* PropertyAccessExpression */: {
|
|
const symbol = checker.getSymbolAtLocation(arg);
|
|
if (!symbol) {
|
|
return false;
|
|
}
|
|
return checker.isUndefinedSymbol(symbol) || some(skipAlias(symbol, checker).declarations, (d) => isFunctionLike(d) || hasInitializer(d) && !!d.initializer && isFunctionLike(d.initializer));
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getKeyFromNode(exp) {
|
|
return `${exp.pos.toString()}:${exp.end.toString()}`;
|
|
}
|
|
function canBeConvertedToClass(node, checker) {
|
|
var _a2, _b, _c, _d;
|
|
if (node.kind === 215 /* FunctionExpression */) {
|
|
if (isVariableDeclaration(node.parent) && ((_a2 = node.symbol.members) == null ? void 0 : _a2.size)) {
|
|
return true;
|
|
}
|
|
const symbol = checker.getSymbolOfExpando(node, false);
|
|
return !!(symbol && (((_b = symbol.exports) == null ? void 0 : _b.size) || ((_c = symbol.members) == null ? void 0 : _c.size)));
|
|
}
|
|
if (node.kind === 259 /* FunctionDeclaration */) {
|
|
return !!((_d = node.symbol.members) == null ? void 0 : _d.size);
|
|
}
|
|
return false;
|
|
}
|
|
function canBeConvertedToAsync(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// src/services/transpile.ts
|
|
function transpileModule(input, transpileOptions) {
|
|
const diagnostics = [];
|
|
const options = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : {};
|
|
const defaultOptions = getDefaultCompilerOptions2();
|
|
for (const key in defaultOptions) {
|
|
if (hasProperty(defaultOptions, key) && options[key] === void 0) {
|
|
options[key] = defaultOptions[key];
|
|
}
|
|
}
|
|
for (const option of transpileOptionValueCompilerOptions) {
|
|
options[option.name] = option.transpileOptionValue;
|
|
}
|
|
options.suppressOutputPathCheck = true;
|
|
options.allowNonTsExtensions = true;
|
|
const newLine = getNewLineCharacter(options);
|
|
const compilerHost = {
|
|
getSourceFile: (fileName) => fileName === normalizePath(inputFileName) ? sourceFile : void 0,
|
|
writeFile: (name, text) => {
|
|
if (fileExtensionIs(name, ".map")) {
|
|
Debug.assertEqual(sourceMapText, void 0, "Unexpected multiple source map outputs, file:", name);
|
|
sourceMapText = text;
|
|
} else {
|
|
Debug.assertEqual(outputText, void 0, "Unexpected multiple outputs, file:", name);
|
|
outputText = text;
|
|
}
|
|
},
|
|
getDefaultLibFileName: () => "lib.d.ts",
|
|
useCaseSensitiveFileNames: () => false,
|
|
getCanonicalFileName: (fileName) => fileName,
|
|
getCurrentDirectory: () => "",
|
|
getNewLine: () => newLine,
|
|
fileExists: (fileName) => fileName === inputFileName,
|
|
readFile: () => "",
|
|
directoryExists: () => true,
|
|
getDirectories: () => []
|
|
};
|
|
const inputFileName = transpileOptions.fileName || (transpileOptions.compilerOptions && transpileOptions.compilerOptions.jsx ? "module.tsx" : "module.ts");
|
|
const sourceFile = createSourceFile(
|
|
inputFileName,
|
|
input,
|
|
{
|
|
languageVersion: getEmitScriptTarget(options),
|
|
impliedNodeFormat: getImpliedNodeFormatForFile(toPath(inputFileName, "", compilerHost.getCanonicalFileName), void 0, compilerHost, options),
|
|
setExternalModuleIndicator: getSetExternalModuleIndicator(options)
|
|
}
|
|
);
|
|
if (transpileOptions.moduleName) {
|
|
sourceFile.moduleName = transpileOptions.moduleName;
|
|
}
|
|
if (transpileOptions.renamedDependencies) {
|
|
sourceFile.renamedDependencies = new Map(getEntries(transpileOptions.renamedDependencies));
|
|
}
|
|
let outputText;
|
|
let sourceMapText;
|
|
const program = createProgram([inputFileName], options, compilerHost);
|
|
if (transpileOptions.reportDiagnostics) {
|
|
addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile));
|
|
addRange(diagnostics, program.getOptionsDiagnostics());
|
|
}
|
|
program.emit(void 0, void 0, void 0, void 0, transpileOptions.transformers);
|
|
if (outputText === void 0)
|
|
return Debug.fail("Output generation failed");
|
|
return { outputText, diagnostics, sourceMapText };
|
|
}
|
|
function transpile(input, compilerOptions, fileName, diagnostics, moduleName) {
|
|
const output = transpileModule(input, { compilerOptions, fileName, reportDiagnostics: !!diagnostics, moduleName });
|
|
addRange(diagnostics, output.diagnostics);
|
|
return output.outputText;
|
|
}
|
|
var commandLineOptionsStringToEnum;
|
|
function fixupCompilerOptions(options, diagnostics) {
|
|
commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || filter(optionDeclarations, (o) => typeof o.type === "object" && !forEachEntry(o.type, (v) => typeof v !== "number"));
|
|
options = cloneCompilerOptions(options);
|
|
for (const opt of commandLineOptionsStringToEnum) {
|
|
if (!hasProperty(options, opt.name)) {
|
|
continue;
|
|
}
|
|
const value = options[opt.name];
|
|
if (isString(value)) {
|
|
options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
|
|
} else {
|
|
if (!forEachEntry(opt.type, (v) => v === value)) {
|
|
diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
|
|
}
|
|
}
|
|
}
|
|
return options;
|
|
}
|
|
|
|
// src/services/_namespaces/ts.NavigateTo.ts
|
|
var ts_NavigateTo_exports = {};
|
|
__export(ts_NavigateTo_exports, {
|
|
getNavigateToItems: () => getNavigateToItems
|
|
});
|
|
|
|
// src/services/navigateTo.ts
|
|
function getNavigateToItems(sourceFiles, checker, cancellationToken, searchValue, maxResultCount, excludeDtsFiles) {
|
|
const patternMatcher = createPatternMatcher(searchValue);
|
|
if (!patternMatcher)
|
|
return emptyArray;
|
|
const rawItems = [];
|
|
for (const sourceFile of sourceFiles) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
if (excludeDtsFiles && sourceFile.isDeclarationFile) {
|
|
continue;
|
|
}
|
|
sourceFile.getNamedDeclarations().forEach((declarations, name) => {
|
|
getItemsFromNamedDeclaration(patternMatcher, name, declarations, checker, sourceFile.fileName, rawItems);
|
|
});
|
|
}
|
|
rawItems.sort(compareNavigateToItems);
|
|
return (maxResultCount === void 0 ? rawItems : rawItems.slice(0, maxResultCount)).map(createNavigateToItem);
|
|
}
|
|
function getItemsFromNamedDeclaration(patternMatcher, name, declarations, checker, fileName, rawItems) {
|
|
const match = patternMatcher.getMatchForLastSegmentOfPattern(name);
|
|
if (!match) {
|
|
return;
|
|
}
|
|
for (const declaration of declarations) {
|
|
if (!shouldKeepItem(declaration, checker))
|
|
continue;
|
|
if (patternMatcher.patternContainsDots) {
|
|
const fullMatch = patternMatcher.getFullMatch(getContainers(declaration), name);
|
|
if (fullMatch) {
|
|
rawItems.push({ name, fileName, matchKind: fullMatch.kind, isCaseSensitive: fullMatch.isCaseSensitive, declaration });
|
|
}
|
|
} else {
|
|
rawItems.push({ name, fileName, matchKind: match.kind, isCaseSensitive: match.isCaseSensitive, declaration });
|
|
}
|
|
}
|
|
}
|
|
function shouldKeepItem(declaration, checker) {
|
|
switch (declaration.kind) {
|
|
case 270 /* ImportClause */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
const importer = checker.getSymbolAtLocation(declaration.name);
|
|
const imported = checker.getAliasedSymbol(importer);
|
|
return importer.escapedName !== imported.escapedName;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function tryAddSingleDeclarationName(declaration, containers) {
|
|
const name = getNameOfDeclaration(declaration);
|
|
return !!name && (pushLiteral(name, containers) || name.kind === 164 /* ComputedPropertyName */ && tryAddComputedPropertyName(name.expression, containers));
|
|
}
|
|
function tryAddComputedPropertyName(expression, containers) {
|
|
return pushLiteral(expression, containers) || isPropertyAccessExpression(expression) && (containers.push(expression.name.text), true) && tryAddComputedPropertyName(expression.expression, containers);
|
|
}
|
|
function pushLiteral(node, containers) {
|
|
return isPropertyNameLiteral(node) && (containers.push(getTextOfIdentifierOrLiteral(node)), true);
|
|
}
|
|
function getContainers(declaration) {
|
|
const containers = [];
|
|
const name = getNameOfDeclaration(declaration);
|
|
if (name && name.kind === 164 /* ComputedPropertyName */ && !tryAddComputedPropertyName(name.expression, containers)) {
|
|
return emptyArray;
|
|
}
|
|
containers.shift();
|
|
let container = getContainerNode(declaration);
|
|
while (container) {
|
|
if (!tryAddSingleDeclarationName(container, containers)) {
|
|
return emptyArray;
|
|
}
|
|
container = getContainerNode(container);
|
|
}
|
|
return containers.reverse();
|
|
}
|
|
function compareNavigateToItems(i1, i2) {
|
|
return compareValues(i1.matchKind, i2.matchKind) || compareStringsCaseSensitiveUI(i1.name, i2.name);
|
|
}
|
|
function createNavigateToItem(rawItem) {
|
|
const declaration = rawItem.declaration;
|
|
const container = getContainerNode(declaration);
|
|
const containerName = container && getNameOfDeclaration(container);
|
|
return {
|
|
name: rawItem.name,
|
|
kind: getNodeKind(declaration),
|
|
kindModifiers: getNodeModifiers(declaration),
|
|
matchKind: PatternMatchKind[rawItem.matchKind],
|
|
isCaseSensitive: rawItem.isCaseSensitive,
|
|
fileName: rawItem.fileName,
|
|
textSpan: createTextSpanFromNode(declaration),
|
|
containerName: containerName ? containerName.text : "",
|
|
containerKind: containerName ? getNodeKind(container) : "" /* unknown */
|
|
};
|
|
}
|
|
|
|
// src/services/_namespaces/ts.NavigationBar.ts
|
|
var ts_NavigationBar_exports = {};
|
|
__export(ts_NavigationBar_exports, {
|
|
getNavigationBarItems: () => getNavigationBarItems,
|
|
getNavigationTree: () => getNavigationTree
|
|
});
|
|
|
|
// src/services/navigationBar.ts
|
|
var whiteSpaceRegex = /\s+/g;
|
|
var maxLength = 150;
|
|
var curCancellationToken;
|
|
var curSourceFile;
|
|
var parentsStack = [];
|
|
var parent;
|
|
var trackedEs5ClassesStack = [];
|
|
var trackedEs5Classes;
|
|
var emptyChildItemArray = [];
|
|
function getNavigationBarItems(sourceFile, cancellationToken) {
|
|
curCancellationToken = cancellationToken;
|
|
curSourceFile = sourceFile;
|
|
try {
|
|
return map(primaryNavBarMenuItems(rootNavigationBarNode(sourceFile)), convertToPrimaryNavBarMenuItem);
|
|
} finally {
|
|
reset();
|
|
}
|
|
}
|
|
function getNavigationTree(sourceFile, cancellationToken) {
|
|
curCancellationToken = cancellationToken;
|
|
curSourceFile = sourceFile;
|
|
try {
|
|
return convertToTree(rootNavigationBarNode(sourceFile));
|
|
} finally {
|
|
reset();
|
|
}
|
|
}
|
|
function reset() {
|
|
curSourceFile = void 0;
|
|
curCancellationToken = void 0;
|
|
parentsStack = [];
|
|
parent = void 0;
|
|
emptyChildItemArray = [];
|
|
}
|
|
function nodeText(node) {
|
|
return cleanText(node.getText(curSourceFile));
|
|
}
|
|
function navigationBarNodeKind(n) {
|
|
return n.node.kind;
|
|
}
|
|
function pushChild(parent2, child) {
|
|
if (parent2.children) {
|
|
parent2.children.push(child);
|
|
} else {
|
|
parent2.children = [child];
|
|
}
|
|
}
|
|
function rootNavigationBarNode(sourceFile) {
|
|
Debug.assert(!parentsStack.length);
|
|
const root = { node: sourceFile, name: void 0, additionalNodes: void 0, parent: void 0, children: void 0, indent: 0 };
|
|
parent = root;
|
|
for (const statement of sourceFile.statements) {
|
|
addChildrenRecursively(statement);
|
|
}
|
|
endNode();
|
|
Debug.assert(!parent && !parentsStack.length);
|
|
return root;
|
|
}
|
|
function addLeafNode(node, name) {
|
|
pushChild(parent, emptyNavigationBarNode(node, name));
|
|
}
|
|
function emptyNavigationBarNode(node, name) {
|
|
return {
|
|
node,
|
|
name: name || (isDeclaration(node) || isExpression(node) ? getNameOfDeclaration(node) : void 0),
|
|
additionalNodes: void 0,
|
|
parent,
|
|
children: void 0,
|
|
indent: parent.indent + 1
|
|
};
|
|
}
|
|
function addTrackedEs5Class(name) {
|
|
if (!trackedEs5Classes) {
|
|
trackedEs5Classes = /* @__PURE__ */ new Map();
|
|
}
|
|
trackedEs5Classes.set(name, true);
|
|
}
|
|
function endNestedNodes(depth) {
|
|
for (let i = 0; i < depth; i++)
|
|
endNode();
|
|
}
|
|
function startNestedNodes(targetNode, entityName) {
|
|
const names = [];
|
|
while (!isPropertyNameLiteral(entityName)) {
|
|
const name = getNameOrArgument(entityName);
|
|
const nameText = getElementOrPropertyAccessName(entityName);
|
|
entityName = entityName.expression;
|
|
if (nameText === "prototype" || isPrivateIdentifier(name))
|
|
continue;
|
|
names.push(name);
|
|
}
|
|
names.push(entityName);
|
|
for (let i = names.length - 1; i > 0; i--) {
|
|
const name = names[i];
|
|
startNode(targetNode, name);
|
|
}
|
|
return [names.length - 1, names[0]];
|
|
}
|
|
function startNode(node, name) {
|
|
const navNode = emptyNavigationBarNode(node, name);
|
|
pushChild(parent, navNode);
|
|
parentsStack.push(parent);
|
|
trackedEs5ClassesStack.push(trackedEs5Classes);
|
|
trackedEs5Classes = void 0;
|
|
parent = navNode;
|
|
}
|
|
function endNode() {
|
|
if (parent.children) {
|
|
mergeChildren(parent.children, parent);
|
|
sortChildren(parent.children);
|
|
}
|
|
parent = parentsStack.pop();
|
|
trackedEs5Classes = trackedEs5ClassesStack.pop();
|
|
}
|
|
function addNodeWithRecursiveChild(node, child, name) {
|
|
startNode(node, name);
|
|
addChildrenRecursively(child);
|
|
endNode();
|
|
}
|
|
function addNodeWithRecursiveInitializer(node) {
|
|
if (node.initializer && isFunctionOrClassExpression(node.initializer)) {
|
|
startNode(node);
|
|
forEachChild(node.initializer, addChildrenRecursively);
|
|
endNode();
|
|
} else {
|
|
addNodeWithRecursiveChild(node, node.initializer);
|
|
}
|
|
}
|
|
function hasNavigationBarName(node) {
|
|
return !hasDynamicName(node) || node.kind !== 223 /* BinaryExpression */ && isPropertyAccessExpression(node.name.expression) && isIdentifier(node.name.expression.expression) && idText(node.name.expression.expression) === "Symbol";
|
|
}
|
|
function addChildrenRecursively(node) {
|
|
curCancellationToken.throwIfCancellationRequested();
|
|
if (!node || isToken(node)) {
|
|
return;
|
|
}
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
const ctr = node;
|
|
addNodeWithRecursiveChild(ctr, ctr.body);
|
|
for (const param of ctr.parameters) {
|
|
if (isParameterPropertyDeclaration(param, ctr)) {
|
|
addLeafNode(param);
|
|
}
|
|
}
|
|
break;
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 170 /* MethodSignature */:
|
|
if (hasNavigationBarName(node)) {
|
|
addNodeWithRecursiveChild(node, node.body);
|
|
}
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
if (hasNavigationBarName(node)) {
|
|
addNodeWithRecursiveInitializer(node);
|
|
}
|
|
break;
|
|
case 168 /* PropertySignature */:
|
|
if (hasNavigationBarName(node)) {
|
|
addLeafNode(node);
|
|
}
|
|
break;
|
|
case 270 /* ImportClause */:
|
|
const importClause = node;
|
|
if (importClause.name) {
|
|
addLeafNode(importClause.name);
|
|
}
|
|
const { namedBindings } = importClause;
|
|
if (namedBindings) {
|
|
if (namedBindings.kind === 271 /* NamespaceImport */) {
|
|
addLeafNode(namedBindings);
|
|
} else {
|
|
for (const element of namedBindings.elements) {
|
|
addLeafNode(element);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
addNodeWithRecursiveChild(node, node.name);
|
|
break;
|
|
case 301 /* SpreadAssignment */:
|
|
const { expression } = node;
|
|
isIdentifier(expression) ? addLeafNode(node, expression) : addLeafNode(node);
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 257 /* VariableDeclaration */: {
|
|
const child = node;
|
|
if (isBindingPattern(child.name)) {
|
|
addChildrenRecursively(child.name);
|
|
} else {
|
|
addNodeWithRecursiveInitializer(child);
|
|
}
|
|
break;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
const nameNode = node.name;
|
|
if (nameNode && isIdentifier(nameNode)) {
|
|
addTrackedEs5Class(nameNode.text);
|
|
}
|
|
addNodeWithRecursiveChild(node, node.body);
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
addNodeWithRecursiveChild(node, node.body);
|
|
break;
|
|
case 263 /* EnumDeclaration */:
|
|
startNode(node);
|
|
for (const member of node.members) {
|
|
if (!isComputedProperty(member)) {
|
|
addLeafNode(member);
|
|
}
|
|
}
|
|
endNode();
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
startNode(node);
|
|
for (const member of node.members) {
|
|
addChildrenRecursively(member);
|
|
}
|
|
endNode();
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
addNodeWithRecursiveChild(node, getInteriorModule(node).body);
|
|
break;
|
|
case 274 /* ExportAssignment */: {
|
|
const expression2 = node.expression;
|
|
const child = isObjectLiteralExpression(expression2) || isCallExpression(expression2) ? expression2 : isArrowFunction(expression2) || isFunctionExpression(expression2) ? expression2.body : void 0;
|
|
if (child) {
|
|
startNode(node);
|
|
addChildrenRecursively(child);
|
|
endNode();
|
|
} else {
|
|
addLeafNode(node);
|
|
}
|
|
break;
|
|
}
|
|
case 278 /* ExportSpecifier */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 178 /* IndexSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
addLeafNode(node);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
case 223 /* BinaryExpression */: {
|
|
const special = getAssignmentDeclarationKind(node);
|
|
switch (special) {
|
|
case 1 /* ExportsProperty */:
|
|
case 2 /* ModuleExports */:
|
|
addNodeWithRecursiveChild(node, node.right);
|
|
return;
|
|
case 6 /* Prototype */:
|
|
case 3 /* PrototypeProperty */: {
|
|
const binaryExpression = node;
|
|
const assignmentTarget = binaryExpression.left;
|
|
const prototypeAccess = special === 3 /* PrototypeProperty */ ? assignmentTarget.expression : assignmentTarget;
|
|
let depth = 0;
|
|
let className;
|
|
if (isIdentifier(prototypeAccess.expression)) {
|
|
addTrackedEs5Class(prototypeAccess.expression.text);
|
|
className = prototypeAccess.expression;
|
|
} else {
|
|
[depth, className] = startNestedNodes(binaryExpression, prototypeAccess.expression);
|
|
}
|
|
if (special === 6 /* Prototype */) {
|
|
if (isObjectLiteralExpression(binaryExpression.right)) {
|
|
if (binaryExpression.right.properties.length > 0) {
|
|
startNode(binaryExpression, className);
|
|
forEachChild(binaryExpression.right, addChildrenRecursively);
|
|
endNode();
|
|
}
|
|
}
|
|
} else if (isFunctionExpression(binaryExpression.right) || isArrowFunction(binaryExpression.right)) {
|
|
addNodeWithRecursiveChild(
|
|
node,
|
|
binaryExpression.right,
|
|
className
|
|
);
|
|
} else {
|
|
startNode(binaryExpression, className);
|
|
addNodeWithRecursiveChild(node, binaryExpression.right, assignmentTarget.name);
|
|
endNode();
|
|
}
|
|
endNestedNodes(depth);
|
|
return;
|
|
}
|
|
case 7 /* ObjectDefinePropertyValue */:
|
|
case 9 /* ObjectDefinePrototypeProperty */: {
|
|
const defineCall = node;
|
|
const className = special === 7 /* ObjectDefinePropertyValue */ ? defineCall.arguments[0] : defineCall.arguments[0].expression;
|
|
const memberName = defineCall.arguments[1];
|
|
const [depth, classNameIdentifier] = startNestedNodes(node, className);
|
|
startNode(node, classNameIdentifier);
|
|
startNode(node, setTextRange(factory.createIdentifier(memberName.text), memberName));
|
|
addChildrenRecursively(node.arguments[2]);
|
|
endNode();
|
|
endNode();
|
|
endNestedNodes(depth);
|
|
return;
|
|
}
|
|
case 5 /* Property */: {
|
|
const binaryExpression = node;
|
|
const assignmentTarget = binaryExpression.left;
|
|
const targetFunction = assignmentTarget.expression;
|
|
if (isIdentifier(targetFunction) && getElementOrPropertyAccessName(assignmentTarget) !== "prototype" && trackedEs5Classes && trackedEs5Classes.has(targetFunction.text)) {
|
|
if (isFunctionExpression(binaryExpression.right) || isArrowFunction(binaryExpression.right)) {
|
|
addNodeWithRecursiveChild(node, binaryExpression.right, targetFunction);
|
|
} else if (isBindableStaticAccessExpression(assignmentTarget)) {
|
|
startNode(binaryExpression, targetFunction);
|
|
addNodeWithRecursiveChild(binaryExpression.left, binaryExpression.right, getNameOrArgument(assignmentTarget));
|
|
endNode();
|
|
}
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
case 4 /* ThisProperty */:
|
|
case 0 /* None */:
|
|
case 8 /* ObjectDefinePropertyExports */:
|
|
break;
|
|
default:
|
|
Debug.assertNever(special);
|
|
}
|
|
}
|
|
default:
|
|
if (hasJSDocNodes(node)) {
|
|
forEach(node.jsDoc, (jsDoc) => {
|
|
forEach(jsDoc.tags, (tag) => {
|
|
if (isJSDocTypeAlias(tag)) {
|
|
addLeafNode(tag);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
forEachChild(node, addChildrenRecursively);
|
|
}
|
|
}
|
|
function mergeChildren(children, node) {
|
|
const nameToItems = /* @__PURE__ */ new Map();
|
|
filterMutate(children, (child, index) => {
|
|
const declName = child.name || getNameOfDeclaration(child.node);
|
|
const name = declName && nodeText(declName);
|
|
if (!name) {
|
|
return true;
|
|
}
|
|
const itemsWithSameName = nameToItems.get(name);
|
|
if (!itemsWithSameName) {
|
|
nameToItems.set(name, child);
|
|
return true;
|
|
}
|
|
if (itemsWithSameName instanceof Array) {
|
|
for (const itemWithSameName of itemsWithSameName) {
|
|
if (tryMerge(itemWithSameName, child, index, node)) {
|
|
return false;
|
|
}
|
|
}
|
|
itemsWithSameName.push(child);
|
|
return true;
|
|
} else {
|
|
const itemWithSameName = itemsWithSameName;
|
|
if (tryMerge(itemWithSameName, child, index, node)) {
|
|
return false;
|
|
}
|
|
nameToItems.set(name, [itemWithSameName, child]);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
var isEs5ClassMember = {
|
|
[5 /* Property */]: true,
|
|
[3 /* PrototypeProperty */]: true,
|
|
[7 /* ObjectDefinePropertyValue */]: true,
|
|
[9 /* ObjectDefinePrototypeProperty */]: true,
|
|
[0 /* None */]: false,
|
|
[1 /* ExportsProperty */]: false,
|
|
[2 /* ModuleExports */]: false,
|
|
[8 /* ObjectDefinePropertyExports */]: false,
|
|
[6 /* Prototype */]: true,
|
|
[4 /* ThisProperty */]: false
|
|
};
|
|
function tryMergeEs5Class(a, b, bIndex, parent2) {
|
|
function isPossibleConstructor(node) {
|
|
return isFunctionExpression(node) || isFunctionDeclaration(node) || isVariableDeclaration(node);
|
|
}
|
|
const bAssignmentDeclarationKind = isBinaryExpression(b.node) || isCallExpression(b.node) ? getAssignmentDeclarationKind(b.node) : 0 /* None */;
|
|
const aAssignmentDeclarationKind = isBinaryExpression(a.node) || isCallExpression(a.node) ? getAssignmentDeclarationKind(a.node) : 0 /* None */;
|
|
if (isEs5ClassMember[bAssignmentDeclarationKind] && isEs5ClassMember[aAssignmentDeclarationKind] || isPossibleConstructor(a.node) && isEs5ClassMember[bAssignmentDeclarationKind] || isPossibleConstructor(b.node) && isEs5ClassMember[aAssignmentDeclarationKind] || isClassDeclaration(a.node) && isSynthesized(a.node) && isEs5ClassMember[bAssignmentDeclarationKind] || isClassDeclaration(b.node) && isEs5ClassMember[aAssignmentDeclarationKind] || isClassDeclaration(a.node) && isSynthesized(a.node) && isPossibleConstructor(b.node) || isClassDeclaration(b.node) && isPossibleConstructor(a.node) && isSynthesized(a.node)) {
|
|
let lastANode = a.additionalNodes && lastOrUndefined(a.additionalNodes) || a.node;
|
|
if (!isClassDeclaration(a.node) && !isClassDeclaration(b.node) || isPossibleConstructor(a.node) || isPossibleConstructor(b.node)) {
|
|
const ctorFunction = isPossibleConstructor(a.node) ? a.node : isPossibleConstructor(b.node) ? b.node : void 0;
|
|
if (ctorFunction !== void 0) {
|
|
const ctorNode = setTextRange(
|
|
factory.createConstructorDeclaration(void 0, [], void 0),
|
|
ctorFunction
|
|
);
|
|
const ctor = emptyNavigationBarNode(ctorNode);
|
|
ctor.indent = a.indent + 1;
|
|
ctor.children = a.node === ctorFunction ? a.children : b.children;
|
|
a.children = a.node === ctorFunction ? concatenate([ctor], b.children || [b]) : concatenate(a.children || [{ ...a }], [ctor]);
|
|
} else {
|
|
if (a.children || b.children) {
|
|
a.children = concatenate(a.children || [{ ...a }], b.children || [b]);
|
|
if (a.children) {
|
|
mergeChildren(a.children, a);
|
|
sortChildren(a.children);
|
|
}
|
|
}
|
|
}
|
|
lastANode = a.node = setTextRange(factory.createClassDeclaration(
|
|
void 0,
|
|
a.name || factory.createIdentifier("__class__"),
|
|
void 0,
|
|
void 0,
|
|
[]
|
|
), a.node);
|
|
} else {
|
|
a.children = concatenate(a.children, b.children);
|
|
if (a.children) {
|
|
mergeChildren(a.children, a);
|
|
}
|
|
}
|
|
const bNode = b.node;
|
|
if (parent2.children[bIndex - 1].node.end === lastANode.end) {
|
|
setTextRange(lastANode, { pos: lastANode.pos, end: bNode.end });
|
|
} else {
|
|
if (!a.additionalNodes)
|
|
a.additionalNodes = [];
|
|
a.additionalNodes.push(setTextRange(factory.createClassDeclaration(
|
|
void 0,
|
|
a.name || factory.createIdentifier("__class__"),
|
|
void 0,
|
|
void 0,
|
|
[]
|
|
), b.node));
|
|
}
|
|
return true;
|
|
}
|
|
return bAssignmentDeclarationKind === 0 /* None */ ? false : true;
|
|
}
|
|
function tryMerge(a, b, bIndex, parent2) {
|
|
if (tryMergeEs5Class(a, b, bIndex, parent2)) {
|
|
return true;
|
|
}
|
|
if (shouldReallyMerge(a.node, b.node, parent2)) {
|
|
merge(a, b);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function shouldReallyMerge(a, b, parent2) {
|
|
if (a.kind !== b.kind || a.parent !== b.parent && !(isOwnChild(a, parent2) && isOwnChild(b, parent2))) {
|
|
return false;
|
|
}
|
|
switch (a.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return isStatic(a) === isStatic(b);
|
|
case 264 /* ModuleDeclaration */:
|
|
return areSameModule(a, b) && getFullyQualifiedModuleName(a) === getFullyQualifiedModuleName(b);
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function isSynthesized(node) {
|
|
return !!(node.flags & 8 /* Synthesized */);
|
|
}
|
|
function isOwnChild(n, parent2) {
|
|
const par = isModuleBlock(n.parent) ? n.parent.parent : n.parent;
|
|
return par === parent2.node || contains(parent2.additionalNodes, par);
|
|
}
|
|
function areSameModule(a, b) {
|
|
if (!a.body || !b.body) {
|
|
return a.body === b.body;
|
|
}
|
|
return a.body.kind === b.body.kind && (a.body.kind !== 264 /* ModuleDeclaration */ || areSameModule(a.body, b.body));
|
|
}
|
|
function merge(target, source) {
|
|
target.additionalNodes = target.additionalNodes || [];
|
|
target.additionalNodes.push(source.node);
|
|
if (source.additionalNodes) {
|
|
target.additionalNodes.push(...source.additionalNodes);
|
|
}
|
|
target.children = concatenate(target.children, source.children);
|
|
if (target.children) {
|
|
mergeChildren(target.children, target);
|
|
sortChildren(target.children);
|
|
}
|
|
}
|
|
function sortChildren(children) {
|
|
children.sort(compareChildren);
|
|
}
|
|
function compareChildren(child1, child2) {
|
|
return compareStringsCaseSensitiveUI(tryGetName(child1.node), tryGetName(child2.node)) || compareValues(navigationBarNodeKind(child1), navigationBarNodeKind(child2));
|
|
}
|
|
function tryGetName(node) {
|
|
if (node.kind === 264 /* ModuleDeclaration */) {
|
|
return getModuleName(node);
|
|
}
|
|
const declName = getNameOfDeclaration(node);
|
|
if (declName && isPropertyName(declName)) {
|
|
const propertyName = getPropertyNameForPropertyNameNode(declName);
|
|
return propertyName && unescapeLeadingUnderscores(propertyName);
|
|
}
|
|
switch (node.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 228 /* ClassExpression */:
|
|
return getFunctionOrClassName(node);
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function getItemName(node, name) {
|
|
if (node.kind === 264 /* ModuleDeclaration */) {
|
|
return cleanText(getModuleName(node));
|
|
}
|
|
if (name) {
|
|
const text = isIdentifier(name) ? name.text : isElementAccessExpression(name) ? `[${nodeText(name.argumentExpression)}]` : nodeText(name);
|
|
if (text.length > 0) {
|
|
return cleanText(text);
|
|
}
|
|
}
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
const sourceFile = node;
|
|
return isExternalModule(sourceFile) ? `"${escapeString(getBaseFileName(removeFileExtension(normalizePath(sourceFile.fileName))))}"` : "<global>";
|
|
case 274 /* ExportAssignment */:
|
|
return isExportAssignment(node) && node.isExportEquals ? "export=" /* ExportEquals */ : "default" /* Default */;
|
|
case 216 /* ArrowFunction */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
if (getSyntacticModifierFlags(node) & 1024 /* Default */) {
|
|
return "default";
|
|
}
|
|
return getFunctionOrClassName(node);
|
|
case 173 /* Constructor */:
|
|
return "constructor";
|
|
case 177 /* ConstructSignature */:
|
|
return "new()";
|
|
case 176 /* CallSignature */:
|
|
return "()";
|
|
case 178 /* IndexSignature */:
|
|
return "[]";
|
|
default:
|
|
return "<unknown>";
|
|
}
|
|
}
|
|
function primaryNavBarMenuItems(root) {
|
|
const primaryNavBarMenuItems2 = [];
|
|
function recur(item) {
|
|
if (shouldAppearInPrimaryNavBarMenu(item)) {
|
|
primaryNavBarMenuItems2.push(item);
|
|
if (item.children) {
|
|
for (const child of item.children) {
|
|
recur(child);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
recur(root);
|
|
return primaryNavBarMenuItems2;
|
|
function shouldAppearInPrimaryNavBarMenu(item) {
|
|
if (item.children) {
|
|
return true;
|
|
}
|
|
switch (navigationBarNodeKind(item)) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 308 /* SourceFile */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
return true;
|
|
case 216 /* ArrowFunction */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
return isTopLevelFunctionDeclaration(item);
|
|
default:
|
|
return false;
|
|
}
|
|
function isTopLevelFunctionDeclaration(item2) {
|
|
if (!item2.node.body) {
|
|
return false;
|
|
}
|
|
switch (navigationBarNodeKind(item2.parent)) {
|
|
case 265 /* ModuleBlock */:
|
|
case 308 /* SourceFile */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function convertToTree(n) {
|
|
return {
|
|
text: getItemName(n.node, n.name),
|
|
kind: getNodeKind(n.node),
|
|
kindModifiers: getModifiers2(n.node),
|
|
spans: getSpans(n),
|
|
nameSpan: n.name && getNodeSpan(n.name),
|
|
childItems: map(n.children, convertToTree)
|
|
};
|
|
}
|
|
function convertToPrimaryNavBarMenuItem(n) {
|
|
return {
|
|
text: getItemName(n.node, n.name),
|
|
kind: getNodeKind(n.node),
|
|
kindModifiers: getModifiers2(n.node),
|
|
spans: getSpans(n),
|
|
childItems: map(n.children, convertToSecondaryNavBarMenuItem) || emptyChildItemArray,
|
|
indent: n.indent,
|
|
bolded: false,
|
|
grayed: false
|
|
};
|
|
function convertToSecondaryNavBarMenuItem(n2) {
|
|
return {
|
|
text: getItemName(n2.node, n2.name),
|
|
kind: getNodeKind(n2.node),
|
|
kindModifiers: getNodeModifiers(n2.node),
|
|
spans: getSpans(n2),
|
|
childItems: emptyChildItemArray,
|
|
indent: 0,
|
|
bolded: false,
|
|
grayed: false
|
|
};
|
|
}
|
|
}
|
|
function getSpans(n) {
|
|
const spans = [getNodeSpan(n.node)];
|
|
if (n.additionalNodes) {
|
|
for (const node of n.additionalNodes) {
|
|
spans.push(getNodeSpan(node));
|
|
}
|
|
}
|
|
return spans;
|
|
}
|
|
function getModuleName(moduleDeclaration) {
|
|
if (isAmbientModule(moduleDeclaration)) {
|
|
return getTextOfNode(moduleDeclaration.name);
|
|
}
|
|
return getFullyQualifiedModuleName(moduleDeclaration);
|
|
}
|
|
function getFullyQualifiedModuleName(moduleDeclaration) {
|
|
const result = [getTextOfIdentifierOrLiteral(moduleDeclaration.name)];
|
|
while (moduleDeclaration.body && moduleDeclaration.body.kind === 264 /* ModuleDeclaration */) {
|
|
moduleDeclaration = moduleDeclaration.body;
|
|
result.push(getTextOfIdentifierOrLiteral(moduleDeclaration.name));
|
|
}
|
|
return result.join(".");
|
|
}
|
|
function getInteriorModule(decl) {
|
|
return decl.body && isModuleDeclaration(decl.body) ? getInteriorModule(decl.body) : decl;
|
|
}
|
|
function isComputedProperty(member) {
|
|
return !member.name || member.name.kind === 164 /* ComputedPropertyName */;
|
|
}
|
|
function getNodeSpan(node) {
|
|
return node.kind === 308 /* SourceFile */ ? createTextSpanFromRange(node) : createTextSpanFromNode(node, curSourceFile);
|
|
}
|
|
function getModifiers2(node) {
|
|
if (node.parent && node.parent.kind === 257 /* VariableDeclaration */) {
|
|
node = node.parent;
|
|
}
|
|
return getNodeModifiers(node);
|
|
}
|
|
function getFunctionOrClassName(node) {
|
|
const { parent: parent2 } = node;
|
|
if (node.name && getFullWidth(node.name) > 0) {
|
|
return cleanText(declarationNameToString(node.name));
|
|
} else if (isVariableDeclaration(parent2)) {
|
|
return cleanText(declarationNameToString(parent2.name));
|
|
} else if (isBinaryExpression(parent2) && parent2.operatorToken.kind === 63 /* EqualsToken */) {
|
|
return nodeText(parent2.left).replace(whiteSpaceRegex, "");
|
|
} else if (isPropertyAssignment(parent2)) {
|
|
return nodeText(parent2.name);
|
|
} else if (getSyntacticModifierFlags(node) & 1024 /* Default */) {
|
|
return "default";
|
|
} else if (isClassLike(node)) {
|
|
return "<class>";
|
|
} else if (isCallExpression(parent2)) {
|
|
let name = getCalledExpressionName(parent2.expression);
|
|
if (name !== void 0) {
|
|
name = cleanText(name);
|
|
if (name.length > maxLength) {
|
|
return `${name} callback`;
|
|
}
|
|
const args = cleanText(mapDefined(parent2.arguments, (a) => isStringLiteralLike(a) ? a.getText(curSourceFile) : void 0).join(", "));
|
|
return `${name}(${args}) callback`;
|
|
}
|
|
}
|
|
return "<function>";
|
|
}
|
|
function getCalledExpressionName(expr) {
|
|
if (isIdentifier(expr)) {
|
|
return expr.text;
|
|
} else if (isPropertyAccessExpression(expr)) {
|
|
const left = getCalledExpressionName(expr.expression);
|
|
const right = expr.name.text;
|
|
return left === void 0 ? right : `${left}.${right}`;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
function isFunctionOrClassExpression(node) {
|
|
switch (node.kind) {
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
case 228 /* ClassExpression */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function cleanText(text) {
|
|
text = text.length > maxLength ? text.substring(0, maxLength) + "..." : text;
|
|
return text.replace(/\\?(\r?\n|\r|\u2028|\u2029)/g, "");
|
|
}
|
|
|
|
// src/services/services.ts
|
|
var servicesVersion = "0.8";
|
|
function createNode(kind, pos, end, parent2) {
|
|
const node = isNodeKind(kind) ? new NodeObject(kind, pos, end) : kind === 79 /* Identifier */ ? new IdentifierObject(79 /* Identifier */, pos, end) : kind === 80 /* PrivateIdentifier */ ? new PrivateIdentifierObject(80 /* PrivateIdentifier */, pos, end) : new TokenObject(kind, pos, end);
|
|
node.parent = parent2;
|
|
node.flags = parent2.flags & 50720768 /* ContextFlags */;
|
|
return node;
|
|
}
|
|
var NodeObject = class {
|
|
constructor(kind, pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.flags = 0 /* None */;
|
|
this.modifierFlagsCache = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
this.kind = kind;
|
|
}
|
|
assertHasRealPosition(message) {
|
|
Debug.assert(!positionIsSynthesized(this.pos) && !positionIsSynthesized(this.end), message || "Node must have a real position for this operation");
|
|
}
|
|
getSourceFile() {
|
|
return getSourceFileOfNode(this);
|
|
}
|
|
getStart(sourceFile, includeJsDocComment) {
|
|
this.assertHasRealPosition();
|
|
return getTokenPosOfNode(this, sourceFile, includeJsDocComment);
|
|
}
|
|
getFullStart() {
|
|
this.assertHasRealPosition();
|
|
return this.pos;
|
|
}
|
|
getEnd() {
|
|
this.assertHasRealPosition();
|
|
return this.end;
|
|
}
|
|
getWidth(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
return this.getEnd() - this.getStart(sourceFile);
|
|
}
|
|
getFullWidth() {
|
|
this.assertHasRealPosition();
|
|
return this.end - this.pos;
|
|
}
|
|
getLeadingTriviaWidth(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
return this.getStart(sourceFile) - this.pos;
|
|
}
|
|
getFullText(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);
|
|
}
|
|
getText(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
if (!sourceFile) {
|
|
sourceFile = this.getSourceFile();
|
|
}
|
|
return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd());
|
|
}
|
|
getChildCount(sourceFile) {
|
|
return this.getChildren(sourceFile).length;
|
|
}
|
|
getChildAt(index, sourceFile) {
|
|
return this.getChildren(sourceFile)[index];
|
|
}
|
|
getChildren(sourceFile) {
|
|
this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine");
|
|
return this._children || (this._children = createChildren(this, sourceFile));
|
|
}
|
|
getFirstToken(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
const children = this.getChildren(sourceFile);
|
|
if (!children.length) {
|
|
return void 0;
|
|
}
|
|
const child = find(children, (kid) => kid.kind < 312 /* FirstJSDocNode */ || kid.kind > 350 /* LastJSDocNode */);
|
|
return child.kind < 163 /* FirstNode */ ? child : child.getFirstToken(sourceFile);
|
|
}
|
|
getLastToken(sourceFile) {
|
|
this.assertHasRealPosition();
|
|
const children = this.getChildren(sourceFile);
|
|
const child = lastOrUndefined(children);
|
|
if (!child) {
|
|
return void 0;
|
|
}
|
|
return child.kind < 163 /* FirstNode */ ? child : child.getLastToken(sourceFile);
|
|
}
|
|
forEachChild(cbNode, cbNodeArray) {
|
|
return forEachChild(this, cbNode, cbNodeArray);
|
|
}
|
|
};
|
|
function createChildren(node, sourceFile) {
|
|
if (!isNodeKind(node.kind)) {
|
|
return emptyArray;
|
|
}
|
|
const children = [];
|
|
if (isJSDocCommentContainingNode(node)) {
|
|
node.forEachChild((child) => {
|
|
children.push(child);
|
|
});
|
|
return children;
|
|
}
|
|
scanner.setText((sourceFile || node.getSourceFile()).text);
|
|
let pos = node.pos;
|
|
const processNode = (child) => {
|
|
addSyntheticNodes(children, pos, child.pos, node);
|
|
children.push(child);
|
|
pos = child.end;
|
|
};
|
|
const processNodes = (nodes) => {
|
|
addSyntheticNodes(children, pos, nodes.pos, node);
|
|
children.push(createSyntaxList(nodes, node));
|
|
pos = nodes.end;
|
|
};
|
|
forEach(node.jsDoc, processNode);
|
|
pos = node.pos;
|
|
node.forEachChild(processNode, processNodes);
|
|
addSyntheticNodes(children, pos, node.end, node);
|
|
scanner.setText(void 0);
|
|
return children;
|
|
}
|
|
function addSyntheticNodes(nodes, pos, end, parent2) {
|
|
scanner.setTextPos(pos);
|
|
while (pos < end) {
|
|
const token = scanner.scan();
|
|
const textPos = scanner.getTextPos();
|
|
if (textPos <= end) {
|
|
if (token === 79 /* Identifier */) {
|
|
Debug.fail(`Did not expect ${Debug.formatSyntaxKind(parent2.kind)} to have an Identifier in its trivia`);
|
|
}
|
|
nodes.push(createNode(token, pos, textPos, parent2));
|
|
}
|
|
pos = textPos;
|
|
if (token === 1 /* EndOfFileToken */) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function createSyntaxList(nodes, parent2) {
|
|
const list = createNode(351 /* SyntaxList */, nodes.pos, nodes.end, parent2);
|
|
list._children = [];
|
|
let pos = nodes.pos;
|
|
for (const node of nodes) {
|
|
addSyntheticNodes(list._children, pos, node.pos, parent2);
|
|
list._children.push(node);
|
|
pos = node.end;
|
|
}
|
|
addSyntheticNodes(list._children, pos, nodes.end, parent2);
|
|
return list;
|
|
}
|
|
var TokenOrIdentifierObject = class {
|
|
constructor(pos, end) {
|
|
this.pos = pos;
|
|
this.end = end;
|
|
this.flags = 0 /* None */;
|
|
this.modifierFlagsCache = 0 /* None */;
|
|
this.transformFlags = 0 /* None */;
|
|
this.parent = void 0;
|
|
}
|
|
getSourceFile() {
|
|
return getSourceFileOfNode(this);
|
|
}
|
|
getStart(sourceFile, includeJsDocComment) {
|
|
return getTokenPosOfNode(this, sourceFile, includeJsDocComment);
|
|
}
|
|
getFullStart() {
|
|
return this.pos;
|
|
}
|
|
getEnd() {
|
|
return this.end;
|
|
}
|
|
getWidth(sourceFile) {
|
|
return this.getEnd() - this.getStart(sourceFile);
|
|
}
|
|
getFullWidth() {
|
|
return this.end - this.pos;
|
|
}
|
|
getLeadingTriviaWidth(sourceFile) {
|
|
return this.getStart(sourceFile) - this.pos;
|
|
}
|
|
getFullText(sourceFile) {
|
|
return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end);
|
|
}
|
|
getText(sourceFile) {
|
|
if (!sourceFile) {
|
|
sourceFile = this.getSourceFile();
|
|
}
|
|
return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd());
|
|
}
|
|
getChildCount() {
|
|
return this.getChildren().length;
|
|
}
|
|
getChildAt(index) {
|
|
return this.getChildren()[index];
|
|
}
|
|
getChildren() {
|
|
return this.kind === 1 /* EndOfFileToken */ ? this.jsDoc || emptyArray : emptyArray;
|
|
}
|
|
getFirstToken() {
|
|
return void 0;
|
|
}
|
|
getLastToken() {
|
|
return void 0;
|
|
}
|
|
forEachChild() {
|
|
return void 0;
|
|
}
|
|
};
|
|
var SymbolObject = class {
|
|
constructor(flags, name) {
|
|
this.flags = flags;
|
|
this.escapedName = name;
|
|
}
|
|
getFlags() {
|
|
return this.flags;
|
|
}
|
|
get name() {
|
|
return symbolName(this);
|
|
}
|
|
getEscapedName() {
|
|
return this.escapedName;
|
|
}
|
|
getName() {
|
|
return this.name;
|
|
}
|
|
getDeclarations() {
|
|
return this.declarations;
|
|
}
|
|
getDocumentationComment(checker) {
|
|
if (!this.documentationComment) {
|
|
this.documentationComment = emptyArray;
|
|
if (!this.declarations && this.target && this.target.tupleLabelDeclaration) {
|
|
const labelDecl = this.target.tupleLabelDeclaration;
|
|
this.documentationComment = getDocumentationComment([labelDecl], checker);
|
|
} else {
|
|
this.documentationComment = getDocumentationComment(this.declarations, checker);
|
|
}
|
|
}
|
|
return this.documentationComment;
|
|
}
|
|
getContextualDocumentationComment(context, checker) {
|
|
if (context) {
|
|
if (isGetAccessor(context)) {
|
|
if (!this.contextualGetAccessorDocumentationComment) {
|
|
this.contextualGetAccessorDocumentationComment = getDocumentationComment(filter(this.declarations, isGetAccessor), checker);
|
|
}
|
|
if (length(this.contextualGetAccessorDocumentationComment)) {
|
|
return this.contextualGetAccessorDocumentationComment;
|
|
}
|
|
}
|
|
if (isSetAccessor(context)) {
|
|
if (!this.contextualSetAccessorDocumentationComment) {
|
|
this.contextualSetAccessorDocumentationComment = getDocumentationComment(filter(this.declarations, isSetAccessor), checker);
|
|
}
|
|
if (length(this.contextualSetAccessorDocumentationComment)) {
|
|
return this.contextualSetAccessorDocumentationComment;
|
|
}
|
|
}
|
|
}
|
|
return this.getDocumentationComment(checker);
|
|
}
|
|
getJsDocTags(checker) {
|
|
if (this.tags === void 0) {
|
|
this.tags = getJsDocTagsOfDeclarations(this.declarations, checker);
|
|
}
|
|
return this.tags;
|
|
}
|
|
getContextualJsDocTags(context, checker) {
|
|
if (context) {
|
|
if (isGetAccessor(context)) {
|
|
if (!this.contextualGetAccessorTags) {
|
|
this.contextualGetAccessorTags = getJsDocTagsOfDeclarations(filter(this.declarations, isGetAccessor), checker);
|
|
}
|
|
if (length(this.contextualGetAccessorTags)) {
|
|
return this.contextualGetAccessorTags;
|
|
}
|
|
}
|
|
if (isSetAccessor(context)) {
|
|
if (!this.contextualSetAccessorTags) {
|
|
this.contextualSetAccessorTags = getJsDocTagsOfDeclarations(filter(this.declarations, isSetAccessor), checker);
|
|
}
|
|
if (length(this.contextualSetAccessorTags)) {
|
|
return this.contextualSetAccessorTags;
|
|
}
|
|
}
|
|
}
|
|
return this.getJsDocTags(checker);
|
|
}
|
|
};
|
|
var TokenObject = class extends TokenOrIdentifierObject {
|
|
constructor(kind, pos, end) {
|
|
super(pos, end);
|
|
this.kind = kind;
|
|
}
|
|
};
|
|
var IdentifierObject = class extends TokenOrIdentifierObject {
|
|
constructor(_kind, pos, end) {
|
|
super(pos, end);
|
|
this.kind = 79 /* Identifier */;
|
|
}
|
|
get text() {
|
|
return idText(this);
|
|
}
|
|
};
|
|
IdentifierObject.prototype.kind = 79 /* Identifier */;
|
|
var PrivateIdentifierObject = class extends TokenOrIdentifierObject {
|
|
constructor(_kind, pos, end) {
|
|
super(pos, end);
|
|
this.kind = 80 /* PrivateIdentifier */;
|
|
}
|
|
get text() {
|
|
return idText(this);
|
|
}
|
|
};
|
|
PrivateIdentifierObject.prototype.kind = 80 /* PrivateIdentifier */;
|
|
var TypeObject = class {
|
|
constructor(checker, flags) {
|
|
this.checker = checker;
|
|
this.flags = flags;
|
|
}
|
|
getFlags() {
|
|
return this.flags;
|
|
}
|
|
getSymbol() {
|
|
return this.symbol;
|
|
}
|
|
getProperties() {
|
|
return this.checker.getPropertiesOfType(this);
|
|
}
|
|
getProperty(propertyName) {
|
|
return this.checker.getPropertyOfType(this, propertyName);
|
|
}
|
|
getApparentProperties() {
|
|
return this.checker.getAugmentedPropertiesOfType(this);
|
|
}
|
|
getCallSignatures() {
|
|
return this.checker.getSignaturesOfType(this, 0 /* Call */);
|
|
}
|
|
getConstructSignatures() {
|
|
return this.checker.getSignaturesOfType(this, 1 /* Construct */);
|
|
}
|
|
getStringIndexType() {
|
|
return this.checker.getIndexTypeOfType(this, 0 /* String */);
|
|
}
|
|
getNumberIndexType() {
|
|
return this.checker.getIndexTypeOfType(this, 1 /* Number */);
|
|
}
|
|
getBaseTypes() {
|
|
return this.isClassOrInterface() ? this.checker.getBaseTypes(this) : void 0;
|
|
}
|
|
isNullableType() {
|
|
return this.checker.isNullableType(this);
|
|
}
|
|
getNonNullableType() {
|
|
return this.checker.getNonNullableType(this);
|
|
}
|
|
getNonOptionalType() {
|
|
return this.checker.getNonOptionalType(this);
|
|
}
|
|
getConstraint() {
|
|
return this.checker.getBaseConstraintOfType(this);
|
|
}
|
|
getDefault() {
|
|
return this.checker.getDefaultFromTypeParameter(this);
|
|
}
|
|
isUnion() {
|
|
return !!(this.flags & 1048576 /* Union */);
|
|
}
|
|
isIntersection() {
|
|
return !!(this.flags & 2097152 /* Intersection */);
|
|
}
|
|
isUnionOrIntersection() {
|
|
return !!(this.flags & 3145728 /* UnionOrIntersection */);
|
|
}
|
|
isLiteral() {
|
|
return !!(this.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */ | 2048 /* BigIntLiteral */));
|
|
}
|
|
isStringLiteral() {
|
|
return !!(this.flags & 128 /* StringLiteral */);
|
|
}
|
|
isNumberLiteral() {
|
|
return !!(this.flags & 256 /* NumberLiteral */);
|
|
}
|
|
isTypeParameter() {
|
|
return !!(this.flags & 262144 /* TypeParameter */);
|
|
}
|
|
isClassOrInterface() {
|
|
return !!(getObjectFlags(this) & 3 /* ClassOrInterface */);
|
|
}
|
|
isClass() {
|
|
return !!(getObjectFlags(this) & 1 /* Class */);
|
|
}
|
|
isIndexType() {
|
|
return !!(this.flags & 4194304 /* Index */);
|
|
}
|
|
get typeArguments() {
|
|
if (getObjectFlags(this) & 4 /* Reference */) {
|
|
return this.checker.getTypeArguments(this);
|
|
}
|
|
return void 0;
|
|
}
|
|
};
|
|
var SignatureObject = class {
|
|
constructor(checker, flags) {
|
|
this.checker = checker;
|
|
this.flags = flags;
|
|
}
|
|
getDeclaration() {
|
|
return this.declaration;
|
|
}
|
|
getTypeParameters() {
|
|
return this.typeParameters;
|
|
}
|
|
getParameters() {
|
|
return this.parameters;
|
|
}
|
|
getReturnType() {
|
|
return this.checker.getReturnTypeOfSignature(this);
|
|
}
|
|
getTypeParameterAtPosition(pos) {
|
|
const type = this.checker.getParameterType(this, pos);
|
|
if (type.isIndexType() && isThisTypeParameter(type.type)) {
|
|
const constraint = type.type.getConstraint();
|
|
if (constraint) {
|
|
return this.checker.getIndexType(constraint);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
getDocumentationComment() {
|
|
return this.documentationComment || (this.documentationComment = getDocumentationComment(singleElementArray(this.declaration), this.checker));
|
|
}
|
|
getJsDocTags() {
|
|
return this.jsDocTags || (this.jsDocTags = getJsDocTagsOfDeclarations(singleElementArray(this.declaration), this.checker));
|
|
}
|
|
};
|
|
function hasJSDocInheritDocTag(node) {
|
|
return getJSDocTags(node).some((tag) => tag.tagName.text === "inheritDoc" || tag.tagName.text === "inheritdoc");
|
|
}
|
|
function getJsDocTagsOfDeclarations(declarations, checker) {
|
|
if (!declarations)
|
|
return emptyArray;
|
|
let tags = ts_JsDoc_exports.getJsDocTagsFromDeclarations(declarations, checker);
|
|
if (checker && (tags.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
|
|
const seenSymbols = /* @__PURE__ */ new Set();
|
|
for (const declaration of declarations) {
|
|
const inheritedTags = findBaseOfDeclaration(checker, declaration, (symbol) => {
|
|
var _a2;
|
|
if (!seenSymbols.has(symbol)) {
|
|
seenSymbols.add(symbol);
|
|
if (declaration.kind === 174 /* GetAccessor */ || declaration.kind === 175 /* SetAccessor */) {
|
|
return symbol.getContextualJsDocTags(declaration, checker);
|
|
}
|
|
return ((_a2 = symbol.declarations) == null ? void 0 : _a2.length) === 1 ? symbol.getJsDocTags() : void 0;
|
|
}
|
|
});
|
|
if (inheritedTags) {
|
|
tags = [...inheritedTags, ...tags];
|
|
}
|
|
}
|
|
}
|
|
return tags;
|
|
}
|
|
function getDocumentationComment(declarations, checker) {
|
|
if (!declarations)
|
|
return emptyArray;
|
|
let doc = ts_JsDoc_exports.getJsDocCommentsFromDeclarations(declarations, checker);
|
|
if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) {
|
|
const seenSymbols = /* @__PURE__ */ new Set();
|
|
for (const declaration of declarations) {
|
|
const inheritedDocs = findBaseOfDeclaration(checker, declaration, (symbol) => {
|
|
if (!seenSymbols.has(symbol)) {
|
|
seenSymbols.add(symbol);
|
|
if (declaration.kind === 174 /* GetAccessor */ || declaration.kind === 175 /* SetAccessor */) {
|
|
return symbol.getContextualDocumentationComment(declaration, checker);
|
|
}
|
|
return symbol.getDocumentationComment(checker);
|
|
}
|
|
});
|
|
if (inheritedDocs)
|
|
doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(lineBreakPart(), doc);
|
|
}
|
|
}
|
|
return doc;
|
|
}
|
|
function findBaseOfDeclaration(checker, declaration, cb) {
|
|
var _a2;
|
|
const classOrInterfaceDeclaration = ((_a2 = declaration.parent) == null ? void 0 : _a2.kind) === 173 /* Constructor */ ? declaration.parent.parent : declaration.parent;
|
|
if (!classOrInterfaceDeclaration)
|
|
return;
|
|
const isStaticMember = hasStaticModifier(declaration);
|
|
return firstDefined(getAllSuperTypeNodes(classOrInterfaceDeclaration), (superTypeNode) => {
|
|
const baseType = checker.getTypeAtLocation(superTypeNode);
|
|
const type = isStaticMember && baseType.symbol ? checker.getTypeOfSymbol(baseType.symbol) : baseType;
|
|
const symbol = checker.getPropertyOfType(type, declaration.symbol.name);
|
|
return symbol ? cb(symbol) : void 0;
|
|
});
|
|
}
|
|
var SourceFileObject = class extends NodeObject {
|
|
constructor(kind, pos, end) {
|
|
super(kind, pos, end);
|
|
this.kind = 308 /* SourceFile */;
|
|
}
|
|
update(newText, textChangeRange) {
|
|
return updateSourceFile(this, newText, textChangeRange);
|
|
}
|
|
getLineAndCharacterOfPosition(position) {
|
|
return getLineAndCharacterOfPosition(this, position);
|
|
}
|
|
getLineStarts() {
|
|
return getLineStarts(this);
|
|
}
|
|
getPositionOfLineAndCharacter(line, character, allowEdits) {
|
|
return computePositionOfLineAndCharacter(getLineStarts(this), line, character, this.text, allowEdits);
|
|
}
|
|
getLineEndOfPosition(pos) {
|
|
const { line } = this.getLineAndCharacterOfPosition(pos);
|
|
const lineStarts = this.getLineStarts();
|
|
let lastCharPos;
|
|
if (line + 1 >= lineStarts.length) {
|
|
lastCharPos = this.getEnd();
|
|
}
|
|
if (!lastCharPos) {
|
|
lastCharPos = lineStarts[line + 1] - 1;
|
|
}
|
|
const fullText = this.getFullText();
|
|
return fullText[lastCharPos] === "\n" && fullText[lastCharPos - 1] === "\r" ? lastCharPos - 1 : lastCharPos;
|
|
}
|
|
getNamedDeclarations() {
|
|
if (!this.namedDeclarations) {
|
|
this.namedDeclarations = this.computeNamedDeclarations();
|
|
}
|
|
return this.namedDeclarations;
|
|
}
|
|
computeNamedDeclarations() {
|
|
const result = createMultiMap();
|
|
this.forEachChild(visit);
|
|
return result;
|
|
function addDeclaration(declaration) {
|
|
const name = getDeclarationName(declaration);
|
|
if (name) {
|
|
result.add(name, declaration);
|
|
}
|
|
}
|
|
function getDeclarations(name) {
|
|
let declarations = result.get(name);
|
|
if (!declarations) {
|
|
result.set(name, declarations = []);
|
|
}
|
|
return declarations;
|
|
}
|
|
function getDeclarationName(declaration) {
|
|
const name = getNonAssignedNameOfDeclaration(declaration);
|
|
return name && (isComputedPropertyName(name) && isPropertyAccessExpression(name.expression) ? name.expression.name.text : isPropertyName(name) ? getNameFromPropertyName(name) : void 0);
|
|
}
|
|
function visit(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
const functionDeclaration = node;
|
|
const declarationName = getDeclarationName(functionDeclaration);
|
|
if (declarationName) {
|
|
const declarations = getDeclarations(declarationName);
|
|
const lastDeclaration = lastOrUndefined(declarations);
|
|
if (lastDeclaration && functionDeclaration.parent === lastDeclaration.parent && functionDeclaration.symbol === lastDeclaration.symbol) {
|
|
if (functionDeclaration.body && !lastDeclaration.body) {
|
|
declarations[declarations.length - 1] = functionDeclaration;
|
|
}
|
|
} else {
|
|
declarations.push(functionDeclaration);
|
|
}
|
|
}
|
|
forEachChild(node, visit);
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 184 /* TypeLiteral */:
|
|
addDeclaration(node);
|
|
forEachChild(node, visit);
|
|
break;
|
|
case 166 /* Parameter */:
|
|
if (!hasSyntacticModifier(node, 16476 /* ParameterPropertyModifier */)) {
|
|
break;
|
|
}
|
|
case 257 /* VariableDeclaration */:
|
|
case 205 /* BindingElement */: {
|
|
const decl = node;
|
|
if (isBindingPattern(decl.name)) {
|
|
forEachChild(decl.name, visit);
|
|
break;
|
|
}
|
|
if (decl.initializer) {
|
|
visit(decl.initializer);
|
|
}
|
|
}
|
|
case 302 /* EnumMember */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
addDeclaration(node);
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
const exportDeclaration = node;
|
|
if (exportDeclaration.exportClause) {
|
|
if (isNamedExports(exportDeclaration.exportClause)) {
|
|
forEach(exportDeclaration.exportClause.elements, visit);
|
|
} else {
|
|
visit(exportDeclaration.exportClause.name);
|
|
}
|
|
}
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
const importClause = node.importClause;
|
|
if (importClause) {
|
|
if (importClause.name) {
|
|
addDeclaration(importClause.name);
|
|
}
|
|
if (importClause.namedBindings) {
|
|
if (importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
addDeclaration(importClause.namedBindings);
|
|
} else {
|
|
forEach(importClause.namedBindings.elements, visit);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (getAssignmentDeclarationKind(node) !== 0 /* None */) {
|
|
addDeclaration(node);
|
|
}
|
|
default:
|
|
forEachChild(node, visit);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var SourceMapSourceObject = class {
|
|
constructor(fileName, text, skipTrivia2) {
|
|
this.fileName = fileName;
|
|
this.text = text;
|
|
this.skipTrivia = skipTrivia2;
|
|
}
|
|
getLineAndCharacterOfPosition(pos) {
|
|
return getLineAndCharacterOfPosition(this, pos);
|
|
}
|
|
};
|
|
function getServicesObjectAllocator() {
|
|
return {
|
|
getNodeConstructor: () => NodeObject,
|
|
getTokenConstructor: () => TokenObject,
|
|
getIdentifierConstructor: () => IdentifierObject,
|
|
getPrivateIdentifierConstructor: () => PrivateIdentifierObject,
|
|
getSourceFileConstructor: () => SourceFileObject,
|
|
getSymbolConstructor: () => SymbolObject,
|
|
getTypeConstructor: () => TypeObject,
|
|
getSignatureConstructor: () => SignatureObject,
|
|
getSourceMapSourceConstructor: () => SourceMapSourceObject
|
|
};
|
|
}
|
|
function toEditorSettings(optionsAsMap) {
|
|
let allPropertiesAreCamelCased = true;
|
|
for (const key in optionsAsMap) {
|
|
if (hasProperty(optionsAsMap, key) && !isCamelCase(key)) {
|
|
allPropertiesAreCamelCased = false;
|
|
break;
|
|
}
|
|
}
|
|
if (allPropertiesAreCamelCased) {
|
|
return optionsAsMap;
|
|
}
|
|
const settings = {};
|
|
for (const key in optionsAsMap) {
|
|
if (hasProperty(optionsAsMap, key)) {
|
|
const newKey = isCamelCase(key) ? key : key.charAt(0).toLowerCase() + key.substr(1);
|
|
settings[newKey] = optionsAsMap[key];
|
|
}
|
|
}
|
|
return settings;
|
|
}
|
|
function isCamelCase(s) {
|
|
return !s.length || s.charAt(0) === s.charAt(0).toLowerCase();
|
|
}
|
|
function displayPartsToString(displayParts) {
|
|
if (displayParts) {
|
|
return map(displayParts, (displayPart2) => displayPart2.text).join("");
|
|
}
|
|
return "";
|
|
}
|
|
function getDefaultCompilerOptions2() {
|
|
return {
|
|
target: 1 /* ES5 */,
|
|
jsx: 1 /* Preserve */
|
|
};
|
|
}
|
|
function getSupportedCodeFixes() {
|
|
return ts_codefix_exports.getSupportedErrorCodes();
|
|
}
|
|
var SyntaxTreeCache = class {
|
|
constructor(host) {
|
|
this.host = host;
|
|
}
|
|
getCurrentSourceFile(fileName) {
|
|
var _a2, _b, _c, _d, _e, _f, _g, _h;
|
|
const scriptSnapshot = this.host.getScriptSnapshot(fileName);
|
|
if (!scriptSnapshot) {
|
|
throw new Error("Could not find file: '" + fileName + "'.");
|
|
}
|
|
const scriptKind = getScriptKind(fileName, this.host);
|
|
const version2 = this.host.getScriptVersion(fileName);
|
|
let sourceFile;
|
|
if (this.currentFileName !== fileName) {
|
|
const options = {
|
|
languageVersion: 99 /* Latest */,
|
|
impliedNodeFormat: getImpliedNodeFormatForFile(
|
|
toPath(fileName, this.host.getCurrentDirectory(), ((_c = (_b = (_a2 = this.host).getCompilerHost) == null ? void 0 : _b.call(_a2)) == null ? void 0 : _c.getCanonicalFileName) || hostGetCanonicalFileName(this.host)),
|
|
(_h = (_g = (_f = (_e = (_d = this.host).getCompilerHost) == null ? void 0 : _e.call(_d)) == null ? void 0 : _f.getModuleResolutionCache) == null ? void 0 : _g.call(_f)) == null ? void 0 : _h.getPackageJsonInfoCache(),
|
|
this.host,
|
|
this.host.getCompilationSettings()
|
|
),
|
|
setExternalModuleIndicator: getSetExternalModuleIndicator(this.host.getCompilationSettings())
|
|
};
|
|
sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, options, version2, true, scriptKind);
|
|
} else if (this.currentFileVersion !== version2) {
|
|
const editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot);
|
|
sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version2, editRange);
|
|
}
|
|
if (sourceFile) {
|
|
this.currentFileVersion = version2;
|
|
this.currentFileName = fileName;
|
|
this.currentFileScriptSnapshot = scriptSnapshot;
|
|
this.currentSourceFile = sourceFile;
|
|
}
|
|
return this.currentSourceFile;
|
|
}
|
|
};
|
|
function setSourceFileFields(sourceFile, scriptSnapshot, version2) {
|
|
sourceFile.version = version2;
|
|
sourceFile.scriptSnapshot = scriptSnapshot;
|
|
}
|
|
function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTargetOrOptions, version2, setNodeParents, scriptKind) {
|
|
const sourceFile = createSourceFile(fileName, getSnapshotText(scriptSnapshot), scriptTargetOrOptions, setNodeParents, scriptKind);
|
|
setSourceFileFields(sourceFile, scriptSnapshot, version2);
|
|
return sourceFile;
|
|
}
|
|
function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version2, textChangeRange, aggressiveChecks) {
|
|
if (textChangeRange) {
|
|
if (version2 !== sourceFile.version) {
|
|
let newText;
|
|
const prefix = textChangeRange.span.start !== 0 ? sourceFile.text.substr(0, textChangeRange.span.start) : "";
|
|
const suffix = textSpanEnd(textChangeRange.span) !== sourceFile.text.length ? sourceFile.text.substr(textSpanEnd(textChangeRange.span)) : "";
|
|
if (textChangeRange.newLength === 0) {
|
|
newText = prefix && suffix ? prefix + suffix : prefix || suffix;
|
|
} else {
|
|
const changedText = scriptSnapshot.getText(textChangeRange.span.start, textChangeRange.span.start + textChangeRange.newLength);
|
|
newText = prefix && suffix ? prefix + changedText + suffix : prefix ? prefix + changedText : changedText + suffix;
|
|
}
|
|
const newSourceFile = updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks);
|
|
setSourceFileFields(newSourceFile, scriptSnapshot, version2);
|
|
newSourceFile.nameTable = void 0;
|
|
if (sourceFile !== newSourceFile && sourceFile.scriptSnapshot) {
|
|
if (sourceFile.scriptSnapshot.dispose) {
|
|
sourceFile.scriptSnapshot.dispose();
|
|
}
|
|
sourceFile.scriptSnapshot = void 0;
|
|
}
|
|
return newSourceFile;
|
|
}
|
|
}
|
|
const options = {
|
|
languageVersion: sourceFile.languageVersion,
|
|
impliedNodeFormat: sourceFile.impliedNodeFormat,
|
|
setExternalModuleIndicator: sourceFile.setExternalModuleIndicator
|
|
};
|
|
return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, options, version2, true, sourceFile.scriptKind);
|
|
}
|
|
var NoopCancellationToken = {
|
|
isCancellationRequested: returnFalse,
|
|
throwIfCancellationRequested: noop
|
|
};
|
|
var CancellationTokenObject = class {
|
|
constructor(cancellationToken) {
|
|
this.cancellationToken = cancellationToken;
|
|
}
|
|
isCancellationRequested() {
|
|
return this.cancellationToken.isCancellationRequested();
|
|
}
|
|
throwIfCancellationRequested() {
|
|
var _a2;
|
|
if (this.isCancellationRequested()) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.Session, "cancellationThrown", { kind: "CancellationTokenObject" });
|
|
throw new OperationCanceledException();
|
|
}
|
|
}
|
|
};
|
|
var ThrottledCancellationToken = class {
|
|
constructor(hostCancellationToken, throttleWaitMilliseconds = 20) {
|
|
this.hostCancellationToken = hostCancellationToken;
|
|
this.throttleWaitMilliseconds = throttleWaitMilliseconds;
|
|
this.lastCancellationCheckTime = 0;
|
|
}
|
|
isCancellationRequested() {
|
|
const time = timestamp();
|
|
const duration = Math.abs(time - this.lastCancellationCheckTime);
|
|
if (duration >= this.throttleWaitMilliseconds) {
|
|
this.lastCancellationCheckTime = time;
|
|
return this.hostCancellationToken.isCancellationRequested();
|
|
}
|
|
return false;
|
|
}
|
|
throwIfCancellationRequested() {
|
|
var _a2;
|
|
if (this.isCancellationRequested()) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.Session, "cancellationThrown", { kind: "ThrottledCancellationToken" });
|
|
throw new OperationCanceledException();
|
|
}
|
|
}
|
|
};
|
|
var invalidOperationsInPartialSemanticMode = [
|
|
"getSemanticDiagnostics",
|
|
"getSuggestionDiagnostics",
|
|
"getCompilerOptionsDiagnostics",
|
|
"getSemanticClassifications",
|
|
"getEncodedSemanticClassifications",
|
|
"getCodeFixesAtPosition",
|
|
"getCombinedCodeFix",
|
|
"applyCodeActionCommand",
|
|
"organizeImports",
|
|
"getEditsForFileRename",
|
|
"getEmitOutput",
|
|
"getApplicableRefactors",
|
|
"getEditsForRefactor",
|
|
"prepareCallHierarchy",
|
|
"provideCallHierarchyIncomingCalls",
|
|
"provideCallHierarchyOutgoingCalls",
|
|
"provideInlayHints"
|
|
];
|
|
var invalidOperationsInSyntacticMode = [
|
|
...invalidOperationsInPartialSemanticMode,
|
|
"getCompletionsAtPosition",
|
|
"getCompletionEntryDetails",
|
|
"getCompletionEntrySymbol",
|
|
"getSignatureHelpItems",
|
|
"getQuickInfoAtPosition",
|
|
"getDefinitionAtPosition",
|
|
"getDefinitionAndBoundSpan",
|
|
"getImplementationAtPosition",
|
|
"getTypeDefinitionAtPosition",
|
|
"getReferencesAtPosition",
|
|
"findReferences",
|
|
"getOccurrencesAtPosition",
|
|
"getDocumentHighlights",
|
|
"getNavigateToItems",
|
|
"getRenameInfo",
|
|
"findRenameLocations",
|
|
"getApplicableRefactors"
|
|
];
|
|
function createLanguageService(host, documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()), syntaxOnlyOrLanguageServiceMode) {
|
|
var _a2;
|
|
let languageServiceMode;
|
|
if (syntaxOnlyOrLanguageServiceMode === void 0) {
|
|
languageServiceMode = 0 /* Semantic */;
|
|
} else if (typeof syntaxOnlyOrLanguageServiceMode === "boolean") {
|
|
languageServiceMode = syntaxOnlyOrLanguageServiceMode ? 2 /* Syntactic */ : 0 /* Semantic */;
|
|
} else {
|
|
languageServiceMode = syntaxOnlyOrLanguageServiceMode;
|
|
}
|
|
const syntaxTreeCache = new SyntaxTreeCache(host);
|
|
let program;
|
|
let lastProjectVersion;
|
|
let lastTypesRootVersion = 0;
|
|
const cancellationToken = host.getCancellationToken ? new CancellationTokenObject(host.getCancellationToken()) : NoopCancellationToken;
|
|
const currentDirectory = host.getCurrentDirectory();
|
|
maybeSetLocalizedDiagnosticMessages((_a2 = host.getLocalizedDiagnosticMessages) == null ? void 0 : _a2.bind(host));
|
|
function log(message) {
|
|
if (host.log) {
|
|
host.log(message);
|
|
}
|
|
}
|
|
const useCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames(host);
|
|
const getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
|
|
const sourceMapper = getSourceMapper({
|
|
useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
getProgram,
|
|
fileExists: maybeBind(host, host.fileExists),
|
|
readFile: maybeBind(host, host.readFile),
|
|
getDocumentPositionMapper: maybeBind(host, host.getDocumentPositionMapper),
|
|
getSourceFileLike: maybeBind(host, host.getSourceFileLike),
|
|
log
|
|
});
|
|
function getValidSourceFile(fileName) {
|
|
const sourceFile = program.getSourceFile(fileName);
|
|
if (!sourceFile) {
|
|
const error = new Error(`Could not find source file: '${fileName}'.`);
|
|
error.ProgramFiles = program.getSourceFiles().map((f) => f.fileName);
|
|
throw error;
|
|
}
|
|
return sourceFile;
|
|
}
|
|
function synchronizeHostData() {
|
|
var _a3, _b, _c;
|
|
Debug.assert(languageServiceMode !== 2 /* Syntactic */);
|
|
if (host.getProjectVersion) {
|
|
const hostProjectVersion = host.getProjectVersion();
|
|
if (hostProjectVersion) {
|
|
if (lastProjectVersion === hostProjectVersion && !((_a3 = host.hasChangedAutomaticTypeDirectiveNames) == null ? void 0 : _a3.call(host))) {
|
|
return;
|
|
}
|
|
lastProjectVersion = hostProjectVersion;
|
|
}
|
|
}
|
|
const typeRootsVersion = host.getTypeRootsVersion ? host.getTypeRootsVersion() : 0;
|
|
if (lastTypesRootVersion !== typeRootsVersion) {
|
|
log("TypeRoots version has changed; provide new program");
|
|
program = void 0;
|
|
lastTypesRootVersion = typeRootsVersion;
|
|
}
|
|
const rootFileNames = host.getScriptFileNames().slice();
|
|
const newSettings = host.getCompilationSettings() || getDefaultCompilerOptions2();
|
|
const hasInvalidatedResolutions = host.hasInvalidatedResolutions || returnFalse;
|
|
const hasChangedAutomaticTypeDirectiveNames = maybeBind(host, host.hasChangedAutomaticTypeDirectiveNames);
|
|
const projectReferences = (_b = host.getProjectReferences) == null ? void 0 : _b.call(host);
|
|
let parsedCommandLines;
|
|
let compilerHost = {
|
|
getSourceFile: getOrCreateSourceFile,
|
|
getSourceFileByPath: getOrCreateSourceFileByPath,
|
|
getCancellationToken: () => cancellationToken,
|
|
getCanonicalFileName,
|
|
useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
|
|
getNewLine: () => getNewLineCharacter(newSettings, () => getNewLineOrDefaultFromHost(host)),
|
|
getDefaultLibFileName: (options2) => host.getDefaultLibFileName(options2),
|
|
writeFile: noop,
|
|
getCurrentDirectory: () => currentDirectory,
|
|
fileExists: (fileName) => host.fileExists(fileName),
|
|
readFile: (fileName) => host.readFile && host.readFile(fileName),
|
|
getSymlinkCache: maybeBind(host, host.getSymlinkCache),
|
|
realpath: maybeBind(host, host.realpath),
|
|
directoryExists: (directoryName) => {
|
|
return directoryProbablyExists(directoryName, host);
|
|
},
|
|
getDirectories: (path) => {
|
|
return host.getDirectories ? host.getDirectories(path) : [];
|
|
},
|
|
readDirectory: (path, extensions, exclude, include, depth) => {
|
|
Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'");
|
|
return host.readDirectory(path, extensions, exclude, include, depth);
|
|
},
|
|
onReleaseOldSourceFile,
|
|
onReleaseParsedCommandLine,
|
|
hasInvalidatedResolutions,
|
|
hasChangedAutomaticTypeDirectiveNames,
|
|
trace: maybeBind(host, host.trace),
|
|
resolveModuleNames: maybeBind(host, host.resolveModuleNames),
|
|
getModuleResolutionCache: maybeBind(host, host.getModuleResolutionCache),
|
|
createHash: maybeBind(host, host.createHash),
|
|
resolveTypeReferenceDirectives: maybeBind(host, host.resolveTypeReferenceDirectives),
|
|
useSourceOfProjectReferenceRedirect: maybeBind(host, host.useSourceOfProjectReferenceRedirect),
|
|
getParsedCommandLine
|
|
};
|
|
const originalGetSourceFile = compilerHost.getSourceFile;
|
|
const { getSourceFileWithCache } = changeCompilerHostLikeToUseCache(
|
|
compilerHost,
|
|
(fileName) => toPath(fileName, currentDirectory, getCanonicalFileName),
|
|
(...args) => originalGetSourceFile.call(compilerHost, ...args)
|
|
);
|
|
compilerHost.getSourceFile = getSourceFileWithCache;
|
|
(_c = host.setCompilerHost) == null ? void 0 : _c.call(host, compilerHost);
|
|
const parseConfigHost = {
|
|
useCaseSensitiveFileNames,
|
|
fileExists: (fileName) => compilerHost.fileExists(fileName),
|
|
readFile: (fileName) => compilerHost.readFile(fileName),
|
|
readDirectory: (...args) => compilerHost.readDirectory(...args),
|
|
trace: compilerHost.trace,
|
|
getCurrentDirectory: compilerHost.getCurrentDirectory,
|
|
onUnRecoverableConfigFileDiagnostic: noop
|
|
};
|
|
const documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
|
|
if (isProgramUptoDate(program, rootFileNames, newSettings, (_path, fileName) => host.getScriptVersion(fileName), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
|
|
return;
|
|
}
|
|
const options = {
|
|
rootNames: rootFileNames,
|
|
options: newSettings,
|
|
host: compilerHost,
|
|
oldProgram: program,
|
|
projectReferences
|
|
};
|
|
program = createProgram(options);
|
|
compilerHost = void 0;
|
|
parsedCommandLines = void 0;
|
|
sourceMapper.clearCache();
|
|
program.getTypeChecker();
|
|
return;
|
|
function getParsedCommandLine(fileName) {
|
|
const path = toPath(fileName, currentDirectory, getCanonicalFileName);
|
|
const existing = parsedCommandLines == null ? void 0 : parsedCommandLines.get(path);
|
|
if (existing !== void 0)
|
|
return existing || void 0;
|
|
const result = host.getParsedCommandLine ? host.getParsedCommandLine(fileName) : getParsedCommandLineOfConfigFileUsingSourceFile(fileName);
|
|
(parsedCommandLines || (parsedCommandLines = /* @__PURE__ */ new Map())).set(path, result || false);
|
|
return result;
|
|
}
|
|
function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) {
|
|
const result = getOrCreateSourceFile(configFileName, 100 /* JSON */);
|
|
if (!result)
|
|
return void 0;
|
|
result.path = toPath(configFileName, currentDirectory, getCanonicalFileName);
|
|
result.resolvedPath = result.path;
|
|
result.originalFileName = result.fileName;
|
|
return parseJsonSourceFileConfigFileContent(
|
|
result,
|
|
parseConfigHost,
|
|
getNormalizedAbsolutePath(getDirectoryPath(configFileName), currentDirectory),
|
|
void 0,
|
|
getNormalizedAbsolutePath(configFileName, currentDirectory)
|
|
);
|
|
}
|
|
function onReleaseParsedCommandLine(configFileName, oldResolvedRef, oldOptions) {
|
|
var _a4;
|
|
if (host.getParsedCommandLine) {
|
|
(_a4 = host.onReleaseParsedCommandLine) == null ? void 0 : _a4.call(host, configFileName, oldResolvedRef, oldOptions);
|
|
} else if (oldResolvedRef) {
|
|
onReleaseOldSourceFile(oldResolvedRef.sourceFile, oldOptions);
|
|
}
|
|
}
|
|
function onReleaseOldSourceFile(oldSourceFile, oldOptions) {
|
|
const oldSettingsKey = documentRegistry.getKeyForCompilationSettings(oldOptions);
|
|
documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, oldSettingsKey, oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
|
|
}
|
|
function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) {
|
|
return getOrCreateSourceFileByPath(fileName, toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile);
|
|
}
|
|
function getOrCreateSourceFileByPath(fileName, path, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) {
|
|
Debug.assert(compilerHost, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host.");
|
|
const scriptSnapshot = host.getScriptSnapshot(fileName);
|
|
if (!scriptSnapshot) {
|
|
return void 0;
|
|
}
|
|
const scriptKind = getScriptKind(fileName, host);
|
|
const scriptVersion = host.getScriptVersion(fileName);
|
|
if (!shouldCreateNewSourceFile) {
|
|
const oldSourceFile = program && program.getSourceFileByPath(path);
|
|
if (oldSourceFile) {
|
|
if (scriptKind === oldSourceFile.scriptKind) {
|
|
return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
|
|
} else {
|
|
documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
|
|
}
|
|
}
|
|
}
|
|
return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
|
|
}
|
|
}
|
|
function getProgram() {
|
|
if (languageServiceMode === 2 /* Syntactic */) {
|
|
Debug.assert(program === void 0);
|
|
return void 0;
|
|
}
|
|
synchronizeHostData();
|
|
return program;
|
|
}
|
|
function getAutoImportProvider() {
|
|
var _a3;
|
|
return (_a3 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a3.call(host);
|
|
}
|
|
function updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans) {
|
|
const checker = program.getTypeChecker();
|
|
const symbol = getSymbolForProgram();
|
|
if (!symbol)
|
|
return false;
|
|
for (const referencedSymbol of referencedSymbols) {
|
|
for (const ref of referencedSymbol.references) {
|
|
const refNode = getNodeForSpan(ref);
|
|
Debug.assertIsDefined(refNode);
|
|
if (knownSymbolSpans.has(ref) || ts_FindAllReferences_exports.isDeclarationOfSymbol(refNode, symbol)) {
|
|
knownSymbolSpans.add(ref);
|
|
ref.isDefinition = true;
|
|
const mappedSpan = getMappedDocumentSpan(ref, sourceMapper, maybeBind(host, host.fileExists));
|
|
if (mappedSpan) {
|
|
knownSymbolSpans.add(mappedSpan);
|
|
}
|
|
} else {
|
|
ref.isDefinition = false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
function getSymbolForProgram() {
|
|
for (const referencedSymbol of referencedSymbols) {
|
|
for (const ref of referencedSymbol.references) {
|
|
if (knownSymbolSpans.has(ref)) {
|
|
const refNode = getNodeForSpan(ref);
|
|
Debug.assertIsDefined(refNode);
|
|
return checker.getSymbolAtLocation(refNode);
|
|
}
|
|
const mappedSpan = getMappedDocumentSpan(ref, sourceMapper, maybeBind(host, host.fileExists));
|
|
if (mappedSpan && knownSymbolSpans.has(mappedSpan)) {
|
|
const refNode = getNodeForSpan(mappedSpan);
|
|
if (refNode) {
|
|
return checker.getSymbolAtLocation(refNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getNodeForSpan(docSpan) {
|
|
const sourceFile = program.getSourceFile(docSpan.fileName);
|
|
if (!sourceFile)
|
|
return void 0;
|
|
const rawNode = getTouchingPropertyName(sourceFile, docSpan.textSpan.start);
|
|
const adjustedNode = ts_FindAllReferences_exports.Core.getAdjustedNode(rawNode, { use: ts_FindAllReferences_exports.FindReferencesUse.References });
|
|
return adjustedNode;
|
|
}
|
|
}
|
|
function cleanupSemanticCache() {
|
|
program = void 0;
|
|
}
|
|
function dispose() {
|
|
if (program) {
|
|
const key = documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions());
|
|
forEach(program.getSourceFiles(), (f) => documentRegistry.releaseDocumentWithKey(f.resolvedPath, key, f.scriptKind, f.impliedNodeFormat));
|
|
program = void 0;
|
|
}
|
|
host = void 0;
|
|
}
|
|
function getSyntacticDiagnostics(fileName) {
|
|
synchronizeHostData();
|
|
return program.getSyntacticDiagnostics(getValidSourceFile(fileName), cancellationToken).slice();
|
|
}
|
|
function getSemanticDiagnostics(fileName) {
|
|
synchronizeHostData();
|
|
const targetSourceFile = getValidSourceFile(fileName);
|
|
const semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile, cancellationToken);
|
|
if (!getEmitDeclarations(program.getCompilerOptions())) {
|
|
return semanticDiagnostics.slice();
|
|
}
|
|
const declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile, cancellationToken);
|
|
return [...semanticDiagnostics, ...declarationDiagnostics];
|
|
}
|
|
function getSuggestionDiagnostics(fileName) {
|
|
synchronizeHostData();
|
|
return computeSuggestionDiagnostics(getValidSourceFile(fileName), program, cancellationToken);
|
|
}
|
|
function getCompilerOptionsDiagnostics() {
|
|
synchronizeHostData();
|
|
return [...program.getOptionsDiagnostics(cancellationToken), ...program.getGlobalDiagnostics(cancellationToken)];
|
|
}
|
|
function getCompletionsAtPosition2(fileName, position, options = emptyOptions, formattingSettings) {
|
|
const fullPreferences = {
|
|
...identity(options),
|
|
includeCompletionsForModuleExports: options.includeCompletionsForModuleExports || options.includeExternalModuleExports,
|
|
includeCompletionsWithInsertText: options.includeCompletionsWithInsertText || options.includeInsertTextCompletions
|
|
};
|
|
synchronizeHostData();
|
|
return ts_Completions_exports.getCompletionsAtPosition(
|
|
host,
|
|
program,
|
|
log,
|
|
getValidSourceFile(fileName),
|
|
position,
|
|
fullPreferences,
|
|
options.triggerCharacter,
|
|
options.triggerKind,
|
|
cancellationToken,
|
|
formattingSettings && ts_formatting_exports.getFormatContext(formattingSettings, host)
|
|
);
|
|
}
|
|
function getCompletionEntryDetails2(fileName, position, name, formattingOptions, source, preferences = emptyOptions, data) {
|
|
synchronizeHostData();
|
|
return ts_Completions_exports.getCompletionEntryDetails(
|
|
program,
|
|
log,
|
|
getValidSourceFile(fileName),
|
|
position,
|
|
{ name, source, data },
|
|
host,
|
|
formattingOptions && ts_formatting_exports.getFormatContext(formattingOptions, host),
|
|
preferences,
|
|
cancellationToken
|
|
);
|
|
}
|
|
function getCompletionEntrySymbol2(fileName, position, name, source, preferences = emptyOptions) {
|
|
synchronizeHostData();
|
|
return ts_Completions_exports.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name, source }, host, preferences);
|
|
}
|
|
function getQuickInfoAtPosition(fileName, position) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
if (node === sourceFile) {
|
|
return void 0;
|
|
}
|
|
const typeChecker = program.getTypeChecker();
|
|
const nodeForQuickInfo = getNodeForQuickInfo(node);
|
|
const symbol = getSymbolAtLocationForQuickInfo(nodeForQuickInfo, typeChecker);
|
|
if (!symbol || typeChecker.isUnknownSymbol(symbol)) {
|
|
const type = shouldGetType(sourceFile, nodeForQuickInfo, position) ? typeChecker.getTypeAtLocation(nodeForQuickInfo) : void 0;
|
|
return type && {
|
|
kind: "" /* unknown */,
|
|
kindModifiers: "" /* none */,
|
|
textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
|
|
displayParts: typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => typeToDisplayParts(typeChecker2, type, getContainerNode(nodeForQuickInfo))),
|
|
documentation: type.symbol ? type.symbol.getDocumentationComment(typeChecker) : void 0,
|
|
tags: type.symbol ? type.symbol.getJsDocTags(typeChecker) : void 0
|
|
};
|
|
}
|
|
const { symbolKind, displayParts, documentation, tags } = typeChecker.runWithCancellationToken(
|
|
cancellationToken,
|
|
(typeChecker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker2, symbol, sourceFile, getContainerNode(nodeForQuickInfo), nodeForQuickInfo)
|
|
);
|
|
return {
|
|
kind: symbolKind,
|
|
kindModifiers: ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol),
|
|
textSpan: createTextSpanFromNode(nodeForQuickInfo, sourceFile),
|
|
displayParts,
|
|
documentation,
|
|
tags
|
|
};
|
|
}
|
|
function getNodeForQuickInfo(node) {
|
|
if (isNewExpression(node.parent) && node.pos === node.parent.pos) {
|
|
return node.parent.expression;
|
|
}
|
|
if (isNamedTupleMember(node.parent) && node.pos === node.parent.pos) {
|
|
return node.parent;
|
|
}
|
|
if (isImportMeta(node.parent) && node.parent.name === node) {
|
|
return node.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function shouldGetType(sourceFile, node, position) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
return !isLabelName(node) && !isTagName(node) && !isConstTypeReference(node.parent);
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 163 /* QualifiedName */:
|
|
return !isInComment(sourceFile, position);
|
|
case 108 /* ThisKeyword */:
|
|
case 194 /* ThisType */:
|
|
case 106 /* SuperKeyword */:
|
|
case 199 /* NamedTupleMember */:
|
|
return true;
|
|
case 233 /* MetaProperty */:
|
|
return isImportMeta(node);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getDefinitionAtPosition2(fileName, position, searchOtherFilesOnly, stopAtAlias) {
|
|
synchronizeHostData();
|
|
return ts_GoToDefinition_exports.getDefinitionAtPosition(program, getValidSourceFile(fileName), position, searchOtherFilesOnly, stopAtAlias);
|
|
}
|
|
function getDefinitionAndBoundSpan2(fileName, position) {
|
|
synchronizeHostData();
|
|
return ts_GoToDefinition_exports.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position);
|
|
}
|
|
function getTypeDefinitionAtPosition2(fileName, position) {
|
|
synchronizeHostData();
|
|
return ts_GoToDefinition_exports.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position);
|
|
}
|
|
function getImplementationAtPosition(fileName, position) {
|
|
synchronizeHostData();
|
|
return ts_FindAllReferences_exports.getImplementationsAtPosition(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
|
|
}
|
|
function getOccurrencesAtPosition(fileName, position) {
|
|
return flatMap(
|
|
getDocumentHighlights(fileName, position, [fileName]),
|
|
(entry) => entry.highlightSpans.map((highlightSpan) => ({
|
|
fileName: entry.fileName,
|
|
textSpan: highlightSpan.textSpan,
|
|
isWriteAccess: highlightSpan.kind === "writtenReference" /* writtenReference */,
|
|
...highlightSpan.isInString && { isInString: true },
|
|
...highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan }
|
|
}))
|
|
);
|
|
}
|
|
function getDocumentHighlights(fileName, position, filesToSearch) {
|
|
const normalizedFileName = normalizePath(fileName);
|
|
Debug.assert(filesToSearch.some((f) => normalizePath(f) === normalizedFileName));
|
|
synchronizeHostData();
|
|
const sourceFilesToSearch = mapDefined(filesToSearch, (fileName2) => program.getSourceFile(fileName2));
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
return DocumentHighlights.getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch);
|
|
}
|
|
function findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const node = getAdjustedRenameLocation(getTouchingPropertyName(sourceFile, position));
|
|
if (!ts_Rename_exports.nodeIsEligibleForRename(node))
|
|
return void 0;
|
|
if (isIdentifier(node) && (isJsxOpeningElement(node.parent) || isJsxClosingElement(node.parent)) && isIntrinsicJsxName(node.escapedText)) {
|
|
const { openingElement, closingElement } = node.parent.parent;
|
|
return [openingElement, closingElement].map((node2) => {
|
|
const textSpan = createTextSpanFromNode(node2.tagName, sourceFile);
|
|
return {
|
|
fileName: sourceFile.fileName,
|
|
textSpan,
|
|
...ts_FindAllReferences_exports.toContextSpan(textSpan, sourceFile, node2.parent)
|
|
};
|
|
});
|
|
} else {
|
|
return getReferencesWorker2(
|
|
node,
|
|
position,
|
|
{ findInStrings, findInComments, providePrefixAndSuffixTextForRename, use: ts_FindAllReferences_exports.FindReferencesUse.Rename },
|
|
(entry, originalNode, checker) => ts_FindAllReferences_exports.toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixTextForRename || false)
|
|
);
|
|
}
|
|
}
|
|
function getReferencesAtPosition(fileName, position) {
|
|
synchronizeHostData();
|
|
return getReferencesWorker2(getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: ts_FindAllReferences_exports.FindReferencesUse.References }, ts_FindAllReferences_exports.toReferenceEntry);
|
|
}
|
|
function getReferencesWorker2(node, position, options, cb) {
|
|
synchronizeHostData();
|
|
const sourceFiles = options && options.use === ts_FindAllReferences_exports.FindReferencesUse.Rename ? program.getSourceFiles().filter((sourceFile) => !program.isSourceFileDefaultLibrary(sourceFile)) : program.getSourceFiles();
|
|
return ts_FindAllReferences_exports.findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, cb);
|
|
}
|
|
function findReferences(fileName, position) {
|
|
synchronizeHostData();
|
|
return ts_FindAllReferences_exports.findReferencedSymbols(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position);
|
|
}
|
|
function getFileReferences(fileName) {
|
|
synchronizeHostData();
|
|
return ts_FindAllReferences_exports.Core.getReferencesForFileName(fileName, program, program.getSourceFiles()).map(ts_FindAllReferences_exports.toReferenceEntry);
|
|
}
|
|
function getNavigateToItems2(searchValue, maxResultCount, fileName, excludeDtsFiles = false) {
|
|
synchronizeHostData();
|
|
const sourceFiles = fileName ? [getValidSourceFile(fileName)] : program.getSourceFiles();
|
|
return getNavigateToItems(sourceFiles, program.getTypeChecker(), cancellationToken, searchValue, maxResultCount, excludeDtsFiles);
|
|
}
|
|
function getEmitOutput(fileName, emitOnlyDtsFiles, forceDtsEmit) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const customTransformers = host.getCustomTransformers && host.getCustomTransformers();
|
|
return getFileEmitOutput(program, sourceFile, !!emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit);
|
|
}
|
|
function getSignatureHelpItems2(fileName, position, { triggerReason } = emptyOptions) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
return ts_SignatureHelp_exports.getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken);
|
|
}
|
|
function getNonBoundSourceFile(fileName) {
|
|
return syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
}
|
|
function getNameOrDottedNameSpan(fileName, startPos, _endPos) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const node = getTouchingPropertyName(sourceFile, startPos);
|
|
if (node === sourceFile) {
|
|
return void 0;
|
|
}
|
|
switch (node.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 163 /* QualifiedName */:
|
|
case 10 /* StringLiteral */:
|
|
case 95 /* FalseKeyword */:
|
|
case 110 /* TrueKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 106 /* SuperKeyword */:
|
|
case 108 /* ThisKeyword */:
|
|
case 194 /* ThisType */:
|
|
case 79 /* Identifier */:
|
|
break;
|
|
default:
|
|
return void 0;
|
|
}
|
|
let nodeForStartPos = node;
|
|
while (true) {
|
|
if (isRightSideOfPropertyAccess(nodeForStartPos) || isRightSideOfQualifiedName(nodeForStartPos)) {
|
|
nodeForStartPos = nodeForStartPos.parent;
|
|
} else if (isNameOfModuleDeclaration(nodeForStartPos)) {
|
|
if (nodeForStartPos.parent.parent.kind === 264 /* ModuleDeclaration */ && nodeForStartPos.parent.parent.body === nodeForStartPos.parent) {
|
|
nodeForStartPos = nodeForStartPos.parent.parent.name;
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd());
|
|
}
|
|
function getBreakpointStatementAtPosition(fileName, position) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
return ts_BreakpointResolver_exports.spanInSourceFileAtLocation(sourceFile, position);
|
|
}
|
|
function getNavigationBarItems2(fileName) {
|
|
return getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken);
|
|
}
|
|
function getNavigationTree2(fileName) {
|
|
return getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken);
|
|
}
|
|
function getSemanticClassifications3(fileName, span, format) {
|
|
synchronizeHostData();
|
|
const responseFormat = format || "original" /* Original */;
|
|
if (responseFormat === "2020" /* TwentyTwenty */) {
|
|
return ts_classifier_exports.v2020.getSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
|
|
} else {
|
|
return getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
|
|
}
|
|
}
|
|
function getEncodedSemanticClassifications3(fileName, span, format) {
|
|
synchronizeHostData();
|
|
const responseFormat = format || "original" /* Original */;
|
|
if (responseFormat === "original" /* Original */) {
|
|
return getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
|
|
} else {
|
|
return ts_classifier_exports.v2020.getEncodedSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
|
|
}
|
|
}
|
|
function getSyntacticClassifications2(fileName, span) {
|
|
return getSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span);
|
|
}
|
|
function getEncodedSyntacticClassifications2(fileName, span) {
|
|
return getEncodedSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span);
|
|
}
|
|
function getOutliningSpans(fileName) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
return ts_OutliningElementsCollector_exports.collectElements(sourceFile, cancellationToken);
|
|
}
|
|
const braceMatching = new Map(getEntries({
|
|
[18 /* OpenBraceToken */]: 19 /* CloseBraceToken */,
|
|
[20 /* OpenParenToken */]: 21 /* CloseParenToken */,
|
|
[22 /* OpenBracketToken */]: 23 /* CloseBracketToken */,
|
|
[31 /* GreaterThanToken */]: 29 /* LessThanToken */
|
|
}));
|
|
braceMatching.forEach((value, key) => braceMatching.set(value.toString(), Number(key)));
|
|
function getBraceMatchingAtPosition(fileName, position) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const token = getTouchingToken(sourceFile, position);
|
|
const matchKind = token.getStart(sourceFile) === position ? braceMatching.get(token.kind.toString()) : void 0;
|
|
const match = matchKind && findChildOfKind(token.parent, matchKind, sourceFile);
|
|
return match ? [createTextSpanFromNode(token, sourceFile), createTextSpanFromNode(match, sourceFile)].sort((a, b) => a.start - b.start) : emptyArray;
|
|
}
|
|
function getIndentationAtPosition(fileName, position, editorOptions) {
|
|
let start2 = timestamp();
|
|
const settings = toEditorSettings(editorOptions);
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
log("getIndentationAtPosition: getCurrentSourceFile: " + (timestamp() - start2));
|
|
start2 = timestamp();
|
|
const result = ts_formatting_exports.SmartIndenter.getIndentation(position, sourceFile, settings);
|
|
log("getIndentationAtPosition: computeIndentation : " + (timestamp() - start2));
|
|
return result;
|
|
}
|
|
function getFormattingEditsForRange(fileName, start2, end, options) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
return ts_formatting_exports.formatSelection(start2, end, sourceFile, ts_formatting_exports.getFormatContext(toEditorSettings(options), host));
|
|
}
|
|
function getFormattingEditsForDocument(fileName, options) {
|
|
return ts_formatting_exports.formatDocument(syntaxTreeCache.getCurrentSourceFile(fileName), ts_formatting_exports.getFormatContext(toEditorSettings(options), host));
|
|
}
|
|
function getFormattingEditsAfterKeystroke(fileName, position, key, options) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const formatContext = ts_formatting_exports.getFormatContext(toEditorSettings(options), host);
|
|
if (!isInComment(sourceFile, position)) {
|
|
switch (key) {
|
|
case "{":
|
|
return ts_formatting_exports.formatOnOpeningCurly(position, sourceFile, formatContext);
|
|
case "}":
|
|
return ts_formatting_exports.formatOnClosingCurly(position, sourceFile, formatContext);
|
|
case ";":
|
|
return ts_formatting_exports.formatOnSemicolon(position, sourceFile, formatContext);
|
|
case "\n":
|
|
return ts_formatting_exports.formatOnEnter(position, sourceFile, formatContext);
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
function getCodeFixesAtPosition(fileName, start2, end, errorCodes64, formatOptions, preferences = emptyOptions) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const span = createTextSpanFromBounds(start2, end);
|
|
const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
|
|
return flatMap(deduplicate(errorCodes64, equateValues, compareValues), (errorCode) => {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
return ts_codefix_exports.getFixes({ errorCode, sourceFile, span, program, host, cancellationToken, formatContext, preferences });
|
|
});
|
|
}
|
|
function getCombinedCodeFix(scope, fixId52, formatOptions, preferences = emptyOptions) {
|
|
synchronizeHostData();
|
|
Debug.assert(scope.type === "file");
|
|
const sourceFile = getValidSourceFile(scope.fileName);
|
|
const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
|
|
return ts_codefix_exports.getAllFixes({ fixId: fixId52, sourceFile, program, host, cancellationToken, formatContext, preferences });
|
|
}
|
|
function organizeImports2(args, formatOptions, preferences = emptyOptions) {
|
|
var _a3;
|
|
synchronizeHostData();
|
|
Debug.assert(args.type === "file");
|
|
const sourceFile = getValidSourceFile(args.fileName);
|
|
const formatContext = ts_formatting_exports.getFormatContext(formatOptions, host);
|
|
const mode = (_a3 = args.mode) != null ? _a3 : args.skipDestructiveCodeActions ? "SortAndCombine" /* SortAndCombine */ : "All" /* All */;
|
|
return ts_OrganizeImports_exports.organizeImports(sourceFile, formatContext, host, program, preferences, mode);
|
|
}
|
|
function getEditsForFileRename2(oldFilePath, newFilePath, formatOptions, preferences = emptyOptions) {
|
|
return getEditsForFileRename(getProgram(), oldFilePath, newFilePath, host, ts_formatting_exports.getFormatContext(formatOptions, host), preferences, sourceMapper);
|
|
}
|
|
function applyCodeActionCommand(fileName, actionOrFormatSettingsOrUndefined) {
|
|
const action = typeof fileName === "string" ? actionOrFormatSettingsOrUndefined : fileName;
|
|
return isArray(action) ? Promise.all(action.map((a) => applySingleCodeActionCommand(a))) : applySingleCodeActionCommand(action);
|
|
}
|
|
function applySingleCodeActionCommand(action) {
|
|
const getPath = (path) => toPath(path, currentDirectory, getCanonicalFileName);
|
|
Debug.assertEqual(action.type, "install package");
|
|
return host.installPackage ? host.installPackage({ fileName: getPath(action.file), packageName: action.packageName }) : Promise.reject("Host does not implement `installPackage`");
|
|
}
|
|
function getDocCommentTemplateAtPosition2(fileName, position, options) {
|
|
return ts_JsDoc_exports.getDocCommentTemplateAtPosition(getNewLineOrDefaultFromHost(host), syntaxTreeCache.getCurrentSourceFile(fileName), position, options);
|
|
}
|
|
function isValidBraceCompletionAtPosition(fileName, position, openingBrace) {
|
|
if (openingBrace === 60 /* lessThan */) {
|
|
return false;
|
|
}
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
if (isInString(sourceFile, position)) {
|
|
return false;
|
|
}
|
|
if (isInsideJsxElementOrAttribute(sourceFile, position)) {
|
|
return openingBrace === 123 /* openBrace */;
|
|
}
|
|
if (isInTemplateString(sourceFile, position)) {
|
|
return false;
|
|
}
|
|
switch (openingBrace) {
|
|
case 39 /* singleQuote */:
|
|
case 34 /* doubleQuote */:
|
|
case 96 /* backtick */:
|
|
return !isInComment(sourceFile, position);
|
|
}
|
|
return true;
|
|
}
|
|
function getJsxClosingTagAtPosition(fileName, position) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const token = findPrecedingToken(position, sourceFile);
|
|
if (!token)
|
|
return void 0;
|
|
const element = token.kind === 31 /* GreaterThanToken */ && isJsxOpeningElement(token.parent) ? token.parent.parent : isJsxText(token) && isJsxElement(token.parent) ? token.parent : void 0;
|
|
if (element && isUnclosedTag(element)) {
|
|
return { newText: `</${element.openingElement.tagName.getText(sourceFile)}>` };
|
|
}
|
|
const fragment = token.kind === 31 /* GreaterThanToken */ && isJsxOpeningFragment(token.parent) ? token.parent.parent : isJsxText(token) && isJsxFragment(token.parent) ? token.parent : void 0;
|
|
if (fragment && isUnclosedFragment(fragment)) {
|
|
return { newText: "</>" };
|
|
}
|
|
}
|
|
function getLinesForRange(sourceFile, textRange) {
|
|
return {
|
|
lineStarts: sourceFile.getLineStarts(),
|
|
firstLine: sourceFile.getLineAndCharacterOfPosition(textRange.pos).line,
|
|
lastLine: sourceFile.getLineAndCharacterOfPosition(textRange.end).line
|
|
};
|
|
}
|
|
function toggleLineComment(fileName, textRange, insertComment) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const textChanges2 = [];
|
|
const { lineStarts, firstLine, lastLine } = getLinesForRange(sourceFile, textRange);
|
|
let isCommenting = insertComment || false;
|
|
let leftMostPosition = Number.MAX_VALUE;
|
|
const lineTextStarts = /* @__PURE__ */ new Map();
|
|
const firstNonWhitespaceCharacterRegex = new RegExp(/\S/);
|
|
const isJsx = isInsideJsxElement(sourceFile, lineStarts[firstLine]);
|
|
const openComment = isJsx ? "{/*" : "//";
|
|
for (let i = firstLine; i <= lastLine; i++) {
|
|
const lineText = sourceFile.text.substring(lineStarts[i], sourceFile.getLineEndOfPosition(lineStarts[i]));
|
|
const regExec = firstNonWhitespaceCharacterRegex.exec(lineText);
|
|
if (regExec) {
|
|
leftMostPosition = Math.min(leftMostPosition, regExec.index);
|
|
lineTextStarts.set(i.toString(), regExec.index);
|
|
if (lineText.substr(regExec.index, openComment.length) !== openComment) {
|
|
isCommenting = insertComment === void 0 || insertComment;
|
|
}
|
|
}
|
|
}
|
|
for (let i = firstLine; i <= lastLine; i++) {
|
|
if (firstLine !== lastLine && lineStarts[i] === textRange.end) {
|
|
continue;
|
|
}
|
|
const lineTextStart = lineTextStarts.get(i.toString());
|
|
if (lineTextStart !== void 0) {
|
|
if (isJsx) {
|
|
textChanges2.push.apply(textChanges2, toggleMultilineComment(fileName, { pos: lineStarts[i] + leftMostPosition, end: sourceFile.getLineEndOfPosition(lineStarts[i]) }, isCommenting, isJsx));
|
|
} else if (isCommenting) {
|
|
textChanges2.push({
|
|
newText: openComment,
|
|
span: {
|
|
length: 0,
|
|
start: lineStarts[i] + leftMostPosition
|
|
}
|
|
});
|
|
} else if (sourceFile.text.substr(lineStarts[i] + lineTextStart, openComment.length) === openComment) {
|
|
textChanges2.push({
|
|
newText: "",
|
|
span: {
|
|
length: openComment.length,
|
|
start: lineStarts[i] + lineTextStart
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return textChanges2;
|
|
}
|
|
function toggleMultilineComment(fileName, textRange, insertComment, isInsideJsx) {
|
|
var _a3;
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const textChanges2 = [];
|
|
const { text } = sourceFile;
|
|
let hasComment = false;
|
|
let isCommenting = insertComment || false;
|
|
const positions = [];
|
|
let { pos } = textRange;
|
|
const isJsx = isInsideJsx !== void 0 ? isInsideJsx : isInsideJsxElement(sourceFile, pos);
|
|
const openMultiline = isJsx ? "{/*" : "/*";
|
|
const closeMultiline = isJsx ? "*/}" : "*/";
|
|
const openMultilineRegex = isJsx ? "\\{\\/\\*" : "\\/\\*";
|
|
const closeMultilineRegex = isJsx ? "\\*\\/\\}" : "\\*\\/";
|
|
while (pos <= textRange.end) {
|
|
const offset = text.substr(pos, openMultiline.length) === openMultiline ? openMultiline.length : 0;
|
|
const commentRange = isInComment(sourceFile, pos + offset);
|
|
if (commentRange) {
|
|
if (isJsx) {
|
|
commentRange.pos--;
|
|
commentRange.end++;
|
|
}
|
|
positions.push(commentRange.pos);
|
|
if (commentRange.kind === 3 /* MultiLineCommentTrivia */) {
|
|
positions.push(commentRange.end);
|
|
}
|
|
hasComment = true;
|
|
pos = commentRange.end + 1;
|
|
} else {
|
|
const newPos = text.substring(pos, textRange.end).search(`(${openMultilineRegex})|(${closeMultilineRegex})`);
|
|
isCommenting = insertComment !== void 0 ? insertComment : isCommenting || !isTextWhiteSpaceLike(text, pos, newPos === -1 ? textRange.end : pos + newPos);
|
|
pos = newPos === -1 ? textRange.end + 1 : pos + newPos + closeMultiline.length;
|
|
}
|
|
}
|
|
if (isCommenting || !hasComment) {
|
|
if (((_a3 = isInComment(sourceFile, textRange.pos)) == null ? void 0 : _a3.kind) !== 2 /* SingleLineCommentTrivia */) {
|
|
insertSorted(positions, textRange.pos, compareValues);
|
|
}
|
|
insertSorted(positions, textRange.end, compareValues);
|
|
const firstPos = positions[0];
|
|
if (text.substr(firstPos, openMultiline.length) !== openMultiline) {
|
|
textChanges2.push({
|
|
newText: openMultiline,
|
|
span: {
|
|
length: 0,
|
|
start: firstPos
|
|
}
|
|
});
|
|
}
|
|
for (let i = 1; i < positions.length - 1; i++) {
|
|
if (text.substr(positions[i] - closeMultiline.length, closeMultiline.length) !== closeMultiline) {
|
|
textChanges2.push({
|
|
newText: closeMultiline,
|
|
span: {
|
|
length: 0,
|
|
start: positions[i]
|
|
}
|
|
});
|
|
}
|
|
if (text.substr(positions[i], openMultiline.length) !== openMultiline) {
|
|
textChanges2.push({
|
|
newText: openMultiline,
|
|
span: {
|
|
length: 0,
|
|
start: positions[i]
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (textChanges2.length % 2 !== 0) {
|
|
textChanges2.push({
|
|
newText: closeMultiline,
|
|
span: {
|
|
length: 0,
|
|
start: positions[positions.length - 1]
|
|
}
|
|
});
|
|
}
|
|
} else {
|
|
for (const pos2 of positions) {
|
|
const from = pos2 - closeMultiline.length > 0 ? pos2 - closeMultiline.length : 0;
|
|
const offset = text.substr(from, closeMultiline.length) === closeMultiline ? closeMultiline.length : 0;
|
|
textChanges2.push({
|
|
newText: "",
|
|
span: {
|
|
length: openMultiline.length,
|
|
start: pos2 - offset
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return textChanges2;
|
|
}
|
|
function commentSelection(fileName, textRange) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const { firstLine, lastLine } = getLinesForRange(sourceFile, textRange);
|
|
return firstLine === lastLine && textRange.pos !== textRange.end ? toggleMultilineComment(fileName, textRange, true) : toggleLineComment(fileName, textRange, true);
|
|
}
|
|
function uncommentSelection(fileName, textRange) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const textChanges2 = [];
|
|
const { pos } = textRange;
|
|
let { end } = textRange;
|
|
if (pos === end) {
|
|
end += isInsideJsxElement(sourceFile, pos) ? 2 : 1;
|
|
}
|
|
for (let i = pos; i <= end; i++) {
|
|
const commentRange = isInComment(sourceFile, i);
|
|
if (commentRange) {
|
|
switch (commentRange.kind) {
|
|
case 2 /* SingleLineCommentTrivia */:
|
|
textChanges2.push.apply(textChanges2, toggleLineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, false));
|
|
break;
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
textChanges2.push.apply(textChanges2, toggleMultilineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, false));
|
|
}
|
|
i = commentRange.end + 1;
|
|
}
|
|
}
|
|
return textChanges2;
|
|
}
|
|
function isUnclosedTag({ openingElement, closingElement, parent: parent2 }) {
|
|
return !tagNamesAreEquivalent(openingElement.tagName, closingElement.tagName) || isJsxElement(parent2) && tagNamesAreEquivalent(openingElement.tagName, parent2.openingElement.tagName) && isUnclosedTag(parent2);
|
|
}
|
|
function isUnclosedFragment({ closingFragment, parent: parent2 }) {
|
|
return !!(closingFragment.flags & 131072 /* ThisNodeHasError */) || isJsxFragment(parent2) && isUnclosedFragment(parent2);
|
|
}
|
|
function getSpanOfEnclosingComment(fileName, position, onlyMultiLine) {
|
|
const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
|
|
const range = ts_formatting_exports.getRangeOfEnclosingComment(sourceFile, position);
|
|
return range && (!onlyMultiLine || range.kind === 3 /* MultiLineCommentTrivia */) ? createTextSpanFromRange(range) : void 0;
|
|
}
|
|
function getTodoComments(fileName, descriptors) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
cancellationToken.throwIfCancellationRequested();
|
|
const fileContents = sourceFile.text;
|
|
const result = [];
|
|
if (descriptors.length > 0 && !isNodeModulesFile(sourceFile.fileName)) {
|
|
const regExp = getTodoCommentsRegExp();
|
|
let matchArray;
|
|
while (matchArray = regExp.exec(fileContents)) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
const firstDescriptorCaptureIndex = 3;
|
|
Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex);
|
|
const preamble = matchArray[1];
|
|
const matchPosition = matchArray.index + preamble.length;
|
|
if (!isInComment(sourceFile, matchPosition)) {
|
|
continue;
|
|
}
|
|
let descriptor;
|
|
for (let i = 0; i < descriptors.length; i++) {
|
|
if (matchArray[i + firstDescriptorCaptureIndex]) {
|
|
descriptor = descriptors[i];
|
|
}
|
|
}
|
|
if (descriptor === void 0)
|
|
return Debug.fail();
|
|
if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) {
|
|
continue;
|
|
}
|
|
const message = matchArray[2];
|
|
result.push({ descriptor, message, position: matchPosition });
|
|
}
|
|
}
|
|
return result;
|
|
function escapeRegExp(str) {
|
|
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
|
|
}
|
|
function getTodoCommentsRegExp() {
|
|
const singleLineCommentStart = /(?:\/\/+\s*)/.source;
|
|
const multiLineCommentStart = /(?:\/\*+\s*)/.source;
|
|
const anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source;
|
|
const preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")";
|
|
const literals = "(?:" + map(descriptors, (d) => "(" + escapeRegExp(d.text) + ")").join("|") + ")";
|
|
const endOfLineOrEndOfComment = /(?:$|\*\/)/.source;
|
|
const messageRemainder = /(?:.*?)/.source;
|
|
const messagePortion = "(" + literals + messageRemainder + ")";
|
|
const regExpString = preamble + messagePortion + endOfLineOrEndOfComment;
|
|
return new RegExp(regExpString, "gim");
|
|
}
|
|
function isLetterOrDigit(char) {
|
|
return char >= 97 /* a */ && char <= 122 /* z */ || char >= 65 /* A */ && char <= 90 /* Z */ || char >= 48 /* _0 */ && char <= 57 /* _9 */;
|
|
}
|
|
function isNodeModulesFile(path) {
|
|
return stringContains(path, "/node_modules/");
|
|
}
|
|
}
|
|
function getRenameInfo2(fileName, position, preferences) {
|
|
synchronizeHostData();
|
|
return ts_Rename_exports.getRenameInfo(program, getValidSourceFile(fileName), position, preferences || {});
|
|
}
|
|
function getRefactorContext(file, positionOrRange, preferences, formatOptions, triggerReason, kind) {
|
|
const [startPosition, endPosition] = typeof positionOrRange === "number" ? [positionOrRange, void 0] : [positionOrRange.pos, positionOrRange.end];
|
|
return {
|
|
file,
|
|
startPosition,
|
|
endPosition,
|
|
program: getProgram(),
|
|
host,
|
|
formatContext: ts_formatting_exports.getFormatContext(formatOptions, host),
|
|
cancellationToken,
|
|
preferences,
|
|
triggerReason,
|
|
kind
|
|
};
|
|
}
|
|
function getInlayHintsContext(file, span, preferences) {
|
|
return {
|
|
file,
|
|
program: getProgram(),
|
|
host,
|
|
span,
|
|
preferences,
|
|
cancellationToken
|
|
};
|
|
}
|
|
function getSmartSelectionRange2(fileName, position) {
|
|
return ts_SmartSelectionRange_exports.getSmartSelectionRange(position, syntaxTreeCache.getCurrentSourceFile(fileName));
|
|
}
|
|
function getApplicableRefactors2(fileName, positionOrRange, preferences = emptyOptions, triggerReason, kind) {
|
|
synchronizeHostData();
|
|
const file = getValidSourceFile(fileName);
|
|
return ts_refactor_exports.getApplicableRefactors(getRefactorContext(file, positionOrRange, preferences, emptyOptions, triggerReason, kind));
|
|
}
|
|
function getEditsForRefactor2(fileName, formatOptions, positionOrRange, refactorName13, actionName2, preferences = emptyOptions) {
|
|
synchronizeHostData();
|
|
const file = getValidSourceFile(fileName);
|
|
return ts_refactor_exports.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName13, actionName2);
|
|
}
|
|
function toLineColumnOffset(fileName, position) {
|
|
if (position === 0) {
|
|
return { line: 0, character: 0 };
|
|
}
|
|
return sourceMapper.toLineColumnOffset(fileName, position);
|
|
}
|
|
function prepareCallHierarchy(fileName, position) {
|
|
synchronizeHostData();
|
|
const declarations = ts_CallHierarchy_exports.resolveCallHierarchyDeclaration(program, getTouchingPropertyName(getValidSourceFile(fileName), position));
|
|
return declarations && mapOneOrMany(declarations, (declaration) => ts_CallHierarchy_exports.createCallHierarchyItem(program, declaration));
|
|
}
|
|
function provideCallHierarchyIncomingCalls(fileName, position) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const declaration = firstOrOnly(ts_CallHierarchy_exports.resolveCallHierarchyDeclaration(program, position === 0 ? sourceFile : getTouchingPropertyName(sourceFile, position)));
|
|
return declaration ? ts_CallHierarchy_exports.getIncomingCalls(program, declaration, cancellationToken) : [];
|
|
}
|
|
function provideCallHierarchyOutgoingCalls(fileName, position) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
const declaration = firstOrOnly(ts_CallHierarchy_exports.resolveCallHierarchyDeclaration(program, position === 0 ? sourceFile : getTouchingPropertyName(sourceFile, position)));
|
|
return declaration ? ts_CallHierarchy_exports.getOutgoingCalls(program, declaration) : [];
|
|
}
|
|
function provideInlayHints2(fileName, span, preferences = emptyOptions) {
|
|
synchronizeHostData();
|
|
const sourceFile = getValidSourceFile(fileName);
|
|
return ts_InlayHints_exports.provideInlayHints(getInlayHintsContext(sourceFile, span, preferences));
|
|
}
|
|
const ls = {
|
|
dispose,
|
|
cleanupSemanticCache,
|
|
getSyntacticDiagnostics,
|
|
getSemanticDiagnostics,
|
|
getSuggestionDiagnostics,
|
|
getCompilerOptionsDiagnostics,
|
|
getSyntacticClassifications: getSyntacticClassifications2,
|
|
getSemanticClassifications: getSemanticClassifications3,
|
|
getEncodedSyntacticClassifications: getEncodedSyntacticClassifications2,
|
|
getEncodedSemanticClassifications: getEncodedSemanticClassifications3,
|
|
getCompletionsAtPosition: getCompletionsAtPosition2,
|
|
getCompletionEntryDetails: getCompletionEntryDetails2,
|
|
getCompletionEntrySymbol: getCompletionEntrySymbol2,
|
|
getSignatureHelpItems: getSignatureHelpItems2,
|
|
getQuickInfoAtPosition,
|
|
getDefinitionAtPosition: getDefinitionAtPosition2,
|
|
getDefinitionAndBoundSpan: getDefinitionAndBoundSpan2,
|
|
getImplementationAtPosition,
|
|
getTypeDefinitionAtPosition: getTypeDefinitionAtPosition2,
|
|
getReferencesAtPosition,
|
|
findReferences,
|
|
getFileReferences,
|
|
getOccurrencesAtPosition,
|
|
getDocumentHighlights,
|
|
getNameOrDottedNameSpan,
|
|
getBreakpointStatementAtPosition,
|
|
getNavigateToItems: getNavigateToItems2,
|
|
getRenameInfo: getRenameInfo2,
|
|
getSmartSelectionRange: getSmartSelectionRange2,
|
|
findRenameLocations,
|
|
getNavigationBarItems: getNavigationBarItems2,
|
|
getNavigationTree: getNavigationTree2,
|
|
getOutliningSpans,
|
|
getTodoComments,
|
|
getBraceMatchingAtPosition,
|
|
getIndentationAtPosition,
|
|
getFormattingEditsForRange,
|
|
getFormattingEditsForDocument,
|
|
getFormattingEditsAfterKeystroke,
|
|
getDocCommentTemplateAtPosition: getDocCommentTemplateAtPosition2,
|
|
isValidBraceCompletionAtPosition,
|
|
getJsxClosingTagAtPosition,
|
|
getSpanOfEnclosingComment,
|
|
getCodeFixesAtPosition,
|
|
getCombinedCodeFix,
|
|
applyCodeActionCommand,
|
|
organizeImports: organizeImports2,
|
|
getEditsForFileRename: getEditsForFileRename2,
|
|
getEmitOutput,
|
|
getNonBoundSourceFile,
|
|
getProgram,
|
|
getCurrentProgram: () => program,
|
|
getAutoImportProvider,
|
|
updateIsDefinitionOfReferencedSymbols,
|
|
getApplicableRefactors: getApplicableRefactors2,
|
|
getEditsForRefactor: getEditsForRefactor2,
|
|
toLineColumnOffset,
|
|
getSourceMapper: () => sourceMapper,
|
|
clearSourceMapperCache: () => sourceMapper.clearCache(),
|
|
prepareCallHierarchy,
|
|
provideCallHierarchyIncomingCalls,
|
|
provideCallHierarchyOutgoingCalls,
|
|
toggleLineComment,
|
|
toggleMultilineComment,
|
|
commentSelection,
|
|
uncommentSelection,
|
|
provideInlayHints: provideInlayHints2
|
|
};
|
|
switch (languageServiceMode) {
|
|
case 0 /* Semantic */:
|
|
break;
|
|
case 1 /* PartialSemantic */:
|
|
invalidOperationsInPartialSemanticMode.forEach(
|
|
(key) => ls[key] = () => {
|
|
throw new Error(`LanguageService Operation: ${key} not allowed in LanguageServiceMode.PartialSemantic`);
|
|
}
|
|
);
|
|
break;
|
|
case 2 /* Syntactic */:
|
|
invalidOperationsInSyntacticMode.forEach(
|
|
(key) => ls[key] = () => {
|
|
throw new Error(`LanguageService Operation: ${key} not allowed in LanguageServiceMode.Syntactic`);
|
|
}
|
|
);
|
|
break;
|
|
default:
|
|
Debug.assertNever(languageServiceMode);
|
|
}
|
|
return ls;
|
|
}
|
|
function getNameTable(sourceFile) {
|
|
if (!sourceFile.nameTable) {
|
|
initializeNameTable(sourceFile);
|
|
}
|
|
return sourceFile.nameTable;
|
|
}
|
|
function initializeNameTable(sourceFile) {
|
|
const nameTable = sourceFile.nameTable = /* @__PURE__ */ new Map();
|
|
sourceFile.forEachChild(function walk(node) {
|
|
if (isIdentifier(node) && !isTagName(node) && node.escapedText || isStringOrNumericLiteralLike(node) && literalIsName(node)) {
|
|
const text = getEscapedTextOfIdentifierOrLiteral(node);
|
|
nameTable.set(text, nameTable.get(text) === void 0 ? node.pos : -1);
|
|
} else if (isPrivateIdentifier(node)) {
|
|
const text = node.escapedText;
|
|
nameTable.set(text, nameTable.get(text) === void 0 ? node.pos : -1);
|
|
}
|
|
forEachChild(node, walk);
|
|
if (hasJSDocNodes(node)) {
|
|
for (const jsDoc of node.jsDoc) {
|
|
forEachChild(jsDoc, walk);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function literalIsName(node) {
|
|
return isDeclarationName(node) || node.parent.kind === 280 /* ExternalModuleReference */ || isArgumentOfElementAccessExpression(node) || isLiteralComputedPropertyDeclarationName(node);
|
|
}
|
|
function getContainingObjectLiteralElement(node) {
|
|
const element = getContainingObjectLiteralElementWorker(node);
|
|
return element && (isObjectLiteralExpression(element.parent) || isJsxAttributes(element.parent)) ? element : void 0;
|
|
}
|
|
function getContainingObjectLiteralElementWorker(node) {
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 8 /* NumericLiteral */:
|
|
if (node.parent.kind === 164 /* ComputedPropertyName */) {
|
|
return isObjectLiteralElement(node.parent.parent) ? node.parent.parent : void 0;
|
|
}
|
|
case 79 /* Identifier */:
|
|
return isObjectLiteralElement(node.parent) && (node.parent.parent.kind === 207 /* ObjectLiteralExpression */ || node.parent.parent.kind === 289 /* JsxAttributes */) && node.parent.name === node ? node.parent : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getSymbolAtLocationForQuickInfo(node, checker) {
|
|
const object = getContainingObjectLiteralElement(node);
|
|
if (object) {
|
|
const contextualType = checker.getContextualType(object.parent);
|
|
const properties = contextualType && getPropertySymbolsFromContextualType(object, checker, contextualType, false);
|
|
if (properties && properties.length === 1) {
|
|
return first(properties);
|
|
}
|
|
}
|
|
return checker.getSymbolAtLocation(node);
|
|
}
|
|
function getPropertySymbolsFromContextualType(node, checker, contextualType, unionSymbolOk) {
|
|
const name = getNameFromPropertyName(node.name);
|
|
if (!name)
|
|
return emptyArray;
|
|
if (!contextualType.isUnion()) {
|
|
const symbol = contextualType.getProperty(name);
|
|
return symbol ? [symbol] : emptyArray;
|
|
}
|
|
const discriminatedPropertySymbols = mapDefined(contextualType.types, (t) => (isObjectLiteralExpression(node.parent) || isJsxAttributes(node.parent)) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? void 0 : t.getProperty(name));
|
|
if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) {
|
|
const symbol = contextualType.getProperty(name);
|
|
if (symbol)
|
|
return [symbol];
|
|
}
|
|
if (discriminatedPropertySymbols.length === 0) {
|
|
return mapDefined(contextualType.types, (t) => t.getProperty(name));
|
|
}
|
|
return discriminatedPropertySymbols;
|
|
}
|
|
function isArgumentOfElementAccessExpression(node) {
|
|
return node && node.parent && node.parent.kind === 209 /* ElementAccessExpression */ && node.parent.argumentExpression === node;
|
|
}
|
|
function getDefaultLibFilePath(options) {
|
|
if (sys) {
|
|
return combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), getDefaultLibFileName(options));
|
|
}
|
|
throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. ");
|
|
}
|
|
setObjectAllocator(getServicesObjectAllocator());
|
|
|
|
// src/services/transform.ts
|
|
function transform(source, transformers, compilerOptions) {
|
|
const diagnostics = [];
|
|
compilerOptions = fixupCompilerOptions(compilerOptions, diagnostics);
|
|
const nodes = isArray(source) ? source : [source];
|
|
const result = transformNodes(void 0, void 0, factory, compilerOptions, nodes, transformers, true);
|
|
result.diagnostics = concatenate(result.diagnostics, diagnostics);
|
|
return result;
|
|
}
|
|
|
|
// src/services/shims.ts
|
|
var debugObjectHost = function() {
|
|
return this;
|
|
}();
|
|
function logInternalError(logger, err) {
|
|
if (logger) {
|
|
logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message);
|
|
}
|
|
}
|
|
var ScriptSnapshotShimAdapter = class {
|
|
constructor(scriptSnapshotShim) {
|
|
this.scriptSnapshotShim = scriptSnapshotShim;
|
|
}
|
|
getText(start2, end) {
|
|
return this.scriptSnapshotShim.getText(start2, end);
|
|
}
|
|
getLength() {
|
|
return this.scriptSnapshotShim.getLength();
|
|
}
|
|
getChangeRange(oldSnapshot) {
|
|
const oldSnapshotShim = oldSnapshot;
|
|
const encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim);
|
|
if (encoded === null) {
|
|
return null;
|
|
}
|
|
const decoded = JSON.parse(encoded);
|
|
return createTextChangeRange(
|
|
createTextSpan(decoded.span.start, decoded.span.length),
|
|
decoded.newLength
|
|
);
|
|
}
|
|
dispose() {
|
|
if ("dispose" in this.scriptSnapshotShim) {
|
|
this.scriptSnapshotShim.dispose();
|
|
}
|
|
}
|
|
};
|
|
var LanguageServiceShimHostAdapter = class {
|
|
constructor(shimHost) {
|
|
this.shimHost = shimHost;
|
|
this.loggingEnabled = false;
|
|
this.tracingEnabled = false;
|
|
if ("getModuleResolutionsForFile" in this.shimHost) {
|
|
this.resolveModuleNames = (moduleNames, containingFile) => {
|
|
const resolutionsInFile = JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile));
|
|
return map(moduleNames, (name) => {
|
|
const result = getProperty(resolutionsInFile, name);
|
|
return result ? { resolvedFileName: result, extension: extensionFromPath(result), isExternalLibraryImport: false } : void 0;
|
|
});
|
|
};
|
|
}
|
|
if ("directoryExists" in this.shimHost) {
|
|
this.directoryExists = (directoryName) => this.shimHost.directoryExists(directoryName);
|
|
}
|
|
if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) {
|
|
this.resolveTypeReferenceDirectives = (typeDirectiveNames, containingFile) => {
|
|
const typeDirectivesForFile = JSON.parse(this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile));
|
|
return map(typeDirectiveNames, (name) => getProperty(typeDirectivesForFile, isString(name) ? name : toFileNameLowerCase(name.fileName)));
|
|
};
|
|
}
|
|
}
|
|
log(s) {
|
|
if (this.loggingEnabled) {
|
|
this.shimHost.log(s);
|
|
}
|
|
}
|
|
trace(s) {
|
|
if (this.tracingEnabled) {
|
|
this.shimHost.trace(s);
|
|
}
|
|
}
|
|
error(s) {
|
|
this.shimHost.error(s);
|
|
}
|
|
getProjectVersion() {
|
|
if (!this.shimHost.getProjectVersion) {
|
|
return void 0;
|
|
}
|
|
return this.shimHost.getProjectVersion();
|
|
}
|
|
getTypeRootsVersion() {
|
|
if (!this.shimHost.getTypeRootsVersion) {
|
|
return 0;
|
|
}
|
|
return this.shimHost.getTypeRootsVersion();
|
|
}
|
|
useCaseSensitiveFileNames() {
|
|
return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;
|
|
}
|
|
getCompilationSettings() {
|
|
const settingsJson = this.shimHost.getCompilationSettings();
|
|
if (settingsJson === null || settingsJson === "") {
|
|
throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings");
|
|
}
|
|
const compilerOptions = JSON.parse(settingsJson);
|
|
compilerOptions.allowNonTsExtensions = true;
|
|
return compilerOptions;
|
|
}
|
|
getScriptFileNames() {
|
|
const encoded = this.shimHost.getScriptFileNames();
|
|
return JSON.parse(encoded);
|
|
}
|
|
getScriptSnapshot(fileName) {
|
|
const scriptSnapshot = this.shimHost.getScriptSnapshot(fileName);
|
|
return scriptSnapshot && new ScriptSnapshotShimAdapter(scriptSnapshot);
|
|
}
|
|
getScriptKind(fileName) {
|
|
if ("getScriptKind" in this.shimHost) {
|
|
return this.shimHost.getScriptKind(fileName);
|
|
} else {
|
|
return 0 /* Unknown */;
|
|
}
|
|
}
|
|
getScriptVersion(fileName) {
|
|
return this.shimHost.getScriptVersion(fileName);
|
|
}
|
|
getLocalizedDiagnosticMessages() {
|
|
const diagnosticMessagesJson = this.shimHost.getLocalizedDiagnosticMessages();
|
|
if (diagnosticMessagesJson === null || diagnosticMessagesJson === "") {
|
|
return null;
|
|
}
|
|
try {
|
|
return JSON.parse(diagnosticMessagesJson);
|
|
} catch (e) {
|
|
this.log(e.description || "diagnosticMessages.generated.json has invalid JSON format");
|
|
return null;
|
|
}
|
|
}
|
|
getCancellationToken() {
|
|
const hostCancellationToken = this.shimHost.getCancellationToken();
|
|
return new ThrottledCancellationToken(hostCancellationToken);
|
|
}
|
|
getCurrentDirectory() {
|
|
return this.shimHost.getCurrentDirectory();
|
|
}
|
|
getDirectories(path) {
|
|
return JSON.parse(this.shimHost.getDirectories(path));
|
|
}
|
|
getDefaultLibFileName(options) {
|
|
return this.shimHost.getDefaultLibFileName(JSON.stringify(options));
|
|
}
|
|
readDirectory(path, extensions, exclude, include, depth) {
|
|
const pattern = getFileMatcherPatterns(
|
|
path,
|
|
exclude,
|
|
include,
|
|
this.shimHost.useCaseSensitiveFileNames(),
|
|
this.shimHost.getCurrentDirectory()
|
|
);
|
|
return JSON.parse(this.shimHost.readDirectory(
|
|
path,
|
|
JSON.stringify(extensions),
|
|
JSON.stringify(pattern.basePaths),
|
|
pattern.excludePattern,
|
|
pattern.includeFilePattern,
|
|
pattern.includeDirectoryPattern,
|
|
depth
|
|
));
|
|
}
|
|
readFile(path, encoding) {
|
|
return this.shimHost.readFile(path, encoding);
|
|
}
|
|
fileExists(path) {
|
|
return this.shimHost.fileExists(path);
|
|
}
|
|
};
|
|
var CoreServicesShimHostAdapter = class {
|
|
constructor(shimHost) {
|
|
this.shimHost = shimHost;
|
|
this.useCaseSensitiveFileNames = this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false;
|
|
if ("directoryExists" in this.shimHost) {
|
|
this.directoryExists = (directoryName) => this.shimHost.directoryExists(directoryName);
|
|
} else {
|
|
this.directoryExists = void 0;
|
|
}
|
|
if ("realpath" in this.shimHost) {
|
|
this.realpath = (path) => this.shimHost.realpath(path);
|
|
} else {
|
|
this.realpath = void 0;
|
|
}
|
|
}
|
|
readDirectory(rootDir, extensions, exclude, include, depth) {
|
|
const pattern = getFileMatcherPatterns(
|
|
rootDir,
|
|
exclude,
|
|
include,
|
|
this.shimHost.useCaseSensitiveFileNames(),
|
|
this.shimHost.getCurrentDirectory()
|
|
);
|
|
return JSON.parse(this.shimHost.readDirectory(
|
|
rootDir,
|
|
JSON.stringify(extensions),
|
|
JSON.stringify(pattern.basePaths),
|
|
pattern.excludePattern,
|
|
pattern.includeFilePattern,
|
|
pattern.includeDirectoryPattern,
|
|
depth
|
|
));
|
|
}
|
|
fileExists(fileName) {
|
|
return this.shimHost.fileExists(fileName);
|
|
}
|
|
readFile(fileName) {
|
|
return this.shimHost.readFile(fileName);
|
|
}
|
|
getDirectories(path) {
|
|
return JSON.parse(this.shimHost.getDirectories(path));
|
|
}
|
|
};
|
|
function simpleForwardCall(logger, actionDescription2, action, logPerformance) {
|
|
let start2;
|
|
if (logPerformance) {
|
|
logger.log(actionDescription2);
|
|
start2 = timestamp();
|
|
}
|
|
const result = action();
|
|
if (logPerformance) {
|
|
const end = timestamp();
|
|
logger.log(`${actionDescription2} completed in ${end - start2} msec`);
|
|
if (isString(result)) {
|
|
let str = result;
|
|
if (str.length > 128) {
|
|
str = str.substring(0, 128) + "...";
|
|
}
|
|
logger.log(` result.length=${str.length}, result='${JSON.stringify(str)}'`);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function forwardJSONCall(logger, actionDescription2, action, logPerformance) {
|
|
return forwardCall(logger, actionDescription2, true, action, logPerformance);
|
|
}
|
|
function forwardCall(logger, actionDescription2, returnJson, action, logPerformance) {
|
|
try {
|
|
const result = simpleForwardCall(logger, actionDescription2, action, logPerformance);
|
|
return returnJson ? JSON.stringify({ result }) : result;
|
|
} catch (err) {
|
|
if (err instanceof OperationCanceledException) {
|
|
return JSON.stringify({ canceled: true });
|
|
}
|
|
logInternalError(logger, err);
|
|
err.description = actionDescription2;
|
|
return JSON.stringify({ error: err });
|
|
}
|
|
}
|
|
var ShimBase = class {
|
|
constructor(factory2) {
|
|
this.factory = factory2;
|
|
factory2.registerShim(this);
|
|
}
|
|
dispose(_dummy) {
|
|
this.factory.unregisterShim(this);
|
|
}
|
|
};
|
|
function realizeDiagnostics(diagnostics, newLine) {
|
|
return diagnostics.map((d) => realizeDiagnostic(d, newLine));
|
|
}
|
|
function realizeDiagnostic(diagnostic, newLine) {
|
|
return {
|
|
message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
|
|
start: diagnostic.start,
|
|
length: diagnostic.length,
|
|
category: diagnosticCategoryName(diagnostic),
|
|
code: diagnostic.code,
|
|
reportsUnnecessary: diagnostic.reportsUnnecessary,
|
|
reportsDeprecated: diagnostic.reportsDeprecated
|
|
};
|
|
}
|
|
var LanguageServiceShimObject = class extends ShimBase {
|
|
constructor(factory2, host, languageService) {
|
|
super(factory2);
|
|
this.host = host;
|
|
this.languageService = languageService;
|
|
this.logPerformance = false;
|
|
this.logger = this.host;
|
|
}
|
|
forwardJSONCall(actionDescription2, action) {
|
|
return forwardJSONCall(this.logger, actionDescription2, action, this.logPerformance);
|
|
}
|
|
dispose(dummy) {
|
|
this.logger.log("dispose()");
|
|
this.languageService.dispose();
|
|
this.languageService = null;
|
|
if (debugObjectHost && debugObjectHost.CollectGarbage) {
|
|
debugObjectHost.CollectGarbage();
|
|
this.logger.log("CollectGarbage()");
|
|
}
|
|
this.logger = null;
|
|
super.dispose(dummy);
|
|
}
|
|
refresh(throwOnError) {
|
|
this.forwardJSONCall(
|
|
`refresh(${throwOnError})`,
|
|
() => null
|
|
);
|
|
}
|
|
cleanupSemanticCache() {
|
|
this.forwardJSONCall(
|
|
"cleanupSemanticCache()",
|
|
() => {
|
|
this.languageService.cleanupSemanticCache();
|
|
return null;
|
|
}
|
|
);
|
|
}
|
|
realizeDiagnostics(diagnostics) {
|
|
const newLine = getNewLineOrDefaultFromHost(this.host);
|
|
return realizeDiagnostics(diagnostics, newLine);
|
|
}
|
|
getSyntacticClassifications(fileName, start2, length2) {
|
|
return this.forwardJSONCall(
|
|
`getSyntacticClassifications('${fileName}', ${start2}, ${length2})`,
|
|
() => this.languageService.getSyntacticClassifications(fileName, createTextSpan(start2, length2))
|
|
);
|
|
}
|
|
getSemanticClassifications(fileName, start2, length2) {
|
|
return this.forwardJSONCall(
|
|
`getSemanticClassifications('${fileName}', ${start2}, ${length2})`,
|
|
() => this.languageService.getSemanticClassifications(fileName, createTextSpan(start2, length2))
|
|
);
|
|
}
|
|
getEncodedSyntacticClassifications(fileName, start2, length2) {
|
|
return this.forwardJSONCall(
|
|
`getEncodedSyntacticClassifications('${fileName}', ${start2}, ${length2})`,
|
|
() => convertClassifications(this.languageService.getEncodedSyntacticClassifications(fileName, createTextSpan(start2, length2)))
|
|
);
|
|
}
|
|
getEncodedSemanticClassifications(fileName, start2, length2) {
|
|
return this.forwardJSONCall(
|
|
`getEncodedSemanticClassifications('${fileName}', ${start2}, ${length2})`,
|
|
() => convertClassifications(this.languageService.getEncodedSemanticClassifications(fileName, createTextSpan(start2, length2)))
|
|
);
|
|
}
|
|
getSyntacticDiagnostics(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getSyntacticDiagnostics('${fileName}')`,
|
|
() => {
|
|
const diagnostics = this.languageService.getSyntacticDiagnostics(fileName);
|
|
return this.realizeDiagnostics(diagnostics);
|
|
}
|
|
);
|
|
}
|
|
getSemanticDiagnostics(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getSemanticDiagnostics('${fileName}')`,
|
|
() => {
|
|
const diagnostics = this.languageService.getSemanticDiagnostics(fileName);
|
|
return this.realizeDiagnostics(diagnostics);
|
|
}
|
|
);
|
|
}
|
|
getSuggestionDiagnostics(fileName) {
|
|
return this.forwardJSONCall(`getSuggestionDiagnostics('${fileName}')`, () => this.realizeDiagnostics(this.languageService.getSuggestionDiagnostics(fileName)));
|
|
}
|
|
getCompilerOptionsDiagnostics() {
|
|
return this.forwardJSONCall(
|
|
"getCompilerOptionsDiagnostics()",
|
|
() => {
|
|
const diagnostics = this.languageService.getCompilerOptionsDiagnostics();
|
|
return this.realizeDiagnostics(diagnostics);
|
|
}
|
|
);
|
|
}
|
|
getQuickInfoAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getQuickInfoAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getQuickInfoAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getNameOrDottedNameSpan(fileName, startPos, endPos) {
|
|
return this.forwardJSONCall(
|
|
`getNameOrDottedNameSpan('${fileName}', ${startPos}, ${endPos})`,
|
|
() => this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos)
|
|
);
|
|
}
|
|
getBreakpointStatementAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getBreakpointStatementAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getBreakpointStatementAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getSignatureHelpItems(fileName, position, options) {
|
|
return this.forwardJSONCall(
|
|
`getSignatureHelpItems('${fileName}', ${position})`,
|
|
() => this.languageService.getSignatureHelpItems(fileName, position, options)
|
|
);
|
|
}
|
|
getDefinitionAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getDefinitionAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getDefinitionAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getDefinitionAndBoundSpan(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getDefinitionAndBoundSpan('${fileName}', ${position})`,
|
|
() => this.languageService.getDefinitionAndBoundSpan(fileName, position)
|
|
);
|
|
}
|
|
getTypeDefinitionAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getTypeDefinitionAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getTypeDefinitionAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getImplementationAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getImplementationAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getImplementationAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getRenameInfo(fileName, position, preferences) {
|
|
return this.forwardJSONCall(
|
|
`getRenameInfo('${fileName}', ${position})`,
|
|
() => this.languageService.getRenameInfo(fileName, position, preferences)
|
|
);
|
|
}
|
|
getSmartSelectionRange(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getSmartSelectionRange('${fileName}', ${position})`,
|
|
() => this.languageService.getSmartSelectionRange(fileName, position)
|
|
);
|
|
}
|
|
findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) {
|
|
return this.forwardJSONCall(
|
|
`findRenameLocations('${fileName}', ${position}, ${findInStrings}, ${findInComments}, ${providePrefixAndSuffixTextForRename})`,
|
|
() => this.languageService.findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename)
|
|
);
|
|
}
|
|
getBraceMatchingAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getBraceMatchingAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getBraceMatchingAtPosition(fileName, position)
|
|
);
|
|
}
|
|
isValidBraceCompletionAtPosition(fileName, position, openingBrace) {
|
|
return this.forwardJSONCall(
|
|
`isValidBraceCompletionAtPosition('${fileName}', ${position}, ${openingBrace})`,
|
|
() => this.languageService.isValidBraceCompletionAtPosition(fileName, position, openingBrace)
|
|
);
|
|
}
|
|
getSpanOfEnclosingComment(fileName, position, onlyMultiLine) {
|
|
return this.forwardJSONCall(
|
|
`getSpanOfEnclosingComment('${fileName}', ${position})`,
|
|
() => this.languageService.getSpanOfEnclosingComment(fileName, position, onlyMultiLine)
|
|
);
|
|
}
|
|
getIndentationAtPosition(fileName, position, options) {
|
|
return this.forwardJSONCall(
|
|
`getIndentationAtPosition('${fileName}', ${position})`,
|
|
() => {
|
|
const localOptions = JSON.parse(options);
|
|
return this.languageService.getIndentationAtPosition(fileName, position, localOptions);
|
|
}
|
|
);
|
|
}
|
|
getReferencesAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getReferencesAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getReferencesAtPosition(fileName, position)
|
|
);
|
|
}
|
|
findReferences(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`findReferences('${fileName}', ${position})`,
|
|
() => this.languageService.findReferences(fileName, position)
|
|
);
|
|
}
|
|
getFileReferences(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getFileReferences('${fileName})`,
|
|
() => this.languageService.getFileReferences(fileName)
|
|
);
|
|
}
|
|
getOccurrencesAtPosition(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`getOccurrencesAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getOccurrencesAtPosition(fileName, position)
|
|
);
|
|
}
|
|
getDocumentHighlights(fileName, position, filesToSearch) {
|
|
return this.forwardJSONCall(
|
|
`getDocumentHighlights('${fileName}', ${position})`,
|
|
() => {
|
|
const results = this.languageService.getDocumentHighlights(fileName, position, JSON.parse(filesToSearch));
|
|
const normalizedName = toFileNameLowerCase(normalizeSlashes(fileName));
|
|
return filter(results, (r) => toFileNameLowerCase(normalizeSlashes(r.fileName)) === normalizedName);
|
|
}
|
|
);
|
|
}
|
|
getCompletionsAtPosition(fileName, position, preferences, formattingSettings) {
|
|
return this.forwardJSONCall(
|
|
`getCompletionsAtPosition('${fileName}', ${position}, ${preferences}, ${formattingSettings})`,
|
|
() => this.languageService.getCompletionsAtPosition(fileName, position, preferences, formattingSettings)
|
|
);
|
|
}
|
|
getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data) {
|
|
return this.forwardJSONCall(
|
|
`getCompletionEntryDetails('${fileName}', ${position}, '${entryName}')`,
|
|
() => {
|
|
const localOptions = formatOptions === void 0 ? void 0 : JSON.parse(formatOptions);
|
|
return this.languageService.getCompletionEntryDetails(fileName, position, entryName, localOptions, source, preferences, data);
|
|
}
|
|
);
|
|
}
|
|
getFormattingEditsForRange(fileName, start2, end, options) {
|
|
return this.forwardJSONCall(
|
|
`getFormattingEditsForRange('${fileName}', ${start2}, ${end})`,
|
|
() => {
|
|
const localOptions = JSON.parse(options);
|
|
return this.languageService.getFormattingEditsForRange(fileName, start2, end, localOptions);
|
|
}
|
|
);
|
|
}
|
|
getFormattingEditsForDocument(fileName, options) {
|
|
return this.forwardJSONCall(
|
|
`getFormattingEditsForDocument('${fileName}')`,
|
|
() => {
|
|
const localOptions = JSON.parse(options);
|
|
return this.languageService.getFormattingEditsForDocument(fileName, localOptions);
|
|
}
|
|
);
|
|
}
|
|
getFormattingEditsAfterKeystroke(fileName, position, key, options) {
|
|
return this.forwardJSONCall(
|
|
`getFormattingEditsAfterKeystroke('${fileName}', ${position}, '${key}')`,
|
|
() => {
|
|
const localOptions = JSON.parse(options);
|
|
return this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions);
|
|
}
|
|
);
|
|
}
|
|
getDocCommentTemplateAtPosition(fileName, position, options) {
|
|
return this.forwardJSONCall(
|
|
`getDocCommentTemplateAtPosition('${fileName}', ${position})`,
|
|
() => this.languageService.getDocCommentTemplateAtPosition(fileName, position, options)
|
|
);
|
|
}
|
|
getNavigateToItems(searchValue, maxResultCount, fileName) {
|
|
return this.forwardJSONCall(
|
|
`getNavigateToItems('${searchValue}', ${maxResultCount}, ${fileName})`,
|
|
() => this.languageService.getNavigateToItems(searchValue, maxResultCount, fileName)
|
|
);
|
|
}
|
|
getNavigationBarItems(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getNavigationBarItems('${fileName}')`,
|
|
() => this.languageService.getNavigationBarItems(fileName)
|
|
);
|
|
}
|
|
getNavigationTree(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getNavigationTree('${fileName}')`,
|
|
() => this.languageService.getNavigationTree(fileName)
|
|
);
|
|
}
|
|
getOutliningSpans(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getOutliningSpans('${fileName}')`,
|
|
() => this.languageService.getOutliningSpans(fileName)
|
|
);
|
|
}
|
|
getTodoComments(fileName, descriptors) {
|
|
return this.forwardJSONCall(
|
|
`getTodoComments('${fileName}')`,
|
|
() => this.languageService.getTodoComments(fileName, JSON.parse(descriptors))
|
|
);
|
|
}
|
|
prepareCallHierarchy(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`prepareCallHierarchy('${fileName}', ${position})`,
|
|
() => this.languageService.prepareCallHierarchy(fileName, position)
|
|
);
|
|
}
|
|
provideCallHierarchyIncomingCalls(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`provideCallHierarchyIncomingCalls('${fileName}', ${position})`,
|
|
() => this.languageService.provideCallHierarchyIncomingCalls(fileName, position)
|
|
);
|
|
}
|
|
provideCallHierarchyOutgoingCalls(fileName, position) {
|
|
return this.forwardJSONCall(
|
|
`provideCallHierarchyOutgoingCalls('${fileName}', ${position})`,
|
|
() => this.languageService.provideCallHierarchyOutgoingCalls(fileName, position)
|
|
);
|
|
}
|
|
provideInlayHints(fileName, span, preference) {
|
|
return this.forwardJSONCall(
|
|
`provideInlayHints('${fileName}', '${JSON.stringify(span)}', ${JSON.stringify(preference)})`,
|
|
() => this.languageService.provideInlayHints(fileName, span, preference)
|
|
);
|
|
}
|
|
getEmitOutput(fileName) {
|
|
return this.forwardJSONCall(
|
|
`getEmitOutput('${fileName}')`,
|
|
() => {
|
|
const { diagnostics, ...rest } = this.languageService.getEmitOutput(fileName);
|
|
return { ...rest, diagnostics: this.realizeDiagnostics(diagnostics) };
|
|
}
|
|
);
|
|
}
|
|
getEmitOutputObject(fileName) {
|
|
return forwardCall(
|
|
this.logger,
|
|
`getEmitOutput('${fileName}')`,
|
|
false,
|
|
() => this.languageService.getEmitOutput(fileName),
|
|
this.logPerformance
|
|
);
|
|
}
|
|
toggleLineComment(fileName, textRange) {
|
|
return this.forwardJSONCall(
|
|
`toggleLineComment('${fileName}', '${JSON.stringify(textRange)}')`,
|
|
() => this.languageService.toggleLineComment(fileName, textRange)
|
|
);
|
|
}
|
|
toggleMultilineComment(fileName, textRange) {
|
|
return this.forwardJSONCall(
|
|
`toggleMultilineComment('${fileName}', '${JSON.stringify(textRange)}')`,
|
|
() => this.languageService.toggleMultilineComment(fileName, textRange)
|
|
);
|
|
}
|
|
commentSelection(fileName, textRange) {
|
|
return this.forwardJSONCall(
|
|
`commentSelection('${fileName}', '${JSON.stringify(textRange)}')`,
|
|
() => this.languageService.commentSelection(fileName, textRange)
|
|
);
|
|
}
|
|
uncommentSelection(fileName, textRange) {
|
|
return this.forwardJSONCall(
|
|
`uncommentSelection('${fileName}', '${JSON.stringify(textRange)}')`,
|
|
() => this.languageService.uncommentSelection(fileName, textRange)
|
|
);
|
|
}
|
|
};
|
|
function convertClassifications(classifications) {
|
|
return { spans: classifications.spans.join(","), endOfLineState: classifications.endOfLineState };
|
|
}
|
|
var ClassifierShimObject = class extends ShimBase {
|
|
constructor(factory2, logger) {
|
|
super(factory2);
|
|
this.logger = logger;
|
|
this.logPerformance = false;
|
|
this.classifier = createClassifier();
|
|
}
|
|
getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent = false) {
|
|
return forwardJSONCall(
|
|
this.logger,
|
|
"getEncodedLexicalClassifications",
|
|
() => convertClassifications(this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)),
|
|
this.logPerformance
|
|
);
|
|
}
|
|
getClassificationsForLine(text, lexState, classifyKeywordsInGenerics = false) {
|
|
const classification = this.classifier.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics);
|
|
let result = "";
|
|
for (const item of classification.entries) {
|
|
result += item.length + "\n";
|
|
result += item.classification + "\n";
|
|
}
|
|
result += classification.finalLexState;
|
|
return result;
|
|
}
|
|
};
|
|
var CoreServicesShimObject = class extends ShimBase {
|
|
constructor(factory2, logger, host) {
|
|
super(factory2);
|
|
this.logger = logger;
|
|
this.host = host;
|
|
this.logPerformance = false;
|
|
}
|
|
forwardJSONCall(actionDescription2, action) {
|
|
return forwardJSONCall(this.logger, actionDescription2, action, this.logPerformance);
|
|
}
|
|
resolveModuleName(fileName, moduleName, compilerOptionsJson) {
|
|
return this.forwardJSONCall(`resolveModuleName('${fileName}')`, () => {
|
|
const compilerOptions = JSON.parse(compilerOptionsJson);
|
|
const result = resolveModuleName(moduleName, normalizeSlashes(fileName), compilerOptions, this.host);
|
|
let resolvedFileName = result.resolvedModule ? result.resolvedModule.resolvedFileName : void 0;
|
|
if (result.resolvedModule && result.resolvedModule.extension !== ".ts" /* Ts */ && result.resolvedModule.extension !== ".tsx" /* Tsx */ && result.resolvedModule.extension !== ".d.ts" /* Dts */) {
|
|
resolvedFileName = void 0;
|
|
}
|
|
return {
|
|
resolvedFileName,
|
|
failedLookupLocations: result.failedLookupLocations,
|
|
affectingLocations: result.affectingLocations
|
|
};
|
|
});
|
|
}
|
|
resolveTypeReferenceDirective(fileName, typeReferenceDirective, compilerOptionsJson) {
|
|
return this.forwardJSONCall(`resolveTypeReferenceDirective(${fileName})`, () => {
|
|
const compilerOptions = JSON.parse(compilerOptionsJson);
|
|
const result = resolveTypeReferenceDirective(typeReferenceDirective, normalizeSlashes(fileName), compilerOptions, this.host);
|
|
return {
|
|
resolvedFileName: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.resolvedFileName : void 0,
|
|
primary: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.primary : true,
|
|
failedLookupLocations: result.failedLookupLocations
|
|
};
|
|
});
|
|
}
|
|
getPreProcessedFileInfo(fileName, sourceTextSnapshot) {
|
|
return this.forwardJSONCall(
|
|
`getPreProcessedFileInfo('${fileName}')`,
|
|
() => {
|
|
const result = preProcessFile(getSnapshotText(sourceTextSnapshot), true, true);
|
|
return {
|
|
referencedFiles: this.convertFileReferences(result.referencedFiles),
|
|
importedFiles: this.convertFileReferences(result.importedFiles),
|
|
ambientExternalModules: result.ambientExternalModules,
|
|
isLibFile: result.isLibFile,
|
|
typeReferenceDirectives: this.convertFileReferences(result.typeReferenceDirectives),
|
|
libReferenceDirectives: this.convertFileReferences(result.libReferenceDirectives)
|
|
};
|
|
}
|
|
);
|
|
}
|
|
getAutomaticTypeDirectiveNames(compilerOptionsJson) {
|
|
return this.forwardJSONCall(
|
|
`getAutomaticTypeDirectiveNames('${compilerOptionsJson}')`,
|
|
() => {
|
|
const compilerOptions = JSON.parse(compilerOptionsJson);
|
|
return getAutomaticTypeDirectiveNames(compilerOptions, this.host);
|
|
}
|
|
);
|
|
}
|
|
convertFileReferences(refs) {
|
|
if (!refs) {
|
|
return void 0;
|
|
}
|
|
const result = [];
|
|
for (const ref of refs) {
|
|
result.push({
|
|
path: normalizeSlashes(ref.fileName),
|
|
position: ref.pos,
|
|
length: ref.end - ref.pos
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
getTSConfigFileInfo(fileName, sourceTextSnapshot) {
|
|
return this.forwardJSONCall(
|
|
`getTSConfigFileInfo('${fileName}')`,
|
|
() => {
|
|
const result = parseJsonText(fileName, getSnapshotText(sourceTextSnapshot));
|
|
const normalizedFileName = normalizeSlashes(fileName);
|
|
const configFile = parseJsonSourceFileConfigFileContent(result, this.host, getDirectoryPath(normalizedFileName), {}, normalizedFileName);
|
|
return {
|
|
options: configFile.options,
|
|
typeAcquisition: configFile.typeAcquisition,
|
|
files: configFile.fileNames,
|
|
raw: configFile.raw,
|
|
errors: realizeDiagnostics([...result.parseDiagnostics, ...configFile.errors], "\r\n")
|
|
};
|
|
}
|
|
);
|
|
}
|
|
getDefaultCompilationSettings() {
|
|
return this.forwardJSONCall(
|
|
"getDefaultCompilationSettings()",
|
|
() => getDefaultCompilerOptions2()
|
|
);
|
|
}
|
|
discoverTypings(discoverTypingsJson) {
|
|
const getCanonicalFileName = createGetCanonicalFileName(false);
|
|
return this.forwardJSONCall("discoverTypings()", () => {
|
|
const info = JSON.parse(discoverTypingsJson);
|
|
if (this.safeList === void 0) {
|
|
this.safeList = ts_JsTyping_exports.loadSafeList(this.host, toPath(info.safeListPath, info.safeListPath, getCanonicalFileName));
|
|
}
|
|
return ts_JsTyping_exports.discoverTypings(
|
|
this.host,
|
|
(msg) => this.logger.log(msg),
|
|
info.fileNames,
|
|
toPath(info.projectRootPath, info.projectRootPath, getCanonicalFileName),
|
|
this.safeList,
|
|
info.packageNameToTypingLocation,
|
|
info.typeAcquisition,
|
|
info.unresolvedImports,
|
|
info.typesRegistry,
|
|
emptyOptions
|
|
);
|
|
});
|
|
}
|
|
};
|
|
var TypeScriptServicesFactory = class {
|
|
constructor() {
|
|
this._shims = [];
|
|
}
|
|
getServicesVersion() {
|
|
return servicesVersion;
|
|
}
|
|
createLanguageServiceShim(host) {
|
|
try {
|
|
if (this.documentRegistry === void 0) {
|
|
this.documentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory());
|
|
}
|
|
const hostAdapter = new LanguageServiceShimHostAdapter(host);
|
|
const languageService = createLanguageService(hostAdapter, this.documentRegistry, false);
|
|
return new LanguageServiceShimObject(this, host, languageService);
|
|
} catch (err) {
|
|
logInternalError(host, err);
|
|
throw err;
|
|
}
|
|
}
|
|
createClassifierShim(logger) {
|
|
try {
|
|
return new ClassifierShimObject(this, logger);
|
|
} catch (err) {
|
|
logInternalError(logger, err);
|
|
throw err;
|
|
}
|
|
}
|
|
createCoreServicesShim(host) {
|
|
try {
|
|
const adapter = new CoreServicesShimHostAdapter(host);
|
|
return new CoreServicesShimObject(this, host, adapter);
|
|
} catch (err) {
|
|
logInternalError(host, err);
|
|
throw err;
|
|
}
|
|
}
|
|
close() {
|
|
clear(this._shims);
|
|
this.documentRegistry = void 0;
|
|
}
|
|
registerShim(shim) {
|
|
this._shims.push(shim);
|
|
}
|
|
unregisterShim(shim) {
|
|
for (let i = 0; i < this._shims.length; i++) {
|
|
if (this._shims[i] === shim) {
|
|
delete this._shims[i];
|
|
return;
|
|
}
|
|
}
|
|
throw new Error("Invalid operation");
|
|
}
|
|
};
|
|
|
|
// src/services/_namespaces/ts.BreakpointResolver.ts
|
|
var ts_BreakpointResolver_exports = {};
|
|
__export(ts_BreakpointResolver_exports, {
|
|
spanInSourceFileAtLocation: () => spanInSourceFileAtLocation
|
|
});
|
|
|
|
// src/services/breakpoints.ts
|
|
function spanInSourceFileAtLocation(sourceFile, position) {
|
|
if (sourceFile.isDeclarationFile) {
|
|
return void 0;
|
|
}
|
|
let tokenAtLocation = getTokenAtPosition(sourceFile, position);
|
|
const lineOfPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
|
|
if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart(sourceFile)).line > lineOfPosition) {
|
|
const preceding = findPrecedingToken(tokenAtLocation.pos, sourceFile);
|
|
if (!preceding || sourceFile.getLineAndCharacterOfPosition(preceding.getEnd()).line !== lineOfPosition) {
|
|
return void 0;
|
|
}
|
|
tokenAtLocation = preceding;
|
|
}
|
|
if (tokenAtLocation.flags & 16777216 /* Ambient */) {
|
|
return void 0;
|
|
}
|
|
return spanInNode(tokenAtLocation);
|
|
function textSpan(startNode2, endNode2) {
|
|
const lastDecorator = canHaveDecorators(startNode2) ? findLast(startNode2.modifiers, isDecorator) : void 0;
|
|
const start2 = lastDecorator ? skipTrivia(sourceFile.text, lastDecorator.end) : startNode2.getStart(sourceFile);
|
|
return createTextSpanFromBounds(start2, (endNode2 || startNode2).getEnd());
|
|
}
|
|
function textSpanEndingAtNextToken(startNode2, previousTokenToFindNextEndToken) {
|
|
return textSpan(startNode2, findNextToken(previousTokenToFindNextEndToken, previousTokenToFindNextEndToken.parent, sourceFile));
|
|
}
|
|
function spanInNodeIfStartsOnSameLine(node, otherwiseOnNode) {
|
|
if (node && lineOfPosition === sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line) {
|
|
return spanInNode(node);
|
|
}
|
|
return spanInNode(otherwiseOnNode);
|
|
}
|
|
function spanInNodeArray(nodeArray, node, match) {
|
|
if (nodeArray) {
|
|
const index = nodeArray.indexOf(node);
|
|
if (index >= 0) {
|
|
let start2 = index;
|
|
let end = index + 1;
|
|
while (start2 > 0 && match(nodeArray[start2 - 1]))
|
|
start2--;
|
|
while (end < nodeArray.length && match(nodeArray[end]))
|
|
end++;
|
|
return createTextSpanFromBounds(skipTrivia(sourceFile.text, nodeArray[start2].pos), nodeArray[end - 1].end);
|
|
}
|
|
}
|
|
return textSpan(node);
|
|
}
|
|
function spanInPreviousNode(node) {
|
|
return spanInNode(findPrecedingToken(node.pos, sourceFile));
|
|
}
|
|
function spanInNextNode(node) {
|
|
return spanInNode(findNextToken(node, node.parent, sourceFile));
|
|
}
|
|
function spanInNode(node) {
|
|
if (node) {
|
|
const { parent: parent2 } = node;
|
|
switch (node.kind) {
|
|
case 240 /* VariableStatement */:
|
|
return spanInVariableDeclaration(node.declarationList.declarations[0]);
|
|
case 257 /* VariableDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return spanInVariableDeclaration(node);
|
|
case 166 /* Parameter */:
|
|
return spanInParameterDeclaration(node);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return spanInFunctionDeclaration(node);
|
|
case 238 /* Block */:
|
|
if (isFunctionBlock(node)) {
|
|
return spanInFunctionBlock(node);
|
|
}
|
|
case 265 /* ModuleBlock */:
|
|
return spanInBlock(node);
|
|
case 295 /* CatchClause */:
|
|
return spanInBlock(node.block);
|
|
case 241 /* ExpressionStatement */:
|
|
return textSpan(node.expression);
|
|
case 250 /* ReturnStatement */:
|
|
return textSpan(node.getChildAt(0), node.expression);
|
|
case 244 /* WhileStatement */:
|
|
return textSpanEndingAtNextToken(node, node.expression);
|
|
case 243 /* DoStatement */:
|
|
return spanInNode(node.statement);
|
|
case 256 /* DebuggerStatement */:
|
|
return textSpan(node.getChildAt(0));
|
|
case 242 /* IfStatement */:
|
|
return textSpanEndingAtNextToken(node, node.expression);
|
|
case 253 /* LabeledStatement */:
|
|
return spanInNode(node.statement);
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
return textSpan(node.getChildAt(0), node.label);
|
|
case 245 /* ForStatement */:
|
|
return spanInForStatement(node);
|
|
case 246 /* ForInStatement */:
|
|
return textSpanEndingAtNextToken(node, node.expression);
|
|
case 247 /* ForOfStatement */:
|
|
return spanInInitializerOfForLike(node);
|
|
case 252 /* SwitchStatement */:
|
|
return textSpanEndingAtNextToken(node, node.expression);
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
return spanInNode(node.statements[0]);
|
|
case 255 /* TryStatement */:
|
|
return spanInBlock(node.tryBlock);
|
|
case 254 /* ThrowStatement */:
|
|
return textSpan(node, node.expression);
|
|
case 274 /* ExportAssignment */:
|
|
return textSpan(node, node.expression);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return textSpan(node, node.moduleReference);
|
|
case 269 /* ImportDeclaration */:
|
|
return textSpan(node, node.moduleSpecifier);
|
|
case 275 /* ExportDeclaration */:
|
|
return textSpan(node, node.moduleSpecifier);
|
|
case 264 /* ModuleDeclaration */:
|
|
if (getModuleInstanceState(node) !== 1 /* Instantiated */) {
|
|
return void 0;
|
|
}
|
|
case 260 /* ClassDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
case 205 /* BindingElement */:
|
|
return textSpan(node);
|
|
case 251 /* WithStatement */:
|
|
return spanInNode(node.statement);
|
|
case 167 /* Decorator */:
|
|
return spanInNodeArray(parent2.modifiers, node, isDecorator);
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
return spanInBindingPattern(node);
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return void 0;
|
|
case 26 /* SemicolonToken */:
|
|
case 1 /* EndOfFileToken */:
|
|
return spanInNodeIfStartsOnSameLine(findPrecedingToken(node.pos, sourceFile));
|
|
case 27 /* CommaToken */:
|
|
return spanInPreviousNode(node);
|
|
case 18 /* OpenBraceToken */:
|
|
return spanInOpenBraceToken(node);
|
|
case 19 /* CloseBraceToken */:
|
|
return spanInCloseBraceToken(node);
|
|
case 23 /* CloseBracketToken */:
|
|
return spanInCloseBracketToken(node);
|
|
case 20 /* OpenParenToken */:
|
|
return spanInOpenParenToken(node);
|
|
case 21 /* CloseParenToken */:
|
|
return spanInCloseParenToken(node);
|
|
case 58 /* ColonToken */:
|
|
return spanInColonToken(node);
|
|
case 31 /* GreaterThanToken */:
|
|
case 29 /* LessThanToken */:
|
|
return spanInGreaterThanOrLessThanToken(node);
|
|
case 115 /* WhileKeyword */:
|
|
return spanInWhileKeyword(node);
|
|
case 91 /* ElseKeyword */:
|
|
case 83 /* CatchKeyword */:
|
|
case 96 /* FinallyKeyword */:
|
|
return spanInNextNode(node);
|
|
case 162 /* OfKeyword */:
|
|
return spanInOfKeyword(node);
|
|
default:
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(node)) {
|
|
return spanInArrayLiteralOrObjectLiteralDestructuringPattern(node);
|
|
}
|
|
if ((node.kind === 79 /* Identifier */ || node.kind === 227 /* SpreadElement */ || node.kind === 299 /* PropertyAssignment */ || node.kind === 300 /* ShorthandPropertyAssignment */) && isArrayLiteralOrObjectLiteralDestructuringPattern(parent2)) {
|
|
return textSpan(node);
|
|
}
|
|
if (node.kind === 223 /* BinaryExpression */) {
|
|
const { left, operatorToken } = node;
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(left)) {
|
|
return spanInArrayLiteralOrObjectLiteralDestructuringPattern(
|
|
left
|
|
);
|
|
}
|
|
if (operatorToken.kind === 63 /* EqualsToken */ && isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
|
|
return textSpan(node);
|
|
}
|
|
if (operatorToken.kind === 27 /* CommaToken */) {
|
|
return spanInNode(left);
|
|
}
|
|
}
|
|
if (isExpressionNode(node)) {
|
|
switch (parent2.kind) {
|
|
case 243 /* DoStatement */:
|
|
return spanInPreviousNode(node);
|
|
case 167 /* Decorator */:
|
|
return spanInNode(node.parent);
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return textSpan(node);
|
|
case 223 /* BinaryExpression */:
|
|
if (node.parent.operatorToken.kind === 27 /* CommaToken */) {
|
|
return textSpan(node);
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
if (node.parent.body === node) {
|
|
return textSpan(node);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
switch (node.parent.kind) {
|
|
case 299 /* PropertyAssignment */:
|
|
if (node.parent.name === node && !isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.parent)) {
|
|
return spanInNode(node.parent.initializer);
|
|
}
|
|
break;
|
|
case 213 /* TypeAssertionExpression */:
|
|
if (node.parent.type === node) {
|
|
return spanInNextNode(node.parent.type);
|
|
}
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */: {
|
|
const { initializer, type } = node.parent;
|
|
if (initializer === node || type === node || isAssignmentOperator(node.kind)) {
|
|
return spanInPreviousNode(node);
|
|
}
|
|
break;
|
|
}
|
|
case 223 /* BinaryExpression */: {
|
|
const { left } = node.parent;
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(left) && node !== left) {
|
|
return spanInPreviousNode(node);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
if (isFunctionLike(node.parent) && node.parent.type === node) {
|
|
return spanInPreviousNode(node);
|
|
}
|
|
}
|
|
return spanInNode(node.parent);
|
|
}
|
|
}
|
|
function textSpanFromVariableDeclaration(variableDeclaration) {
|
|
if (isVariableDeclarationList(variableDeclaration.parent) && variableDeclaration.parent.declarations[0] === variableDeclaration) {
|
|
return textSpan(findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration);
|
|
} else {
|
|
return textSpan(variableDeclaration);
|
|
}
|
|
}
|
|
function spanInVariableDeclaration(variableDeclaration) {
|
|
if (variableDeclaration.parent.parent.kind === 246 /* ForInStatement */) {
|
|
return spanInNode(variableDeclaration.parent.parent);
|
|
}
|
|
const parent2 = variableDeclaration.parent;
|
|
if (isBindingPattern(variableDeclaration.name)) {
|
|
return spanInBindingPattern(variableDeclaration.name);
|
|
}
|
|
if (hasOnlyExpressionInitializer(variableDeclaration) && variableDeclaration.initializer || hasSyntacticModifier(variableDeclaration, 1 /* Export */) || parent2.parent.kind === 247 /* ForOfStatement */) {
|
|
return textSpanFromVariableDeclaration(variableDeclaration);
|
|
}
|
|
if (isVariableDeclarationList(variableDeclaration.parent) && variableDeclaration.parent.declarations[0] !== variableDeclaration) {
|
|
return spanInNode(findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent));
|
|
}
|
|
}
|
|
function canHaveSpanInParameterDeclaration(parameter) {
|
|
return !!parameter.initializer || parameter.dotDotDotToken !== void 0 || hasSyntacticModifier(parameter, 4 /* Public */ | 8 /* Private */);
|
|
}
|
|
function spanInParameterDeclaration(parameter) {
|
|
if (isBindingPattern(parameter.name)) {
|
|
return spanInBindingPattern(parameter.name);
|
|
} else if (canHaveSpanInParameterDeclaration(parameter)) {
|
|
return textSpan(parameter);
|
|
} else {
|
|
const functionDeclaration = parameter.parent;
|
|
const indexOfParameter = functionDeclaration.parameters.indexOf(parameter);
|
|
Debug.assert(indexOfParameter !== -1);
|
|
if (indexOfParameter !== 0) {
|
|
return spanInParameterDeclaration(functionDeclaration.parameters[indexOfParameter - 1]);
|
|
} else {
|
|
return spanInNode(functionDeclaration.body);
|
|
}
|
|
}
|
|
}
|
|
function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) {
|
|
return hasSyntacticModifier(functionDeclaration, 1 /* Export */) || functionDeclaration.parent.kind === 260 /* ClassDeclaration */ && functionDeclaration.kind !== 173 /* Constructor */;
|
|
}
|
|
function spanInFunctionDeclaration(functionDeclaration) {
|
|
if (!functionDeclaration.body) {
|
|
return void 0;
|
|
}
|
|
if (canFunctionHaveSpanInWholeDeclaration(functionDeclaration)) {
|
|
return textSpan(functionDeclaration);
|
|
}
|
|
return spanInNode(functionDeclaration.body);
|
|
}
|
|
function spanInFunctionBlock(block) {
|
|
const nodeForSpanInBlock = block.statements.length ? block.statements[0] : block.getLastToken();
|
|
if (canFunctionHaveSpanInWholeDeclaration(block.parent)) {
|
|
return spanInNodeIfStartsOnSameLine(block.parent, nodeForSpanInBlock);
|
|
}
|
|
return spanInNode(nodeForSpanInBlock);
|
|
}
|
|
function spanInBlock(block) {
|
|
switch (block.parent.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
if (getModuleInstanceState(block.parent) !== 1 /* Instantiated */) {
|
|
return void 0;
|
|
}
|
|
case 244 /* WhileStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]);
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
return spanInNodeIfStartsOnSameLine(findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]);
|
|
}
|
|
return spanInNode(block.statements[0]);
|
|
}
|
|
function spanInInitializerOfForLike(forLikeStatement) {
|
|
if (forLikeStatement.initializer.kind === 258 /* VariableDeclarationList */) {
|
|
const variableDeclarationList = forLikeStatement.initializer;
|
|
if (variableDeclarationList.declarations.length > 0) {
|
|
return spanInNode(variableDeclarationList.declarations[0]);
|
|
}
|
|
} else {
|
|
return spanInNode(forLikeStatement.initializer);
|
|
}
|
|
}
|
|
function spanInForStatement(forStatement) {
|
|
if (forStatement.initializer) {
|
|
return spanInInitializerOfForLike(forStatement);
|
|
}
|
|
if (forStatement.condition) {
|
|
return textSpan(forStatement.condition);
|
|
}
|
|
if (forStatement.incrementor) {
|
|
return textSpan(forStatement.incrementor);
|
|
}
|
|
}
|
|
function spanInBindingPattern(bindingPattern) {
|
|
const firstBindingElement = forEach(
|
|
bindingPattern.elements,
|
|
(element) => element.kind !== 229 /* OmittedExpression */ ? element : void 0
|
|
);
|
|
if (firstBindingElement) {
|
|
return spanInNode(firstBindingElement);
|
|
}
|
|
if (bindingPattern.parent.kind === 205 /* BindingElement */) {
|
|
return textSpan(bindingPattern.parent);
|
|
}
|
|
return textSpanFromVariableDeclaration(bindingPattern.parent);
|
|
}
|
|
function spanInArrayLiteralOrObjectLiteralDestructuringPattern(node2) {
|
|
Debug.assert(node2.kind !== 204 /* ArrayBindingPattern */ && node2.kind !== 203 /* ObjectBindingPattern */);
|
|
const elements = node2.kind === 206 /* ArrayLiteralExpression */ ? node2.elements : node2.properties;
|
|
const firstBindingElement = forEach(
|
|
elements,
|
|
(element) => element.kind !== 229 /* OmittedExpression */ ? element : void 0
|
|
);
|
|
if (firstBindingElement) {
|
|
return spanInNode(firstBindingElement);
|
|
}
|
|
return textSpan(node2.parent.kind === 223 /* BinaryExpression */ ? node2.parent : node2);
|
|
}
|
|
function spanInOpenBraceToken(node2) {
|
|
switch (node2.parent.kind) {
|
|
case 263 /* EnumDeclaration */:
|
|
const enumDeclaration = node2.parent;
|
|
return spanInNodeIfStartsOnSameLine(findPrecedingToken(node2.pos, sourceFile, node2.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile));
|
|
case 260 /* ClassDeclaration */:
|
|
const classDeclaration = node2.parent;
|
|
return spanInNodeIfStartsOnSameLine(findPrecedingToken(node2.pos, sourceFile, node2.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile));
|
|
case 266 /* CaseBlock */:
|
|
return spanInNodeIfStartsOnSameLine(node2.parent.parent, node2.parent.clauses[0]);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
function spanInCloseBraceToken(node2) {
|
|
switch (node2.parent.kind) {
|
|
case 265 /* ModuleBlock */:
|
|
if (getModuleInstanceState(node2.parent.parent) !== 1 /* Instantiated */) {
|
|
return void 0;
|
|
}
|
|
case 263 /* EnumDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
return textSpan(node2);
|
|
case 238 /* Block */:
|
|
if (isFunctionBlock(node2.parent)) {
|
|
return textSpan(node2);
|
|
}
|
|
case 295 /* CatchClause */:
|
|
return spanInNode(lastOrUndefined(node2.parent.statements));
|
|
case 266 /* CaseBlock */:
|
|
const caseBlock = node2.parent;
|
|
const lastClause = lastOrUndefined(caseBlock.clauses);
|
|
if (lastClause) {
|
|
return spanInNode(lastOrUndefined(lastClause.statements));
|
|
}
|
|
return void 0;
|
|
case 203 /* ObjectBindingPattern */:
|
|
const bindingPattern = node2.parent;
|
|
return spanInNode(lastOrUndefined(bindingPattern.elements) || bindingPattern);
|
|
default:
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(node2.parent)) {
|
|
const objectLiteral = node2.parent;
|
|
return textSpan(lastOrUndefined(objectLiteral.properties) || objectLiteral);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
}
|
|
function spanInCloseBracketToken(node2) {
|
|
switch (node2.parent.kind) {
|
|
case 204 /* ArrayBindingPattern */:
|
|
const bindingPattern = node2.parent;
|
|
return textSpan(lastOrUndefined(bindingPattern.elements) || bindingPattern);
|
|
default:
|
|
if (isArrayLiteralOrObjectLiteralDestructuringPattern(node2.parent)) {
|
|
const arrayLiteral = node2.parent;
|
|
return textSpan(lastOrUndefined(arrayLiteral.elements) || arrayLiteral);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
}
|
|
function spanInOpenParenToken(node2) {
|
|
if (node2.parent.kind === 243 /* DoStatement */ || node2.parent.kind === 210 /* CallExpression */ || node2.parent.kind === 211 /* NewExpression */) {
|
|
return spanInPreviousNode(node2);
|
|
}
|
|
if (node2.parent.kind === 214 /* ParenthesizedExpression */) {
|
|
return spanInNextNode(node2);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
function spanInCloseParenToken(node2) {
|
|
switch (node2.parent.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 173 /* Constructor */:
|
|
case 244 /* WhileStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
return spanInPreviousNode(node2);
|
|
default:
|
|
return spanInNode(node2.parent);
|
|
}
|
|
}
|
|
function spanInColonToken(node2) {
|
|
if (isFunctionLike(node2.parent) || node2.parent.kind === 299 /* PropertyAssignment */ || node2.parent.kind === 166 /* Parameter */) {
|
|
return spanInPreviousNode(node2);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
function spanInGreaterThanOrLessThanToken(node2) {
|
|
if (node2.parent.kind === 213 /* TypeAssertionExpression */) {
|
|
return spanInNextNode(node2);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
function spanInWhileKeyword(node2) {
|
|
if (node2.parent.kind === 243 /* DoStatement */) {
|
|
return textSpanEndingAtNextToken(node2, node2.parent.expression);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
function spanInOfKeyword(node2) {
|
|
if (node2.parent.kind === 247 /* ForOfStatement */) {
|
|
return spanInNextNode(node2);
|
|
}
|
|
return spanInNode(node2.parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.CallHierarchy.ts
|
|
var ts_CallHierarchy_exports = {};
|
|
__export(ts_CallHierarchy_exports, {
|
|
createCallHierarchyItem: () => createCallHierarchyItem,
|
|
getIncomingCalls: () => getIncomingCalls,
|
|
getOutgoingCalls: () => getOutgoingCalls,
|
|
resolveCallHierarchyDeclaration: () => resolveCallHierarchyDeclaration
|
|
});
|
|
|
|
// src/services/callHierarchy.ts
|
|
function isNamedExpression(node) {
|
|
return (isFunctionExpression(node) || isClassExpression(node)) && isNamedDeclaration(node);
|
|
}
|
|
function isConstNamedExpression(node) {
|
|
return (isFunctionExpression(node) || isArrowFunction(node) || isClassExpression(node)) && isVariableDeclaration(node.parent) && node === node.parent.initializer && isIdentifier(node.parent.name) && !!(getCombinedNodeFlags(node.parent) & 2 /* Const */);
|
|
}
|
|
function isPossibleCallHierarchyDeclaration(node) {
|
|
return isSourceFile(node) || isModuleDeclaration(node) || isFunctionDeclaration(node) || isFunctionExpression(node) || isClassDeclaration(node) || isClassExpression(node) || isClassStaticBlockDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node);
|
|
}
|
|
function isValidCallHierarchyDeclaration(node) {
|
|
return isSourceFile(node) || isModuleDeclaration(node) && isIdentifier(node.name) || isFunctionDeclaration(node) || isClassDeclaration(node) || isClassStaticBlockDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isGetAccessorDeclaration(node) || isSetAccessorDeclaration(node) || isNamedExpression(node) || isConstNamedExpression(node);
|
|
}
|
|
function getCallHierarchyDeclarationReferenceNode(node) {
|
|
if (isSourceFile(node))
|
|
return node;
|
|
if (isNamedDeclaration(node))
|
|
return node.name;
|
|
if (isConstNamedExpression(node))
|
|
return node.parent.name;
|
|
return Debug.checkDefined(node.modifiers && find(node.modifiers, isDefaultModifier2));
|
|
}
|
|
function isDefaultModifier2(node) {
|
|
return node.kind === 88 /* DefaultKeyword */;
|
|
}
|
|
function getSymbolOfCallHierarchyDeclaration(typeChecker, node) {
|
|
const location2 = getCallHierarchyDeclarationReferenceNode(node);
|
|
return location2 && typeChecker.getSymbolAtLocation(location2);
|
|
}
|
|
function getCallHierarchyItemName(program, node) {
|
|
if (isSourceFile(node)) {
|
|
return { text: node.fileName, pos: 0, end: 0 };
|
|
}
|
|
if ((isFunctionDeclaration(node) || isClassDeclaration(node)) && !isNamedDeclaration(node)) {
|
|
const defaultModifier = node.modifiers && find(node.modifiers, isDefaultModifier2);
|
|
if (defaultModifier) {
|
|
return { text: "default", pos: defaultModifier.getStart(), end: defaultModifier.getEnd() };
|
|
}
|
|
}
|
|
if (isClassStaticBlockDeclaration(node)) {
|
|
const sourceFile = node.getSourceFile();
|
|
const pos = skipTrivia(sourceFile.text, moveRangePastModifiers(node).pos);
|
|
const end = pos + 6;
|
|
const typeChecker = program.getTypeChecker();
|
|
const symbol = typeChecker.getSymbolAtLocation(node.parent);
|
|
const prefix = symbol ? `${typeChecker.symbolToString(symbol, node.parent)} ` : "";
|
|
return { text: `${prefix}static {}`, pos, end };
|
|
}
|
|
const declName = isConstNamedExpression(node) ? node.parent.name : Debug.checkDefined(getNameOfDeclaration(node), "Expected call hierarchy item to have a name");
|
|
let text = isIdentifier(declName) ? idText(declName) : isStringOrNumericLiteralLike(declName) ? declName.text : isComputedPropertyName(declName) ? isStringOrNumericLiteralLike(declName.expression) ? declName.expression.text : void 0 : void 0;
|
|
if (text === void 0) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const symbol = typeChecker.getSymbolAtLocation(declName);
|
|
if (symbol) {
|
|
text = typeChecker.symbolToString(symbol, node);
|
|
}
|
|
}
|
|
if (text === void 0) {
|
|
const printer = createPrinter({ removeComments: true, omitTrailingSemicolon: true });
|
|
text = usingSingleLineStringWriter((writer) => printer.writeNode(4 /* Unspecified */, node, node.getSourceFile(), writer));
|
|
}
|
|
return { text, pos: declName.getStart(), end: declName.getEnd() };
|
|
}
|
|
function getCallHierarchItemContainerName(node) {
|
|
var _a2, _b;
|
|
if (isConstNamedExpression(node)) {
|
|
if (isModuleBlock(node.parent.parent.parent.parent) && isIdentifier(node.parent.parent.parent.parent.parent.name)) {
|
|
return node.parent.parent.parent.parent.parent.name.getText();
|
|
}
|
|
return;
|
|
}
|
|
switch (node.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (node.parent.kind === 207 /* ObjectLiteralExpression */) {
|
|
return (_a2 = getAssignedName(node.parent)) == null ? void 0 : _a2.getText();
|
|
}
|
|
return (_b = getNameOfDeclaration(node.parent)) == null ? void 0 : _b.getText();
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
if (isModuleBlock(node.parent) && isIdentifier(node.parent.parent.name)) {
|
|
return node.parent.parent.name.getText();
|
|
}
|
|
}
|
|
}
|
|
function findImplementation(typeChecker, node) {
|
|
if (node.body) {
|
|
return node;
|
|
}
|
|
if (isConstructorDeclaration(node)) {
|
|
return getFirstConstructorWithBody(node.parent);
|
|
}
|
|
if (isFunctionDeclaration(node) || isMethodDeclaration(node)) {
|
|
const symbol = getSymbolOfCallHierarchyDeclaration(typeChecker, node);
|
|
if (symbol && symbol.valueDeclaration && isFunctionLikeDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.body) {
|
|
return symbol.valueDeclaration;
|
|
}
|
|
return void 0;
|
|
}
|
|
return node;
|
|
}
|
|
function findAllInitialDeclarations(typeChecker, node) {
|
|
const symbol = getSymbolOfCallHierarchyDeclaration(typeChecker, node);
|
|
let declarations;
|
|
if (symbol && symbol.declarations) {
|
|
const indices = indicesOf(symbol.declarations);
|
|
const keys = map(symbol.declarations, (decl) => ({ file: decl.getSourceFile().fileName, pos: decl.pos }));
|
|
indices.sort((a, b) => compareStringsCaseSensitive(keys[a].file, keys[b].file) || keys[a].pos - keys[b].pos);
|
|
const sortedDeclarations = map(indices, (i) => symbol.declarations[i]);
|
|
let lastDecl;
|
|
for (const decl of sortedDeclarations) {
|
|
if (isValidCallHierarchyDeclaration(decl)) {
|
|
if (!lastDecl || lastDecl.parent !== decl.parent || lastDecl.end !== decl.pos) {
|
|
declarations = append(declarations, decl);
|
|
}
|
|
lastDecl = decl;
|
|
}
|
|
}
|
|
}
|
|
return declarations;
|
|
}
|
|
function findImplementationOrAllInitialDeclarations(typeChecker, node) {
|
|
var _a2, _b, _c;
|
|
if (isClassStaticBlockDeclaration(node)) {
|
|
return node;
|
|
}
|
|
if (isFunctionLikeDeclaration(node)) {
|
|
return (_b = (_a2 = findImplementation(typeChecker, node)) != null ? _a2 : findAllInitialDeclarations(typeChecker, node)) != null ? _b : node;
|
|
}
|
|
return (_c = findAllInitialDeclarations(typeChecker, node)) != null ? _c : node;
|
|
}
|
|
function resolveCallHierarchyDeclaration(program, location2) {
|
|
const typeChecker = program.getTypeChecker();
|
|
let followingSymbol = false;
|
|
while (true) {
|
|
if (isValidCallHierarchyDeclaration(location2)) {
|
|
return findImplementationOrAllInitialDeclarations(typeChecker, location2);
|
|
}
|
|
if (isPossibleCallHierarchyDeclaration(location2)) {
|
|
const ancestor = findAncestor(location2, isValidCallHierarchyDeclaration);
|
|
return ancestor && findImplementationOrAllInitialDeclarations(typeChecker, ancestor);
|
|
}
|
|
if (isDeclarationName(location2)) {
|
|
if (isValidCallHierarchyDeclaration(location2.parent)) {
|
|
return findImplementationOrAllInitialDeclarations(typeChecker, location2.parent);
|
|
}
|
|
if (isPossibleCallHierarchyDeclaration(location2.parent)) {
|
|
const ancestor = findAncestor(location2.parent, isValidCallHierarchyDeclaration);
|
|
return ancestor && findImplementationOrAllInitialDeclarations(typeChecker, ancestor);
|
|
}
|
|
if (isVariableDeclaration(location2.parent) && location2.parent.initializer && isConstNamedExpression(location2.parent.initializer)) {
|
|
return location2.parent.initializer;
|
|
}
|
|
return void 0;
|
|
}
|
|
if (isConstructorDeclaration(location2)) {
|
|
if (isValidCallHierarchyDeclaration(location2.parent)) {
|
|
return location2.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
if (location2.kind === 124 /* StaticKeyword */ && isClassStaticBlockDeclaration(location2.parent)) {
|
|
location2 = location2.parent;
|
|
continue;
|
|
}
|
|
if (isVariableDeclaration(location2) && location2.initializer && isConstNamedExpression(location2.initializer)) {
|
|
return location2.initializer;
|
|
}
|
|
if (!followingSymbol) {
|
|
let symbol = typeChecker.getSymbolAtLocation(location2);
|
|
if (symbol) {
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
symbol = typeChecker.getAliasedSymbol(symbol);
|
|
}
|
|
if (symbol.valueDeclaration) {
|
|
followingSymbol = true;
|
|
location2 = symbol.valueDeclaration;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function createCallHierarchyItem(program, node) {
|
|
const sourceFile = node.getSourceFile();
|
|
const name = getCallHierarchyItemName(program, node);
|
|
const containerName = getCallHierarchItemContainerName(node);
|
|
const kind = getNodeKind(node);
|
|
const kindModifiers = getNodeModifiers(node);
|
|
const span = createTextSpanFromBounds(skipTrivia(sourceFile.text, node.getFullStart(), false, true), node.getEnd());
|
|
const selectionSpan = createTextSpanFromBounds(name.pos, name.end);
|
|
return { file: sourceFile.fileName, kind, kindModifiers, name: name.text, containerName, span, selectionSpan };
|
|
}
|
|
function isDefined(x) {
|
|
return x !== void 0;
|
|
}
|
|
function convertEntryToCallSite(entry) {
|
|
if (entry.kind === ts_FindAllReferences_exports.EntryKind.Node) {
|
|
const { node } = entry;
|
|
if (isCallOrNewExpressionTarget(node, true, true) || isTaggedTemplateTag(node, true, true) || isDecoratorTarget(node, true, true) || isJsxOpeningLikeElementTagName(node, true, true) || isRightSideOfPropertyAccess(node) || isArgumentExpressionOfElementAccess(node)) {
|
|
const sourceFile = node.getSourceFile();
|
|
const ancestor = findAncestor(node, isValidCallHierarchyDeclaration) || sourceFile;
|
|
return { declaration: ancestor, range: createTextRangeFromNode(node, sourceFile) };
|
|
}
|
|
}
|
|
}
|
|
function getCallSiteGroupKey(entry) {
|
|
return getNodeId(entry.declaration);
|
|
}
|
|
function createCallHierarchyIncomingCall(from, fromSpans) {
|
|
return { from, fromSpans };
|
|
}
|
|
function convertCallSiteGroupToIncomingCall(program, entries) {
|
|
return createCallHierarchyIncomingCall(createCallHierarchyItem(program, entries[0].declaration), map(entries, (entry) => createTextSpanFromRange(entry.range)));
|
|
}
|
|
function getIncomingCalls(program, declaration, cancellationToken) {
|
|
if (isSourceFile(declaration) || isModuleDeclaration(declaration) || isClassStaticBlockDeclaration(declaration)) {
|
|
return [];
|
|
}
|
|
const location2 = getCallHierarchyDeclarationReferenceNode(declaration);
|
|
const calls = filter(ts_FindAllReferences_exports.findReferenceOrRenameEntries(program, cancellationToken, program.getSourceFiles(), location2, 0, { use: ts_FindAllReferences_exports.FindReferencesUse.References }, convertEntryToCallSite), isDefined);
|
|
return calls ? group(calls, getCallSiteGroupKey, (entries) => convertCallSiteGroupToIncomingCall(program, entries)) : [];
|
|
}
|
|
function createCallSiteCollector(program, callSites) {
|
|
function recordCallSite(node) {
|
|
const target = isTaggedTemplateExpression(node) ? node.tag : isJsxOpeningLikeElement(node) ? node.tagName : isAccessExpression(node) ? node : isClassStaticBlockDeclaration(node) ? node : node.expression;
|
|
const declaration = resolveCallHierarchyDeclaration(program, target);
|
|
if (declaration) {
|
|
const range = createTextRangeFromNode(target, node.getSourceFile());
|
|
if (isArray(declaration)) {
|
|
for (const decl of declaration) {
|
|
callSites.push({ declaration: decl, range });
|
|
}
|
|
} else {
|
|
callSites.push({ declaration, range });
|
|
}
|
|
}
|
|
}
|
|
function collect(node) {
|
|
if (!node)
|
|
return;
|
|
if (node.flags & 16777216 /* Ambient */) {
|
|
return;
|
|
}
|
|
if (isValidCallHierarchyDeclaration(node)) {
|
|
if (isClassLike(node)) {
|
|
for (const member of node.members) {
|
|
if (member.name && isComputedPropertyName(member.name)) {
|
|
collect(member.name.expression);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
recordCallSite(node);
|
|
return;
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 231 /* AsExpression */:
|
|
collect(node.expression);
|
|
return;
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
collect(node.name);
|
|
collect(node.initializer);
|
|
return;
|
|
case 210 /* CallExpression */:
|
|
recordCallSite(node);
|
|
collect(node.expression);
|
|
forEach(node.arguments, collect);
|
|
return;
|
|
case 211 /* NewExpression */:
|
|
recordCallSite(node);
|
|
collect(node.expression);
|
|
forEach(node.arguments, collect);
|
|
return;
|
|
case 212 /* TaggedTemplateExpression */:
|
|
recordCallSite(node);
|
|
collect(node.tag);
|
|
collect(node.template);
|
|
return;
|
|
case 283 /* JsxOpeningElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
recordCallSite(node);
|
|
collect(node.tagName);
|
|
collect(node.attributes);
|
|
return;
|
|
case 167 /* Decorator */:
|
|
recordCallSite(node);
|
|
collect(node.expression);
|
|
return;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
recordCallSite(node);
|
|
forEachChild(node, collect);
|
|
break;
|
|
case 235 /* SatisfiesExpression */:
|
|
collect(node.expression);
|
|
return;
|
|
}
|
|
if (isPartOfTypeNode(node)) {
|
|
return;
|
|
}
|
|
forEachChild(node, collect);
|
|
}
|
|
return collect;
|
|
}
|
|
function collectCallSitesOfSourceFile(node, collect) {
|
|
forEach(node.statements, collect);
|
|
}
|
|
function collectCallSitesOfModuleDeclaration(node, collect) {
|
|
if (!hasSyntacticModifier(node, 2 /* Ambient */) && node.body && isModuleBlock(node.body)) {
|
|
forEach(node.body.statements, collect);
|
|
}
|
|
}
|
|
function collectCallSitesOfFunctionLikeDeclaration(typeChecker, node, collect) {
|
|
const implementation = findImplementation(typeChecker, node);
|
|
if (implementation) {
|
|
forEach(implementation.parameters, collect);
|
|
collect(implementation.body);
|
|
}
|
|
}
|
|
function collectCallSitesOfClassStaticBlockDeclaration(node, collect) {
|
|
collect(node.body);
|
|
}
|
|
function collectCallSitesOfClassLikeDeclaration(node, collect) {
|
|
forEach(node.modifiers, collect);
|
|
const heritage = getClassExtendsHeritageElement(node);
|
|
if (heritage) {
|
|
collect(heritage.expression);
|
|
}
|
|
for (const member of node.members) {
|
|
if (canHaveModifiers(member)) {
|
|
forEach(member.modifiers, collect);
|
|
}
|
|
if (isPropertyDeclaration(member)) {
|
|
collect(member.initializer);
|
|
} else if (isConstructorDeclaration(member) && member.body) {
|
|
forEach(member.parameters, collect);
|
|
collect(member.body);
|
|
} else if (isClassStaticBlockDeclaration(member)) {
|
|
collect(member);
|
|
}
|
|
}
|
|
}
|
|
function collectCallSites(program, node) {
|
|
const callSites = [];
|
|
const collect = createCallSiteCollector(program, callSites);
|
|
switch (node.kind) {
|
|
case 308 /* SourceFile */:
|
|
collectCallSitesOfSourceFile(node, collect);
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
collectCallSitesOfModuleDeclaration(node, collect);
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
collectCallSitesOfFunctionLikeDeclaration(program.getTypeChecker(), node, collect);
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
collectCallSitesOfClassLikeDeclaration(node, collect);
|
|
break;
|
|
case 172 /* ClassStaticBlockDeclaration */:
|
|
collectCallSitesOfClassStaticBlockDeclaration(node, collect);
|
|
break;
|
|
default:
|
|
Debug.assertNever(node);
|
|
}
|
|
return callSites;
|
|
}
|
|
function createCallHierarchyOutgoingCall(to, fromSpans) {
|
|
return { to, fromSpans };
|
|
}
|
|
function convertCallSiteGroupToOutgoingCall(program, entries) {
|
|
return createCallHierarchyOutgoingCall(createCallHierarchyItem(program, entries[0].declaration), map(entries, (entry) => createTextSpanFromRange(entry.range)));
|
|
}
|
|
function getOutgoingCalls(program, declaration) {
|
|
if (declaration.flags & 16777216 /* Ambient */ || isMethodSignature(declaration)) {
|
|
return [];
|
|
}
|
|
return group(collectCallSites(program, declaration), getCallSiteGroupKey, (entries) => convertCallSiteGroupToOutgoingCall(program, entries));
|
|
}
|
|
|
|
// src/services/_namespaces/ts.classifier.ts
|
|
var ts_classifier_exports = {};
|
|
__export(ts_classifier_exports, {
|
|
v2020: () => ts_classifier_v2020_exports
|
|
});
|
|
|
|
// src/services/_namespaces/ts.classifier.v2020.ts
|
|
var ts_classifier_v2020_exports = {};
|
|
__export(ts_classifier_v2020_exports, {
|
|
TokenEncodingConsts: () => TokenEncodingConsts,
|
|
TokenModifier: () => TokenModifier,
|
|
TokenType: () => TokenType,
|
|
getEncodedSemanticClassifications: () => getEncodedSemanticClassifications2,
|
|
getSemanticClassifications: () => getSemanticClassifications2
|
|
});
|
|
|
|
// src/services/classifier2020.ts
|
|
var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
|
|
TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
|
|
TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
|
|
return TokenEncodingConsts2;
|
|
})(TokenEncodingConsts || {});
|
|
var TokenType = /* @__PURE__ */ ((TokenType2) => {
|
|
TokenType2[TokenType2["class"] = 0] = "class";
|
|
TokenType2[TokenType2["enum"] = 1] = "enum";
|
|
TokenType2[TokenType2["interface"] = 2] = "interface";
|
|
TokenType2[TokenType2["namespace"] = 3] = "namespace";
|
|
TokenType2[TokenType2["typeParameter"] = 4] = "typeParameter";
|
|
TokenType2[TokenType2["type"] = 5] = "type";
|
|
TokenType2[TokenType2["parameter"] = 6] = "parameter";
|
|
TokenType2[TokenType2["variable"] = 7] = "variable";
|
|
TokenType2[TokenType2["enumMember"] = 8] = "enumMember";
|
|
TokenType2[TokenType2["property"] = 9] = "property";
|
|
TokenType2[TokenType2["function"] = 10] = "function";
|
|
TokenType2[TokenType2["member"] = 11] = "member";
|
|
return TokenType2;
|
|
})(TokenType || {});
|
|
var TokenModifier = /* @__PURE__ */ ((TokenModifier2) => {
|
|
TokenModifier2[TokenModifier2["declaration"] = 0] = "declaration";
|
|
TokenModifier2[TokenModifier2["static"] = 1] = "static";
|
|
TokenModifier2[TokenModifier2["async"] = 2] = "async";
|
|
TokenModifier2[TokenModifier2["readonly"] = 3] = "readonly";
|
|
TokenModifier2[TokenModifier2["defaultLibrary"] = 4] = "defaultLibrary";
|
|
TokenModifier2[TokenModifier2["local"] = 5] = "local";
|
|
return TokenModifier2;
|
|
})(TokenModifier || {});
|
|
function getSemanticClassifications2(program, cancellationToken, sourceFile, span) {
|
|
const classifications = getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span);
|
|
Debug.assert(classifications.spans.length % 3 === 0);
|
|
const dense = classifications.spans;
|
|
const result = [];
|
|
for (let i = 0; i < dense.length; i += 3) {
|
|
result.push({
|
|
textSpan: createTextSpan(dense[i], dense[i + 1]),
|
|
classificationType: dense[i + 2]
|
|
});
|
|
}
|
|
return result;
|
|
}
|
|
function getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span) {
|
|
return {
|
|
spans: getSemanticTokens(program, sourceFile, span, cancellationToken),
|
|
endOfLineState: 0 /* None */
|
|
};
|
|
}
|
|
function getSemanticTokens(program, sourceFile, span, cancellationToken) {
|
|
const resultTokens = [];
|
|
const collector = (node, typeIdx, modifierSet) => {
|
|
resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), (typeIdx + 1 << 8 /* typeOffset */) + modifierSet);
|
|
};
|
|
if (program && sourceFile) {
|
|
collectTokens(program, sourceFile, span, collector, cancellationToken);
|
|
}
|
|
return resultTokens;
|
|
}
|
|
function collectTokens(program, sourceFile, span, collector, cancellationToken) {
|
|
const typeChecker = program.getTypeChecker();
|
|
let inJSXElement = false;
|
|
function visit(node) {
|
|
switch (node.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) {
|
|
return;
|
|
}
|
|
const prevInJSXElement = inJSXElement;
|
|
if (isJsxElement(node) || isJsxSelfClosingElement(node)) {
|
|
inJSXElement = true;
|
|
}
|
|
if (isJsxExpression(node)) {
|
|
inJSXElement = false;
|
|
}
|
|
if (isIdentifier(node) && !inJSXElement && !inImportClause(node) && !isInfinityOrNaNString(node.escapedText)) {
|
|
let symbol = typeChecker.getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
symbol = typeChecker.getAliasedSymbol(symbol);
|
|
}
|
|
let typeIdx = classifySymbol2(symbol, getMeaningFromLocation(node));
|
|
if (typeIdx !== void 0) {
|
|
let modifierSet = 0;
|
|
if (node.parent) {
|
|
const parentIsDeclaration = isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx;
|
|
if (parentIsDeclaration && node.parent.name === node) {
|
|
modifierSet = 1 << 0 /* declaration */;
|
|
}
|
|
}
|
|
if (typeIdx === 6 /* parameter */ && isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
|
|
typeIdx = 9 /* property */;
|
|
}
|
|
typeIdx = reclassifyByType(typeChecker, node, typeIdx);
|
|
const decl = symbol.valueDeclaration;
|
|
if (decl) {
|
|
const modifiers = getCombinedModifierFlags(decl);
|
|
const nodeFlags = getCombinedNodeFlags(decl);
|
|
if (modifiers & 32 /* Static */) {
|
|
modifierSet |= 1 << 1 /* static */;
|
|
}
|
|
if (modifiers & 512 /* Async */) {
|
|
modifierSet |= 1 << 2 /* async */;
|
|
}
|
|
if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
|
|
if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
|
|
modifierSet |= 1 << 3 /* readonly */;
|
|
}
|
|
}
|
|
if ((typeIdx === 7 /* variable */ || typeIdx === 10 /* function */) && isLocalDeclaration(decl, sourceFile)) {
|
|
modifierSet |= 1 << 5 /* local */;
|
|
}
|
|
if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
|
|
modifierSet |= 1 << 4 /* defaultLibrary */;
|
|
}
|
|
} else if (symbol.declarations && symbol.declarations.some((d) => program.isSourceFileDefaultLibrary(d.getSourceFile()))) {
|
|
modifierSet |= 1 << 4 /* defaultLibrary */;
|
|
}
|
|
collector(node, typeIdx, modifierSet);
|
|
}
|
|
}
|
|
}
|
|
forEachChild(node, visit);
|
|
inJSXElement = prevInJSXElement;
|
|
}
|
|
visit(sourceFile);
|
|
}
|
|
function classifySymbol2(symbol, meaning) {
|
|
const flags = symbol.getFlags();
|
|
if (flags & 32 /* Class */) {
|
|
return 0 /* class */;
|
|
} else if (flags & 384 /* Enum */) {
|
|
return 1 /* enum */;
|
|
} else if (flags & 524288 /* TypeAlias */) {
|
|
return 5 /* type */;
|
|
} else if (flags & 64 /* Interface */) {
|
|
if (meaning & 2 /* Type */) {
|
|
return 2 /* interface */;
|
|
}
|
|
} else if (flags & 262144 /* TypeParameter */) {
|
|
return 4 /* typeParameter */;
|
|
}
|
|
let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
|
|
if (decl && isBindingElement(decl)) {
|
|
decl = getDeclarationForBindingElement(decl);
|
|
}
|
|
return decl && tokenFromDeclarationMapping.get(decl.kind);
|
|
}
|
|
function reclassifyByType(typeChecker, node, typeIdx) {
|
|
if (typeIdx === 7 /* variable */ || typeIdx === 9 /* property */ || typeIdx === 6 /* parameter */) {
|
|
const type = typeChecker.getTypeAtLocation(node);
|
|
if (type) {
|
|
const test = (condition) => {
|
|
return condition(type) || type.isUnion() && type.types.some(condition);
|
|
};
|
|
if (typeIdx !== 6 /* parameter */ && test((t) => t.getConstructSignatures().length > 0)) {
|
|
return 0 /* class */;
|
|
}
|
|
if (test((t) => t.getCallSignatures().length > 0) && !test((t) => t.getProperties().length > 0) || isExpressionInCallExpression(node)) {
|
|
return typeIdx === 9 /* property */ ? 11 /* member */ : 10 /* function */;
|
|
}
|
|
}
|
|
}
|
|
return typeIdx;
|
|
}
|
|
function isLocalDeclaration(decl, sourceFile) {
|
|
if (isBindingElement(decl)) {
|
|
decl = getDeclarationForBindingElement(decl);
|
|
}
|
|
if (isVariableDeclaration(decl)) {
|
|
return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile;
|
|
} else if (isFunctionDeclaration(decl)) {
|
|
return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile;
|
|
}
|
|
return false;
|
|
}
|
|
function getDeclarationForBindingElement(element) {
|
|
while (true) {
|
|
if (isBindingElement(element.parent.parent)) {
|
|
element = element.parent.parent;
|
|
} else {
|
|
return element.parent.parent;
|
|
}
|
|
}
|
|
}
|
|
function inImportClause(node) {
|
|
const parent2 = node.parent;
|
|
return parent2 && (isImportClause(parent2) || isImportSpecifier(parent2) || isNamespaceImport(parent2));
|
|
}
|
|
function isExpressionInCallExpression(node) {
|
|
while (isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
|
|
node = node.parent;
|
|
}
|
|
return isCallExpression(node.parent) && node.parent.expression === node;
|
|
}
|
|
function isRightSideOfQualifiedNameOrPropertyAccess2(node) {
|
|
return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node;
|
|
}
|
|
var tokenFromDeclarationMapping = /* @__PURE__ */ new Map([
|
|
[257 /* VariableDeclaration */, 7 /* variable */],
|
|
[166 /* Parameter */, 6 /* parameter */],
|
|
[169 /* PropertyDeclaration */, 9 /* property */],
|
|
[264 /* ModuleDeclaration */, 3 /* namespace */],
|
|
[263 /* EnumDeclaration */, 1 /* enum */],
|
|
[302 /* EnumMember */, 8 /* enumMember */],
|
|
[260 /* ClassDeclaration */, 0 /* class */],
|
|
[171 /* MethodDeclaration */, 11 /* member */],
|
|
[259 /* FunctionDeclaration */, 10 /* function */],
|
|
[215 /* FunctionExpression */, 10 /* function */],
|
|
[170 /* MethodSignature */, 11 /* member */],
|
|
[174 /* GetAccessor */, 9 /* property */],
|
|
[175 /* SetAccessor */, 9 /* property */],
|
|
[168 /* PropertySignature */, 9 /* property */],
|
|
[261 /* InterfaceDeclaration */, 2 /* interface */],
|
|
[262 /* TypeAliasDeclaration */, 5 /* type */],
|
|
[165 /* TypeParameter */, 4 /* typeParameter */],
|
|
[299 /* PropertyAssignment */, 9 /* property */],
|
|
[300 /* ShorthandPropertyAssignment */, 9 /* property */]
|
|
]);
|
|
|
|
// src/services/_namespaces/ts.codefix.ts
|
|
var ts_codefix_exports = {};
|
|
__export(ts_codefix_exports, {
|
|
PreserveOptionalFlags: () => PreserveOptionalFlags,
|
|
addNewNodeForMemberSymbol: () => addNewNodeForMemberSymbol,
|
|
codeFixAll: () => codeFixAll,
|
|
createCodeFixAction: () => createCodeFixAction,
|
|
createCodeFixActionMaybeFixAll: () => createCodeFixActionMaybeFixAll,
|
|
createCodeFixActionWithoutFixAll: () => createCodeFixActionWithoutFixAll,
|
|
createCombinedCodeActions: () => createCombinedCodeActions,
|
|
createFileTextChanges: () => createFileTextChanges,
|
|
createImportAdder: () => createImportAdder,
|
|
createImportSpecifierResolver: () => createImportSpecifierResolver,
|
|
createJsonPropertyAssignment: () => createJsonPropertyAssignment,
|
|
createMissingMemberNodes: () => createMissingMemberNodes,
|
|
createSignatureDeclarationFromCallExpression: () => createSignatureDeclarationFromCallExpression,
|
|
createSignatureDeclarationFromSignature: () => createSignatureDeclarationFromSignature,
|
|
createStubbedBody: () => createStubbedBody,
|
|
eachDiagnostic: () => eachDiagnostic,
|
|
findAncestorMatchingSpan: () => findAncestorMatchingSpan,
|
|
findJsonProperty: () => findJsonProperty,
|
|
generateAccessorFromProperty: () => generateAccessorFromProperty,
|
|
getAccessorConvertiblePropertyAtPosition: () => getAccessorConvertiblePropertyAtPosition,
|
|
getAllFixes: () => getAllFixes,
|
|
getAllSupers: () => getAllSupers,
|
|
getArgumentTypesAndTypeParameters: () => getArgumentTypesAndTypeParameters,
|
|
getFixes: () => getFixes,
|
|
getImportCompletionAction: () => getImportCompletionAction,
|
|
getImportKind: () => getImportKind,
|
|
getNoopSymbolTrackerWithResolver: () => getNoopSymbolTrackerWithResolver,
|
|
getPromoteTypeOnlyCompletionAction: () => getPromoteTypeOnlyCompletionAction,
|
|
getSupportedErrorCodes: () => getSupportedErrorCodes,
|
|
importFixName: () => importFixName,
|
|
importSymbols: () => importSymbols,
|
|
moduleSpecifierToValidIdentifier: () => moduleSpecifierToValidIdentifier,
|
|
moduleSymbolToValidIdentifier: () => moduleSymbolToValidIdentifier,
|
|
parameterShouldGetTypeFromJSDoc: () => parameterShouldGetTypeFromJSDoc,
|
|
registerCodeFix: () => registerCodeFix,
|
|
setJsonCompilerOptionValue: () => setJsonCompilerOptionValue,
|
|
setJsonCompilerOptionValues: () => setJsonCompilerOptionValues,
|
|
tryGetAutoImportableReferenceFromTypeNode: () => tryGetAutoImportableReferenceFromTypeNode,
|
|
typeToAutoImportableTypeNode: () => typeToAutoImportableTypeNode
|
|
});
|
|
|
|
// src/services/codeFixProvider.ts
|
|
var errorCodeToFixes = createMultiMap();
|
|
var fixIdToRegistration = /* @__PURE__ */ new Map();
|
|
function createCodeFixActionWithoutFixAll(fixName8, changes, description2) {
|
|
return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, void 0, void 0);
|
|
}
|
|
function createCodeFixAction(fixName8, changes, description2, fixId52, fixAllDescription, command) {
|
|
return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, diagnosticToString(fixAllDescription), command);
|
|
}
|
|
function createCodeFixActionMaybeFixAll(fixName8, changes, description2, fixId52, fixAllDescription, command) {
|
|
return createCodeFixActionWorker(fixName8, diagnosticToString(description2), changes, fixId52, fixAllDescription && diagnosticToString(fixAllDescription), command);
|
|
}
|
|
function createCodeFixActionWorker(fixName8, description2, changes, fixId52, fixAllDescription, command) {
|
|
return { fixName: fixName8, description: description2, changes, fixId: fixId52, fixAllDescription, commands: command ? [command] : void 0 };
|
|
}
|
|
function registerCodeFix(reg) {
|
|
for (const error of reg.errorCodes) {
|
|
errorCodeToFixes.add(String(error), reg);
|
|
}
|
|
if (reg.fixIds) {
|
|
for (const fixId52 of reg.fixIds) {
|
|
Debug.assert(!fixIdToRegistration.has(fixId52));
|
|
fixIdToRegistration.set(fixId52, reg);
|
|
}
|
|
}
|
|
}
|
|
function getSupportedErrorCodes() {
|
|
return arrayFrom(errorCodeToFixes.keys());
|
|
}
|
|
function removeFixIdIfFixAllUnavailable(registration, diagnostics) {
|
|
const { errorCodes: errorCodes64 } = registration;
|
|
let maybeFixableDiagnostics = 0;
|
|
for (const diag2 of diagnostics) {
|
|
if (contains(errorCodes64, diag2.code))
|
|
maybeFixableDiagnostics++;
|
|
if (maybeFixableDiagnostics > 1)
|
|
break;
|
|
}
|
|
const fixAllUnavailable = maybeFixableDiagnostics < 2;
|
|
return ({ fixId: fixId52, fixAllDescription, ...action }) => {
|
|
return fixAllUnavailable ? action : { ...action, fixId: fixId52, fixAllDescription };
|
|
};
|
|
}
|
|
function getFixes(context) {
|
|
const diagnostics = getDiagnostics(context);
|
|
const registrations = errorCodeToFixes.get(String(context.errorCode));
|
|
return flatMap(registrations, (f) => map(f.getCodeActions(context), removeFixIdIfFixAllUnavailable(f, diagnostics)));
|
|
}
|
|
function getAllFixes(context) {
|
|
return fixIdToRegistration.get(cast(context.fixId, isString)).getAllCodeActions(context);
|
|
}
|
|
function createCombinedCodeActions(changes, commands) {
|
|
return { changes, commands };
|
|
}
|
|
function createFileTextChanges(fileName, textChanges2) {
|
|
return { fileName, textChanges: textChanges2 };
|
|
}
|
|
function codeFixAll(context, errorCodes64, use) {
|
|
const commands = [];
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => eachDiagnostic(context, errorCodes64, (diag2) => use(t, diag2, commands)));
|
|
return createCombinedCodeActions(changes, commands.length === 0 ? void 0 : commands);
|
|
}
|
|
function eachDiagnostic(context, errorCodes64, cb) {
|
|
for (const diag2 of getDiagnostics(context)) {
|
|
if (contains(errorCodes64, diag2.code)) {
|
|
cb(diag2);
|
|
}
|
|
}
|
|
}
|
|
function getDiagnostics({ program, sourceFile, cancellationToken }) {
|
|
return [
|
|
...program.getSemanticDiagnostics(sourceFile, cancellationToken),
|
|
...program.getSyntacticDiagnostics(sourceFile, cancellationToken),
|
|
...computeSuggestionDiagnostics(sourceFile, program, cancellationToken)
|
|
];
|
|
}
|
|
|
|
// src/services/codefixes/addConvertToUnknownForNonOverlappingTypes.ts
|
|
var fixId = "addConvertToUnknownForNonOverlappingTypes";
|
|
var errorCodes = [Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first.code];
|
|
registerCodeFix({
|
|
errorCodes,
|
|
getCodeActions: function getCodeActionsToAddConvertToUnknownForNonOverlappingTypes(context) {
|
|
const assertion = getAssertion(context.sourceFile, context.span.start);
|
|
if (assertion === void 0)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange(t, context.sourceFile, assertion));
|
|
return [createCodeFixAction(fixId, changes, Diagnostics.Add_unknown_conversion_for_non_overlapping_types, fixId, Diagnostics.Add_unknown_to_all_conversions_of_non_overlapping_types)];
|
|
},
|
|
fixIds: [fixId],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes, (changes, diag2) => {
|
|
const assertion = getAssertion(diag2.file, diag2.start);
|
|
if (assertion) {
|
|
makeChange(changes, diag2.file, assertion);
|
|
}
|
|
})
|
|
});
|
|
function makeChange(changeTracker, sourceFile, assertion) {
|
|
const replacement = isAsExpression(assertion) ? factory.createAsExpression(assertion.expression, factory.createKeywordTypeNode(157 /* UnknownKeyword */)) : factory.createTypeAssertion(factory.createKeywordTypeNode(157 /* UnknownKeyword */), assertion.expression);
|
|
changeTracker.replaceNode(sourceFile, assertion.expression, replacement);
|
|
}
|
|
function getAssertion(sourceFile, pos) {
|
|
if (isInJSFile(sourceFile))
|
|
return void 0;
|
|
return findAncestor(getTokenAtPosition(sourceFile, pos), (n) => isAsExpression(n) || isTypeAssertionExpression(n));
|
|
}
|
|
|
|
// src/services/codefixes/addEmptyExportDeclaration.ts
|
|
registerCodeFix({
|
|
errorCodes: [
|
|
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,
|
|
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 getCodeActionsToAddEmptyExportDeclaration(context) {
|
|
const { sourceFile } = context;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
|
|
const exportDeclaration = factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports([]),
|
|
void 0
|
|
);
|
|
changes2.insertNodeAtEndOfScope(sourceFile, sourceFile, exportDeclaration);
|
|
});
|
|
return [createCodeFixActionWithoutFixAll("addEmptyExportDeclaration", changes, Diagnostics.Add_export_to_make_this_file_into_a_module)];
|
|
}
|
|
});
|
|
|
|
// src/services/codefixes/addMissingAsync.ts
|
|
var fixId2 = "addMissingAsync";
|
|
var errorCodes2 = [
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1.code,
|
|
Diagnostics.Type_0_is_not_comparable_to_type_1.code
|
|
];
|
|
registerCodeFix({
|
|
fixIds: [fixId2],
|
|
errorCodes: errorCodes2,
|
|
getCodeActions: function getCodeActionsToAddMissingAsync(context) {
|
|
const { sourceFile, errorCode, cancellationToken, program, span } = context;
|
|
const diagnostic = find(program.getTypeChecker().getDiagnostics(sourceFile, cancellationToken), getIsMatchingAsyncError(span, errorCode));
|
|
const directSpan = diagnostic && diagnostic.relatedInformation && find(diagnostic.relatedInformation, (r) => r.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
|
|
const decl = getFixableErrorSpanDeclaration(sourceFile, directSpan);
|
|
if (!decl) {
|
|
return;
|
|
}
|
|
const trackChanges = (cb) => ts_textChanges_exports.ChangeTracker.with(context, cb);
|
|
return [getFix(context, decl, trackChanges)];
|
|
},
|
|
getAllCodeActions: (context) => {
|
|
const { sourceFile } = context;
|
|
const fixedDeclarations = /* @__PURE__ */ new Set();
|
|
return codeFixAll(context, errorCodes2, (t, diagnostic) => {
|
|
const span = diagnostic.relatedInformation && find(diagnostic.relatedInformation, (r) => r.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
|
|
const decl = getFixableErrorSpanDeclaration(sourceFile, span);
|
|
if (!decl) {
|
|
return;
|
|
}
|
|
const trackChanges = (cb) => (cb(t), []);
|
|
return getFix(context, decl, trackChanges, fixedDeclarations);
|
|
});
|
|
}
|
|
});
|
|
function getFix(context, decl, trackChanges, fixedDeclarations) {
|
|
const changes = trackChanges((t) => makeChange2(t, context.sourceFile, decl, fixedDeclarations));
|
|
return createCodeFixAction(fixId2, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId2, Diagnostics.Add_all_missing_async_modifiers);
|
|
}
|
|
function makeChange2(changeTracker, sourceFile, insertionSite, fixedDeclarations) {
|
|
if (fixedDeclarations) {
|
|
if (fixedDeclarations.has(getNodeId(insertionSite))) {
|
|
return;
|
|
}
|
|
}
|
|
fixedDeclarations == null ? void 0 : fixedDeclarations.add(getNodeId(insertionSite));
|
|
const cloneWithModifier = factory.updateModifiers(
|
|
getSynthesizedDeepClone(insertionSite, true),
|
|
factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | 512 /* Async */))
|
|
);
|
|
changeTracker.replaceNode(
|
|
sourceFile,
|
|
insertionSite,
|
|
cloneWithModifier
|
|
);
|
|
}
|
|
function getFixableErrorSpanDeclaration(sourceFile, span) {
|
|
if (!span)
|
|
return void 0;
|
|
const token = getTokenAtPosition(sourceFile, span.start);
|
|
const decl = findAncestor(token, (node) => {
|
|
if (node.getStart(sourceFile) < span.start || node.getEnd() > textSpanEnd(span)) {
|
|
return "quit";
|
|
}
|
|
return (isArrowFunction(node) || isMethodDeclaration(node) || isFunctionExpression(node) || isFunctionDeclaration(node)) && textSpansEqual(span, createTextSpanFromNode(node, sourceFile));
|
|
});
|
|
return decl;
|
|
}
|
|
function getIsMatchingAsyncError(span, errorCode) {
|
|
return ({ start: start2, length: length2, relatedInformation, code }) => isNumber(start2) && isNumber(length2) && textSpansEqual({ start: start2, length: length2 }, span) && code === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code);
|
|
}
|
|
|
|
// src/services/codefixes/addMissingAwait.ts
|
|
var fixId3 = "addMissingAwait";
|
|
var propertyAccessCode = Diagnostics.Property_0_does_not_exist_on_type_1.code;
|
|
var callableConstructableErrorCodes = [
|
|
Diagnostics.This_expression_is_not_callable.code,
|
|
Diagnostics.This_expression_is_not_constructable.code
|
|
];
|
|
var errorCodes3 = [
|
|
Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type.code,
|
|
Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code,
|
|
Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code,
|
|
Diagnostics.Operator_0_cannot_be_applied_to_type_1.code,
|
|
Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code,
|
|
Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap.code,
|
|
Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined.code,
|
|
Diagnostics.Type_0_is_not_an_array_type.code,
|
|
Diagnostics.Type_0_is_not_an_array_type_or_a_string_type.code,
|
|
Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher.code,
|
|
Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
|
|
Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
|
|
Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
|
|
Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator.code,
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
|
|
propertyAccessCode,
|
|
...callableConstructableErrorCodes
|
|
];
|
|
registerCodeFix({
|
|
fixIds: [fixId3],
|
|
errorCodes: errorCodes3,
|
|
getCodeActions: function getCodeActionsToAddMissingAwait(context) {
|
|
const { sourceFile, errorCode, span, cancellationToken, program } = context;
|
|
const expression = getAwaitErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program);
|
|
if (!expression) {
|
|
return;
|
|
}
|
|
const checker = context.program.getTypeChecker();
|
|
const trackChanges = (cb) => ts_textChanges_exports.ChangeTracker.with(context, cb);
|
|
return compact([
|
|
getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges),
|
|
getUseSiteFix(context, expression, errorCode, checker, trackChanges)
|
|
]);
|
|
},
|
|
getAllCodeActions: (context) => {
|
|
const { sourceFile, program, cancellationToken } = context;
|
|
const checker = context.program.getTypeChecker();
|
|
const fixedDeclarations = /* @__PURE__ */ new Set();
|
|
return codeFixAll(context, errorCodes3, (t, diagnostic) => {
|
|
const expression = getAwaitErrorSpanExpression(sourceFile, diagnostic.code, diagnostic, cancellationToken, program);
|
|
if (!expression) {
|
|
return;
|
|
}
|
|
const trackChanges = (cb) => (cb(t), []);
|
|
return getDeclarationSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations) || getUseSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations);
|
|
});
|
|
}
|
|
});
|
|
function getAwaitErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program) {
|
|
const expression = getFixableErrorSpanExpression(sourceFile, span);
|
|
return expression && isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) && isInsideAwaitableBody(expression) ? expression : void 0;
|
|
}
|
|
function getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) {
|
|
const { sourceFile, program, cancellationToken } = context;
|
|
const awaitableInitializers = findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker);
|
|
if (awaitableInitializers) {
|
|
const initializerChanges = trackChanges((t) => {
|
|
forEach(awaitableInitializers.initializers, ({ expression: expression2 }) => makeChange3(t, errorCode, sourceFile, checker, expression2, fixedDeclarations));
|
|
if (fixedDeclarations && awaitableInitializers.needsSecondPassForFixAll) {
|
|
makeChange3(t, errorCode, sourceFile, checker, expression, fixedDeclarations);
|
|
}
|
|
});
|
|
return createCodeFixActionWithoutFixAll(
|
|
"addMissingAwaitToInitializer",
|
|
initializerChanges,
|
|
awaitableInitializers.initializers.length === 1 ? [Diagnostics.Add_await_to_initializer_for_0, awaitableInitializers.initializers[0].declarationSymbol.name] : Diagnostics.Add_await_to_initializers
|
|
);
|
|
}
|
|
}
|
|
function getUseSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) {
|
|
const changes = trackChanges((t) => makeChange3(t, errorCode, context.sourceFile, checker, expression, fixedDeclarations));
|
|
return createCodeFixAction(fixId3, changes, Diagnostics.Add_await, fixId3, Diagnostics.Fix_all_expressions_possibly_missing_await);
|
|
}
|
|
function isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) {
|
|
const checker = program.getTypeChecker();
|
|
const diagnostics = checker.getDiagnostics(sourceFile, cancellationToken);
|
|
return some(diagnostics, ({ start: start2, length: length2, relatedInformation, code }) => isNumber(start2) && isNumber(length2) && textSpansEqual({ start: start2, length: length2 }, span) && code === errorCode && !!relatedInformation && some(relatedInformation, (related) => related.code === Diagnostics.Did_you_forget_to_use_await.code));
|
|
}
|
|
function findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker) {
|
|
const identifiers = getIdentifiersFromErrorSpanExpression(expression, checker);
|
|
if (!identifiers) {
|
|
return;
|
|
}
|
|
let isCompleteFix = identifiers.isCompleteFix;
|
|
let initializers;
|
|
for (const identifier of identifiers.identifiers) {
|
|
const symbol = checker.getSymbolAtLocation(identifier);
|
|
if (!symbol) {
|
|
continue;
|
|
}
|
|
const declaration = tryCast(symbol.valueDeclaration, isVariableDeclaration);
|
|
const variableName = declaration && tryCast(declaration.name, isIdentifier);
|
|
const variableStatement = getAncestor(declaration, 240 /* VariableStatement */);
|
|
if (!declaration || !variableStatement || declaration.type || !declaration.initializer || variableStatement.getSourceFile() !== sourceFile || hasSyntacticModifier(variableStatement, 1 /* Export */) || !variableName || !isInsideAwaitableBody(declaration.initializer)) {
|
|
isCompleteFix = false;
|
|
continue;
|
|
}
|
|
const diagnostics = program.getSemanticDiagnostics(sourceFile, cancellationToken);
|
|
const isUsedElsewhere = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(variableName, checker, sourceFile, (reference) => {
|
|
return identifier !== reference && !symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker);
|
|
});
|
|
if (isUsedElsewhere) {
|
|
isCompleteFix = false;
|
|
continue;
|
|
}
|
|
(initializers || (initializers = [])).push({
|
|
expression: declaration.initializer,
|
|
declarationSymbol: symbol
|
|
});
|
|
}
|
|
return initializers && {
|
|
initializers,
|
|
needsSecondPassForFixAll: !isCompleteFix
|
|
};
|
|
}
|
|
function getIdentifiersFromErrorSpanExpression(expression, checker) {
|
|
if (isPropertyAccessExpression(expression.parent) && isIdentifier(expression.parent.expression)) {
|
|
return { identifiers: [expression.parent.expression], isCompleteFix: true };
|
|
}
|
|
if (isIdentifier(expression)) {
|
|
return { identifiers: [expression], isCompleteFix: true };
|
|
}
|
|
if (isBinaryExpression(expression)) {
|
|
let sides;
|
|
let isCompleteFix = true;
|
|
for (const side of [expression.left, expression.right]) {
|
|
const type = checker.getTypeAtLocation(side);
|
|
if (checker.getPromisedTypeOfPromise(type)) {
|
|
if (!isIdentifier(side)) {
|
|
isCompleteFix = false;
|
|
continue;
|
|
}
|
|
(sides || (sides = [])).push(side);
|
|
}
|
|
}
|
|
return sides && { identifiers: sides, isCompleteFix };
|
|
}
|
|
}
|
|
function symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker) {
|
|
const errorNode = isPropertyAccessExpression(reference.parent) ? reference.parent.name : isBinaryExpression(reference.parent) ? reference.parent : reference;
|
|
const diagnostic = find(diagnostics, (diagnostic2) => diagnostic2.start === errorNode.getStart(sourceFile) && diagnostic2.start + diagnostic2.length === errorNode.getEnd());
|
|
return diagnostic && contains(errorCodes3, diagnostic.code) || checker.getTypeAtLocation(errorNode).flags & 1 /* Any */;
|
|
}
|
|
function isInsideAwaitableBody(node) {
|
|
return node.kind & 32768 /* AwaitContext */ || !!findAncestor(node, (ancestor) => ancestor.parent && isArrowFunction(ancestor.parent) && ancestor.parent.body === ancestor || isBlock(ancestor) && (ancestor.parent.kind === 259 /* FunctionDeclaration */ || ancestor.parent.kind === 215 /* FunctionExpression */ || ancestor.parent.kind === 216 /* ArrowFunction */ || ancestor.parent.kind === 171 /* MethodDeclaration */));
|
|
}
|
|
function makeChange3(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) {
|
|
if (isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) {
|
|
const exprType = checker.getTypeAtLocation(insertionSite);
|
|
const asyncIter = checker.getAsyncIterableType();
|
|
if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) {
|
|
const forOf = insertionSite.parent;
|
|
changeTracker.replaceNode(sourceFile, forOf, factory.updateForOfStatement(forOf, factory.createToken(133 /* AwaitKeyword */), forOf.initializer, forOf.expression, forOf.statement));
|
|
return;
|
|
}
|
|
}
|
|
if (isBinaryExpression(insertionSite)) {
|
|
for (const side of [insertionSite.left, insertionSite.right]) {
|
|
if (fixedDeclarations && isIdentifier(side)) {
|
|
const symbol = checker.getSymbolAtLocation(side);
|
|
if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
|
|
continue;
|
|
}
|
|
}
|
|
const type = checker.getTypeAtLocation(side);
|
|
const newNode = checker.getPromisedTypeOfPromise(type) ? factory.createAwaitExpression(side) : side;
|
|
changeTracker.replaceNode(sourceFile, side, newNode);
|
|
}
|
|
} else if (errorCode === propertyAccessCode && isPropertyAccessExpression(insertionSite.parent)) {
|
|
if (fixedDeclarations && isIdentifier(insertionSite.parent.expression)) {
|
|
const symbol = checker.getSymbolAtLocation(insertionSite.parent.expression);
|
|
if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
|
|
return;
|
|
}
|
|
}
|
|
changeTracker.replaceNode(
|
|
sourceFile,
|
|
insertionSite.parent.expression,
|
|
factory.createParenthesizedExpression(factory.createAwaitExpression(insertionSite.parent.expression))
|
|
);
|
|
insertLeadingSemicolonIfNeeded(changeTracker, insertionSite.parent.expression, sourceFile);
|
|
} else if (contains(callableConstructableErrorCodes, errorCode) && isCallOrNewExpression(insertionSite.parent)) {
|
|
if (fixedDeclarations && isIdentifier(insertionSite)) {
|
|
const symbol = checker.getSymbolAtLocation(insertionSite);
|
|
if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
|
|
return;
|
|
}
|
|
}
|
|
changeTracker.replaceNode(sourceFile, insertionSite, factory.createParenthesizedExpression(factory.createAwaitExpression(insertionSite)));
|
|
insertLeadingSemicolonIfNeeded(changeTracker, insertionSite, sourceFile);
|
|
} else {
|
|
if (fixedDeclarations && isVariableDeclaration(insertionSite.parent) && isIdentifier(insertionSite.parent.name)) {
|
|
const symbol = checker.getSymbolAtLocation(insertionSite.parent.name);
|
|
if (symbol && !tryAddToSet(fixedDeclarations, getSymbolId(symbol))) {
|
|
return;
|
|
}
|
|
}
|
|
changeTracker.replaceNode(sourceFile, insertionSite, factory.createAwaitExpression(insertionSite));
|
|
}
|
|
}
|
|
function insertLeadingSemicolonIfNeeded(changeTracker, beforeNode, sourceFile) {
|
|
const precedingToken = findPrecedingToken(beforeNode.pos, sourceFile);
|
|
if (precedingToken && positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) {
|
|
changeTracker.insertText(sourceFile, beforeNode.getStart(sourceFile), ";");
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/addMissingConst.ts
|
|
var fixId4 = "addMissingConst";
|
|
var errorCodes4 = [
|
|
Diagnostics.Cannot_find_name_0.code,
|
|
Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes4,
|
|
getCodeActions: function getCodeActionsToAddMissingConst(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange4(t, context.sourceFile, context.span.start, context.program));
|
|
if (changes.length > 0) {
|
|
return [createCodeFixAction(fixId4, changes, Diagnostics.Add_const_to_unresolved_variable, fixId4, Diagnostics.Add_const_to_all_unresolved_variables)];
|
|
}
|
|
},
|
|
fixIds: [fixId4],
|
|
getAllCodeActions: (context) => {
|
|
const fixedNodes = /* @__PURE__ */ new Set();
|
|
return codeFixAll(context, errorCodes4, (changes, diag2) => makeChange4(changes, diag2.file, diag2.start, context.program, fixedNodes));
|
|
}
|
|
});
|
|
function makeChange4(changeTracker, sourceFile, pos, program, fixedNodes) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const forInitializer = findAncestor(
|
|
token,
|
|
(node) => isForInOrOfStatement(node.parent) ? node.parent.initializer === node : isPossiblyPartOfDestructuring(node) ? false : "quit"
|
|
);
|
|
if (forInitializer)
|
|
return applyChange(changeTracker, forInitializer, sourceFile, fixedNodes);
|
|
const parent2 = token.parent;
|
|
if (isBinaryExpression(parent2) && parent2.operatorToken.kind === 63 /* EqualsToken */ && isExpressionStatement(parent2.parent)) {
|
|
return applyChange(changeTracker, token, sourceFile, fixedNodes);
|
|
}
|
|
if (isArrayLiteralExpression(parent2)) {
|
|
const checker = program.getTypeChecker();
|
|
if (!every(parent2.elements, (element) => arrayElementCouldBeVariableDeclaration(element, checker))) {
|
|
return;
|
|
}
|
|
return applyChange(changeTracker, parent2, sourceFile, fixedNodes);
|
|
}
|
|
const commaExpression = findAncestor(
|
|
token,
|
|
(node) => isExpressionStatement(node.parent) ? true : isPossiblyPartOfCommaSeperatedInitializer(node) ? false : "quit"
|
|
);
|
|
if (commaExpression) {
|
|
const checker = program.getTypeChecker();
|
|
if (!expressionCouldBeVariableDeclaration(commaExpression, checker)) {
|
|
return;
|
|
}
|
|
return applyChange(changeTracker, commaExpression, sourceFile, fixedNodes);
|
|
}
|
|
}
|
|
function applyChange(changeTracker, initializer, sourceFile, fixedNodes) {
|
|
if (!fixedNodes || tryAddToSet(fixedNodes, initializer)) {
|
|
changeTracker.insertModifierBefore(sourceFile, 85 /* ConstKeyword */, initializer);
|
|
}
|
|
}
|
|
function isPossiblyPartOfDestructuring(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function arrayElementCouldBeVariableDeclaration(expression, checker) {
|
|
const identifier = isIdentifier(expression) ? expression : isAssignmentExpression(expression, true) && isIdentifier(expression.left) ? expression.left : void 0;
|
|
return !!identifier && !checker.getSymbolAtLocation(identifier);
|
|
}
|
|
function isPossiblyPartOfCommaSeperatedInitializer(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 223 /* BinaryExpression */:
|
|
case 27 /* CommaToken */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function expressionCouldBeVariableDeclaration(expression, checker) {
|
|
if (!isBinaryExpression(expression)) {
|
|
return false;
|
|
}
|
|
if (expression.operatorToken.kind === 27 /* CommaToken */) {
|
|
return every([expression.left, expression.right], (expression2) => expressionCouldBeVariableDeclaration(expression2, checker));
|
|
}
|
|
return expression.operatorToken.kind === 63 /* EqualsToken */ && isIdentifier(expression.left) && !checker.getSymbolAtLocation(expression.left);
|
|
}
|
|
|
|
// src/services/codefixes/addMissingDeclareProperty.ts
|
|
var fixId5 = "addMissingDeclareProperty";
|
|
var errorCodes5 = [
|
|
Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes5,
|
|
getCodeActions: function getCodeActionsToAddMissingDeclareOnProperty(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange5(t, context.sourceFile, context.span.start));
|
|
if (changes.length > 0) {
|
|
return [createCodeFixAction(fixId5, changes, Diagnostics.Prefix_with_declare, fixId5, Diagnostics.Prefix_all_incorrect_property_declarations_with_declare)];
|
|
}
|
|
},
|
|
fixIds: [fixId5],
|
|
getAllCodeActions: (context) => {
|
|
const fixedNodes = /* @__PURE__ */ new Set();
|
|
return codeFixAll(context, errorCodes5, (changes, diag2) => makeChange5(changes, diag2.file, diag2.start, fixedNodes));
|
|
}
|
|
});
|
|
function makeChange5(changeTracker, sourceFile, pos, fixedNodes) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (!isIdentifier(token)) {
|
|
return;
|
|
}
|
|
const declaration = token.parent;
|
|
if (declaration.kind === 169 /* PropertyDeclaration */ && (!fixedNodes || tryAddToSet(fixedNodes, declaration))) {
|
|
changeTracker.insertModifierBefore(sourceFile, 136 /* DeclareKeyword */, declaration);
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/addMissingInvocationForDecorator.ts
|
|
var fixId6 = "addMissingInvocationForDecorator";
|
|
var errorCodes6 = [Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes6,
|
|
getCodeActions: function getCodeActionsToAddMissingInvocationForDecorator(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange6(t, context.sourceFile, context.span.start));
|
|
return [createCodeFixAction(fixId6, changes, Diagnostics.Call_decorator_expression, fixId6, Diagnostics.Add_to_all_uncalled_decorators)];
|
|
},
|
|
fixIds: [fixId6],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes6, (changes, diag2) => makeChange6(changes, diag2.file, diag2.start))
|
|
});
|
|
function makeChange6(changeTracker, sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const decorator = findAncestor(token, isDecorator);
|
|
Debug.assert(!!decorator, "Expected position to be owned by a decorator.");
|
|
const replacement = factory.createCallExpression(decorator.expression, void 0, void 0);
|
|
changeTracker.replaceNode(sourceFile, decorator.expression, replacement);
|
|
}
|
|
|
|
// src/services/codefixes/addNameToNamelessParameter.ts
|
|
var fixId7 = "addNameToNamelessParameter";
|
|
var errorCodes7 = [Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes7,
|
|
getCodeActions: function getCodeActionsToAddNameToNamelessParameter(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange7(t, context.sourceFile, context.span.start));
|
|
return [createCodeFixAction(fixId7, changes, Diagnostics.Add_parameter_name, fixId7, Diagnostics.Add_names_to_all_parameters_without_names)];
|
|
},
|
|
fixIds: [fixId7],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes7, (changes, diag2) => makeChange7(changes, diag2.file, diag2.start))
|
|
});
|
|
function makeChange7(changeTracker, sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const param = token.parent;
|
|
if (!isParameter(param)) {
|
|
return Debug.fail("Tried to add a parameter name to a non-parameter: " + Debug.formatSyntaxKind(token.kind));
|
|
}
|
|
const i = param.parent.parameters.indexOf(param);
|
|
Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one.");
|
|
Debug.assert(i > -1, "Parameter not found in parent parameter list.");
|
|
const typeNode = factory.createTypeReferenceNode(param.name, void 0);
|
|
const replacement = factory.createParameterDeclaration(
|
|
param.modifiers,
|
|
param.dotDotDotToken,
|
|
"arg" + i,
|
|
param.questionToken,
|
|
param.dotDotDotToken ? factory.createArrayTypeNode(typeNode) : typeNode,
|
|
param.initializer
|
|
);
|
|
changeTracker.replaceNode(sourceFile, param, replacement);
|
|
}
|
|
|
|
// src/services/codefixes/addOptionalPropertyUndefined.ts
|
|
var addOptionalPropertyUndefined = "addOptionalPropertyUndefined";
|
|
var errorCodes8 = [
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes8,
|
|
getCodeActions(context) {
|
|
const typeChecker = context.program.getTypeChecker();
|
|
const toAdd = getPropertiesToAdd(context.sourceFile, context.span, typeChecker);
|
|
if (!toAdd.length) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addUndefinedToOptionalProperty(t, toAdd));
|
|
return [createCodeFixActionWithoutFixAll(addOptionalPropertyUndefined, changes, Diagnostics.Add_undefined_to_optional_property_type)];
|
|
},
|
|
fixIds: [addOptionalPropertyUndefined]
|
|
});
|
|
function getPropertiesToAdd(file, span, checker) {
|
|
var _a2, _b;
|
|
const sourceTarget = getSourceTarget(getFixableErrorSpanExpression(file, span), checker);
|
|
if (!sourceTarget) {
|
|
return emptyArray;
|
|
}
|
|
const { source: sourceNode, target: targetNode } = sourceTarget;
|
|
const target = shouldUseParentTypeOfProperty(sourceNode, targetNode, checker) ? checker.getTypeAtLocation(targetNode.expression) : checker.getTypeAtLocation(targetNode);
|
|
if ((_b = (_a2 = target.symbol) == null ? void 0 : _a2.declarations) == null ? void 0 : _b.some((d) => getSourceFileOfNode(d).fileName.match(/\.d\.ts$/))) {
|
|
return emptyArray;
|
|
}
|
|
return checker.getExactOptionalProperties(target);
|
|
}
|
|
function shouldUseParentTypeOfProperty(sourceNode, targetNode, checker) {
|
|
return isPropertyAccessExpression(targetNode) && !!checker.getExactOptionalProperties(checker.getTypeAtLocation(targetNode.expression)).length && checker.getTypeAtLocation(sourceNode) === checker.getUndefinedType();
|
|
}
|
|
function getSourceTarget(errorNode, checker) {
|
|
var _a2;
|
|
if (!errorNode) {
|
|
return void 0;
|
|
} else if (isBinaryExpression(errorNode.parent) && errorNode.parent.operatorToken.kind === 63 /* EqualsToken */) {
|
|
return { source: errorNode.parent.right, target: errorNode.parent.left };
|
|
} else if (isVariableDeclaration(errorNode.parent) && errorNode.parent.initializer) {
|
|
return { source: errorNode.parent.initializer, target: errorNode.parent.name };
|
|
} else if (isCallExpression(errorNode.parent)) {
|
|
const n = checker.getSymbolAtLocation(errorNode.parent.expression);
|
|
if (!(n == null ? void 0 : n.valueDeclaration) || !isFunctionLikeKind(n.valueDeclaration.kind))
|
|
return void 0;
|
|
if (!isExpression(errorNode))
|
|
return void 0;
|
|
const i = errorNode.parent.arguments.indexOf(errorNode);
|
|
if (i === -1)
|
|
return void 0;
|
|
const name = n.valueDeclaration.parameters[i].name;
|
|
if (isIdentifier(name))
|
|
return { source: errorNode, target: name };
|
|
} else if (isPropertyAssignment(errorNode.parent) && isIdentifier(errorNode.parent.name) || isShorthandPropertyAssignment(errorNode.parent)) {
|
|
const parentTarget = getSourceTarget(errorNode.parent.parent, checker);
|
|
if (!parentTarget)
|
|
return void 0;
|
|
const prop = checker.getPropertyOfType(checker.getTypeAtLocation(parentTarget.target), errorNode.parent.name.text);
|
|
const declaration = (_a2 = prop == null ? void 0 : prop.declarations) == null ? void 0 : _a2[0];
|
|
if (!declaration)
|
|
return void 0;
|
|
return {
|
|
source: isPropertyAssignment(errorNode.parent) ? errorNode.parent.initializer : errorNode.parent.name,
|
|
target: declaration
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function addUndefinedToOptionalProperty(changes, toAdd) {
|
|
for (const add of toAdd) {
|
|
const d = add.valueDeclaration;
|
|
if (d && (isPropertySignature(d) || isPropertyDeclaration(d)) && d.type) {
|
|
const t = factory.createUnionTypeNode([
|
|
...d.type.kind === 189 /* UnionType */ ? d.type.types : [d.type],
|
|
factory.createTypeReferenceNode("undefined")
|
|
]);
|
|
changes.replaceNode(d.getSourceFile(), d.type, t);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/annotateWithTypeFromJSDoc.ts
|
|
var fixId8 = "annotateWithTypeFromJSDoc";
|
|
var errorCodes9 = [Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes9,
|
|
getCodeActions(context) {
|
|
const decl = getDeclaration(context.sourceFile, context.span.start);
|
|
if (!decl)
|
|
return;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange(t, context.sourceFile, decl));
|
|
return [createCodeFixAction(fixId8, changes, Diagnostics.Annotate_with_type_from_JSDoc, fixId8, Diagnostics.Annotate_everything_with_types_from_JSDoc)];
|
|
},
|
|
fixIds: [fixId8],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes9, (changes, diag2) => {
|
|
const decl = getDeclaration(diag2.file, diag2.start);
|
|
if (decl)
|
|
doChange(changes, diag2.file, decl);
|
|
})
|
|
});
|
|
function getDeclaration(file, pos) {
|
|
const name = getTokenAtPosition(file, pos);
|
|
return tryCast(isParameter(name.parent) ? name.parent.parent : name.parent, parameterShouldGetTypeFromJSDoc);
|
|
}
|
|
function parameterShouldGetTypeFromJSDoc(node) {
|
|
return isDeclarationWithType(node) && hasUsableJSDoc(node);
|
|
}
|
|
function hasUsableJSDoc(decl) {
|
|
return isFunctionLikeDeclaration(decl) ? decl.parameters.some(hasUsableJSDoc) || !decl.type && !!getJSDocReturnType(decl) : !decl.type && !!getJSDocType(decl);
|
|
}
|
|
function doChange(changes, sourceFile, decl) {
|
|
if (isFunctionLikeDeclaration(decl) && (getJSDocReturnType(decl) || decl.parameters.some((p) => !!getJSDocType(p)))) {
|
|
if (!decl.typeParameters) {
|
|
const typeParameters = getJSDocTypeParameterDeclarations(decl);
|
|
if (typeParameters.length)
|
|
changes.insertTypeParameters(sourceFile, decl, typeParameters);
|
|
}
|
|
const needParens = isArrowFunction(decl) && !findChildOfKind(decl, 20 /* OpenParenToken */, sourceFile);
|
|
if (needParens)
|
|
changes.insertNodeBefore(sourceFile, first(decl.parameters), factory.createToken(20 /* OpenParenToken */));
|
|
for (const param of decl.parameters) {
|
|
if (!param.type) {
|
|
const paramType = getJSDocType(param);
|
|
if (paramType)
|
|
changes.tryInsertTypeAnnotation(sourceFile, param, transformJSDocType(paramType));
|
|
}
|
|
}
|
|
if (needParens)
|
|
changes.insertNodeAfter(sourceFile, last(decl.parameters), factory.createToken(21 /* CloseParenToken */));
|
|
if (!decl.type) {
|
|
const returnType = getJSDocReturnType(decl);
|
|
if (returnType)
|
|
changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(returnType));
|
|
}
|
|
} else {
|
|
const jsdocType = Debug.checkDefined(getJSDocType(decl), "A JSDocType for this declaration should exist");
|
|
Debug.assert(!decl.type, "The JSDocType decl should have a type");
|
|
changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(jsdocType));
|
|
}
|
|
}
|
|
function isDeclarationWithType(node) {
|
|
return isFunctionLikeDeclaration(node) || node.kind === 257 /* VariableDeclaration */ || node.kind === 168 /* PropertySignature */ || node.kind === 169 /* PropertyDeclaration */;
|
|
}
|
|
function transformJSDocType(node) {
|
|
switch (node.kind) {
|
|
case 315 /* JSDocAllType */:
|
|
case 316 /* JSDocUnknownType */:
|
|
return factory.createTypeReferenceNode("any", emptyArray);
|
|
case 319 /* JSDocOptionalType */:
|
|
return transformJSDocOptionalType(node);
|
|
case 318 /* JSDocNonNullableType */:
|
|
return transformJSDocType(node.type);
|
|
case 317 /* JSDocNullableType */:
|
|
return transformJSDocNullableType(node);
|
|
case 321 /* JSDocVariadicType */:
|
|
return transformJSDocVariadicType(node);
|
|
case 320 /* JSDocFunctionType */:
|
|
return transformJSDocFunctionType(node);
|
|
case 180 /* TypeReference */:
|
|
return transformJSDocTypeReference(node);
|
|
case 325 /* JSDocTypeLiteral */:
|
|
return transformJSDocTypeLiteral(node);
|
|
default:
|
|
const visited = visitEachChild(node, transformJSDocType, nullTransformationContext);
|
|
setEmitFlags(visited, 1 /* SingleLine */);
|
|
return visited;
|
|
}
|
|
}
|
|
function transformJSDocTypeLiteral(node) {
|
|
const typeNode = factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (tag) => factory.createPropertySignature(
|
|
void 0,
|
|
isIdentifier(tag.name) ? tag.name : tag.name.right,
|
|
isOptionalJSDocPropertyLikeTag(tag) ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
tag.typeExpression && visitNode(tag.typeExpression.type, transformJSDocType) || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
)));
|
|
setEmitFlags(typeNode, 1 /* SingleLine */);
|
|
return typeNode;
|
|
}
|
|
function transformJSDocOptionalType(node) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, transformJSDocType), factory.createTypeReferenceNode("undefined", emptyArray)]);
|
|
}
|
|
function transformJSDocNullableType(node) {
|
|
return factory.createUnionTypeNode([visitNode(node.type, transformJSDocType), factory.createTypeReferenceNode("null", emptyArray)]);
|
|
}
|
|
function transformJSDocVariadicType(node) {
|
|
return factory.createArrayTypeNode(visitNode(node.type, transformJSDocType));
|
|
}
|
|
function transformJSDocFunctionType(node) {
|
|
var _a2;
|
|
return factory.createFunctionTypeNode(emptyArray, node.parameters.map(transformJSDocParameter), (_a2 = node.type) != null ? _a2 : factory.createKeywordTypeNode(131 /* AnyKeyword */));
|
|
}
|
|
function transformJSDocParameter(node) {
|
|
const index = node.parent.parameters.indexOf(node);
|
|
const isRest = node.type.kind === 321 /* JSDocVariadicType */ && index === node.parent.parameters.length - 1;
|
|
const name = node.name || (isRest ? "rest" : "arg" + index);
|
|
const dotdotdot = isRest ? factory.createToken(25 /* DotDotDotToken */) : node.dotDotDotToken;
|
|
return factory.createParameterDeclaration(node.modifiers, dotdotdot, name, node.questionToken, visitNode(node.type, transformJSDocType), node.initializer);
|
|
}
|
|
function transformJSDocTypeReference(node) {
|
|
let name = node.typeName;
|
|
let args = node.typeArguments;
|
|
if (isIdentifier(node.typeName)) {
|
|
if (isJSDocIndexSignature(node)) {
|
|
return transformJSDocIndexSignature(node);
|
|
}
|
|
let text = node.typeName.text;
|
|
switch (node.typeName.text) {
|
|
case "String":
|
|
case "Boolean":
|
|
case "Object":
|
|
case "Number":
|
|
text = text.toLowerCase();
|
|
break;
|
|
case "array":
|
|
case "date":
|
|
case "promise":
|
|
text = text[0].toUpperCase() + text.slice(1);
|
|
break;
|
|
}
|
|
name = factory.createIdentifier(text);
|
|
if ((text === "Array" || text === "Promise") && !node.typeArguments) {
|
|
args = factory.createNodeArray([factory.createTypeReferenceNode("any", emptyArray)]);
|
|
} else {
|
|
args = visitNodes2(node.typeArguments, transformJSDocType);
|
|
}
|
|
}
|
|
return factory.createTypeReferenceNode(name, args);
|
|
}
|
|
function transformJSDocIndexSignature(node) {
|
|
const index = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
node.typeArguments[0].kind === 148 /* NumberKeyword */ ? "n" : "s",
|
|
void 0,
|
|
factory.createTypeReferenceNode(node.typeArguments[0].kind === 148 /* NumberKeyword */ ? "number" : "string", []),
|
|
void 0
|
|
);
|
|
const indexSignature = factory.createTypeLiteralNode([factory.createIndexSignature(void 0, [index], node.typeArguments[1])]);
|
|
setEmitFlags(indexSignature, 1 /* SingleLine */);
|
|
return indexSignature;
|
|
}
|
|
|
|
// src/services/codefixes/convertFunctionToEs6Class.ts
|
|
var fixId9 = "convertFunctionToEs6Class";
|
|
var errorCodes10 = [Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes10,
|
|
getCodeActions(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange2(t, context.sourceFile, context.span.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()));
|
|
return [createCodeFixAction(fixId9, changes, Diagnostics.Convert_function_to_an_ES2015_class, fixId9, Diagnostics.Convert_all_constructor_functions_to_classes)];
|
|
},
|
|
fixIds: [fixId9],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes10, (changes, err) => doChange2(changes, err.file, err.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()))
|
|
});
|
|
function doChange2(changes, sourceFile, position, checker, preferences, compilerOptions) {
|
|
const ctorSymbol = checker.getSymbolAtLocation(getTokenAtPosition(sourceFile, position));
|
|
if (!ctorSymbol || !ctorSymbol.valueDeclaration || !(ctorSymbol.flags & (16 /* Function */ | 3 /* Variable */))) {
|
|
return void 0;
|
|
}
|
|
const ctorDeclaration = ctorSymbol.valueDeclaration;
|
|
if (isFunctionDeclaration(ctorDeclaration) || isFunctionExpression(ctorDeclaration)) {
|
|
changes.replaceNode(sourceFile, ctorDeclaration, createClassFromFunction(ctorDeclaration));
|
|
} else if (isVariableDeclaration(ctorDeclaration)) {
|
|
const classDeclaration = createClassFromVariableDeclaration(ctorDeclaration);
|
|
if (!classDeclaration) {
|
|
return void 0;
|
|
}
|
|
const ancestor = ctorDeclaration.parent.parent;
|
|
if (isVariableDeclarationList(ctorDeclaration.parent) && ctorDeclaration.parent.declarations.length > 1) {
|
|
changes.delete(sourceFile, ctorDeclaration);
|
|
changes.insertNodeAfter(sourceFile, ancestor, classDeclaration);
|
|
} else {
|
|
changes.replaceNode(sourceFile, ancestor, classDeclaration);
|
|
}
|
|
}
|
|
function createClassElementsFromSymbol(symbol) {
|
|
const memberElements = [];
|
|
if (symbol.exports) {
|
|
symbol.exports.forEach((member) => {
|
|
if (member.name === "prototype" && member.declarations) {
|
|
const firstDeclaration = member.declarations[0];
|
|
if (member.declarations.length === 1 && isPropertyAccessExpression(firstDeclaration) && isBinaryExpression(firstDeclaration.parent) && firstDeclaration.parent.operatorToken.kind === 63 /* EqualsToken */ && isObjectLiteralExpression(firstDeclaration.parent.right)) {
|
|
const prototypes = firstDeclaration.parent.right;
|
|
createClassElement(prototypes.symbol, void 0, memberElements);
|
|
}
|
|
} else {
|
|
createClassElement(member, [factory.createToken(124 /* StaticKeyword */)], memberElements);
|
|
}
|
|
});
|
|
}
|
|
if (symbol.members) {
|
|
symbol.members.forEach((member, key) => {
|
|
var _a2, _b, _c, _d;
|
|
if (key === "constructor" && member.valueDeclaration) {
|
|
const prototypeAssignment = (_d = (_c = (_b = (_a2 = symbol.exports) == null ? void 0 : _a2.get("prototype")) == null ? void 0 : _b.declarations) == null ? void 0 : _c[0]) == null ? void 0 : _d.parent;
|
|
if (prototypeAssignment && isBinaryExpression(prototypeAssignment) && isObjectLiteralExpression(prototypeAssignment.right) && some(prototypeAssignment.right.properties, isConstructorAssignment)) {
|
|
} else {
|
|
changes.delete(sourceFile, member.valueDeclaration.parent);
|
|
}
|
|
return;
|
|
}
|
|
createClassElement(member, void 0, memberElements);
|
|
});
|
|
}
|
|
return memberElements;
|
|
function shouldConvertDeclaration(_target, source) {
|
|
if (isAccessExpression(_target)) {
|
|
if (isPropertyAccessExpression(_target) && isConstructorAssignment(_target))
|
|
return true;
|
|
return isFunctionLike(source);
|
|
} else {
|
|
return every(_target.properties, (property) => {
|
|
if (isMethodDeclaration(property) || isGetOrSetAccessorDeclaration(property))
|
|
return true;
|
|
if (isPropertyAssignment(property) && isFunctionExpression(property.initializer) && !!property.name)
|
|
return true;
|
|
if (isConstructorAssignment(property))
|
|
return true;
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
function createClassElement(symbol2, modifiers, members) {
|
|
if (!(symbol2.flags & 8192 /* Method */) && !(symbol2.flags & 4096 /* ObjectLiteral */)) {
|
|
return;
|
|
}
|
|
const memberDeclaration = symbol2.valueDeclaration;
|
|
const assignmentBinaryExpression = memberDeclaration.parent;
|
|
const assignmentExpr = assignmentBinaryExpression.right;
|
|
if (!shouldConvertDeclaration(memberDeclaration, assignmentExpr)) {
|
|
return;
|
|
}
|
|
if (some(members, (m) => {
|
|
const name = getNameOfDeclaration(m);
|
|
if (name && isIdentifier(name) && idText(name) === symbolName(symbol2)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
})) {
|
|
return;
|
|
}
|
|
const nodeToDelete = assignmentBinaryExpression.parent && assignmentBinaryExpression.parent.kind === 241 /* ExpressionStatement */ ? assignmentBinaryExpression.parent : assignmentBinaryExpression;
|
|
changes.delete(sourceFile, nodeToDelete);
|
|
if (!assignmentExpr) {
|
|
members.push(factory.createPropertyDeclaration(
|
|
modifiers,
|
|
symbol2.name,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
));
|
|
return;
|
|
}
|
|
if (isAccessExpression(memberDeclaration) && (isFunctionExpression(assignmentExpr) || isArrowFunction(assignmentExpr))) {
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
const name = tryGetPropertyName(memberDeclaration, compilerOptions, quotePreference);
|
|
if (name) {
|
|
createFunctionLikeExpressionMember(members, assignmentExpr, name);
|
|
}
|
|
return;
|
|
} else if (isObjectLiteralExpression(assignmentExpr)) {
|
|
forEach(
|
|
assignmentExpr.properties,
|
|
(property) => {
|
|
if (isMethodDeclaration(property) || isGetOrSetAccessorDeclaration(property)) {
|
|
members.push(property);
|
|
}
|
|
if (isPropertyAssignment(property) && isFunctionExpression(property.initializer)) {
|
|
createFunctionLikeExpressionMember(members, property.initializer, property.name);
|
|
}
|
|
if (isConstructorAssignment(property))
|
|
return;
|
|
return;
|
|
}
|
|
);
|
|
return;
|
|
} else {
|
|
if (isSourceFileJS(sourceFile))
|
|
return;
|
|
if (!isPropertyAccessExpression(memberDeclaration))
|
|
return;
|
|
const prop = factory.createPropertyDeclaration(modifiers, memberDeclaration.name, void 0, void 0, assignmentExpr);
|
|
copyLeadingComments(assignmentBinaryExpression.parent, prop, sourceFile);
|
|
members.push(prop);
|
|
return;
|
|
}
|
|
function createFunctionLikeExpressionMember(members2, expression, name) {
|
|
if (isFunctionExpression(expression))
|
|
return createFunctionExpressionMember(members2, expression, name);
|
|
else
|
|
return createArrowFunctionExpressionMember(members2, expression, name);
|
|
}
|
|
function createFunctionExpressionMember(members2, functionExpression, name) {
|
|
const fullModifiers = concatenate(modifiers, getModifierKindFromSource(functionExpression, 132 /* AsyncKeyword */));
|
|
const method = factory.createMethodDeclaration(
|
|
fullModifiers,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
void 0,
|
|
functionExpression.parameters,
|
|
void 0,
|
|
functionExpression.body
|
|
);
|
|
copyLeadingComments(assignmentBinaryExpression, method, sourceFile);
|
|
members2.push(method);
|
|
return;
|
|
}
|
|
function createArrowFunctionExpressionMember(members2, arrowFunction, name) {
|
|
const arrowFunctionBody = arrowFunction.body;
|
|
let bodyBlock;
|
|
if (arrowFunctionBody.kind === 238 /* Block */) {
|
|
bodyBlock = arrowFunctionBody;
|
|
} else {
|
|
bodyBlock = factory.createBlock([factory.createReturnStatement(arrowFunctionBody)]);
|
|
}
|
|
const fullModifiers = concatenate(modifiers, getModifierKindFromSource(arrowFunction, 132 /* AsyncKeyword */));
|
|
const method = factory.createMethodDeclaration(
|
|
fullModifiers,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
void 0,
|
|
arrowFunction.parameters,
|
|
void 0,
|
|
bodyBlock
|
|
);
|
|
copyLeadingComments(assignmentBinaryExpression, method, sourceFile);
|
|
members2.push(method);
|
|
}
|
|
}
|
|
}
|
|
function createClassFromVariableDeclaration(node) {
|
|
const initializer = node.initializer;
|
|
if (!initializer || !isFunctionExpression(initializer) || !isIdentifier(node.name)) {
|
|
return void 0;
|
|
}
|
|
const memberElements = createClassElementsFromSymbol(node.symbol);
|
|
if (initializer.body) {
|
|
memberElements.unshift(factory.createConstructorDeclaration(void 0, initializer.parameters, initializer.body));
|
|
}
|
|
const modifiers = getModifierKindFromSource(node.parent.parent, 93 /* ExportKeyword */);
|
|
const cls = factory.createClassDeclaration(
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
memberElements
|
|
);
|
|
return cls;
|
|
}
|
|
function createClassFromFunction(node) {
|
|
const memberElements = createClassElementsFromSymbol(ctorSymbol);
|
|
if (node.body) {
|
|
memberElements.unshift(factory.createConstructorDeclaration(void 0, node.parameters, node.body));
|
|
}
|
|
const modifiers = getModifierKindFromSource(node, 93 /* ExportKeyword */);
|
|
const cls = factory.createClassDeclaration(
|
|
modifiers,
|
|
node.name,
|
|
void 0,
|
|
void 0,
|
|
memberElements
|
|
);
|
|
return cls;
|
|
}
|
|
}
|
|
function getModifierKindFromSource(source, kind) {
|
|
return canHaveModifiers(source) ? filter(source.modifiers, (modifier) => modifier.kind === kind) : void 0;
|
|
}
|
|
function isConstructorAssignment(x) {
|
|
if (!x.name)
|
|
return false;
|
|
if (isIdentifier(x.name) && x.name.text === "constructor")
|
|
return true;
|
|
return false;
|
|
}
|
|
function tryGetPropertyName(node, compilerOptions, quotePreference) {
|
|
if (isPropertyAccessExpression(node)) {
|
|
return node.name;
|
|
}
|
|
const propName = node.argumentExpression;
|
|
if (isNumericLiteral(propName)) {
|
|
return propName;
|
|
}
|
|
if (isStringLiteralLike(propName)) {
|
|
return isIdentifierText(propName.text, getEmitScriptTarget(compilerOptions)) ? factory.createIdentifier(propName.text) : isNoSubstitutionTemplateLiteral(propName) ? factory.createStringLiteral(propName.text, quotePreference === 0 /* Single */) : propName;
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/services/codefixes/convertToAsyncFunction.ts
|
|
var fixId10 = "convertToAsyncFunction";
|
|
var errorCodes11 = [Diagnostics.This_may_be_converted_to_an_async_function.code];
|
|
var codeActionSucceeded = true;
|
|
registerCodeFix({
|
|
errorCodes: errorCodes11,
|
|
getCodeActions(context) {
|
|
codeActionSucceeded = true;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => convertToAsyncFunction(t, context.sourceFile, context.span.start, context.program.getTypeChecker()));
|
|
return codeActionSucceeded ? [createCodeFixAction(fixId10, changes, Diagnostics.Convert_to_async_function, fixId10, Diagnostics.Convert_all_to_async_functions)] : [];
|
|
},
|
|
fixIds: [fixId10],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes11, (changes, err) => convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker()))
|
|
});
|
|
function convertToAsyncFunction(changes, sourceFile, position, checker) {
|
|
const tokenAtPosition = getTokenAtPosition(sourceFile, position);
|
|
let functionToConvert;
|
|
if (isIdentifier(tokenAtPosition) && isVariableDeclaration(tokenAtPosition.parent) && tokenAtPosition.parent.initializer && isFunctionLikeDeclaration(tokenAtPosition.parent.initializer)) {
|
|
functionToConvert = tokenAtPosition.parent.initializer;
|
|
} else {
|
|
functionToConvert = tryCast(getContainingFunction(getTokenAtPosition(sourceFile, position)), canBeConvertedToAsync);
|
|
}
|
|
if (!functionToConvert) {
|
|
return;
|
|
}
|
|
const synthNamesMap = /* @__PURE__ */ new Map();
|
|
const isInJavascript = isInJSFile(functionToConvert);
|
|
const setOfExpressionsToReturn = getAllPromiseExpressionsToReturn(functionToConvert, checker);
|
|
const functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap);
|
|
if (!returnsPromise(functionToConvertRenamed, checker)) {
|
|
return;
|
|
}
|
|
const returnStatements = functionToConvertRenamed.body && isBlock(functionToConvertRenamed.body) ? getReturnStatementsWithPromiseHandlers(functionToConvertRenamed.body, checker) : emptyArray;
|
|
const transformer = { checker, synthNamesMap, setOfExpressionsToReturn, isInJSFile: isInJavascript };
|
|
if (!returnStatements.length) {
|
|
return;
|
|
}
|
|
const pos = skipTrivia(sourceFile.text, moveRangePastModifiers(functionToConvert).pos);
|
|
changes.insertModifierAt(sourceFile, pos, 132 /* AsyncKeyword */, { suffix: " " });
|
|
for (const returnStatement of returnStatements) {
|
|
forEachChild(returnStatement, function visit(node) {
|
|
if (isCallExpression(node)) {
|
|
const newNodes = transformExpression(node, node, transformer, false);
|
|
if (hasFailed()) {
|
|
return true;
|
|
}
|
|
changes.replaceNodeWithNodes(sourceFile, returnStatement, newNodes);
|
|
} else if (!isFunctionLike(node)) {
|
|
forEachChild(node, visit);
|
|
if (hasFailed()) {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
if (hasFailed()) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
function getReturnStatementsWithPromiseHandlers(body, checker) {
|
|
const res = [];
|
|
forEachReturnStatement(body, (ret) => {
|
|
if (isReturnStatementWithFixablePromiseHandler(ret, checker))
|
|
res.push(ret);
|
|
});
|
|
return res;
|
|
}
|
|
function getAllPromiseExpressionsToReturn(func, checker) {
|
|
if (!func.body) {
|
|
return /* @__PURE__ */ new Set();
|
|
}
|
|
const setOfExpressionsToReturn = /* @__PURE__ */ new Set();
|
|
forEachChild(func.body, function visit(node) {
|
|
if (isPromiseReturningCallExpression(node, checker, "then")) {
|
|
setOfExpressionsToReturn.add(getNodeId(node));
|
|
forEach(node.arguments, visit);
|
|
} else if (isPromiseReturningCallExpression(node, checker, "catch") || isPromiseReturningCallExpression(node, checker, "finally")) {
|
|
setOfExpressionsToReturn.add(getNodeId(node));
|
|
forEachChild(node, visit);
|
|
} else if (isPromiseTypedExpression(node, checker)) {
|
|
setOfExpressionsToReturn.add(getNodeId(node));
|
|
} else {
|
|
forEachChild(node, visit);
|
|
}
|
|
});
|
|
return setOfExpressionsToReturn;
|
|
}
|
|
function isPromiseReturningCallExpression(node, checker, name) {
|
|
if (!isCallExpression(node))
|
|
return false;
|
|
const isExpressionOfName = hasPropertyAccessExpressionWithName(node, name);
|
|
const nodeType = isExpressionOfName && checker.getTypeAtLocation(node);
|
|
return !!(nodeType && checker.getPromisedTypeOfPromise(nodeType));
|
|
}
|
|
function isReferenceToType(type, target) {
|
|
return (getObjectFlags(type) & 4 /* Reference */) !== 0 && type.target === target;
|
|
}
|
|
function getExplicitPromisedTypeOfPromiseReturningCallExpression(node, callback, checker) {
|
|
if (node.expression.name.escapedText === "finally") {
|
|
return void 0;
|
|
}
|
|
const promiseType = checker.getTypeAtLocation(node.expression.expression);
|
|
if (isReferenceToType(promiseType, checker.getPromiseType()) || isReferenceToType(promiseType, checker.getPromiseLikeType())) {
|
|
if (node.expression.name.escapedText === "then") {
|
|
if (callback === elementAt(node.arguments, 0)) {
|
|
return elementAt(node.typeArguments, 0);
|
|
} else if (callback === elementAt(node.arguments, 1)) {
|
|
return elementAt(node.typeArguments, 1);
|
|
}
|
|
} else {
|
|
return elementAt(node.typeArguments, 0);
|
|
}
|
|
}
|
|
}
|
|
function isPromiseTypedExpression(node, checker) {
|
|
if (!isExpression(node))
|
|
return false;
|
|
return !!checker.getPromisedTypeOfPromise(checker.getTypeAtLocation(node));
|
|
}
|
|
function renameCollidingVarNames(nodeToRename, checker, synthNamesMap) {
|
|
const identsToRenameMap = /* @__PURE__ */ new Map();
|
|
const collidingSymbolMap = createMultiMap();
|
|
forEachChild(nodeToRename, function visit(node) {
|
|
if (!isIdentifier(node)) {
|
|
forEachChild(node, visit);
|
|
return;
|
|
}
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
const type = checker.getTypeAtLocation(node);
|
|
const lastCallSignature = getLastCallSignature(type, checker);
|
|
const symbolIdString = getSymbolId(symbol).toString();
|
|
if (lastCallSignature && !isParameter(node.parent) && !isFunctionLikeDeclaration(node.parent) && !synthNamesMap.has(symbolIdString)) {
|
|
const firstParameter = firstOrUndefined(lastCallSignature.parameters);
|
|
const ident = (firstParameter == null ? void 0 : firstParameter.valueDeclaration) && isParameter(firstParameter.valueDeclaration) && tryCast(firstParameter.valueDeclaration.name, isIdentifier) || factory.createUniqueName("result", 16 /* Optimistic */);
|
|
const synthName = getNewNameIfConflict(ident, collidingSymbolMap);
|
|
synthNamesMap.set(symbolIdString, synthName);
|
|
collidingSymbolMap.add(ident.text, symbol);
|
|
} else if (node.parent && (isParameter(node.parent) || isVariableDeclaration(node.parent) || isBindingElement(node.parent))) {
|
|
const originalName = node.text;
|
|
const collidingSymbols = collidingSymbolMap.get(originalName);
|
|
if (collidingSymbols && collidingSymbols.some((prevSymbol) => prevSymbol !== symbol)) {
|
|
const newName = getNewNameIfConflict(node, collidingSymbolMap);
|
|
identsToRenameMap.set(symbolIdString, newName.identifier);
|
|
synthNamesMap.set(symbolIdString, newName);
|
|
collidingSymbolMap.add(originalName, symbol);
|
|
} else {
|
|
const identifier = getSynthesizedDeepClone(node);
|
|
synthNamesMap.set(symbolIdString, createSynthIdentifier(identifier));
|
|
collidingSymbolMap.add(originalName, symbol);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return getSynthesizedDeepCloneWithReplacements(nodeToRename, true, (original) => {
|
|
if (isBindingElement(original) && isIdentifier(original.name) && isObjectBindingPattern(original.parent)) {
|
|
const symbol = checker.getSymbolAtLocation(original.name);
|
|
const renameInfo = symbol && identsToRenameMap.get(String(getSymbolId(symbol)));
|
|
if (renameInfo && renameInfo.text !== (original.name || original.propertyName).getText()) {
|
|
return factory.createBindingElement(
|
|
original.dotDotDotToken,
|
|
original.propertyName || original.name,
|
|
renameInfo,
|
|
original.initializer
|
|
);
|
|
}
|
|
} else if (isIdentifier(original)) {
|
|
const symbol = checker.getSymbolAtLocation(original);
|
|
const renameInfo = symbol && identsToRenameMap.get(String(getSymbolId(symbol)));
|
|
if (renameInfo) {
|
|
return factory.createIdentifier(renameInfo.text);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function getNewNameIfConflict(name, originalNames) {
|
|
const numVarsSameName = (originalNames.get(name.text) || emptyArray).length;
|
|
const identifier = numVarsSameName === 0 ? name : factory.createIdentifier(name.text + "_" + numVarsSameName);
|
|
return createSynthIdentifier(identifier);
|
|
}
|
|
function hasFailed() {
|
|
return !codeActionSucceeded;
|
|
}
|
|
function silentFail() {
|
|
codeActionSucceeded = false;
|
|
return emptyArray;
|
|
}
|
|
function transformExpression(returnContextNode, node, transformer, hasContinuation, continuationArgName) {
|
|
if (isPromiseReturningCallExpression(node, transformer.checker, "then")) {
|
|
return transformThen(node, elementAt(node.arguments, 0), elementAt(node.arguments, 1), transformer, hasContinuation, continuationArgName);
|
|
}
|
|
if (isPromiseReturningCallExpression(node, transformer.checker, "catch")) {
|
|
return transformCatch(node, elementAt(node.arguments, 0), transformer, hasContinuation, continuationArgName);
|
|
}
|
|
if (isPromiseReturningCallExpression(node, transformer.checker, "finally")) {
|
|
return transformFinally(node, elementAt(node.arguments, 0), transformer, hasContinuation, continuationArgName);
|
|
}
|
|
if (isPropertyAccessExpression(node)) {
|
|
return transformExpression(returnContextNode, node.expression, transformer, hasContinuation, continuationArgName);
|
|
}
|
|
const nodeType = transformer.checker.getTypeAtLocation(node);
|
|
if (nodeType && transformer.checker.getPromisedTypeOfPromise(nodeType)) {
|
|
Debug.assertNode(getOriginalNode(node).parent, isPropertyAccessExpression);
|
|
return transformPromiseExpressionOfPropertyAccess(returnContextNode, node, transformer, hasContinuation, continuationArgName);
|
|
}
|
|
return silentFail();
|
|
}
|
|
function isNullOrUndefined2({ checker }, node) {
|
|
if (node.kind === 104 /* NullKeyword */)
|
|
return true;
|
|
if (isIdentifier(node) && !isGeneratedIdentifier(node) && idText(node) === "undefined") {
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
return !symbol || checker.isUndefinedSymbol(symbol);
|
|
}
|
|
return false;
|
|
}
|
|
function createUniqueSynthName(prevArgName) {
|
|
const renamedPrevArg = factory.createUniqueName(prevArgName.identifier.text, 16 /* Optimistic */);
|
|
return createSynthIdentifier(renamedPrevArg);
|
|
}
|
|
function getPossibleNameForVarDecl(node, transformer, continuationArgName) {
|
|
let possibleNameForVarDecl;
|
|
if (continuationArgName && !shouldReturn(node, transformer)) {
|
|
if (isSynthIdentifier(continuationArgName)) {
|
|
possibleNameForVarDecl = continuationArgName;
|
|
transformer.synthNamesMap.forEach((val, key) => {
|
|
if (val.identifier.text === continuationArgName.identifier.text) {
|
|
const newSynthName = createUniqueSynthName(continuationArgName);
|
|
transformer.synthNamesMap.set(key, newSynthName);
|
|
}
|
|
});
|
|
} else {
|
|
possibleNameForVarDecl = createSynthIdentifier(factory.createUniqueName("result", 16 /* Optimistic */), continuationArgName.types);
|
|
}
|
|
declareSynthIdentifier(possibleNameForVarDecl);
|
|
}
|
|
return possibleNameForVarDecl;
|
|
}
|
|
function finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName) {
|
|
const statements = [];
|
|
let varDeclIdentifier;
|
|
if (possibleNameForVarDecl && !shouldReturn(node, transformer)) {
|
|
varDeclIdentifier = getSynthesizedDeepClone(declareSynthIdentifier(possibleNameForVarDecl));
|
|
const typeArray = possibleNameForVarDecl.types;
|
|
const unionType = transformer.checker.getUnionType(typeArray, 2 /* Subtype */);
|
|
const unionTypeNode = transformer.isInJSFile ? void 0 : transformer.checker.typeToTypeNode(unionType, void 0, void 0);
|
|
const varDecl = [factory.createVariableDeclaration(varDeclIdentifier, void 0, unionTypeNode)];
|
|
const varDeclList = factory.createVariableStatement(void 0, factory.createVariableDeclarationList(varDecl, 1 /* Let */));
|
|
statements.push(varDeclList);
|
|
}
|
|
statements.push(tryStatement);
|
|
if (continuationArgName && varDeclIdentifier && isSynthBindingPattern(continuationArgName)) {
|
|
statements.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[
|
|
factory.createVariableDeclaration(
|
|
getSynthesizedDeepClone(declareSynthBindingPattern(continuationArgName)),
|
|
void 0,
|
|
void 0,
|
|
varDeclIdentifier
|
|
)
|
|
],
|
|
2 /* Const */
|
|
)
|
|
));
|
|
}
|
|
return statements;
|
|
}
|
|
function transformFinally(node, onFinally, transformer, hasContinuation, continuationArgName) {
|
|
if (!onFinally || isNullOrUndefined2(transformer, onFinally)) {
|
|
return transformExpression(node, node.expression.expression, transformer, hasContinuation, continuationArgName);
|
|
}
|
|
const possibleNameForVarDecl = getPossibleNameForVarDecl(node, transformer, continuationArgName);
|
|
const inlinedLeftHandSide = transformExpression(node, node.expression.expression, transformer, true, possibleNameForVarDecl);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
const inlinedCallback = transformCallbackArgument(onFinally, hasContinuation, void 0, void 0, node, transformer);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
const tryBlock = factory.createBlock(inlinedLeftHandSide);
|
|
const finallyBlock = factory.createBlock(inlinedCallback);
|
|
const tryStatement = factory.createTryStatement(tryBlock, void 0, finallyBlock);
|
|
return finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName);
|
|
}
|
|
function transformCatch(node, onRejected, transformer, hasContinuation, continuationArgName) {
|
|
if (!onRejected || isNullOrUndefined2(transformer, onRejected)) {
|
|
return transformExpression(node, node.expression.expression, transformer, hasContinuation, continuationArgName);
|
|
}
|
|
const inputArgName = getArgBindingName(onRejected, transformer);
|
|
const possibleNameForVarDecl = getPossibleNameForVarDecl(node, transformer, continuationArgName);
|
|
const inlinedLeftHandSide = transformExpression(node, node.expression.expression, transformer, true, possibleNameForVarDecl);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
const inlinedCallback = transformCallbackArgument(onRejected, hasContinuation, possibleNameForVarDecl, inputArgName, node, transformer);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
const tryBlock = factory.createBlock(inlinedLeftHandSide);
|
|
const catchClause = factory.createCatchClause(inputArgName && getSynthesizedDeepClone(declareSynthBindingName(inputArgName)), factory.createBlock(inlinedCallback));
|
|
const tryStatement = factory.createTryStatement(tryBlock, catchClause, void 0);
|
|
return finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName);
|
|
}
|
|
function transformThen(node, onFulfilled, onRejected, transformer, hasContinuation, continuationArgName) {
|
|
if (!onFulfilled || isNullOrUndefined2(transformer, onFulfilled)) {
|
|
return transformCatch(node, onRejected, transformer, hasContinuation, continuationArgName);
|
|
}
|
|
if (onRejected && !isNullOrUndefined2(transformer, onRejected)) {
|
|
return silentFail();
|
|
}
|
|
const inputArgName = getArgBindingName(onFulfilled, transformer);
|
|
const inlinedLeftHandSide = transformExpression(node.expression.expression, node.expression.expression, transformer, true, inputArgName);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
const inlinedCallback = transformCallbackArgument(onFulfilled, hasContinuation, continuationArgName, inputArgName, node, transformer);
|
|
if (hasFailed())
|
|
return silentFail();
|
|
return concatenate(inlinedLeftHandSide, inlinedCallback);
|
|
}
|
|
function transformPromiseExpressionOfPropertyAccess(returnContextNode, node, transformer, hasContinuation, continuationArgName) {
|
|
if (shouldReturn(returnContextNode, transformer)) {
|
|
let returnValue = getSynthesizedDeepClone(node);
|
|
if (hasContinuation) {
|
|
returnValue = factory.createAwaitExpression(returnValue);
|
|
}
|
|
return [factory.createReturnStatement(returnValue)];
|
|
}
|
|
return createVariableOrAssignmentOrExpressionStatement(continuationArgName, factory.createAwaitExpression(node), void 0);
|
|
}
|
|
function createVariableOrAssignmentOrExpressionStatement(variableName, rightHandSide, typeAnnotation) {
|
|
if (!variableName || isEmptyBindingName(variableName)) {
|
|
return [factory.createExpressionStatement(rightHandSide)];
|
|
}
|
|
if (isSynthIdentifier(variableName) && variableName.hasBeenDeclared) {
|
|
return [factory.createExpressionStatement(factory.createAssignment(getSynthesizedDeepClone(referenceSynthIdentifier(variableName)), rightHandSide))];
|
|
}
|
|
return [
|
|
factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[
|
|
factory.createVariableDeclaration(
|
|
getSynthesizedDeepClone(declareSynthBindingName(variableName)),
|
|
void 0,
|
|
typeAnnotation,
|
|
rightHandSide
|
|
)
|
|
],
|
|
2 /* Const */
|
|
)
|
|
)
|
|
];
|
|
}
|
|
function maybeAnnotateAndReturn(expressionToReturn, typeAnnotation) {
|
|
if (typeAnnotation && expressionToReturn) {
|
|
const name = factory.createUniqueName("result", 16 /* Optimistic */);
|
|
return [
|
|
...createVariableOrAssignmentOrExpressionStatement(createSynthIdentifier(name), expressionToReturn, typeAnnotation),
|
|
factory.createReturnStatement(name)
|
|
];
|
|
}
|
|
return [factory.createReturnStatement(expressionToReturn)];
|
|
}
|
|
function transformCallbackArgument(func, hasContinuation, continuationArgName, inputArgName, parent2, transformer) {
|
|
var _a2;
|
|
switch (func.kind) {
|
|
case 104 /* NullKeyword */:
|
|
break;
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 79 /* Identifier */:
|
|
if (!inputArgName) {
|
|
break;
|
|
}
|
|
const synthCall = factory.createCallExpression(getSynthesizedDeepClone(func), void 0, isSynthIdentifier(inputArgName) ? [referenceSynthIdentifier(inputArgName)] : []);
|
|
if (shouldReturn(parent2, transformer)) {
|
|
return maybeAnnotateAndReturn(synthCall, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent2, func, transformer.checker));
|
|
}
|
|
const type = transformer.checker.getTypeAtLocation(func);
|
|
const callSignatures = transformer.checker.getSignaturesOfType(type, 0 /* Call */);
|
|
if (!callSignatures.length) {
|
|
return silentFail();
|
|
}
|
|
const returnType = callSignatures[0].getReturnType();
|
|
const varDeclOrAssignment = createVariableOrAssignmentOrExpressionStatement(continuationArgName, factory.createAwaitExpression(synthCall), getExplicitPromisedTypeOfPromiseReturningCallExpression(parent2, func, transformer.checker));
|
|
if (continuationArgName) {
|
|
continuationArgName.types.push(transformer.checker.getAwaitedType(returnType) || returnType);
|
|
}
|
|
return varDeclOrAssignment;
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */: {
|
|
const funcBody = func.body;
|
|
const returnType2 = (_a2 = getLastCallSignature(transformer.checker.getTypeAtLocation(func), transformer.checker)) == null ? void 0 : _a2.getReturnType();
|
|
if (isBlock(funcBody)) {
|
|
let refactoredStmts = [];
|
|
let seenReturnStatement = false;
|
|
for (const statement of funcBody.statements) {
|
|
if (isReturnStatement(statement)) {
|
|
seenReturnStatement = true;
|
|
if (isReturnStatementWithFixablePromiseHandler(statement, transformer.checker)) {
|
|
refactoredStmts = refactoredStmts.concat(transformReturnStatementWithFixablePromiseHandler(transformer, statement, hasContinuation, continuationArgName));
|
|
} else {
|
|
const possiblyAwaitedRightHandSide = returnType2 && statement.expression ? getPossiblyAwaitedRightHandSide(transformer.checker, returnType2, statement.expression) : statement.expression;
|
|
refactoredStmts.push(...maybeAnnotateAndReturn(possiblyAwaitedRightHandSide, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent2, func, transformer.checker)));
|
|
}
|
|
} else if (hasContinuation && forEachReturnStatement(statement, returnTrue)) {
|
|
return silentFail();
|
|
} else {
|
|
refactoredStmts.push(statement);
|
|
}
|
|
}
|
|
return shouldReturn(parent2, transformer) ? refactoredStmts.map((s) => getSynthesizedDeepClone(s)) : removeReturns(
|
|
refactoredStmts,
|
|
continuationArgName,
|
|
transformer,
|
|
seenReturnStatement
|
|
);
|
|
} else {
|
|
const inlinedStatements = isFixablePromiseHandler(funcBody, transformer.checker) ? transformReturnStatementWithFixablePromiseHandler(transformer, factory.createReturnStatement(funcBody), hasContinuation, continuationArgName) : emptyArray;
|
|
if (inlinedStatements.length > 0) {
|
|
return inlinedStatements;
|
|
}
|
|
if (returnType2) {
|
|
const possiblyAwaitedRightHandSide = getPossiblyAwaitedRightHandSide(transformer.checker, returnType2, funcBody);
|
|
if (!shouldReturn(parent2, transformer)) {
|
|
const transformedStatement = createVariableOrAssignmentOrExpressionStatement(continuationArgName, possiblyAwaitedRightHandSide, void 0);
|
|
if (continuationArgName) {
|
|
continuationArgName.types.push(transformer.checker.getAwaitedType(returnType2) || returnType2);
|
|
}
|
|
return transformedStatement;
|
|
} else {
|
|
return maybeAnnotateAndReturn(possiblyAwaitedRightHandSide, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent2, func, transformer.checker));
|
|
}
|
|
} else {
|
|
return silentFail();
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
return silentFail();
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getPossiblyAwaitedRightHandSide(checker, type, expr) {
|
|
const rightHandSide = getSynthesizedDeepClone(expr);
|
|
return !!checker.getPromisedTypeOfPromise(type) ? factory.createAwaitExpression(rightHandSide) : rightHandSide;
|
|
}
|
|
function getLastCallSignature(type, checker) {
|
|
const callSignatures = checker.getSignaturesOfType(type, 0 /* Call */);
|
|
return lastOrUndefined(callSignatures);
|
|
}
|
|
function removeReturns(stmts, prevArgName, transformer, seenReturnStatement) {
|
|
const ret = [];
|
|
for (const stmt of stmts) {
|
|
if (isReturnStatement(stmt)) {
|
|
if (stmt.expression) {
|
|
const possiblyAwaitedExpression = isPromiseTypedExpression(stmt.expression, transformer.checker) ? factory.createAwaitExpression(stmt.expression) : stmt.expression;
|
|
if (prevArgName === void 0) {
|
|
ret.push(factory.createExpressionStatement(possiblyAwaitedExpression));
|
|
} else if (isSynthIdentifier(prevArgName) && prevArgName.hasBeenDeclared) {
|
|
ret.push(factory.createExpressionStatement(factory.createAssignment(referenceSynthIdentifier(prevArgName), possiblyAwaitedExpression)));
|
|
} else {
|
|
ret.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList([factory.createVariableDeclaration(declareSynthBindingName(prevArgName), void 0, void 0, possiblyAwaitedExpression)], 2 /* Const */)
|
|
));
|
|
}
|
|
}
|
|
} else {
|
|
ret.push(getSynthesizedDeepClone(stmt));
|
|
}
|
|
}
|
|
if (!seenReturnStatement && prevArgName !== void 0) {
|
|
ret.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList([factory.createVariableDeclaration(declareSynthBindingName(prevArgName), void 0, void 0, factory.createIdentifier("undefined"))], 2 /* Const */)
|
|
));
|
|
}
|
|
return ret;
|
|
}
|
|
function transformReturnStatementWithFixablePromiseHandler(transformer, innerRetStmt, hasContinuation, continuationArgName) {
|
|
let innerCbBody = [];
|
|
forEachChild(innerRetStmt, function visit(node) {
|
|
if (isCallExpression(node)) {
|
|
const temp = transformExpression(node, node, transformer, hasContinuation, continuationArgName);
|
|
innerCbBody = innerCbBody.concat(temp);
|
|
if (innerCbBody.length > 0) {
|
|
return;
|
|
}
|
|
} else if (!isFunctionLike(node)) {
|
|
forEachChild(node, visit);
|
|
}
|
|
});
|
|
return innerCbBody;
|
|
}
|
|
function getArgBindingName(funcNode, transformer) {
|
|
const types = [];
|
|
let name;
|
|
if (isFunctionLikeDeclaration(funcNode)) {
|
|
if (funcNode.parameters.length > 0) {
|
|
const param = funcNode.parameters[0].name;
|
|
name = getMappedBindingNameOrDefault(param);
|
|
}
|
|
} else if (isIdentifier(funcNode)) {
|
|
name = getMapEntryOrDefault(funcNode);
|
|
} else if (isPropertyAccessExpression(funcNode) && isIdentifier(funcNode.name)) {
|
|
name = getMapEntryOrDefault(funcNode.name);
|
|
}
|
|
if (!name || "identifier" in name && name.identifier.text === "undefined") {
|
|
return void 0;
|
|
}
|
|
return name;
|
|
function getMappedBindingNameOrDefault(bindingName) {
|
|
if (isIdentifier(bindingName))
|
|
return getMapEntryOrDefault(bindingName);
|
|
const elements = flatMap(bindingName.elements, (element) => {
|
|
if (isOmittedExpression(element))
|
|
return [];
|
|
return [getMappedBindingNameOrDefault(element.name)];
|
|
});
|
|
return createSynthBindingPattern(bindingName, elements);
|
|
}
|
|
function getMapEntryOrDefault(identifier) {
|
|
const originalNode = getOriginalNode2(identifier);
|
|
const symbol = getSymbol2(originalNode);
|
|
if (!symbol) {
|
|
return createSynthIdentifier(identifier, types);
|
|
}
|
|
const mapEntry = transformer.synthNamesMap.get(getSymbolId(symbol).toString());
|
|
return mapEntry || createSynthIdentifier(identifier, types);
|
|
}
|
|
function getSymbol2(node) {
|
|
return node.symbol ? node.symbol : transformer.checker.getSymbolAtLocation(node);
|
|
}
|
|
function getOriginalNode2(node) {
|
|
return node.original ? node.original : node;
|
|
}
|
|
}
|
|
function isEmptyBindingName(bindingName) {
|
|
if (!bindingName) {
|
|
return true;
|
|
}
|
|
if (isSynthIdentifier(bindingName)) {
|
|
return !bindingName.identifier.text;
|
|
}
|
|
return every(bindingName.elements, isEmptyBindingName);
|
|
}
|
|
function createSynthIdentifier(identifier, types = []) {
|
|
return { kind: 0 /* Identifier */, identifier, types, hasBeenDeclared: false, hasBeenReferenced: false };
|
|
}
|
|
function createSynthBindingPattern(bindingPattern, elements = emptyArray, types = []) {
|
|
return { kind: 1 /* BindingPattern */, bindingPattern, elements, types };
|
|
}
|
|
function referenceSynthIdentifier(synthId) {
|
|
synthId.hasBeenReferenced = true;
|
|
return synthId.identifier;
|
|
}
|
|
function declareSynthBindingName(synthName) {
|
|
return isSynthIdentifier(synthName) ? declareSynthIdentifier(synthName) : declareSynthBindingPattern(synthName);
|
|
}
|
|
function declareSynthBindingPattern(synthPattern) {
|
|
for (const element of synthPattern.elements) {
|
|
declareSynthBindingName(element);
|
|
}
|
|
return synthPattern.bindingPattern;
|
|
}
|
|
function declareSynthIdentifier(synthId) {
|
|
synthId.hasBeenDeclared = true;
|
|
return synthId.identifier;
|
|
}
|
|
function isSynthIdentifier(bindingName) {
|
|
return bindingName.kind === 0 /* Identifier */;
|
|
}
|
|
function isSynthBindingPattern(bindingName) {
|
|
return bindingName.kind === 1 /* BindingPattern */;
|
|
}
|
|
function shouldReturn(expression, transformer) {
|
|
return !!expression.original && transformer.setOfExpressionsToReturn.has(getNodeId(expression.original));
|
|
}
|
|
|
|
// src/services/codefixes/convertToEsModule.ts
|
|
registerCodeFix({
|
|
errorCodes: [Diagnostics.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module.code],
|
|
getCodeActions(context) {
|
|
const { sourceFile, program, preferences } = context;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
|
|
const moduleExportsChangedToDefault = convertFileToEsModule(sourceFile, program.getTypeChecker(), changes2, getEmitScriptTarget(program.getCompilerOptions()), getQuotePreference(sourceFile, preferences));
|
|
if (moduleExportsChangedToDefault) {
|
|
for (const importingFile of program.getSourceFiles()) {
|
|
fixImportOfModuleExports(importingFile, sourceFile, changes2, getQuotePreference(importingFile, preferences));
|
|
}
|
|
}
|
|
});
|
|
return [createCodeFixActionWithoutFixAll("convertToEsModule", changes, Diagnostics.Convert_to_ES_module)];
|
|
}
|
|
});
|
|
function fixImportOfModuleExports(importingFile, exportingFile, changes, quotePreference) {
|
|
for (const moduleSpecifier of importingFile.imports) {
|
|
const imported = getResolvedModule(importingFile, moduleSpecifier.text, getModeForUsageLocation(importingFile, moduleSpecifier));
|
|
if (!imported || imported.resolvedFileName !== exportingFile.fileName) {
|
|
continue;
|
|
}
|
|
const importNode = importFromModuleSpecifier(moduleSpecifier);
|
|
switch (importNode.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
changes.replaceNode(importingFile, importNode, makeImport(importNode.name, void 0, moduleSpecifier, quotePreference));
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
if (isRequireCall(importNode, false)) {
|
|
changes.replaceNode(importingFile, importNode, factory.createPropertyAccessExpression(getSynthesizedDeepClone(importNode), "default"));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
function convertFileToEsModule(sourceFile, checker, changes, target, quotePreference) {
|
|
const identifiers = { original: collectFreeIdentifiers(sourceFile), additional: /* @__PURE__ */ new Set() };
|
|
const exports = collectExportRenames(sourceFile, checker, identifiers);
|
|
convertExportsAccesses(sourceFile, exports, changes);
|
|
let moduleExportsChangedToDefault = false;
|
|
let useSitesToUnqualify;
|
|
for (const statement of filter(sourceFile.statements, isVariableStatement)) {
|
|
const newUseSites = convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference);
|
|
if (newUseSites) {
|
|
copyEntries(newUseSites, useSitesToUnqualify != null ? useSitesToUnqualify : useSitesToUnqualify = /* @__PURE__ */ new Map());
|
|
}
|
|
}
|
|
for (const statement of filter(sourceFile.statements, (s) => !isVariableStatement(s))) {
|
|
const moduleExportsChanged = convertStatement(sourceFile, statement, checker, changes, identifiers, target, exports, useSitesToUnqualify, quotePreference);
|
|
moduleExportsChangedToDefault = moduleExportsChangedToDefault || moduleExportsChanged;
|
|
}
|
|
useSitesToUnqualify == null ? void 0 : useSitesToUnqualify.forEach((replacement, original) => {
|
|
changes.replaceNode(sourceFile, original, replacement);
|
|
});
|
|
return moduleExportsChangedToDefault;
|
|
}
|
|
function collectExportRenames(sourceFile, checker, identifiers) {
|
|
const res = /* @__PURE__ */ new Map();
|
|
forEachExportReference(sourceFile, (node) => {
|
|
const { text, originalKeywordKind } = node.name;
|
|
if (!res.has(text) && (originalKeywordKind !== void 0 && isNonContextualKeyword(originalKeywordKind) || checker.resolveName(text, node, 111551 /* Value */, true))) {
|
|
res.set(text, makeUniqueName(`_${text}`, identifiers));
|
|
}
|
|
});
|
|
return res;
|
|
}
|
|
function convertExportsAccesses(sourceFile, exports, changes) {
|
|
forEachExportReference(sourceFile, (node, isAssignmentLhs) => {
|
|
if (isAssignmentLhs) {
|
|
return;
|
|
}
|
|
const { text } = node.name;
|
|
changes.replaceNode(sourceFile, node, factory.createIdentifier(exports.get(text) || text));
|
|
});
|
|
}
|
|
function forEachExportReference(sourceFile, cb) {
|
|
sourceFile.forEachChild(function recur(node) {
|
|
if (isPropertyAccessExpression(node) && isExportsOrModuleExportsOrAlias(sourceFile, node.expression) && isIdentifier(node.name)) {
|
|
const { parent: parent2 } = node;
|
|
cb(node, isBinaryExpression(parent2) && parent2.left === node && parent2.operatorToken.kind === 63 /* EqualsToken */);
|
|
}
|
|
node.forEachChild(recur);
|
|
});
|
|
}
|
|
function convertStatement(sourceFile, statement, checker, changes, identifiers, target, exports, useSitesToUnqualify, quotePreference) {
|
|
switch (statement.kind) {
|
|
case 240 /* VariableStatement */:
|
|
convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference);
|
|
return false;
|
|
case 241 /* ExpressionStatement */: {
|
|
const { expression } = statement;
|
|
switch (expression.kind) {
|
|
case 210 /* CallExpression */: {
|
|
if (isRequireCall(expression, true)) {
|
|
changes.replaceNode(sourceFile, statement, makeImport(void 0, void 0, expression.arguments[0], quotePreference));
|
|
}
|
|
return false;
|
|
}
|
|
case 223 /* BinaryExpression */: {
|
|
const { operatorToken } = expression;
|
|
return operatorToken.kind === 63 /* EqualsToken */ && convertAssignment(sourceFile, checker, expression, changes, exports, useSitesToUnqualify);
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference) {
|
|
const { declarationList } = statement;
|
|
let foundImport = false;
|
|
const converted = map(declarationList.declarations, (decl) => {
|
|
const { name, initializer } = decl;
|
|
if (initializer) {
|
|
if (isExportsOrModuleExportsOrAlias(sourceFile, initializer)) {
|
|
foundImport = true;
|
|
return convertedImports([]);
|
|
} else if (isRequireCall(initializer, true)) {
|
|
foundImport = true;
|
|
return convertSingleImport(name, initializer.arguments[0], checker, identifiers, target, quotePreference);
|
|
} else if (isPropertyAccessExpression(initializer) && isRequireCall(initializer.expression, true)) {
|
|
foundImport = true;
|
|
return convertPropertyAccessImport(name, initializer.name.text, initializer.expression.arguments[0], identifiers, quotePreference);
|
|
}
|
|
}
|
|
return convertedImports([factory.createVariableStatement(void 0, factory.createVariableDeclarationList([decl], declarationList.flags))]);
|
|
});
|
|
if (foundImport) {
|
|
changes.replaceNodeWithNodes(sourceFile, statement, flatMap(converted, (c) => c.newImports));
|
|
let combinedUseSites;
|
|
forEach(converted, (c) => {
|
|
if (c.useSitesToUnqualify) {
|
|
copyEntries(c.useSitesToUnqualify, combinedUseSites != null ? combinedUseSites : combinedUseSites = /* @__PURE__ */ new Map());
|
|
}
|
|
});
|
|
return combinedUseSites;
|
|
}
|
|
}
|
|
function convertPropertyAccessImport(name, propertyName, moduleSpecifier, identifiers, quotePreference) {
|
|
switch (name.kind) {
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */: {
|
|
const tmp = makeUniqueName(propertyName, identifiers);
|
|
return convertedImports([
|
|
makeSingleImport(tmp, propertyName, moduleSpecifier, quotePreference),
|
|
makeConst(void 0, name, factory.createIdentifier(tmp))
|
|
]);
|
|
}
|
|
case 79 /* Identifier */:
|
|
return convertedImports([makeSingleImport(name.text, propertyName, moduleSpecifier, quotePreference)]);
|
|
default:
|
|
return Debug.assertNever(name, `Convert to ES module got invalid syntax form ${name.kind}`);
|
|
}
|
|
}
|
|
function convertAssignment(sourceFile, checker, assignment, changes, exports, useSitesToUnqualify) {
|
|
const { left, right } = assignment;
|
|
if (!isPropertyAccessExpression(left)) {
|
|
return false;
|
|
}
|
|
if (isExportsOrModuleExportsOrAlias(sourceFile, left)) {
|
|
if (isExportsOrModuleExportsOrAlias(sourceFile, right)) {
|
|
changes.delete(sourceFile, assignment.parent);
|
|
} else {
|
|
const replacement = isObjectLiteralExpression(right) ? tryChangeModuleExportsObject(right, useSitesToUnqualify) : isRequireCall(right, true) ? convertReExportAll(right.arguments[0], checker) : void 0;
|
|
if (replacement) {
|
|
changes.replaceNodeWithNodes(sourceFile, assignment.parent, replacement[0]);
|
|
return replacement[1];
|
|
} else {
|
|
changes.replaceRangeWithText(sourceFile, createRange(left.getStart(sourceFile), right.pos), "export default");
|
|
return true;
|
|
}
|
|
}
|
|
} else if (isExportsOrModuleExportsOrAlias(sourceFile, left.expression)) {
|
|
convertNamedExport(sourceFile, assignment, changes, exports);
|
|
}
|
|
return false;
|
|
}
|
|
function tryChangeModuleExportsObject(object, useSitesToUnqualify) {
|
|
const statements = mapAllOrFail(object.properties, (prop) => {
|
|
switch (prop.kind) {
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 301 /* SpreadAssignment */:
|
|
return void 0;
|
|
case 299 /* PropertyAssignment */:
|
|
return !isIdentifier(prop.name) ? void 0 : convertExportsDotXEquals_replaceNode(prop.name.text, prop.initializer, useSitesToUnqualify);
|
|
case 171 /* MethodDeclaration */:
|
|
return !isIdentifier(prop.name) ? void 0 : functionExpressionToDeclaration(prop.name.text, [factory.createToken(93 /* ExportKeyword */)], prop, useSitesToUnqualify);
|
|
default:
|
|
Debug.assertNever(prop, `Convert to ES6 got invalid prop kind ${prop.kind}`);
|
|
}
|
|
});
|
|
return statements && [statements, false];
|
|
}
|
|
function convertNamedExport(sourceFile, assignment, changes, exports) {
|
|
const { text } = assignment.left.name;
|
|
const rename = exports.get(text);
|
|
if (rename !== void 0) {
|
|
const newNodes = [
|
|
makeConst(void 0, rename, assignment.right),
|
|
makeExportDeclaration([factory.createExportSpecifier(false, rename, text)])
|
|
];
|
|
changes.replaceNodeWithNodes(sourceFile, assignment.parent, newNodes);
|
|
} else {
|
|
convertExportsPropertyAssignment(assignment, sourceFile, changes);
|
|
}
|
|
}
|
|
function convertReExportAll(reExported, checker) {
|
|
const moduleSpecifier = reExported.text;
|
|
const moduleSymbol = checker.getSymbolAtLocation(reExported);
|
|
const exports = moduleSymbol ? moduleSymbol.exports : emptyMap;
|
|
return exports.has("export=" /* ExportEquals */) ? [[reExportDefault(moduleSpecifier)], true] : !exports.has("default" /* Default */) ? [[reExportStar(moduleSpecifier)], false] : exports.size > 1 ? [[reExportStar(moduleSpecifier), reExportDefault(moduleSpecifier)], true] : [[reExportDefault(moduleSpecifier)], true];
|
|
}
|
|
function reExportStar(moduleSpecifier) {
|
|
return makeExportDeclaration(void 0, moduleSpecifier);
|
|
}
|
|
function reExportDefault(moduleSpecifier) {
|
|
return makeExportDeclaration([factory.createExportSpecifier(false, void 0, "default")], moduleSpecifier);
|
|
}
|
|
function convertExportsPropertyAssignment({ left, right, parent: parent2 }, sourceFile, changes) {
|
|
const name = left.name.text;
|
|
if ((isFunctionExpression(right) || isArrowFunction(right) || isClassExpression(right)) && (!right.name || right.name.text === name)) {
|
|
changes.replaceRange(sourceFile, { pos: left.getStart(sourceFile), end: right.getStart(sourceFile) }, factory.createToken(93 /* ExportKeyword */), { suffix: " " });
|
|
if (!right.name)
|
|
changes.insertName(sourceFile, right, name);
|
|
const semi = findChildOfKind(parent2, 26 /* SemicolonToken */, sourceFile);
|
|
if (semi)
|
|
changes.delete(sourceFile, semi);
|
|
} else {
|
|
changes.replaceNodeRangeWithNodes(
|
|
sourceFile,
|
|
left.expression,
|
|
findChildOfKind(left, 24 /* DotToken */, sourceFile),
|
|
[factory.createToken(93 /* ExportKeyword */), factory.createToken(85 /* ConstKeyword */)],
|
|
{ joiner: " ", suffix: " " }
|
|
);
|
|
}
|
|
}
|
|
function convertExportsDotXEquals_replaceNode(name, exported, useSitesToUnqualify) {
|
|
const modifiers = [factory.createToken(93 /* ExportKeyword */)];
|
|
switch (exported.kind) {
|
|
case 215 /* FunctionExpression */: {
|
|
const { name: expressionName } = exported;
|
|
if (expressionName && expressionName.text !== name) {
|
|
return exportConst();
|
|
}
|
|
}
|
|
case 216 /* ArrowFunction */:
|
|
return functionExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify);
|
|
case 228 /* ClassExpression */:
|
|
return classExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify);
|
|
default:
|
|
return exportConst();
|
|
}
|
|
function exportConst() {
|
|
return makeConst(modifiers, factory.createIdentifier(name), replaceImportUseSites(exported, useSitesToUnqualify));
|
|
}
|
|
}
|
|
function replaceImportUseSites(nodeOrNodes, useSitesToUnqualify) {
|
|
if (!useSitesToUnqualify || !some(arrayFrom(useSitesToUnqualify.keys()), (original) => rangeContainsRange(nodeOrNodes, original))) {
|
|
return nodeOrNodes;
|
|
}
|
|
return isArray(nodeOrNodes) ? getSynthesizedDeepClonesWithReplacements(nodeOrNodes, true, replaceNode) : getSynthesizedDeepCloneWithReplacements(nodeOrNodes, true, replaceNode);
|
|
function replaceNode(original) {
|
|
if (original.kind === 208 /* PropertyAccessExpression */) {
|
|
const replacement = useSitesToUnqualify.get(original);
|
|
useSitesToUnqualify.delete(original);
|
|
return replacement;
|
|
}
|
|
}
|
|
}
|
|
function convertSingleImport(name, moduleSpecifier, checker, identifiers, target, quotePreference) {
|
|
switch (name.kind) {
|
|
case 203 /* ObjectBindingPattern */: {
|
|
const importSpecifiers = mapAllOrFail(name.elements, (e) => e.dotDotDotToken || e.initializer || e.propertyName && !isIdentifier(e.propertyName) || !isIdentifier(e.name) ? void 0 : makeImportSpecifier(e.propertyName && e.propertyName.text, e.name.text));
|
|
if (importSpecifiers) {
|
|
return convertedImports([makeImport(void 0, importSpecifiers, moduleSpecifier, quotePreference)]);
|
|
}
|
|
}
|
|
case 204 /* ArrayBindingPattern */: {
|
|
const tmp = makeUniqueName(moduleSpecifierToValidIdentifier(moduleSpecifier.text, target), identifiers);
|
|
return convertedImports([
|
|
makeImport(factory.createIdentifier(tmp), void 0, moduleSpecifier, quotePreference),
|
|
makeConst(void 0, getSynthesizedDeepClone(name), factory.createIdentifier(tmp))
|
|
]);
|
|
}
|
|
case 79 /* Identifier */:
|
|
return convertSingleIdentifierImport(name, moduleSpecifier, checker, identifiers, quotePreference);
|
|
default:
|
|
return Debug.assertNever(name, `Convert to ES module got invalid name kind ${name.kind}`);
|
|
}
|
|
}
|
|
function convertSingleIdentifierImport(name, moduleSpecifier, checker, identifiers, quotePreference) {
|
|
const nameSymbol = checker.getSymbolAtLocation(name);
|
|
const namedBindingsNames = /* @__PURE__ */ new Map();
|
|
let needDefaultImport = false;
|
|
let useSitesToUnqualify;
|
|
for (const use of identifiers.original.get(name.text)) {
|
|
if (checker.getSymbolAtLocation(use) !== nameSymbol || use === name) {
|
|
continue;
|
|
}
|
|
const { parent: parent2 } = use;
|
|
if (isPropertyAccessExpression(parent2)) {
|
|
const { name: { text: propertyName } } = parent2;
|
|
if (propertyName === "default") {
|
|
needDefaultImport = true;
|
|
const importDefaultName = use.getText();
|
|
(useSitesToUnqualify != null ? useSitesToUnqualify : useSitesToUnqualify = /* @__PURE__ */ new Map()).set(parent2, factory.createIdentifier(importDefaultName));
|
|
} else {
|
|
Debug.assert(parent2.expression === use, "Didn't expect expression === use");
|
|
let idName = namedBindingsNames.get(propertyName);
|
|
if (idName === void 0) {
|
|
idName = makeUniqueName(propertyName, identifiers);
|
|
namedBindingsNames.set(propertyName, idName);
|
|
}
|
|
(useSitesToUnqualify != null ? useSitesToUnqualify : useSitesToUnqualify = /* @__PURE__ */ new Map()).set(parent2, factory.createIdentifier(idName));
|
|
}
|
|
} else {
|
|
needDefaultImport = true;
|
|
}
|
|
}
|
|
const namedBindings = namedBindingsNames.size === 0 ? void 0 : arrayFrom(mapIterator(namedBindingsNames.entries(), ([propertyName, idName]) => factory.createImportSpecifier(false, propertyName === idName ? void 0 : factory.createIdentifier(propertyName), factory.createIdentifier(idName))));
|
|
if (!namedBindings) {
|
|
needDefaultImport = true;
|
|
}
|
|
return convertedImports(
|
|
[makeImport(needDefaultImport ? getSynthesizedDeepClone(name) : void 0, namedBindings, moduleSpecifier, quotePreference)],
|
|
useSitesToUnqualify
|
|
);
|
|
}
|
|
function makeUniqueName(name, identifiers) {
|
|
while (identifiers.original.has(name) || identifiers.additional.has(name)) {
|
|
name = `_${name}`;
|
|
}
|
|
identifiers.additional.add(name);
|
|
return name;
|
|
}
|
|
function collectFreeIdentifiers(file) {
|
|
const map2 = createMultiMap();
|
|
forEachFreeIdentifier(file, (id) => map2.add(id.text, id));
|
|
return map2;
|
|
}
|
|
function forEachFreeIdentifier(node, cb) {
|
|
if (isIdentifier(node) && isFreeIdentifier(node))
|
|
cb(node);
|
|
node.forEachChild((child) => forEachFreeIdentifier(child, cb));
|
|
}
|
|
function isFreeIdentifier(node) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
return parent2.name !== node;
|
|
case 205 /* BindingElement */:
|
|
return parent2.propertyName !== node;
|
|
case 273 /* ImportSpecifier */:
|
|
return parent2.propertyName !== node;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
function functionExpressionToDeclaration(name, additionalModifiers, fn, useSitesToUnqualify) {
|
|
return factory.createFunctionDeclaration(
|
|
concatenate(additionalModifiers, getSynthesizedDeepClones(fn.modifiers)),
|
|
getSynthesizedDeepClone(fn.asteriskToken),
|
|
name,
|
|
getSynthesizedDeepClones(fn.typeParameters),
|
|
getSynthesizedDeepClones(fn.parameters),
|
|
getSynthesizedDeepClone(fn.type),
|
|
factory.converters.convertToFunctionBlock(replaceImportUseSites(fn.body, useSitesToUnqualify))
|
|
);
|
|
}
|
|
function classExpressionToDeclaration(name, additionalModifiers, cls, useSitesToUnqualify) {
|
|
return factory.createClassDeclaration(
|
|
concatenate(additionalModifiers, getSynthesizedDeepClones(cls.modifiers)),
|
|
name,
|
|
getSynthesizedDeepClones(cls.typeParameters),
|
|
getSynthesizedDeepClones(cls.heritageClauses),
|
|
replaceImportUseSites(cls.members, useSitesToUnqualify)
|
|
);
|
|
}
|
|
function makeSingleImport(localName, propertyName, moduleSpecifier, quotePreference) {
|
|
return propertyName === "default" ? makeImport(factory.createIdentifier(localName), void 0, moduleSpecifier, quotePreference) : makeImport(void 0, [makeImportSpecifier(propertyName, localName)], moduleSpecifier, quotePreference);
|
|
}
|
|
function makeImportSpecifier(propertyName, name) {
|
|
return factory.createImportSpecifier(false, propertyName !== void 0 && propertyName !== name ? factory.createIdentifier(propertyName) : void 0, factory.createIdentifier(name));
|
|
}
|
|
function makeConst(modifiers, name, init) {
|
|
return factory.createVariableStatement(
|
|
modifiers,
|
|
factory.createVariableDeclarationList(
|
|
[factory.createVariableDeclaration(name, void 0, void 0, init)],
|
|
2 /* Const */
|
|
)
|
|
);
|
|
}
|
|
function makeExportDeclaration(exportSpecifiers, moduleSpecifier) {
|
|
return factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
exportSpecifiers && factory.createNamedExports(exportSpecifiers),
|
|
moduleSpecifier === void 0 ? void 0 : factory.createStringLiteral(moduleSpecifier)
|
|
);
|
|
}
|
|
function convertedImports(newImports, useSitesToUnqualify) {
|
|
return {
|
|
newImports,
|
|
useSitesToUnqualify
|
|
};
|
|
}
|
|
|
|
// src/services/codefixes/correctQualifiedNameToIndexedAccessType.ts
|
|
var fixId11 = "correctQualifiedNameToIndexedAccessType";
|
|
var errorCodes12 = [Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes12,
|
|
getCodeActions(context) {
|
|
const qualifiedName = getQualifiedName(context.sourceFile, context.span.start);
|
|
if (!qualifiedName)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange3(t, context.sourceFile, qualifiedName));
|
|
const newText = `${qualifiedName.left.text}["${qualifiedName.right.text}"]`;
|
|
return [createCodeFixAction(fixId11, changes, [Diagnostics.Rewrite_as_the_indexed_access_type_0, newText], fixId11, Diagnostics.Rewrite_all_as_indexed_access_types)];
|
|
},
|
|
fixIds: [fixId11],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes12, (changes, diag2) => {
|
|
const q = getQualifiedName(diag2.file, diag2.start);
|
|
if (q) {
|
|
doChange3(changes, diag2.file, q);
|
|
}
|
|
})
|
|
});
|
|
function getQualifiedName(sourceFile, pos) {
|
|
const qualifiedName = findAncestor(getTokenAtPosition(sourceFile, pos), isQualifiedName);
|
|
Debug.assert(!!qualifiedName, "Expected position to be owned by a qualified name.");
|
|
return isIdentifier(qualifiedName.left) ? qualifiedName : void 0;
|
|
}
|
|
function doChange3(changeTracker, sourceFile, qualifiedName) {
|
|
const rightText = qualifiedName.right.text;
|
|
const replacement = factory.createIndexedAccessTypeNode(
|
|
factory.createTypeReferenceNode(qualifiedName.left, void 0),
|
|
factory.createLiteralTypeNode(factory.createStringLiteral(rightText))
|
|
);
|
|
changeTracker.replaceNode(sourceFile, qualifiedName, replacement);
|
|
}
|
|
|
|
// src/services/codefixes/convertToTypeOnlyExport.ts
|
|
var errorCodes13 = [Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type.code];
|
|
var fixId12 = "convertToTypeOnlyExport";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes13,
|
|
getCodeActions: function getCodeActionsToConvertToTypeOnlyExport(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => fixSingleExportDeclaration(t, getExportSpecifierForDiagnosticSpan(context.span, context.sourceFile), context));
|
|
if (changes.length) {
|
|
return [createCodeFixAction(fixId12, changes, Diagnostics.Convert_to_type_only_export, fixId12, Diagnostics.Convert_all_re_exported_types_to_type_only_exports)];
|
|
}
|
|
},
|
|
fixIds: [fixId12],
|
|
getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyExport(context) {
|
|
const fixedExportDeclarations = /* @__PURE__ */ new Map();
|
|
return codeFixAll(context, errorCodes13, (changes, diag2) => {
|
|
const exportSpecifier = getExportSpecifierForDiagnosticSpan(diag2, context.sourceFile);
|
|
if (exportSpecifier && addToSeen(fixedExportDeclarations, getNodeId(exportSpecifier.parent.parent))) {
|
|
fixSingleExportDeclaration(changes, exportSpecifier, context);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getExportSpecifierForDiagnosticSpan(span, sourceFile) {
|
|
return tryCast(getTokenAtPosition(sourceFile, span.start).parent, isExportSpecifier);
|
|
}
|
|
function fixSingleExportDeclaration(changes, exportSpecifier, context) {
|
|
if (!exportSpecifier) {
|
|
return;
|
|
}
|
|
const exportClause = exportSpecifier.parent;
|
|
const exportDeclaration = exportClause.parent;
|
|
const typeExportSpecifiers = getTypeExportSpecifiers(exportSpecifier, context);
|
|
if (typeExportSpecifiers.length === exportClause.elements.length) {
|
|
changes.insertModifierBefore(context.sourceFile, 154 /* TypeKeyword */, exportClause);
|
|
} else {
|
|
const valueExportDeclaration = factory.updateExportDeclaration(
|
|
exportDeclaration,
|
|
exportDeclaration.modifiers,
|
|
false,
|
|
factory.updateNamedExports(exportClause, filter(exportClause.elements, (e) => !contains(typeExportSpecifiers, e))),
|
|
exportDeclaration.moduleSpecifier,
|
|
void 0
|
|
);
|
|
const typeExportDeclaration = factory.createExportDeclaration(
|
|
void 0,
|
|
true,
|
|
factory.createNamedExports(typeExportSpecifiers),
|
|
exportDeclaration.moduleSpecifier,
|
|
void 0
|
|
);
|
|
changes.replaceNode(context.sourceFile, exportDeclaration, valueExportDeclaration, {
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.IncludeAll,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Exclude
|
|
});
|
|
changes.insertNodeAfter(context.sourceFile, exportDeclaration, typeExportDeclaration);
|
|
}
|
|
}
|
|
function getTypeExportSpecifiers(originExportSpecifier, context) {
|
|
const exportClause = originExportSpecifier.parent;
|
|
if (exportClause.elements.length === 1) {
|
|
return exportClause.elements;
|
|
}
|
|
const diagnostics = getDiagnosticsWithinSpan(
|
|
createTextSpanFromNode(exportClause),
|
|
context.program.getSemanticDiagnostics(context.sourceFile, context.cancellationToken)
|
|
);
|
|
return filter(exportClause.elements, (element) => {
|
|
var _a2;
|
|
return element === originExportSpecifier || ((_a2 = findDiagnosticForNode(element, diagnostics)) == null ? void 0 : _a2.code) === errorCodes13[0];
|
|
});
|
|
}
|
|
|
|
// src/services/codefixes/convertToTypeOnlyImport.ts
|
|
var errorCodes14 = [Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code];
|
|
var fixId13 = "convertToTypeOnlyImport";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes14,
|
|
getCodeActions: function getCodeActionsToConvertToTypeOnlyImport(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
const importDeclaration = getImportDeclarationForDiagnosticSpan(context.span, context.sourceFile);
|
|
fixSingleImportDeclaration(t, importDeclaration, context);
|
|
});
|
|
if (changes.length) {
|
|
return [createCodeFixAction(fixId13, changes, Diagnostics.Convert_to_type_only_import, fixId13, Diagnostics.Convert_all_imports_not_used_as_a_value_to_type_only_imports)];
|
|
}
|
|
},
|
|
fixIds: [fixId13],
|
|
getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyImport(context) {
|
|
return codeFixAll(context, errorCodes14, (changes, diag2) => {
|
|
const importDeclaration = getImportDeclarationForDiagnosticSpan(diag2, context.sourceFile);
|
|
fixSingleImportDeclaration(changes, importDeclaration, context);
|
|
});
|
|
}
|
|
});
|
|
function getImportDeclarationForDiagnosticSpan(span, sourceFile) {
|
|
return tryCast(getTokenAtPosition(sourceFile, span.start).parent, isImportDeclaration);
|
|
}
|
|
function fixSingleImportDeclaration(changes, importDeclaration, context) {
|
|
if (!(importDeclaration == null ? void 0 : importDeclaration.importClause)) {
|
|
return;
|
|
}
|
|
const { importClause } = importDeclaration;
|
|
changes.insertText(context.sourceFile, importDeclaration.getStart() + "import".length, " type");
|
|
if (importClause.name && importClause.namedBindings) {
|
|
changes.deleteNodeRangeExcludingEnd(context.sourceFile, importClause.name, importDeclaration.importClause.namedBindings);
|
|
changes.insertNodeBefore(context.sourceFile, importDeclaration, factory.updateImportDeclaration(
|
|
importDeclaration,
|
|
void 0,
|
|
factory.createImportClause(
|
|
true,
|
|
importClause.name,
|
|
void 0
|
|
),
|
|
importDeclaration.moduleSpecifier,
|
|
void 0
|
|
));
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/convertLiteralTypeToMappedType.ts
|
|
var fixId14 = "convertLiteralTypeToMappedType";
|
|
var errorCodes15 = [Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes15,
|
|
getCodeActions: function getCodeActionsToConvertLiteralTypeToMappedType(context) {
|
|
const { sourceFile, span } = context;
|
|
const info = getInfo2(sourceFile, span.start);
|
|
if (!info) {
|
|
return void 0;
|
|
}
|
|
const { name, constraint } = info;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange4(t, sourceFile, info));
|
|
return [createCodeFixAction(fixId14, changes, [Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId14, Diagnostics.Convert_all_type_literals_to_mapped_type)];
|
|
},
|
|
fixIds: [fixId14],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes15, (changes, diag2) => {
|
|
const info = getInfo2(diag2.file, diag2.start);
|
|
if (info) {
|
|
doChange4(changes, diag2.file, info);
|
|
}
|
|
})
|
|
});
|
|
function getInfo2(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (isIdentifier(token)) {
|
|
const propertySignature = cast(token.parent.parent, isPropertySignature);
|
|
const propertyName = token.getText(sourceFile);
|
|
return {
|
|
container: cast(propertySignature.parent, isTypeLiteralNode),
|
|
typeNode: propertySignature.type,
|
|
constraint: propertyName,
|
|
name: propertyName === "K" ? "P" : "K"
|
|
};
|
|
}
|
|
return void 0;
|
|
}
|
|
function doChange4(changes, sourceFile, { container, typeNode, constraint, name }) {
|
|
changes.replaceNode(sourceFile, container, factory.createMappedTypeNode(
|
|
void 0,
|
|
factory.createTypeParameterDeclaration(void 0, name, factory.createTypeReferenceNode(constraint)),
|
|
void 0,
|
|
void 0,
|
|
typeNode,
|
|
void 0
|
|
));
|
|
}
|
|
|
|
// src/services/codefixes/fixClassIncorrectlyImplementsInterface.ts
|
|
var errorCodes16 = [
|
|
Diagnostics.Class_0_incorrectly_implements_interface_1.code,
|
|
Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code
|
|
];
|
|
var fixId15 = "fixClassIncorrectlyImplementsInterface";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes16,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const classDeclaration = getClass(sourceFile, span.start);
|
|
return mapDefined(getEffectiveImplementsTypeNodes(classDeclaration), (implementedTypeNode) => {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, t, context.preferences));
|
|
return changes.length === 0 ? void 0 : createCodeFixAction(fixId15, changes, [Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId15, Diagnostics.Implement_all_unimplemented_interfaces);
|
|
});
|
|
},
|
|
fixIds: [fixId15],
|
|
getAllCodeActions(context) {
|
|
const seenClassDeclarations = /* @__PURE__ */ new Map();
|
|
return codeFixAll(context, errorCodes16, (changes, diag2) => {
|
|
const classDeclaration = getClass(diag2.file, diag2.start);
|
|
if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
|
|
for (const implementedTypeNode of getEffectiveImplementsTypeNodes(classDeclaration)) {
|
|
addMissingDeclarations(context, implementedTypeNode, diag2.file, classDeclaration, changes, context.preferences);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getClass(sourceFile, pos) {
|
|
return Debug.checkDefined(getContainingClass(getTokenAtPosition(sourceFile, pos)), "There should be a containing class");
|
|
}
|
|
function symbolPointsToNonPrivateMember(symbol) {
|
|
return !symbol.valueDeclaration || !(getEffectiveModifierFlags(symbol.valueDeclaration) & 8 /* Private */);
|
|
}
|
|
function addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, changeTracker, preferences) {
|
|
const checker = context.program.getTypeChecker();
|
|
const maybeHeritageClauseSymbol = getHeritageClauseSymbolTable(classDeclaration, checker);
|
|
const implementedType = checker.getTypeAtLocation(implementedTypeNode);
|
|
const implementedTypeSymbols = checker.getPropertiesOfType(implementedType);
|
|
const nonPrivateAndNotExistedInHeritageClauseMembers = implementedTypeSymbols.filter(and(symbolPointsToNonPrivateMember, (symbol) => !maybeHeritageClauseSymbol.has(symbol.escapedName)));
|
|
const classType = checker.getTypeAtLocation(classDeclaration);
|
|
const constructor = find(classDeclaration.members, (m) => isConstructorDeclaration(m));
|
|
if (!classType.getNumberIndexType()) {
|
|
createMissingIndexSignatureDeclaration(implementedType, 1 /* Number */);
|
|
}
|
|
if (!classType.getStringIndexType()) {
|
|
createMissingIndexSignatureDeclaration(implementedType, 0 /* String */);
|
|
}
|
|
const importAdder = createImportAdder(sourceFile, context.program, preferences, context.host);
|
|
createMissingMemberNodes(classDeclaration, nonPrivateAndNotExistedInHeritageClauseMembers, sourceFile, context, preferences, importAdder, (member) => insertInterfaceMemberNode(sourceFile, classDeclaration, member));
|
|
importAdder.writeFixes(changeTracker);
|
|
function createMissingIndexSignatureDeclaration(type, kind) {
|
|
const indexInfoOfKind = checker.getIndexInfoOfType(type, kind);
|
|
if (indexInfoOfKind) {
|
|
insertInterfaceMemberNode(sourceFile, classDeclaration, checker.indexInfoToIndexSignatureDeclaration(indexInfoOfKind, classDeclaration, void 0, getNoopSymbolTrackerWithResolver(context)));
|
|
}
|
|
}
|
|
function insertInterfaceMemberNode(sourceFile2, cls, newElement) {
|
|
if (constructor) {
|
|
changeTracker.insertNodeAfter(sourceFile2, constructor, newElement);
|
|
} else {
|
|
changeTracker.insertMemberAtStart(sourceFile2, cls, newElement);
|
|
}
|
|
}
|
|
}
|
|
function getHeritageClauseSymbolTable(classDeclaration, checker) {
|
|
const heritageClauseNode = getEffectiveBaseTypeNode(classDeclaration);
|
|
if (!heritageClauseNode)
|
|
return createSymbolTable();
|
|
const heritageClauseType = checker.getTypeAtLocation(heritageClauseNode);
|
|
const heritageClauseTypeSymbols = checker.getPropertiesOfType(heritageClauseType);
|
|
return createSymbolTable(heritageClauseTypeSymbols.filter(symbolPointsToNonPrivateMember));
|
|
}
|
|
|
|
// src/services/codefixes/importFixes.ts
|
|
var importFixName = "import";
|
|
var importFixId = "fixMissingImport";
|
|
var errorCodes17 = [
|
|
Diagnostics.Cannot_find_name_0.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code,
|
|
Diagnostics.Cannot_find_namespace_0.code,
|
|
Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code,
|
|
Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code,
|
|
Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code,
|
|
Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes17,
|
|
getCodeActions(context) {
|
|
const { errorCode, preferences, sourceFile, span, program } = context;
|
|
const info = getFixInfos(context, errorCode, span.start, true);
|
|
if (!info)
|
|
return void 0;
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
return info.map(({ fix, symbolName: symbolName2, errorIdentifierText }) => codeActionForFix(
|
|
context,
|
|
sourceFile,
|
|
symbolName2,
|
|
fix,
|
|
symbolName2 !== errorIdentifierText,
|
|
quotePreference,
|
|
program.getCompilerOptions()
|
|
));
|
|
},
|
|
fixIds: [importFixId],
|
|
getAllCodeActions: (context) => {
|
|
const { sourceFile, program, preferences, host, cancellationToken } = context;
|
|
const importAdder = createImportAdderWorker(sourceFile, program, true, preferences, host, cancellationToken);
|
|
eachDiagnostic(context, errorCodes17, (diag2) => importAdder.addImportFromDiagnostic(diag2, context));
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, importAdder.writeFixes));
|
|
}
|
|
});
|
|
function createImportAdder(sourceFile, program, preferences, host, cancellationToken) {
|
|
return createImportAdderWorker(sourceFile, program, false, preferences, host, cancellationToken);
|
|
}
|
|
function createImportAdderWorker(sourceFile, program, useAutoImportProvider, preferences, host, cancellationToken) {
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const addToNamespace = [];
|
|
const importType = [];
|
|
const addToExisting = /* @__PURE__ */ new Map();
|
|
const newImports = /* @__PURE__ */ new Map();
|
|
return { addImportFromDiagnostic, addImportFromExportedSymbol, writeFixes, hasFixes };
|
|
function addImportFromDiagnostic(diagnostic, context) {
|
|
const info = getFixInfos(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
|
|
if (!info || !info.length)
|
|
return;
|
|
addImport(first(info));
|
|
}
|
|
function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite) {
|
|
const moduleSymbol = Debug.checkDefined(exportedSymbol.parent);
|
|
const symbolName2 = getNameForExportedSymbol(exportedSymbol, getEmitScriptTarget(compilerOptions));
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getMergedSymbol(skipAlias(exportedSymbol, checker));
|
|
const exportInfo = getAllExportInfoForSymbol(sourceFile, symbol, symbolName2, false, program, host, preferences, cancellationToken);
|
|
const useRequire = shouldUseRequire(sourceFile, program);
|
|
const fix = getImportFixForSymbol(sourceFile, Debug.checkDefined(exportInfo), moduleSymbol, program, void 0, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
|
|
if (fix) {
|
|
addImport({ fix, symbolName: symbolName2, errorIdentifierText: void 0 });
|
|
}
|
|
}
|
|
function addImport(info) {
|
|
var _a2, _b;
|
|
const { fix, symbolName: symbolName2 } = info;
|
|
switch (fix.kind) {
|
|
case ImportFixKind.UseNamespace:
|
|
addToNamespace.push(fix);
|
|
break;
|
|
case ImportFixKind.JsdocTypeImport:
|
|
importType.push(fix);
|
|
break;
|
|
case ImportFixKind.AddToExisting: {
|
|
const { importClauseOrBindingPattern, importKind, addAsTypeOnly } = fix;
|
|
const key = String(getNodeId(importClauseOrBindingPattern));
|
|
let entry = addToExisting.get(key);
|
|
if (!entry) {
|
|
addToExisting.set(key, entry = { importClauseOrBindingPattern, defaultImport: void 0, namedImports: /* @__PURE__ */ new Map() });
|
|
}
|
|
if (importKind === 0 /* Named */) {
|
|
const prevValue = entry == null ? void 0 : entry.namedImports.get(symbolName2);
|
|
entry.namedImports.set(symbolName2, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
|
|
} else {
|
|
Debug.assert(entry.defaultImport === void 0 || entry.defaultImport.name === symbolName2, "(Add to Existing) Default import should be missing or match symbolName");
|
|
entry.defaultImport = {
|
|
name: symbolName2,
|
|
addAsTypeOnly: reduceAddAsTypeOnlyValues((_a2 = entry.defaultImport) == null ? void 0 : _a2.addAsTypeOnly, addAsTypeOnly)
|
|
};
|
|
}
|
|
break;
|
|
}
|
|
case ImportFixKind.AddNew: {
|
|
const { moduleSpecifier, importKind, useRequire, addAsTypeOnly } = fix;
|
|
const entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly);
|
|
Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module");
|
|
switch (importKind) {
|
|
case 1 /* Default */:
|
|
Debug.assert(entry.defaultImport === void 0 || entry.defaultImport.name === symbolName2, "(Add new) Default import should be missing or match symbolName");
|
|
entry.defaultImport = { name: symbolName2, addAsTypeOnly: reduceAddAsTypeOnlyValues((_b = entry.defaultImport) == null ? void 0 : _b.addAsTypeOnly, addAsTypeOnly) };
|
|
break;
|
|
case 0 /* Named */:
|
|
const prevValue = (entry.namedImports || (entry.namedImports = /* @__PURE__ */ new Map())).get(symbolName2);
|
|
entry.namedImports.set(symbolName2, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly));
|
|
break;
|
|
case 3 /* CommonJS */:
|
|
case 2 /* Namespace */:
|
|
Debug.assert(entry.namespaceLikeImport === void 0 || entry.namespaceLikeImport.name === symbolName2, "Namespacelike import shoudl be missing or match symbolName");
|
|
entry.namespaceLikeImport = { importKind, name: symbolName2, addAsTypeOnly };
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case ImportFixKind.PromoteTypeOnly:
|
|
break;
|
|
default:
|
|
Debug.assertNever(fix, `fix wasn't never - got kind ${fix.kind}`);
|
|
}
|
|
function reduceAddAsTypeOnlyValues(prevValue, newValue) {
|
|
return Math.max(prevValue != null ? prevValue : 0, newValue);
|
|
}
|
|
function getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly) {
|
|
const typeOnlyKey = newImportsKey(moduleSpecifier, true);
|
|
const nonTypeOnlyKey = newImportsKey(moduleSpecifier, false);
|
|
const typeOnlyEntry = newImports.get(typeOnlyKey);
|
|
const nonTypeOnlyEntry = newImports.get(nonTypeOnlyKey);
|
|
const newEntry = {
|
|
defaultImport: void 0,
|
|
namedImports: void 0,
|
|
namespaceLikeImport: void 0,
|
|
useRequire
|
|
};
|
|
if (importKind === 1 /* Default */ && addAsTypeOnly === AddAsTypeOnly.Required) {
|
|
if (typeOnlyEntry)
|
|
return typeOnlyEntry;
|
|
newImports.set(typeOnlyKey, newEntry);
|
|
return newEntry;
|
|
}
|
|
if (addAsTypeOnly === AddAsTypeOnly.Allowed && (typeOnlyEntry || nonTypeOnlyEntry)) {
|
|
return typeOnlyEntry || nonTypeOnlyEntry;
|
|
}
|
|
if (nonTypeOnlyEntry) {
|
|
return nonTypeOnlyEntry;
|
|
}
|
|
newImports.set(nonTypeOnlyKey, newEntry);
|
|
return newEntry;
|
|
}
|
|
function newImportsKey(moduleSpecifier, topLevelTypeOnly) {
|
|
return `${topLevelTypeOnly ? 1 : 0}|${moduleSpecifier}`;
|
|
}
|
|
}
|
|
function writeFixes(changeTracker) {
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
for (const fix of addToNamespace) {
|
|
addNamespaceQualifier(changeTracker, sourceFile, fix);
|
|
}
|
|
for (const fix of importType) {
|
|
addImportType(changeTracker, sourceFile, fix, quotePreference);
|
|
}
|
|
addToExisting.forEach(({ importClauseOrBindingPattern, defaultImport, namedImports }) => {
|
|
doAddExistingFix(
|
|
changeTracker,
|
|
sourceFile,
|
|
importClauseOrBindingPattern,
|
|
defaultImport,
|
|
arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
|
|
compilerOptions
|
|
);
|
|
});
|
|
let newDeclarations;
|
|
newImports.forEach(({ useRequire, defaultImport, namedImports, namespaceLikeImport }, key) => {
|
|
const moduleSpecifier = key.slice(2);
|
|
const getDeclarations = useRequire ? getNewRequires : getNewImports;
|
|
const declarations = getDeclarations(
|
|
moduleSpecifier,
|
|
quotePreference,
|
|
defaultImport,
|
|
namedImports && arrayFrom(namedImports.entries(), ([name, addAsTypeOnly]) => ({ addAsTypeOnly, name })),
|
|
namespaceLikeImport
|
|
);
|
|
newDeclarations = combine(newDeclarations, declarations);
|
|
});
|
|
if (newDeclarations) {
|
|
insertImports(changeTracker, sourceFile, newDeclarations, true);
|
|
}
|
|
}
|
|
function hasFixes() {
|
|
return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0;
|
|
}
|
|
}
|
|
function createImportSpecifierResolver(importingFile, program, host, preferences) {
|
|
const packageJsonImportFilter = createPackageJsonImportFilter(importingFile, preferences, host);
|
|
const importMap = createExistingImportMap(program.getTypeChecker(), importingFile, program.getCompilerOptions());
|
|
return { getModuleSpecifierForBestExportInfo };
|
|
function getModuleSpecifierForBestExportInfo(exportInfo, symbolName2, position, isValidTypeOnlyUseSite, fromCacheOnly) {
|
|
const { fixes, computedWithoutCacheCount } = getImportFixes(
|
|
exportInfo,
|
|
{ symbolName: symbolName2, position },
|
|
isValidTypeOnlyUseSite,
|
|
false,
|
|
program,
|
|
importingFile,
|
|
host,
|
|
preferences,
|
|
importMap,
|
|
fromCacheOnly
|
|
);
|
|
const result = getBestFix(fixes, importingFile, program, packageJsonImportFilter, host);
|
|
return result && { ...result, computedWithoutCacheCount };
|
|
}
|
|
}
|
|
var ImportFixKind = /* @__PURE__ */ ((ImportFixKind2) => {
|
|
ImportFixKind2[ImportFixKind2["UseNamespace"] = 0] = "UseNamespace";
|
|
ImportFixKind2[ImportFixKind2["JsdocTypeImport"] = 1] = "JsdocTypeImport";
|
|
ImportFixKind2[ImportFixKind2["AddToExisting"] = 2] = "AddToExisting";
|
|
ImportFixKind2[ImportFixKind2["AddNew"] = 3] = "AddNew";
|
|
ImportFixKind2[ImportFixKind2["PromoteTypeOnly"] = 4] = "PromoteTypeOnly";
|
|
return ImportFixKind2;
|
|
})(ImportFixKind || {});
|
|
var AddAsTypeOnly = /* @__PURE__ */ ((AddAsTypeOnly2) => {
|
|
AddAsTypeOnly2[AddAsTypeOnly2["Allowed"] = 1] = "Allowed";
|
|
AddAsTypeOnly2[AddAsTypeOnly2["Required"] = 2] = "Required";
|
|
AddAsTypeOnly2[AddAsTypeOnly2["NotAllowed"] = 4] = "NotAllowed";
|
|
return AddAsTypeOnly2;
|
|
})(AddAsTypeOnly || {});
|
|
function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
|
|
Debug.assertIsDefined(exportInfos);
|
|
const useRequire = shouldUseRequire(sourceFile, program);
|
|
const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
|
|
const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, { symbolName: symbolName2, position }, isValidTypeOnlyUseSite, useRequire, host, preferences));
|
|
return {
|
|
moduleSpecifier: fix.moduleSpecifier,
|
|
codeAction: codeFixActionToCodeAction(codeActionForFix(
|
|
{ host, formatContext, preferences },
|
|
sourceFile,
|
|
symbolName2,
|
|
fix,
|
|
false,
|
|
getQuotePreference(sourceFile, preferences),
|
|
compilerOptions
|
|
))
|
|
};
|
|
}
|
|
function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) {
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const symbolName2 = single(getSymbolNamesToImport(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions));
|
|
const fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName2, program);
|
|
const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
|
|
return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, 1 /* Double */, compilerOptions));
|
|
}
|
|
function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, useNamespaceInfo, isValidTypeOnlyUseSite, useRequire, host, preferences) {
|
|
Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
|
|
const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
|
|
return getBestFix(getImportFixes(exportInfos, useNamespaceInfo, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
|
|
}
|
|
function codeFixActionToCodeAction({ description: description2, changes, commands }) {
|
|
return { description: description2, changes, commands };
|
|
}
|
|
function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
|
|
const getChecker = createGetChecker(program, host);
|
|
return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
|
|
if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
|
|
return info;
|
|
}
|
|
});
|
|
}
|
|
function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
|
|
var _a2, _b;
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const mainProgramInfo = getInfoWithChecker(program.getTypeChecker(), false);
|
|
if (mainProgramInfo) {
|
|
return mainProgramInfo;
|
|
}
|
|
const autoImportProvider = (_b = (_a2 = host.getPackageJsonAutoImportProvider) == null ? void 0 : _a2.call(host)) == null ? void 0 : _b.getTypeChecker();
|
|
return Debug.checkDefined(autoImportProvider && getInfoWithChecker(autoImportProvider, true), `Could not find symbol in specified module for code actions`);
|
|
function getInfoWithChecker(checker, isFromPackageJson) {
|
|
const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
|
|
if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
|
|
return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
|
|
}
|
|
const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
|
|
if (named && skipAlias(named, checker) === symbol) {
|
|
return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
|
|
}
|
|
}
|
|
}
|
|
function getImportFixes(exportInfos, useNamespaceInfo, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap = createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()), fromCacheOnly) {
|
|
const checker = program.getTypeChecker();
|
|
const existingImports = flatMap(exportInfos, importMap.getImportsForExportInfo);
|
|
const useNamespace = useNamespaceInfo && tryUseExistingNamespaceImport(existingImports, useNamespaceInfo.symbolName, useNamespaceInfo.position, checker);
|
|
const addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions());
|
|
if (addToExisting) {
|
|
return {
|
|
computedWithoutCacheCount: 0,
|
|
fixes: [...useNamespace ? [useNamespace] : emptyArray, addToExisting]
|
|
};
|
|
}
|
|
const { fixes, computedWithoutCacheCount = 0 } = getFixesForAddImport(
|
|
exportInfos,
|
|
existingImports,
|
|
program,
|
|
sourceFile,
|
|
useNamespaceInfo == null ? void 0 : useNamespaceInfo.position,
|
|
isValidTypeOnlyUseSite,
|
|
useRequire,
|
|
host,
|
|
preferences,
|
|
fromCacheOnly
|
|
);
|
|
return {
|
|
computedWithoutCacheCount,
|
|
fixes: [...useNamespace ? [useNamespace] : emptyArray, ...fixes]
|
|
};
|
|
}
|
|
function tryUseExistingNamespaceImport(existingImports, symbolName2, position, checker) {
|
|
return firstDefined(existingImports, ({ declaration }) => {
|
|
var _a2;
|
|
const namespacePrefix = getNamespaceLikeImportText(declaration);
|
|
const moduleSpecifier = (_a2 = tryGetModuleSpecifierFromDeclaration(declaration)) == null ? void 0 : _a2.text;
|
|
if (namespacePrefix && moduleSpecifier) {
|
|
const moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker);
|
|
if (moduleSymbol && moduleSymbol.exports.has(escapeLeadingUnderscores(symbolName2))) {
|
|
return { kind: 0 /* UseNamespace */, namespacePrefix, position, moduleSpecifier };
|
|
}
|
|
}
|
|
});
|
|
}
|
|
function getTargetModuleFromNamespaceLikeImport(declaration, checker) {
|
|
var _a2;
|
|
switch (declaration.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return checker.resolveExternalModuleName(declaration.initializer.arguments[0]);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return checker.getAliasedSymbol(declaration.symbol);
|
|
case 269 /* ImportDeclaration */:
|
|
const namespaceImport = tryCast((_a2 = declaration.importClause) == null ? void 0 : _a2.namedBindings, isNamespaceImport);
|
|
return namespaceImport && checker.getAliasedSymbol(namespaceImport.symbol);
|
|
default:
|
|
return Debug.assertNever(declaration);
|
|
}
|
|
}
|
|
function getNamespaceLikeImportText(declaration) {
|
|
var _a2, _b, _c;
|
|
switch (declaration.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return (_a2 = tryCast(declaration.name, isIdentifier)) == null ? void 0 : _a2.text;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return declaration.name.text;
|
|
case 269 /* ImportDeclaration */:
|
|
return (_c = tryCast((_b = declaration.importClause) == null ? void 0 : _b.namedBindings, isNamespaceImport)) == null ? void 0 : _c.name.text;
|
|
default:
|
|
return Debug.assertNever(declaration);
|
|
}
|
|
}
|
|
function getAddAsTypeOnly(isValidTypeOnlyUseSite, isForNewImportDeclaration, symbol, targetFlags, checker, compilerOptions) {
|
|
if (!isValidTypeOnlyUseSite) {
|
|
return 4 /* NotAllowed */;
|
|
}
|
|
if (isForNewImportDeclaration && compilerOptions.importsNotUsedAsValues === 2 /* Error */) {
|
|
return 2 /* Required */;
|
|
}
|
|
if (compilerOptions.isolatedModules && compilerOptions.preserveValueImports && (!(targetFlags & 111551 /* Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) {
|
|
return 2 /* Required */;
|
|
}
|
|
return 1 /* Allowed */;
|
|
}
|
|
function tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, compilerOptions) {
|
|
return firstDefined(existingImports, ({ declaration, importKind, symbol, targetFlags }) => {
|
|
if (importKind === 3 /* CommonJS */ || importKind === 2 /* Namespace */ || declaration.kind === 268 /* ImportEqualsDeclaration */) {
|
|
return void 0;
|
|
}
|
|
if (declaration.kind === 257 /* VariableDeclaration */) {
|
|
return (importKind === 0 /* Named */ || importKind === 1 /* Default */) && declaration.name.kind === 203 /* ObjectBindingPattern */ ? { kind: 2 /* AddToExisting */, importClauseOrBindingPattern: declaration.name, importKind, moduleSpecifier: declaration.initializer.arguments[0].text, addAsTypeOnly: 4 /* NotAllowed */ } : void 0;
|
|
}
|
|
const { importClause } = declaration;
|
|
if (!importClause || !isStringLiteralLike(declaration.moduleSpecifier))
|
|
return void 0;
|
|
const { name, namedBindings } = importClause;
|
|
if (importClause.isTypeOnly && !(importKind === 0 /* Named */ && namedBindings))
|
|
return void 0;
|
|
const addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, false, symbol, targetFlags, checker, compilerOptions);
|
|
if (importKind === 1 /* Default */ && (name || addAsTypeOnly === 2 /* Required */ && namedBindings))
|
|
return void 0;
|
|
if (importKind === 0 /* Named */ && (namedBindings == null ? void 0 : namedBindings.kind) === 271 /* NamespaceImport */)
|
|
return void 0;
|
|
return {
|
|
kind: 2 /* AddToExisting */,
|
|
importClauseOrBindingPattern: importClause,
|
|
importKind,
|
|
moduleSpecifier: declaration.moduleSpecifier.text,
|
|
addAsTypeOnly
|
|
};
|
|
});
|
|
}
|
|
function createExistingImportMap(checker, importingFile, compilerOptions) {
|
|
let importMap;
|
|
for (const moduleSpecifier of importingFile.imports) {
|
|
const i = importFromModuleSpecifier(moduleSpecifier);
|
|
if (isVariableDeclarationInitializedToRequire(i.parent)) {
|
|
const moduleSymbol = checker.resolveExternalModuleName(moduleSpecifier);
|
|
if (moduleSymbol) {
|
|
(importMap || (importMap = createMultiMap())).add(getSymbolId(moduleSymbol), i.parent);
|
|
}
|
|
} else if (i.kind === 269 /* ImportDeclaration */ || i.kind === 268 /* ImportEqualsDeclaration */) {
|
|
const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
|
|
if (moduleSymbol) {
|
|
(importMap || (importMap = createMultiMap())).add(getSymbolId(moduleSymbol), i);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
getImportsForExportInfo: ({ moduleSymbol, exportKind, targetFlags, symbol }) => {
|
|
if (!(targetFlags & 111551 /* Value */) && isSourceFileJS(importingFile))
|
|
return emptyArray;
|
|
const matchingDeclarations = importMap == null ? void 0 : importMap.get(getSymbolId(moduleSymbol));
|
|
if (!matchingDeclarations)
|
|
return emptyArray;
|
|
const importKind = getImportKind(importingFile, exportKind, compilerOptions);
|
|
return matchingDeclarations.map((declaration) => ({ declaration, importKind, symbol, targetFlags }));
|
|
}
|
|
};
|
|
}
|
|
function shouldUseRequire(sourceFile, program) {
|
|
if (!isSourceFileJS(sourceFile)) {
|
|
return false;
|
|
}
|
|
if (sourceFile.commonJsModuleIndicator && !sourceFile.externalModuleIndicator)
|
|
return true;
|
|
if (sourceFile.externalModuleIndicator && !sourceFile.commonJsModuleIndicator)
|
|
return false;
|
|
const compilerOptions = program.getCompilerOptions();
|
|
if (compilerOptions.configFile) {
|
|
return getEmitModuleKind(compilerOptions) < 5 /* ES2015 */;
|
|
}
|
|
for (const otherFile of program.getSourceFiles()) {
|
|
if (otherFile === sourceFile || !isSourceFileJS(otherFile) || program.isSourceFileFromExternalLibrary(otherFile))
|
|
continue;
|
|
if (otherFile.commonJsModuleIndicator && !otherFile.externalModuleIndicator)
|
|
return true;
|
|
if (otherFile.externalModuleIndicator && !otherFile.commonJsModuleIndicator)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function createGetChecker(program, host) {
|
|
return memoizeOne((isFromPackageJson) => isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker());
|
|
}
|
|
function getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfo, host, preferences, fromCacheOnly) {
|
|
const isJs = isSourceFileJS(sourceFile);
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const moduleSpecifierResolutionHost = createModuleSpecifierResolutionHost(program, host);
|
|
const getChecker = createGetChecker(program, host);
|
|
const rejectNodeModulesRelativePaths = moduleResolutionUsesNodeModules(getEmitModuleResolutionKind(compilerOptions));
|
|
const getModuleSpecifiers2 = fromCacheOnly ? (moduleSymbol) => ({ moduleSpecifiers: ts_moduleSpecifiers_exports.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }) : (moduleSymbol, checker) => ts_moduleSpecifiers_exports.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences);
|
|
let computedWithoutCacheCount = 0;
|
|
const fixes = flatMap(exportInfo, (exportInfo2, i) => {
|
|
const checker = getChecker(exportInfo2.isFromPackageJson);
|
|
const { computedWithoutCache, moduleSpecifiers } = getModuleSpecifiers2(exportInfo2.moduleSymbol, checker);
|
|
const importedSymbolHasValueMeaning = !!(exportInfo2.targetFlags & 111551 /* Value */);
|
|
const addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, true, exportInfo2.symbol, exportInfo2.targetFlags, checker, compilerOptions);
|
|
computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
|
|
return mapDefined(
|
|
moduleSpecifiers,
|
|
(moduleSpecifier) => rejectNodeModulesRelativePaths && pathContainsNodeModules(moduleSpecifier) ? void 0 : !importedSymbolHasValueMeaning && isJs && position !== void 0 ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier, position, exportInfo: exportInfo2, isReExport: i > 0 } : {
|
|
kind: 3 /* AddNew */,
|
|
moduleSpecifier,
|
|
importKind: getImportKind(sourceFile, exportInfo2.exportKind, compilerOptions),
|
|
useRequire,
|
|
addAsTypeOnly,
|
|
exportInfo: exportInfo2,
|
|
isReExport: i > 0
|
|
}
|
|
);
|
|
});
|
|
return { computedWithoutCacheCount, fixes };
|
|
}
|
|
function getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, host, preferences, fromCacheOnly) {
|
|
const existingDeclaration = firstDefined(existingImports, (info) => newImportInfoFromExistingSpecifier(info, isValidTypeOnlyUseSite, useRequire, program.getTypeChecker(), program.getCompilerOptions()));
|
|
return existingDeclaration ? { fixes: [existingDeclaration] } : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences, fromCacheOnly);
|
|
}
|
|
function newImportInfoFromExistingSpecifier({ declaration, importKind, symbol, targetFlags }, isValidTypeOnlyUseSite, useRequire, checker, compilerOptions) {
|
|
var _a2;
|
|
const moduleSpecifier = (_a2 = tryGetModuleSpecifierFromDeclaration(declaration)) == null ? void 0 : _a2.text;
|
|
if (moduleSpecifier) {
|
|
const addAsTypeOnly = useRequire ? 4 /* NotAllowed */ : getAddAsTypeOnly(isValidTypeOnlyUseSite, true, symbol, targetFlags, checker, compilerOptions);
|
|
return { kind: 3 /* AddNew */, moduleSpecifier, importKind, addAsTypeOnly, useRequire };
|
|
}
|
|
}
|
|
function getFixInfos(context, errorCode, pos, useAutoImportProvider) {
|
|
const symbolToken = getTokenAtPosition(context.sourceFile, pos);
|
|
let info;
|
|
if (errorCode === Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
|
|
info = getFixesInfoForUMDImport(context, symbolToken);
|
|
} else if (!isIdentifier(symbolToken)) {
|
|
return void 0;
|
|
} else if (errorCode === Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) {
|
|
const symbolName2 = single(getSymbolNamesToImport(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions()));
|
|
const fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName2, context.program);
|
|
return fix && [{ fix, symbolName: symbolName2, errorIdentifierText: symbolToken.text }];
|
|
} else {
|
|
info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
|
|
}
|
|
const packageJsonImportFilter = createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
|
|
return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host);
|
|
}
|
|
function sortFixInfo(fixes, sourceFile, program, packageJsonImportFilter, host) {
|
|
const _toPath = (fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host));
|
|
return sort(fixes, (a, b) => compareBooleans(!!a.isJsxNamespaceFix, !!b.isJsxNamespaceFix) || compareValues(a.fix.kind, b.fix.kind) || compareModuleSpecifiers(a.fix, b.fix, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath));
|
|
}
|
|
function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
|
|
if (!some(fixes))
|
|
return;
|
|
if (fixes[0].kind === 0 /* UseNamespace */ || fixes[0].kind === 2 /* AddToExisting */) {
|
|
return fixes[0];
|
|
}
|
|
return fixes.reduce(
|
|
(best, fix) => compareModuleSpecifiers(
|
|
fix,
|
|
best,
|
|
sourceFile,
|
|
program,
|
|
packageJsonImportFilter.allowsImportingSpecifier,
|
|
(fileName) => toPath(fileName, host.getCurrentDirectory(), hostGetCanonicalFileName(host))
|
|
) === -1 /* LessThan */ ? fix : best
|
|
);
|
|
}
|
|
function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath3) {
|
|
if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
|
|
return compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier)) || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program) || compareBooleans(
|
|
isFixPossiblyReExportingImportingFile(a, importingFile, program.getCompilerOptions(), toPath3),
|
|
isFixPossiblyReExportingImportingFile(b, importingFile, program.getCompilerOptions(), toPath3)
|
|
) || compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
|
|
}
|
|
return 0 /* EqualTo */;
|
|
}
|
|
function isFixPossiblyReExportingImportingFile(fix, importingFile, compilerOptions, toPath3) {
|
|
var _a2;
|
|
if (fix.isReExport && ((_a2 = fix.exportInfo) == null ? void 0 : _a2.moduleFileName) && getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */ && isIndexFileName(fix.exportInfo.moduleFileName)) {
|
|
const reExportDir = toPath3(getDirectoryPath(fix.exportInfo.moduleFileName));
|
|
return startsWith(importingFile.path, reExportDir);
|
|
}
|
|
return false;
|
|
}
|
|
function isIndexFileName(fileName) {
|
|
return getBaseFileName(fileName, [".js", ".jsx", ".d.ts", ".ts", ".tsx"], true) === "index";
|
|
}
|
|
function compareNodeCoreModuleSpecifiers(a, b, importingFile, program) {
|
|
if (startsWith(a, "node:") && !startsWith(b, "node:"))
|
|
return shouldUseUriStyleNodeCoreModules(importingFile, program) ? -1 /* LessThan */ : 1 /* GreaterThan */;
|
|
if (startsWith(b, "node:") && !startsWith(a, "node:"))
|
|
return shouldUseUriStyleNodeCoreModules(importingFile, program) ? 1 /* GreaterThan */ : -1 /* LessThan */;
|
|
return 0 /* EqualTo */;
|
|
}
|
|
function getFixesInfoForUMDImport({ sourceFile, program, host, preferences }, token) {
|
|
const checker = program.getTypeChecker();
|
|
const umdSymbol = getUmdSymbol(token, checker);
|
|
if (!umdSymbol)
|
|
return void 0;
|
|
const symbol = checker.getAliasedSymbol(umdSymbol);
|
|
const symbolName2 = umdSymbol.name;
|
|
const exportInfo = [{ symbol: umdSymbol, moduleSymbol: symbol, moduleFileName: void 0, exportKind: 3 /* UMD */, targetFlags: symbol.flags, isFromPackageJson: false }];
|
|
const useRequire = shouldUseRequire(sourceFile, program);
|
|
const position = isIdentifier(token) ? token.getStart(sourceFile) : void 0;
|
|
const fixes = getImportFixes(exportInfo, position ? { position, symbolName: symbolName2 } : void 0, false, useRequire, program, sourceFile, host, preferences).fixes;
|
|
return fixes.map((fix) => {
|
|
var _a2;
|
|
return { fix, symbolName: symbolName2, errorIdentifierText: (_a2 = tryCast(token, isIdentifier)) == null ? void 0 : _a2.text };
|
|
});
|
|
}
|
|
function getUmdSymbol(token, checker) {
|
|
const umdSymbol = isIdentifier(token) ? checker.getSymbolAtLocation(token) : void 0;
|
|
if (isUMDExportSymbol(umdSymbol))
|
|
return umdSymbol;
|
|
const { parent: parent2 } = token;
|
|
return isJsxOpeningLikeElement(parent2) && parent2.tagName === token || isJsxOpeningFragment(parent2) ? tryCast(checker.resolveName(checker.getJsxNamespace(parent2), isJsxOpeningLikeElement(parent2) ? token : parent2, 111551 /* Value */, false), isUMDExportSymbol) : void 0;
|
|
}
|
|
function getImportKind(importingFile, exportKind, compilerOptions, forceImportKeyword) {
|
|
switch (exportKind) {
|
|
case 0 /* Named */:
|
|
return 0 /* Named */;
|
|
case 1 /* Default */:
|
|
return 1 /* Default */;
|
|
case 2 /* ExportEquals */:
|
|
return getExportEqualsImportKind(importingFile, compilerOptions, !!forceImportKeyword);
|
|
case 3 /* UMD */:
|
|
return getUmdImportKind(importingFile, compilerOptions, !!forceImportKeyword);
|
|
default:
|
|
return Debug.assertNever(exportKind);
|
|
}
|
|
}
|
|
function getUmdImportKind(importingFile, compilerOptions, forceImportKeyword) {
|
|
if (getAllowSyntheticDefaultImports(compilerOptions)) {
|
|
return 1 /* Default */;
|
|
}
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
switch (moduleKind) {
|
|
case 2 /* AMD */:
|
|
case 1 /* CommonJS */:
|
|
case 3 /* UMD */:
|
|
if (isInJSFile(importingFile)) {
|
|
return isExternalModule(importingFile) || forceImportKeyword ? 2 /* Namespace */ : 3 /* CommonJS */;
|
|
}
|
|
return 3 /* CommonJS */;
|
|
case 4 /* System */:
|
|
case 5 /* ES2015 */:
|
|
case 6 /* ES2020 */:
|
|
case 7 /* ES2022 */:
|
|
case 99 /* ESNext */:
|
|
case 0 /* None */:
|
|
return 2 /* Namespace */;
|
|
case 100 /* Node16 */:
|
|
case 199 /* NodeNext */:
|
|
return importingFile.impliedNodeFormat === 99 /* ESNext */ ? 2 /* Namespace */ : 3 /* CommonJS */;
|
|
default:
|
|
return Debug.assertNever(moduleKind, `Unexpected moduleKind ${moduleKind}`);
|
|
}
|
|
}
|
|
function getFixesInfoForNonUMDImport({ sourceFile, program, cancellationToken, host, preferences }, symbolToken, useAutoImportProvider) {
|
|
const checker = program.getTypeChecker();
|
|
const compilerOptions = program.getCompilerOptions();
|
|
return flatMap(getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions), (symbolName2) => {
|
|
if (symbolName2 === "default" /* Default */) {
|
|
return void 0;
|
|
}
|
|
const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(symbolToken);
|
|
const useRequire = shouldUseRequire(sourceFile, program);
|
|
const exportInfo = getExportInfos(symbolName2, isJSXTagName(symbolToken), getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
|
|
const fixes = arrayFrom(flatMapIterator(exportInfo.entries(), ([_, exportInfos]) => getImportFixes(exportInfos, { symbolName: symbolName2, position: symbolToken.getStart(sourceFile) }, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes));
|
|
return fixes.map((fix) => ({ fix, symbolName: symbolName2, errorIdentifierText: symbolToken.text, isJsxNamespaceFix: symbolName2 !== symbolToken.text }));
|
|
});
|
|
}
|
|
function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName2, program) {
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.resolveName(symbolName2, symbolToken, 111551 /* Value */, true);
|
|
if (!symbol)
|
|
return void 0;
|
|
const typeOnlyAliasDeclaration = checker.getTypeOnlyAliasDeclaration(symbol);
|
|
if (!typeOnlyAliasDeclaration || getSourceFileOfNode(typeOnlyAliasDeclaration) !== sourceFile)
|
|
return void 0;
|
|
return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration };
|
|
}
|
|
function getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions) {
|
|
const parent2 = symbolToken.parent;
|
|
if ((isJsxOpeningLikeElement(parent2) || isJsxClosingElement(parent2)) && parent2.tagName === symbolToken && jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
|
|
const jsxNamespace = checker.getJsxNamespace(sourceFile);
|
|
if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
|
|
const needsComponentNameFix = !isIntrinsicJsxName(symbolToken.text) && !checker.resolveName(symbolToken.text, symbolToken, 111551 /* Value */, false);
|
|
return needsComponentNameFix ? [symbolToken.text, jsxNamespace] : [jsxNamespace];
|
|
}
|
|
}
|
|
return [symbolToken.text];
|
|
}
|
|
function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) {
|
|
if (isIntrinsicJsxName(symbolToken.text))
|
|
return true;
|
|
const namespaceSymbol = checker.resolveName(jsxNamespace, symbolToken, 111551 /* Value */, true);
|
|
return !namespaceSymbol || some(namespaceSymbol.declarations, isTypeOnlyImportOrExportDeclaration) && !(namespaceSymbol.flags & 111551 /* Value */);
|
|
}
|
|
function getExportInfos(symbolName2, isJsxTagName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) {
|
|
var _a2;
|
|
const originalSymbolToExportInfos = createMultiMap();
|
|
const packageJsonFilter = createPackageJsonImportFilter(fromFile, preferences, host);
|
|
const moduleSpecifierCache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
const getModuleSpecifierResolutionHost = memoizeOne((isFromPackageJson) => {
|
|
return createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host);
|
|
});
|
|
function addSymbol(moduleSymbol, toFile, exportedSymbol, exportKind, program2, isFromPackageJson) {
|
|
const moduleSpecifierResolutionHost = getModuleSpecifierResolutionHost(isFromPackageJson);
|
|
if (toFile && isImportableFile(program2, fromFile, toFile, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) || !toFile && packageJsonFilter.allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost)) {
|
|
const checker = program2.getTypeChecker();
|
|
originalSymbolToExportInfos.add(getUniqueSymbolId(exportedSymbol, checker).toString(), { symbol: exportedSymbol, moduleSymbol, moduleFileName: toFile == null ? void 0 : toFile.fileName, exportKind, targetFlags: skipAlias(exportedSymbol, checker).flags, isFromPackageJson });
|
|
}
|
|
}
|
|
forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, (moduleSymbol, sourceFile, program2, isFromPackageJson) => {
|
|
const checker = program2.getTypeChecker();
|
|
cancellationToken.throwIfCancellationRequested();
|
|
const compilerOptions = program2.getCompilerOptions();
|
|
const defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions);
|
|
if (defaultInfo && (defaultInfo.name === symbolName2 || moduleSymbolToValidIdentifier(moduleSymbol, getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName2) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) {
|
|
addSymbol(moduleSymbol, sourceFile, defaultInfo.symbol, defaultInfo.exportKind, program2, isFromPackageJson);
|
|
}
|
|
const exportSymbolWithIdenticalName = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
|
|
if (exportSymbolWithIdenticalName && symbolHasMeaning(exportSymbolWithIdenticalName, currentTokenMeaning)) {
|
|
addSymbol(moduleSymbol, sourceFile, exportSymbolWithIdenticalName, 0 /* Named */, program2, isFromPackageJson);
|
|
}
|
|
});
|
|
return originalSymbolToExportInfos;
|
|
}
|
|
function getExportEqualsImportKind(importingFile, compilerOptions, forceImportKeyword) {
|
|
const allowSyntheticDefaults = getAllowSyntheticDefaultImports(compilerOptions);
|
|
const isJS = isInJSFile(importingFile);
|
|
if (!isJS && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */) {
|
|
return allowSyntheticDefaults ? 1 /* Default */ : 2 /* Namespace */;
|
|
}
|
|
if (isJS) {
|
|
return isExternalModule(importingFile) || forceImportKeyword ? allowSyntheticDefaults ? 1 /* Default */ : 2 /* Namespace */ : 3 /* CommonJS */;
|
|
}
|
|
for (const statement of importingFile.statements) {
|
|
if (isImportEqualsDeclaration(statement) && !nodeIsMissing(statement.moduleReference)) {
|
|
return 3 /* CommonJS */;
|
|
}
|
|
}
|
|
return allowSyntheticDefaults ? 1 /* Default */ : 3 /* CommonJS */;
|
|
}
|
|
function codeActionForFix(context, sourceFile, symbolName2, fix, includeSymbolNameInDescription, quotePreference, compilerOptions) {
|
|
let diag2;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (tracker) => {
|
|
diag2 = codeActionForFixWorker(tracker, sourceFile, symbolName2, fix, includeSymbolNameInDescription, quotePreference, compilerOptions);
|
|
});
|
|
return createCodeFixAction(importFixName, changes, diag2, importFixId, Diagnostics.Add_all_missing_imports);
|
|
}
|
|
function codeActionForFixWorker(changes, sourceFile, symbolName2, fix, includeSymbolNameInDescription, quotePreference, compilerOptions) {
|
|
switch (fix.kind) {
|
|
case 0 /* UseNamespace */:
|
|
addNamespaceQualifier(changes, sourceFile, fix);
|
|
return [Diagnostics.Change_0_to_1, symbolName2, `${fix.namespacePrefix}.${symbolName2}`];
|
|
case 1 /* JsdocTypeImport */:
|
|
addImportType(changes, sourceFile, fix, quotePreference);
|
|
return [Diagnostics.Change_0_to_1, symbolName2, getImportTypePrefix(fix.moduleSpecifier, quotePreference) + symbolName2];
|
|
case 2 /* AddToExisting */: {
|
|
const { importClauseOrBindingPattern, importKind, addAsTypeOnly, moduleSpecifier } = fix;
|
|
doAddExistingFix(
|
|
changes,
|
|
sourceFile,
|
|
importClauseOrBindingPattern,
|
|
importKind === 1 /* Default */ ? { name: symbolName2, addAsTypeOnly } : void 0,
|
|
importKind === 0 /* Named */ ? [{ name: symbolName2, addAsTypeOnly }] : emptyArray,
|
|
compilerOptions
|
|
);
|
|
const moduleSpecifierWithoutQuotes = stripQuotes(moduleSpecifier);
|
|
return includeSymbolNameInDescription ? [Diagnostics.Import_0_from_1, symbolName2, moduleSpecifierWithoutQuotes] : [Diagnostics.Update_import_from_0, moduleSpecifierWithoutQuotes];
|
|
}
|
|
case 3 /* AddNew */: {
|
|
const { importKind, moduleSpecifier, addAsTypeOnly, useRequire } = fix;
|
|
const getDeclarations = useRequire ? getNewRequires : getNewImports;
|
|
const defaultImport = importKind === 1 /* Default */ ? { name: symbolName2, addAsTypeOnly } : void 0;
|
|
const namedImports = importKind === 0 /* Named */ ? [{ name: symbolName2, addAsTypeOnly }] : void 0;
|
|
const namespaceLikeImport = importKind === 2 /* Namespace */ || importKind === 3 /* CommonJS */ ? { importKind, name: symbolName2, addAsTypeOnly } : void 0;
|
|
insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport), true);
|
|
return includeSymbolNameInDescription ? [Diagnostics.Import_0_from_1, symbolName2, moduleSpecifier] : [Diagnostics.Add_import_from_0, moduleSpecifier];
|
|
}
|
|
case 4 /* PromoteTypeOnly */: {
|
|
const { typeOnlyAliasDeclaration } = fix;
|
|
const promotedDeclaration = promoteFromTypeOnly(changes, typeOnlyAliasDeclaration, compilerOptions, sourceFile);
|
|
return promotedDeclaration.kind === 273 /* ImportSpecifier */ ? [Diagnostics.Remove_type_from_import_of_0_from_1, symbolName2, getModuleSpecifierText(promotedDeclaration.parent.parent)] : [Diagnostics.Remove_type_from_import_declaration_from_0, getModuleSpecifierText(promotedDeclaration)];
|
|
}
|
|
default:
|
|
return Debug.assertNever(fix, `Unexpected fix kind ${fix.kind}`);
|
|
}
|
|
}
|
|
function getModuleSpecifierText(promotedDeclaration) {
|
|
var _a2, _b;
|
|
return promotedDeclaration.kind === 268 /* ImportEqualsDeclaration */ ? ((_b = tryCast((_a2 = tryCast(promotedDeclaration.moduleReference, isExternalModuleReference)) == null ? void 0 : _a2.expression, isStringLiteralLike)) == null ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText() : cast(promotedDeclaration.parent.moduleSpecifier, isStringLiteral).text;
|
|
}
|
|
function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile) {
|
|
const convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
|
|
switch (aliasDeclaration.kind) {
|
|
case 273 /* ImportSpecifier */:
|
|
if (aliasDeclaration.isTypeOnly) {
|
|
if (aliasDeclaration.parent.elements.length > 1 && ts_OrganizeImports_exports.importSpecifiersAreSorted(aliasDeclaration.parent.elements)) {
|
|
changes.delete(sourceFile, aliasDeclaration);
|
|
const newSpecifier = factory.updateImportSpecifier(aliasDeclaration, false, aliasDeclaration.propertyName, aliasDeclaration.name);
|
|
const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier);
|
|
changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
|
|
} else {
|
|
changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
|
|
}
|
|
return aliasDeclaration;
|
|
} else {
|
|
Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
|
|
promoteImportClause(aliasDeclaration.parent.parent);
|
|
return aliasDeclaration.parent.parent;
|
|
}
|
|
case 270 /* ImportClause */:
|
|
promoteImportClause(aliasDeclaration);
|
|
return aliasDeclaration;
|
|
case 271 /* NamespaceImport */:
|
|
promoteImportClause(aliasDeclaration.parent);
|
|
return aliasDeclaration.parent;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
changes.deleteRange(sourceFile, aliasDeclaration.getChildAt(1));
|
|
return aliasDeclaration;
|
|
default:
|
|
Debug.failBadSyntaxKind(aliasDeclaration);
|
|
}
|
|
function promoteImportClause(importClause) {
|
|
changes.delete(sourceFile, getTypeKeywordOfTypeOnlyImport(importClause, sourceFile));
|
|
if (convertExistingToTypeOnly) {
|
|
const namedImports = tryCast(importClause.namedBindings, isNamedImports);
|
|
if (namedImports && namedImports.elements.length > 1) {
|
|
if (ts_OrganizeImports_exports.importSpecifiersAreSorted(namedImports.elements) && aliasDeclaration.kind === 273 /* ImportSpecifier */ && namedImports.elements.indexOf(aliasDeclaration) !== 0) {
|
|
changes.delete(sourceFile, aliasDeclaration);
|
|
changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0);
|
|
}
|
|
for (const element of namedImports.elements) {
|
|
if (element !== aliasDeclaration && !element.isTypeOnly) {
|
|
changes.insertModifierBefore(sourceFile, 154 /* TypeKeyword */, element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) {
|
|
var _a2;
|
|
if (clause.kind === 203 /* ObjectBindingPattern */) {
|
|
if (defaultImport) {
|
|
addElementToBindingPattern(clause, defaultImport.name, "default");
|
|
}
|
|
for (const specifier of namedImports) {
|
|
addElementToBindingPattern(clause, specifier.name, void 0);
|
|
}
|
|
return;
|
|
}
|
|
const promoteFromTypeOnly2 = clause.isTypeOnly && some([defaultImport, ...namedImports], (i) => (i == null ? void 0 : i.addAsTypeOnly) === 4 /* NotAllowed */);
|
|
const existingSpecifiers = clause.namedBindings && ((_a2 = tryCast(clause.namedBindings, isNamedImports)) == null ? void 0 : _a2.elements);
|
|
const convertExistingToTypeOnly = promoteFromTypeOnly2 && compilerOptions.preserveValueImports && compilerOptions.isolatedModules;
|
|
if (defaultImport) {
|
|
Debug.assert(!clause.name, "Cannot add a default import to an import clause that already has one");
|
|
changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), factory.createIdentifier(defaultImport.name), { suffix: ", " });
|
|
}
|
|
if (namedImports.length) {
|
|
const newSpecifiers = stableSort(
|
|
namedImports.map((namedImport) => factory.createImportSpecifier(
|
|
(!clause.isTypeOnly || promoteFromTypeOnly2) && needsTypeOnly(namedImport),
|
|
void 0,
|
|
factory.createIdentifier(namedImport.name)
|
|
)),
|
|
ts_OrganizeImports_exports.compareImportOrExportSpecifiers
|
|
);
|
|
if ((existingSpecifiers == null ? void 0 : existingSpecifiers.length) && ts_OrganizeImports_exports.importSpecifiersAreSorted(existingSpecifiers)) {
|
|
for (const spec of newSpecifiers) {
|
|
const insertionIndex = convertExistingToTypeOnly && !spec.isTypeOnly ? 0 : ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(existingSpecifiers, spec);
|
|
changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex);
|
|
}
|
|
} else if (existingSpecifiers == null ? void 0 : existingSpecifiers.length) {
|
|
for (const spec of newSpecifiers) {
|
|
changes.insertNodeInListAfter(sourceFile, last(existingSpecifiers), spec, existingSpecifiers);
|
|
}
|
|
} else {
|
|
if (newSpecifiers.length) {
|
|
const namedImports2 = factory.createNamedImports(newSpecifiers);
|
|
if (clause.namedBindings) {
|
|
changes.replaceNode(sourceFile, clause.namedBindings, namedImports2);
|
|
} else {
|
|
changes.insertNodeAfter(sourceFile, Debug.checkDefined(clause.name, "Import clause must have either named imports or a default import"), namedImports2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (promoteFromTypeOnly2) {
|
|
changes.delete(sourceFile, getTypeKeywordOfTypeOnlyImport(clause, sourceFile));
|
|
if (convertExistingToTypeOnly && existingSpecifiers) {
|
|
for (const specifier of existingSpecifiers) {
|
|
changes.insertModifierBefore(sourceFile, 154 /* TypeKeyword */, specifier);
|
|
}
|
|
}
|
|
}
|
|
function addElementToBindingPattern(bindingPattern, name, propertyName) {
|
|
const element = factory.createBindingElement(void 0, propertyName, name);
|
|
if (bindingPattern.elements.length) {
|
|
changes.insertNodeInListAfter(sourceFile, last(bindingPattern.elements), element);
|
|
} else {
|
|
changes.replaceNode(sourceFile, bindingPattern, factory.createObjectBindingPattern([element]));
|
|
}
|
|
}
|
|
}
|
|
function addNamespaceQualifier(changes, sourceFile, { namespacePrefix, position }) {
|
|
changes.insertText(sourceFile, position, namespacePrefix + ".");
|
|
}
|
|
function addImportType(changes, sourceFile, { moduleSpecifier, position }, quotePreference) {
|
|
changes.insertText(sourceFile, position, getImportTypePrefix(moduleSpecifier, quotePreference));
|
|
}
|
|
function getImportTypePrefix(moduleSpecifier, quotePreference) {
|
|
const quote2 = getQuoteFromPreference(quotePreference);
|
|
return `import(${quote2}${moduleSpecifier}${quote2}).`;
|
|
}
|
|
function needsTypeOnly({ addAsTypeOnly }) {
|
|
return addAsTypeOnly === 2 /* Required */;
|
|
}
|
|
function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) {
|
|
const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference);
|
|
let statements;
|
|
if (defaultImport !== void 0 || (namedImports == null ? void 0 : namedImports.length)) {
|
|
const topLevelTypeOnly = (!defaultImport || needsTypeOnly(defaultImport)) && every(namedImports, needsTypeOnly);
|
|
statements = combine(statements, makeImport(
|
|
defaultImport && factory.createIdentifier(defaultImport.name),
|
|
namedImports == null ? void 0 : namedImports.map(({ addAsTypeOnly, name }) => factory.createImportSpecifier(
|
|
!topLevelTypeOnly && addAsTypeOnly === 2 /* Required */,
|
|
void 0,
|
|
factory.createIdentifier(name)
|
|
)),
|
|
moduleSpecifier,
|
|
quotePreference,
|
|
topLevelTypeOnly
|
|
));
|
|
}
|
|
if (namespaceLikeImport) {
|
|
const declaration = namespaceLikeImport.importKind === 3 /* CommonJS */ ? factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
needsTypeOnly(namespaceLikeImport),
|
|
factory.createIdentifier(namespaceLikeImport.name),
|
|
factory.createExternalModuleReference(quotedModuleSpecifier)
|
|
) : factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(
|
|
needsTypeOnly(namespaceLikeImport),
|
|
void 0,
|
|
factory.createNamespaceImport(factory.createIdentifier(namespaceLikeImport.name))
|
|
),
|
|
quotedModuleSpecifier,
|
|
void 0
|
|
);
|
|
statements = combine(statements, declaration);
|
|
}
|
|
return Debug.checkDefined(statements);
|
|
}
|
|
function getNewRequires(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) {
|
|
const quotedModuleSpecifier = makeStringLiteral(moduleSpecifier, quotePreference);
|
|
let statements;
|
|
if (defaultImport || (namedImports == null ? void 0 : namedImports.length)) {
|
|
const bindingElements = (namedImports == null ? void 0 : namedImports.map(({ name }) => factory.createBindingElement(void 0, void 0, name))) || [];
|
|
if (defaultImport) {
|
|
bindingElements.unshift(factory.createBindingElement(void 0, "default", defaultImport.name));
|
|
}
|
|
const declaration = createConstEqualsRequireDeclaration(factory.createObjectBindingPattern(bindingElements), quotedModuleSpecifier);
|
|
statements = combine(statements, declaration);
|
|
}
|
|
if (namespaceLikeImport) {
|
|
const declaration = createConstEqualsRequireDeclaration(namespaceLikeImport.name, quotedModuleSpecifier);
|
|
statements = combine(statements, declaration);
|
|
}
|
|
return Debug.checkDefined(statements);
|
|
}
|
|
function createConstEqualsRequireDeclaration(name, quotedModuleSpecifier) {
|
|
return factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[
|
|
factory.createVariableDeclaration(
|
|
typeof name === "string" ? factory.createIdentifier(name) : name,
|
|
void 0,
|
|
void 0,
|
|
factory.createCallExpression(factory.createIdentifier("require"), void 0, [quotedModuleSpecifier])
|
|
)
|
|
],
|
|
2 /* Const */
|
|
)
|
|
);
|
|
}
|
|
function symbolHasMeaning({ declarations }, meaning) {
|
|
return some(declarations, (decl) => !!(getMeaningFromDeclaration(decl) & meaning));
|
|
}
|
|
function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) {
|
|
return moduleSpecifierToValidIdentifier(removeFileExtension(stripQuotes(moduleSymbol.name)), target, forceCapitalize);
|
|
}
|
|
function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) {
|
|
const baseName = getBaseFileName(removeSuffix(moduleSpecifier, "/index"));
|
|
let res = "";
|
|
let lastCharWasValid = true;
|
|
const firstCharCode = baseName.charCodeAt(0);
|
|
if (isIdentifierStart(firstCharCode, target)) {
|
|
res += String.fromCharCode(firstCharCode);
|
|
if (forceCapitalize) {
|
|
res = res.toUpperCase();
|
|
}
|
|
} else {
|
|
lastCharWasValid = false;
|
|
}
|
|
for (let i = 1; i < baseName.length; i++) {
|
|
const ch = baseName.charCodeAt(i);
|
|
const isValid = isIdentifierPart(ch, target);
|
|
if (isValid) {
|
|
let char = String.fromCharCode(ch);
|
|
if (!lastCharWasValid) {
|
|
char = char.toUpperCase();
|
|
}
|
|
res += char;
|
|
}
|
|
lastCharWasValid = isValid;
|
|
}
|
|
return !isStringANonContextualKeyword(res) ? res || "_" : `_${res}`;
|
|
}
|
|
|
|
// src/services/codefixes/fixAddMissingConstraint.ts
|
|
var fixId16 = "addMissingConstraint";
|
|
var errorCodes18 = [
|
|
Diagnostics.Type_0_is_not_comparable_to_type_1.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1.code,
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
|
|
Diagnostics.Property_0_is_incompatible_with_index_signature.code,
|
|
Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
|
|
Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes18,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span, program, preferences, host } = context;
|
|
const info = getInfo3(program, sourceFile, span);
|
|
if (info === void 0)
|
|
return;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingConstraint(t, program, preferences, host, sourceFile, info));
|
|
return [createCodeFixAction(fixId16, changes, Diagnostics.Add_extends_constraint, fixId16, Diagnostics.Add_extends_constraint_to_all_type_parameters)];
|
|
},
|
|
fixIds: [fixId16],
|
|
getAllCodeActions: (context) => {
|
|
const { program, preferences, host } = context;
|
|
const seen = /* @__PURE__ */ new Map();
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
eachDiagnostic(context, errorCodes18, (diag2) => {
|
|
const info = getInfo3(program, diag2.file, createTextSpan(diag2.start, diag2.length));
|
|
if (info) {
|
|
if (addToSeen(seen, getNodeId(info.declaration))) {
|
|
return addMissingConstraint(changes, program, preferences, host, diag2.file, info);
|
|
}
|
|
}
|
|
return void 0;
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
function getInfo3(program, sourceFile, span) {
|
|
const diag2 = find(program.getSemanticDiagnostics(sourceFile), (diag3) => diag3.start === span.start && diag3.length === span.length);
|
|
if (diag2 === void 0 || diag2.relatedInformation === void 0)
|
|
return;
|
|
const related = find(diag2.relatedInformation, (related2) => related2.code === Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code);
|
|
if (related === void 0 || related.file === void 0 || related.start === void 0 || related.length === void 0)
|
|
return;
|
|
let declaration = findAncestorMatchingSpan(related.file, createTextSpan(related.start, related.length));
|
|
if (declaration === void 0)
|
|
return;
|
|
if (isIdentifier(declaration) && isTypeParameterDeclaration(declaration.parent)) {
|
|
declaration = declaration.parent;
|
|
}
|
|
if (isTypeParameterDeclaration(declaration)) {
|
|
if (isMappedTypeNode(declaration.parent))
|
|
return;
|
|
const token = getTokenAtPosition(sourceFile, span.start);
|
|
const checker = program.getTypeChecker();
|
|
const constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
|
|
return { constraint, declaration, token };
|
|
}
|
|
return void 0;
|
|
}
|
|
function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
|
|
const { declaration, constraint } = info;
|
|
const checker = program.getTypeChecker();
|
|
if (isString(constraint)) {
|
|
changes.insertText(sourceFile, declaration.name.end, ` extends ${constraint}`);
|
|
} else {
|
|
const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
|
|
const tracker = getNoopSymbolTrackerWithResolver({ program, host });
|
|
const importAdder = createImportAdder(sourceFile, program, preferences, host);
|
|
const typeNode = typeToAutoImportableTypeNode(checker, importAdder, constraint, void 0, scriptTarget, void 0, tracker);
|
|
if (typeNode) {
|
|
changes.replaceNode(sourceFile, declaration, factory.updateTypeParameterDeclaration(declaration, void 0, declaration.name, typeNode, declaration.default));
|
|
importAdder.writeFixes(changes);
|
|
}
|
|
}
|
|
}
|
|
function tryGetConstraintFromDiagnosticMessage(messageText) {
|
|
const [_, constraint] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [];
|
|
return constraint;
|
|
}
|
|
function tryGetConstraintType(checker, node) {
|
|
if (isTypeNode(node.parent)) {
|
|
return checker.getTypeArgumentConstraint(node.parent);
|
|
}
|
|
const contextualType = isExpression(node) ? checker.getContextualType(node) : void 0;
|
|
return contextualType || checker.getTypeAtLocation(node);
|
|
}
|
|
|
|
// src/services/codefixes/fixOverrideModifier.ts
|
|
var fixName = "fixOverrideModifier";
|
|
var fixAddOverrideId = "fixAddOverrideModifier";
|
|
var fixRemoveOverrideId = "fixRemoveOverrideModifier";
|
|
var errorCodes19 = [
|
|
Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code,
|
|
Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code,
|
|
Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code,
|
|
Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code,
|
|
Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code,
|
|
Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
|
|
Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code,
|
|
Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code,
|
|
Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code
|
|
];
|
|
var errorCodeFixIdMap = {
|
|
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Add_override_modifier,
|
|
fixId: fixAddOverrideId,
|
|
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Add_override_modifier,
|
|
fixId: fixAddOverrideId,
|
|
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code]: {
|
|
descriptions: Diagnostics.Remove_override_modifier,
|
|
fixId: fixRemoveOverrideId,
|
|
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code]: {
|
|
descriptions: Diagnostics.Remove_override_modifier,
|
|
fixId: fixRemoveOverrideId,
|
|
fixAllDescriptions: Diagnostics.Remove_override_modifier
|
|
},
|
|
[Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code]: {
|
|
descriptions: Diagnostics.Add_override_modifier,
|
|
fixId: fixAddOverrideId,
|
|
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
|
|
},
|
|
[Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Add_override_modifier,
|
|
fixId: fixAddOverrideId,
|
|
fixAllDescriptions: Diagnostics.Add_all_missing_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Add_override_modifier,
|
|
fixId: fixAddOverrideId,
|
|
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Remove_override_modifier,
|
|
fixId: fixRemoveOverrideId,
|
|
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers
|
|
},
|
|
[Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code]: {
|
|
descriptions: Diagnostics.Remove_override_modifier,
|
|
fixId: fixRemoveOverrideId,
|
|
fixAllDescriptions: Diagnostics.Remove_all_unnecessary_override_modifiers
|
|
}
|
|
};
|
|
registerCodeFix({
|
|
errorCodes: errorCodes19,
|
|
getCodeActions: function getCodeActionsToFixOverrideModifierIssues(context) {
|
|
const { errorCode, span } = context;
|
|
const info = errorCodeFixIdMap[errorCode];
|
|
if (!info)
|
|
return emptyArray;
|
|
const { descriptions, fixId: fixId52, fixAllDescriptions } = info;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => dispatchChanges(changes2, context, errorCode, span.start));
|
|
return [
|
|
createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId52, fixAllDescriptions)
|
|
];
|
|
},
|
|
fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes19, (changes, diag2) => {
|
|
const { code, start: start2 } = diag2;
|
|
const info = errorCodeFixIdMap[code];
|
|
if (!info || info.fixId !== context.fixId) {
|
|
return;
|
|
}
|
|
dispatchChanges(changes, context, code, start2);
|
|
})
|
|
});
|
|
function dispatchChanges(changeTracker, context, errorCode, pos) {
|
|
switch (errorCode) {
|
|
case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code:
|
|
case Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
|
|
case Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code:
|
|
case Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code:
|
|
case Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code:
|
|
return doAddOverrideModifierChange(changeTracker, context.sourceFile, pos);
|
|
case Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code:
|
|
case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code:
|
|
case Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code:
|
|
case Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code:
|
|
return doRemoveOverrideModifierChange(changeTracker, context.sourceFile, pos);
|
|
default:
|
|
Debug.fail("Unexpected error code: " + errorCode);
|
|
}
|
|
}
|
|
function doAddOverrideModifierChange(changeTracker, sourceFile, pos) {
|
|
const classElement = findContainerClassElementLike(sourceFile, pos);
|
|
if (isSourceFileJS(sourceFile)) {
|
|
changeTracker.addJSDocTags(sourceFile, classElement, [factory.createJSDocOverrideTag(factory.createIdentifier("override"))]);
|
|
return;
|
|
}
|
|
const modifiers = classElement.modifiers || emptyArray;
|
|
const staticModifier = find(modifiers, isStaticModifier);
|
|
const abstractModifier = find(modifiers, isAbstractModifier);
|
|
const accessibilityModifier = find(modifiers, (m) => isAccessibilityModifier(m.kind));
|
|
const lastDecorator = findLast(modifiers, isDecorator);
|
|
const modifierPos = abstractModifier ? abstractModifier.end : staticModifier ? staticModifier.end : accessibilityModifier ? accessibilityModifier.end : lastDecorator ? skipTrivia(sourceFile.text, lastDecorator.end) : classElement.getStart(sourceFile);
|
|
const options = accessibilityModifier || staticModifier || abstractModifier ? { prefix: " " } : { suffix: " " };
|
|
changeTracker.insertModifierAt(sourceFile, modifierPos, 161 /* OverrideKeyword */, options);
|
|
}
|
|
function doRemoveOverrideModifierChange(changeTracker, sourceFile, pos) {
|
|
const classElement = findContainerClassElementLike(sourceFile, pos);
|
|
if (isSourceFileJS(sourceFile)) {
|
|
changeTracker.filterJSDocTags(sourceFile, classElement, not(isJSDocOverrideTag));
|
|
return;
|
|
}
|
|
const overrideModifier = find(classElement.modifiers, isOverrideModifier);
|
|
Debug.assertIsDefined(overrideModifier);
|
|
changeTracker.deleteModifier(sourceFile, overrideModifier);
|
|
}
|
|
function isClassElementLikeHasJSDoc(node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return true;
|
|
case 166 /* Parameter */:
|
|
return isParameterPropertyDeclaration(node, node.parent);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function findContainerClassElementLike(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const classElement = findAncestor(token, (node) => {
|
|
if (isClassLike(node))
|
|
return "quit";
|
|
return isClassElementLikeHasJSDoc(node);
|
|
});
|
|
Debug.assert(classElement && isClassElementLikeHasJSDoc(classElement));
|
|
return classElement;
|
|
}
|
|
|
|
// src/services/codefixes/fixNoPropertyAccessFromIndexSignature.ts
|
|
var fixId17 = "fixNoPropertyAccessFromIndexSignature";
|
|
var errorCodes20 = [
|
|
Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes20,
|
|
fixIds: [fixId17],
|
|
getCodeActions(context) {
|
|
const { sourceFile, span, preferences } = context;
|
|
const property = getPropertyAccessExpression(sourceFile, span.start);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange5(t, context.sourceFile, property, preferences));
|
|
return [createCodeFixAction(fixId17, changes, [Diagnostics.Use_element_access_for_0, property.name.text], fixId17, Diagnostics.Use_element_access_for_all_undeclared_properties)];
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes20, (changes, diag2) => doChange5(changes, diag2.file, getPropertyAccessExpression(diag2.file, diag2.start), context.preferences))
|
|
});
|
|
function doChange5(changes, sourceFile, node, preferences) {
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
const argumentsExpression = factory.createStringLiteral(node.name.text, quotePreference === 0 /* Single */);
|
|
changes.replaceNode(
|
|
sourceFile,
|
|
node,
|
|
isPropertyAccessChain(node) ? factory.createElementAccessChain(node.expression, node.questionDotToken, argumentsExpression) : factory.createElementAccessExpression(node.expression, argumentsExpression)
|
|
);
|
|
}
|
|
function getPropertyAccessExpression(sourceFile, pos) {
|
|
return cast(getTokenAtPosition(sourceFile, pos).parent, isPropertyAccessExpression);
|
|
}
|
|
|
|
// src/services/codefixes/fixImplicitThis.ts
|
|
var fixId18 = "fixImplicitThis";
|
|
var errorCodes21 = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes21,
|
|
getCodeActions: function getCodeActionsToFixImplicitThis(context) {
|
|
const { sourceFile, program, span } = context;
|
|
let diagnostic;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
diagnostic = doChange6(t, sourceFile, span.start, program.getTypeChecker());
|
|
});
|
|
return diagnostic ? [createCodeFixAction(fixId18, changes, diagnostic, fixId18, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
|
|
},
|
|
fixIds: [fixId18],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes21, (changes, diag2) => {
|
|
doChange6(changes, diag2.file, diag2.start, context.program.getTypeChecker());
|
|
})
|
|
});
|
|
function doChange6(changes, sourceFile, pos, checker) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (!isThis(token))
|
|
return void 0;
|
|
const fn = getThisContainer(token, false);
|
|
if (!isFunctionDeclaration(fn) && !isFunctionExpression(fn))
|
|
return void 0;
|
|
if (!isSourceFile(getThisContainer(fn, false))) {
|
|
const fnKeyword = Debug.checkDefined(findChildOfKind(fn, 98 /* FunctionKeyword */, sourceFile));
|
|
const { name } = fn;
|
|
const body = Debug.checkDefined(fn.body);
|
|
if (isFunctionExpression(fn)) {
|
|
if (name && ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(name, checker, sourceFile, body)) {
|
|
return void 0;
|
|
}
|
|
changes.delete(sourceFile, fnKeyword);
|
|
if (name) {
|
|
changes.delete(sourceFile, name);
|
|
}
|
|
changes.insertText(sourceFile, body.pos, " =>");
|
|
return [Diagnostics.Convert_function_expression_0_to_arrow_function, name ? name.text : ANONYMOUS];
|
|
} else {
|
|
changes.replaceNode(sourceFile, fnKeyword, factory.createToken(85 /* ConstKeyword */));
|
|
changes.insertText(sourceFile, name.end, " = ");
|
|
changes.insertText(sourceFile, body.pos, " =>");
|
|
return [Diagnostics.Convert_function_declaration_0_to_arrow_function, name.text];
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/fixImportNonExportedMember.ts
|
|
var fixId19 = "fixImportNonExportedMember";
|
|
var errorCodes22 = [
|
|
Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes22,
|
|
fixIds: [fixId19],
|
|
getCodeActions(context) {
|
|
const { sourceFile, span, program } = context;
|
|
const info = getInfo4(sourceFile, span.start, program);
|
|
if (info === void 0)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange7(t, program, info));
|
|
return [createCodeFixAction(fixId19, changes, [Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId19, Diagnostics.Export_all_referenced_locals)];
|
|
},
|
|
getAllCodeActions(context) {
|
|
const { program } = context;
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
const exports = /* @__PURE__ */ new Map();
|
|
eachDiagnostic(context, errorCodes22, (diag2) => {
|
|
const info = getInfo4(diag2.file, diag2.start, program);
|
|
if (info === void 0)
|
|
return void 0;
|
|
const { exportName, node, moduleSourceFile } = info;
|
|
if (tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly) === void 0 && canHaveExportModifier(node)) {
|
|
changes.insertExportModifier(moduleSourceFile, node);
|
|
} else {
|
|
const moduleExports = exports.get(moduleSourceFile) || { typeOnlyExports: [], exports: [] };
|
|
if (exportName.isTypeOnly) {
|
|
moduleExports.typeOnlyExports.push(exportName);
|
|
} else {
|
|
moduleExports.exports.push(exportName);
|
|
}
|
|
exports.set(moduleSourceFile, moduleExports);
|
|
}
|
|
});
|
|
exports.forEach((moduleExports, moduleSourceFile) => {
|
|
const exportDeclaration = tryGetExportDeclaration(moduleSourceFile, true);
|
|
if (exportDeclaration && exportDeclaration.isTypeOnly) {
|
|
doChanges(changes, program, moduleSourceFile, moduleExports.typeOnlyExports, exportDeclaration);
|
|
doChanges(changes, program, moduleSourceFile, moduleExports.exports, tryGetExportDeclaration(moduleSourceFile, false));
|
|
} else {
|
|
doChanges(changes, program, moduleSourceFile, [...moduleExports.exports, ...moduleExports.typeOnlyExports], exportDeclaration);
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
function getInfo4(sourceFile, pos, program) {
|
|
var _a2;
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (isIdentifier(token)) {
|
|
const importDeclaration = findAncestor(token, isImportDeclaration);
|
|
if (importDeclaration === void 0)
|
|
return void 0;
|
|
const moduleSpecifier = isStringLiteral(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : void 0;
|
|
if (moduleSpecifier === void 0)
|
|
return void 0;
|
|
const resolvedModule = getResolvedModule(sourceFile, moduleSpecifier, void 0);
|
|
if (resolvedModule === void 0)
|
|
return void 0;
|
|
const moduleSourceFile = program.getSourceFile(resolvedModule.resolvedFileName);
|
|
if (moduleSourceFile === void 0 || isSourceFileFromLibrary(program, moduleSourceFile))
|
|
return void 0;
|
|
const moduleSymbol = moduleSourceFile.symbol;
|
|
const locals = (_a2 = moduleSymbol.valueDeclaration) == null ? void 0 : _a2.locals;
|
|
if (locals === void 0)
|
|
return void 0;
|
|
const localSymbol = locals.get(token.escapedText);
|
|
if (localSymbol === void 0)
|
|
return void 0;
|
|
const node = getNodeOfSymbol(localSymbol);
|
|
if (node === void 0)
|
|
return void 0;
|
|
const exportName = { node: token, isTypeOnly: isTypeDeclaration(node) };
|
|
return { exportName, node, moduleSourceFile, moduleSpecifier };
|
|
}
|
|
return void 0;
|
|
}
|
|
function doChange7(changes, program, { exportName, node, moduleSourceFile }) {
|
|
const exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly);
|
|
if (exportDeclaration) {
|
|
updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]);
|
|
} else if (canHaveExportModifier(node)) {
|
|
changes.insertExportModifier(moduleSourceFile, node);
|
|
} else {
|
|
createExport(changes, program, moduleSourceFile, [exportName]);
|
|
}
|
|
}
|
|
function doChanges(changes, program, sourceFile, moduleExports, node) {
|
|
if (length(moduleExports)) {
|
|
if (node) {
|
|
updateExport(changes, program, sourceFile, node, moduleExports);
|
|
} else {
|
|
createExport(changes, program, sourceFile, moduleExports);
|
|
}
|
|
}
|
|
}
|
|
function tryGetExportDeclaration(sourceFile, isTypeOnly) {
|
|
const predicate = (node) => isExportDeclaration(node) && (isTypeOnly && node.isTypeOnly || !node.isTypeOnly);
|
|
return findLast(sourceFile.statements, predicate);
|
|
}
|
|
function updateExport(changes, program, sourceFile, node, names) {
|
|
const namedExports = node.exportClause && isNamedExports(node.exportClause) ? node.exportClause.elements : factory.createNodeArray([]);
|
|
const allowTypeModifier = !node.isTypeOnly && !!(program.getCompilerOptions().isolatedModules || find(namedExports, (e) => e.isTypeOnly));
|
|
changes.replaceNode(
|
|
sourceFile,
|
|
node,
|
|
factory.updateExportDeclaration(
|
|
node,
|
|
node.modifiers,
|
|
node.isTypeOnly,
|
|
factory.createNamedExports(
|
|
factory.createNodeArray([...namedExports, ...createExportSpecifiers(names, allowTypeModifier)], namedExports.hasTrailingComma)
|
|
),
|
|
node.moduleSpecifier,
|
|
node.assertClause
|
|
)
|
|
);
|
|
}
|
|
function createExport(changes, program, sourceFile, names) {
|
|
changes.insertNodeAtEndOfScope(
|
|
sourceFile,
|
|
sourceFile,
|
|
factory.createExportDeclaration(
|
|
void 0,
|
|
false,
|
|
factory.createNamedExports(createExportSpecifiers(names, !!program.getCompilerOptions().isolatedModules)),
|
|
void 0,
|
|
void 0
|
|
)
|
|
);
|
|
}
|
|
function createExportSpecifiers(names, allowTypeModifier) {
|
|
return factory.createNodeArray(map(names, (n) => factory.createExportSpecifier(allowTypeModifier && n.isTypeOnly, void 0, n.node)));
|
|
}
|
|
function getNodeOfSymbol(symbol) {
|
|
if (symbol.valueDeclaration === void 0) {
|
|
return firstOrUndefined(symbol.declarations);
|
|
}
|
|
const declaration = symbol.valueDeclaration;
|
|
const variableStatement = isVariableDeclaration(declaration) ? tryCast(declaration.parent.parent, isVariableStatement) : void 0;
|
|
return variableStatement && length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration;
|
|
}
|
|
|
|
// src/services/codefixes/fixIncorrectNamedTupleSyntax.ts
|
|
var fixId20 = "fixIncorrectNamedTupleSyntax";
|
|
var errorCodes23 = [
|
|
Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code,
|
|
Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes23,
|
|
getCodeActions: function getCodeActionsToFixIncorrectNamedTupleSyntax(context) {
|
|
const { sourceFile, span } = context;
|
|
const namedTupleMember = getNamedTupleMember(sourceFile, span.start);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange8(t, sourceFile, namedTupleMember));
|
|
return [createCodeFixAction(fixId20, changes, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId20, Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)];
|
|
},
|
|
fixIds: [fixId20]
|
|
});
|
|
function getNamedTupleMember(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
return findAncestor(token, (t) => t.kind === 199 /* NamedTupleMember */);
|
|
}
|
|
function doChange8(changes, sourceFile, namedTupleMember) {
|
|
if (!namedTupleMember) {
|
|
return;
|
|
}
|
|
let unwrappedType = namedTupleMember.type;
|
|
let sawOptional = false;
|
|
let sawRest = false;
|
|
while (unwrappedType.kind === 187 /* OptionalType */ || unwrappedType.kind === 188 /* RestType */ || unwrappedType.kind === 193 /* ParenthesizedType */) {
|
|
if (unwrappedType.kind === 187 /* OptionalType */) {
|
|
sawOptional = true;
|
|
} else if (unwrappedType.kind === 188 /* RestType */) {
|
|
sawRest = true;
|
|
}
|
|
unwrappedType = unwrappedType.type;
|
|
}
|
|
const updated = factory.updateNamedTupleMember(
|
|
namedTupleMember,
|
|
namedTupleMember.dotDotDotToken || (sawRest ? factory.createToken(25 /* DotDotDotToken */) : void 0),
|
|
namedTupleMember.name,
|
|
namedTupleMember.questionToken || (sawOptional ? factory.createToken(57 /* QuestionToken */) : void 0),
|
|
unwrappedType
|
|
);
|
|
if (updated === namedTupleMember) {
|
|
return;
|
|
}
|
|
changes.replaceNode(sourceFile, namedTupleMember, updated);
|
|
}
|
|
|
|
// src/services/codefixes/fixSpelling.ts
|
|
var fixId21 = "fixSpelling";
|
|
var errorCodes24 = [
|
|
Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
|
|
Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_1.code,
|
|
Diagnostics.Could_not_find_name_0_Did_you_mean_1.code,
|
|
Diagnostics.Cannot_find_namespace_0_Did_you_mean_1.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code,
|
|
Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2.code,
|
|
Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code,
|
|
Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code,
|
|
Diagnostics.No_overload_matches_this_call.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes24,
|
|
getCodeActions(context) {
|
|
const { sourceFile, errorCode } = context;
|
|
const info = getInfo5(sourceFile, context.span.start, context, errorCode);
|
|
if (!info)
|
|
return void 0;
|
|
const { node, suggestedSymbol } = info;
|
|
const target = getEmitScriptTarget(context.host.getCompilationSettings());
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange9(t, sourceFile, node, suggestedSymbol, target));
|
|
return [createCodeFixAction("spelling", changes, [Diagnostics.Change_spelling_to_0, symbolName(suggestedSymbol)], fixId21, Diagnostics.Fix_all_detected_spelling_errors)];
|
|
},
|
|
fixIds: [fixId21],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes24, (changes, diag2) => {
|
|
const info = getInfo5(diag2.file, diag2.start, context, diag2.code);
|
|
const target = getEmitScriptTarget(context.host.getCompilationSettings());
|
|
if (info)
|
|
doChange9(changes, context.sourceFile, info.node, info.suggestedSymbol, target);
|
|
})
|
|
});
|
|
function getInfo5(sourceFile, pos, context, errorCode) {
|
|
const node = getTokenAtPosition(sourceFile, pos);
|
|
const parent2 = node.parent;
|
|
if ((errorCode === Diagnostics.No_overload_matches_this_call.code || errorCode === Diagnostics.Type_0_is_not_assignable_to_type_1.code) && !isJsxAttribute(parent2))
|
|
return void 0;
|
|
const checker = context.program.getTypeChecker();
|
|
let suggestedSymbol;
|
|
if (isPropertyAccessExpression(parent2) && parent2.name === node) {
|
|
Debug.assert(isMemberName(node), "Expected an identifier for spelling (property access)");
|
|
let containingType = checker.getTypeAtLocation(parent2.expression);
|
|
if (parent2.flags & 32 /* OptionalChain */) {
|
|
containingType = checker.getNonNullableType(containingType);
|
|
}
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, containingType);
|
|
} else if (isBinaryExpression(parent2) && parent2.operatorToken.kind === 101 /* InKeyword */ && parent2.left === node && isPrivateIdentifier(node)) {
|
|
const receiverType = checker.getTypeAtLocation(parent2.right);
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, receiverType);
|
|
} else if (isQualifiedName(parent2) && parent2.right === node) {
|
|
const symbol = checker.getSymbolAtLocation(parent2.left);
|
|
if (symbol && symbol.flags & 1536 /* Module */) {
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentModule(parent2.right, symbol);
|
|
}
|
|
} else if (isImportSpecifier(parent2) && parent2.name === node) {
|
|
Debug.assertNode(node, isIdentifier, "Expected an identifier for spelling (import)");
|
|
const importDeclaration = findAncestor(node, isImportDeclaration);
|
|
const resolvedSourceFile = getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration);
|
|
if (resolvedSourceFile && resolvedSourceFile.symbol) {
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentModule(node, resolvedSourceFile.symbol);
|
|
}
|
|
} else if (isJsxAttribute(parent2) && parent2.name === node) {
|
|
Debug.assertNode(node, isIdentifier, "Expected an identifier for JSX attribute");
|
|
const tag = findAncestor(node, isJsxOpeningLikeElement);
|
|
const props = checker.getContextualTypeForArgumentAtIndex(tag, 0);
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentJSXAttribute(node, props);
|
|
} else if (hasSyntacticModifier(parent2, 16384 /* Override */) && isClassElement(parent2) && parent2.name === node) {
|
|
const baseDeclaration = findAncestor(node, isClassLike);
|
|
const baseTypeNode = baseDeclaration ? getEffectiveBaseTypeNode(baseDeclaration) : void 0;
|
|
const baseType = baseTypeNode ? checker.getTypeAtLocation(baseTypeNode) : void 0;
|
|
if (baseType) {
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentClassMember(getTextOfNode(node), baseType);
|
|
}
|
|
} else {
|
|
const meaning = getMeaningFromLocation(node);
|
|
const name = getTextOfNode(node);
|
|
Debug.assert(name !== void 0, "name should be defined");
|
|
suggestedSymbol = checker.getSuggestedSymbolForNonexistentSymbol(node, name, convertSemanticMeaningToSymbolFlags(meaning));
|
|
}
|
|
return suggestedSymbol === void 0 ? void 0 : { node, suggestedSymbol };
|
|
}
|
|
function doChange9(changes, sourceFile, node, suggestedSymbol, target) {
|
|
const suggestion = symbolName(suggestedSymbol);
|
|
if (!isIdentifierText(suggestion, target) && isPropertyAccessExpression(node.parent)) {
|
|
const valDecl = suggestedSymbol.valueDeclaration;
|
|
if (valDecl && isNamedDeclaration(valDecl) && isPrivateIdentifier(valDecl.name)) {
|
|
changes.replaceNode(sourceFile, node, factory.createIdentifier(suggestion));
|
|
} else {
|
|
changes.replaceNode(sourceFile, node.parent, factory.createElementAccessExpression(node.parent.expression, factory.createStringLiteral(suggestion)));
|
|
}
|
|
} else {
|
|
changes.replaceNode(sourceFile, node, factory.createIdentifier(suggestion));
|
|
}
|
|
}
|
|
function convertSemanticMeaningToSymbolFlags(meaning) {
|
|
let flags = 0;
|
|
if (meaning & 4 /* Namespace */) {
|
|
flags |= 1920 /* Namespace */;
|
|
}
|
|
if (meaning & 2 /* Type */) {
|
|
flags |= 788968 /* Type */;
|
|
}
|
|
if (meaning & 1 /* Value */) {
|
|
flags |= 111551 /* Value */;
|
|
}
|
|
return flags;
|
|
}
|
|
function getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration) {
|
|
if (!importDeclaration || !isStringLiteralLike(importDeclaration.moduleSpecifier))
|
|
return void 0;
|
|
const resolvedModule = getResolvedModule(sourceFile, importDeclaration.moduleSpecifier.text, getModeForUsageLocation(sourceFile, importDeclaration.moduleSpecifier));
|
|
if (!resolvedModule)
|
|
return void 0;
|
|
return context.program.getSourceFile(resolvedModule.resolvedFileName);
|
|
}
|
|
|
|
// src/services/codefixes/returnValueCorrect.ts
|
|
var fixId22 = "returnValueCorrect";
|
|
var fixIdAddReturnStatement = "fixAddReturnStatement";
|
|
var fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
|
|
var fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
|
|
var errorCodes25 = [
|
|
Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1.code,
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes25,
|
|
fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen],
|
|
getCodeActions: function getCodeActionsToCorrectReturnValue(context) {
|
|
const { program, sourceFile, span: { start: start2 }, errorCode } = context;
|
|
const info = getInfo6(program.getTypeChecker(), sourceFile, start2, errorCode);
|
|
if (!info)
|
|
return void 0;
|
|
if (info.kind === 0 /* MissingReturnStatement */) {
|
|
return append(
|
|
[getActionForfixAddReturnStatement(context, info.expression, info.statement)],
|
|
isArrowFunction(info.declaration) ? getActionForFixRemoveBracesFromArrowFunctionBody(context, info.declaration, info.expression, info.commentSource) : void 0
|
|
);
|
|
} else {
|
|
return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)];
|
|
}
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes25, (changes, diag2) => {
|
|
const info = getInfo6(context.program.getTypeChecker(), diag2.file, diag2.start, diag2.code);
|
|
if (!info)
|
|
return void 0;
|
|
switch (context.fixId) {
|
|
case fixIdAddReturnStatement:
|
|
addReturnStatement(changes, diag2.file, info.expression, info.statement);
|
|
break;
|
|
case fixRemoveBracesFromArrowFunctionBody:
|
|
if (!isArrowFunction(info.declaration))
|
|
return void 0;
|
|
removeBlockBodyBrace(changes, diag2.file, info.declaration, info.expression, info.commentSource, false);
|
|
break;
|
|
case fixIdWrapTheBlockWithParen:
|
|
if (!isArrowFunction(info.declaration))
|
|
return void 0;
|
|
wrapBlockWithParen(changes, diag2.file, info.declaration, info.expression);
|
|
break;
|
|
default:
|
|
Debug.fail(JSON.stringify(context.fixId));
|
|
}
|
|
})
|
|
});
|
|
function createObjectTypeFromLabeledExpression(checker, label, expression) {
|
|
const member = checker.createSymbol(4 /* Property */, label.escapedText);
|
|
member.type = checker.getTypeAtLocation(expression);
|
|
const members = createSymbolTable([member]);
|
|
return checker.createAnonymousType(void 0, members, [], [], []);
|
|
}
|
|
function getFixInfo(checker, declaration, expectType, isFunctionType) {
|
|
if (!declaration.body || !isBlock(declaration.body) || length(declaration.body.statements) !== 1)
|
|
return void 0;
|
|
const firstStatement = first(declaration.body.statements);
|
|
if (isExpressionStatement(firstStatement) && checkFixedAssignableTo(checker, declaration, checker.getTypeAtLocation(firstStatement.expression), expectType, isFunctionType)) {
|
|
return {
|
|
declaration,
|
|
kind: 0 /* MissingReturnStatement */,
|
|
expression: firstStatement.expression,
|
|
statement: firstStatement,
|
|
commentSource: firstStatement.expression
|
|
};
|
|
} else if (isLabeledStatement(firstStatement) && isExpressionStatement(firstStatement.statement)) {
|
|
const node = factory.createObjectLiteralExpression([factory.createPropertyAssignment(firstStatement.label, firstStatement.statement.expression)]);
|
|
const nodeType = createObjectTypeFromLabeledExpression(checker, firstStatement.label, firstStatement.statement.expression);
|
|
if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) {
|
|
return isArrowFunction(declaration) ? {
|
|
declaration,
|
|
kind: 1 /* MissingParentheses */,
|
|
expression: node,
|
|
statement: firstStatement,
|
|
commentSource: firstStatement.statement.expression
|
|
} : {
|
|
declaration,
|
|
kind: 0 /* MissingReturnStatement */,
|
|
expression: node,
|
|
statement: firstStatement,
|
|
commentSource: firstStatement.statement.expression
|
|
};
|
|
}
|
|
} else if (isBlock(firstStatement) && length(firstStatement.statements) === 1) {
|
|
const firstBlockStatement = first(firstStatement.statements);
|
|
if (isLabeledStatement(firstBlockStatement) && isExpressionStatement(firstBlockStatement.statement)) {
|
|
const node = factory.createObjectLiteralExpression([factory.createPropertyAssignment(firstBlockStatement.label, firstBlockStatement.statement.expression)]);
|
|
const nodeType = createObjectTypeFromLabeledExpression(checker, firstBlockStatement.label, firstBlockStatement.statement.expression);
|
|
if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) {
|
|
return {
|
|
declaration,
|
|
kind: 0 /* MissingReturnStatement */,
|
|
expression: node,
|
|
statement: firstStatement,
|
|
commentSource: firstBlockStatement
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkFixedAssignableTo(checker, declaration, exprType, type, isFunctionType) {
|
|
if (isFunctionType) {
|
|
const sig = checker.getSignatureFromDeclaration(declaration);
|
|
if (sig) {
|
|
if (hasSyntacticModifier(declaration, 512 /* Async */)) {
|
|
exprType = checker.createPromiseType(exprType);
|
|
}
|
|
const newSig = checker.createSignature(
|
|
declaration,
|
|
sig.typeParameters,
|
|
sig.thisParameter,
|
|
sig.parameters,
|
|
exprType,
|
|
void 0,
|
|
sig.minArgumentCount,
|
|
sig.flags
|
|
);
|
|
exprType = checker.createAnonymousType(
|
|
void 0,
|
|
createSymbolTable(),
|
|
[newSig],
|
|
[],
|
|
[]
|
|
);
|
|
} else {
|
|
exprType = checker.getAnyType();
|
|
}
|
|
}
|
|
return checker.isTypeAssignableTo(exprType, type);
|
|
}
|
|
function getInfo6(checker, sourceFile, position, errorCode) {
|
|
const node = getTokenAtPosition(sourceFile, position);
|
|
if (!node.parent)
|
|
return void 0;
|
|
const declaration = findAncestor(node.parent, isFunctionLikeDeclaration);
|
|
switch (errorCode) {
|
|
case Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code:
|
|
if (!declaration || !declaration.body || !declaration.type || !rangeContainsRange(declaration.type, node))
|
|
return void 0;
|
|
return getFixInfo(checker, declaration, checker.getTypeFromTypeNode(declaration.type), false);
|
|
case Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code:
|
|
if (!declaration || !isCallExpression(declaration.parent) || !declaration.body)
|
|
return void 0;
|
|
const pos = declaration.parent.arguments.indexOf(declaration);
|
|
const type = checker.getContextualTypeForArgumentAtIndex(declaration.parent, pos);
|
|
if (!type)
|
|
return void 0;
|
|
return getFixInfo(checker, declaration, type, true);
|
|
case Diagnostics.Type_0_is_not_assignable_to_type_1.code:
|
|
if (!isDeclarationName(node) || !isVariableLike(node.parent) && !isJsxAttribute(node.parent))
|
|
return void 0;
|
|
const initializer = getVariableLikeInitializer(node.parent);
|
|
if (!initializer || !isFunctionLikeDeclaration(initializer) || !initializer.body)
|
|
return void 0;
|
|
return getFixInfo(checker, initializer, checker.getTypeAtLocation(node.parent), true);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getVariableLikeInitializer(declaration) {
|
|
switch (declaration.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 205 /* BindingElement */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
return declaration.initializer;
|
|
case 288 /* JsxAttribute */:
|
|
return declaration.initializer && (isJsxExpression(declaration.initializer) ? declaration.initializer.expression : void 0);
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 168 /* PropertySignature */:
|
|
case 302 /* EnumMember */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 343 /* JSDocParameterTag */:
|
|
return void 0;
|
|
}
|
|
}
|
|
function addReturnStatement(changes, sourceFile, expression, statement) {
|
|
suppressLeadingAndTrailingTrivia(expression);
|
|
const probablyNeedSemi = probablyUsesSemicolons(sourceFile);
|
|
changes.replaceNode(sourceFile, statement, factory.createReturnStatement(expression), {
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Exclude,
|
|
suffix: probablyNeedSemi ? ";" : void 0
|
|
});
|
|
}
|
|
function removeBlockBodyBrace(changes, sourceFile, declaration, expression, commentSource, withParen) {
|
|
const newBody = withParen || needsParentheses(expression) ? factory.createParenthesizedExpression(expression) : expression;
|
|
suppressLeadingAndTrailingTrivia(commentSource);
|
|
copyComments(commentSource, newBody);
|
|
changes.replaceNode(sourceFile, declaration.body, newBody);
|
|
}
|
|
function wrapBlockWithParen(changes, sourceFile, declaration, expression) {
|
|
changes.replaceNode(sourceFile, declaration.body, factory.createParenthesizedExpression(expression));
|
|
}
|
|
function getActionForfixAddReturnStatement(context, expression, statement) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addReturnStatement(t, context.sourceFile, expression, statement));
|
|
return createCodeFixAction(fixId22, changes, Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, Diagnostics.Add_all_missing_return_statement);
|
|
}
|
|
function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, expression, commentSource) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => removeBlockBodyBrace(t, context.sourceFile, declaration, expression, commentSource, false));
|
|
return createCodeFixAction(fixId22, changes, Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues);
|
|
}
|
|
function getActionForfixWrapTheBlockWithParen(context, declaration, expression) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => wrapBlockWithParen(t, context.sourceFile, declaration, expression));
|
|
return createCodeFixAction(fixId22, changes, Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, Diagnostics.Wrap_all_object_literal_with_parentheses);
|
|
}
|
|
|
|
// src/services/codefixes/fixAddMissingMember.ts
|
|
var fixMissingMember = "fixMissingMember";
|
|
var fixMissingProperties = "fixMissingProperties";
|
|
var fixMissingAttributes = "fixMissingAttributes";
|
|
var fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration";
|
|
var errorCodes26 = [
|
|
Diagnostics.Property_0_does_not_exist_on_type_1.code,
|
|
Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code,
|
|
Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code,
|
|
Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2.code,
|
|
Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code,
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
|
|
Diagnostics.Cannot_find_name_0.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes26,
|
|
getCodeActions(context) {
|
|
const typeChecker = context.program.getTypeChecker();
|
|
const info = getInfo7(context.sourceFile, context.span.start, context.errorCode, typeChecker, context.program);
|
|
if (!info) {
|
|
return void 0;
|
|
}
|
|
if (info.kind === 3 /* ObjectLiteral */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addObjectLiteralProperties(t, context, info));
|
|
return [createCodeFixAction(fixMissingProperties, changes, Diagnostics.Add_missing_properties, fixMissingProperties, Diagnostics.Add_all_missing_properties)];
|
|
}
|
|
if (info.kind === 4 /* JsxAttributes */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addJsxAttributes(t, context, info));
|
|
return [createCodeFixAction(fixMissingAttributes, changes, Diagnostics.Add_missing_attributes, fixMissingAttributes, Diagnostics.Add_all_missing_attributes)];
|
|
}
|
|
if (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addFunctionDeclaration(t, context, info));
|
|
return [createCodeFixAction(fixMissingFunctionDeclaration, changes, [Diagnostics.Add_missing_function_declaration_0, info.token.text], fixMissingFunctionDeclaration, Diagnostics.Add_all_missing_function_declarations)];
|
|
}
|
|
if (info.kind === 1 /* Enum */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addEnumMemberDeclaration(t, context.program.getTypeChecker(), info));
|
|
return [createCodeFixAction(fixMissingMember, changes, [Diagnostics.Add_missing_enum_member_0, info.token.text], fixMissingMember, Diagnostics.Add_all_missing_members)];
|
|
}
|
|
return concatenate(getActionsForMissingMethodDeclaration(context, info), getActionsForMissingMemberDeclaration(context, info));
|
|
},
|
|
fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes],
|
|
getAllCodeActions: (context) => {
|
|
const { program, fixId: fixId52 } = context;
|
|
const checker = program.getTypeChecker();
|
|
const seen = /* @__PURE__ */ new Map();
|
|
const typeDeclToMembers = /* @__PURE__ */ new Map();
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
eachDiagnostic(context, errorCodes26, (diag2) => {
|
|
const info = getInfo7(diag2.file, diag2.start, diag2.code, checker, context.program);
|
|
if (!info || !addToSeen(seen, getNodeId(info.parentDeclaration) + "#" + info.token.text)) {
|
|
return;
|
|
}
|
|
if (fixId52 === fixMissingFunctionDeclaration && (info.kind === 2 /* Function */ || info.kind === 5 /* Signature */)) {
|
|
addFunctionDeclaration(changes, context, info);
|
|
} else if (fixId52 === fixMissingProperties && info.kind === 3 /* ObjectLiteral */) {
|
|
addObjectLiteralProperties(changes, context, info);
|
|
} else if (fixId52 === fixMissingAttributes && info.kind === 4 /* JsxAttributes */) {
|
|
addJsxAttributes(changes, context, info);
|
|
} else {
|
|
if (info.kind === 1 /* Enum */) {
|
|
addEnumMemberDeclaration(changes, checker, info);
|
|
}
|
|
if (info.kind === 0 /* TypeLikeDeclaration */) {
|
|
const { parentDeclaration, token } = info;
|
|
const infos = getOrUpdate(typeDeclToMembers, parentDeclaration, () => []);
|
|
if (!infos.some((i) => i.token.text === token.text)) {
|
|
infos.push(info);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
typeDeclToMembers.forEach((infos, declaration) => {
|
|
const supers = isTypeLiteralNode(declaration) ? void 0 : getAllSupers(declaration, checker);
|
|
for (const info of infos) {
|
|
if (supers == null ? void 0 : supers.some((superClassOrInterface) => {
|
|
const superInfos = typeDeclToMembers.get(superClassOrInterface);
|
|
return !!superInfos && superInfos.some(({ token: token2 }) => token2.text === info.token.text);
|
|
}))
|
|
continue;
|
|
const { parentDeclaration, declSourceFile, modifierFlags, token, call, isJSFile } = info;
|
|
if (call && !isPrivateIdentifier(token)) {
|
|
addMethodDeclaration(context, changes, call, token, modifierFlags & 32 /* Static */, parentDeclaration, declSourceFile);
|
|
} else {
|
|
if (isJSFile && !isInterfaceDeclaration(parentDeclaration) && !isTypeLiteralNode(parentDeclaration)) {
|
|
addMissingMemberInJs(changes, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */));
|
|
} else {
|
|
const typeNode = getTypeNode2(checker, parentDeclaration, token);
|
|
addPropertyDeclaration(changes, declSourceFile, parentDeclaration, token.text, typeNode, modifierFlags & 32 /* Static */);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
function getInfo7(sourceFile, tokenPos, errorCode, checker, program) {
|
|
const token = getTokenAtPosition(sourceFile, tokenPos);
|
|
const parent2 = token.parent;
|
|
if (errorCode === Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) {
|
|
if (!(token.kind === 18 /* OpenBraceToken */ && isObjectLiteralExpression(parent2) && isCallExpression(parent2.parent)))
|
|
return void 0;
|
|
const argIndex = findIndex(parent2.parent.arguments, (arg) => arg === parent2);
|
|
if (argIndex < 0)
|
|
return void 0;
|
|
const signature = checker.getResolvedSignature(parent2.parent);
|
|
if (!(signature && signature.declaration && signature.parameters[argIndex]))
|
|
return void 0;
|
|
const param = signature.parameters[argIndex].valueDeclaration;
|
|
if (!(param && isParameter(param) && isIdentifier(param.name)))
|
|
return void 0;
|
|
const properties = arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent2), checker.getParameterType(signature, argIndex), false, false));
|
|
if (!length(properties))
|
|
return void 0;
|
|
return { kind: 3 /* ObjectLiteral */, token: param.name, properties, parentDeclaration: parent2 };
|
|
}
|
|
if (!isMemberName(token))
|
|
return void 0;
|
|
if (isIdentifier(token) && hasInitializer(parent2) && parent2.initializer && isObjectLiteralExpression(parent2.initializer)) {
|
|
const properties = arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent2.initializer), checker.getTypeAtLocation(token), false, false));
|
|
if (!length(properties))
|
|
return void 0;
|
|
return { kind: 3 /* ObjectLiteral */, token, properties, parentDeclaration: parent2.initializer };
|
|
}
|
|
if (isIdentifier(token) && isJsxOpeningLikeElement(token.parent)) {
|
|
const target = getEmitScriptTarget(program.getCompilerOptions());
|
|
const attributes = getUnmatchedAttributes(checker, target, token.parent);
|
|
if (!length(attributes))
|
|
return void 0;
|
|
return { kind: 4 /* JsxAttributes */, token, attributes, parentDeclaration: token.parent };
|
|
}
|
|
if (isIdentifier(token)) {
|
|
const type = checker.getContextualType(token);
|
|
if (type && getObjectFlags(type) & 16 /* Anonymous */) {
|
|
const signature = firstOrUndefined(checker.getSignaturesOfType(type, 0 /* Call */));
|
|
if (signature === void 0)
|
|
return void 0;
|
|
return { kind: 5 /* Signature */, token, signature, sourceFile, parentDeclaration: findScope(token) };
|
|
}
|
|
if (isCallExpression(parent2) && parent2.expression === token) {
|
|
return { kind: 2 /* Function */, token, call: parent2, sourceFile, modifierFlags: 0 /* None */, parentDeclaration: findScope(token) };
|
|
}
|
|
}
|
|
if (!isPropertyAccessExpression(parent2))
|
|
return void 0;
|
|
const leftExpressionType = skipConstraint(checker.getTypeAtLocation(parent2.expression));
|
|
const symbol = leftExpressionType.symbol;
|
|
if (!symbol || !symbol.declarations)
|
|
return void 0;
|
|
if (isIdentifier(token) && isCallExpression(parent2.parent)) {
|
|
const moduleDeclaration = find(symbol.declarations, isModuleDeclaration);
|
|
const moduleDeclarationSourceFile = moduleDeclaration == null ? void 0 : moduleDeclaration.getSourceFile();
|
|
if (moduleDeclaration && moduleDeclarationSourceFile && !isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
|
|
return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleDeclaration };
|
|
}
|
|
const moduleSourceFile = find(symbol.declarations, isSourceFile);
|
|
if (sourceFile.commonJsModuleIndicator)
|
|
return void 0;
|
|
if (moduleSourceFile && !isSourceFileFromLibrary(program, moduleSourceFile)) {
|
|
return { kind: 2 /* Function */, token, call: parent2.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* Export */, parentDeclaration: moduleSourceFile };
|
|
}
|
|
}
|
|
const classDeclaration = find(symbol.declarations, isClassLike);
|
|
if (!classDeclaration && isPrivateIdentifier(token))
|
|
return void 0;
|
|
const declaration = classDeclaration || find(symbol.declarations, (d) => isInterfaceDeclaration(d) || isTypeLiteralNode(d));
|
|
if (declaration && !isSourceFileFromLibrary(program, declaration.getSourceFile())) {
|
|
const makeStatic = !isTypeLiteralNode(declaration) && (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol);
|
|
if (makeStatic && (isPrivateIdentifier(token) || isInterfaceDeclaration(declaration)))
|
|
return void 0;
|
|
const declSourceFile = declaration.getSourceFile();
|
|
const modifierFlags = isTypeLiteralNode(declaration) ? 0 /* None */ : (makeStatic ? 32 /* Static */ : 0 /* None */) | (startsWithUnderscore(token.text) ? 8 /* Private */ : 0 /* None */);
|
|
const isJSFile = isSourceFileJS(declSourceFile);
|
|
const call = tryCast(parent2.parent, isCallExpression);
|
|
return { kind: 0 /* TypeLikeDeclaration */, token, call, modifierFlags, parentDeclaration: declaration, declSourceFile, isJSFile };
|
|
}
|
|
const enumDeclaration = find(symbol.declarations, isEnumDeclaration);
|
|
if (enumDeclaration && !(leftExpressionType.flags & 1056 /* EnumLike */) && !isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
|
|
return { kind: 1 /* Enum */, token, parentDeclaration: enumDeclaration };
|
|
}
|
|
return void 0;
|
|
}
|
|
function getActionsForMissingMemberDeclaration(context, info) {
|
|
return info.isJSFile ? singleElementArray(createActionForAddMissingMemberInJavascriptFile(context, info)) : createActionsForAddMissingMemberInTypeScriptFile(context, info);
|
|
}
|
|
function createActionForAddMissingMemberInJavascriptFile(context, { parentDeclaration, declSourceFile, modifierFlags, token }) {
|
|
if (isInterfaceDeclaration(parentDeclaration) || isTypeLiteralNode(parentDeclaration)) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMemberInJs(t, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* Static */)));
|
|
if (changes.length === 0) {
|
|
return void 0;
|
|
}
|
|
const diagnostic = modifierFlags & 32 /* Static */ ? Diagnostics.Initialize_static_property_0 : isPrivateIdentifier(token) ? Diagnostics.Declare_a_private_field_named_0 : Diagnostics.Initialize_property_0_in_the_constructor;
|
|
return createCodeFixAction(fixMissingMember, changes, [diagnostic, token.text], fixMissingMember, Diagnostics.Add_all_missing_members);
|
|
}
|
|
function addMissingMemberInJs(changeTracker, sourceFile, classDeclaration, token, makeStatic) {
|
|
const tokenName = token.text;
|
|
if (makeStatic) {
|
|
if (classDeclaration.kind === 228 /* ClassExpression */) {
|
|
return;
|
|
}
|
|
const className = classDeclaration.name.getText();
|
|
const staticInitialization = initializePropertyToUndefined(factory.createIdentifier(className), tokenName);
|
|
changeTracker.insertNodeAfter(sourceFile, classDeclaration, staticInitialization);
|
|
} else if (isPrivateIdentifier(token)) {
|
|
const property = factory.createPropertyDeclaration(
|
|
void 0,
|
|
tokenName,
|
|
void 0,
|
|
void 0,
|
|
void 0
|
|
);
|
|
const lastProp = getNodeToInsertPropertyAfter(classDeclaration);
|
|
if (lastProp) {
|
|
changeTracker.insertNodeAfter(sourceFile, lastProp, property);
|
|
} else {
|
|
changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property);
|
|
}
|
|
} else {
|
|
const classConstructor = getFirstConstructorWithBody(classDeclaration);
|
|
if (!classConstructor) {
|
|
return;
|
|
}
|
|
const propertyInitialization = initializePropertyToUndefined(factory.createThis(), tokenName);
|
|
changeTracker.insertNodeAtConstructorEnd(sourceFile, classConstructor, propertyInitialization);
|
|
}
|
|
}
|
|
function initializePropertyToUndefined(obj, propertyName) {
|
|
return factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(obj, propertyName), createUndefined()));
|
|
}
|
|
function createActionsForAddMissingMemberInTypeScriptFile(context, { parentDeclaration, declSourceFile, modifierFlags, token }) {
|
|
const memberName = token.text;
|
|
const isStatic2 = modifierFlags & 32 /* Static */;
|
|
const typeNode = getTypeNode2(context.program.getTypeChecker(), parentDeclaration, token);
|
|
const addPropertyDeclarationChanges = (modifierFlags2) => ts_textChanges_exports.ChangeTracker.with(context, (t) => addPropertyDeclaration(t, declSourceFile, parentDeclaration, memberName, typeNode, modifierFlags2));
|
|
const actions2 = [createCodeFixAction(fixMissingMember, addPropertyDeclarationChanges(modifierFlags & 32 /* Static */), [isStatic2 ? Diagnostics.Declare_static_property_0 : Diagnostics.Declare_property_0, memberName], fixMissingMember, Diagnostics.Add_all_missing_members)];
|
|
if (isStatic2 || isPrivateIdentifier(token)) {
|
|
return actions2;
|
|
}
|
|
if (modifierFlags & 8 /* Private */) {
|
|
actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addPropertyDeclarationChanges(8 /* Private */), [Diagnostics.Declare_private_property_0, memberName]));
|
|
}
|
|
actions2.push(createAddIndexSignatureAction(context, declSourceFile, parentDeclaration, token.text, typeNode));
|
|
return actions2;
|
|
}
|
|
function getTypeNode2(checker, node, token) {
|
|
let typeNode;
|
|
if (token.parent.parent.kind === 223 /* BinaryExpression */) {
|
|
const binaryExpression = token.parent.parent;
|
|
const otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left;
|
|
const widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression)));
|
|
typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NoTruncation */);
|
|
} else {
|
|
const contextualType = checker.getContextualType(token.parent);
|
|
typeNode = contextualType ? checker.typeToTypeNode(contextualType, void 0, 1 /* NoTruncation */) : void 0;
|
|
}
|
|
return typeNode || factory.createKeywordTypeNode(131 /* AnyKeyword */);
|
|
}
|
|
function addPropertyDeclaration(changeTracker, sourceFile, node, tokenName, typeNode, modifierFlags) {
|
|
const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
|
|
const property = isClassLike(node) ? factory.createPropertyDeclaration(modifiers, tokenName, void 0, typeNode, void 0) : factory.createPropertySignature(void 0, tokenName, void 0, typeNode);
|
|
const lastProp = getNodeToInsertPropertyAfter(node);
|
|
if (lastProp) {
|
|
changeTracker.insertNodeAfter(sourceFile, lastProp, property);
|
|
} else {
|
|
changeTracker.insertMemberAtStart(sourceFile, node, property);
|
|
}
|
|
}
|
|
function getNodeToInsertPropertyAfter(node) {
|
|
let res;
|
|
for (const member of node.members) {
|
|
if (!isPropertyDeclaration(member))
|
|
break;
|
|
res = member;
|
|
}
|
|
return res;
|
|
}
|
|
function createAddIndexSignatureAction(context, sourceFile, node, tokenName, typeNode) {
|
|
const stringTypeNode = factory.createKeywordTypeNode(152 /* StringKeyword */);
|
|
const indexingParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"x",
|
|
void 0,
|
|
stringTypeNode,
|
|
void 0
|
|
);
|
|
const indexSignature = factory.createIndexSignature(
|
|
void 0,
|
|
[indexingParameter],
|
|
typeNode
|
|
);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => t.insertMemberAtStart(sourceFile, node, indexSignature));
|
|
return createCodeFixActionWithoutFixAll(fixMissingMember, changes, [Diagnostics.Add_index_signature_for_property_0, tokenName]);
|
|
}
|
|
function getActionsForMissingMethodDeclaration(context, info) {
|
|
const { parentDeclaration, declSourceFile, modifierFlags, token, call } = info;
|
|
if (call === void 0) {
|
|
return void 0;
|
|
}
|
|
if (isPrivateIdentifier(token)) {
|
|
return void 0;
|
|
}
|
|
const methodName = token.text;
|
|
const addMethodDeclarationChanges = (modifierFlags2) => ts_textChanges_exports.ChangeTracker.with(context, (t) => addMethodDeclaration(context, t, call, token, modifierFlags2, parentDeclaration, declSourceFile));
|
|
const actions2 = [createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 32 /* Static */), [modifierFlags & 32 /* Static */ ? Diagnostics.Declare_static_method_0 : Diagnostics.Declare_method_0, methodName], fixMissingMember, Diagnostics.Add_all_missing_members)];
|
|
if (modifierFlags & 8 /* Private */) {
|
|
actions2.unshift(createCodeFixActionWithoutFixAll(fixMissingMember, addMethodDeclarationChanges(8 /* Private */), [Diagnostics.Declare_private_method_0, methodName]));
|
|
}
|
|
return actions2;
|
|
}
|
|
function addMethodDeclaration(context, changes, callExpression, name, modifierFlags, parentDeclaration, sourceFile) {
|
|
const importAdder = createImportAdder(sourceFile, context.program, context.preferences, context.host);
|
|
const kind = isClassLike(parentDeclaration) ? 171 /* MethodDeclaration */ : 170 /* MethodSignature */;
|
|
const signatureDeclaration = createSignatureDeclarationFromCallExpression(kind, context, importAdder, callExpression, name, modifierFlags, parentDeclaration);
|
|
const containingMethodDeclaration = tryGetContainingMethodDeclaration(parentDeclaration, callExpression);
|
|
if (containingMethodDeclaration) {
|
|
changes.insertNodeAfter(sourceFile, containingMethodDeclaration, signatureDeclaration);
|
|
} else {
|
|
changes.insertMemberAtStart(sourceFile, parentDeclaration, signatureDeclaration);
|
|
}
|
|
importAdder.writeFixes(changes);
|
|
}
|
|
function addEnumMemberDeclaration(changes, checker, { token, parentDeclaration }) {
|
|
const hasStringInitializer = some(parentDeclaration.members, (member) => {
|
|
const type = checker.getTypeAtLocation(member);
|
|
return !!(type && type.flags & 402653316 /* StringLike */);
|
|
});
|
|
const enumMember = factory.createEnumMember(token, hasStringInitializer ? factory.createStringLiteral(token.text) : void 0);
|
|
changes.replaceNode(parentDeclaration.getSourceFile(), parentDeclaration, factory.updateEnumDeclaration(
|
|
parentDeclaration,
|
|
parentDeclaration.modifiers,
|
|
parentDeclaration.name,
|
|
concatenate(parentDeclaration.members, singleElementArray(enumMember))
|
|
), {
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.IncludeAll,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Exclude
|
|
});
|
|
}
|
|
function addFunctionDeclaration(changes, context, info) {
|
|
const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
|
|
const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
|
|
const functionDeclaration = info.kind === 2 /* Function */ ? createSignatureDeclarationFromCallExpression(259 /* FunctionDeclaration */, context, importAdder, info.call, idText(info.token), info.modifierFlags, info.parentDeclaration) : createSignatureDeclarationFromSignature(259 /* FunctionDeclaration */, context, quotePreference, info.signature, createStubbedBody(Diagnostics.Function_not_implemented.message, quotePreference), info.token, void 0, void 0, void 0, importAdder);
|
|
if (functionDeclaration === void 0) {
|
|
Debug.fail("fixMissingFunctionDeclaration codefix got unexpected error.");
|
|
}
|
|
isReturnStatement(info.parentDeclaration) ? changes.insertNodeBefore(info.sourceFile, info.parentDeclaration, functionDeclaration, true) : changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration);
|
|
importAdder.writeFixes(changes);
|
|
}
|
|
function addJsxAttributes(changes, context, info) {
|
|
const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
|
|
const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
|
|
const checker = context.program.getTypeChecker();
|
|
const jsxAttributesNode = info.parentDeclaration.attributes;
|
|
const hasSpreadAttribute = some(jsxAttributesNode.properties, isJsxSpreadAttribute);
|
|
const attrs = map(info.attributes, (attr) => {
|
|
const value = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(attr), info.parentDeclaration);
|
|
const name = factory.createIdentifier(attr.name);
|
|
const jsxAttribute = factory.createJsxAttribute(name, factory.createJsxExpression(void 0, value));
|
|
setParent(name, jsxAttribute);
|
|
return jsxAttribute;
|
|
});
|
|
const jsxAttributes = factory.createJsxAttributes(hasSpreadAttribute ? [...attrs, ...jsxAttributesNode.properties] : [...jsxAttributesNode.properties, ...attrs]);
|
|
const options = { prefix: jsxAttributesNode.pos === jsxAttributesNode.end ? " " : void 0 };
|
|
changes.replaceNode(context.sourceFile, jsxAttributesNode, jsxAttributes, options);
|
|
importAdder.writeFixes(changes);
|
|
}
|
|
function addObjectLiteralProperties(changes, context, info) {
|
|
const importAdder = createImportAdder(context.sourceFile, context.program, context.preferences, context.host);
|
|
const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
|
|
const target = getEmitScriptTarget(context.program.getCompilerOptions());
|
|
const checker = context.program.getTypeChecker();
|
|
const props = map(info.properties, (prop) => {
|
|
const initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop), info.parentDeclaration);
|
|
return factory.createPropertyAssignment(createPropertyNameFromSymbol(prop, target, quotePreference, checker), initializer);
|
|
});
|
|
const options = {
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Exclude,
|
|
indentation: info.indentation
|
|
};
|
|
changes.replaceNode(context.sourceFile, info.parentDeclaration, factory.createObjectLiteralExpression([...info.parentDeclaration.properties, ...props], true), options);
|
|
importAdder.writeFixes(changes);
|
|
}
|
|
function tryGetValueFromType(context, checker, importAdder, quotePreference, type, enclosingDeclaration) {
|
|
if (type.flags & 3 /* AnyOrUnknown */) {
|
|
return createUndefined();
|
|
}
|
|
if (type.flags & (4 /* String */ | 134217728 /* TemplateLiteral */)) {
|
|
return factory.createStringLiteral("", quotePreference === 0 /* Single */);
|
|
}
|
|
if (type.flags & 8 /* Number */) {
|
|
return factory.createNumericLiteral(0);
|
|
}
|
|
if (type.flags & 64 /* BigInt */) {
|
|
return factory.createBigIntLiteral("0n");
|
|
}
|
|
if (type.flags & 16 /* Boolean */) {
|
|
return factory.createFalse();
|
|
}
|
|
if (type.flags & 1056 /* EnumLike */) {
|
|
const enumMember = type.symbol.exports ? firstOrUndefined(arrayFrom(type.symbol.exports.values())) : type.symbol;
|
|
const name = checker.symbolToExpression(type.symbol.parent ? type.symbol.parent : type.symbol, 111551 /* Value */, void 0, void 0);
|
|
return enumMember === void 0 || name === void 0 ? factory.createNumericLiteral(0) : factory.createPropertyAccessExpression(name, checker.symbolToString(enumMember));
|
|
}
|
|
if (type.flags & 256 /* NumberLiteral */) {
|
|
return factory.createNumericLiteral(type.value);
|
|
}
|
|
if (type.flags & 2048 /* BigIntLiteral */) {
|
|
return factory.createBigIntLiteral(type.value);
|
|
}
|
|
if (type.flags & 128 /* StringLiteral */) {
|
|
return factory.createStringLiteral(type.value, quotePreference === 0 /* Single */);
|
|
}
|
|
if (type.flags & 512 /* BooleanLiteral */) {
|
|
return type === checker.getFalseType() || type === checker.getFalseType(true) ? factory.createFalse() : factory.createTrue();
|
|
}
|
|
if (type.flags & 65536 /* Null */) {
|
|
return factory.createNull();
|
|
}
|
|
if (type.flags & 1048576 /* Union */) {
|
|
const expression = firstDefined(type.types, (t) => tryGetValueFromType(context, checker, importAdder, quotePreference, t, enclosingDeclaration));
|
|
return expression != null ? expression : createUndefined();
|
|
}
|
|
if (checker.isArrayLikeType(type)) {
|
|
return factory.createArrayLiteralExpression();
|
|
}
|
|
if (isObjectLiteralType(type)) {
|
|
const props = map(checker.getPropertiesOfType(type), (prop) => {
|
|
const initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration), enclosingDeclaration) : createUndefined();
|
|
return factory.createPropertyAssignment(prop.name, initializer);
|
|
});
|
|
return factory.createObjectLiteralExpression(props, true);
|
|
}
|
|
if (getObjectFlags(type) & 16 /* Anonymous */) {
|
|
const decl = find(type.symbol.declarations || emptyArray, or(isFunctionTypeNode, isMethodSignature, isMethodDeclaration));
|
|
if (decl === void 0)
|
|
return createUndefined();
|
|
const signature = checker.getSignaturesOfType(type, 0 /* Call */);
|
|
if (signature === void 0)
|
|
return createUndefined();
|
|
const func = createSignatureDeclarationFromSignature(
|
|
215 /* FunctionExpression */,
|
|
context,
|
|
quotePreference,
|
|
signature[0],
|
|
createStubbedBody(Diagnostics.Function_not_implemented.message, quotePreference),
|
|
void 0,
|
|
void 0,
|
|
void 0,
|
|
enclosingDeclaration,
|
|
importAdder
|
|
);
|
|
return func != null ? func : createUndefined();
|
|
}
|
|
if (getObjectFlags(type) & 1 /* Class */) {
|
|
const classDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (classDeclaration === void 0 || hasAbstractModifier(classDeclaration))
|
|
return createUndefined();
|
|
const constructorDeclaration = getFirstConstructorWithBody(classDeclaration);
|
|
if (constructorDeclaration && length(constructorDeclaration.parameters))
|
|
return createUndefined();
|
|
return factory.createNewExpression(factory.createIdentifier(type.symbol.name), void 0, void 0);
|
|
}
|
|
return createUndefined();
|
|
}
|
|
function createUndefined() {
|
|
return factory.createIdentifier("undefined");
|
|
}
|
|
function isObjectLiteralType(type) {
|
|
return type.flags & 524288 /* Object */ && (getObjectFlags(type) & 128 /* ObjectLiteral */ || type.symbol && tryCast(singleOrUndefined(type.symbol.declarations), isTypeLiteralNode));
|
|
}
|
|
function getUnmatchedAttributes(checker, target, source) {
|
|
const attrsType = checker.getContextualType(source.attributes);
|
|
if (attrsType === void 0)
|
|
return emptyArray;
|
|
const targetProps = attrsType.getProperties();
|
|
if (!length(targetProps))
|
|
return emptyArray;
|
|
const seenNames = /* @__PURE__ */ new Set();
|
|
for (const sourceProp of source.attributes.properties) {
|
|
if (isJsxAttribute(sourceProp)) {
|
|
seenNames.add(sourceProp.name.escapedText);
|
|
}
|
|
if (isJsxSpreadAttribute(sourceProp)) {
|
|
const type = checker.getTypeAtLocation(sourceProp.expression);
|
|
for (const prop of type.getProperties()) {
|
|
seenNames.add(prop.escapedName);
|
|
}
|
|
}
|
|
}
|
|
return filter(targetProps, (targetProp) => isIdentifierText(targetProp.name, target, 1 /* JSX */) && !(targetProp.flags & 16777216 /* Optional */ || getCheckFlags(targetProp) & 48 /* Partial */ || seenNames.has(targetProp.escapedName)));
|
|
}
|
|
function tryGetContainingMethodDeclaration(node, callExpression) {
|
|
if (isTypeLiteralNode(node)) {
|
|
return void 0;
|
|
}
|
|
const declaration = findAncestor(callExpression, (n) => isMethodDeclaration(n) || isConstructorDeclaration(n));
|
|
return declaration && declaration.parent === node ? declaration : void 0;
|
|
}
|
|
function createPropertyNameFromSymbol(symbol, target, quotePreference, checker) {
|
|
if (isTransientSymbol(symbol)) {
|
|
const prop = checker.symbolToNode(symbol, 111551 /* Value */, void 0, 1073741824 /* WriteComputedProps */);
|
|
if (prop && isComputedPropertyName(prop))
|
|
return prop;
|
|
}
|
|
return createPropertyNameNodeForIdentifierOrLiteral(symbol.name, target, quotePreference === 0 /* Single */);
|
|
}
|
|
function findScope(node) {
|
|
if (findAncestor(node, isJsxExpression)) {
|
|
const returnStatement = findAncestor(node.parent, isReturnStatement);
|
|
if (returnStatement)
|
|
return returnStatement;
|
|
}
|
|
return getSourceFileOfNode(node);
|
|
}
|
|
|
|
// src/services/codefixes/fixAddMissingNewOperator.ts
|
|
var fixId23 = "addMissingNewOperator";
|
|
var errorCodes27 = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes27,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingNewOperator(t, sourceFile, span));
|
|
return [createCodeFixAction(fixId23, changes, Diagnostics.Add_missing_new_operator_to_call, fixId23, Diagnostics.Add_missing_new_operator_to_all_calls)];
|
|
},
|
|
fixIds: [fixId23],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes27, (changes, diag2) => addMissingNewOperator(changes, context.sourceFile, diag2))
|
|
});
|
|
function addMissingNewOperator(changes, sourceFile, span) {
|
|
const call = cast(findAncestorMatchingSpan2(sourceFile, span), isCallExpression);
|
|
const newExpression = factory.createNewExpression(call.expression, call.typeArguments, call.arguments);
|
|
changes.replaceNode(sourceFile, call, newExpression);
|
|
}
|
|
function findAncestorMatchingSpan2(sourceFile, span) {
|
|
let token = getTokenAtPosition(sourceFile, span.start);
|
|
const end = textSpanEnd(span);
|
|
while (token.end < end) {
|
|
token = token.parent;
|
|
}
|
|
return token;
|
|
}
|
|
|
|
// src/services/codefixes/fixCannotFindModule.ts
|
|
var fixName2 = "fixCannotFindModule";
|
|
var fixIdInstallTypesPackage = "installTypesPackage";
|
|
var errorCodeCannotFindModule = Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code;
|
|
var errorCodes28 = [
|
|
errorCodeCannotFindModule,
|
|
Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes28,
|
|
getCodeActions: function getCodeActionsToFixNotFoundModule(context) {
|
|
const { host, sourceFile, span: { start: start2 } } = context;
|
|
const packageName = tryGetImportedPackageName(sourceFile, start2);
|
|
if (packageName === void 0)
|
|
return void 0;
|
|
const typesPackageName = getTypesPackageNameToInstall(packageName, host, context.errorCode);
|
|
return typesPackageName === void 0 ? [] : [createCodeFixAction(fixName2, [], [Diagnostics.Install_0, typesPackageName], fixIdInstallTypesPackage, Diagnostics.Install_all_missing_types_packages, getInstallCommand(sourceFile.fileName, typesPackageName))];
|
|
},
|
|
fixIds: [fixIdInstallTypesPackage],
|
|
getAllCodeActions: (context) => {
|
|
return codeFixAll(context, errorCodes28, (_changes, diag2, commands) => {
|
|
const packageName = tryGetImportedPackageName(diag2.file, diag2.start);
|
|
if (packageName === void 0)
|
|
return void 0;
|
|
switch (context.fixId) {
|
|
case fixIdInstallTypesPackage: {
|
|
const pkg = getTypesPackageNameToInstall(packageName, context.host, diag2.code);
|
|
if (pkg) {
|
|
commands.push(getInstallCommand(diag2.file.fileName, pkg));
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
Debug.fail(`Bad fixId: ${context.fixId}`);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getInstallCommand(fileName, packageName) {
|
|
return { type: "install package", file: fileName, packageName };
|
|
}
|
|
function tryGetImportedPackageName(sourceFile, pos) {
|
|
const moduleSpecifierText = tryCast(getTokenAtPosition(sourceFile, pos), isStringLiteral);
|
|
if (!moduleSpecifierText)
|
|
return void 0;
|
|
const moduleName = moduleSpecifierText.text;
|
|
const { packageName } = parsePackageName(moduleName);
|
|
return isExternalModuleNameRelative(packageName) ? void 0 : packageName;
|
|
}
|
|
function getTypesPackageNameToInstall(packageName, host, diagCode) {
|
|
var _a2;
|
|
return diagCode === errorCodeCannotFindModule ? ts_JsTyping_exports.nodeCoreModules.has(packageName) ? "@types/node" : void 0 : ((_a2 = host.isKnownTypesPackageName) == null ? void 0 : _a2.call(host, packageName)) ? getTypesPackageName(packageName) : void 0;
|
|
}
|
|
|
|
// src/services/codefixes/fixClassDoesntImplementInheritedAbstractMember.ts
|
|
var errorCodes29 = [
|
|
Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code,
|
|
Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code
|
|
];
|
|
var fixId24 = "fixClassDoesntImplementInheritedAbstractMember";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes29,
|
|
getCodeActions: function getCodeActionsToFixClassNotImplementingInheritedMembers(context) {
|
|
const { sourceFile, span } = context;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addMissingMembers(getClass2(sourceFile, span.start), sourceFile, context, t, context.preferences));
|
|
return changes.length === 0 ? void 0 : [createCodeFixAction(fixId24, changes, Diagnostics.Implement_inherited_abstract_class, fixId24, Diagnostics.Implement_all_inherited_abstract_classes)];
|
|
},
|
|
fixIds: [fixId24],
|
|
getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) {
|
|
const seenClassDeclarations = /* @__PURE__ */ new Map();
|
|
return codeFixAll(context, errorCodes29, (changes, diag2) => {
|
|
const classDeclaration = getClass2(diag2.file, diag2.start);
|
|
if (addToSeen(seenClassDeclarations, getNodeId(classDeclaration))) {
|
|
addMissingMembers(classDeclaration, context.sourceFile, context, changes, context.preferences);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getClass2(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
return cast(token.parent, isClassLike);
|
|
}
|
|
function addMissingMembers(classDeclaration, sourceFile, context, changeTracker, preferences) {
|
|
const extendsNode = getEffectiveBaseTypeNode(classDeclaration);
|
|
const checker = context.program.getTypeChecker();
|
|
const instantiatedExtendsType = checker.getTypeAtLocation(extendsNode);
|
|
const abstractAndNonPrivateExtendsSymbols = checker.getPropertiesOfType(instantiatedExtendsType).filter(symbolPointsToNonPrivateAndAbstractMember);
|
|
const importAdder = createImportAdder(sourceFile, context.program, preferences, context.host);
|
|
createMissingMemberNodes(classDeclaration, abstractAndNonPrivateExtendsSymbols, sourceFile, context, preferences, importAdder, (member) => changeTracker.insertMemberAtStart(sourceFile, classDeclaration, member));
|
|
importAdder.writeFixes(changeTracker);
|
|
}
|
|
function symbolPointsToNonPrivateAndAbstractMember(symbol) {
|
|
const flags = getSyntacticModifierFlags(first(symbol.getDeclarations()));
|
|
return !(flags & 8 /* Private */) && !!(flags & 256 /* Abstract */);
|
|
}
|
|
|
|
// src/services/codefixes/fixClassSuperMustPrecedeThisAccess.ts
|
|
var fixId25 = "classSuperMustPrecedeThisAccess";
|
|
var errorCodes30 = [Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes30,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const nodes = getNodes(sourceFile, span.start);
|
|
if (!nodes)
|
|
return void 0;
|
|
const { constructor, superCall } = nodes;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange10(t, sourceFile, constructor, superCall));
|
|
return [createCodeFixAction(fixId25, changes, Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId25, Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)];
|
|
},
|
|
fixIds: [fixId25],
|
|
getAllCodeActions(context) {
|
|
const { sourceFile } = context;
|
|
const seenClasses = /* @__PURE__ */ new Map();
|
|
return codeFixAll(context, errorCodes30, (changes, diag2) => {
|
|
const nodes = getNodes(diag2.file, diag2.start);
|
|
if (!nodes)
|
|
return;
|
|
const { constructor, superCall } = nodes;
|
|
if (addToSeen(seenClasses, getNodeId(constructor.parent))) {
|
|
doChange10(changes, sourceFile, constructor, superCall);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function doChange10(changes, sourceFile, constructor, superCall) {
|
|
changes.insertNodeAtConstructorStart(sourceFile, constructor, superCall);
|
|
changes.delete(sourceFile, superCall);
|
|
}
|
|
function getNodes(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (token.kind !== 108 /* ThisKeyword */)
|
|
return void 0;
|
|
const constructor = getContainingFunction(token);
|
|
const superCall = findSuperCall(constructor.body);
|
|
return superCall && !superCall.expression.arguments.some((arg) => isPropertyAccessExpression(arg) && arg.expression === token) ? { constructor, superCall } : void 0;
|
|
}
|
|
function findSuperCall(n) {
|
|
return isExpressionStatement(n) && isSuperCall(n.expression) ? n : isFunctionLike(n) ? void 0 : forEachChild(n, findSuperCall);
|
|
}
|
|
|
|
// src/services/codefixes/fixConstructorForDerivedNeedSuperCall.ts
|
|
var fixId26 = "constructorForDerivedNeedSuperCall";
|
|
var errorCodes31 = [Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes31,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const ctr = getNode(sourceFile, span.start);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange11(t, sourceFile, ctr));
|
|
return [createCodeFixAction(fixId26, changes, Diagnostics.Add_missing_super_call, fixId26, Diagnostics.Add_all_missing_super_calls)];
|
|
},
|
|
fixIds: [fixId26],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes31, (changes, diag2) => doChange11(changes, context.sourceFile, getNode(diag2.file, diag2.start)))
|
|
});
|
|
function getNode(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
Debug.assert(isConstructorDeclaration(token.parent), "token should be at the constructor declaration");
|
|
return token.parent;
|
|
}
|
|
function doChange11(changes, sourceFile, ctr) {
|
|
const superCall = factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), void 0, emptyArray));
|
|
changes.insertNodeAtConstructorStart(sourceFile, ctr, superCall);
|
|
}
|
|
|
|
// src/services/codefixes/fixEnableExperimentalDecorators.ts
|
|
var fixId27 = "enableExperimentalDecorators";
|
|
var errorCodes32 = [
|
|
Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes32,
|
|
getCodeActions: function getCodeActionsToEnableExperimentalDecorators(context) {
|
|
const { configFile } = context.program.getCompilerOptions();
|
|
if (configFile === void 0) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changeTracker) => doChange12(changeTracker, configFile));
|
|
return [createCodeFixActionWithoutFixAll(fixId27, changes, Diagnostics.Enable_the_experimentalDecorators_option_in_your_configuration_file)];
|
|
},
|
|
fixIds: [fixId27],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes32, (changes) => {
|
|
const { configFile } = context.program.getCompilerOptions();
|
|
if (configFile === void 0) {
|
|
return void 0;
|
|
}
|
|
doChange12(changes, configFile);
|
|
})
|
|
});
|
|
function doChange12(changeTracker, configFile) {
|
|
setJsonCompilerOptionValue(changeTracker, configFile, "experimentalDecorators", factory.createTrue());
|
|
}
|
|
|
|
// src/services/codefixes/fixEnableJsxFlag.ts
|
|
var fixID = "fixEnableJsxFlag";
|
|
var errorCodes33 = [Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes33,
|
|
getCodeActions: function getCodeActionsToFixEnableJsxFlag(context) {
|
|
const { configFile } = context.program.getCompilerOptions();
|
|
if (configFile === void 0) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(
|
|
context,
|
|
(changeTracker) => doChange13(changeTracker, configFile)
|
|
);
|
|
return [
|
|
createCodeFixActionWithoutFixAll(fixID, changes, Diagnostics.Enable_the_jsx_flag_in_your_configuration_file)
|
|
];
|
|
},
|
|
fixIds: [fixID],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes33, (changes) => {
|
|
const { configFile } = context.program.getCompilerOptions();
|
|
if (configFile === void 0) {
|
|
return void 0;
|
|
}
|
|
doChange13(changes, configFile);
|
|
})
|
|
});
|
|
function doChange13(changeTracker, configFile) {
|
|
setJsonCompilerOptionValue(changeTracker, configFile, "jsx", factory.createStringLiteral("react"));
|
|
}
|
|
|
|
// src/services/codefixes/fixNaNEquality.ts
|
|
var fixId28 = "fixNaNEquality";
|
|
var errorCodes34 = [
|
|
Diagnostics.This_condition_will_always_return_0.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes34,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span, program } = context;
|
|
const info = getInfo8(program, sourceFile, span);
|
|
if (info === void 0)
|
|
return;
|
|
const { suggestion, expression, arg } = info;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange14(t, sourceFile, arg, expression));
|
|
return [createCodeFixAction(fixId28, changes, [Diagnostics.Use_0, suggestion], fixId28, Diagnostics.Use_Number_isNaN_in_all_conditions)];
|
|
},
|
|
fixIds: [fixId28],
|
|
getAllCodeActions: (context) => {
|
|
return codeFixAll(context, errorCodes34, (changes, diag2) => {
|
|
const info = getInfo8(context.program, diag2.file, createTextSpan(diag2.start, diag2.length));
|
|
if (info) {
|
|
doChange14(changes, diag2.file, info.arg, info.expression);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getInfo8(program, sourceFile, span) {
|
|
const diag2 = find(program.getSemanticDiagnostics(sourceFile), (diag3) => diag3.start === span.start && diag3.length === span.length);
|
|
if (diag2 === void 0 || diag2.relatedInformation === void 0)
|
|
return;
|
|
const related = find(diag2.relatedInformation, (related2) => related2.code === Diagnostics.Did_you_mean_0.code);
|
|
if (related === void 0 || related.file === void 0 || related.start === void 0 || related.length === void 0)
|
|
return;
|
|
const token = findAncestorMatchingSpan(related.file, createTextSpan(related.start, related.length));
|
|
if (token === void 0)
|
|
return;
|
|
if (isExpression(token) && isBinaryExpression(token.parent)) {
|
|
return { suggestion: getSuggestion(related.messageText), expression: token.parent, arg: token };
|
|
}
|
|
return void 0;
|
|
}
|
|
function doChange14(changes, sourceFile, arg, expression) {
|
|
const callExpression = factory.createCallExpression(
|
|
factory.createPropertyAccessExpression(factory.createIdentifier("Number"), factory.createIdentifier("isNaN")),
|
|
void 0,
|
|
[arg]
|
|
);
|
|
const operator = expression.operatorToken.kind;
|
|
changes.replaceNode(
|
|
sourceFile,
|
|
expression,
|
|
operator === 37 /* ExclamationEqualsEqualsToken */ || operator === 35 /* ExclamationEqualsToken */ ? factory.createPrefixUnaryExpression(53 /* ExclamationToken */, callExpression) : callExpression
|
|
);
|
|
}
|
|
function getSuggestion(messageText) {
|
|
const [_, suggestion] = flattenDiagnosticMessageText(messageText, "\n", 0).match(/\'(.*)\'/) || [];
|
|
return suggestion;
|
|
}
|
|
|
|
// src/services/codefixes/fixModuleAndTargetOptions.ts
|
|
registerCodeFix({
|
|
errorCodes: [
|
|
Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code,
|
|
Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code
|
|
],
|
|
getCodeActions: function getCodeActionsToFixModuleAndTarget(context) {
|
|
const compilerOptions = context.program.getCompilerOptions();
|
|
const { configFile } = compilerOptions;
|
|
if (configFile === void 0) {
|
|
return void 0;
|
|
}
|
|
const codeFixes = [];
|
|
const moduleKind = getEmitModuleKind(compilerOptions);
|
|
const moduleOutOfRange = moduleKind >= 5 /* ES2015 */ && moduleKind < 99 /* ESNext */;
|
|
if (moduleOutOfRange) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
|
|
setJsonCompilerOptionValue(changes2, configFile, "module", factory.createStringLiteral("esnext"));
|
|
});
|
|
codeFixes.push(createCodeFixActionWithoutFixAll("fixModuleOption", changes, [Diagnostics.Set_the_module_option_in_your_configuration_file_to_0, "esnext"]));
|
|
}
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
const targetOutOfRange = target < 4 /* ES2017 */ || target > 99 /* ESNext */;
|
|
if (targetOutOfRange) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (tracker) => {
|
|
const configObject = getTsConfigObjectLiteralExpression(configFile);
|
|
if (!configObject)
|
|
return;
|
|
const options = [["target", factory.createStringLiteral("es2017")]];
|
|
if (moduleKind === 1 /* CommonJS */) {
|
|
options.push(["module", factory.createStringLiteral("commonjs")]);
|
|
}
|
|
setJsonCompilerOptionValues(tracker, configFile, options);
|
|
});
|
|
codeFixes.push(createCodeFixActionWithoutFixAll("fixTargetOption", changes, [Diagnostics.Set_the_target_option_in_your_configuration_file_to_0, "es2017"]));
|
|
}
|
|
return codeFixes.length ? codeFixes : void 0;
|
|
}
|
|
});
|
|
|
|
// src/services/codefixes/fixPropertyAssignment.ts
|
|
var fixId29 = "fixPropertyAssignment";
|
|
var errorCodes35 = [
|
|
Diagnostics.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.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes35,
|
|
fixIds: [fixId29],
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const property = getProperty2(sourceFile, span.start);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange15(t, context.sourceFile, property));
|
|
return [createCodeFixAction(fixId29, changes, [Diagnostics.Change_0_to_1, "=", ":"], fixId29, [Diagnostics.Switch_each_misused_0_to_1, "=", ":"])];
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes35, (changes, diag2) => doChange15(changes, diag2.file, getProperty2(diag2.file, diag2.start)))
|
|
});
|
|
function doChange15(changes, sourceFile, node) {
|
|
changes.replaceNode(sourceFile, node, factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer));
|
|
}
|
|
function getProperty2(sourceFile, pos) {
|
|
return cast(getTokenAtPosition(sourceFile, pos).parent, isShorthandPropertyAssignment);
|
|
}
|
|
|
|
// src/services/codefixes/fixExtendsInterfaceBecomesImplements.ts
|
|
var fixId30 = "extendsInterfaceBecomesImplements";
|
|
var errorCodes36 = [Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes36,
|
|
getCodeActions(context) {
|
|
const { sourceFile } = context;
|
|
const nodes = getNodes2(sourceFile, context.span.start);
|
|
if (!nodes)
|
|
return void 0;
|
|
const { extendsToken, heritageClauses } = nodes;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChanges2(t, sourceFile, extendsToken, heritageClauses));
|
|
return [createCodeFixAction(fixId30, changes, Diagnostics.Change_extends_to_implements, fixId30, Diagnostics.Change_all_extended_interfaces_to_implements)];
|
|
},
|
|
fixIds: [fixId30],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes36, (changes, diag2) => {
|
|
const nodes = getNodes2(diag2.file, diag2.start);
|
|
if (nodes)
|
|
doChanges2(changes, diag2.file, nodes.extendsToken, nodes.heritageClauses);
|
|
})
|
|
});
|
|
function getNodes2(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const heritageClauses = getContainingClass(token).heritageClauses;
|
|
const extendsToken = heritageClauses[0].getFirstToken();
|
|
return extendsToken.kind === 94 /* ExtendsKeyword */ ? { extendsToken, heritageClauses } : void 0;
|
|
}
|
|
function doChanges2(changes, sourceFile, extendsToken, heritageClauses) {
|
|
changes.replaceNode(sourceFile, extendsToken, factory.createToken(117 /* ImplementsKeyword */));
|
|
if (heritageClauses.length === 2 && heritageClauses[0].token === 94 /* ExtendsKeyword */ && heritageClauses[1].token === 117 /* ImplementsKeyword */) {
|
|
const implementsToken = heritageClauses[1].getFirstToken();
|
|
const implementsFullStart = implementsToken.getFullStart();
|
|
changes.replaceRange(sourceFile, { pos: implementsFullStart, end: implementsFullStart }, factory.createToken(27 /* CommaToken */));
|
|
const text = sourceFile.text;
|
|
let end = implementsToken.end;
|
|
while (end < text.length && isWhiteSpaceSingleLine(text.charCodeAt(end))) {
|
|
end++;
|
|
}
|
|
changes.deleteRange(sourceFile, { pos: implementsToken.getStart(), end });
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/fixForgottenThisPropertyAccess.ts
|
|
var fixId31 = "forgottenThisPropertyAccess";
|
|
var didYouMeanStaticMemberCode = Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code;
|
|
var errorCodes37 = [
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code,
|
|
Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code,
|
|
didYouMeanStaticMemberCode
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes37,
|
|
getCodeActions(context) {
|
|
const { sourceFile } = context;
|
|
const info = getInfo9(sourceFile, context.span.start, context.errorCode);
|
|
if (!info) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange16(t, sourceFile, info));
|
|
return [createCodeFixAction(fixId31, changes, [Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId31, Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)];
|
|
},
|
|
fixIds: [fixId31],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes37, (changes, diag2) => {
|
|
const info = getInfo9(diag2.file, diag2.start, diag2.code);
|
|
if (info)
|
|
doChange16(changes, context.sourceFile, info);
|
|
})
|
|
});
|
|
function getInfo9(sourceFile, pos, diagCode) {
|
|
const node = getTokenAtPosition(sourceFile, pos);
|
|
if (isIdentifier(node) || isPrivateIdentifier(node)) {
|
|
return { node, className: diagCode === didYouMeanStaticMemberCode ? getContainingClass(node).name.text : void 0 };
|
|
}
|
|
}
|
|
function doChange16(changes, sourceFile, { node, className }) {
|
|
suppressLeadingAndTrailingTrivia(node);
|
|
changes.replaceNode(sourceFile, node, factory.createPropertyAccessExpression(className ? factory.createIdentifier(className) : factory.createThis(), node));
|
|
}
|
|
|
|
// src/services/codefixes/fixInvalidJsxCharacters.ts
|
|
var fixIdExpression = "fixInvalidJsxCharacters_expression";
|
|
var fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity";
|
|
var errorCodes38 = [
|
|
Diagnostics.Unexpected_token_Did_you_mean_or_gt.code,
|
|
Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes38,
|
|
fixIds: [fixIdExpression, fixIdHtmlEntity],
|
|
getCodeActions(context) {
|
|
const { sourceFile, preferences, span } = context;
|
|
const changeToExpression = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, preferences, sourceFile, span.start, false));
|
|
const changeToHtmlEntity = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange17(t, preferences, sourceFile, span.start, true));
|
|
return [
|
|
createCodeFixAction(fixIdExpression, changeToExpression, Diagnostics.Wrap_invalid_character_in_an_expression_container, fixIdExpression, Diagnostics.Wrap_all_invalid_characters_in_an_expression_container),
|
|
createCodeFixAction(fixIdHtmlEntity, changeToHtmlEntity, Diagnostics.Convert_invalid_character_to_its_html_entity_code, fixIdHtmlEntity, Diagnostics.Convert_all_invalid_characters_to_HTML_entity_code)
|
|
];
|
|
},
|
|
getAllCodeActions(context) {
|
|
return codeFixAll(context, errorCodes38, (changes, diagnostic) => doChange17(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity));
|
|
}
|
|
});
|
|
var htmlEntity = {
|
|
">": ">",
|
|
"}": "}"
|
|
};
|
|
function isValidCharacter(character) {
|
|
return hasProperty(htmlEntity, character);
|
|
}
|
|
function doChange17(changes, preferences, sourceFile, start2, useHtmlEntity) {
|
|
const character = sourceFile.getText()[start2];
|
|
if (!isValidCharacter(character)) {
|
|
return;
|
|
}
|
|
const replacement = useHtmlEntity ? htmlEntity[character] : `{${quote(sourceFile, preferences, character)}}`;
|
|
changes.replaceRangeWithText(sourceFile, { pos: start2, end: start2 + 1 }, replacement);
|
|
}
|
|
|
|
// src/services/codefixes/fixUnmatchedParameter.ts
|
|
var deleteUnmatchedParameter = "deleteUnmatchedParameter";
|
|
var renameUnmatchedParameter = "renameUnmatchedParameter";
|
|
var errorCodes39 = [
|
|
Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code
|
|
];
|
|
registerCodeFix({
|
|
fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter],
|
|
errorCodes: errorCodes39,
|
|
getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) {
|
|
const { sourceFile, span } = context;
|
|
const actions2 = [];
|
|
const info = getInfo10(sourceFile, span.start);
|
|
if (info) {
|
|
append(actions2, getDeleteAction(context, info));
|
|
append(actions2, getRenameAction(context, info));
|
|
return actions2;
|
|
}
|
|
return void 0;
|
|
},
|
|
getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) {
|
|
const tagsToSignature = /* @__PURE__ */ new Map();
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
eachDiagnostic(context, errorCodes39, ({ file, start: start2 }) => {
|
|
const info = getInfo10(file, start2);
|
|
if (info) {
|
|
tagsToSignature.set(info.signature, append(tagsToSignature.get(info.signature), info.jsDocParameterTag));
|
|
}
|
|
});
|
|
tagsToSignature.forEach((tags, signature) => {
|
|
if (context.fixId === deleteUnmatchedParameter) {
|
|
const tagsSet = new Set(tags);
|
|
changes.filterJSDocTags(signature.getSourceFile(), signature, (t) => !tagsSet.has(t));
|
|
}
|
|
});
|
|
}));
|
|
}
|
|
});
|
|
function getDeleteAction(context, { name, signature, jsDocParameterTag }) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changeTracker) => changeTracker.filterJSDocTags(context.sourceFile, signature, (t) => t !== jsDocParameterTag));
|
|
return createCodeFixAction(
|
|
deleteUnmatchedParameter,
|
|
changes,
|
|
[Diagnostics.Delete_unused_param_tag_0, name.getText(context.sourceFile)],
|
|
deleteUnmatchedParameter,
|
|
Diagnostics.Delete_all_unused_param_tags
|
|
);
|
|
}
|
|
function getRenameAction(context, { name, signature, jsDocParameterTag }) {
|
|
if (!length(signature.parameters))
|
|
return void 0;
|
|
const sourceFile = context.sourceFile;
|
|
const tags = getJSDocTags(signature);
|
|
const names = /* @__PURE__ */ new Set();
|
|
for (const tag of tags) {
|
|
if (isJSDocParameterTag(tag) && isIdentifier(tag.name)) {
|
|
names.add(tag.name.escapedText);
|
|
}
|
|
}
|
|
const parameterName = firstDefined(signature.parameters, (p) => isIdentifier(p.name) && !names.has(p.name.escapedText) ? p.name.getText(sourceFile) : void 0);
|
|
if (parameterName === void 0)
|
|
return void 0;
|
|
const newJSDocParameterTag = factory.updateJSDocParameterTag(
|
|
jsDocParameterTag,
|
|
jsDocParameterTag.tagName,
|
|
factory.createIdentifier(parameterName),
|
|
jsDocParameterTag.isBracketed,
|
|
jsDocParameterTag.typeExpression,
|
|
jsDocParameterTag.isNameFirst,
|
|
jsDocParameterTag.comment
|
|
);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changeTracker) => changeTracker.replaceJSDocComment(sourceFile, signature, map(tags, (t) => t === jsDocParameterTag ? newJSDocParameterTag : t)));
|
|
return createCodeFixActionWithoutFixAll(renameUnmatchedParameter, changes, [Diagnostics.Rename_param_tag_name_0_to_1, name.getText(sourceFile), parameterName]);
|
|
}
|
|
function getInfo10(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (token.parent && isJSDocParameterTag(token.parent) && isIdentifier(token.parent.name)) {
|
|
const jsDocParameterTag = token.parent;
|
|
const signature = getHostSignatureFromJSDoc(jsDocParameterTag);
|
|
if (signature) {
|
|
return { signature, name: token.parent.name, jsDocParameterTag };
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/services/codefixes/fixUnreferenceableDecoratorMetadata.ts
|
|
var fixId32 = "fixUnreferenceableDecoratorMetadata";
|
|
var errorCodes40 = [Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes40,
|
|
getCodeActions: (context) => {
|
|
const importDeclaration = getImportDeclaration(context.sourceFile, context.program, context.span.start);
|
|
if (!importDeclaration)
|
|
return;
|
|
const namespaceChanges = ts_textChanges_exports.ChangeTracker.with(context, (t) => importDeclaration.kind === 273 /* ImportSpecifier */ && doNamespaceImportChange(t, context.sourceFile, importDeclaration, context.program));
|
|
const typeOnlyChanges = ts_textChanges_exports.ChangeTracker.with(context, (t) => doTypeOnlyImportChange(t, context.sourceFile, importDeclaration, context.program));
|
|
let actions2;
|
|
if (namespaceChanges.length) {
|
|
actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, namespaceChanges, Diagnostics.Convert_named_imports_to_namespace_import));
|
|
}
|
|
if (typeOnlyChanges.length) {
|
|
actions2 = append(actions2, createCodeFixActionWithoutFixAll(fixId32, typeOnlyChanges, Diagnostics.Convert_to_type_only_import));
|
|
}
|
|
return actions2;
|
|
},
|
|
fixIds: [fixId32]
|
|
});
|
|
function getImportDeclaration(sourceFile, program, start2) {
|
|
const identifier = tryCast(getTokenAtPosition(sourceFile, start2), isIdentifier);
|
|
if (!identifier || identifier.parent.kind !== 180 /* TypeReference */)
|
|
return;
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(identifier);
|
|
return find((symbol == null ? void 0 : symbol.declarations) || emptyArray, or(isImportClause, isImportSpecifier, isImportEqualsDeclaration));
|
|
}
|
|
function doTypeOnlyImportChange(changes, sourceFile, importDeclaration, program) {
|
|
if (importDeclaration.kind === 268 /* ImportEqualsDeclaration */) {
|
|
changes.insertModifierBefore(sourceFile, 154 /* TypeKeyword */, importDeclaration.name);
|
|
return;
|
|
}
|
|
const importClause = importDeclaration.kind === 270 /* ImportClause */ ? importDeclaration : importDeclaration.parent.parent;
|
|
if (importClause.name && importClause.namedBindings) {
|
|
return;
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const importsValue = !!forEachImportClauseDeclaration(importClause, (decl) => {
|
|
if (skipAlias(decl.symbol, checker).flags & 111551 /* Value */)
|
|
return true;
|
|
});
|
|
if (importsValue) {
|
|
return;
|
|
}
|
|
changes.insertModifierBefore(sourceFile, 154 /* TypeKeyword */, importClause);
|
|
}
|
|
function doNamespaceImportChange(changes, sourceFile, importDeclaration, program) {
|
|
ts_refactor_exports.doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, importDeclaration.parent);
|
|
}
|
|
|
|
// src/services/codefixes/fixUnusedIdentifier.ts
|
|
var fixName3 = "unusedIdentifier";
|
|
var fixIdPrefix = "unusedIdentifier_prefix";
|
|
var fixIdDelete = "unusedIdentifier_delete";
|
|
var fixIdDeleteImports = "unusedIdentifier_deleteImports";
|
|
var fixIdInfer = "unusedIdentifier_infer";
|
|
var errorCodes41 = [
|
|
Diagnostics._0_is_declared_but_its_value_is_never_read.code,
|
|
Diagnostics._0_is_declared_but_never_used.code,
|
|
Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code,
|
|
Diagnostics.All_imports_in_import_declaration_are_unused.code,
|
|
Diagnostics.All_destructured_elements_are_unused.code,
|
|
Diagnostics.All_variables_are_unused.code,
|
|
Diagnostics.All_type_parameters_are_unused.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes41,
|
|
getCodeActions(context) {
|
|
const { errorCode, sourceFile, program, cancellationToken } = context;
|
|
const checker = program.getTypeChecker();
|
|
const sourceFiles = program.getSourceFiles();
|
|
const token = getTokenAtPosition(sourceFile, context.span.start);
|
|
if (isJSDocTemplateTag(token)) {
|
|
return [createDeleteFix(ts_textChanges_exports.ChangeTracker.with(context, (t) => t.delete(sourceFile, token)), Diagnostics.Remove_template_tag)];
|
|
}
|
|
if (token.kind === 29 /* LessThanToken */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => deleteTypeParameters(t, sourceFile, token));
|
|
return [createDeleteFix(changes, Diagnostics.Remove_type_parameters)];
|
|
}
|
|
const importDecl = tryGetFullImport(token);
|
|
if (importDecl) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => t.delete(sourceFile, importDecl));
|
|
return [createCodeFixAction(fixName3, changes, [Diagnostics.Remove_import_from_0, showModuleSpecifier(importDecl)], fixIdDeleteImports, Diagnostics.Delete_all_unused_imports)];
|
|
} else if (isImport(token)) {
|
|
const deletion = ts_textChanges_exports.ChangeTracker.with(context, (t) => tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, false));
|
|
if (deletion.length) {
|
|
return [createCodeFixAction(fixName3, deletion, [Diagnostics.Remove_unused_declaration_for_Colon_0, token.getText(sourceFile)], fixIdDeleteImports, Diagnostics.Delete_all_unused_imports)];
|
|
}
|
|
}
|
|
if (isObjectBindingPattern(token.parent) || isArrayBindingPattern(token.parent)) {
|
|
if (isParameter(token.parent.parent)) {
|
|
const elements = token.parent.elements;
|
|
const diagnostic = [
|
|
elements.length > 1 ? Diagnostics.Remove_unused_declarations_for_Colon_0 : Diagnostics.Remove_unused_declaration_for_Colon_0,
|
|
map(elements, (e) => e.getText(sourceFile)).join(", ")
|
|
];
|
|
return [
|
|
createDeleteFix(ts_textChanges_exports.ChangeTracker.with(context, (t) => deleteDestructuringElements(t, sourceFile, token.parent)), diagnostic)
|
|
];
|
|
}
|
|
return [
|
|
createDeleteFix(ts_textChanges_exports.ChangeTracker.with(context, (t) => t.delete(sourceFile, token.parent.parent)), Diagnostics.Remove_unused_destructuring_declaration)
|
|
];
|
|
}
|
|
if (canDeleteEntireVariableStatement(sourceFile, token)) {
|
|
return [
|
|
createDeleteFix(ts_textChanges_exports.ChangeTracker.with(context, (t) => deleteEntireVariableStatement(t, sourceFile, token.parent)), Diagnostics.Remove_variable_statement)
|
|
];
|
|
}
|
|
const result = [];
|
|
if (token.kind === 138 /* InferKeyword */) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => changeInferToUnknown(t, sourceFile, token));
|
|
const name = cast(token.parent, isInferTypeNode).typeParameter.name.text;
|
|
result.push(createCodeFixAction(fixName3, changes, [Diagnostics.Replace_infer_0_with_unknown, name], fixIdInfer, Diagnostics.Replace_all_unused_infer_with_unknown));
|
|
} else {
|
|
const deletion = ts_textChanges_exports.ChangeTracker.with(context, (t) => tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, false));
|
|
if (deletion.length) {
|
|
const name = isComputedPropertyName(token.parent) ? token.parent : token;
|
|
result.push(createDeleteFix(deletion, [Diagnostics.Remove_unused_declaration_for_Colon_0, name.getText(sourceFile)]));
|
|
}
|
|
}
|
|
const prefix = ts_textChanges_exports.ChangeTracker.with(context, (t) => tryPrefixDeclaration(t, errorCode, sourceFile, token));
|
|
if (prefix.length) {
|
|
result.push(createCodeFixAction(fixName3, prefix, [Diagnostics.Prefix_0_with_an_underscore, token.getText(sourceFile)], fixIdPrefix, Diagnostics.Prefix_all_unused_declarations_with_where_possible));
|
|
}
|
|
return result;
|
|
},
|
|
fixIds: [fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer],
|
|
getAllCodeActions: (context) => {
|
|
const { sourceFile, program, cancellationToken } = context;
|
|
const checker = program.getTypeChecker();
|
|
const sourceFiles = program.getSourceFiles();
|
|
return codeFixAll(context, errorCodes41, (changes, diag2) => {
|
|
const token = getTokenAtPosition(sourceFile, diag2.start);
|
|
switch (context.fixId) {
|
|
case fixIdPrefix:
|
|
tryPrefixDeclaration(changes, diag2.code, sourceFile, token);
|
|
break;
|
|
case fixIdDeleteImports: {
|
|
const importDecl = tryGetFullImport(token);
|
|
if (importDecl) {
|
|
changes.delete(sourceFile, importDecl);
|
|
} else if (isImport(token)) {
|
|
tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, true);
|
|
}
|
|
break;
|
|
}
|
|
case fixIdDelete: {
|
|
if (token.kind === 138 /* InferKeyword */ || isImport(token)) {
|
|
break;
|
|
} else if (isJSDocTemplateTag(token)) {
|
|
changes.delete(sourceFile, token);
|
|
} else if (token.kind === 29 /* LessThanToken */) {
|
|
deleteTypeParameters(changes, sourceFile, token);
|
|
} else if (isObjectBindingPattern(token.parent)) {
|
|
if (token.parent.parent.initializer) {
|
|
break;
|
|
} else if (!isParameter(token.parent.parent) || isNotProvidedArguments(token.parent.parent, checker, sourceFiles)) {
|
|
changes.delete(sourceFile, token.parent.parent);
|
|
}
|
|
} else if (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, program, cancellationToken, true);
|
|
}
|
|
break;
|
|
}
|
|
case fixIdInfer:
|
|
if (token.kind === 138 /* InferKeyword */) {
|
|
changeInferToUnknown(changes, sourceFile, token);
|
|
}
|
|
break;
|
|
default:
|
|
Debug.fail(JSON.stringify(context.fixId));
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function changeInferToUnknown(changes, sourceFile, token) {
|
|
changes.replaceNode(sourceFile, token.parent, factory.createKeywordTypeNode(157 /* UnknownKeyword */));
|
|
}
|
|
function createDeleteFix(changes, diag2) {
|
|
return createCodeFixAction(fixName3, changes, diag2, fixIdDelete, Diagnostics.Delete_all_unused_declarations);
|
|
}
|
|
function deleteTypeParameters(changes, sourceFile, token) {
|
|
changes.delete(sourceFile, Debug.checkDefined(cast(token.parent, isDeclarationWithTypeParameterChildren).typeParameters, "The type parameter to delete should exist"));
|
|
}
|
|
function isImport(token) {
|
|
return token.kind === 100 /* ImportKeyword */ || token.kind === 79 /* Identifier */ && (token.parent.kind === 273 /* ImportSpecifier */ || token.parent.kind === 270 /* ImportClause */);
|
|
}
|
|
function tryGetFullImport(token) {
|
|
return token.kind === 100 /* ImportKeyword */ ? tryCast(token.parent, isImportDeclaration) : void 0;
|
|
}
|
|
function canDeleteEntireVariableStatement(sourceFile, token) {
|
|
return isVariableDeclarationList(token.parent) && first(token.parent.getChildren(sourceFile)) === token;
|
|
}
|
|
function deleteEntireVariableStatement(changes, sourceFile, node) {
|
|
changes.delete(sourceFile, node.parent.kind === 240 /* VariableStatement */ ? node.parent : node);
|
|
}
|
|
function deleteDestructuringElements(changes, sourceFile, node) {
|
|
forEach(node.elements, (n) => changes.delete(sourceFile, n));
|
|
}
|
|
function tryPrefixDeclaration(changes, errorCode, sourceFile, token) {
|
|
if (errorCode === Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code)
|
|
return;
|
|
if (token.kind === 138 /* InferKeyword */) {
|
|
token = cast(token.parent, isInferTypeNode).typeParameter.name;
|
|
}
|
|
if (isIdentifier(token) && canPrefix(token)) {
|
|
changes.replaceNode(sourceFile, token, factory.createIdentifier(`_${token.text}`));
|
|
if (isParameter(token.parent)) {
|
|
getJSDocParameterTags(token.parent).forEach((tag) => {
|
|
if (isIdentifier(tag.name)) {
|
|
changes.replaceNode(sourceFile, tag.name, factory.createIdentifier(`_${tag.name.text}`));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function canPrefix(token) {
|
|
switch (token.parent.kind) {
|
|
case 166 /* Parameter */:
|
|
case 165 /* TypeParameter */:
|
|
return true;
|
|
case 257 /* VariableDeclaration */: {
|
|
const varDecl = token.parent;
|
|
switch (varDecl.parent.parent.kind) {
|
|
case 247 /* ForOfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, isFixAll) {
|
|
tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, program, cancellationToken, isFixAll);
|
|
if (isIdentifier(token)) {
|
|
ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(token, checker, sourceFile, (ref) => {
|
|
if (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, program, cancellationToken, isFixAll) {
|
|
const { parent: parent2 } = token;
|
|
if (isParameter(parent2)) {
|
|
tryDeleteParameter(changes, sourceFile, parent2, checker, sourceFiles, program, cancellationToken, isFixAll);
|
|
} else if (!(isFixAll && isIdentifier(token) && ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(token, checker, sourceFile))) {
|
|
const node = isImportClause(parent2) ? token : isComputedPropertyName(parent2) ? parent2.parent : parent2;
|
|
Debug.assert(node !== sourceFile, "should not delete whole source file");
|
|
changes.delete(sourceFile, node);
|
|
}
|
|
}
|
|
function tryDeleteParameter(changes, sourceFile, parameter, checker, sourceFiles, program, cancellationToken, isFixAll = false) {
|
|
if (mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll)) {
|
|
if (parameter.modifiers && parameter.modifiers.length > 0 && (!isIdentifier(parameter.name) || ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(parameter.name, checker, sourceFile))) {
|
|
for (const modifier of parameter.modifiers) {
|
|
if (isModifier(modifier)) {
|
|
changes.deleteModifier(sourceFile, modifier);
|
|
}
|
|
}
|
|
} else if (!parameter.initializer && isNotProvidedArguments(parameter, checker, sourceFiles)) {
|
|
changes.delete(sourceFile, parameter);
|
|
}
|
|
}
|
|
}
|
|
function isNotProvidedArguments(parameter, checker, sourceFiles) {
|
|
const index = parameter.parent.parameters.indexOf(parameter);
|
|
return !ts_FindAllReferences_exports.Core.someSignatureUsage(parameter.parent, sourceFiles, checker, (_, call) => !call || call.arguments.length > index);
|
|
}
|
|
function mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll) {
|
|
const { parent: parent2 } = parameter;
|
|
switch (parent2.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
const index = parent2.parameters.indexOf(parameter);
|
|
const referent = isMethodDeclaration(parent2) ? parent2.name : parent2;
|
|
const entries = ts_FindAllReferences_exports.Core.getReferencedSymbolsForNode(parent2.pos, referent, program, sourceFiles, cancellationToken);
|
|
if (entries) {
|
|
for (const entry of entries) {
|
|
for (const reference of entry.references) {
|
|
if (reference.kind === ts_FindAllReferences_exports.EntryKind.Node) {
|
|
const isSuperCall2 = isSuperKeyword(reference.node) && isCallExpression(reference.node.parent) && reference.node.parent.arguments.length > index;
|
|
const isSuperMethodCall = isPropertyAccessExpression(reference.node.parent) && isSuperKeyword(reference.node.parent.expression) && isCallExpression(reference.node.parent.parent) && reference.node.parent.parent.arguments.length > index;
|
|
const isOverriddenMethod = (isMethodDeclaration(reference.node.parent) || isMethodSignature(reference.node.parent)) && reference.node.parent !== parameter.parent && reference.node.parent.parameters.length > index;
|
|
if (isSuperCall2 || isSuperMethodCall || isOverriddenMethod)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
case 259 /* FunctionDeclaration */: {
|
|
if (parent2.name && isCallbackLike(checker, sourceFile, parent2.name)) {
|
|
return isLastParameter(parent2, parameter, isFixAll);
|
|
}
|
|
return true;
|
|
}
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return isLastParameter(parent2, parameter, isFixAll);
|
|
case 175 /* SetAccessor */:
|
|
return false;
|
|
case 174 /* GetAccessor */:
|
|
return true;
|
|
default:
|
|
return Debug.failBadSyntaxKind(parent2);
|
|
}
|
|
}
|
|
function isCallbackLike(checker, sourceFile, name) {
|
|
return !!ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(name, checker, sourceFile, (reference) => isIdentifier(reference) && isCallExpression(reference.parent) && reference.parent.arguments.indexOf(reference) >= 0);
|
|
}
|
|
function isLastParameter(func, parameter, isFixAll) {
|
|
const parameters = func.parameters;
|
|
const index = parameters.indexOf(parameter);
|
|
Debug.assert(index !== -1, "The parameter should already be in the list");
|
|
return isFixAll ? parameters.slice(index + 1).every((p) => isIdentifier(p.name) && !p.symbol.isReferenced) : index === parameters.length - 1;
|
|
}
|
|
function mayDeleteExpression(node) {
|
|
return (isBinaryExpression(node.parent) && node.parent.left === node || (isPostfixUnaryExpression(node.parent) || isPrefixUnaryExpression(node.parent)) && node.parent.operand === node) && isExpressionStatement(node.parent.parent);
|
|
}
|
|
|
|
// src/services/codefixes/fixUnreachableCode.ts
|
|
var fixId33 = "fixUnreachableCode";
|
|
var errorCodes42 = [Diagnostics.Unreachable_code_detected.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes42,
|
|
getCodeActions(context) {
|
|
const syntacticDiagnostics = context.program.getSyntacticDiagnostics(context.sourceFile, context.cancellationToken);
|
|
if (syntacticDiagnostics.length)
|
|
return;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange18(t, context.sourceFile, context.span.start, context.span.length, context.errorCode));
|
|
return [createCodeFixAction(fixId33, changes, Diagnostics.Remove_unreachable_code, fixId33, Diagnostics.Remove_all_unreachable_code)];
|
|
},
|
|
fixIds: [fixId33],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes42, (changes, diag2) => doChange18(changes, diag2.file, diag2.start, diag2.length, diag2.code))
|
|
});
|
|
function doChange18(changes, sourceFile, start2, length2, errorCode) {
|
|
const token = getTokenAtPosition(sourceFile, start2);
|
|
const statement = findAncestor(token, isStatement);
|
|
if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) {
|
|
const logData = JSON.stringify({
|
|
statementKind: Debug.formatSyntaxKind(statement.kind),
|
|
tokenKind: Debug.formatSyntaxKind(token.kind),
|
|
errorCode,
|
|
start: start2,
|
|
length: length2
|
|
});
|
|
Debug.fail("Token and statement should start at the same point. " + logData);
|
|
}
|
|
const container = (isBlock(statement.parent) ? statement.parent : statement).parent;
|
|
if (!isBlock(statement.parent) || statement === first(statement.parent.statements)) {
|
|
switch (container.kind) {
|
|
case 242 /* IfStatement */:
|
|
if (container.elseStatement) {
|
|
if (isBlock(statement.parent)) {
|
|
break;
|
|
} else {
|
|
changes.replaceNode(sourceFile, statement, factory.createBlock(emptyArray));
|
|
}
|
|
return;
|
|
}
|
|
case 244 /* WhileStatement */:
|
|
case 245 /* ForStatement */:
|
|
changes.delete(sourceFile, container);
|
|
return;
|
|
}
|
|
}
|
|
if (isBlock(statement.parent)) {
|
|
const end = start2 + length2;
|
|
const lastStatement = Debug.checkDefined(lastWhere(sliceAfter(statement.parent.statements, statement), (s) => s.pos < end), "Some statement should be last");
|
|
changes.deleteNodeRange(sourceFile, statement, lastStatement);
|
|
} else {
|
|
changes.delete(sourceFile, statement);
|
|
}
|
|
}
|
|
function lastWhere(a, pred) {
|
|
let last2;
|
|
for (const value of a) {
|
|
if (!pred(value))
|
|
break;
|
|
last2 = value;
|
|
}
|
|
return last2;
|
|
}
|
|
|
|
// src/services/codefixes/fixUnusedLabel.ts
|
|
var fixId34 = "fixUnusedLabel";
|
|
var errorCodes43 = [Diagnostics.Unused_label.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes43,
|
|
getCodeActions(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange19(t, context.sourceFile, context.span.start));
|
|
return [createCodeFixAction(fixId34, changes, Diagnostics.Remove_unused_label, fixId34, Diagnostics.Remove_all_unused_labels)];
|
|
},
|
|
fixIds: [fixId34],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes43, (changes, diag2) => doChange19(changes, diag2.file, diag2.start))
|
|
});
|
|
function doChange19(changes, sourceFile, start2) {
|
|
const token = getTokenAtPosition(sourceFile, start2);
|
|
const labeledStatement = cast(token.parent, isLabeledStatement);
|
|
const pos = token.getStart(sourceFile);
|
|
const statementPos = labeledStatement.statement.getStart(sourceFile);
|
|
const end = positionsAreOnSameLine(pos, statementPos, sourceFile) ? statementPos : skipTrivia(sourceFile.text, findChildOfKind(labeledStatement, 58 /* ColonToken */, sourceFile).end, true);
|
|
changes.deleteRange(sourceFile, { pos, end });
|
|
}
|
|
|
|
// src/services/codefixes/fixJSDocTypes.ts
|
|
var fixIdPlain = "fixJSDocTypes_plain";
|
|
var fixIdNullable = "fixJSDocTypes_nullable";
|
|
var errorCodes44 = [Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes44,
|
|
getCodeActions(context) {
|
|
const { sourceFile } = context;
|
|
const checker = context.program.getTypeChecker();
|
|
const info = getInfo11(sourceFile, context.span.start, checker);
|
|
if (!info)
|
|
return void 0;
|
|
const { typeNode, type } = info;
|
|
const original = typeNode.getText(sourceFile);
|
|
const actions2 = [fix(type, fixIdPlain, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript)];
|
|
if (typeNode.kind === 317 /* JSDocNullableType */) {
|
|
actions2.push(fix(checker.getNullableType(type, 32768 /* Undefined */), fixIdNullable, Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types));
|
|
}
|
|
return actions2;
|
|
function fix(type2, fixId52, fixAllDescription) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange20(t, sourceFile, typeNode, type2, checker));
|
|
return createCodeFixAction("jdocTypes", changes, [Diagnostics.Change_0_to_1, original, checker.typeToString(type2)], fixId52, fixAllDescription);
|
|
}
|
|
},
|
|
fixIds: [fixIdPlain, fixIdNullable],
|
|
getAllCodeActions(context) {
|
|
const { fixId: fixId52, program, sourceFile } = context;
|
|
const checker = program.getTypeChecker();
|
|
return codeFixAll(context, errorCodes44, (changes, err) => {
|
|
const info = getInfo11(err.file, err.start, checker);
|
|
if (!info)
|
|
return;
|
|
const { typeNode, type } = info;
|
|
const fixedType = typeNode.kind === 317 /* JSDocNullableType */ && fixId52 === fixIdNullable ? checker.getNullableType(type, 32768 /* Undefined */) : type;
|
|
doChange20(changes, sourceFile, typeNode, fixedType, checker);
|
|
});
|
|
}
|
|
});
|
|
function doChange20(changes, sourceFile, oldTypeNode, newType, checker) {
|
|
changes.replaceNode(sourceFile, oldTypeNode, checker.typeToTypeNode(newType, oldTypeNode, void 0));
|
|
}
|
|
function getInfo11(sourceFile, pos, checker) {
|
|
const decl = findAncestor(getTokenAtPosition(sourceFile, pos), isTypeContainer);
|
|
const typeNode = decl && decl.type;
|
|
return typeNode && { typeNode, type: checker.getTypeFromTypeNode(typeNode) };
|
|
}
|
|
function isTypeContainer(node) {
|
|
switch (node.kind) {
|
|
case 231 /* AsExpression */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 178 /* IndexSignature */:
|
|
case 197 /* MappedType */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 166 /* Parameter */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 175 /* SetAccessor */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 257 /* VariableDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/fixMissingCallParentheses.ts
|
|
var fixId35 = "fixMissingCallParentheses";
|
|
var errorCodes45 = [
|
|
Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes45,
|
|
fixIds: [fixId35],
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const callName = getCallName(sourceFile, span.start);
|
|
if (!callName)
|
|
return;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange21(t, context.sourceFile, callName));
|
|
return [createCodeFixAction(fixId35, changes, Diagnostics.Add_missing_call_parentheses, fixId35, Diagnostics.Add_all_missing_call_parentheses)];
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes45, (changes, diag2) => {
|
|
const callName = getCallName(diag2.file, diag2.start);
|
|
if (callName)
|
|
doChange21(changes, diag2.file, callName);
|
|
})
|
|
});
|
|
function doChange21(changes, sourceFile, name) {
|
|
changes.replaceNodeWithText(sourceFile, name, `${name.text}()`);
|
|
}
|
|
function getCallName(sourceFile, start2) {
|
|
const token = getTokenAtPosition(sourceFile, start2);
|
|
if (isPropertyAccessExpression(token.parent)) {
|
|
let current = token.parent;
|
|
while (isPropertyAccessExpression(current.parent)) {
|
|
current = current.parent;
|
|
}
|
|
return current.name;
|
|
}
|
|
if (isIdentifier(token)) {
|
|
return token;
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/services/codefixes/fixAwaitInSyncFunction.ts
|
|
var fixId36 = "fixAwaitInSyncFunction";
|
|
var errorCodes46 = [
|
|
Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
|
|
Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
|
|
Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes46,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span } = context;
|
|
const nodes = getNodes3(sourceFile, span.start);
|
|
if (!nodes)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange22(t, sourceFile, nodes));
|
|
return [createCodeFixAction(fixId36, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId36, Diagnostics.Add_all_missing_async_modifiers)];
|
|
},
|
|
fixIds: [fixId36],
|
|
getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) {
|
|
const seen = /* @__PURE__ */ new Map();
|
|
return codeFixAll(context, errorCodes46, (changes, diag2) => {
|
|
const nodes = getNodes3(diag2.file, diag2.start);
|
|
if (!nodes || !addToSeen(seen, getNodeId(nodes.insertBefore)))
|
|
return;
|
|
doChange22(changes, context.sourceFile, nodes);
|
|
});
|
|
}
|
|
});
|
|
function getReturnType(expr) {
|
|
if (expr.type) {
|
|
return expr.type;
|
|
}
|
|
if (isVariableDeclaration(expr.parent) && expr.parent.type && isFunctionTypeNode(expr.parent.type)) {
|
|
return expr.parent.type.type;
|
|
}
|
|
}
|
|
function getNodes3(sourceFile, start2) {
|
|
const token = getTokenAtPosition(sourceFile, start2);
|
|
const containingFunction = getContainingFunction(token);
|
|
if (!containingFunction) {
|
|
return;
|
|
}
|
|
let insertBefore;
|
|
switch (containingFunction.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
insertBefore = containingFunction.name;
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
insertBefore = findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
const kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
|
|
insertBefore = findChildOfKind(containingFunction, kind, sourceFile) || first(containingFunction.parameters);
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
return insertBefore && {
|
|
insertBefore,
|
|
returnType: getReturnType(containingFunction)
|
|
};
|
|
}
|
|
function doChange22(changes, sourceFile, { insertBefore, returnType }) {
|
|
if (returnType) {
|
|
const entityName = getEntityNameFromTypeNode(returnType);
|
|
if (!entityName || entityName.kind !== 79 /* Identifier */ || entityName.text !== "Promise") {
|
|
changes.replaceNode(sourceFile, returnType, factory.createTypeReferenceNode("Promise", factory.createNodeArray([returnType])));
|
|
}
|
|
}
|
|
changes.insertModifierBefore(sourceFile, 132 /* AsyncKeyword */, insertBefore);
|
|
}
|
|
|
|
// src/services/codefixes/fixPropertyOverrideAccessor.ts
|
|
var errorCodes47 = [
|
|
Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code,
|
|
Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code
|
|
];
|
|
var fixId37 = "fixPropertyOverrideAccessor";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes47,
|
|
getCodeActions(context) {
|
|
const edits = doChange23(context.sourceFile, context.span.start, context.span.length, context.errorCode, context);
|
|
if (edits) {
|
|
return [createCodeFixAction(fixId37, edits, Diagnostics.Generate_get_and_set_accessors, fixId37, Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)];
|
|
}
|
|
},
|
|
fixIds: [fixId37],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes47, (changes, diag2) => {
|
|
const edits = doChange23(diag2.file, diag2.start, diag2.length, diag2.code, context);
|
|
if (edits) {
|
|
for (const edit of edits) {
|
|
changes.pushRaw(context.sourceFile, edit);
|
|
}
|
|
}
|
|
})
|
|
});
|
|
function doChange23(file, start2, length2, code, context) {
|
|
let startPosition;
|
|
let endPosition;
|
|
if (code === Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code) {
|
|
startPosition = start2;
|
|
endPosition = start2 + length2;
|
|
} else if (code === Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code) {
|
|
const checker = context.program.getTypeChecker();
|
|
const node = getTokenAtPosition(file, start2).parent;
|
|
Debug.assert(isAccessor(node), "error span of fixPropertyOverrideAccessor should only be on an accessor");
|
|
const containingClass = node.parent;
|
|
Debug.assert(isClassLike(containingClass), "erroneous accessors should only be inside classes");
|
|
const base = singleOrUndefined(getAllSupers(containingClass, checker));
|
|
if (!base)
|
|
return [];
|
|
const name = unescapeLeadingUnderscores(getTextOfPropertyName(node.name));
|
|
const baseProp = checker.getPropertyOfType(checker.getTypeAtLocation(base), name);
|
|
if (!baseProp || !baseProp.valueDeclaration)
|
|
return [];
|
|
startPosition = baseProp.valueDeclaration.pos;
|
|
endPosition = baseProp.valueDeclaration.end;
|
|
file = getSourceFileOfNode(baseProp.valueDeclaration);
|
|
} else {
|
|
Debug.fail("fixPropertyOverrideAccessor codefix got unexpected error code " + code);
|
|
}
|
|
return generateAccessorFromProperty(file, context.program, startPosition, endPosition, context, Diagnostics.Generate_get_and_set_accessors.message);
|
|
}
|
|
|
|
// src/services/codefixes/inferFromUsage.ts
|
|
var fixId38 = "inferFromUsage";
|
|
var errorCodes48 = [
|
|
Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code,
|
|
Diagnostics.Variable_0_implicitly_has_an_1_type.code,
|
|
Diagnostics.Parameter_0_implicitly_has_an_1_type.code,
|
|
Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code,
|
|
Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code,
|
|
Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code,
|
|
Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code,
|
|
Diagnostics.Member_0_implicitly_has_an_1_type.code,
|
|
Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code,
|
|
Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code,
|
|
Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code,
|
|
Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes48,
|
|
getCodeActions(context) {
|
|
const { sourceFile, program, span: { start: start2 }, errorCode, cancellationToken, host, preferences } = context;
|
|
const token = getTokenAtPosition(sourceFile, start2);
|
|
let declaration;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (changes2) => {
|
|
declaration = doChange24(changes2, sourceFile, token, errorCode, program, cancellationToken, returnTrue, host, preferences);
|
|
});
|
|
const name = declaration && getNameOfDeclaration(declaration);
|
|
return !name || changes.length === 0 ? void 0 : [createCodeFixAction(fixId38, changes, [getDiagnostic(errorCode, token), getTextOfNode(name)], fixId38, Diagnostics.Infer_all_types_from_usage)];
|
|
},
|
|
fixIds: [fixId38],
|
|
getAllCodeActions(context) {
|
|
const { sourceFile, program, cancellationToken, host, preferences } = context;
|
|
const markSeen = nodeSeenTracker();
|
|
return codeFixAll(context, errorCodes48, (changes, err) => {
|
|
doChange24(changes, sourceFile, getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences);
|
|
});
|
|
}
|
|
});
|
|
function getDiagnostic(errorCode, token) {
|
|
switch (errorCode) {
|
|
case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
|
|
case Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return isSetAccessorDeclaration(getContainingFunction(token)) ? Diagnostics.Infer_type_of_0_from_usage : Diagnostics.Infer_parameter_types_from_usage;
|
|
case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
|
|
case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Infer_parameter_types_from_usage;
|
|
case Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code:
|
|
return Diagnostics.Infer_this_type_of_0_from_usage;
|
|
default:
|
|
return Diagnostics.Infer_type_of_0_from_usage;
|
|
}
|
|
}
|
|
function mapSuggestionDiagnostic(errorCode) {
|
|
switch (errorCode) {
|
|
case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code;
|
|
case Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Variable_0_implicitly_has_an_1_type.code;
|
|
case Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Parameter_0_implicitly_has_an_1_type.code;
|
|
case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code;
|
|
case Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code;
|
|
case Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code;
|
|
case Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code;
|
|
case Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code:
|
|
return Diagnostics.Member_0_implicitly_has_an_1_type.code;
|
|
}
|
|
return errorCode;
|
|
}
|
|
function doChange24(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) {
|
|
if (!isParameterPropertyModifier(token.kind) && token.kind !== 79 /* Identifier */ && token.kind !== 25 /* DotDotDotToken */ && token.kind !== 108 /* ThisKeyword */) {
|
|
return void 0;
|
|
}
|
|
const { parent: parent2 } = token;
|
|
const importAdder = createImportAdder(sourceFile, program, preferences, host);
|
|
errorCode = mapSuggestionDiagnostic(errorCode);
|
|
switch (errorCode) {
|
|
case Diagnostics.Member_0_implicitly_has_an_1_type.code:
|
|
case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code:
|
|
if (isVariableDeclaration(parent2) && markSeen(parent2) || isPropertyDeclaration(parent2) || isPropertySignature(parent2)) {
|
|
annotateVariableDeclaration(changes, importAdder, sourceFile, parent2, program, host, cancellationToken);
|
|
importAdder.writeFixes(changes);
|
|
return parent2;
|
|
}
|
|
if (isPropertyAccessExpression(parent2)) {
|
|
const type = inferTypeForVariableFromUsage(parent2.name, program, cancellationToken);
|
|
const typeNode = getTypeNodeIfAccessible(type, parent2, program, host);
|
|
if (typeNode) {
|
|
const typeTag = factory.createJSDocTypeTag(void 0, factory.createJSDocTypeExpression(typeNode), void 0);
|
|
changes.addJSDocTags(sourceFile, cast(parent2.parent.parent, isExpressionStatement), [typeTag]);
|
|
}
|
|
importAdder.writeFixes(changes);
|
|
return parent2;
|
|
}
|
|
return void 0;
|
|
case Diagnostics.Variable_0_implicitly_has_an_1_type.code: {
|
|
const symbol = program.getTypeChecker().getSymbolAtLocation(token);
|
|
if (symbol && symbol.valueDeclaration && isVariableDeclaration(symbol.valueDeclaration) && markSeen(symbol.valueDeclaration)) {
|
|
annotateVariableDeclaration(changes, importAdder, getSourceFileOfNode(symbol.valueDeclaration), symbol.valueDeclaration, program, host, cancellationToken);
|
|
importAdder.writeFixes(changes);
|
|
return symbol.valueDeclaration;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
const containingFunction = getContainingFunction(token);
|
|
if (containingFunction === void 0) {
|
|
return void 0;
|
|
}
|
|
let declaration;
|
|
switch (errorCode) {
|
|
case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
|
|
if (isSetAccessorDeclaration(containingFunction)) {
|
|
annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken);
|
|
declaration = containingFunction;
|
|
break;
|
|
}
|
|
case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
|
|
if (markSeen(containingFunction)) {
|
|
const param = cast(parent2, isParameter);
|
|
annotateParameters(changes, importAdder, sourceFile, param, containingFunction, program, host, cancellationToken);
|
|
declaration = param;
|
|
}
|
|
break;
|
|
case Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code:
|
|
case Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code:
|
|
if (isGetAccessorDeclaration(containingFunction) && isIdentifier(containingFunction.name)) {
|
|
annotate(changes, importAdder, sourceFile, containingFunction, inferTypeForVariableFromUsage(containingFunction.name, program, cancellationToken), program, host);
|
|
declaration = containingFunction;
|
|
}
|
|
break;
|
|
case Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code:
|
|
if (isSetAccessorDeclaration(containingFunction)) {
|
|
annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken);
|
|
declaration = containingFunction;
|
|
}
|
|
break;
|
|
case Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code:
|
|
if (ts_textChanges_exports.isThisTypeAnnotatable(containingFunction) && markSeen(containingFunction)) {
|
|
annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken);
|
|
declaration = containingFunction;
|
|
}
|
|
break;
|
|
default:
|
|
return Debug.fail(String(errorCode));
|
|
}
|
|
importAdder.writeFixes(changes);
|
|
return declaration;
|
|
}
|
|
function annotateVariableDeclaration(changes, importAdder, sourceFile, declaration, program, host, cancellationToken) {
|
|
if (isIdentifier(declaration.name)) {
|
|
annotate(changes, importAdder, sourceFile, declaration, inferTypeForVariableFromUsage(declaration.name, program, cancellationToken), program, host);
|
|
}
|
|
}
|
|
function annotateParameters(changes, importAdder, sourceFile, parameterDeclaration, containingFunction, program, host, cancellationToken) {
|
|
if (!isIdentifier(parameterDeclaration.name)) {
|
|
return;
|
|
}
|
|
const parameterInferences = inferTypeForParametersFromUsage(containingFunction, sourceFile, program, cancellationToken);
|
|
Debug.assert(containingFunction.parameters.length === parameterInferences.length, "Parameter count and inference count should match");
|
|
if (isInJSFile(containingFunction)) {
|
|
annotateJSDocParameters(changes, sourceFile, parameterInferences, program, host);
|
|
} else {
|
|
const needParens = isArrowFunction(containingFunction) && !findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile);
|
|
if (needParens)
|
|
changes.insertNodeBefore(sourceFile, first(containingFunction.parameters), factory.createToken(20 /* OpenParenToken */));
|
|
for (const { declaration, type } of parameterInferences) {
|
|
if (declaration && !declaration.type && !declaration.initializer) {
|
|
annotate(changes, importAdder, sourceFile, declaration, type, program, host);
|
|
}
|
|
}
|
|
if (needParens)
|
|
changes.insertNodeAfter(sourceFile, last(containingFunction.parameters), factory.createToken(21 /* CloseParenToken */));
|
|
}
|
|
}
|
|
function annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken) {
|
|
const references = getFunctionReferences(containingFunction, sourceFile, program, cancellationToken);
|
|
if (!references || !references.length) {
|
|
return;
|
|
}
|
|
const thisInference = inferTypeFromReferences(program, references, cancellationToken).thisParameter();
|
|
const typeNode = getTypeNodeIfAccessible(thisInference, containingFunction, program, host);
|
|
if (!typeNode) {
|
|
return;
|
|
}
|
|
if (isInJSFile(containingFunction)) {
|
|
annotateJSDocThis(changes, sourceFile, containingFunction, typeNode);
|
|
} else {
|
|
changes.tryInsertThisTypeAnnotation(sourceFile, containingFunction, typeNode);
|
|
}
|
|
}
|
|
function annotateJSDocThis(changes, sourceFile, containingFunction, typeNode) {
|
|
changes.addJSDocTags(sourceFile, containingFunction, [
|
|
factory.createJSDocThisTag(void 0, factory.createJSDocTypeExpression(typeNode))
|
|
]);
|
|
}
|
|
function annotateSetAccessor(changes, importAdder, sourceFile, setAccessorDeclaration, program, host, cancellationToken) {
|
|
const param = firstOrUndefined(setAccessorDeclaration.parameters);
|
|
if (param && isIdentifier(setAccessorDeclaration.name) && isIdentifier(param.name)) {
|
|
let type = inferTypeForVariableFromUsage(setAccessorDeclaration.name, program, cancellationToken);
|
|
if (type === program.getTypeChecker().getAnyType()) {
|
|
type = inferTypeForVariableFromUsage(param.name, program, cancellationToken);
|
|
}
|
|
if (isInJSFile(setAccessorDeclaration)) {
|
|
annotateJSDocParameters(changes, sourceFile, [{ declaration: param, type }], program, host);
|
|
} else {
|
|
annotate(changes, importAdder, sourceFile, param, type, program, host);
|
|
}
|
|
}
|
|
}
|
|
function annotate(changes, importAdder, sourceFile, declaration, type, program, host) {
|
|
const typeNode = getTypeNodeIfAccessible(type, declaration, program, host);
|
|
if (typeNode) {
|
|
if (isInJSFile(sourceFile) && declaration.kind !== 168 /* PropertySignature */) {
|
|
const parent2 = isVariableDeclaration(declaration) ? tryCast(declaration.parent.parent, isVariableStatement) : declaration;
|
|
if (!parent2) {
|
|
return;
|
|
}
|
|
const typeExpression = factory.createJSDocTypeExpression(typeNode);
|
|
const typeTag = isGetAccessorDeclaration(declaration) ? factory.createJSDocReturnTag(void 0, typeExpression, void 0) : factory.createJSDocTypeTag(void 0, typeExpression, void 0);
|
|
changes.addJSDocTags(sourceFile, parent2, [typeTag]);
|
|
} else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, getEmitScriptTarget(program.getCompilerOptions()))) {
|
|
changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode);
|
|
}
|
|
}
|
|
}
|
|
function tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, scriptTarget) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
|
|
if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeNode)) {
|
|
forEach(importableReference.symbols, (s) => importAdder.addImportFromExportedSymbol(s, true));
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function annotateJSDocParameters(changes, sourceFile, parameterInferences, program, host) {
|
|
const signature = parameterInferences.length && parameterInferences[0].declaration.parent;
|
|
if (!signature) {
|
|
return;
|
|
}
|
|
const inferences = mapDefined(parameterInferences, (inference) => {
|
|
const param = inference.declaration;
|
|
if (param.initializer || getJSDocType(param) || !isIdentifier(param.name)) {
|
|
return;
|
|
}
|
|
const typeNode = inference.type && getTypeNodeIfAccessible(inference.type, param, program, host);
|
|
if (typeNode) {
|
|
const name = factory.cloneNode(param.name);
|
|
setEmitFlags(name, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
|
|
return { name: factory.cloneNode(param.name), param, isOptional: !!inference.isOptional, typeNode };
|
|
}
|
|
});
|
|
if (!inferences.length) {
|
|
return;
|
|
}
|
|
if (isArrowFunction(signature) || isFunctionExpression(signature)) {
|
|
const needParens = isArrowFunction(signature) && !findChildOfKind(signature, 20 /* OpenParenToken */, sourceFile);
|
|
if (needParens) {
|
|
changes.insertNodeBefore(sourceFile, first(signature.parameters), factory.createToken(20 /* OpenParenToken */));
|
|
}
|
|
forEach(inferences, ({ typeNode, param }) => {
|
|
const typeTag = factory.createJSDocTypeTag(void 0, factory.createJSDocTypeExpression(typeNode));
|
|
const jsDoc = factory.createJSDocComment(void 0, [typeTag]);
|
|
changes.insertNodeAt(sourceFile, param.getStart(sourceFile), jsDoc, { suffix: " " });
|
|
});
|
|
if (needParens) {
|
|
changes.insertNodeAfter(sourceFile, last(signature.parameters), factory.createToken(21 /* CloseParenToken */));
|
|
}
|
|
} else {
|
|
const paramTags = map(inferences, ({ name, typeNode, isOptional }) => factory.createJSDocParameterTag(void 0, name, !!isOptional, factory.createJSDocTypeExpression(typeNode), false, void 0));
|
|
changes.addJSDocTags(sourceFile, signature, paramTags);
|
|
}
|
|
}
|
|
function getReferences(token, program, cancellationToken) {
|
|
return mapDefined(ts_FindAllReferences_exports.getReferenceEntriesForNode(-1, token, program, program.getSourceFiles(), cancellationToken), (entry) => entry.kind !== ts_FindAllReferences_exports.EntryKind.Span ? tryCast(entry.node, isIdentifier) : void 0);
|
|
}
|
|
function inferTypeForVariableFromUsage(token, program, cancellationToken) {
|
|
const references = getReferences(token, program, cancellationToken);
|
|
return inferTypeFromReferences(program, references, cancellationToken).single();
|
|
}
|
|
function inferTypeForParametersFromUsage(func, sourceFile, program, cancellationToken) {
|
|
const references = getFunctionReferences(func, sourceFile, program, cancellationToken);
|
|
return references && inferTypeFromReferences(program, references, cancellationToken).parameters(func) || func.parameters.map((p) => ({
|
|
declaration: p,
|
|
type: isIdentifier(p.name) ? inferTypeForVariableFromUsage(p.name, program, cancellationToken) : program.getTypeChecker().getAnyType()
|
|
}));
|
|
}
|
|
function getFunctionReferences(containingFunction, sourceFile, program, cancellationToken) {
|
|
let searchToken;
|
|
switch (containingFunction.kind) {
|
|
case 173 /* Constructor */:
|
|
searchToken = findChildOfKind(containingFunction, 135 /* ConstructorKeyword */, sourceFile);
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
const parent2 = containingFunction.parent;
|
|
searchToken = (isVariableDeclaration(parent2) || isPropertyDeclaration(parent2)) && isIdentifier(parent2.name) ? parent2.name : containingFunction.name;
|
|
break;
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
searchToken = containingFunction.name;
|
|
break;
|
|
}
|
|
if (!searchToken) {
|
|
return void 0;
|
|
}
|
|
return getReferences(searchToken, program, cancellationToken);
|
|
}
|
|
function inferTypeFromReferences(program, references, cancellationToken) {
|
|
const checker = program.getTypeChecker();
|
|
const builtinConstructors = {
|
|
string: () => checker.getStringType(),
|
|
number: () => checker.getNumberType(),
|
|
Array: (t) => checker.createArrayType(t),
|
|
Promise: (t) => checker.createPromiseType(t)
|
|
};
|
|
const builtins = [
|
|
checker.getStringType(),
|
|
checker.getNumberType(),
|
|
checker.createArrayType(checker.getAnyType()),
|
|
checker.createPromiseType(checker.getAnyType())
|
|
];
|
|
return {
|
|
single: single2,
|
|
parameters,
|
|
thisParameter
|
|
};
|
|
function createEmptyUsage() {
|
|
return {
|
|
isNumber: void 0,
|
|
isString: void 0,
|
|
isNumberOrString: void 0,
|
|
candidateTypes: void 0,
|
|
properties: void 0,
|
|
calls: void 0,
|
|
constructs: void 0,
|
|
numberIndex: void 0,
|
|
stringIndex: void 0,
|
|
candidateThisTypes: void 0,
|
|
inferredTypes: void 0
|
|
};
|
|
}
|
|
function combineUsages(usages) {
|
|
const combinedProperties = /* @__PURE__ */ new Map();
|
|
for (const u of usages) {
|
|
if (u.properties) {
|
|
u.properties.forEach((p, name) => {
|
|
if (!combinedProperties.has(name)) {
|
|
combinedProperties.set(name, []);
|
|
}
|
|
combinedProperties.get(name).push(p);
|
|
});
|
|
}
|
|
}
|
|
const properties = /* @__PURE__ */ new Map();
|
|
combinedProperties.forEach((ps, name) => {
|
|
properties.set(name, combineUsages(ps));
|
|
});
|
|
return {
|
|
isNumber: usages.some((u) => u.isNumber),
|
|
isString: usages.some((u) => u.isString),
|
|
isNumberOrString: usages.some((u) => u.isNumberOrString),
|
|
candidateTypes: flatMap(usages, (u) => u.candidateTypes),
|
|
properties,
|
|
calls: flatMap(usages, (u) => u.calls),
|
|
constructs: flatMap(usages, (u) => u.constructs),
|
|
numberIndex: forEach(usages, (u) => u.numberIndex),
|
|
stringIndex: forEach(usages, (u) => u.stringIndex),
|
|
candidateThisTypes: flatMap(usages, (u) => u.candidateThisTypes),
|
|
inferredTypes: void 0
|
|
};
|
|
}
|
|
function single2() {
|
|
return combineTypes(inferTypesFromReferencesSingle(references));
|
|
}
|
|
function parameters(declaration) {
|
|
if (references.length === 0 || !declaration.parameters) {
|
|
return void 0;
|
|
}
|
|
const usage = createEmptyUsage();
|
|
for (const reference of references) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
calculateUsageOfNode(reference, usage);
|
|
}
|
|
const calls = [...usage.constructs || [], ...usage.calls || []];
|
|
return declaration.parameters.map((parameter, parameterIndex) => {
|
|
const types = [];
|
|
const isRest = isRestParameter(parameter);
|
|
let isOptional = false;
|
|
for (const call of calls) {
|
|
if (call.argumentTypes.length <= parameterIndex) {
|
|
isOptional = isInJSFile(declaration);
|
|
types.push(checker.getUndefinedType());
|
|
} else if (isRest) {
|
|
for (let i = parameterIndex; i < call.argumentTypes.length; i++) {
|
|
types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[i]));
|
|
}
|
|
} else {
|
|
types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[parameterIndex]));
|
|
}
|
|
}
|
|
if (isIdentifier(parameter.name)) {
|
|
const inferred = inferTypesFromReferencesSingle(getReferences(parameter.name, program, cancellationToken));
|
|
types.push(...isRest ? mapDefined(inferred, checker.getElementTypeOfArrayType) : inferred);
|
|
}
|
|
const type = combineTypes(types);
|
|
return {
|
|
type: isRest ? checker.createArrayType(type) : type,
|
|
isOptional: isOptional && !isRest,
|
|
declaration: parameter
|
|
};
|
|
});
|
|
}
|
|
function thisParameter() {
|
|
const usage = createEmptyUsage();
|
|
for (const reference of references) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
calculateUsageOfNode(reference, usage);
|
|
}
|
|
return combineTypes(usage.candidateThisTypes || emptyArray);
|
|
}
|
|
function inferTypesFromReferencesSingle(references2) {
|
|
const usage = createEmptyUsage();
|
|
for (const reference of references2) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
calculateUsageOfNode(reference, usage);
|
|
}
|
|
return inferTypes(usage);
|
|
}
|
|
function calculateUsageOfNode(node, usage) {
|
|
while (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
|
|
node = node.parent;
|
|
}
|
|
switch (node.parent.kind) {
|
|
case 241 /* ExpressionStatement */:
|
|
inferTypeFromExpressionStatement(node, usage);
|
|
break;
|
|
case 222 /* PostfixUnaryExpression */:
|
|
usage.isNumber = true;
|
|
break;
|
|
case 221 /* PrefixUnaryExpression */:
|
|
inferTypeFromPrefixUnaryExpression(node.parent, usage);
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
inferTypeFromBinaryExpression(node, node.parent, usage);
|
|
break;
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
inferTypeFromSwitchStatementLabel(node.parent, usage);
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
if (node.parent.expression === node) {
|
|
inferTypeFromCallExpression(node.parent, usage);
|
|
} else {
|
|
inferTypeFromContextualType(node, usage);
|
|
}
|
|
break;
|
|
case 208 /* PropertyAccessExpression */:
|
|
inferTypeFromPropertyAccessExpression(node.parent, usage);
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
inferTypeFromPropertyElementExpression(node.parent, node, usage);
|
|
break;
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
inferTypeFromPropertyAssignment(node.parent, usage);
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
inferTypeFromPropertyDeclaration(node.parent, usage);
|
|
break;
|
|
case 257 /* VariableDeclaration */: {
|
|
const { name, initializer } = node.parent;
|
|
if (node === name) {
|
|
if (initializer) {
|
|
addCandidateType(usage, checker.getTypeAtLocation(initializer));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
default:
|
|
return inferTypeFromContextualType(node, usage);
|
|
}
|
|
}
|
|
function inferTypeFromContextualType(node, usage) {
|
|
if (isExpressionNode(node)) {
|
|
addCandidateType(usage, checker.getContextualType(node));
|
|
}
|
|
}
|
|
function inferTypeFromExpressionStatement(node, usage) {
|
|
addCandidateType(usage, isCallExpression(node) ? checker.getVoidType() : checker.getAnyType());
|
|
}
|
|
function inferTypeFromPrefixUnaryExpression(node, usage) {
|
|
switch (node.operator) {
|
|
case 45 /* PlusPlusToken */:
|
|
case 46 /* MinusMinusToken */:
|
|
case 40 /* MinusToken */:
|
|
case 54 /* TildeToken */:
|
|
usage.isNumber = true;
|
|
break;
|
|
case 39 /* PlusToken */:
|
|
usage.isNumberOrString = true;
|
|
break;
|
|
}
|
|
}
|
|
function inferTypeFromBinaryExpression(node, parent2, usage) {
|
|
switch (parent2.operatorToken.kind) {
|
|
case 42 /* AsteriskAsteriskToken */:
|
|
case 41 /* AsteriskToken */:
|
|
case 43 /* SlashToken */:
|
|
case 44 /* PercentToken */:
|
|
case 47 /* LessThanLessThanToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 50 /* AmpersandToken */:
|
|
case 51 /* BarToken */:
|
|
case 52 /* CaretToken */:
|
|
case 65 /* MinusEqualsToken */:
|
|
case 67 /* AsteriskAsteriskEqualsToken */:
|
|
case 66 /* AsteriskEqualsToken */:
|
|
case 68 /* SlashEqualsToken */:
|
|
case 69 /* PercentEqualsToken */:
|
|
case 73 /* AmpersandEqualsToken */:
|
|
case 74 /* BarEqualsToken */:
|
|
case 78 /* CaretEqualsToken */:
|
|
case 70 /* LessThanLessThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 40 /* MinusToken */:
|
|
case 29 /* LessThanToken */:
|
|
case 32 /* LessThanEqualsToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
const operandType = checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left);
|
|
if (operandType.flags & 1056 /* EnumLike */) {
|
|
addCandidateType(usage, operandType);
|
|
} else {
|
|
usage.isNumber = true;
|
|
}
|
|
break;
|
|
case 64 /* PlusEqualsToken */:
|
|
case 39 /* PlusToken */:
|
|
const otherOperandType = checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left);
|
|
if (otherOperandType.flags & 1056 /* EnumLike */) {
|
|
addCandidateType(usage, otherOperandType);
|
|
} else if (otherOperandType.flags & 296 /* NumberLike */) {
|
|
usage.isNumber = true;
|
|
} else if (otherOperandType.flags & 402653316 /* StringLike */) {
|
|
usage.isString = true;
|
|
} else if (otherOperandType.flags & 1 /* Any */) {
|
|
} else {
|
|
usage.isNumberOrString = true;
|
|
}
|
|
break;
|
|
case 63 /* EqualsToken */:
|
|
case 34 /* EqualsEqualsToken */:
|
|
case 36 /* EqualsEqualsEqualsToken */:
|
|
case 37 /* ExclamationEqualsEqualsToken */:
|
|
case 35 /* ExclamationEqualsToken */:
|
|
addCandidateType(usage, checker.getTypeAtLocation(parent2.left === node ? parent2.right : parent2.left));
|
|
break;
|
|
case 101 /* InKeyword */:
|
|
if (node === parent2.left) {
|
|
usage.isString = true;
|
|
}
|
|
break;
|
|
case 56 /* BarBarToken */:
|
|
case 60 /* QuestionQuestionToken */:
|
|
if (node === parent2.left && (node.parent.parent.kind === 257 /* VariableDeclaration */ || isAssignmentExpression(node.parent.parent, true))) {
|
|
addCandidateType(usage, checker.getTypeAtLocation(parent2.right));
|
|
}
|
|
break;
|
|
case 55 /* AmpersandAmpersandToken */:
|
|
case 27 /* CommaToken */:
|
|
case 102 /* InstanceOfKeyword */:
|
|
break;
|
|
}
|
|
}
|
|
function inferTypeFromSwitchStatementLabel(parent2, usage) {
|
|
addCandidateType(usage, checker.getTypeAtLocation(parent2.parent.parent.expression));
|
|
}
|
|
function inferTypeFromCallExpression(parent2, usage) {
|
|
const call = {
|
|
argumentTypes: [],
|
|
return_: createEmptyUsage()
|
|
};
|
|
if (parent2.arguments) {
|
|
for (const argument of parent2.arguments) {
|
|
call.argumentTypes.push(checker.getTypeAtLocation(argument));
|
|
}
|
|
}
|
|
calculateUsageOfNode(parent2, call.return_);
|
|
if (parent2.kind === 210 /* CallExpression */) {
|
|
(usage.calls || (usage.calls = [])).push(call);
|
|
} else {
|
|
(usage.constructs || (usage.constructs = [])).push(call);
|
|
}
|
|
}
|
|
function inferTypeFromPropertyAccessExpression(parent2, usage) {
|
|
const name = escapeLeadingUnderscores(parent2.name.text);
|
|
if (!usage.properties) {
|
|
usage.properties = /* @__PURE__ */ new Map();
|
|
}
|
|
const propertyUsage = usage.properties.get(name) || createEmptyUsage();
|
|
calculateUsageOfNode(parent2, propertyUsage);
|
|
usage.properties.set(name, propertyUsage);
|
|
}
|
|
function inferTypeFromPropertyElementExpression(parent2, node, usage) {
|
|
if (node === parent2.argumentExpression) {
|
|
usage.isNumberOrString = true;
|
|
return;
|
|
} else {
|
|
const indexType = checker.getTypeAtLocation(parent2.argumentExpression);
|
|
const indexUsage = createEmptyUsage();
|
|
calculateUsageOfNode(parent2, indexUsage);
|
|
if (indexType.flags & 296 /* NumberLike */) {
|
|
usage.numberIndex = indexUsage;
|
|
} else {
|
|
usage.stringIndex = indexUsage;
|
|
}
|
|
}
|
|
}
|
|
function inferTypeFromPropertyAssignment(assignment, usage) {
|
|
const nodeWithRealType = isVariableDeclaration(assignment.parent.parent) ? assignment.parent.parent : assignment.parent;
|
|
addCandidateThisType(usage, checker.getTypeAtLocation(nodeWithRealType));
|
|
}
|
|
function inferTypeFromPropertyDeclaration(declaration, usage) {
|
|
addCandidateThisType(usage, checker.getTypeAtLocation(declaration.parent));
|
|
}
|
|
function removeLowPriorityInferences(inferences, priorities) {
|
|
const toRemove = [];
|
|
for (const i of inferences) {
|
|
for (const { high, low } of priorities) {
|
|
if (high(i)) {
|
|
Debug.assert(!low(i), "Priority can't have both low and high");
|
|
toRemove.push(low);
|
|
}
|
|
}
|
|
}
|
|
return inferences.filter((i) => toRemove.every((f) => !f(i)));
|
|
}
|
|
function combineFromUsage(usage) {
|
|
return combineTypes(inferTypes(usage));
|
|
}
|
|
function combineTypes(inferences) {
|
|
if (!inferences.length)
|
|
return checker.getAnyType();
|
|
const stringNumber = checker.getUnionType([checker.getStringType(), checker.getNumberType()]);
|
|
const priorities = [
|
|
{
|
|
high: (t) => t === checker.getStringType() || t === checker.getNumberType(),
|
|
low: (t) => t === stringNumber
|
|
},
|
|
{
|
|
high: (t) => !(t.flags & (1 /* Any */ | 16384 /* Void */)),
|
|
low: (t) => !!(t.flags & (1 /* Any */ | 16384 /* Void */))
|
|
},
|
|
{
|
|
high: (t) => !(t.flags & (98304 /* Nullable */ | 1 /* Any */ | 16384 /* Void */)) && !(getObjectFlags(t) & 16 /* Anonymous */),
|
|
low: (t) => !!(getObjectFlags(t) & 16 /* Anonymous */)
|
|
}
|
|
];
|
|
let good = removeLowPriorityInferences(inferences, priorities);
|
|
const anons = good.filter((i) => getObjectFlags(i) & 16 /* Anonymous */);
|
|
if (anons.length) {
|
|
good = good.filter((i) => !(getObjectFlags(i) & 16 /* Anonymous */));
|
|
good.push(combineAnonymousTypes(anons));
|
|
}
|
|
return checker.getWidenedType(checker.getUnionType(good.map(checker.getBaseTypeOfLiteralType), 2 /* Subtype */));
|
|
}
|
|
function combineAnonymousTypes(anons) {
|
|
if (anons.length === 1) {
|
|
return anons[0];
|
|
}
|
|
const calls = [];
|
|
const constructs = [];
|
|
const stringIndices = [];
|
|
const numberIndices = [];
|
|
let stringIndexReadonly = false;
|
|
let numberIndexReadonly = false;
|
|
const props = createMultiMap();
|
|
for (const anon2 of anons) {
|
|
for (const p of checker.getPropertiesOfType(anon2)) {
|
|
props.add(p.name, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType());
|
|
}
|
|
calls.push(...checker.getSignaturesOfType(anon2, 0 /* Call */));
|
|
constructs.push(...checker.getSignaturesOfType(anon2, 1 /* Construct */));
|
|
const stringIndexInfo = checker.getIndexInfoOfType(anon2, 0 /* String */);
|
|
if (stringIndexInfo) {
|
|
stringIndices.push(stringIndexInfo.type);
|
|
stringIndexReadonly = stringIndexReadonly || stringIndexInfo.isReadonly;
|
|
}
|
|
const numberIndexInfo = checker.getIndexInfoOfType(anon2, 1 /* Number */);
|
|
if (numberIndexInfo) {
|
|
numberIndices.push(numberIndexInfo.type);
|
|
numberIndexReadonly = numberIndexReadonly || numberIndexInfo.isReadonly;
|
|
}
|
|
}
|
|
const members = mapEntries(props, (name, types) => {
|
|
const isOptional = types.length < anons.length ? 16777216 /* Optional */ : 0;
|
|
const s = checker.createSymbol(4 /* Property */ | isOptional, name);
|
|
s.type = checker.getUnionType(types);
|
|
return [name, s];
|
|
});
|
|
const indexInfos = [];
|
|
if (stringIndices.length)
|
|
indexInfos.push(checker.createIndexInfo(checker.getStringType(), checker.getUnionType(stringIndices), stringIndexReadonly));
|
|
if (numberIndices.length)
|
|
indexInfos.push(checker.createIndexInfo(checker.getNumberType(), checker.getUnionType(numberIndices), numberIndexReadonly));
|
|
return checker.createAnonymousType(
|
|
anons[0].symbol,
|
|
members,
|
|
calls,
|
|
constructs,
|
|
indexInfos
|
|
);
|
|
}
|
|
function inferTypes(usage) {
|
|
var _a2, _b, _c;
|
|
const types = [];
|
|
if (usage.isNumber) {
|
|
types.push(checker.getNumberType());
|
|
}
|
|
if (usage.isString) {
|
|
types.push(checker.getStringType());
|
|
}
|
|
if (usage.isNumberOrString) {
|
|
types.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()]));
|
|
}
|
|
if (usage.numberIndex) {
|
|
types.push(checker.createArrayType(combineFromUsage(usage.numberIndex)));
|
|
}
|
|
if (((_a2 = usage.properties) == null ? void 0 : _a2.size) || ((_b = usage.constructs) == null ? void 0 : _b.length) || usage.stringIndex) {
|
|
types.push(inferStructuralType(usage));
|
|
}
|
|
const candidateTypes = (usage.candidateTypes || []).map((t) => checker.getBaseTypeOfLiteralType(t));
|
|
const callsType = ((_c = usage.calls) == null ? void 0 : _c.length) ? inferStructuralType(usage) : void 0;
|
|
if (callsType && candidateTypes) {
|
|
types.push(checker.getUnionType([callsType, ...candidateTypes], 2 /* Subtype */));
|
|
} else {
|
|
if (callsType) {
|
|
types.push(callsType);
|
|
}
|
|
if (length(candidateTypes)) {
|
|
types.push(...candidateTypes);
|
|
}
|
|
}
|
|
types.push(...inferNamedTypesFromProperties(usage));
|
|
return types;
|
|
}
|
|
function inferStructuralType(usage) {
|
|
const members = /* @__PURE__ */ new Map();
|
|
if (usage.properties) {
|
|
usage.properties.forEach((u, name) => {
|
|
const symbol = checker.createSymbol(4 /* Property */, name);
|
|
symbol.type = combineFromUsage(u);
|
|
members.set(name, symbol);
|
|
});
|
|
}
|
|
const callSignatures = usage.calls ? [getSignatureFromCalls(usage.calls)] : [];
|
|
const constructSignatures = usage.constructs ? [getSignatureFromCalls(usage.constructs)] : [];
|
|
const indexInfos = usage.stringIndex ? [checker.createIndexInfo(checker.getStringType(), combineFromUsage(usage.stringIndex), false)] : [];
|
|
return checker.createAnonymousType(void 0, members, callSignatures, constructSignatures, indexInfos);
|
|
}
|
|
function inferNamedTypesFromProperties(usage) {
|
|
if (!usage.properties || !usage.properties.size)
|
|
return [];
|
|
const types = builtins.filter((t) => allPropertiesAreAssignableToUsage(t, usage));
|
|
if (0 < types.length && types.length < 3) {
|
|
return types.map((t) => inferInstantiationFromUsage(t, usage));
|
|
}
|
|
return [];
|
|
}
|
|
function allPropertiesAreAssignableToUsage(type, usage) {
|
|
if (!usage.properties)
|
|
return false;
|
|
return !forEachEntry(usage.properties, (propUsage, name) => {
|
|
const source = checker.getTypeOfPropertyOfType(type, name);
|
|
if (!source) {
|
|
return true;
|
|
}
|
|
if (propUsage.calls) {
|
|
const sigs = checker.getSignaturesOfType(source, 0 /* Call */);
|
|
return !sigs.length || !checker.isTypeAssignableTo(source, getFunctionFromCalls(propUsage.calls));
|
|
} else {
|
|
return !checker.isTypeAssignableTo(source, combineFromUsage(propUsage));
|
|
}
|
|
});
|
|
}
|
|
function inferInstantiationFromUsage(type, usage) {
|
|
if (!(getObjectFlags(type) & 4 /* Reference */) || !usage.properties) {
|
|
return type;
|
|
}
|
|
const generic = type.target;
|
|
const singleTypeParameter = singleOrUndefined(generic.typeParameters);
|
|
if (!singleTypeParameter)
|
|
return type;
|
|
const types = [];
|
|
usage.properties.forEach((propUsage, name) => {
|
|
const genericPropertyType = checker.getTypeOfPropertyOfType(generic, name);
|
|
Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference.");
|
|
types.push(...inferTypeParameters(genericPropertyType, combineFromUsage(propUsage), singleTypeParameter));
|
|
});
|
|
return builtinConstructors[type.symbol.escapedName](combineTypes(types));
|
|
}
|
|
function inferTypeParameters(genericType, usageType, typeParameter) {
|
|
if (genericType === typeParameter) {
|
|
return [usageType];
|
|
} else if (genericType.flags & 3145728 /* UnionOrIntersection */) {
|
|
return flatMap(genericType.types, (t) => inferTypeParameters(t, usageType, typeParameter));
|
|
} else if (getObjectFlags(genericType) & 4 /* Reference */ && getObjectFlags(usageType) & 4 /* Reference */) {
|
|
const genericArgs = checker.getTypeArguments(genericType);
|
|
const usageArgs = checker.getTypeArguments(usageType);
|
|
const types = [];
|
|
if (genericArgs && usageArgs) {
|
|
for (let i = 0; i < genericArgs.length; i++) {
|
|
if (usageArgs[i]) {
|
|
types.push(...inferTypeParameters(genericArgs[i], usageArgs[i], typeParameter));
|
|
}
|
|
}
|
|
}
|
|
return types;
|
|
}
|
|
const genericSigs = checker.getSignaturesOfType(genericType, 0 /* Call */);
|
|
const usageSigs = checker.getSignaturesOfType(usageType, 0 /* Call */);
|
|
if (genericSigs.length === 1 && usageSigs.length === 1) {
|
|
return inferFromSignatures(genericSigs[0], usageSigs[0], typeParameter);
|
|
}
|
|
return [];
|
|
}
|
|
function inferFromSignatures(genericSig, usageSig, typeParameter) {
|
|
const types = [];
|
|
for (let i = 0; i < genericSig.parameters.length; i++) {
|
|
const genericParam = genericSig.parameters[i];
|
|
const usageParam = usageSig.parameters[i];
|
|
const isRest = genericSig.declaration && isRestParameter(genericSig.declaration.parameters[i]);
|
|
if (!usageParam) {
|
|
break;
|
|
}
|
|
let genericParamType = genericParam.valueDeclaration ? checker.getTypeOfSymbolAtLocation(genericParam, genericParam.valueDeclaration) : checker.getAnyType();
|
|
const elementType = isRest && checker.getElementTypeOfArrayType(genericParamType);
|
|
if (elementType) {
|
|
genericParamType = elementType;
|
|
}
|
|
const targetType = usageParam.type || (usageParam.valueDeclaration ? checker.getTypeOfSymbolAtLocation(usageParam, usageParam.valueDeclaration) : checker.getAnyType());
|
|
types.push(...inferTypeParameters(genericParamType, targetType, typeParameter));
|
|
}
|
|
const genericReturn = checker.getReturnTypeOfSignature(genericSig);
|
|
const usageReturn = checker.getReturnTypeOfSignature(usageSig);
|
|
types.push(...inferTypeParameters(genericReturn, usageReturn, typeParameter));
|
|
return types;
|
|
}
|
|
function getFunctionFromCalls(calls) {
|
|
return checker.createAnonymousType(void 0, createSymbolTable(), [getSignatureFromCalls(calls)], emptyArray, emptyArray);
|
|
}
|
|
function getSignatureFromCalls(calls) {
|
|
const parameters2 = [];
|
|
const length2 = Math.max(...calls.map((c) => c.argumentTypes.length));
|
|
for (let i = 0; i < length2; i++) {
|
|
const symbol = checker.createSymbol(1 /* FunctionScopedVariable */, escapeLeadingUnderscores(`arg${i}`));
|
|
symbol.type = combineTypes(calls.map((call) => call.argumentTypes[i] || checker.getUndefinedType()));
|
|
if (calls.some((call) => call.argumentTypes[i] === void 0)) {
|
|
symbol.flags |= 16777216 /* Optional */;
|
|
}
|
|
parameters2.push(symbol);
|
|
}
|
|
const returnType = combineFromUsage(combineUsages(calls.map((call) => call.return_)));
|
|
return checker.createSignature(void 0, void 0, void 0, parameters2, returnType, void 0, length2, 0 /* None */);
|
|
}
|
|
function addCandidateType(usage, type) {
|
|
if (type && !(type.flags & 1 /* Any */) && !(type.flags & 131072 /* Never */)) {
|
|
(usage.candidateTypes || (usage.candidateTypes = [])).push(type);
|
|
}
|
|
}
|
|
function addCandidateThisType(usage, type) {
|
|
if (type && !(type.flags & 1 /* Any */) && !(type.flags & 131072 /* Never */)) {
|
|
(usage.candidateThisTypes || (usage.candidateThisTypes = [])).push(type);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/fixReturnTypeInAsyncFunction.ts
|
|
var fixId39 = "fixReturnTypeInAsyncFunction";
|
|
var errorCodes49 = [
|
|
Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes49,
|
|
fixIds: [fixId39],
|
|
getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) {
|
|
const { sourceFile, program, span } = context;
|
|
const checker = program.getTypeChecker();
|
|
const info = getInfo12(sourceFile, program.getTypeChecker(), span.start);
|
|
if (!info) {
|
|
return void 0;
|
|
}
|
|
const { returnTypeNode, returnType, promisedTypeNode, promisedType } = info;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange25(t, sourceFile, returnTypeNode, promisedTypeNode));
|
|
return [createCodeFixAction(
|
|
fixId39,
|
|
changes,
|
|
[
|
|
Diagnostics.Replace_0_with_Promise_1,
|
|
checker.typeToString(returnType),
|
|
checker.typeToString(promisedType)
|
|
],
|
|
fixId39,
|
|
Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions
|
|
)];
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes49, (changes, diag2) => {
|
|
const info = getInfo12(diag2.file, context.program.getTypeChecker(), diag2.start);
|
|
if (info) {
|
|
doChange25(changes, diag2.file, info.returnTypeNode, info.promisedTypeNode);
|
|
}
|
|
})
|
|
});
|
|
function getInfo12(sourceFile, checker, pos) {
|
|
if (isInJSFile(sourceFile)) {
|
|
return void 0;
|
|
}
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const func = findAncestor(token, isFunctionLikeDeclaration);
|
|
const returnTypeNode = func == null ? void 0 : func.type;
|
|
if (!returnTypeNode) {
|
|
return void 0;
|
|
}
|
|
const returnType = checker.getTypeFromTypeNode(returnTypeNode);
|
|
const promisedType = checker.getAwaitedType(returnType) || checker.getVoidType();
|
|
const promisedTypeNode = checker.typeToTypeNode(promisedType, returnTypeNode, void 0);
|
|
if (promisedTypeNode) {
|
|
return { returnTypeNode, returnType, promisedTypeNode, promisedType };
|
|
}
|
|
}
|
|
function doChange25(changes, sourceFile, returnTypeNode, promisedTypeNode) {
|
|
changes.replaceNode(sourceFile, returnTypeNode, factory.createTypeReferenceNode("Promise", [promisedTypeNode]));
|
|
}
|
|
|
|
// src/services/codefixes/disableJsDiagnostics.ts
|
|
var fixName4 = "disableJsDiagnostics";
|
|
var fixId40 = "disableJsDiagnostics";
|
|
var errorCodes50 = mapDefined(Object.keys(Diagnostics), (key) => {
|
|
const diag2 = Diagnostics[key];
|
|
return diag2.category === 1 /* Error */ ? diag2.code : void 0;
|
|
});
|
|
registerCodeFix({
|
|
errorCodes: errorCodes50,
|
|
getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) {
|
|
const { sourceFile, program, span, host, formatContext } = context;
|
|
if (!isInJSFile(sourceFile) || !isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) {
|
|
return void 0;
|
|
}
|
|
const newLineCharacter = sourceFile.checkJsDirective ? "" : getNewLineOrDefaultFromHost(host, formatContext.options);
|
|
const fixes = [
|
|
createCodeFixActionWithoutFixAll(
|
|
fixName4,
|
|
[createFileTextChanges(sourceFile.fileName, [
|
|
createTextChange(sourceFile.checkJsDirective ? createTextSpanFromBounds(sourceFile.checkJsDirective.pos, sourceFile.checkJsDirective.end) : createTextSpan(0, 0), `// @ts-nocheck${newLineCharacter}`)
|
|
])],
|
|
Diagnostics.Disable_checking_for_this_file
|
|
)
|
|
];
|
|
if (ts_textChanges_exports.isValidLocationToAddComment(sourceFile, span.start)) {
|
|
fixes.unshift(createCodeFixAction(fixName4, ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange8(t, sourceFile, span.start)), Diagnostics.Ignore_this_error_message, fixId40, Diagnostics.Add_ts_ignore_to_all_error_messages));
|
|
}
|
|
return fixes;
|
|
},
|
|
fixIds: [fixId40],
|
|
getAllCodeActions: (context) => {
|
|
const seenLines = /* @__PURE__ */ new Set();
|
|
return codeFixAll(context, errorCodes50, (changes, diag2) => {
|
|
if (ts_textChanges_exports.isValidLocationToAddComment(diag2.file, diag2.start)) {
|
|
makeChange8(changes, diag2.file, diag2.start, seenLines);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function makeChange8(changes, sourceFile, position, seenLines) {
|
|
const { line: lineNumber } = getLineAndCharacterOfPosition(sourceFile, position);
|
|
if (!seenLines || tryAddToSet(seenLines, lineNumber)) {
|
|
changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore");
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/helpers.ts
|
|
function createMissingMemberNodes(classDeclaration, possiblyMissingSymbols, sourceFile, context, preferences, importAdder, addClassElement) {
|
|
const classMembers = classDeclaration.symbol.members;
|
|
for (const symbol of possiblyMissingSymbols) {
|
|
if (!classMembers.has(symbol.escapedName)) {
|
|
addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement, void 0);
|
|
}
|
|
}
|
|
}
|
|
function getNoopSymbolTrackerWithResolver(context) {
|
|
return {
|
|
trackSymbol: () => false,
|
|
moduleResolverHost: getModuleSpecifierResolverHost(context.program, context.host)
|
|
};
|
|
}
|
|
var PreserveOptionalFlags = /* @__PURE__ */ ((PreserveOptionalFlags2) => {
|
|
PreserveOptionalFlags2[PreserveOptionalFlags2["Method"] = 1] = "Method";
|
|
PreserveOptionalFlags2[PreserveOptionalFlags2["Property"] = 2] = "Property";
|
|
PreserveOptionalFlags2[PreserveOptionalFlags2["All"] = 3] = "All";
|
|
return PreserveOptionalFlags2;
|
|
})(PreserveOptionalFlags || {});
|
|
function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional = 3 /* All */, isAmbient = false) {
|
|
var _a2;
|
|
const declarations = symbol.getDeclarations();
|
|
const declaration = declarations == null ? void 0 : declarations[0];
|
|
const checker = context.program.getTypeChecker();
|
|
const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
|
|
const kind = (_a2 = declaration == null ? void 0 : declaration.kind) != null ? _a2 : 168 /* PropertySignature */;
|
|
const declarationName = getSynthesizedDeepClone(getNameOfDeclaration(declaration), false);
|
|
const effectiveModifierFlags = declaration ? getEffectiveModifierFlags(declaration) : 0 /* None */;
|
|
let modifierFlags = effectiveModifierFlags & 4 /* Public */ ? 4 /* Public */ : effectiveModifierFlags & 16 /* Protected */ ? 16 /* Protected */ : 0 /* None */;
|
|
if (declaration && isAutoAccessorPropertyDeclaration(declaration)) {
|
|
modifierFlags |= 128 /* Accessor */;
|
|
}
|
|
const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
|
|
const type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
|
|
const optional = !!(symbol.flags & 16777216 /* Optional */);
|
|
const ambient = !!(enclosingDeclaration.flags & 16777216 /* Ambient */) || isAmbient;
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
switch (kind) {
|
|
case 168 /* PropertySignature */:
|
|
case 169 /* PropertyDeclaration */:
|
|
const flags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : void 0;
|
|
let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
|
|
if (importAdder) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
|
|
if (importableReference) {
|
|
typeNode = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
}
|
|
addClassElement(factory.createPropertyDeclaration(
|
|
modifiers,
|
|
declaration ? createName(declarationName) : symbol.getName(),
|
|
optional && preserveOptional & 2 /* Property */ ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
typeNode,
|
|
void 0
|
|
));
|
|
break;
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */: {
|
|
Debug.assertIsDefined(declarations);
|
|
let typeNode2 = checker.typeToTypeNode(type, enclosingDeclaration, void 0, getNoopSymbolTrackerWithResolver(context));
|
|
const allAccessors = getAllAccessorDeclarations(declarations, declaration);
|
|
const orderedAccessors = allAccessors.secondAccessor ? [allAccessors.firstAccessor, allAccessors.secondAccessor] : [allAccessors.firstAccessor];
|
|
if (importAdder) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode2, scriptTarget);
|
|
if (importableReference) {
|
|
typeNode2 = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
}
|
|
for (const accessor of orderedAccessors) {
|
|
if (isGetAccessorDeclaration(accessor)) {
|
|
addClassElement(factory.createGetAccessorDeclaration(
|
|
modifiers,
|
|
createName(declarationName),
|
|
emptyArray,
|
|
createTypeNode(typeNode2),
|
|
createBody(body, quotePreference, ambient)
|
|
));
|
|
} else {
|
|
Debug.assertNode(accessor, isSetAccessorDeclaration, "The counterpart to a getter should be a setter");
|
|
const parameter = getSetAccessorValueParameter(accessor);
|
|
const parameterName = parameter && isIdentifier(parameter.name) ? idText(parameter.name) : void 0;
|
|
addClassElement(factory.createSetAccessorDeclaration(
|
|
modifiers,
|
|
createName(declarationName),
|
|
createDummyParameters(1, [parameterName], [createTypeNode(typeNode2)], 1, false),
|
|
createBody(body, quotePreference, ambient)
|
|
));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 170 /* MethodSignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
Debug.assertIsDefined(declarations);
|
|
const signatures = type.isUnion() ? flatMap(type.types, (t) => t.getCallSignatures()) : type.getCallSignatures();
|
|
if (!some(signatures)) {
|
|
break;
|
|
}
|
|
if (declarations.length === 1) {
|
|
Debug.assert(signatures.length === 1, "One declaration implies one signature");
|
|
const signature = signatures[0];
|
|
outputMethod(quotePreference, signature, modifiers, createName(declarationName), createBody(body, quotePreference, ambient));
|
|
break;
|
|
}
|
|
for (const signature of signatures) {
|
|
outputMethod(quotePreference, signature, modifiers, createName(declarationName));
|
|
}
|
|
if (!ambient) {
|
|
if (declarations.length > signatures.length) {
|
|
const signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1]);
|
|
outputMethod(quotePreference, signature, modifiers, createName(declarationName), createBody(body, quotePreference));
|
|
} else {
|
|
Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
|
|
addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, createName(declarationName), optional && !!(preserveOptional & 1 /* Method */), modifiers, quotePreference, body));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
function outputMethod(quotePreference2, signature, modifiers2, name, body2) {
|
|
const method = createSignatureDeclarationFromSignature(171 /* MethodDeclaration */, context, quotePreference2, signature, body2, name, modifiers2, optional && !!(preserveOptional & 1 /* Method */), enclosingDeclaration, importAdder);
|
|
if (method)
|
|
addClassElement(method);
|
|
}
|
|
function createName(node) {
|
|
return getSynthesizedDeepClone(node, false);
|
|
}
|
|
function createBody(block, quotePreference2, ambient2) {
|
|
return ambient2 ? void 0 : getSynthesizedDeepClone(block, false) || createStubbedMethodBody(quotePreference2);
|
|
}
|
|
function createTypeNode(typeNode) {
|
|
return getSynthesizedDeepClone(typeNode, false);
|
|
}
|
|
}
|
|
function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) {
|
|
const program = context.program;
|
|
const checker = program.getTypeChecker();
|
|
const scriptTarget = getEmitScriptTarget(program.getCompilerOptions());
|
|
const flags = 1 /* NoTruncation */ | 256 /* SuppressAnyReturnType */ | 524288 /* AllowEmptyTuple */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
|
|
const signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context));
|
|
if (!signatureDeclaration) {
|
|
return void 0;
|
|
}
|
|
let typeParameters = signatureDeclaration.typeParameters;
|
|
let parameters = signatureDeclaration.parameters;
|
|
let type = signatureDeclaration.type;
|
|
if (importAdder) {
|
|
if (typeParameters) {
|
|
const newTypeParameters = sameMap(typeParameters, (typeParameterDecl) => {
|
|
let constraint = typeParameterDecl.constraint;
|
|
let defaultType = typeParameterDecl.default;
|
|
if (constraint) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(constraint, scriptTarget);
|
|
if (importableReference) {
|
|
constraint = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
}
|
|
if (defaultType) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(defaultType, scriptTarget);
|
|
if (importableReference) {
|
|
defaultType = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
}
|
|
return factory.updateTypeParameterDeclaration(
|
|
typeParameterDecl,
|
|
typeParameterDecl.modifiers,
|
|
typeParameterDecl.name,
|
|
constraint,
|
|
defaultType
|
|
);
|
|
});
|
|
if (typeParameters !== newTypeParameters) {
|
|
typeParameters = setTextRange(factory.createNodeArray(newTypeParameters, typeParameters.hasTrailingComma), typeParameters);
|
|
}
|
|
}
|
|
const newParameters = sameMap(parameters, (parameterDecl) => {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(parameterDecl.type, scriptTarget);
|
|
let type2 = parameterDecl.type;
|
|
if (importableReference) {
|
|
type2 = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
return factory.updateParameterDeclaration(
|
|
parameterDecl,
|
|
parameterDecl.modifiers,
|
|
parameterDecl.dotDotDotToken,
|
|
parameterDecl.name,
|
|
parameterDecl.questionToken,
|
|
type2,
|
|
parameterDecl.initializer
|
|
);
|
|
});
|
|
if (parameters !== newParameters) {
|
|
parameters = setTextRange(factory.createNodeArray(newParameters, parameters.hasTrailingComma), parameters);
|
|
}
|
|
if (type) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(type, scriptTarget);
|
|
if (importableReference) {
|
|
type = importableReference.typeNode;
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
}
|
|
}
|
|
}
|
|
const questionToken = optional ? factory.createToken(57 /* QuestionToken */) : void 0;
|
|
const asteriskToken = signatureDeclaration.asteriskToken;
|
|
if (isFunctionExpression(signatureDeclaration)) {
|
|
return factory.updateFunctionExpression(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, tryCast(name, isIdentifier), typeParameters, parameters, type, body != null ? body : signatureDeclaration.body);
|
|
}
|
|
if (isArrowFunction(signatureDeclaration)) {
|
|
return factory.updateArrowFunction(signatureDeclaration, modifiers, typeParameters, parameters, type, signatureDeclaration.equalsGreaterThanToken, body != null ? body : signatureDeclaration.body);
|
|
}
|
|
if (isMethodDeclaration(signatureDeclaration)) {
|
|
return factory.updateMethodDeclaration(signatureDeclaration, modifiers, asteriskToken, name != null ? name : factory.createIdentifier(""), questionToken, typeParameters, parameters, type, body);
|
|
}
|
|
if (isFunctionDeclaration(signatureDeclaration)) {
|
|
return factory.updateFunctionDeclaration(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, tryCast(name, isIdentifier), typeParameters, parameters, type, body != null ? body : signatureDeclaration.body);
|
|
}
|
|
return void 0;
|
|
}
|
|
function createSignatureDeclarationFromCallExpression(kind, context, importAdder, call, name, modifierFlags, contextNode) {
|
|
const quotePreference = getQuotePreference(context.sourceFile, context.preferences);
|
|
const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
|
|
const tracker = getNoopSymbolTrackerWithResolver(context);
|
|
const checker = context.program.getTypeChecker();
|
|
const isJs = isInJSFile(contextNode);
|
|
const { typeArguments, arguments: args, parent: parent2 } = call;
|
|
const contextualType = isJs ? void 0 : checker.getContextualType(call);
|
|
const names = map(args, (arg) => isIdentifier(arg) ? arg.text : isPropertyAccessExpression(arg) && isIdentifier(arg.name) ? arg.name.text : void 0);
|
|
const instanceTypes = isJs ? [] : map(args, (arg) => checker.getTypeAtLocation(arg));
|
|
const { argumentTypeNodes, argumentTypeParameters } = getArgumentTypesAndTypeParameters(
|
|
checker,
|
|
importAdder,
|
|
instanceTypes,
|
|
contextNode,
|
|
scriptTarget,
|
|
void 0,
|
|
tracker
|
|
);
|
|
const modifiers = modifierFlags ? factory.createNodeArray(factory.createModifiersFromModifierFlags(modifierFlags)) : void 0;
|
|
const asteriskToken = isYieldExpression(parent2) ? factory.createToken(41 /* AsteriskToken */) : void 0;
|
|
const typeParameters = isJs ? void 0 : createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments);
|
|
const parameters = createDummyParameters(args.length, names, argumentTypeNodes, void 0, isJs);
|
|
const type = isJs || contextualType === void 0 ? void 0 : checker.typeToTypeNode(contextualType, contextNode, void 0, tracker);
|
|
switch (kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
return factory.createMethodDeclaration(
|
|
modifiers,
|
|
asteriskToken,
|
|
name,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
createStubbedMethodBody(quotePreference)
|
|
);
|
|
case 170 /* MethodSignature */:
|
|
return factory.createMethodSignature(
|
|
modifiers,
|
|
name,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
type === void 0 ? factory.createKeywordTypeNode(157 /* UnknownKeyword */) : type
|
|
);
|
|
case 259 /* FunctionDeclaration */:
|
|
return factory.createFunctionDeclaration(
|
|
modifiers,
|
|
asteriskToken,
|
|
name,
|
|
typeParameters,
|
|
parameters,
|
|
type,
|
|
createStubbedBody(Diagnostics.Function_not_implemented.message, quotePreference)
|
|
);
|
|
default:
|
|
Debug.fail("Unexpected kind");
|
|
}
|
|
}
|
|
function createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments) {
|
|
const usedNames = new Set(argumentTypeParameters.map((pair) => pair[0]));
|
|
const constraintsByName = new Map(argumentTypeParameters);
|
|
if (typeArguments) {
|
|
const typeArgumentsWithNewTypes = typeArguments.filter((typeArgument) => !argumentTypeParameters.some((pair) => {
|
|
var _a2;
|
|
return checker.getTypeAtLocation(typeArgument) === ((_a2 = pair[1]) == null ? void 0 : _a2.argumentType);
|
|
}));
|
|
const targetSize = usedNames.size + typeArgumentsWithNewTypes.length;
|
|
for (let i = 0; usedNames.size < targetSize; i += 1) {
|
|
usedNames.add(createTypeParameterName(i));
|
|
}
|
|
}
|
|
return map(
|
|
arrayFrom(usedNames.values()),
|
|
(usedName) => {
|
|
var _a2;
|
|
return factory.createTypeParameterDeclaration(void 0, usedName, (_a2 = constraintsByName.get(usedName)) == null ? void 0 : _a2.constraint);
|
|
}
|
|
);
|
|
}
|
|
function createTypeParameterName(index) {
|
|
return 84 /* T */ + index <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + index) : `T${index}`;
|
|
}
|
|
function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
|
|
let typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
|
|
if (typeNode && isImportTypeNode(typeNode)) {
|
|
const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
|
|
if (importableReference) {
|
|
importSymbols(importAdder, importableReference.symbols);
|
|
typeNode = importableReference.typeNode;
|
|
}
|
|
}
|
|
return getSynthesizedDeepClone(typeNode);
|
|
}
|
|
function typeContainsTypeParameter(type) {
|
|
if (type.isUnionOrIntersection()) {
|
|
return type.types.some(typeContainsTypeParameter);
|
|
}
|
|
return type.flags & 262144 /* TypeParameter */;
|
|
}
|
|
function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) {
|
|
const argumentTypeNodes = [];
|
|
const argumentTypeParameters = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < instanceTypes.length; i += 1) {
|
|
const instanceType = instanceTypes[i];
|
|
if (instanceType.isUnionOrIntersection() && instanceType.types.some(typeContainsTypeParameter)) {
|
|
const synthesizedTypeParameterName = createTypeParameterName(i);
|
|
argumentTypeNodes.push(factory.createTypeReferenceNode(synthesizedTypeParameterName));
|
|
argumentTypeParameters.set(synthesizedTypeParameterName, void 0);
|
|
continue;
|
|
}
|
|
const widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType);
|
|
const argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker);
|
|
if (!argumentTypeNode) {
|
|
continue;
|
|
}
|
|
argumentTypeNodes.push(argumentTypeNode);
|
|
const argumentTypeParameter = getFirstTypeParameterName(instanceType);
|
|
const instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker) : void 0;
|
|
if (argumentTypeParameter) {
|
|
argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint });
|
|
}
|
|
}
|
|
return { argumentTypeNodes, argumentTypeParameters: arrayFrom(argumentTypeParameters.entries()) };
|
|
}
|
|
function isAnonymousObjectConstraintType(type) {
|
|
return type.flags & 524288 /* Object */ && type.objectFlags === 16 /* Anonymous */;
|
|
}
|
|
function getFirstTypeParameterName(type) {
|
|
var _a2;
|
|
if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
|
|
for (const subType of type.types) {
|
|
const subTypeName = getFirstTypeParameterName(subType);
|
|
if (subTypeName) {
|
|
return subTypeName;
|
|
}
|
|
}
|
|
}
|
|
return type.flags & 262144 /* TypeParameter */ ? (_a2 = type.getSymbol()) == null ? void 0 : _a2.getName() : void 0;
|
|
}
|
|
function createDummyParameters(argCount, names, types, minArgumentCount, inJs) {
|
|
const parameters = [];
|
|
const parameterNameCounts = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < argCount; i++) {
|
|
const parameterName = (names == null ? void 0 : names[i]) || `arg${i}`;
|
|
const parameterNameCount = parameterNameCounts.get(parameterName);
|
|
parameterNameCounts.set(parameterName, (parameterNameCount || 0) + 1);
|
|
const newParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
parameterName + (parameterNameCount || ""),
|
|
minArgumentCount !== void 0 && i >= minArgumentCount ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
inJs ? void 0 : (types == null ? void 0 : types[i]) || factory.createKeywordTypeNode(157 /* UnknownKeyword */),
|
|
void 0
|
|
);
|
|
parameters.push(newParameter);
|
|
}
|
|
return parameters;
|
|
}
|
|
function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body) {
|
|
let maxArgsSignature = signatures[0];
|
|
let minArgumentCount = signatures[0].minArgumentCount;
|
|
let someSigHasRestParameter = false;
|
|
for (const sig of signatures) {
|
|
minArgumentCount = Math.min(sig.minArgumentCount, minArgumentCount);
|
|
if (signatureHasRestParameter(sig)) {
|
|
someSigHasRestParameter = true;
|
|
}
|
|
if (sig.parameters.length >= maxArgsSignature.parameters.length && (!signatureHasRestParameter(sig) || signatureHasRestParameter(maxArgsSignature))) {
|
|
maxArgsSignature = sig;
|
|
}
|
|
}
|
|
const maxNonRestArgs = maxArgsSignature.parameters.length - (signatureHasRestParameter(maxArgsSignature) ? 1 : 0);
|
|
const maxArgsParameterSymbolNames = maxArgsSignature.parameters.map((symbol) => symbol.name);
|
|
const parameters = createDummyParameters(maxNonRestArgs, maxArgsParameterSymbolNames, void 0, minArgumentCount, false);
|
|
if (someSigHasRestParameter) {
|
|
const restParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
factory.createToken(25 /* DotDotDotToken */),
|
|
maxArgsParameterSymbolNames[maxNonRestArgs] || "rest",
|
|
maxNonRestArgs >= minArgumentCount ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
factory.createArrayTypeNode(factory.createKeywordTypeNode(157 /* UnknownKeyword */)),
|
|
void 0
|
|
);
|
|
parameters.push(restParameter);
|
|
}
|
|
return createStubbedMethod(
|
|
modifiers,
|
|
name,
|
|
optional,
|
|
void 0,
|
|
parameters,
|
|
getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration),
|
|
quotePreference,
|
|
body
|
|
);
|
|
}
|
|
function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) {
|
|
if (length(signatures)) {
|
|
const type = checker.getUnionType(map(signatures, checker.getReturnTypeOfSignature));
|
|
return checker.typeToTypeNode(type, enclosingDeclaration, void 0, getNoopSymbolTrackerWithResolver(context));
|
|
}
|
|
}
|
|
function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) {
|
|
return factory.createMethodDeclaration(
|
|
modifiers,
|
|
void 0,
|
|
name,
|
|
optional ? factory.createToken(57 /* QuestionToken */) : void 0,
|
|
typeParameters,
|
|
parameters,
|
|
returnType,
|
|
body || createStubbedMethodBody(quotePreference)
|
|
);
|
|
}
|
|
function createStubbedMethodBody(quotePreference) {
|
|
return createStubbedBody(Diagnostics.Method_not_implemented.message, quotePreference);
|
|
}
|
|
function createStubbedBody(text, quotePreference) {
|
|
return factory.createBlock(
|
|
[factory.createThrowStatement(
|
|
factory.createNewExpression(
|
|
factory.createIdentifier("Error"),
|
|
void 0,
|
|
[factory.createStringLiteral(text, quotePreference === 0 /* Single */)]
|
|
)
|
|
)],
|
|
true
|
|
);
|
|
}
|
|
function setJsonCompilerOptionValues(changeTracker, configFile, options) {
|
|
const tsconfigObjectLiteral = getTsConfigObjectLiteralExpression(configFile);
|
|
if (!tsconfigObjectLiteral)
|
|
return void 0;
|
|
const compilerOptionsProperty = findJsonProperty(tsconfigObjectLiteral, "compilerOptions");
|
|
if (compilerOptionsProperty === void 0) {
|
|
changeTracker.insertNodeAtObjectStart(configFile, tsconfigObjectLiteral, createJsonPropertyAssignment(
|
|
"compilerOptions",
|
|
factory.createObjectLiteralExpression(options.map(([optionName, optionValue]) => createJsonPropertyAssignment(optionName, optionValue)), true)
|
|
));
|
|
return;
|
|
}
|
|
const compilerOptions = compilerOptionsProperty.initializer;
|
|
if (!isObjectLiteralExpression(compilerOptions)) {
|
|
return;
|
|
}
|
|
for (const [optionName, optionValue] of options) {
|
|
const optionProperty = findJsonProperty(compilerOptions, optionName);
|
|
if (optionProperty === void 0) {
|
|
changeTracker.insertNodeAtObjectStart(configFile, compilerOptions, createJsonPropertyAssignment(optionName, optionValue));
|
|
} else {
|
|
changeTracker.replaceNode(configFile, optionProperty.initializer, optionValue);
|
|
}
|
|
}
|
|
}
|
|
function setJsonCompilerOptionValue(changeTracker, configFile, optionName, optionValue) {
|
|
setJsonCompilerOptionValues(changeTracker, configFile, [[optionName, optionValue]]);
|
|
}
|
|
function createJsonPropertyAssignment(name, initializer) {
|
|
return factory.createPropertyAssignment(factory.createStringLiteral(name), initializer);
|
|
}
|
|
function findJsonProperty(obj, name) {
|
|
return find(obj.properties, (p) => isPropertyAssignment(p) && !!p.name && isStringLiteral(p.name) && p.name.text === name);
|
|
}
|
|
function tryGetAutoImportableReferenceFromTypeNode(importTypeNode, scriptTarget) {
|
|
let symbols;
|
|
const typeNode = visitNode(importTypeNode, visit);
|
|
if (symbols && typeNode) {
|
|
return { typeNode, symbols };
|
|
}
|
|
function visit(node) {
|
|
var _a2;
|
|
if (isLiteralImportTypeNode(node) && node.qualifier) {
|
|
const firstIdentifier = getFirstIdentifier(node.qualifier);
|
|
const name = getNameForExportedSymbol(firstIdentifier.symbol, scriptTarget);
|
|
const qualifier = name !== firstIdentifier.text ? replaceFirstIdentifierOfEntityName(node.qualifier, factory.createIdentifier(name)) : node.qualifier;
|
|
symbols = append(symbols, firstIdentifier.symbol);
|
|
const typeArguments = (_a2 = node.typeArguments) == null ? void 0 : _a2.map(visit);
|
|
return factory.createTypeReferenceNode(qualifier, typeArguments);
|
|
}
|
|
return visitEachChild(node, visit, nullTransformationContext);
|
|
}
|
|
}
|
|
function replaceFirstIdentifierOfEntityName(name, newIdentifier) {
|
|
if (name.kind === 79 /* Identifier */) {
|
|
return newIdentifier;
|
|
}
|
|
return factory.createQualifiedName(replaceFirstIdentifierOfEntityName(name.left, newIdentifier), name.right);
|
|
}
|
|
function importSymbols(importAdder, symbols) {
|
|
symbols.forEach((s) => importAdder.addImportFromExportedSymbol(s, true));
|
|
}
|
|
function findAncestorMatchingSpan(sourceFile, span) {
|
|
const end = textSpanEnd(span);
|
|
let token = getTokenAtPosition(sourceFile, span.start);
|
|
while (token.end < end) {
|
|
token = token.parent;
|
|
}
|
|
return token;
|
|
}
|
|
|
|
// src/services/codefixes/generateAccessors.ts
|
|
function generateAccessorFromProperty(file, program, start2, end, context, _actionName) {
|
|
const fieldInfo = getAccessorConvertiblePropertyAtPosition(file, program, start2, end);
|
|
if (!fieldInfo || ts_refactor_exports.isRefactorErrorInfo(fieldInfo))
|
|
return void 0;
|
|
const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext(context);
|
|
const { isStatic: isStatic2, isReadonly, fieldName, accessorName, originalName, type, container, declaration } = fieldInfo;
|
|
suppressLeadingAndTrailingTrivia(fieldName);
|
|
suppressLeadingAndTrailingTrivia(accessorName);
|
|
suppressLeadingAndTrailingTrivia(declaration);
|
|
suppressLeadingAndTrailingTrivia(container);
|
|
let accessorModifiers;
|
|
let fieldModifiers;
|
|
if (isClassLike(container)) {
|
|
const modifierFlags = getEffectiveModifierFlags(declaration);
|
|
if (isSourceFileJS(file)) {
|
|
const modifiers = factory.createModifiersFromModifierFlags(modifierFlags);
|
|
accessorModifiers = modifiers;
|
|
fieldModifiers = modifiers;
|
|
} else {
|
|
accessorModifiers = factory.createModifiersFromModifierFlags(prepareModifierFlagsForAccessor(modifierFlags));
|
|
fieldModifiers = factory.createModifiersFromModifierFlags(prepareModifierFlagsForField(modifierFlags));
|
|
}
|
|
if (canHaveDecorators(declaration)) {
|
|
fieldModifiers = concatenate(getDecorators(declaration), fieldModifiers);
|
|
}
|
|
}
|
|
updateFieldDeclaration(changeTracker, file, declaration, type, fieldName, fieldModifiers);
|
|
const getAccessor = generateGetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic2, container);
|
|
suppressLeadingAndTrailingTrivia(getAccessor);
|
|
insertAccessor(changeTracker, file, getAccessor, declaration, container);
|
|
if (isReadonly) {
|
|
const constructor = getFirstConstructorWithBody(container);
|
|
if (constructor) {
|
|
updateReadonlyPropertyInitializerStatementConstructor(changeTracker, file, constructor, fieldName.text, originalName);
|
|
}
|
|
} else {
|
|
const setAccessor = generateSetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic2, container);
|
|
suppressLeadingAndTrailingTrivia(setAccessor);
|
|
insertAccessor(changeTracker, file, setAccessor, declaration, container);
|
|
}
|
|
return changeTracker.getChanges();
|
|
}
|
|
function isConvertibleName(name) {
|
|
return isIdentifier(name) || isStringLiteral(name);
|
|
}
|
|
function isAcceptedDeclaration(node) {
|
|
return isParameterPropertyDeclaration(node, node.parent) || isPropertyDeclaration(node) || isPropertyAssignment(node);
|
|
}
|
|
function createPropertyName(name, originalName) {
|
|
return isIdentifier(originalName) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
|
|
}
|
|
function createAccessorAccessExpression(fieldName, isStatic2, container) {
|
|
const leftHead = isStatic2 ? container.name : factory.createThis();
|
|
return isIdentifier(fieldName) ? factory.createPropertyAccessExpression(leftHead, fieldName) : factory.createElementAccessExpression(leftHead, factory.createStringLiteralFromNode(fieldName));
|
|
}
|
|
function prepareModifierFlagsForAccessor(modifierFlags) {
|
|
modifierFlags &= ~64 /* Readonly */;
|
|
modifierFlags &= ~8 /* Private */;
|
|
if (!(modifierFlags & 16 /* Protected */)) {
|
|
modifierFlags |= 4 /* Public */;
|
|
}
|
|
return modifierFlags;
|
|
}
|
|
function prepareModifierFlagsForField(modifierFlags) {
|
|
modifierFlags &= ~4 /* Public */;
|
|
modifierFlags &= ~16 /* Protected */;
|
|
modifierFlags |= 8 /* Private */;
|
|
return modifierFlags;
|
|
}
|
|
function getAccessorConvertiblePropertyAtPosition(file, program, start2, end, considerEmptySpans = true) {
|
|
const node = getTokenAtPosition(file, start2);
|
|
const cursorRequest = start2 === end && considerEmptySpans;
|
|
const declaration = findAncestor(node.parent, isAcceptedDeclaration);
|
|
const meaning = 28 /* AccessibilityModifier */ | 32 /* Static */ | 64 /* Readonly */;
|
|
if (!declaration || !(nodeOverlapsWithStartEnd(declaration.name, file, start2, end) || cursorRequest)) {
|
|
return {
|
|
error: getLocaleSpecificMessage(Diagnostics.Could_not_find_property_for_which_to_generate_accessor)
|
|
};
|
|
}
|
|
if (!isConvertibleName(declaration.name)) {
|
|
return {
|
|
error: getLocaleSpecificMessage(Diagnostics.Name_is_not_valid)
|
|
};
|
|
}
|
|
if ((getEffectiveModifierFlags(declaration) & 126975 /* Modifier */ | meaning) !== meaning) {
|
|
return {
|
|
error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_property_with_modifier)
|
|
};
|
|
}
|
|
const name = declaration.name.text;
|
|
const startWithUnderscore = startsWithUnderscore(name);
|
|
const fieldName = createPropertyName(startWithUnderscore ? name : getUniqueName(`_${name}`, file), declaration.name);
|
|
const accessorName = createPropertyName(startWithUnderscore ? getUniqueName(name.substring(1), file) : name, declaration.name);
|
|
return {
|
|
isStatic: hasStaticModifier(declaration),
|
|
isReadonly: hasEffectiveReadonlyModifier(declaration),
|
|
type: getDeclarationType(declaration, program),
|
|
container: declaration.kind === 166 /* Parameter */ ? declaration.parent.parent : declaration.parent,
|
|
originalName: declaration.name.text,
|
|
declaration,
|
|
fieldName,
|
|
accessorName,
|
|
renameAccessor: startWithUnderscore
|
|
};
|
|
}
|
|
function generateGetAccessor(fieldName, accessorName, type, modifiers, isStatic2, container) {
|
|
return factory.createGetAccessorDeclaration(
|
|
modifiers,
|
|
accessorName,
|
|
void 0,
|
|
type,
|
|
factory.createBlock([
|
|
factory.createReturnStatement(
|
|
createAccessorAccessExpression(fieldName, isStatic2, container)
|
|
)
|
|
], true)
|
|
);
|
|
}
|
|
function generateSetAccessor(fieldName, accessorName, type, modifiers, isStatic2, container) {
|
|
return factory.createSetAccessorDeclaration(
|
|
modifiers,
|
|
accessorName,
|
|
[factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
factory.createIdentifier("value"),
|
|
void 0,
|
|
type
|
|
)],
|
|
factory.createBlock([
|
|
factory.createExpressionStatement(
|
|
factory.createAssignment(
|
|
createAccessorAccessExpression(fieldName, isStatic2, container),
|
|
factory.createIdentifier("value")
|
|
)
|
|
)
|
|
], true)
|
|
);
|
|
}
|
|
function updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) {
|
|
const property = factory.updatePropertyDeclaration(
|
|
declaration,
|
|
modifiers,
|
|
fieldName,
|
|
declaration.questionToken || declaration.exclamationToken,
|
|
type,
|
|
declaration.initializer
|
|
);
|
|
changeTracker.replaceNode(file, declaration, property);
|
|
}
|
|
function updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName) {
|
|
const assignment = factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer);
|
|
changeTracker.replacePropertyAssignment(file, declaration, assignment);
|
|
}
|
|
function updateFieldDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) {
|
|
if (isPropertyDeclaration(declaration)) {
|
|
updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers);
|
|
} else if (isPropertyAssignment(declaration)) {
|
|
updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName);
|
|
} else {
|
|
changeTracker.replaceNode(
|
|
file,
|
|
declaration,
|
|
factory.updateParameterDeclaration(declaration, modifiers, declaration.dotDotDotToken, cast(fieldName, isIdentifier), declaration.questionToken, declaration.type, declaration.initializer)
|
|
);
|
|
}
|
|
}
|
|
function insertAccessor(changeTracker, file, accessor, declaration, container) {
|
|
isParameterPropertyDeclaration(declaration, declaration.parent) ? changeTracker.insertMemberAtStart(file, container, accessor) : isPropertyAssignment(declaration) ? changeTracker.insertNodeAfterComma(file, declaration, accessor) : changeTracker.insertNodeAfter(file, declaration, accessor);
|
|
}
|
|
function updateReadonlyPropertyInitializerStatementConstructor(changeTracker, file, constructor, fieldName, originalName) {
|
|
if (!constructor.body)
|
|
return;
|
|
constructor.body.forEachChild(function recur(node) {
|
|
if (isElementAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */ && isStringLiteral(node.argumentExpression) && node.argumentExpression.text === originalName && isWriteAccess(node)) {
|
|
changeTracker.replaceNode(file, node.argumentExpression, factory.createStringLiteral(fieldName));
|
|
}
|
|
if (isPropertyAccessExpression(node) && node.expression.kind === 108 /* ThisKeyword */ && node.name.text === originalName && isWriteAccess(node)) {
|
|
changeTracker.replaceNode(file, node.name, factory.createIdentifier(fieldName));
|
|
}
|
|
if (!isFunctionLike(node) && !isClassLike(node)) {
|
|
node.forEachChild(recur);
|
|
}
|
|
});
|
|
}
|
|
function getDeclarationType(declaration, program) {
|
|
const typeNode = getTypeAnnotationNode(declaration);
|
|
if (isPropertyDeclaration(declaration) && typeNode && declaration.questionToken) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const type = typeChecker.getTypeFromTypeNode(typeNode);
|
|
if (!typeChecker.isTypeAssignableTo(typeChecker.getUndefinedType(), type)) {
|
|
const types = isUnionTypeNode(typeNode) ? typeNode.types : [typeNode];
|
|
return factory.createUnionTypeNode([...types, factory.createKeywordTypeNode(155 /* UndefinedKeyword */)]);
|
|
}
|
|
}
|
|
return typeNode;
|
|
}
|
|
function getAllSupers(decl, checker) {
|
|
const res = [];
|
|
while (decl) {
|
|
const superElement = getClassExtendsHeritageElement(decl);
|
|
const superSymbol = superElement && checker.getSymbolAtLocation(superElement.expression);
|
|
if (!superSymbol)
|
|
break;
|
|
const symbol = superSymbol.flags & 2097152 /* Alias */ ? checker.getAliasedSymbol(superSymbol) : superSymbol;
|
|
const superDecl = symbol.declarations && find(symbol.declarations, isClassLike);
|
|
if (!superDecl)
|
|
break;
|
|
res.push(superDecl);
|
|
decl = superDecl;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// src/services/codefixes/fixInvalidImportSyntax.ts
|
|
var fixName5 = "invalidImportSyntax";
|
|
function getCodeFixesForImportDeclaration(context, node) {
|
|
const sourceFile = getSourceFileOfNode(node);
|
|
const namespace = getNamespaceDeclarationNode(node);
|
|
const opts = context.program.getCompilerOptions();
|
|
const variations = [];
|
|
variations.push(createAction(context, sourceFile, node, makeImport(namespace.name, void 0, node.moduleSpecifier, getQuotePreference(sourceFile, context.preferences))));
|
|
if (getEmitModuleKind(opts) === 1 /* CommonJS */) {
|
|
variations.push(createAction(context, sourceFile, node, factory.createImportEqualsDeclaration(
|
|
void 0,
|
|
false,
|
|
namespace.name,
|
|
factory.createExternalModuleReference(node.moduleSpecifier)
|
|
)));
|
|
}
|
|
return variations;
|
|
}
|
|
function createAction(context, sourceFile, node, replacement) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(sourceFile, node, replacement));
|
|
return createCodeFixActionWithoutFixAll(fixName5, changes, [Diagnostics.Replace_import_with_0, changes[0].textChanges[0].newText]);
|
|
}
|
|
registerCodeFix({
|
|
errorCodes: [
|
|
Diagnostics.This_expression_is_not_callable.code,
|
|
Diagnostics.This_expression_is_not_constructable.code
|
|
],
|
|
getCodeActions: getActionsForUsageOfInvalidImport
|
|
});
|
|
function getActionsForUsageOfInvalidImport(context) {
|
|
const sourceFile = context.sourceFile;
|
|
const targetKind = Diagnostics.This_expression_is_not_callable.code === context.errorCode ? 210 /* CallExpression */ : 211 /* NewExpression */;
|
|
const node = findAncestor(getTokenAtPosition(sourceFile, context.span.start), (a) => a.kind === targetKind);
|
|
if (!node) {
|
|
return [];
|
|
}
|
|
const expr = node.expression;
|
|
return getImportCodeFixesForExpression(context, expr);
|
|
}
|
|
registerCodeFix({
|
|
errorCodes: [
|
|
Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code,
|
|
Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1.code,
|
|
Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
|
|
Diagnostics.Type_predicate_0_is_not_assignable_to_1.code,
|
|
Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3.code,
|
|
Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3.code,
|
|
Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2.code,
|
|
Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
|
|
Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property.code,
|
|
Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1.code
|
|
],
|
|
getCodeActions: getActionsForInvalidImportLocation
|
|
});
|
|
function getActionsForInvalidImportLocation(context) {
|
|
const sourceFile = context.sourceFile;
|
|
const node = findAncestor(getTokenAtPosition(sourceFile, context.span.start), (a) => a.getStart() === context.span.start && a.getEnd() === context.span.start + context.span.length);
|
|
if (!node) {
|
|
return [];
|
|
}
|
|
return getImportCodeFixesForExpression(context, node);
|
|
}
|
|
function getImportCodeFixesForExpression(context, expr) {
|
|
const type = context.program.getTypeChecker().getTypeAtLocation(expr);
|
|
if (!(type.symbol && type.symbol.originatingImport)) {
|
|
return [];
|
|
}
|
|
const fixes = [];
|
|
const relatedImport = type.symbol.originatingImport;
|
|
if (!isImportCall(relatedImport)) {
|
|
addRange(fixes, getCodeFixesForImportDeclaration(context, relatedImport));
|
|
}
|
|
if (isExpression(expr) && !(isNamedDeclaration(expr.parent) && expr.parent.name === expr)) {
|
|
const sourceFile = context.sourceFile;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(sourceFile, expr, factory.createPropertyAccessExpression(expr, "default"), {}));
|
|
fixes.push(createCodeFixActionWithoutFixAll(fixName5, changes, Diagnostics.Use_synthetic_default_member));
|
|
}
|
|
return fixes;
|
|
}
|
|
|
|
// src/services/codefixes/fixStrictClassInitialization.ts
|
|
var fixName6 = "strictClassInitialization";
|
|
var fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions";
|
|
var fixIdAddUndefinedType = "addMissingPropertyUndefinedType";
|
|
var fixIdAddInitializer = "addMissingPropertyInitializer";
|
|
var errorCodes51 = [Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes51,
|
|
getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) {
|
|
const info = getInfo13(context.sourceFile, context.span.start);
|
|
if (!info)
|
|
return;
|
|
const result = [];
|
|
append(result, getActionForAddMissingUndefinedType(context, info));
|
|
append(result, getActionForAddMissingDefiniteAssignmentAssertion(context, info));
|
|
append(result, getActionForAddMissingInitializer(context, info));
|
|
return result;
|
|
},
|
|
fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer],
|
|
getAllCodeActions: (context) => {
|
|
return codeFixAll(context, errorCodes51, (changes, diag2) => {
|
|
const info = getInfo13(diag2.file, diag2.start);
|
|
if (!info)
|
|
return;
|
|
switch (context.fixId) {
|
|
case fixIdAddDefiniteAssignmentAssertions:
|
|
addDefiniteAssignmentAssertion(changes, diag2.file, info.prop);
|
|
break;
|
|
case fixIdAddUndefinedType:
|
|
addUndefinedType(changes, diag2.file, info);
|
|
break;
|
|
case fixIdAddInitializer:
|
|
const checker = context.program.getTypeChecker();
|
|
const initializer = getInitializer(checker, info.prop);
|
|
if (!initializer)
|
|
return;
|
|
addInitializer(changes, diag2.file, info.prop, initializer);
|
|
break;
|
|
default:
|
|
Debug.fail(JSON.stringify(context.fixId));
|
|
}
|
|
});
|
|
}
|
|
});
|
|
function getInfo13(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
if (isIdentifier(token) && isPropertyDeclaration(token.parent)) {
|
|
const type = getEffectiveTypeAnnotationNode(token.parent);
|
|
if (type) {
|
|
return { type, prop: token.parent, isJs: isInJSFile(token.parent) };
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getActionForAddMissingDefiniteAssignmentAssertion(context, info) {
|
|
if (info.isJs)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addDefiniteAssignmentAssertion(t, context.sourceFile, info.prop));
|
|
return createCodeFixAction(fixName6, changes, [Diagnostics.Add_definite_assignment_assertion_to_property_0, info.prop.getText()], fixIdAddDefiniteAssignmentAssertions, Diagnostics.Add_definite_assignment_assertions_to_all_uninitialized_properties);
|
|
}
|
|
function addDefiniteAssignmentAssertion(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) {
|
|
suppressLeadingAndTrailingTrivia(propertyDeclaration);
|
|
const property = factory.updatePropertyDeclaration(
|
|
propertyDeclaration,
|
|
propertyDeclaration.modifiers,
|
|
propertyDeclaration.name,
|
|
factory.createToken(53 /* ExclamationToken */),
|
|
propertyDeclaration.type,
|
|
propertyDeclaration.initializer
|
|
);
|
|
changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property);
|
|
}
|
|
function getActionForAddMissingUndefinedType(context, info) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addUndefinedType(t, context.sourceFile, info));
|
|
return createCodeFixAction(fixName6, changes, [Diagnostics.Add_undefined_type_to_property_0, info.prop.name.getText()], fixIdAddUndefinedType, Diagnostics.Add_undefined_type_to_all_uninitialized_properties);
|
|
}
|
|
function addUndefinedType(changeTracker, sourceFile, info) {
|
|
const undefinedTypeNode = factory.createKeywordTypeNode(155 /* UndefinedKeyword */);
|
|
const types = isUnionTypeNode(info.type) ? info.type.types.concat(undefinedTypeNode) : [info.type, undefinedTypeNode];
|
|
const unionTypeNode = factory.createUnionTypeNode(types);
|
|
if (info.isJs) {
|
|
changeTracker.addJSDocTags(sourceFile, info.prop, [factory.createJSDocTypeTag(void 0, factory.createJSDocTypeExpression(unionTypeNode))]);
|
|
} else {
|
|
changeTracker.replaceNode(sourceFile, info.type, unionTypeNode);
|
|
}
|
|
}
|
|
function getActionForAddMissingInitializer(context, info) {
|
|
if (info.isJs)
|
|
return void 0;
|
|
const checker = context.program.getTypeChecker();
|
|
const initializer = getInitializer(checker, info.prop);
|
|
if (!initializer)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => addInitializer(t, context.sourceFile, info.prop, initializer));
|
|
return createCodeFixAction(fixName6, changes, [Diagnostics.Add_initializer_to_property_0, info.prop.name.getText()], fixIdAddInitializer, Diagnostics.Add_initializers_to_all_uninitialized_properties);
|
|
}
|
|
function addInitializer(changeTracker, propertyDeclarationSourceFile, propertyDeclaration, initializer) {
|
|
suppressLeadingAndTrailingTrivia(propertyDeclaration);
|
|
const property = factory.updatePropertyDeclaration(
|
|
propertyDeclaration,
|
|
propertyDeclaration.modifiers,
|
|
propertyDeclaration.name,
|
|
propertyDeclaration.questionToken,
|
|
propertyDeclaration.type,
|
|
initializer
|
|
);
|
|
changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property);
|
|
}
|
|
function getInitializer(checker, propertyDeclaration) {
|
|
return getDefaultValueFromType(checker, checker.getTypeFromTypeNode(propertyDeclaration.type));
|
|
}
|
|
function getDefaultValueFromType(checker, type) {
|
|
if (type.flags & 512 /* BooleanLiteral */) {
|
|
return type === checker.getFalseType() || type === checker.getFalseType(true) ? factory.createFalse() : factory.createTrue();
|
|
} else if (type.isStringLiteral()) {
|
|
return factory.createStringLiteral(type.value);
|
|
} else if (type.isNumberLiteral()) {
|
|
return factory.createNumericLiteral(type.value);
|
|
} else if (type.flags & 2048 /* BigIntLiteral */) {
|
|
return factory.createBigIntLiteral(type.value);
|
|
} else if (type.isUnion()) {
|
|
return firstDefined(type.types, (t) => getDefaultValueFromType(checker, t));
|
|
} else if (type.isClass()) {
|
|
const classDeclaration = getClassLikeDeclarationOfSymbol(type.symbol);
|
|
if (!classDeclaration || hasSyntacticModifier(classDeclaration, 256 /* Abstract */))
|
|
return void 0;
|
|
const constructorDeclaration = getFirstConstructorWithBody(classDeclaration);
|
|
if (constructorDeclaration && constructorDeclaration.parameters.length)
|
|
return void 0;
|
|
return factory.createNewExpression(factory.createIdentifier(type.symbol.name), void 0, void 0);
|
|
} else if (checker.isArrayLikeType(type)) {
|
|
return factory.createArrayLiteralExpression();
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/services/codefixes/requireInTs.ts
|
|
var fixId41 = "requireInTs";
|
|
var errorCodes52 = [Diagnostics.require_call_may_be_converted_to_an_import.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes52,
|
|
getCodeActions(context) {
|
|
const info = getInfo14(context.sourceFile, context.program, context.span.start);
|
|
if (!info) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange26(t, context.sourceFile, info));
|
|
return [createCodeFixAction(fixId41, changes, Diagnostics.Convert_require_to_import, fixId41, Diagnostics.Convert_all_require_to_import)];
|
|
},
|
|
fixIds: [fixId41],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes52, (changes, diag2) => {
|
|
const info = getInfo14(diag2.file, context.program, diag2.start);
|
|
if (info) {
|
|
doChange26(changes, context.sourceFile, info);
|
|
}
|
|
})
|
|
});
|
|
function doChange26(changes, sourceFile, info) {
|
|
const { allowSyntheticDefaults, defaultImportName, namedImports, statement, required } = info;
|
|
changes.replaceNode(sourceFile, statement, defaultImportName && !allowSyntheticDefaults ? factory.createImportEqualsDeclaration(void 0, false, defaultImportName, factory.createExternalModuleReference(required)) : factory.createImportDeclaration(void 0, factory.createImportClause(false, defaultImportName, namedImports), required, void 0));
|
|
}
|
|
function getInfo14(sourceFile, program, pos) {
|
|
const { parent: parent2 } = getTokenAtPosition(sourceFile, pos);
|
|
if (!isRequireCall(parent2, true)) {
|
|
throw Debug.failBadSyntaxKind(parent2);
|
|
}
|
|
const decl = cast(parent2.parent, isVariableDeclaration);
|
|
const defaultImportName = tryCast(decl.name, isIdentifier);
|
|
const namedImports = isObjectBindingPattern(decl.name) ? tryCreateNamedImportsFromObjectBindingPattern(decl.name) : void 0;
|
|
if (defaultImportName || namedImports) {
|
|
return {
|
|
allowSyntheticDefaults: getAllowSyntheticDefaultImports(program.getCompilerOptions()),
|
|
defaultImportName,
|
|
namedImports,
|
|
statement: cast(decl.parent.parent, isVariableStatement),
|
|
required: first(parent2.arguments)
|
|
};
|
|
}
|
|
}
|
|
function tryCreateNamedImportsFromObjectBindingPattern(node) {
|
|
const importSpecifiers = [];
|
|
for (const element of node.elements) {
|
|
if (!isIdentifier(element.name) || element.initializer) {
|
|
return void 0;
|
|
}
|
|
importSpecifiers.push(factory.createImportSpecifier(false, tryCast(element.propertyName, isIdentifier), element.name));
|
|
}
|
|
if (importSpecifiers.length) {
|
|
return factory.createNamedImports(importSpecifiers);
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/useDefaultImport.ts
|
|
var fixId42 = "useDefaultImport";
|
|
var errorCodes53 = [Diagnostics.Import_may_be_converted_to_a_default_import.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes53,
|
|
getCodeActions(context) {
|
|
const { sourceFile, span: { start: start2 } } = context;
|
|
const info = getInfo15(sourceFile, start2);
|
|
if (!info)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange27(t, sourceFile, info, context.preferences));
|
|
return [createCodeFixAction(fixId42, changes, Diagnostics.Convert_to_default_import, fixId42, Diagnostics.Convert_all_to_default_imports)];
|
|
},
|
|
fixIds: [fixId42],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes53, (changes, diag2) => {
|
|
const info = getInfo15(diag2.file, diag2.start);
|
|
if (info)
|
|
doChange27(changes, diag2.file, info, context.preferences);
|
|
})
|
|
});
|
|
function getInfo15(sourceFile, pos) {
|
|
const name = getTokenAtPosition(sourceFile, pos);
|
|
if (!isIdentifier(name))
|
|
return void 0;
|
|
const { parent: parent2 } = name;
|
|
if (isImportEqualsDeclaration(parent2) && isExternalModuleReference(parent2.moduleReference)) {
|
|
return { importNode: parent2, name, moduleSpecifier: parent2.moduleReference.expression };
|
|
} else if (isNamespaceImport(parent2)) {
|
|
const importNode = parent2.parent.parent;
|
|
return { importNode, name, moduleSpecifier: importNode.moduleSpecifier };
|
|
}
|
|
}
|
|
function doChange27(changes, sourceFile, info, preferences) {
|
|
changes.replaceNode(sourceFile, info.importNode, makeImport(info.name, void 0, info.moduleSpecifier, getQuotePreference(sourceFile, preferences)));
|
|
}
|
|
|
|
// src/services/codefixes/useBigintLiteral.ts
|
|
var fixId43 = "useBigintLiteral";
|
|
var errorCodes54 = [
|
|
Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes54,
|
|
getCodeActions: function getCodeActionsToUseBigintLiteral(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange9(t, context.sourceFile, context.span));
|
|
if (changes.length > 0) {
|
|
return [createCodeFixAction(fixId43, changes, Diagnostics.Convert_to_a_bigint_numeric_literal, fixId43, Diagnostics.Convert_all_to_bigint_numeric_literals)];
|
|
}
|
|
},
|
|
fixIds: [fixId43],
|
|
getAllCodeActions: (context) => {
|
|
return codeFixAll(context, errorCodes54, (changes, diag2) => makeChange9(changes, diag2.file, diag2));
|
|
}
|
|
});
|
|
function makeChange9(changeTracker, sourceFile, span) {
|
|
const numericLiteral = tryCast(getTokenAtPosition(sourceFile, span.start), isNumericLiteral);
|
|
if (!numericLiteral) {
|
|
return;
|
|
}
|
|
const newText = numericLiteral.getText(sourceFile) + "n";
|
|
changeTracker.replaceNode(sourceFile, numericLiteral, factory.createBigIntLiteral(newText));
|
|
}
|
|
|
|
// src/services/codefixes/fixAddModuleReferTypeMissingTypeof.ts
|
|
var fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof";
|
|
var fixId44 = fixIdAddMissingTypeof;
|
|
var errorCodes55 = [Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes55,
|
|
getCodeActions: function getCodeActionsToAddMissingTypeof(context) {
|
|
const { sourceFile, span } = context;
|
|
const importType = getImportTypeNode(sourceFile, span.start);
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange28(t, sourceFile, importType));
|
|
return [createCodeFixAction(fixId44, changes, Diagnostics.Add_missing_typeof, fixId44, Diagnostics.Add_missing_typeof)];
|
|
},
|
|
fixIds: [fixId44],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes55, (changes, diag2) => doChange28(changes, context.sourceFile, getImportTypeNode(diag2.file, diag2.start)))
|
|
});
|
|
function getImportTypeNode(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
Debug.assert(token.kind === 100 /* ImportKeyword */, "This token should be an ImportKeyword");
|
|
Debug.assert(token.parent.kind === 202 /* ImportType */, "Token parent should be an ImportType");
|
|
return token.parent;
|
|
}
|
|
function doChange28(changes, sourceFile, importType) {
|
|
const newTypeNode = factory.updateImportTypeNode(importType, importType.argument, importType.assertions, importType.qualifier, importType.typeArguments, true);
|
|
changes.replaceNode(sourceFile, importType, newTypeNode);
|
|
}
|
|
|
|
// src/services/codefixes/wrapJsxInFragment.ts
|
|
var fixID2 = "wrapJsxInFragment";
|
|
var errorCodes56 = [Diagnostics.JSX_expressions_must_have_one_parent_element.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes56,
|
|
getCodeActions: function getCodeActionsToWrapJsxInFragment(context) {
|
|
const { sourceFile, span } = context;
|
|
const node = findNodeToFix(sourceFile, span.start);
|
|
if (!node)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange29(t, sourceFile, node));
|
|
return [createCodeFixAction(fixID2, changes, Diagnostics.Wrap_in_JSX_fragment, fixID2, Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)];
|
|
},
|
|
fixIds: [fixID2],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes56, (changes, diag2) => {
|
|
const node = findNodeToFix(context.sourceFile, diag2.start);
|
|
if (!node)
|
|
return void 0;
|
|
doChange29(changes, context.sourceFile, node);
|
|
})
|
|
});
|
|
function findNodeToFix(sourceFile, pos) {
|
|
const lessThanToken = getTokenAtPosition(sourceFile, pos);
|
|
const firstJsxElementOrOpenElement = lessThanToken.parent;
|
|
let binaryExpr = firstJsxElementOrOpenElement.parent;
|
|
if (!isBinaryExpression(binaryExpr)) {
|
|
binaryExpr = binaryExpr.parent;
|
|
if (!isBinaryExpression(binaryExpr))
|
|
return void 0;
|
|
}
|
|
if (!nodeIsMissing(binaryExpr.operatorToken))
|
|
return void 0;
|
|
return binaryExpr;
|
|
}
|
|
function doChange29(changeTracker, sf, node) {
|
|
const jsx = flattenInvalidBinaryExpr(node);
|
|
if (jsx)
|
|
changeTracker.replaceNode(sf, node, factory.createJsxFragment(factory.createJsxOpeningFragment(), jsx, factory.createJsxJsxClosingFragment()));
|
|
}
|
|
function flattenInvalidBinaryExpr(node) {
|
|
const children = [];
|
|
let current = node;
|
|
while (true) {
|
|
if (isBinaryExpression(current) && nodeIsMissing(current.operatorToken) && current.operatorToken.kind === 27 /* CommaToken */) {
|
|
children.push(current.left);
|
|
if (isJsxChild(current.right)) {
|
|
children.push(current.right);
|
|
return children;
|
|
} else if (isBinaryExpression(current.right)) {
|
|
current = current.right;
|
|
continue;
|
|
} else
|
|
return void 0;
|
|
} else
|
|
return void 0;
|
|
}
|
|
}
|
|
|
|
// src/services/codefixes/convertToMappedObjectType.ts
|
|
var fixId45 = "fixConvertToMappedObjectType";
|
|
var errorCodes57 = [Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes57,
|
|
getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) {
|
|
const { sourceFile, span } = context;
|
|
const info = getInfo16(sourceFile, span.start);
|
|
if (!info)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange30(t, sourceFile, info));
|
|
const name = idText(info.container.name);
|
|
return [createCodeFixAction(fixId45, changes, [Diagnostics.Convert_0_to_mapped_object_type, name], fixId45, [Diagnostics.Convert_0_to_mapped_object_type, name])];
|
|
},
|
|
fixIds: [fixId45],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes57, (changes, diag2) => {
|
|
const info = getInfo16(diag2.file, diag2.start);
|
|
if (info)
|
|
doChange30(changes, diag2.file, info);
|
|
})
|
|
});
|
|
function getInfo16(sourceFile, pos) {
|
|
const token = getTokenAtPosition(sourceFile, pos);
|
|
const indexSignature = tryCast(token.parent.parent, isIndexSignatureDeclaration);
|
|
if (!indexSignature)
|
|
return void 0;
|
|
const container = isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : tryCast(indexSignature.parent.parent, isTypeAliasDeclaration);
|
|
if (!container)
|
|
return void 0;
|
|
return { indexSignature, container };
|
|
}
|
|
function createTypeAliasFromInterface(declaration, type) {
|
|
return factory.createTypeAliasDeclaration(declaration.modifiers, declaration.name, declaration.typeParameters, type);
|
|
}
|
|
function doChange30(changes, sourceFile, { indexSignature, container }) {
|
|
const members = isInterfaceDeclaration(container) ? container.members : container.type.members;
|
|
const otherMembers = members.filter((member) => !isIndexSignatureDeclaration(member));
|
|
const parameter = first(indexSignature.parameters);
|
|
const mappedTypeParameter = factory.createTypeParameterDeclaration(void 0, cast(parameter.name, isIdentifier), parameter.type);
|
|
const mappedIntersectionType = factory.createMappedTypeNode(
|
|
hasEffectiveReadonlyModifier(indexSignature) ? factory.createModifier(146 /* ReadonlyKeyword */) : void 0,
|
|
mappedTypeParameter,
|
|
void 0,
|
|
indexSignature.questionToken,
|
|
indexSignature.type,
|
|
void 0
|
|
);
|
|
const intersectionType = factory.createIntersectionTypeNode([
|
|
...getAllSuperTypeNodes(container),
|
|
mappedIntersectionType,
|
|
...otherMembers.length ? [factory.createTypeLiteralNode(otherMembers)] : emptyArray
|
|
]);
|
|
changes.replaceNode(sourceFile, container, createTypeAliasFromInterface(container, intersectionType));
|
|
}
|
|
|
|
// src/services/codefixes/removeAccidentalCallParentheses.ts
|
|
var fixId46 = "removeAccidentalCallParentheses";
|
|
var errorCodes58 = [
|
|
Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes58,
|
|
getCodeActions(context) {
|
|
const callExpression = findAncestor(getTokenAtPosition(context.sourceFile, context.span.start), isCallExpression);
|
|
if (!callExpression) {
|
|
return void 0;
|
|
}
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end });
|
|
});
|
|
return [createCodeFixActionWithoutFixAll(fixId46, changes, Diagnostics.Remove_parentheses)];
|
|
},
|
|
fixIds: [fixId46]
|
|
});
|
|
|
|
// src/services/codefixes/removeUnnecessaryAwait.ts
|
|
var fixId47 = "removeUnnecessaryAwait";
|
|
var errorCodes59 = [
|
|
Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes59,
|
|
getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange10(t, context.sourceFile, context.span));
|
|
if (changes.length > 0) {
|
|
return [createCodeFixAction(fixId47, changes, Diagnostics.Remove_unnecessary_await, fixId47, Diagnostics.Remove_all_unnecessary_uses_of_await)];
|
|
}
|
|
},
|
|
fixIds: [fixId47],
|
|
getAllCodeActions: (context) => {
|
|
return codeFixAll(context, errorCodes59, (changes, diag2) => makeChange10(changes, diag2.file, diag2));
|
|
}
|
|
});
|
|
function makeChange10(changeTracker, sourceFile, span) {
|
|
const awaitKeyword = tryCast(getTokenAtPosition(sourceFile, span.start), (node) => node.kind === 133 /* AwaitKeyword */);
|
|
const awaitExpression = awaitKeyword && tryCast(awaitKeyword.parent, isAwaitExpression);
|
|
if (!awaitExpression) {
|
|
return;
|
|
}
|
|
let expressionToReplace = awaitExpression;
|
|
const hasSurroundingParens = isParenthesizedExpression(awaitExpression.parent);
|
|
if (hasSurroundingParens) {
|
|
const leftMostExpression = getLeftmostExpression(awaitExpression.expression, false);
|
|
if (isIdentifier(leftMostExpression)) {
|
|
const precedingToken = findPrecedingToken(awaitExpression.parent.pos, sourceFile);
|
|
if (precedingToken && precedingToken.kind !== 103 /* NewKeyword */) {
|
|
expressionToReplace = awaitExpression.parent;
|
|
}
|
|
}
|
|
}
|
|
changeTracker.replaceNode(sourceFile, expressionToReplace, awaitExpression.expression);
|
|
}
|
|
|
|
// src/services/codefixes/splitTypeOnlyImport.ts
|
|
var errorCodes60 = [Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code];
|
|
var fixId48 = "splitTypeOnlyImport";
|
|
registerCodeFix({
|
|
errorCodes: errorCodes60,
|
|
fixIds: [fixId48],
|
|
getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
return splitTypeOnlyImport(t, getImportDeclaration2(context.sourceFile, context.span), context);
|
|
});
|
|
if (changes.length) {
|
|
return [createCodeFixAction(fixId48, changes, Diagnostics.Split_into_two_separate_import_declarations, fixId48, Diagnostics.Split_all_invalid_type_only_imports)];
|
|
}
|
|
},
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes60, (changes, error) => {
|
|
splitTypeOnlyImport(changes, getImportDeclaration2(context.sourceFile, error), context);
|
|
})
|
|
});
|
|
function getImportDeclaration2(sourceFile, span) {
|
|
return findAncestor(getTokenAtPosition(sourceFile, span.start), isImportDeclaration);
|
|
}
|
|
function splitTypeOnlyImport(changes, importDeclaration, context) {
|
|
if (!importDeclaration) {
|
|
return;
|
|
}
|
|
const importClause = Debug.checkDefined(importDeclaration.importClause);
|
|
changes.replaceNode(context.sourceFile, importDeclaration, factory.updateImportDeclaration(
|
|
importDeclaration,
|
|
importDeclaration.modifiers,
|
|
factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, void 0),
|
|
importDeclaration.moduleSpecifier,
|
|
importDeclaration.assertClause
|
|
));
|
|
changes.insertNodeAfter(context.sourceFile, importDeclaration, factory.createImportDeclaration(
|
|
void 0,
|
|
factory.updateImportClause(importClause, importClause.isTypeOnly, void 0, importClause.namedBindings),
|
|
importDeclaration.moduleSpecifier,
|
|
importDeclaration.assertClause
|
|
));
|
|
}
|
|
|
|
// src/services/codefixes/convertConstToLet.ts
|
|
var fixId49 = "fixConvertConstToLet";
|
|
var errorCodes61 = [Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes61,
|
|
getCodeActions: function getCodeActionsToConvertConstToLet(context) {
|
|
const { sourceFile, span, program } = context;
|
|
const info = getInfo17(sourceFile, span.start, program);
|
|
if (info === void 0)
|
|
return;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange31(t, sourceFile, info.token));
|
|
return [createCodeFixActionMaybeFixAll(fixId49, changes, Diagnostics.Convert_const_to_let, fixId49, Diagnostics.Convert_all_const_to_let)];
|
|
},
|
|
getAllCodeActions: (context) => {
|
|
const { program } = context;
|
|
const seen = /* @__PURE__ */ new Map();
|
|
return createCombinedCodeActions(ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
eachDiagnostic(context, errorCodes61, (diag2) => {
|
|
const info = getInfo17(diag2.file, diag2.start, program);
|
|
if (info) {
|
|
if (addToSeen(seen, getSymbolId(info.symbol))) {
|
|
return doChange31(changes, diag2.file, info.token);
|
|
}
|
|
}
|
|
return void 0;
|
|
});
|
|
}));
|
|
},
|
|
fixIds: [fixId49]
|
|
});
|
|
function getInfo17(sourceFile, pos, program) {
|
|
var _a2;
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(getTokenAtPosition(sourceFile, pos));
|
|
if (symbol === void 0)
|
|
return;
|
|
const declaration = tryCast((_a2 = symbol == null ? void 0 : symbol.valueDeclaration) == null ? void 0 : _a2.parent, isVariableDeclarationList);
|
|
if (declaration === void 0)
|
|
return;
|
|
const constToken = findChildOfKind(declaration, 85 /* ConstKeyword */, sourceFile);
|
|
if (constToken === void 0)
|
|
return;
|
|
return { symbol, token: constToken };
|
|
}
|
|
function doChange31(changes, sourceFile, token) {
|
|
changes.replaceNode(sourceFile, token, factory.createToken(119 /* LetKeyword */));
|
|
}
|
|
|
|
// src/services/codefixes/fixExpectedComma.ts
|
|
var fixId50 = "fixExpectedComma";
|
|
var expectedErrorCode = Diagnostics._0_expected.code;
|
|
var errorCodes62 = [expectedErrorCode];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes62,
|
|
getCodeActions(context) {
|
|
const { sourceFile } = context;
|
|
const info = getInfo18(sourceFile, context.span.start, context.errorCode);
|
|
if (!info)
|
|
return void 0;
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange32(t, sourceFile, info));
|
|
return [createCodeFixAction(
|
|
fixId50,
|
|
changes,
|
|
[Diagnostics.Change_0_to_1, ";", ","],
|
|
fixId50,
|
|
[Diagnostics.Change_0_to_1, ";", ","]
|
|
)];
|
|
},
|
|
fixIds: [fixId50],
|
|
getAllCodeActions: (context) => codeFixAll(context, errorCodes62, (changes, diag2) => {
|
|
const info = getInfo18(diag2.file, diag2.start, diag2.code);
|
|
if (info)
|
|
doChange32(changes, context.sourceFile, info);
|
|
})
|
|
});
|
|
function getInfo18(sourceFile, pos, _) {
|
|
const node = getTokenAtPosition(sourceFile, pos);
|
|
return node.kind === 26 /* SemicolonToken */ && node.parent && (isObjectLiteralExpression(node.parent) || isArrayLiteralExpression(node.parent)) ? { node } : void 0;
|
|
}
|
|
function doChange32(changes, sourceFile, { node }) {
|
|
const newNode = factory.createToken(27 /* CommaToken */);
|
|
changes.replaceNode(sourceFile, node, newNode);
|
|
}
|
|
|
|
// src/services/codefixes/fixAddVoidToPromise.ts
|
|
var fixName7 = "addVoidToPromise";
|
|
var fixId51 = "addVoidToPromise";
|
|
var errorCodes63 = [
|
|
Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code,
|
|
Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code
|
|
];
|
|
registerCodeFix({
|
|
errorCodes: errorCodes63,
|
|
fixIds: [fixId51],
|
|
getCodeActions(context) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(context, (t) => makeChange11(t, context.sourceFile, context.span, context.program));
|
|
if (changes.length > 0) {
|
|
return [createCodeFixAction(fixName7, changes, Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId51, Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)];
|
|
}
|
|
},
|
|
getAllCodeActions(context) {
|
|
return codeFixAll(context, errorCodes63, (changes, diag2) => makeChange11(changes, diag2.file, diag2, context.program, /* @__PURE__ */ new Set()));
|
|
}
|
|
});
|
|
function makeChange11(changes, sourceFile, span, program, seen) {
|
|
const node = getTokenAtPosition(sourceFile, span.start);
|
|
if (!isIdentifier(node) || !isCallExpression(node.parent) || node.parent.expression !== node || node.parent.arguments.length !== 0)
|
|
return;
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
const decl = symbol == null ? void 0 : symbol.valueDeclaration;
|
|
if (!decl || !isParameter(decl) || !isNewExpression(decl.parent.parent))
|
|
return;
|
|
if (seen == null ? void 0 : seen.has(decl))
|
|
return;
|
|
seen == null ? void 0 : seen.add(decl);
|
|
const typeArguments = getEffectiveTypeArguments(decl.parent.parent);
|
|
if (some(typeArguments)) {
|
|
const typeArgument = typeArguments[0];
|
|
const needsParens = !isUnionTypeNode(typeArgument) && !isParenthesizedTypeNode(typeArgument) && isParenthesizedTypeNode(factory.createUnionTypeNode([typeArgument, factory.createKeywordTypeNode(114 /* VoidKeyword */)]).types[0]);
|
|
if (needsParens) {
|
|
changes.insertText(sourceFile, typeArgument.pos, "(");
|
|
}
|
|
changes.insertText(sourceFile, typeArgument.end, needsParens ? ") | void" : " | void");
|
|
} else {
|
|
const signature = checker.getResolvedSignature(node.parent);
|
|
const parameter = signature == null ? void 0 : signature.parameters[0];
|
|
const parameterType = parameter && checker.getTypeOfSymbolAtLocation(parameter, decl.parent.parent);
|
|
if (isInJSFile(decl)) {
|
|
if (!parameterType || parameterType.flags & 3 /* AnyOrUnknown */) {
|
|
changes.insertText(sourceFile, decl.parent.parent.end, `)`);
|
|
changes.insertText(sourceFile, skipTrivia(sourceFile.text, decl.parent.parent.pos), `/** @type {Promise<void>} */(`);
|
|
}
|
|
} else {
|
|
if (!parameterType || parameterType.flags & 2 /* Unknown */) {
|
|
changes.insertText(sourceFile, decl.parent.parent.expression.end, "<void>");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getEffectiveTypeArguments(node) {
|
|
var _a2;
|
|
if (isInJSFile(node)) {
|
|
if (isParenthesizedExpression(node.parent)) {
|
|
const jsDocType = (_a2 = getJSDocTypeTag(node.parent)) == null ? void 0 : _a2.typeExpression.type;
|
|
if (jsDocType && isTypeReferenceNode(jsDocType) && isIdentifier(jsDocType.typeName) && idText(jsDocType.typeName) === "Promise") {
|
|
return jsDocType.typeArguments;
|
|
}
|
|
}
|
|
} else {
|
|
return node.typeArguments;
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.Completions.ts
|
|
var ts_Completions_exports = {};
|
|
__export(ts_Completions_exports, {
|
|
CompletionKind: () => CompletionKind,
|
|
CompletionSource: () => CompletionSource,
|
|
SortText: () => SortText,
|
|
StringCompletions: () => ts_Completions_StringCompletions_exports,
|
|
SymbolOriginInfoKind: () => SymbolOriginInfoKind,
|
|
createCompletionDetails: () => createCompletionDetails,
|
|
createCompletionDetailsForSymbol: () => createCompletionDetailsForSymbol,
|
|
getCompletionEntriesFromSymbols: () => getCompletionEntriesFromSymbols,
|
|
getCompletionEntryDetails: () => getCompletionEntryDetails,
|
|
getCompletionEntrySymbol: () => getCompletionEntrySymbol,
|
|
getCompletionsAtPosition: () => getCompletionsAtPosition,
|
|
getPropertiesForObjectExpression: () => getPropertiesForObjectExpression,
|
|
moduleSpecifierResolutionCacheAttemptLimit: () => moduleSpecifierResolutionCacheAttemptLimit,
|
|
moduleSpecifierResolutionLimit: () => moduleSpecifierResolutionLimit
|
|
});
|
|
|
|
// src/services/completions.ts
|
|
var moduleSpecifierResolutionLimit = 100;
|
|
var moduleSpecifierResolutionCacheAttemptLimit = 1e3;
|
|
var SortText = {
|
|
LocalDeclarationPriority: "10",
|
|
LocationPriority: "11",
|
|
OptionalMember: "12",
|
|
MemberDeclaredBySpreadAssignment: "13",
|
|
SuggestedClassMembers: "14",
|
|
GlobalsOrKeywords: "15",
|
|
AutoImportSuggestions: "16",
|
|
ClassMemberSnippets: "17",
|
|
JavascriptIdentifiers: "18",
|
|
Deprecated(sortText) {
|
|
return "z" + sortText;
|
|
},
|
|
ObjectLiteralProperty(presetSortText, symbolDisplayName) {
|
|
return `${presetSortText}\0${symbolDisplayName}\0`;
|
|
},
|
|
SortBelow(sortText) {
|
|
return sortText + "1";
|
|
}
|
|
};
|
|
var CompletionSource = /* @__PURE__ */ ((CompletionSource2) => {
|
|
CompletionSource2["ThisProperty"] = "ThisProperty/";
|
|
CompletionSource2["ClassMemberSnippet"] = "ClassMemberSnippet/";
|
|
CompletionSource2["TypeOnlyAlias"] = "TypeOnlyAlias/";
|
|
CompletionSource2["ObjectLiteralMethodSnippet"] = "ObjectLiteralMethodSnippet/";
|
|
return CompletionSource2;
|
|
})(CompletionSource || {});
|
|
var SymbolOriginInfoKind = /* @__PURE__ */ ((SymbolOriginInfoKind2) => {
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["ThisType"] = 1] = "ThisType";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMember"] = 2] = "SymbolMember";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["Export"] = 4] = "Export";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["Promise"] = 8] = "Promise";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["Nullable"] = 16] = "Nullable";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["ResolvedExport"] = 32] = "ResolvedExport";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["TypeOnlyAlias"] = 64] = "TypeOnlyAlias";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["ObjectLiteralMethod"] = 128] = "ObjectLiteralMethod";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMemberNoExport"] = 2 /* SymbolMember */] = "SymbolMemberNoExport";
|
|
SymbolOriginInfoKind2[SymbolOriginInfoKind2["SymbolMemberExport"] = 6] = "SymbolMemberExport";
|
|
return SymbolOriginInfoKind2;
|
|
})(SymbolOriginInfoKind || {});
|
|
function originIsThisType(origin) {
|
|
return !!(origin.kind & 1 /* ThisType */);
|
|
}
|
|
function originIsSymbolMember(origin) {
|
|
return !!(origin.kind & 2 /* SymbolMember */);
|
|
}
|
|
function originIsExport(origin) {
|
|
return !!(origin && origin.kind & 4 /* Export */);
|
|
}
|
|
function originIsResolvedExport(origin) {
|
|
return !!(origin && origin.kind === 32 /* ResolvedExport */);
|
|
}
|
|
function originIncludesSymbolName(origin) {
|
|
return originIsExport(origin) || originIsResolvedExport(origin);
|
|
}
|
|
function originIsPackageJsonImport(origin) {
|
|
return (originIsExport(origin) || originIsResolvedExport(origin)) && !!origin.isFromPackageJson;
|
|
}
|
|
function originIsPromise(origin) {
|
|
return !!(origin.kind & 8 /* Promise */);
|
|
}
|
|
function originIsNullableMember(origin) {
|
|
return !!(origin.kind & 16 /* Nullable */);
|
|
}
|
|
function originIsTypeOnlyAlias(origin) {
|
|
return !!(origin && origin.kind & 64 /* TypeOnlyAlias */);
|
|
}
|
|
function originIsObjectLiteralMethod(origin) {
|
|
return !!(origin && origin.kind & 128 /* ObjectLiteralMethod */);
|
|
}
|
|
function resolvingModuleSpecifiers(logPrefix, host, resolver, program, position, preferences, isForImportStatementCompletion, isValidTypeOnlyUseSite, cb) {
|
|
var _a2, _b, _c;
|
|
const start2 = timestamp();
|
|
const needsFullResolution = isForImportStatementCompletion || moduleResolutionRespectsExports(getEmitModuleResolutionKind(program.getCompilerOptions()));
|
|
let skippedAny = false;
|
|
let ambientCount = 0;
|
|
let resolvedCount = 0;
|
|
let resolvedFromCacheCount = 0;
|
|
let cacheAttemptCount = 0;
|
|
const result = cb({
|
|
tryResolve,
|
|
skippedAny: () => skippedAny,
|
|
resolvedAny: () => resolvedCount > 0,
|
|
resolvedBeyondLimit: () => resolvedCount > moduleSpecifierResolutionLimit
|
|
});
|
|
const hitRateMessage = cacheAttemptCount ? ` (${(resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1)}% hit rate)` : "";
|
|
(_a2 = host.log) == null ? void 0 : _a2.call(host, `${logPrefix}: resolved ${resolvedCount} module specifiers, plus ${ambientCount} ambient and ${resolvedFromCacheCount} from cache${hitRateMessage}`);
|
|
(_b = host.log) == null ? void 0 : _b.call(host, `${logPrefix}: response is ${skippedAny ? "incomplete" : "complete"}`);
|
|
(_c = host.log) == null ? void 0 : _c.call(host, `${logPrefix}: ${timestamp() - start2}`);
|
|
return result;
|
|
function tryResolve(exportInfo, symbolName2, isFromAmbientModule) {
|
|
if (isFromAmbientModule) {
|
|
const result3 = resolver.getModuleSpecifierForBestExportInfo(exportInfo, symbolName2, position, isValidTypeOnlyUseSite);
|
|
if (result3) {
|
|
ambientCount++;
|
|
}
|
|
return result3 || "failed";
|
|
}
|
|
const shouldResolveModuleSpecifier = needsFullResolution || preferences.allowIncompleteCompletions && resolvedCount < moduleSpecifierResolutionLimit;
|
|
const shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < moduleSpecifierResolutionCacheAttemptLimit;
|
|
const result2 = shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache ? resolver.getModuleSpecifierForBestExportInfo(exportInfo, symbolName2, position, isValidTypeOnlyUseSite, shouldGetModuleSpecifierFromCache) : void 0;
|
|
if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result2) {
|
|
skippedAny = true;
|
|
}
|
|
resolvedCount += (result2 == null ? void 0 : result2.computedWithoutCacheCount) || 0;
|
|
resolvedFromCacheCount += exportInfo.length - ((result2 == null ? void 0 : result2.computedWithoutCacheCount) || 0);
|
|
if (shouldGetModuleSpecifierFromCache) {
|
|
cacheAttemptCount++;
|
|
}
|
|
return result2 || (needsFullResolution ? "failed" : "skipped");
|
|
}
|
|
}
|
|
function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext) {
|
|
var _a2;
|
|
const { previousToken } = getRelevantTokens(position, sourceFile);
|
|
if (triggerCharacter && !isInString(sourceFile, position, previousToken) && !isValidTrigger(sourceFile, triggerCharacter, previousToken, position)) {
|
|
return void 0;
|
|
}
|
|
if (triggerCharacter === " ") {
|
|
if (preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
|
|
return { isGlobalCompletion: true, isMemberCompletion: false, isNewIdentifierLocation: true, isIncomplete: true, entries: [] };
|
|
}
|
|
return void 0;
|
|
}
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const incompleteCompletionsCache = preferences.allowIncompleteCompletions ? (_a2 = host.getIncompleteCompletionsCache) == null ? void 0 : _a2.call(host) : void 0;
|
|
if (incompleteCompletionsCache && completionKind === 3 /* TriggerForIncompleteCompletions */ && previousToken && isIdentifier(previousToken)) {
|
|
const incompleteContinuation = continuePreviousIncompleteResponse(incompleteCompletionsCache, sourceFile, previousToken, program, host, preferences, cancellationToken);
|
|
if (incompleteContinuation) {
|
|
return incompleteContinuation;
|
|
}
|
|
} else {
|
|
incompleteCompletionsCache == null ? void 0 : incompleteCompletionsCache.clear();
|
|
}
|
|
const stringCompletions = ts_Completions_StringCompletions_exports.getStringLiteralCompletions(sourceFile, position, previousToken, compilerOptions, host, program, log, preferences);
|
|
if (stringCompletions) {
|
|
return stringCompletions;
|
|
}
|
|
if (previousToken && isBreakOrContinueStatement(previousToken.parent) && (previousToken.kind === 81 /* BreakKeyword */ || previousToken.kind === 86 /* ContinueKeyword */ || previousToken.kind === 79 /* Identifier */)) {
|
|
return getLabelCompletionAtPosition(previousToken.parent);
|
|
}
|
|
const completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, void 0, host, formatContext, cancellationToken);
|
|
if (!completionData) {
|
|
return void 0;
|
|
}
|
|
switch (completionData.kind) {
|
|
case CompletionDataKind.Data:
|
|
const response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position);
|
|
if (response == null ? void 0 : response.isIncomplete) {
|
|
incompleteCompletionsCache == null ? void 0 : incompleteCompletionsCache.set(response);
|
|
}
|
|
return response;
|
|
case CompletionDataKind.JsDocTagName:
|
|
return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagNameCompletions());
|
|
case CompletionDataKind.JsDocTag:
|
|
return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocTagCompletions());
|
|
case CompletionDataKind.JsDocParameterName:
|
|
return jsdocCompletionInfo(ts_JsDoc_exports.getJSDocParameterNameCompletions(completionData.tag));
|
|
case CompletionDataKind.Keywords:
|
|
return specificKeywordCompletionInfo(completionData.keywordCompletions, completionData.isNewIdentifierLocation);
|
|
default:
|
|
return Debug.assertNever(completionData);
|
|
}
|
|
}
|
|
function compareCompletionEntries(entryInArray, entryToInsert) {
|
|
var _a2, _b;
|
|
let result = compareStringsCaseSensitiveUI(entryInArray.sortText, entryToInsert.sortText);
|
|
if (result === 0 /* EqualTo */) {
|
|
result = compareStringsCaseSensitiveUI(entryInArray.name, entryToInsert.name);
|
|
}
|
|
if (result === 0 /* EqualTo */ && ((_a2 = entryInArray.data) == null ? void 0 : _a2.moduleSpecifier) && ((_b = entryToInsert.data) == null ? void 0 : _b.moduleSpecifier)) {
|
|
result = compareNumberOfDirectorySeparators(
|
|
entryInArray.data.moduleSpecifier,
|
|
entryToInsert.data.moduleSpecifier
|
|
);
|
|
}
|
|
if (result === 0 /* EqualTo */) {
|
|
return -1 /* LessThan */;
|
|
}
|
|
return result;
|
|
}
|
|
function completionEntryDataIsResolved(data) {
|
|
return !!(data == null ? void 0 : data.moduleSpecifier);
|
|
}
|
|
function continuePreviousIncompleteResponse(cache, file, location2, program, host, preferences, cancellationToken) {
|
|
const previousResponse = cache.get();
|
|
if (!previousResponse)
|
|
return void 0;
|
|
const lowerCaseTokenText = location2.text.toLowerCase();
|
|
const exportMap = getExportInfoMap(file, host, program, preferences, cancellationToken);
|
|
const newEntries = resolvingModuleSpecifiers(
|
|
"continuePreviousIncompleteResponse",
|
|
host,
|
|
ts_codefix_exports.createImportSpecifierResolver(file, program, host, preferences),
|
|
program,
|
|
location2.getStart(),
|
|
preferences,
|
|
false,
|
|
isValidTypeOnlyAliasUseSite(location2),
|
|
(context) => {
|
|
const entries = mapDefined(previousResponse.entries, (entry) => {
|
|
var _a2;
|
|
if (!entry.hasAction || !entry.source || !entry.data || completionEntryDataIsResolved(entry.data)) {
|
|
return entry;
|
|
}
|
|
if (!charactersFuzzyMatchInString(entry.name, lowerCaseTokenText)) {
|
|
return void 0;
|
|
}
|
|
const { origin } = Debug.checkDefined(getAutoImportSymbolFromCompletionEntryData(entry.name, entry.data, program, host));
|
|
const info = exportMap.get(file.path, entry.data.exportMapKey);
|
|
const result = info && context.tryResolve(info, entry.name, !isExternalModuleNameRelative(stripQuotes(origin.moduleSymbol.name)));
|
|
if (result === "skipped")
|
|
return entry;
|
|
if (!result || result === "failed") {
|
|
(_a2 = host.log) == null ? void 0 : _a2.call(host, `Unexpected failure resolving auto import for '${entry.name}' from '${entry.source}'`);
|
|
return void 0;
|
|
}
|
|
const newOrigin = {
|
|
...origin,
|
|
kind: 32 /* ResolvedExport */,
|
|
moduleSpecifier: result.moduleSpecifier
|
|
};
|
|
entry.data = originToCompletionEntryData(newOrigin);
|
|
entry.source = getSourceFromOrigin(newOrigin);
|
|
entry.sourceDisplay = [textPart(newOrigin.moduleSpecifier)];
|
|
return entry;
|
|
});
|
|
if (!context.skippedAny()) {
|
|
previousResponse.isIncomplete = void 0;
|
|
}
|
|
return entries;
|
|
}
|
|
);
|
|
previousResponse.entries = newEntries;
|
|
previousResponse.flags = (previousResponse.flags || 0) | 4 /* IsContinuation */;
|
|
return previousResponse;
|
|
}
|
|
function jsdocCompletionInfo(entries) {
|
|
return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
|
|
}
|
|
function keywordToCompletionEntry(keyword) {
|
|
return {
|
|
name: tokenToString(keyword),
|
|
kind: "keyword" /* keyword */,
|
|
kindModifiers: "" /* none */,
|
|
sortText: SortText.GlobalsOrKeywords
|
|
};
|
|
}
|
|
function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) {
|
|
return {
|
|
isGlobalCompletion: false,
|
|
isMemberCompletion: false,
|
|
isNewIdentifierLocation,
|
|
entries: entries.slice()
|
|
};
|
|
}
|
|
function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) {
|
|
return {
|
|
kind: CompletionDataKind.Keywords,
|
|
keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords),
|
|
isNewIdentifierLocation
|
|
};
|
|
}
|
|
function keywordFiltersFromSyntaxKind(keywordCompletion) {
|
|
switch (keywordCompletion) {
|
|
case 154 /* TypeKeyword */:
|
|
return 8 /* TypeKeyword */;
|
|
default:
|
|
Debug.fail("Unknown mapping from SyntaxKind to KeywordCompletionFilters");
|
|
}
|
|
}
|
|
function getOptionalReplacementSpan(location2) {
|
|
return (location2 == null ? void 0 : location2.kind) === 79 /* Identifier */ ? createTextSpanFromNode(location2) : void 0;
|
|
}
|
|
function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position) {
|
|
const {
|
|
symbols,
|
|
contextToken,
|
|
completionKind,
|
|
isInSnippetScope,
|
|
isNewIdentifierLocation,
|
|
location: location2,
|
|
propertyAccessToConvert,
|
|
keywordFilters,
|
|
literals,
|
|
symbolToOriginInfoMap,
|
|
recommendedCompletion,
|
|
isJsxInitializer,
|
|
isTypeOnlyLocation,
|
|
isJsxIdentifierExpected,
|
|
isRightOfOpenTag,
|
|
importStatementCompletion,
|
|
insideJsDocTagTypeExpression,
|
|
symbolToSortTextMap,
|
|
hasUnresolvedAutoImports
|
|
} = completionData;
|
|
if (getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
|
|
const completionInfo = getJsxClosingTagCompletion(location2, sourceFile);
|
|
if (completionInfo) {
|
|
return completionInfo;
|
|
}
|
|
}
|
|
const entries = createSortedArray();
|
|
const isChecked = isCheckedFile(sourceFile, compilerOptions);
|
|
if (isChecked && !isNewIdentifierLocation && (!symbols || symbols.length === 0) && keywordFilters === 0 /* None */) {
|
|
return void 0;
|
|
}
|
|
const uniqueNames = getCompletionEntriesFromSymbols(
|
|
symbols,
|
|
entries,
|
|
void 0,
|
|
contextToken,
|
|
location2,
|
|
sourceFile,
|
|
host,
|
|
program,
|
|
getEmitScriptTarget(compilerOptions),
|
|
log,
|
|
completionKind,
|
|
preferences,
|
|
compilerOptions,
|
|
formatContext,
|
|
isTypeOnlyLocation,
|
|
propertyAccessToConvert,
|
|
isJsxIdentifierExpected,
|
|
isJsxInitializer,
|
|
importStatementCompletion,
|
|
recommendedCompletion,
|
|
symbolToOriginInfoMap,
|
|
symbolToSortTextMap,
|
|
isJsxIdentifierExpected,
|
|
isRightOfOpenTag
|
|
);
|
|
if (keywordFilters !== 0 /* None */) {
|
|
for (const keywordEntry of getKeywordCompletions(keywordFilters, !insideJsDocTagTypeExpression && isSourceFileJS(sourceFile))) {
|
|
if (isTypeOnlyLocation && isTypeKeyword(stringToToken(keywordEntry.name)) || !uniqueNames.has(keywordEntry.name)) {
|
|
uniqueNames.add(keywordEntry.name);
|
|
insertSorted(entries, keywordEntry, compareCompletionEntries, true);
|
|
}
|
|
}
|
|
}
|
|
for (const keywordEntry of getContextualKeywords(contextToken, position)) {
|
|
if (!uniqueNames.has(keywordEntry.name)) {
|
|
uniqueNames.add(keywordEntry.name);
|
|
insertSorted(entries, keywordEntry, compareCompletionEntries, true);
|
|
}
|
|
}
|
|
for (const literal of literals) {
|
|
const literalEntry = createCompletionEntryForLiteral(sourceFile, preferences, literal);
|
|
uniqueNames.add(literalEntry.name);
|
|
insertSorted(entries, literalEntry, compareCompletionEntries, true);
|
|
}
|
|
if (!isChecked) {
|
|
getJSCompletionEntries(sourceFile, location2.pos, uniqueNames, getEmitScriptTarget(compilerOptions), entries);
|
|
}
|
|
return {
|
|
flags: completionData.flags,
|
|
isGlobalCompletion: isInSnippetScope,
|
|
isIncomplete: preferences.allowIncompleteCompletions && hasUnresolvedAutoImports ? true : void 0,
|
|
isMemberCompletion: isMemberCompletionKind(completionKind),
|
|
isNewIdentifierLocation,
|
|
optionalReplacementSpan: getOptionalReplacementSpan(location2),
|
|
entries
|
|
};
|
|
}
|
|
function isCheckedFile(sourceFile, compilerOptions) {
|
|
return !isSourceFileJS(sourceFile) || !!isCheckJsEnabledForFile(sourceFile, compilerOptions);
|
|
}
|
|
function isMemberCompletionKind(kind) {
|
|
switch (kind) {
|
|
case CompletionKind.ObjectPropertyDeclaration:
|
|
case CompletionKind.MemberLike:
|
|
case CompletionKind.PropertyAccess:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getJsxClosingTagCompletion(location2, sourceFile) {
|
|
const jsxClosingElement = findAncestor(location2, (node) => {
|
|
switch (node.kind) {
|
|
case 284 /* JsxClosingElement */:
|
|
return true;
|
|
case 43 /* SlashToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
case 79 /* Identifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
return false;
|
|
default:
|
|
return "quit";
|
|
}
|
|
});
|
|
if (jsxClosingElement) {
|
|
const hasClosingAngleBracket = !!findChildOfKind(jsxClosingElement, 31 /* GreaterThanToken */, sourceFile);
|
|
const tagName = jsxClosingElement.parent.openingElement.tagName;
|
|
const closingTag = tagName.getText(sourceFile);
|
|
const fullClosingTag = closingTag + (hasClosingAngleBracket ? "" : ">");
|
|
const replacementSpan = createTextSpanFromNode(jsxClosingElement.tagName);
|
|
const entry = {
|
|
name: fullClosingTag,
|
|
kind: "class" /* classElement */,
|
|
kindModifiers: void 0,
|
|
sortText: SortText.LocationPriority
|
|
};
|
|
return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false, optionalReplacementSpan: replacementSpan, entries: [entry] };
|
|
}
|
|
return;
|
|
}
|
|
function getJSCompletionEntries(sourceFile, position, uniqueNames, target, entries) {
|
|
getNameTable(sourceFile).forEach((pos, name) => {
|
|
if (pos === position) {
|
|
return;
|
|
}
|
|
const realName = unescapeLeadingUnderscores(name);
|
|
if (!uniqueNames.has(realName) && isIdentifierText(realName, target)) {
|
|
uniqueNames.add(realName);
|
|
insertSorted(entries, {
|
|
name: realName,
|
|
kind: "warning" /* warning */,
|
|
kindModifiers: "",
|
|
sortText: SortText.JavascriptIdentifiers,
|
|
isFromUncheckedFile: true
|
|
}, compareCompletionEntries);
|
|
}
|
|
});
|
|
}
|
|
function completionNameForLiteral(sourceFile, preferences, literal) {
|
|
return typeof literal === "object" ? pseudoBigIntToString(literal) + "n" : isString(literal) ? quote(sourceFile, preferences, literal) : JSON.stringify(literal);
|
|
}
|
|
function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
|
|
return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
|
|
}
|
|
function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location2, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) {
|
|
let insertText;
|
|
let replacementSpan = getReplacementSpanForContextToken(replacementToken);
|
|
let data;
|
|
let isSnippet;
|
|
let source = getSourceFromOrigin(origin);
|
|
let sourceDisplay;
|
|
let hasAction;
|
|
let labelDetails;
|
|
const typeChecker = program.getTypeChecker();
|
|
const insertQuestionDot = origin && originIsNullableMember(origin);
|
|
const useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess;
|
|
if (origin && originIsThisType(origin)) {
|
|
insertText = needsConvertPropertyAccess ? `this${insertQuestionDot ? "?." : ""}[${quotePropertyName(sourceFile, preferences, name)}]` : `this${insertQuestionDot ? "?." : "."}${name}`;
|
|
} else if ((useBraces || insertQuestionDot) && propertyAccessToConvert) {
|
|
insertText = useBraces ? needsConvertPropertyAccess ? `[${quotePropertyName(sourceFile, preferences, name)}]` : `[${name}]` : name;
|
|
if (insertQuestionDot || propertyAccessToConvert.questionDotToken) {
|
|
insertText = `?.${insertText}`;
|
|
}
|
|
const dot = findChildOfKind(propertyAccessToConvert, 24 /* DotToken */, sourceFile) || findChildOfKind(propertyAccessToConvert, 28 /* QuestionDotToken */, sourceFile);
|
|
if (!dot) {
|
|
return void 0;
|
|
}
|
|
const end = startsWith(name, propertyAccessToConvert.name.text) ? propertyAccessToConvert.name.end : dot.end;
|
|
replacementSpan = createTextSpanFromBounds(dot.getStart(sourceFile), end);
|
|
}
|
|
if (isJsxInitializer) {
|
|
if (insertText === void 0)
|
|
insertText = name;
|
|
insertText = `{${insertText}}`;
|
|
if (typeof isJsxInitializer !== "boolean") {
|
|
replacementSpan = createTextSpanFromNode(isJsxInitializer, sourceFile);
|
|
}
|
|
}
|
|
if (origin && originIsPromise(origin) && propertyAccessToConvert) {
|
|
if (insertText === void 0)
|
|
insertText = name;
|
|
const precedingToken = findPrecedingToken(propertyAccessToConvert.pos, sourceFile);
|
|
let awaitText = "";
|
|
if (precedingToken && positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) {
|
|
awaitText = ";";
|
|
}
|
|
awaitText += `(await ${propertyAccessToConvert.expression.getText()})`;
|
|
insertText = needsConvertPropertyAccess ? `${awaitText}${insertText}` : `${awaitText}${insertQuestionDot ? "?." : "."}${insertText}`;
|
|
replacementSpan = createTextSpanFromBounds(propertyAccessToConvert.getStart(sourceFile), propertyAccessToConvert.end);
|
|
}
|
|
if (originIsResolvedExport(origin)) {
|
|
sourceDisplay = [textPart(origin.moduleSpecifier)];
|
|
if (importStatementCompletion) {
|
|
({ insertText, replacementSpan } = getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences));
|
|
isSnippet = preferences.includeCompletionsWithSnippetText ? true : void 0;
|
|
}
|
|
}
|
|
if ((origin == null ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
|
|
hasAction = true;
|
|
}
|
|
if (preferences.includeCompletionsWithClassMemberSnippets && preferences.includeCompletionsWithInsertText && completionKind === CompletionKind.MemberLike && isClassLikeMemberCompletion(symbol, location2, sourceFile)) {
|
|
let importAdder;
|
|
({ insertText, isSnippet, importAdder, replacementSpan } = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location2, contextToken, formatContext));
|
|
sortText = SortText.ClassMemberSnippets;
|
|
if (importAdder == null ? void 0 : importAdder.hasFixes()) {
|
|
hasAction = true;
|
|
source = "ClassMemberSnippet/" /* ClassMemberSnippet */;
|
|
}
|
|
}
|
|
if (origin && originIsObjectLiteralMethod(origin)) {
|
|
({ insertText, isSnippet, labelDetails } = origin);
|
|
if (!preferences.useLabelDetailsInCompletionEntries) {
|
|
name = name + labelDetails.detail;
|
|
labelDetails = void 0;
|
|
}
|
|
source = "ObjectLiteralMethodSnippet/" /* ObjectLiteralMethodSnippet */;
|
|
sortText = SortText.SortBelow(sortText);
|
|
}
|
|
if (isJsxIdentifierExpected && !isRightOfOpenTag && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
|
|
let useBraces2 = preferences.jsxAttributeCompletionStyle === "braces";
|
|
const type = typeChecker.getTypeOfSymbolAtLocation(symbol, location2);
|
|
if (preferences.jsxAttributeCompletionStyle === "auto" && !(type.flags & 528 /* BooleanLike */) && !(type.flags & 1048576 /* Union */ && find(type.types, (type2) => !!(type2.flags & 528 /* BooleanLike */)))) {
|
|
if (type.flags & 402653316 /* StringLike */ || type.flags & 1048576 /* Union */ && every(type.types, (type2) => !!(type2.flags & (402653316 /* StringLike */ | 32768 /* Undefined */)))) {
|
|
insertText = `${escapeSnippetText(name)}=${quote(sourceFile, preferences, "$1")}`;
|
|
isSnippet = true;
|
|
} else {
|
|
useBraces2 = true;
|
|
}
|
|
}
|
|
if (useBraces2) {
|
|
insertText = `${escapeSnippetText(name)}={$1}`;
|
|
isSnippet = true;
|
|
}
|
|
}
|
|
if (insertText !== void 0 && !preferences.includeCompletionsWithInsertText) {
|
|
return void 0;
|
|
}
|
|
if (originIsExport(origin) || originIsResolvedExport(origin)) {
|
|
data = originToCompletionEntryData(origin);
|
|
hasAction = !importStatementCompletion;
|
|
}
|
|
return {
|
|
name,
|
|
kind: ts_SymbolDisplay_exports.getSymbolKind(typeChecker, symbol, location2),
|
|
kindModifiers: ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol),
|
|
sortText,
|
|
source,
|
|
hasAction: hasAction ? true : void 0,
|
|
isRecommended: isRecommendedCompletionMatch(symbol, recommendedCompletion, typeChecker) || void 0,
|
|
insertText,
|
|
replacementSpan,
|
|
sourceDisplay,
|
|
labelDetails,
|
|
isSnippet,
|
|
isPackageJsonImport: originIsPackageJsonImport(origin) || void 0,
|
|
isImportStatementCompletion: !!importStatementCompletion || void 0,
|
|
data
|
|
};
|
|
}
|
|
function isClassLikeMemberCompletion(symbol, location2, sourceFile) {
|
|
if (isInJSFile(location2)) {
|
|
return false;
|
|
}
|
|
const memberFlags = 106500 /* ClassMember */ & 900095 /* EnumMemberExcludes */;
|
|
return !!(symbol.flags & memberFlags) && (isClassLike(location2) || location2.parent && location2.parent.parent && isClassElement(location2.parent) && location2 === location2.parent.name && location2.parent.getLastToken(sourceFile) === location2.parent.name && isClassLike(location2.parent.parent) || location2.parent && isSyntaxList(location2) && isClassLike(location2.parent));
|
|
}
|
|
function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location2, contextToken, formatContext) {
|
|
const classLikeDeclaration = findAncestor(location2, isClassLike);
|
|
if (!classLikeDeclaration) {
|
|
return { insertText: name };
|
|
}
|
|
let isSnippet;
|
|
let replacementSpan;
|
|
let insertText = name;
|
|
const checker = program.getTypeChecker();
|
|
const sourceFile = location2.getSourceFile();
|
|
const printer = createSnippetPrinter({
|
|
removeComments: true,
|
|
module: options.module,
|
|
target: options.target,
|
|
omitTrailingSemicolon: false,
|
|
newLine: getNewLineKind(getNewLineCharacter(options, maybeBind(host, host.getNewLine)))
|
|
});
|
|
const importAdder = ts_codefix_exports.createImportAdder(sourceFile, program, preferences, host);
|
|
let body;
|
|
if (preferences.includeCompletionsWithSnippetText) {
|
|
isSnippet = true;
|
|
const emptyStmt = factory.createEmptyStatement();
|
|
body = factory.createBlock([emptyStmt], true);
|
|
setSnippetElement(emptyStmt, { kind: 0 /* TabStop */, order: 0 });
|
|
} else {
|
|
body = factory.createBlock([], true);
|
|
}
|
|
let modifiers = 0 /* None */;
|
|
const { modifiers: presentModifiers, span: modifiersSpan } = getPresentModifiers(contextToken);
|
|
const isAbstract = !!(presentModifiers & 256 /* Abstract */);
|
|
const completionNodes = [];
|
|
ts_codefix_exports.addNewNodeForMemberSymbol(
|
|
symbol,
|
|
classLikeDeclaration,
|
|
sourceFile,
|
|
{ program, host },
|
|
preferences,
|
|
importAdder,
|
|
(node) => {
|
|
let requiredModifiers = 0 /* None */;
|
|
if (isAbstract) {
|
|
requiredModifiers |= 256 /* Abstract */;
|
|
}
|
|
if (isClassElement(node) && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === 1 /* NeedsOverride */) {
|
|
requiredModifiers |= 16384 /* Override */;
|
|
}
|
|
if (!completionNodes.length) {
|
|
modifiers = node.modifierFlagsCache | requiredModifiers | presentModifiers;
|
|
}
|
|
node = factory.updateModifiers(node, modifiers);
|
|
completionNodes.push(node);
|
|
},
|
|
body,
|
|
ts_codefix_exports.PreserveOptionalFlags.Property,
|
|
isAbstract
|
|
);
|
|
if (completionNodes.length) {
|
|
const format = 1 /* MultiLine */ | 131072 /* NoTrailingNewLine */;
|
|
replacementSpan = modifiersSpan;
|
|
if (formatContext) {
|
|
insertText = printer.printAndFormatSnippetList(
|
|
format,
|
|
factory.createNodeArray(completionNodes),
|
|
sourceFile,
|
|
formatContext
|
|
);
|
|
} else {
|
|
insertText = printer.printSnippetList(
|
|
format,
|
|
factory.createNodeArray(completionNodes),
|
|
sourceFile
|
|
);
|
|
}
|
|
}
|
|
return { insertText, isSnippet, importAdder, replacementSpan };
|
|
}
|
|
function getPresentModifiers(contextToken) {
|
|
if (!contextToken) {
|
|
return { modifiers: 0 /* None */ };
|
|
}
|
|
let modifiers = 0 /* None */;
|
|
let span;
|
|
let contextMod;
|
|
if (contextMod = isModifierLike2(contextToken)) {
|
|
modifiers |= modifierToFlag(contextMod);
|
|
span = createTextSpanFromNode(contextToken);
|
|
}
|
|
if (isPropertyDeclaration(contextToken.parent)) {
|
|
modifiers |= modifiersToFlags(contextToken.parent.modifiers) & 126975 /* Modifier */;
|
|
span = createTextSpanFromNode(contextToken.parent);
|
|
}
|
|
return { modifiers, span };
|
|
}
|
|
function isModifierLike2(node) {
|
|
if (isModifier(node)) {
|
|
return node.kind;
|
|
}
|
|
if (isIdentifier(node) && node.originalKeywordKind && isModifierKind(node.originalKeywordKind)) {
|
|
return node.originalKeywordKind;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclaration, program, host, options, preferences, formatContext) {
|
|
const isSnippet = preferences.includeCompletionsWithSnippetText || void 0;
|
|
let insertText = name;
|
|
const sourceFile = enclosingDeclaration.getSourceFile();
|
|
const method = createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences);
|
|
if (!method) {
|
|
return void 0;
|
|
}
|
|
const printer = createSnippetPrinter({
|
|
removeComments: true,
|
|
module: options.module,
|
|
target: options.target,
|
|
omitTrailingSemicolon: false,
|
|
newLine: getNewLineKind(getNewLineCharacter(options, maybeBind(host, host.getNewLine)))
|
|
});
|
|
if (formatContext) {
|
|
insertText = printer.printAndFormatSnippetList(16 /* CommaDelimited */ | 64 /* AllowTrailingComma */, factory.createNodeArray([method], true), sourceFile, formatContext);
|
|
} else {
|
|
insertText = printer.printSnippetList(16 /* CommaDelimited */ | 64 /* AllowTrailingComma */, factory.createNodeArray([method], true), sourceFile);
|
|
}
|
|
const signaturePrinter = createPrinter({
|
|
removeComments: true,
|
|
module: options.module,
|
|
target: options.target,
|
|
omitTrailingSemicolon: true
|
|
});
|
|
const methodSignature = factory.createMethodSignature(
|
|
void 0,
|
|
"",
|
|
method.questionToken,
|
|
method.typeParameters,
|
|
method.parameters,
|
|
method.type
|
|
);
|
|
const labelDetails = { detail: signaturePrinter.printNode(4 /* Unspecified */, methodSignature, sourceFile) };
|
|
return { isSnippet, insertText, labelDetails };
|
|
}
|
|
function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences) {
|
|
const declarations = symbol.getDeclarations();
|
|
if (!(declarations && declarations.length)) {
|
|
return void 0;
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const declaration = declarations[0];
|
|
const name = getSynthesizedDeepClone(getNameOfDeclaration(declaration), false);
|
|
const type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
|
|
const quotePreference = getQuotePreference(sourceFile, preferences);
|
|
const builderFlags = 33554432 /* OmitThisParameter */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
|
|
switch (declaration.kind) {
|
|
case 168 /* PropertySignature */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 171 /* MethodDeclaration */: {
|
|
let effectiveType = type.flags & 1048576 /* Union */ && type.types.length < 10 ? checker.getUnionType(type.types, 2 /* Subtype */) : type;
|
|
if (effectiveType.flags & 1048576 /* Union */) {
|
|
const functionTypes = filter(effectiveType.types, (type2) => checker.getSignaturesOfType(type2, 0 /* Call */).length > 0);
|
|
if (functionTypes.length === 1) {
|
|
effectiveType = functionTypes[0];
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
const signatures = checker.getSignaturesOfType(effectiveType, 0 /* Call */);
|
|
if (signatures.length !== 1) {
|
|
return void 0;
|
|
}
|
|
const typeNode = checker.typeToTypeNode(effectiveType, enclosingDeclaration, builderFlags, ts_codefix_exports.getNoopSymbolTrackerWithResolver({ program, host }));
|
|
if (!typeNode || !isFunctionTypeNode(typeNode)) {
|
|
return void 0;
|
|
}
|
|
let body;
|
|
if (preferences.includeCompletionsWithSnippetText) {
|
|
const emptyStmt = factory.createEmptyStatement();
|
|
body = factory.createBlock([emptyStmt], true);
|
|
setSnippetElement(emptyStmt, { kind: 0 /* TabStop */, order: 0 });
|
|
} else {
|
|
body = factory.createBlock([], true);
|
|
}
|
|
const parameters = typeNode.parameters.map((typedParam) => factory.createParameterDeclaration(
|
|
void 0,
|
|
typedParam.dotDotDotToken,
|
|
typedParam.name,
|
|
void 0,
|
|
void 0,
|
|
typedParam.initializer
|
|
));
|
|
return factory.createMethodDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
void 0,
|
|
parameters,
|
|
void 0,
|
|
body
|
|
);
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function createSnippetPrinter(printerOptions) {
|
|
let escapes;
|
|
const baseWriter = ts_textChanges_exports.createWriter(getNewLineCharacter(printerOptions));
|
|
const printer = createPrinter(printerOptions, baseWriter);
|
|
const writer = {
|
|
...baseWriter,
|
|
write: (s) => escapingWrite(s, () => baseWriter.write(s)),
|
|
nonEscapingWrite: baseWriter.write,
|
|
writeLiteral: (s) => escapingWrite(s, () => baseWriter.writeLiteral(s)),
|
|
writeStringLiteral: (s) => escapingWrite(s, () => baseWriter.writeStringLiteral(s)),
|
|
writeSymbol: (s, symbol) => escapingWrite(s, () => baseWriter.writeSymbol(s, symbol)),
|
|
writeParameter: (s) => escapingWrite(s, () => baseWriter.writeParameter(s)),
|
|
writeComment: (s) => escapingWrite(s, () => baseWriter.writeComment(s)),
|
|
writeProperty: (s) => escapingWrite(s, () => baseWriter.writeProperty(s))
|
|
};
|
|
return {
|
|
printSnippetList,
|
|
printAndFormatSnippetList
|
|
};
|
|
function escapingWrite(s, write) {
|
|
const escaped = escapeSnippetText(s);
|
|
if (escaped !== s) {
|
|
const start2 = baseWriter.getTextPos();
|
|
write();
|
|
const end = baseWriter.getTextPos();
|
|
escapes = append(escapes || (escapes = []), { newText: escaped, span: { start: start2, length: end - start2 } });
|
|
} else {
|
|
write();
|
|
}
|
|
}
|
|
function printSnippetList(format, list, sourceFile) {
|
|
const unescaped = printUnescapedSnippetList(format, list, sourceFile);
|
|
return escapes ? ts_textChanges_exports.applyChanges(unescaped, escapes) : unescaped;
|
|
}
|
|
function printUnescapedSnippetList(format, list, sourceFile) {
|
|
escapes = void 0;
|
|
writer.clear();
|
|
printer.writeList(format, list, sourceFile, writer);
|
|
return writer.getText();
|
|
}
|
|
function printAndFormatSnippetList(format, list, sourceFile, formatContext) {
|
|
const syntheticFile = {
|
|
text: printUnescapedSnippetList(
|
|
format,
|
|
list,
|
|
sourceFile
|
|
),
|
|
getLineAndCharacterOfPosition(pos) {
|
|
return getLineAndCharacterOfPosition(this, pos);
|
|
}
|
|
};
|
|
const formatOptions = getFormatCodeSettingsForWriting(formatContext, sourceFile);
|
|
const changes = flatMap(list, (node) => {
|
|
const nodeWithPos = ts_textChanges_exports.assignPositionsToNode(node);
|
|
return ts_formatting_exports.formatNodeGivenIndentation(
|
|
nodeWithPos,
|
|
syntheticFile,
|
|
sourceFile.languageVariant,
|
|
0,
|
|
0,
|
|
{ ...formatContext, options: formatOptions }
|
|
);
|
|
});
|
|
const allChanges = escapes ? stableSort(concatenate(changes, escapes), (a, b) => compareTextSpans(a.span, b.span)) : changes;
|
|
return ts_textChanges_exports.applyChanges(syntheticFile.text, allChanges);
|
|
}
|
|
}
|
|
function originToCompletionEntryData(origin) {
|
|
const ambientModuleName = origin.fileName ? void 0 : stripQuotes(origin.moduleSymbol.name);
|
|
const isPackageJsonImport = origin.isFromPackageJson ? true : void 0;
|
|
if (originIsResolvedExport(origin)) {
|
|
const resolvedData = {
|
|
exportName: origin.exportName,
|
|
moduleSpecifier: origin.moduleSpecifier,
|
|
ambientModuleName,
|
|
fileName: origin.fileName,
|
|
isPackageJsonImport
|
|
};
|
|
return resolvedData;
|
|
}
|
|
const unresolvedData = {
|
|
exportName: origin.exportName,
|
|
exportMapKey: origin.exportMapKey,
|
|
fileName: origin.fileName,
|
|
ambientModuleName: origin.fileName ? void 0 : stripQuotes(origin.moduleSymbol.name),
|
|
isPackageJsonImport: origin.isFromPackageJson ? true : void 0
|
|
};
|
|
return unresolvedData;
|
|
}
|
|
function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbol) {
|
|
const isDefaultExport = data.exportName === "default" /* Default */;
|
|
const isFromPackageJson = !!data.isPackageJsonImport;
|
|
if (completionEntryDataIsResolved(data)) {
|
|
const resolvedOrigin = {
|
|
kind: 32 /* ResolvedExport */,
|
|
exportName: data.exportName,
|
|
moduleSpecifier: data.moduleSpecifier,
|
|
symbolName: completionName,
|
|
fileName: data.fileName,
|
|
moduleSymbol,
|
|
isDefaultExport,
|
|
isFromPackageJson
|
|
};
|
|
return resolvedOrigin;
|
|
}
|
|
const unresolvedOrigin = {
|
|
kind: 4 /* Export */,
|
|
exportName: data.exportName,
|
|
exportMapKey: data.exportMapKey,
|
|
symbolName: completionName,
|
|
fileName: data.fileName,
|
|
moduleSymbol,
|
|
isDefaultExport,
|
|
isFromPackageJson
|
|
};
|
|
return unresolvedOrigin;
|
|
}
|
|
function getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences) {
|
|
const replacementSpan = importStatementCompletion.replacementSpan;
|
|
const quotedModuleSpecifier = quote(sourceFile, preferences, origin.moduleSpecifier);
|
|
const exportKind = origin.isDefaultExport ? 1 /* Default */ : origin.exportName === "export=" /* ExportEquals */ ? 2 /* ExportEquals */ : 0 /* Named */;
|
|
const tabStop = preferences.includeCompletionsWithSnippetText ? "$1" : "";
|
|
const importKind = ts_codefix_exports.getImportKind(sourceFile, exportKind, options, true);
|
|
const isImportSpecifierTypeOnly = importStatementCompletion.couldBeTypeOnlyImportSpecifier;
|
|
const topLevelTypeOnlyText = importStatementCompletion.isTopLevelTypeOnly ? ` ${tokenToString(154 /* TypeKeyword */)} ` : " ";
|
|
const importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? `${tokenToString(154 /* TypeKeyword */)} ` : "";
|
|
const suffix = useSemicolons ? ";" : "";
|
|
switch (importKind) {
|
|
case 3 /* CommonJS */:
|
|
return { replacementSpan, insertText: `import${topLevelTypeOnlyText}${escapeSnippetText(name)}${tabStop} = require(${quotedModuleSpecifier})${suffix}` };
|
|
case 1 /* Default */:
|
|
return { replacementSpan, insertText: `import${topLevelTypeOnlyText}${escapeSnippetText(name)}${tabStop} from ${quotedModuleSpecifier}${suffix}` };
|
|
case 2 /* Namespace */:
|
|
return { replacementSpan, insertText: `import${topLevelTypeOnlyText}* as ${escapeSnippetText(name)} from ${quotedModuleSpecifier}${suffix}` };
|
|
case 0 /* Named */:
|
|
return { replacementSpan, insertText: `import${topLevelTypeOnlyText}{ ${importSpecifierTypeOnlyText}${escapeSnippetText(name)}${tabStop} } from ${quotedModuleSpecifier}${suffix}` };
|
|
}
|
|
}
|
|
function quotePropertyName(sourceFile, preferences, name) {
|
|
if (/^\d+$/.test(name)) {
|
|
return name;
|
|
}
|
|
return quote(sourceFile, preferences, name);
|
|
}
|
|
function isRecommendedCompletionMatch(localSymbol, recommendedCompletion, checker) {
|
|
return localSymbol === recommendedCompletion || !!(localSymbol.flags & 1048576 /* ExportValue */) && checker.getExportSymbolOfSymbol(localSymbol) === recommendedCompletion;
|
|
}
|
|
function getSourceFromOrigin(origin) {
|
|
if (originIsExport(origin)) {
|
|
return stripQuotes(origin.moduleSymbol.name);
|
|
}
|
|
if (originIsResolvedExport(origin)) {
|
|
return origin.moduleSpecifier;
|
|
}
|
|
if ((origin == null ? void 0 : origin.kind) === 1 /* ThisType */) {
|
|
return "ThisProperty/" /* ThisProperty */;
|
|
}
|
|
if ((origin == null ? void 0 : origin.kind) === 64 /* TypeOnlyAlias */) {
|
|
return "TypeOnlyAlias/" /* TypeOnlyAlias */;
|
|
}
|
|
}
|
|
function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location2, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag) {
|
|
var _a2;
|
|
const start2 = timestamp();
|
|
const variableDeclaration = getVariableDeclaration(location2);
|
|
const useSemicolons = probablyUsesSemicolons(sourceFile);
|
|
const typeChecker = program.getTypeChecker();
|
|
const uniques = /* @__PURE__ */ new Map();
|
|
for (let i = 0; i < symbols.length; i++) {
|
|
const symbol = symbols[i];
|
|
const origin = symbolToOriginInfoMap == null ? void 0 : symbolToOriginInfoMap[i];
|
|
const info = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, !!jsxIdentifierExpected);
|
|
if (!info || uniques.get(info.name) && (!origin || !originIsObjectLiteralMethod(origin)) || kind === CompletionKind.Global && symbolToSortTextMap && !shouldIncludeSymbol(symbol, symbolToSortTextMap)) {
|
|
continue;
|
|
}
|
|
const { name, needsConvertPropertyAccess } = info;
|
|
const originalSortText = (_a2 = symbolToSortTextMap == null ? void 0 : symbolToSortTextMap[getSymbolId(symbol)]) != null ? _a2 : SortText.LocationPriority;
|
|
const sortText = isDeprecated(symbol, typeChecker) ? SortText.Deprecated(originalSortText) : originalSortText;
|
|
const entry = createCompletionEntry(
|
|
symbol,
|
|
sortText,
|
|
replacementToken,
|
|
contextToken,
|
|
location2,
|
|
sourceFile,
|
|
host,
|
|
program,
|
|
name,
|
|
needsConvertPropertyAccess,
|
|
origin,
|
|
recommendedCompletion,
|
|
propertyAccessToConvert,
|
|
isJsxInitializer,
|
|
importStatementCompletion,
|
|
useSemicolons,
|
|
compilerOptions,
|
|
preferences,
|
|
kind,
|
|
formatContext,
|
|
isJsxIdentifierExpected,
|
|
isRightOfOpenTag
|
|
);
|
|
if (!entry) {
|
|
continue;
|
|
}
|
|
const shouldShadowLaterSymbols = (!origin || originIsTypeOnlyAlias(origin)) && !(symbol.parent === void 0 && !some(symbol.declarations, (d) => d.getSourceFile() === location2.getSourceFile()));
|
|
uniques.set(name, shouldShadowLaterSymbols);
|
|
insertSorted(entries, entry, compareCompletionEntries, true);
|
|
}
|
|
log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (timestamp() - start2));
|
|
return {
|
|
has: (name) => uniques.has(name),
|
|
add: (name) => uniques.set(name, true)
|
|
};
|
|
function shouldIncludeSymbol(symbol, symbolToSortTextMap2) {
|
|
let allFlags = symbol.flags;
|
|
if (!isSourceFile(location2)) {
|
|
if (isExportAssignment(location2.parent)) {
|
|
return true;
|
|
}
|
|
if (variableDeclaration && symbol.valueDeclaration === variableDeclaration) {
|
|
return false;
|
|
}
|
|
const symbolOrigin = skipAlias(symbol, typeChecker);
|
|
if (!!sourceFile.externalModuleIndicator && !compilerOptions.allowUmdGlobalAccess && symbolToSortTextMap2[getSymbolId(symbol)] === SortText.GlobalsOrKeywords && (symbolToSortTextMap2[getSymbolId(symbolOrigin)] === SortText.AutoImportSuggestions || symbolToSortTextMap2[getSymbolId(symbolOrigin)] === SortText.LocationPriority)) {
|
|
return false;
|
|
}
|
|
allFlags |= getCombinedLocalAndExportSymbolFlags(symbolOrigin);
|
|
if (isInRightSideOfInternalImportEqualsDeclaration(location2)) {
|
|
return !!(allFlags & 1920 /* Namespace */);
|
|
}
|
|
if (isTypeOnlyLocation) {
|
|
return symbolCanBeReferencedAtTypeLocation(symbol, typeChecker);
|
|
}
|
|
}
|
|
return !!(allFlags & 111551 /* Value */);
|
|
}
|
|
}
|
|
function getLabelCompletionAtPosition(node) {
|
|
const entries = getLabelStatementCompletions(node);
|
|
if (entries.length) {
|
|
return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries };
|
|
}
|
|
}
|
|
function getLabelStatementCompletions(node) {
|
|
const entries = [];
|
|
const uniques = /* @__PURE__ */ new Map();
|
|
let current = node;
|
|
while (current) {
|
|
if (isFunctionLike(current)) {
|
|
break;
|
|
}
|
|
if (isLabeledStatement(current)) {
|
|
const name = current.label.text;
|
|
if (!uniques.has(name)) {
|
|
uniques.set(name, true);
|
|
entries.push({
|
|
name,
|
|
kindModifiers: "" /* none */,
|
|
kind: "label" /* label */,
|
|
sortText: SortText.LocationPriority
|
|
});
|
|
}
|
|
}
|
|
current = current.parent;
|
|
}
|
|
return entries;
|
|
}
|
|
function getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences) {
|
|
if (entryId.data) {
|
|
const autoImport = getAutoImportSymbolFromCompletionEntryData(entryId.name, entryId.data, program, host);
|
|
if (autoImport) {
|
|
const { contextToken: contextToken2, previousToken: previousToken2 } = getRelevantTokens(position, sourceFile);
|
|
return {
|
|
type: "symbol",
|
|
symbol: autoImport.symbol,
|
|
location: getTouchingPropertyName(sourceFile, position),
|
|
previousToken: previousToken2,
|
|
contextToken: contextToken2,
|
|
isJsxInitializer: false,
|
|
isTypeOnlyLocation: false,
|
|
origin: autoImport.origin
|
|
};
|
|
}
|
|
}
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId, host, void 0);
|
|
if (!completionData) {
|
|
return { type: "none" };
|
|
}
|
|
if (completionData.kind !== CompletionDataKind.Data) {
|
|
return { type: "request", request: completionData };
|
|
}
|
|
const { symbols, literals, location: location2, completionKind, symbolToOriginInfoMap, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } = completionData;
|
|
const literal = find(literals, (l) => completionNameForLiteral(sourceFile, preferences, l) === entryId.name);
|
|
if (literal !== void 0)
|
|
return { type: "literal", literal };
|
|
return firstDefined(symbols, (symbol, index) => {
|
|
const origin = symbolToOriginInfoMap[index];
|
|
const info = getCompletionEntryDisplayNameForSymbol(symbol, getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
|
|
return info && info.name === entryId.name && (entryId.source === "ClassMemberSnippet/" /* ClassMemberSnippet */ && symbol.flags & 106500 /* ClassMember */ || entryId.source === "ObjectLiteralMethodSnippet/" /* ObjectLiteralMethodSnippet */ && symbol.flags & (4 /* Property */ | 8192 /* Method */) || getSourceFromOrigin(origin) === entryId.source) ? { type: "symbol", symbol, location: location2, origin, contextToken, previousToken, isJsxInitializer, isTypeOnlyLocation } : void 0;
|
|
}) || { type: "none" };
|
|
}
|
|
function getCompletionEntryDetails(program, log, sourceFile, position, entryId, host, formatContext, preferences, cancellationToken) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const { name, source, data } = entryId;
|
|
const contextToken = findPrecedingToken(position, sourceFile);
|
|
if (isInString(sourceFile, position, contextToken)) {
|
|
return ts_Completions_StringCompletions_exports.getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, typeChecker, compilerOptions, host, cancellationToken, preferences);
|
|
}
|
|
const symbolCompletion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
|
|
switch (symbolCompletion.type) {
|
|
case "request": {
|
|
const { request } = symbolCompletion;
|
|
switch (request.kind) {
|
|
case CompletionDataKind.JsDocTagName:
|
|
return ts_JsDoc_exports.getJSDocTagNameCompletionDetails(name);
|
|
case CompletionDataKind.JsDocTag:
|
|
return ts_JsDoc_exports.getJSDocTagCompletionDetails(name);
|
|
case CompletionDataKind.JsDocParameterName:
|
|
return ts_JsDoc_exports.getJSDocParameterNameCompletionDetails(name);
|
|
case CompletionDataKind.Keywords:
|
|
return some(request.keywordCompletions, (c) => c.name === name) ? createSimpleDetails(name, "keyword" /* keyword */, 5 /* keyword */) : void 0;
|
|
default:
|
|
return Debug.assertNever(request);
|
|
}
|
|
}
|
|
case "symbol": {
|
|
const { symbol, location: location2, contextToken: contextToken2, origin, previousToken } = symbolCompletion;
|
|
const { codeActions, sourceDisplay } = getCompletionEntryCodeActionsAndSourceDisplay(name, location2, contextToken2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken);
|
|
return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location2, cancellationToken, codeActions, sourceDisplay);
|
|
}
|
|
case "literal": {
|
|
const { literal } = symbolCompletion;
|
|
return createSimpleDetails(completionNameForLiteral(sourceFile, preferences, literal), "string" /* string */, typeof literal === "string" ? 8 /* stringLiteral */ : 7 /* numericLiteral */);
|
|
}
|
|
case "none":
|
|
return allKeywordsCompletions().some((c) => c.name === name) ? createSimpleDetails(name, "keyword" /* keyword */, 5 /* keyword */) : void 0;
|
|
default:
|
|
Debug.assertNever(symbolCompletion);
|
|
}
|
|
}
|
|
function createSimpleDetails(name, kind, kind2) {
|
|
return createCompletionDetails(name, "" /* none */, kind, [displayPart(name, kind2)]);
|
|
}
|
|
function createCompletionDetailsForSymbol(symbol, checker, sourceFile, location2, cancellationToken, codeActions, sourceDisplay) {
|
|
const { displayParts, documentation, symbolKind, tags } = checker.runWithCancellationToken(
|
|
cancellationToken,
|
|
(checker2) => ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(checker2, symbol, sourceFile, location2, location2, 7 /* All */)
|
|
);
|
|
return createCompletionDetails(symbol.name, ts_SymbolDisplay_exports.getSymbolModifiers(checker, symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay);
|
|
}
|
|
function createCompletionDetails(name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source) {
|
|
return { name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source, sourceDisplay: source };
|
|
}
|
|
function getCompletionEntryCodeActionsAndSourceDisplay(name, location2, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken) {
|
|
if (data == null ? void 0 : data.moduleSpecifier) {
|
|
if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementSpan) {
|
|
return { codeActions: void 0, sourceDisplay: [textPart(data.moduleSpecifier)] };
|
|
}
|
|
}
|
|
if (source === "ClassMemberSnippet/" /* ClassMemberSnippet */) {
|
|
const { importAdder } = getEntryForMemberCompletion(
|
|
host,
|
|
program,
|
|
compilerOptions,
|
|
preferences,
|
|
name,
|
|
symbol,
|
|
location2,
|
|
contextToken,
|
|
formatContext
|
|
);
|
|
if (importAdder) {
|
|
const changes = ts_textChanges_exports.ChangeTracker.with(
|
|
{ host, formatContext, preferences },
|
|
importAdder.writeFixes
|
|
);
|
|
return {
|
|
sourceDisplay: void 0,
|
|
codeActions: [{
|
|
changes,
|
|
description: diagnosticToString([Diagnostics.Includes_imports_of_types_referenced_by_0, name])
|
|
}]
|
|
};
|
|
}
|
|
}
|
|
if (originIsTypeOnlyAlias(origin)) {
|
|
const codeAction2 = ts_codefix_exports.getPromoteTypeOnlyCompletionAction(
|
|
sourceFile,
|
|
origin.declaration.name,
|
|
program,
|
|
host,
|
|
formatContext,
|
|
preferences
|
|
);
|
|
Debug.assertIsDefined(codeAction2, "Expected to have a code action for promoting type-only alias");
|
|
return { codeActions: [codeAction2], sourceDisplay: void 0 };
|
|
}
|
|
if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
|
|
return { codeActions: void 0, sourceDisplay: void 0 };
|
|
}
|
|
const checker = origin.isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker();
|
|
const { moduleSymbol } = origin;
|
|
const targetSymbol = checker.getMergedSymbol(skipAlias(symbol.exportSymbol || symbol, checker));
|
|
const isJsxOpeningTagName = (contextToken == null ? void 0 : contextToken.kind) === 29 /* LessThanToken */ && isJsxOpeningLikeElement(contextToken.parent);
|
|
const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
|
|
targetSymbol,
|
|
moduleSymbol,
|
|
sourceFile,
|
|
getNameForExportedSymbol(symbol, getEmitScriptTarget(compilerOptions), isJsxOpeningTagName),
|
|
isJsxOpeningTagName,
|
|
host,
|
|
program,
|
|
formatContext,
|
|
previousToken && isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position,
|
|
preferences,
|
|
cancellationToken
|
|
);
|
|
Debug.assert(!(data == null ? void 0 : data.moduleSpecifier) || moduleSpecifier === data.moduleSpecifier);
|
|
return { sourceDisplay: [textPart(moduleSpecifier)], codeActions: [codeAction] };
|
|
}
|
|
function getCompletionEntrySymbol(program, log, sourceFile, position, entryId, host, preferences) {
|
|
const completion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences);
|
|
return completion.type === "symbol" ? completion.symbol : void 0;
|
|
}
|
|
var CompletionDataKind = /* @__PURE__ */ ((CompletionDataKind2) => {
|
|
CompletionDataKind2[CompletionDataKind2["Data"] = 0] = "Data";
|
|
CompletionDataKind2[CompletionDataKind2["JsDocTagName"] = 1] = "JsDocTagName";
|
|
CompletionDataKind2[CompletionDataKind2["JsDocTag"] = 2] = "JsDocTag";
|
|
CompletionDataKind2[CompletionDataKind2["JsDocParameterName"] = 3] = "JsDocParameterName";
|
|
CompletionDataKind2[CompletionDataKind2["Keywords"] = 4] = "Keywords";
|
|
return CompletionDataKind2;
|
|
})(CompletionDataKind || {});
|
|
var CompletionKind = /* @__PURE__ */ ((CompletionKind2) => {
|
|
CompletionKind2[CompletionKind2["ObjectPropertyDeclaration"] = 0] = "ObjectPropertyDeclaration";
|
|
CompletionKind2[CompletionKind2["Global"] = 1] = "Global";
|
|
CompletionKind2[CompletionKind2["PropertyAccess"] = 2] = "PropertyAccess";
|
|
CompletionKind2[CompletionKind2["MemberLike"] = 3] = "MemberLike";
|
|
CompletionKind2[CompletionKind2["String"] = 4] = "String";
|
|
CompletionKind2[CompletionKind2["None"] = 5] = "None";
|
|
return CompletionKind2;
|
|
})(CompletionKind || {});
|
|
function getRecommendedCompletion(previousToken, contextualType, checker) {
|
|
return firstDefined(contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]), (type) => {
|
|
const symbol = type && type.symbol;
|
|
return symbol && (symbol.flags & (8 /* EnumMember */ | 384 /* Enum */ | 32 /* Class */) && !isAbstractConstructorSymbol(symbol)) ? getFirstSymbolInChain(symbol, previousToken, checker) : void 0;
|
|
});
|
|
}
|
|
function getContextualType(previousToken, position, sourceFile, checker) {
|
|
const { parent: parent2 } = previousToken;
|
|
switch (previousToken.kind) {
|
|
case 79 /* Identifier */:
|
|
return getContextualTypeFromParent(previousToken, checker);
|
|
case 63 /* EqualsToken */:
|
|
switch (parent2.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return checker.getContextualType(parent2.initializer);
|
|
case 223 /* BinaryExpression */:
|
|
return checker.getTypeAtLocation(parent2.left);
|
|
case 288 /* JsxAttribute */:
|
|
return checker.getContextualTypeForJsxAttribute(parent2);
|
|
default:
|
|
return void 0;
|
|
}
|
|
case 103 /* NewKeyword */:
|
|
return checker.getContextualType(parent2);
|
|
case 82 /* CaseKeyword */:
|
|
const caseClause = tryCast(parent2, isCaseClause);
|
|
return caseClause ? getSwitchedType(caseClause, checker) : void 0;
|
|
case 18 /* OpenBraceToken */:
|
|
return isJsxExpression(parent2) && !isJsxElement(parent2.parent) && !isJsxFragment(parent2.parent) ? checker.getContextualTypeForJsxAttribute(parent2.parent) : void 0;
|
|
default:
|
|
const argInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(previousToken, position, sourceFile);
|
|
return argInfo ? checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex + (previousToken.kind === 27 /* CommaToken */ ? 1 : 0)) : isEqualityOperatorKind(previousToken.kind) && isBinaryExpression(parent2) && isEqualityOperatorKind(parent2.operatorToken.kind) ? checker.getTypeAtLocation(parent2.left) : checker.getContextualType(previousToken);
|
|
}
|
|
}
|
|
function getFirstSymbolInChain(symbol, enclosingDeclaration, checker) {
|
|
const chain = checker.getAccessibleSymbolChain(symbol, enclosingDeclaration, 67108863 /* All */, false);
|
|
if (chain)
|
|
return first(chain);
|
|
return symbol.parent && (isModuleSymbol(symbol.parent) ? symbol : getFirstSymbolInChain(symbol.parent, enclosingDeclaration, checker));
|
|
}
|
|
function isModuleSymbol(symbol) {
|
|
var _a2;
|
|
return !!((_a2 = symbol.declarations) == null ? void 0 : _a2.some((d) => d.kind === 308 /* SourceFile */));
|
|
}
|
|
function getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, detailsEntryId, host, formatContext, cancellationToken) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const inCheckedFile = isCheckedFile(sourceFile, compilerOptions);
|
|
let start2 = timestamp();
|
|
let currentToken = getTokenAtPosition(sourceFile, position);
|
|
log("getCompletionData: Get current token: " + (timestamp() - start2));
|
|
start2 = timestamp();
|
|
const insideComment = isInComment(sourceFile, position, currentToken);
|
|
log("getCompletionData: Is inside comment: " + (timestamp() - start2));
|
|
let insideJsDocTagTypeExpression = false;
|
|
let isInSnippetScope = false;
|
|
if (insideComment) {
|
|
if (hasDocComment(sourceFile, position)) {
|
|
if (sourceFile.text.charCodeAt(position - 1) === 64 /* at */) {
|
|
return { kind: 1 /* JsDocTagName */ };
|
|
} else {
|
|
const lineStart = getLineStartPositionForPosition(position, sourceFile);
|
|
if (!/[^\*|\s(/)]/.test(sourceFile.text.substring(lineStart, position))) {
|
|
return { kind: 2 /* JsDocTag */ };
|
|
}
|
|
}
|
|
}
|
|
const tag = getJsDocTagAtPosition(currentToken, position);
|
|
if (tag) {
|
|
if (tag.tagName.pos <= position && position <= tag.tagName.end) {
|
|
return { kind: 1 /* JsDocTagName */ };
|
|
}
|
|
const typeExpression = tryGetTypeExpressionFromTag(tag);
|
|
if (typeExpression) {
|
|
currentToken = getTokenAtPosition(sourceFile, position);
|
|
if (!currentToken || !isDeclarationName(currentToken) && (currentToken.parent.kind !== 350 /* JSDocPropertyTag */ || currentToken.parent.name !== currentToken)) {
|
|
insideJsDocTagTypeExpression = isCurrentlyEditingNode(typeExpression);
|
|
}
|
|
}
|
|
if (!insideJsDocTagTypeExpression && isJSDocParameterTag(tag) && (nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) {
|
|
return { kind: 3 /* JsDocParameterName */, tag };
|
|
}
|
|
}
|
|
if (!insideJsDocTagTypeExpression) {
|
|
log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment.");
|
|
return void 0;
|
|
}
|
|
}
|
|
start2 = timestamp();
|
|
const isJsOnlyLocation = !insideJsDocTagTypeExpression && isSourceFileJS(sourceFile);
|
|
const tokens = getRelevantTokens(position, sourceFile);
|
|
const previousToken = tokens.previousToken;
|
|
let contextToken = tokens.contextToken;
|
|
log("getCompletionData: Get previous token: " + (timestamp() - start2));
|
|
let node = currentToken;
|
|
let propertyAccessToConvert;
|
|
let isRightOfDot = false;
|
|
let isRightOfQuestionDot = false;
|
|
let isRightOfOpenTag = false;
|
|
let isStartingCloseTag = false;
|
|
let isJsxInitializer = false;
|
|
let isJsxIdentifierExpected = false;
|
|
let importStatementCompletion;
|
|
let location2 = getTouchingPropertyName(sourceFile, position);
|
|
let keywordFilters = 0 /* None */;
|
|
let isNewIdentifierLocation = false;
|
|
let flags = 0 /* None */;
|
|
if (contextToken) {
|
|
const importStatementCompletionInfo = getImportStatementCompletionInfo(contextToken);
|
|
if (importStatementCompletionInfo.keywordCompletion) {
|
|
if (importStatementCompletionInfo.isKeywordOnlyCompletion) {
|
|
return {
|
|
kind: 4 /* Keywords */,
|
|
keywordCompletions: [keywordToCompletionEntry(importStatementCompletionInfo.keywordCompletion)],
|
|
isNewIdentifierLocation: importStatementCompletionInfo.isNewIdentifierLocation
|
|
};
|
|
}
|
|
keywordFilters = keywordFiltersFromSyntaxKind(importStatementCompletionInfo.keywordCompletion);
|
|
}
|
|
if (importStatementCompletionInfo.replacementSpan && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) {
|
|
flags |= 2 /* IsImportStatementCompletion */;
|
|
importStatementCompletion = importStatementCompletionInfo;
|
|
isNewIdentifierLocation = importStatementCompletionInfo.isNewIdentifierLocation;
|
|
}
|
|
if (!importStatementCompletionInfo.replacementSpan && isCompletionListBlocker(contextToken)) {
|
|
log("Returning an empty list because completion was requested in an invalid position.");
|
|
return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation()) : void 0;
|
|
}
|
|
let parent2 = contextToken.parent;
|
|
if (contextToken.kind === 24 /* DotToken */ || contextToken.kind === 28 /* QuestionDotToken */) {
|
|
isRightOfDot = contextToken.kind === 24 /* DotToken */;
|
|
isRightOfQuestionDot = contextToken.kind === 28 /* QuestionDotToken */;
|
|
switch (parent2.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
propertyAccessToConvert = parent2;
|
|
node = propertyAccessToConvert.expression;
|
|
const leftmostAccessExpression = getLeftmostAccessExpression(propertyAccessToConvert);
|
|
if (nodeIsMissing(leftmostAccessExpression) || (isCallExpression(node) || isFunctionLike(node)) && node.end === contextToken.pos && node.getChildCount(sourceFile) && last(node.getChildren(sourceFile)).kind !== 21 /* CloseParenToken */) {
|
|
return void 0;
|
|
}
|
|
break;
|
|
case 163 /* QualifiedName */:
|
|
node = parent2.left;
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
node = parent2.name;
|
|
break;
|
|
case 202 /* ImportType */:
|
|
node = parent2;
|
|
break;
|
|
case 233 /* MetaProperty */:
|
|
node = parent2.getFirstToken(sourceFile);
|
|
Debug.assert(node.kind === 100 /* ImportKeyword */ || node.kind === 103 /* NewKeyword */);
|
|
break;
|
|
default:
|
|
return void 0;
|
|
}
|
|
} else if (!importStatementCompletion) {
|
|
if (parent2 && parent2.kind === 208 /* PropertyAccessExpression */) {
|
|
contextToken = parent2;
|
|
parent2 = parent2.parent;
|
|
}
|
|
if (currentToken.parent === location2) {
|
|
switch (currentToken.kind) {
|
|
case 31 /* GreaterThanToken */:
|
|
if (currentToken.parent.kind === 281 /* JsxElement */ || currentToken.parent.kind === 283 /* JsxOpeningElement */) {
|
|
location2 = currentToken;
|
|
}
|
|
break;
|
|
case 43 /* SlashToken */:
|
|
if (currentToken.parent.kind === 282 /* JsxSelfClosingElement */) {
|
|
location2 = currentToken;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
switch (parent2.kind) {
|
|
case 284 /* JsxClosingElement */:
|
|
if (contextToken.kind === 43 /* SlashToken */) {
|
|
isStartingCloseTag = true;
|
|
location2 = contextToken;
|
|
}
|
|
break;
|
|
case 223 /* BinaryExpression */:
|
|
if (!binaryExpressionMayBeOpenTag(parent2)) {
|
|
break;
|
|
}
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 281 /* JsxElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
isJsxIdentifierExpected = true;
|
|
if (contextToken.kind === 29 /* LessThanToken */) {
|
|
isRightOfOpenTag = true;
|
|
location2 = contextToken;
|
|
}
|
|
break;
|
|
case 291 /* JsxExpression */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
if (previousToken.kind === 19 /* CloseBraceToken */ && currentToken.kind === 31 /* GreaterThanToken */) {
|
|
isJsxIdentifierExpected = true;
|
|
}
|
|
break;
|
|
case 288 /* JsxAttribute */:
|
|
if (parent2.initializer === previousToken && previousToken.end < position) {
|
|
isJsxIdentifierExpected = true;
|
|
break;
|
|
}
|
|
switch (previousToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
isJsxInitializer = true;
|
|
break;
|
|
case 79 /* Identifier */:
|
|
isJsxIdentifierExpected = true;
|
|
if (parent2 !== previousToken.parent && !parent2.initializer && findChildOfKind(parent2, 63 /* EqualsToken */, sourceFile)) {
|
|
isJsxInitializer = previousToken;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const semanticStart = timestamp();
|
|
let completionKind = 5 /* None */;
|
|
let isNonContextualObjectLiteral = false;
|
|
let hasUnresolvedAutoImports = false;
|
|
let symbols = [];
|
|
let importSpecifierResolver;
|
|
const symbolToOriginInfoMap = [];
|
|
const symbolToSortTextMap = [];
|
|
const seenPropertySymbols = /* @__PURE__ */ new Map();
|
|
const isTypeOnlyLocation = isTypeOnlyCompletion();
|
|
const getModuleSpecifierResolutionHost = memoizeOne((isFromPackageJson) => {
|
|
return createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host);
|
|
});
|
|
if (isRightOfDot || isRightOfQuestionDot) {
|
|
getTypeScriptMemberSymbols();
|
|
} else if (isRightOfOpenTag) {
|
|
symbols = typeChecker.getJsxIntrinsicTagNamesAt(location2);
|
|
Debug.assertEachIsDefined(symbols, "getJsxIntrinsicTagNames() should all be defined");
|
|
tryGetGlobalSymbols();
|
|
completionKind = 1 /* Global */;
|
|
keywordFilters = 0 /* None */;
|
|
} else if (isStartingCloseTag) {
|
|
const tagName = contextToken.parent.parent.openingElement.tagName;
|
|
const tagSymbol = typeChecker.getSymbolAtLocation(tagName);
|
|
if (tagSymbol) {
|
|
symbols = [tagSymbol];
|
|
}
|
|
completionKind = 1 /* Global */;
|
|
keywordFilters = 0 /* None */;
|
|
} else {
|
|
if (!tryGetGlobalSymbols()) {
|
|
return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierLocation) : void 0;
|
|
}
|
|
}
|
|
log("getCompletionData: Semantic work: " + (timestamp() - semanticStart));
|
|
const contextualType = previousToken && getContextualType(previousToken, position, sourceFile, typeChecker);
|
|
const literals = mapDefined(
|
|
contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]),
|
|
(t) => t.isLiteral() && !(t.flags & 1024 /* EnumLiteral */) ? t.value : void 0
|
|
);
|
|
const recommendedCompletion = previousToken && contextualType && getRecommendedCompletion(previousToken, contextualType, typeChecker);
|
|
return {
|
|
kind: 0 /* Data */,
|
|
symbols,
|
|
completionKind,
|
|
isInSnippetScope,
|
|
propertyAccessToConvert,
|
|
isNewIdentifierLocation,
|
|
location: location2,
|
|
keywordFilters,
|
|
literals,
|
|
symbolToOriginInfoMap,
|
|
recommendedCompletion,
|
|
previousToken,
|
|
contextToken,
|
|
isJsxInitializer,
|
|
insideJsDocTagTypeExpression,
|
|
symbolToSortTextMap,
|
|
isTypeOnlyLocation,
|
|
isJsxIdentifierExpected,
|
|
isRightOfOpenTag,
|
|
importStatementCompletion,
|
|
hasUnresolvedAutoImports,
|
|
flags
|
|
};
|
|
function isTagWithTypeExpression(tag) {
|
|
switch (tag.kind) {
|
|
case 343 /* JSDocParameterTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 344 /* JSDocReturnTag */:
|
|
case 346 /* JSDocTypeTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
return true;
|
|
case 347 /* JSDocTemplateTag */:
|
|
return !!tag.constraint;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function tryGetTypeExpressionFromTag(tag) {
|
|
if (isTagWithTypeExpression(tag)) {
|
|
const typeExpression = isJSDocTemplateTag(tag) ? tag.constraint : tag.typeExpression;
|
|
return typeExpression && typeExpression.kind === 312 /* JSDocTypeExpression */ ? typeExpression : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeScriptMemberSymbols() {
|
|
completionKind = 2 /* PropertyAccess */;
|
|
const isImportType = isLiteralImportTypeNode(node);
|
|
const isTypeLocation = insideJsDocTagTypeExpression || isImportType && !node.isTypeOf || isPartOfTypeNode(node.parent) || isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker);
|
|
const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node);
|
|
if (isEntityName(node) || isImportType || isPropertyAccessExpression(node)) {
|
|
const isNamespaceName = isModuleDeclaration(node.parent);
|
|
if (isNamespaceName)
|
|
isNewIdentifierLocation = true;
|
|
let symbol = typeChecker.getSymbolAtLocation(node);
|
|
if (symbol) {
|
|
symbol = skipAlias(symbol, typeChecker);
|
|
if (symbol.flags & (1536 /* Module */ | 384 /* Enum */)) {
|
|
const exportedSymbols = typeChecker.getExportsOfModule(symbol);
|
|
Debug.assertEachIsDefined(exportedSymbols, "getExportsOfModule() should all be defined");
|
|
const isValidValueAccess = (symbol2) => typeChecker.isValidPropertyAccess(isImportType ? node : node.parent, symbol2.name);
|
|
const isValidTypeAccess = (symbol2) => symbolCanBeReferencedAtTypeLocation(symbol2, typeChecker);
|
|
const isValidAccess = isNamespaceName ? (symbol2) => {
|
|
var _a2;
|
|
return !!(symbol2.flags & 1920 /* Namespace */) && !((_a2 = symbol2.declarations) == null ? void 0 : _a2.every((d) => d.parent === node.parent));
|
|
} : isRhsOfImportDeclaration ? (symbol2) => isValidTypeAccess(symbol2) || isValidValueAccess(symbol2) : isTypeLocation ? isValidTypeAccess : isValidValueAccess;
|
|
for (const exportedSymbol of exportedSymbols) {
|
|
if (isValidAccess(exportedSymbol)) {
|
|
symbols.push(exportedSymbol);
|
|
}
|
|
}
|
|
if (!isTypeLocation && symbol.declarations && symbol.declarations.some((d) => d.kind !== 308 /* SourceFile */ && d.kind !== 264 /* ModuleDeclaration */ && d.kind !== 263 /* EnumDeclaration */)) {
|
|
let type = typeChecker.getTypeOfSymbolAtLocation(symbol, node).getNonOptionalType();
|
|
let insertQuestionDot = false;
|
|
if (type.isNullableType()) {
|
|
const canCorrectToQuestionDot = isRightOfDot && !isRightOfQuestionDot && preferences.includeAutomaticOptionalChainCompletions !== false;
|
|
if (canCorrectToQuestionDot || isRightOfQuestionDot) {
|
|
type = type.getNonNullableType();
|
|
if (canCorrectToQuestionDot) {
|
|
insertQuestionDot = true;
|
|
}
|
|
}
|
|
}
|
|
addTypeProperties(type, !!(node.flags & 32768 /* AwaitContext */), insertQuestionDot);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (!isTypeLocation) {
|
|
typeChecker.tryGetThisTypeAt(node, false);
|
|
let type = typeChecker.getTypeAtLocation(node).getNonOptionalType();
|
|
let insertQuestionDot = false;
|
|
if (type.isNullableType()) {
|
|
const canCorrectToQuestionDot = isRightOfDot && !isRightOfQuestionDot && preferences.includeAutomaticOptionalChainCompletions !== false;
|
|
if (canCorrectToQuestionDot || isRightOfQuestionDot) {
|
|
type = type.getNonNullableType();
|
|
if (canCorrectToQuestionDot) {
|
|
insertQuestionDot = true;
|
|
}
|
|
}
|
|
}
|
|
addTypeProperties(type, !!(node.flags & 32768 /* AwaitContext */), insertQuestionDot);
|
|
}
|
|
}
|
|
function addTypeProperties(type, insertAwait, insertQuestionDot) {
|
|
isNewIdentifierLocation = !!type.getStringIndexType();
|
|
if (isRightOfQuestionDot && some(type.getCallSignatures())) {
|
|
isNewIdentifierLocation = true;
|
|
}
|
|
const propertyAccess = node.kind === 202 /* ImportType */ ? node : node.parent;
|
|
if (inCheckedFile) {
|
|
for (const symbol of type.getApparentProperties()) {
|
|
if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, type, symbol)) {
|
|
addPropertySymbol(symbol, false, insertQuestionDot);
|
|
}
|
|
}
|
|
} else {
|
|
symbols.push(...filter(getPropertiesForCompletion(type, typeChecker), (s) => typeChecker.isValidPropertyAccessForCompletions(propertyAccess, type, s)));
|
|
}
|
|
if (insertAwait && preferences.includeCompletionsWithInsertText) {
|
|
const promiseType = typeChecker.getPromisedTypeOfPromise(type);
|
|
if (promiseType) {
|
|
for (const symbol of promiseType.getApparentProperties()) {
|
|
if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, promiseType, symbol)) {
|
|
addPropertySymbol(symbol, true, insertQuestionDot);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function addPropertySymbol(symbol, insertAwait, insertQuestionDot) {
|
|
var _a2;
|
|
const computedPropertyName = firstDefined(symbol.declarations, (decl) => tryCast(getNameOfDeclaration(decl), isComputedPropertyName));
|
|
if (computedPropertyName) {
|
|
const leftMostName = getLeftMostName(computedPropertyName.expression);
|
|
const nameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName);
|
|
const firstAccessibleSymbol = nameSymbol && getFirstSymbolInChain(nameSymbol, contextToken, typeChecker);
|
|
if (firstAccessibleSymbol && addToSeen(seenPropertySymbols, getSymbolId(firstAccessibleSymbol))) {
|
|
const index = symbols.length;
|
|
symbols.push(firstAccessibleSymbol);
|
|
const moduleSymbol = firstAccessibleSymbol.parent;
|
|
if (!moduleSymbol || !isExternalModuleSymbol(moduleSymbol) || typeChecker.tryGetMemberInModuleExportsAndProperties(firstAccessibleSymbol.name, moduleSymbol) !== firstAccessibleSymbol) {
|
|
symbolToOriginInfoMap[index] = { kind: getNullableSymbolOriginInfoKind(2 /* SymbolMemberNoExport */) };
|
|
} else {
|
|
const fileName = isExternalModuleNameRelative(stripQuotes(moduleSymbol.name)) ? (_a2 = getSourceFileOfModule(moduleSymbol)) == null ? void 0 : _a2.fileName : void 0;
|
|
const { moduleSpecifier } = (importSpecifierResolver || (importSpecifierResolver = ts_codefix_exports.createImportSpecifierResolver(sourceFile, program, host, preferences))).getModuleSpecifierForBestExportInfo([{
|
|
exportKind: 0 /* Named */,
|
|
moduleFileName: fileName,
|
|
isFromPackageJson: false,
|
|
moduleSymbol,
|
|
symbol: firstAccessibleSymbol,
|
|
targetFlags: skipAlias(firstAccessibleSymbol, typeChecker).flags
|
|
}], firstAccessibleSymbol.name, position, isValidTypeOnlyAliasUseSite(location2)) || {};
|
|
if (moduleSpecifier) {
|
|
const origin = {
|
|
kind: getNullableSymbolOriginInfoKind(6 /* SymbolMemberExport */),
|
|
moduleSymbol,
|
|
isDefaultExport: false,
|
|
symbolName: firstAccessibleSymbol.name,
|
|
exportName: firstAccessibleSymbol.name,
|
|
fileName,
|
|
moduleSpecifier
|
|
};
|
|
symbolToOriginInfoMap[index] = origin;
|
|
}
|
|
}
|
|
} else if (preferences.includeCompletionsWithInsertText) {
|
|
addSymbolOriginInfo(symbol);
|
|
addSymbolSortInfo(symbol);
|
|
symbols.push(symbol);
|
|
}
|
|
} else {
|
|
addSymbolOriginInfo(symbol);
|
|
addSymbolSortInfo(symbol);
|
|
symbols.push(symbol);
|
|
}
|
|
function addSymbolSortInfo(symbol2) {
|
|
if (isStaticProperty(symbol2)) {
|
|
symbolToSortTextMap[getSymbolId(symbol2)] = SortText.LocalDeclarationPriority;
|
|
}
|
|
}
|
|
function addSymbolOriginInfo(symbol2) {
|
|
if (preferences.includeCompletionsWithInsertText) {
|
|
if (insertAwait && addToSeen(seenPropertySymbols, getSymbolId(symbol2))) {
|
|
symbolToOriginInfoMap[symbols.length] = { kind: getNullableSymbolOriginInfoKind(8 /* Promise */) };
|
|
} else if (insertQuestionDot) {
|
|
symbolToOriginInfoMap[symbols.length] = { kind: 16 /* Nullable */ };
|
|
}
|
|
}
|
|
}
|
|
function getNullableSymbolOriginInfoKind(kind) {
|
|
return insertQuestionDot ? kind | 16 /* Nullable */ : kind;
|
|
}
|
|
}
|
|
function getLeftMostName(e) {
|
|
return isIdentifier(e) ? e : isPropertyAccessExpression(e) ? getLeftMostName(e.expression) : void 0;
|
|
}
|
|
function tryGetGlobalSymbols() {
|
|
const result = tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() || tryGetObjectLikeCompletionSymbols() || tryGetImportCompletionSymbols() || tryGetImportOrExportClauseCompletionSymbols() || tryGetLocalNamedExportCompletionSymbols() || tryGetConstructorCompletion() || tryGetClassLikeCompletionSymbols() || tryGetJsxCompletionSymbols() || (getGlobalCompletions(), 1 /* Success */);
|
|
return result === 1 /* Success */;
|
|
}
|
|
function tryGetConstructorCompletion() {
|
|
if (!tryGetConstructorLikeCompletionContainer(contextToken))
|
|
return 0 /* Continue */;
|
|
completionKind = 5 /* None */;
|
|
isNewIdentifierLocation = true;
|
|
keywordFilters = 4 /* ConstructorParameterKeywords */;
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetJsxCompletionSymbols() {
|
|
const jsxContainer = tryGetContainingJsxElement(contextToken);
|
|
const attrsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes);
|
|
if (!attrsType)
|
|
return 0 /* Continue */;
|
|
const completionsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes, 4 /* Completions */);
|
|
symbols = concatenate(symbols, filterJsxAttributes(getPropertiesForObjectExpression(attrsType, completionsType, jsxContainer.attributes, typeChecker), jsxContainer.attributes.properties));
|
|
setSortTextToOptionalMember();
|
|
completionKind = 3 /* MemberLike */;
|
|
isNewIdentifierLocation = false;
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetImportCompletionSymbols() {
|
|
if (!importStatementCompletion)
|
|
return 0 /* Continue */;
|
|
isNewIdentifierLocation = true;
|
|
collectAutoImports();
|
|
return 1 /* Success */;
|
|
}
|
|
function getGlobalCompletions() {
|
|
keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 5 /* FunctionLikeBodyKeywords */ : 1 /* All */;
|
|
completionKind = 1 /* Global */;
|
|
isNewIdentifierLocation = isNewIdentifierDefinitionLocation();
|
|
if (previousToken !== contextToken) {
|
|
Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'.");
|
|
}
|
|
const adjustedPosition = previousToken !== contextToken ? previousToken.getStart() : position;
|
|
const scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile;
|
|
isInSnippetScope = isSnippetScope(scopeNode);
|
|
const symbolMeanings = (isTypeOnlyLocation ? 0 /* None */ : 111551 /* Value */) | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */;
|
|
const typeOnlyAliasNeedsPromotion = previousToken && !isValidTypeOnlyAliasUseSite(previousToken);
|
|
symbols = concatenate(symbols, typeChecker.getSymbolsInScope(scopeNode, symbolMeanings));
|
|
Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined");
|
|
for (let i = 0; i < symbols.length; i++) {
|
|
const symbol = symbols[i];
|
|
if (!typeChecker.isArgumentsSymbol(symbol) && !some(symbol.declarations, (d) => d.getSourceFile() === sourceFile)) {
|
|
symbolToSortTextMap[getSymbolId(symbol)] = SortText.GlobalsOrKeywords;
|
|
}
|
|
if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* Value */)) {
|
|
const typeOnlyAliasDeclaration = symbol.declarations && find(symbol.declarations, isTypeOnlyImportOrExportDeclaration);
|
|
if (typeOnlyAliasDeclaration) {
|
|
const origin = { kind: 64 /* TypeOnlyAlias */, declaration: typeOnlyAliasDeclaration };
|
|
symbolToOriginInfoMap[i] = origin;
|
|
}
|
|
}
|
|
}
|
|
if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 308 /* SourceFile */) {
|
|
const thisType = typeChecker.tryGetThisTypeAt(scopeNode, false, isClassLike(scopeNode.parent) ? scopeNode : void 0);
|
|
if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) {
|
|
for (const symbol of getPropertiesForCompletion(thisType, typeChecker)) {
|
|
symbolToOriginInfoMap[symbols.length] = { kind: 1 /* ThisType */ };
|
|
symbols.push(symbol);
|
|
symbolToSortTextMap[getSymbolId(symbol)] = SortText.SuggestedClassMembers;
|
|
}
|
|
}
|
|
}
|
|
collectAutoImports();
|
|
if (isTypeOnlyLocation) {
|
|
keywordFilters = contextToken && isAssertionExpression(contextToken.parent) ? 6 /* TypeAssertionKeywords */ : 7 /* TypeKeywords */;
|
|
}
|
|
}
|
|
function shouldOfferImportCompletions() {
|
|
if (importStatementCompletion)
|
|
return true;
|
|
if (isNonContextualObjectLiteral)
|
|
return false;
|
|
if (!preferences.includeCompletionsForModuleExports)
|
|
return false;
|
|
if (sourceFile.externalModuleIndicator || sourceFile.commonJsModuleIndicator)
|
|
return true;
|
|
if (compilerOptionsIndicateEsModules(program.getCompilerOptions()))
|
|
return true;
|
|
return programContainsModules(program);
|
|
}
|
|
function isSnippetScope(scopeNode) {
|
|
switch (scopeNode.kind) {
|
|
case 308 /* SourceFile */:
|
|
case 225 /* TemplateExpression */:
|
|
case 291 /* JsxExpression */:
|
|
case 238 /* Block */:
|
|
return true;
|
|
default:
|
|
return isStatement(scopeNode);
|
|
}
|
|
}
|
|
function isTypeOnlyCompletion() {
|
|
return insideJsDocTagTypeExpression || !!importStatementCompletion && isTypeOnlyImportOrExportDeclaration(location2.parent) || !isContextTokenValueLocation(contextToken) && (isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker) || isPartOfTypeNode(location2) || isContextTokenTypeLocation(contextToken));
|
|
}
|
|
function isContextTokenValueLocation(contextToken2) {
|
|
return contextToken2 && (contextToken2.kind === 112 /* TypeOfKeyword */ && (contextToken2.parent.kind === 183 /* TypeQuery */ || isTypeOfExpression(contextToken2.parent)) || contextToken2.kind === 129 /* AssertsKeyword */ && contextToken2.parent.kind === 179 /* TypePredicate */);
|
|
}
|
|
function isContextTokenTypeLocation(contextToken2) {
|
|
if (contextToken2) {
|
|
const parentKind = contextToken2.parent.kind;
|
|
switch (contextToken2.kind) {
|
|
case 58 /* ColonToken */:
|
|
return parentKind === 169 /* PropertyDeclaration */ || parentKind === 168 /* PropertySignature */ || parentKind === 166 /* Parameter */ || parentKind === 257 /* VariableDeclaration */ || isFunctionLikeKind(parentKind);
|
|
case 63 /* EqualsToken */:
|
|
return parentKind === 262 /* TypeAliasDeclaration */;
|
|
case 128 /* AsKeyword */:
|
|
return parentKind === 231 /* AsExpression */;
|
|
case 29 /* LessThanToken */:
|
|
return parentKind === 180 /* TypeReference */ || parentKind === 213 /* TypeAssertionExpression */;
|
|
case 94 /* ExtendsKeyword */:
|
|
return parentKind === 165 /* TypeParameter */;
|
|
case 150 /* SatisfiesKeyword */:
|
|
return parentKind === 235 /* SatisfiesExpression */;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function collectAutoImports() {
|
|
var _a2, _b;
|
|
if (!shouldOfferImportCompletions())
|
|
return;
|
|
Debug.assert(!(detailsEntryId == null ? void 0 : detailsEntryId.data), "Should not run 'collectAutoImports' when faster path is available via `data`");
|
|
if (detailsEntryId && !detailsEntryId.source) {
|
|
return;
|
|
}
|
|
flags |= 1 /* MayIncludeAutoImports */;
|
|
const isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken && importStatementCompletion;
|
|
const lowerCaseTokenText = isAfterTypeOnlyImportSpecifierModifier ? "" : previousToken && isIdentifier(previousToken) ? previousToken.text.toLowerCase() : "";
|
|
const moduleSpecifierCache = (_a2 = host.getModuleSpecifierCache) == null ? void 0 : _a2.call(host);
|
|
const exportInfo = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken);
|
|
const packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) == null ? void 0 : _b.call(host);
|
|
const packageJsonFilter = detailsEntryId ? void 0 : createPackageJsonImportFilter(sourceFile, preferences, host);
|
|
resolvingModuleSpecifiers(
|
|
"collectAutoImports",
|
|
host,
|
|
importSpecifierResolver || (importSpecifierResolver = ts_codefix_exports.createImportSpecifierResolver(sourceFile, program, host, preferences)),
|
|
program,
|
|
position,
|
|
preferences,
|
|
!!importStatementCompletion,
|
|
isValidTypeOnlyAliasUseSite(location2),
|
|
(context) => {
|
|
exportInfo.search(
|
|
sourceFile.path,
|
|
isRightOfOpenTag,
|
|
(symbolName2, targetFlags) => {
|
|
if (!isIdentifierText(symbolName2, getEmitScriptTarget(host.getCompilationSettings())))
|
|
return false;
|
|
if (!detailsEntryId && isStringANonContextualKeyword(symbolName2))
|
|
return false;
|
|
if (!isTypeOnlyLocation && !importStatementCompletion && !(targetFlags & 111551 /* Value */))
|
|
return false;
|
|
if (isTypeOnlyLocation && !(targetFlags & (1536 /* Module */ | 788968 /* Type */)))
|
|
return false;
|
|
const firstChar = symbolName2.charCodeAt(0);
|
|
if (isRightOfOpenTag && (firstChar < 65 /* A */ || firstChar > 90 /* Z */))
|
|
return false;
|
|
if (detailsEntryId)
|
|
return true;
|
|
return charactersFuzzyMatchInString(symbolName2, lowerCaseTokenText);
|
|
},
|
|
(info, symbolName2, isFromAmbientModule, exportMapKey) => {
|
|
if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
|
|
return;
|
|
}
|
|
const firstImportableExportInfo = find(info, isImportableExportInfo);
|
|
if (!firstImportableExportInfo) {
|
|
return;
|
|
}
|
|
const result = context.tryResolve(info, symbolName2, isFromAmbientModule) || {};
|
|
if (result === "failed")
|
|
return;
|
|
let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
|
|
if (result !== "skipped") {
|
|
({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
|
|
}
|
|
const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
|
|
const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;
|
|
pushAutoImportSymbol(symbol, {
|
|
kind: moduleSpecifier ? 32 /* ResolvedExport */ : 4 /* Export */,
|
|
moduleSpecifier,
|
|
symbolName: symbolName2,
|
|
exportMapKey,
|
|
exportName: exportInfo2.exportKind === 2 /* ExportEquals */ ? "export=" /* ExportEquals */ : exportInfo2.symbol.name,
|
|
fileName: exportInfo2.moduleFileName,
|
|
isDefaultExport,
|
|
moduleSymbol: exportInfo2.moduleSymbol,
|
|
isFromPackageJson: exportInfo2.isFromPackageJson
|
|
});
|
|
}
|
|
);
|
|
hasUnresolvedAutoImports = context.skippedAny();
|
|
flags |= context.resolvedAny() ? 8 /* ResolvedModuleSpecifiers */ : 0;
|
|
flags |= context.resolvedBeyondLimit() ? 16 /* ResolvedModuleSpecifiersBeyondLimit */ : 0;
|
|
}
|
|
);
|
|
function isImportableExportInfo(info) {
|
|
const moduleFile = tryCast(info.moduleSymbol.valueDeclaration, isSourceFile);
|
|
if (!moduleFile) {
|
|
const moduleName = stripQuotes(info.moduleSymbol.name);
|
|
if (ts_JsTyping_exports.nodeCoreModules.has(moduleName) && startsWith(moduleName, "node:") !== shouldUseUriStyleNodeCoreModules(sourceFile, program)) {
|
|
return false;
|
|
}
|
|
return packageJsonFilter ? packageJsonFilter.allowsImportingAmbientModule(info.moduleSymbol, getModuleSpecifierResolutionHost(info.isFromPackageJson)) : true;
|
|
}
|
|
return isImportableFile(
|
|
info.isFromPackageJson ? packageJsonAutoImportProvider : program,
|
|
sourceFile,
|
|
moduleFile,
|
|
preferences,
|
|
packageJsonFilter,
|
|
getModuleSpecifierResolutionHost(info.isFromPackageJson),
|
|
moduleSpecifierCache
|
|
);
|
|
}
|
|
}
|
|
function pushAutoImportSymbol(symbol, origin) {
|
|
const symbolId = getSymbolId(symbol);
|
|
if (symbolToSortTextMap[symbolId] === SortText.GlobalsOrKeywords) {
|
|
return;
|
|
}
|
|
symbolToOriginInfoMap[symbols.length] = origin;
|
|
symbolToSortTextMap[symbolId] = importStatementCompletion ? SortText.LocationPriority : SortText.AutoImportSuggestions;
|
|
symbols.push(symbol);
|
|
}
|
|
function collectObjectLiteralMethodSymbols(members, enclosingDeclaration) {
|
|
if (isInJSFile(location2)) {
|
|
return;
|
|
}
|
|
members.forEach((member) => {
|
|
if (!isObjectLiteralMethodSymbol(member)) {
|
|
return;
|
|
}
|
|
const displayName = getCompletionEntryDisplayNameForSymbol(
|
|
member,
|
|
getEmitScriptTarget(compilerOptions),
|
|
void 0,
|
|
0 /* ObjectPropertyDeclaration */,
|
|
false
|
|
);
|
|
if (!displayName) {
|
|
return;
|
|
}
|
|
const { name } = displayName;
|
|
const entryProps = getEntryForObjectLiteralMethodCompletion(
|
|
member,
|
|
name,
|
|
enclosingDeclaration,
|
|
program,
|
|
host,
|
|
compilerOptions,
|
|
preferences,
|
|
formatContext
|
|
);
|
|
if (!entryProps) {
|
|
return;
|
|
}
|
|
const origin = { kind: 128 /* ObjectLiteralMethod */, ...entryProps };
|
|
flags |= 32 /* MayIncludeMethodSnippets */;
|
|
symbolToOriginInfoMap[symbols.length] = origin;
|
|
symbols.push(member);
|
|
});
|
|
}
|
|
function isObjectLiteralMethodSymbol(symbol) {
|
|
if (!(symbol.flags & (4 /* Property */ | 8192 /* Method */))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getScopeNode(initialToken, position2, sourceFile2) {
|
|
let scope = initialToken;
|
|
while (scope && !positionBelongsToNode(scope, position2, sourceFile2)) {
|
|
scope = scope.parent;
|
|
}
|
|
return scope;
|
|
}
|
|
function isCompletionListBlocker(contextToken2) {
|
|
const start3 = timestamp();
|
|
const result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) || isSolelyIdentifierDefinitionLocation(contextToken2) || isDotOfNumericLiteral(contextToken2) || isInJsxText(contextToken2) || isBigIntLiteral(contextToken2);
|
|
log("getCompletionsAtPosition: isCompletionListBlocker: " + (timestamp() - start3));
|
|
return result;
|
|
}
|
|
function isInJsxText(contextToken2) {
|
|
if (contextToken2.kind === 11 /* JsxText */) {
|
|
return true;
|
|
}
|
|
if (contextToken2.kind === 31 /* GreaterThanToken */ && contextToken2.parent) {
|
|
if (location2 === contextToken2.parent && (location2.kind === 283 /* JsxOpeningElement */ || location2.kind === 282 /* JsxSelfClosingElement */)) {
|
|
return false;
|
|
}
|
|
if (contextToken2.parent.kind === 283 /* JsxOpeningElement */) {
|
|
return location2.parent.kind !== 283 /* JsxOpeningElement */;
|
|
}
|
|
if (contextToken2.parent.kind === 284 /* JsxClosingElement */ || contextToken2.parent.kind === 282 /* JsxSelfClosingElement */) {
|
|
return !!contextToken2.parent.parent && contextToken2.parent.parent.kind === 281 /* JsxElement */;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isNewIdentifierDefinitionLocation() {
|
|
if (contextToken) {
|
|
const containingNodeKind = contextToken.parent.kind;
|
|
const tokenKind = keywordForNode(contextToken);
|
|
switch (tokenKind) {
|
|
case 27 /* CommaToken */:
|
|
return containingNodeKind === 210 /* CallExpression */ || containingNodeKind === 173 /* Constructor */ || containingNodeKind === 211 /* NewExpression */ || containingNodeKind === 206 /* ArrayLiteralExpression */ || containingNodeKind === 223 /* BinaryExpression */ || containingNodeKind === 181 /* FunctionType */ || containingNodeKind === 207 /* ObjectLiteralExpression */;
|
|
case 20 /* OpenParenToken */:
|
|
return containingNodeKind === 210 /* CallExpression */ || containingNodeKind === 173 /* Constructor */ || containingNodeKind === 211 /* NewExpression */ || containingNodeKind === 214 /* ParenthesizedExpression */ || containingNodeKind === 193 /* ParenthesizedType */;
|
|
case 22 /* OpenBracketToken */:
|
|
return containingNodeKind === 206 /* ArrayLiteralExpression */ || containingNodeKind === 178 /* IndexSignature */ || containingNodeKind === 164 /* ComputedPropertyName */;
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
return true;
|
|
case 24 /* DotToken */:
|
|
return containingNodeKind === 264 /* ModuleDeclaration */;
|
|
case 18 /* OpenBraceToken */:
|
|
return containingNodeKind === 260 /* ClassDeclaration */ || containingNodeKind === 207 /* ObjectLiteralExpression */;
|
|
case 63 /* EqualsToken */:
|
|
return containingNodeKind === 257 /* VariableDeclaration */ || containingNodeKind === 223 /* BinaryExpression */;
|
|
case 15 /* TemplateHead */:
|
|
return containingNodeKind === 225 /* TemplateExpression */;
|
|
case 16 /* TemplateMiddle */:
|
|
return containingNodeKind === 236 /* TemplateSpan */;
|
|
case 132 /* AsyncKeyword */:
|
|
return containingNodeKind === 171 /* MethodDeclaration */ || containingNodeKind === 300 /* ShorthandPropertyAssignment */;
|
|
case 41 /* AsteriskToken */:
|
|
return containingNodeKind === 171 /* MethodDeclaration */;
|
|
}
|
|
if (isClassMemberCompletionKeyword(tokenKind)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) {
|
|
return (isRegularExpressionLiteral(contextToken2) || isStringTextContainingNode(contextToken2)) && (rangeContainsPositionExclusive(createTextRangeFromSpan(createTextSpanFromNode(contextToken2)), position) || position === contextToken2.end && (!!contextToken2.isUnterminated || isRegularExpressionLiteral(contextToken2)));
|
|
}
|
|
function tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() {
|
|
const typeLiteralNode = tryGetTypeLiteralNode(contextToken);
|
|
if (!typeLiteralNode)
|
|
return 0 /* Continue */;
|
|
const intersectionTypeNode = isIntersectionTypeNode(typeLiteralNode.parent) ? typeLiteralNode.parent : void 0;
|
|
const containerTypeNode = intersectionTypeNode || typeLiteralNode;
|
|
const containerExpectedType = getConstraintOfTypeArgumentProperty(containerTypeNode, typeChecker);
|
|
if (!containerExpectedType)
|
|
return 0 /* Continue */;
|
|
const containerActualType = typeChecker.getTypeFromTypeNode(containerTypeNode);
|
|
const members = getPropertiesForCompletion(containerExpectedType, typeChecker);
|
|
const existingMembers = getPropertiesForCompletion(containerActualType, typeChecker);
|
|
const existingMemberEscapedNames = /* @__PURE__ */ new Set();
|
|
existingMembers.forEach((s) => existingMemberEscapedNames.add(s.escapedName));
|
|
symbols = concatenate(symbols, filter(members, (s) => !existingMemberEscapedNames.has(s.escapedName)));
|
|
completionKind = 0 /* ObjectPropertyDeclaration */;
|
|
isNewIdentifierLocation = true;
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetObjectLikeCompletionSymbols() {
|
|
const symbolsStartIndex = symbols.length;
|
|
const objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken);
|
|
if (!objectLikeContainer)
|
|
return 0 /* Continue */;
|
|
completionKind = 0 /* ObjectPropertyDeclaration */;
|
|
let typeMembers;
|
|
let existingMembers;
|
|
if (objectLikeContainer.kind === 207 /* ObjectLiteralExpression */) {
|
|
const instantiatedType = tryGetObjectLiteralContextualType(objectLikeContainer, typeChecker);
|
|
if (instantiatedType === void 0) {
|
|
if (objectLikeContainer.flags & 33554432 /* InWithStatement */) {
|
|
return 2 /* Fail */;
|
|
}
|
|
isNonContextualObjectLiteral = true;
|
|
return 0 /* Continue */;
|
|
}
|
|
const completionsType = typeChecker.getContextualType(objectLikeContainer, 4 /* Completions */);
|
|
const hasStringIndexType = (completionsType || instantiatedType).getStringIndexType();
|
|
const hasNumberIndextype = (completionsType || instantiatedType).getNumberIndexType();
|
|
isNewIdentifierLocation = !!hasStringIndexType || !!hasNumberIndextype;
|
|
typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker);
|
|
existingMembers = objectLikeContainer.properties;
|
|
if (typeMembers.length === 0) {
|
|
if (!hasNumberIndextype) {
|
|
isNonContextualObjectLiteral = true;
|
|
return 0 /* Continue */;
|
|
}
|
|
}
|
|
} else {
|
|
Debug.assert(objectLikeContainer.kind === 203 /* ObjectBindingPattern */);
|
|
isNewIdentifierLocation = false;
|
|
const rootDeclaration = getRootDeclaration(objectLikeContainer.parent);
|
|
if (!isVariableLike(rootDeclaration))
|
|
return Debug.fail("Root declaration is not variable-like.");
|
|
let canGetType = hasInitializer(rootDeclaration) || !!getEffectiveTypeAnnotationNode(rootDeclaration) || rootDeclaration.parent.parent.kind === 247 /* ForOfStatement */;
|
|
if (!canGetType && rootDeclaration.kind === 166 /* Parameter */) {
|
|
if (isExpression(rootDeclaration.parent)) {
|
|
canGetType = !!typeChecker.getContextualType(rootDeclaration.parent);
|
|
} else if (rootDeclaration.parent.kind === 171 /* MethodDeclaration */ || rootDeclaration.parent.kind === 175 /* SetAccessor */) {
|
|
canGetType = isExpression(rootDeclaration.parent.parent) && !!typeChecker.getContextualType(rootDeclaration.parent.parent);
|
|
}
|
|
}
|
|
if (canGetType) {
|
|
const typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer);
|
|
if (!typeForObject)
|
|
return 2 /* Fail */;
|
|
typeMembers = typeChecker.getPropertiesOfType(typeForObject).filter((propertySymbol) => {
|
|
return typeChecker.isPropertyAccessible(objectLikeContainer, false, false, typeForObject, propertySymbol);
|
|
});
|
|
existingMembers = objectLikeContainer.elements;
|
|
}
|
|
}
|
|
if (typeMembers && typeMembers.length > 0) {
|
|
const filteredMembers = filterObjectMembersList(typeMembers, Debug.checkDefined(existingMembers));
|
|
symbols = concatenate(symbols, filteredMembers);
|
|
setSortTextToOptionalMember();
|
|
if (objectLikeContainer.kind === 207 /* ObjectLiteralExpression */ && preferences.includeCompletionsWithObjectLiteralMethodSnippets && preferences.includeCompletionsWithInsertText) {
|
|
transformObjectLiteralMembersSortText(symbolsStartIndex);
|
|
collectObjectLiteralMethodSymbols(filteredMembers, objectLikeContainer);
|
|
}
|
|
}
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetImportOrExportClauseCompletionSymbols() {
|
|
if (!contextToken)
|
|
return 0 /* Continue */;
|
|
const namedImportsOrExports = contextToken.kind === 18 /* OpenBraceToken */ || contextToken.kind === 27 /* CommaToken */ ? tryCast(contextToken.parent, isNamedImportsOrExports) : isTypeKeywordTokenOrIdentifier(contextToken) ? tryCast(contextToken.parent.parent, isNamedImportsOrExports) : void 0;
|
|
if (!namedImportsOrExports)
|
|
return 0 /* Continue */;
|
|
if (!isTypeKeywordTokenOrIdentifier(contextToken)) {
|
|
keywordFilters = 8 /* TypeKeyword */;
|
|
}
|
|
const { moduleSpecifier } = namedImportsOrExports.kind === 272 /* NamedImports */ ? namedImportsOrExports.parent.parent : namedImportsOrExports.parent;
|
|
if (!moduleSpecifier) {
|
|
isNewIdentifierLocation = true;
|
|
return namedImportsOrExports.kind === 272 /* NamedImports */ ? 2 /* Fail */ : 0 /* Continue */;
|
|
}
|
|
const moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier);
|
|
if (!moduleSpecifierSymbol) {
|
|
isNewIdentifierLocation = true;
|
|
return 2 /* Fail */;
|
|
}
|
|
completionKind = 3 /* MemberLike */;
|
|
isNewIdentifierLocation = false;
|
|
const exports = typeChecker.getExportsAndPropertiesOfModule(moduleSpecifierSymbol);
|
|
const existing = new Set(namedImportsOrExports.elements.filter((n) => !isCurrentlyEditingNode(n)).map((n) => (n.propertyName || n.name).escapedText));
|
|
const uniques = exports.filter((e) => e.escapedName !== "default" /* Default */ && !existing.has(e.escapedName));
|
|
symbols = concatenate(symbols, uniques);
|
|
if (!uniques.length) {
|
|
keywordFilters = 0 /* None */;
|
|
}
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetLocalNamedExportCompletionSymbols() {
|
|
var _a2;
|
|
const namedExports = contextToken && (contextToken.kind === 18 /* OpenBraceToken */ || contextToken.kind === 27 /* CommaToken */) ? tryCast(contextToken.parent, isNamedExports) : void 0;
|
|
if (!namedExports) {
|
|
return 0 /* Continue */;
|
|
}
|
|
const localsContainer = findAncestor(namedExports, or(isSourceFile, isModuleDeclaration));
|
|
completionKind = 5 /* None */;
|
|
isNewIdentifierLocation = false;
|
|
(_a2 = localsContainer.locals) == null ? void 0 : _a2.forEach((symbol, name) => {
|
|
var _a3, _b;
|
|
symbols.push(symbol);
|
|
if ((_b = (_a3 = localsContainer.symbol) == null ? void 0 : _a3.exports) == null ? void 0 : _b.has(name)) {
|
|
symbolToSortTextMap[getSymbolId(symbol)] = SortText.OptionalMember;
|
|
}
|
|
});
|
|
return 1 /* Success */;
|
|
}
|
|
function tryGetClassLikeCompletionSymbols() {
|
|
const decl = tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location2, position);
|
|
if (!decl)
|
|
return 0 /* Continue */;
|
|
completionKind = 3 /* MemberLike */;
|
|
isNewIdentifierLocation = true;
|
|
keywordFilters = contextToken.kind === 41 /* AsteriskToken */ ? 0 /* None */ : isClassLike(decl) ? 2 /* ClassElementKeywords */ : 3 /* InterfaceElementKeywords */;
|
|
if (!isClassLike(decl))
|
|
return 1 /* Success */;
|
|
const classElement = contextToken.kind === 26 /* SemicolonToken */ ? contextToken.parent.parent : contextToken.parent;
|
|
let classElementModifierFlags = isClassElement(classElement) ? getEffectiveModifierFlags(classElement) : 0 /* None */;
|
|
if (contextToken.kind === 79 /* Identifier */ && !isCurrentlyEditingNode(contextToken)) {
|
|
switch (contextToken.getText()) {
|
|
case "private":
|
|
classElementModifierFlags = classElementModifierFlags | 8 /* Private */;
|
|
break;
|
|
case "static":
|
|
classElementModifierFlags = classElementModifierFlags | 32 /* Static */;
|
|
break;
|
|
case "override":
|
|
classElementModifierFlags = classElementModifierFlags | 16384 /* Override */;
|
|
break;
|
|
}
|
|
}
|
|
if (isClassStaticBlockDeclaration(classElement)) {
|
|
classElementModifierFlags |= 32 /* Static */;
|
|
}
|
|
if (!(classElementModifierFlags & 8 /* Private */)) {
|
|
const baseTypeNodes = isClassLike(decl) && classElementModifierFlags & 16384 /* Override */ ? singleElementArray(getEffectiveBaseTypeNode(decl)) : getAllSuperTypeNodes(decl);
|
|
const baseSymbols = flatMap(baseTypeNodes, (baseTypeNode) => {
|
|
const type = typeChecker.getTypeAtLocation(baseTypeNode);
|
|
return classElementModifierFlags & 32 /* Static */ ? (type == null ? void 0 : type.symbol) && typeChecker.getPropertiesOfType(typeChecker.getTypeOfSymbolAtLocation(type.symbol, decl)) : type && typeChecker.getPropertiesOfType(type);
|
|
});
|
|
symbols = concatenate(symbols, filterClassMembersList(baseSymbols, decl.members, classElementModifierFlags));
|
|
}
|
|
return 1 /* Success */;
|
|
}
|
|
function isConstructorParameterCompletion(node2) {
|
|
return !!node2.parent && isParameter(node2.parent) && isConstructorDeclaration(node2.parent.parent) && (isParameterPropertyModifier(node2.kind) || isDeclarationName(node2));
|
|
}
|
|
function tryGetConstructorLikeCompletionContainer(contextToken2) {
|
|
if (contextToken2) {
|
|
const parent2 = contextToken2.parent;
|
|
switch (contextToken2.kind) {
|
|
case 20 /* OpenParenToken */:
|
|
case 27 /* CommaToken */:
|
|
return isConstructorDeclaration(contextToken2.parent) ? contextToken2.parent : void 0;
|
|
default:
|
|
if (isConstructorParameterCompletion(contextToken2)) {
|
|
return parent2.parent;
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function tryGetFunctionLikeBodyCompletionContainer(contextToken2) {
|
|
if (contextToken2) {
|
|
let prev;
|
|
const container = findAncestor(contextToken2.parent, (node2) => {
|
|
if (isClassLike(node2)) {
|
|
return "quit";
|
|
}
|
|
if (isFunctionLikeDeclaration(node2) && prev === node2.body) {
|
|
return true;
|
|
}
|
|
prev = node2;
|
|
return false;
|
|
});
|
|
return container && container;
|
|
}
|
|
}
|
|
function tryGetContainingJsxElement(contextToken2) {
|
|
if (contextToken2) {
|
|
const parent2 = contextToken2.parent;
|
|
switch (contextToken2.kind) {
|
|
case 31 /* GreaterThanToken */:
|
|
case 30 /* LessThanSlashToken */:
|
|
case 43 /* SlashToken */:
|
|
case 79 /* Identifier */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 289 /* JsxAttributes */:
|
|
case 288 /* JsxAttribute */:
|
|
case 290 /* JsxSpreadAttribute */:
|
|
if (parent2 && (parent2.kind === 282 /* JsxSelfClosingElement */ || parent2.kind === 283 /* JsxOpeningElement */)) {
|
|
if (contextToken2.kind === 31 /* GreaterThanToken */) {
|
|
const precedingToken = findPrecedingToken(contextToken2.pos, sourceFile, void 0);
|
|
if (!parent2.typeArguments || precedingToken && precedingToken.kind === 43 /* SlashToken */)
|
|
break;
|
|
}
|
|
return parent2;
|
|
} else if (parent2.kind === 288 /* JsxAttribute */) {
|
|
return parent2.parent.parent;
|
|
}
|
|
break;
|
|
case 10 /* StringLiteral */:
|
|
if (parent2 && (parent2.kind === 288 /* JsxAttribute */ || parent2.kind === 290 /* JsxSpreadAttribute */)) {
|
|
return parent2.parent.parent;
|
|
}
|
|
break;
|
|
case 19 /* CloseBraceToken */:
|
|
if (parent2 && parent2.kind === 291 /* JsxExpression */ && parent2.parent && parent2.parent.kind === 288 /* JsxAttribute */) {
|
|
return parent2.parent.parent.parent;
|
|
}
|
|
if (parent2 && parent2.kind === 290 /* JsxSpreadAttribute */) {
|
|
return parent2.parent.parent;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function isSolelyIdentifierDefinitionLocation(contextToken2) {
|
|
const parent2 = contextToken2.parent;
|
|
const containingNodeKind = parent2.kind;
|
|
switch (contextToken2.kind) {
|
|
case 27 /* CommaToken */:
|
|
return containingNodeKind === 257 /* VariableDeclaration */ || isVariableDeclarationListButNotTypeArgument(contextToken2) || containingNodeKind === 240 /* VariableStatement */ || containingNodeKind === 263 /* EnumDeclaration */ || isFunctionLikeButNotConstructor(containingNodeKind) || containingNodeKind === 261 /* InterfaceDeclaration */ || containingNodeKind === 204 /* ArrayBindingPattern */ || containingNodeKind === 262 /* TypeAliasDeclaration */ || isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
|
|
case 24 /* DotToken */:
|
|
return containingNodeKind === 204 /* ArrayBindingPattern */;
|
|
case 58 /* ColonToken */:
|
|
return containingNodeKind === 205 /* BindingElement */;
|
|
case 22 /* OpenBracketToken */:
|
|
return containingNodeKind === 204 /* ArrayBindingPattern */;
|
|
case 20 /* OpenParenToken */:
|
|
return containingNodeKind === 295 /* CatchClause */ || isFunctionLikeButNotConstructor(containingNodeKind);
|
|
case 18 /* OpenBraceToken */:
|
|
return containingNodeKind === 263 /* EnumDeclaration */;
|
|
case 29 /* LessThanToken */:
|
|
return containingNodeKind === 260 /* ClassDeclaration */ || containingNodeKind === 228 /* ClassExpression */ || containingNodeKind === 261 /* InterfaceDeclaration */ || containingNodeKind === 262 /* TypeAliasDeclaration */ || isFunctionLikeKind(containingNodeKind);
|
|
case 124 /* StaticKeyword */:
|
|
return containingNodeKind === 169 /* PropertyDeclaration */ && !isClassLike(parent2.parent);
|
|
case 25 /* DotDotDotToken */:
|
|
return containingNodeKind === 166 /* Parameter */ || !!parent2.parent && parent2.parent.kind === 204 /* ArrayBindingPattern */;
|
|
case 123 /* PublicKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
return containingNodeKind === 166 /* Parameter */ && !isConstructorDeclaration(parent2.parent);
|
|
case 128 /* AsKeyword */:
|
|
return containingNodeKind === 273 /* ImportSpecifier */ || containingNodeKind === 278 /* ExportSpecifier */ || containingNodeKind === 271 /* NamespaceImport */;
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
return !isFromObjectTypeDeclaration(contextToken2);
|
|
case 79 /* Identifier */:
|
|
if (containingNodeKind === 273 /* ImportSpecifier */ && contextToken2 === parent2.name && contextToken2.text === "type") {
|
|
return false;
|
|
}
|
|
break;
|
|
case 84 /* ClassKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 113 /* VarKeyword */:
|
|
case 100 /* ImportKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 138 /* InferKeyword */:
|
|
return true;
|
|
case 154 /* TypeKeyword */:
|
|
return containingNodeKind !== 273 /* ImportSpecifier */;
|
|
case 41 /* AsteriskToken */:
|
|
return isFunctionLike(contextToken2.parent) && !isMethodDeclaration(contextToken2.parent);
|
|
}
|
|
if (isClassMemberCompletionKeyword(keywordForNode(contextToken2)) && isFromObjectTypeDeclaration(contextToken2)) {
|
|
return false;
|
|
}
|
|
if (isConstructorParameterCompletion(contextToken2)) {
|
|
if (!isIdentifier(contextToken2) || isParameterPropertyModifier(keywordForNode(contextToken2)) || isCurrentlyEditingNode(contextToken2)) {
|
|
return false;
|
|
}
|
|
}
|
|
switch (keywordForNode(contextToken2)) {
|
|
case 126 /* AbstractKeyword */:
|
|
case 84 /* ClassKeyword */:
|
|
case 85 /* ConstKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 98 /* FunctionKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 119 /* LetKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 124 /* StaticKeyword */:
|
|
case 113 /* VarKeyword */:
|
|
return true;
|
|
case 132 /* AsyncKeyword */:
|
|
return isPropertyDeclaration(contextToken2.parent);
|
|
}
|
|
const ancestorClassLike = findAncestor(contextToken2.parent, isClassLike);
|
|
if (ancestorClassLike && contextToken2 === previousToken && isPreviousPropertyDeclarationTerminated(contextToken2, position)) {
|
|
return false;
|
|
}
|
|
const ancestorPropertyDeclaraion = getAncestor(contextToken2.parent, 169 /* PropertyDeclaration */);
|
|
if (ancestorPropertyDeclaraion && contextToken2 !== previousToken && isClassLike(previousToken.parent.parent) && position <= previousToken.end) {
|
|
if (isPreviousPropertyDeclarationTerminated(contextToken2, previousToken.end)) {
|
|
return false;
|
|
} else if (contextToken2.kind !== 63 /* EqualsToken */ && (isInitializedProperty(ancestorPropertyDeclaraion) || hasType(ancestorPropertyDeclaraion))) {
|
|
return true;
|
|
}
|
|
}
|
|
return isDeclarationName(contextToken2) && !isShorthandPropertyAssignment(contextToken2.parent) && !isJsxAttribute(contextToken2.parent) && !(isClassLike(contextToken2.parent) && (contextToken2 !== previousToken || position > previousToken.end));
|
|
}
|
|
function isPreviousPropertyDeclarationTerminated(contextToken2, position2) {
|
|
return contextToken2.kind !== 63 /* EqualsToken */ && (contextToken2.kind === 26 /* SemicolonToken */ || !positionsAreOnSameLine(contextToken2.end, position2, sourceFile));
|
|
}
|
|
function isFunctionLikeButNotConstructor(kind) {
|
|
return isFunctionLikeKind(kind) && kind !== 173 /* Constructor */;
|
|
}
|
|
function isDotOfNumericLiteral(contextToken2) {
|
|
if (contextToken2.kind === 8 /* NumericLiteral */) {
|
|
const text = contextToken2.getFullText();
|
|
return text.charAt(text.length - 1) === ".";
|
|
}
|
|
return false;
|
|
}
|
|
function isVariableDeclarationListButNotTypeArgument(node2) {
|
|
return node2.parent.kind === 258 /* VariableDeclarationList */ && !isPossiblyTypeArgumentPosition(node2, sourceFile, typeChecker);
|
|
}
|
|
function filterObjectMembersList(contextualMemberSymbols, existingMembers) {
|
|
if (existingMembers.length === 0) {
|
|
return contextualMemberSymbols;
|
|
}
|
|
const membersDeclaredBySpreadAssignment = /* @__PURE__ */ new Set();
|
|
const existingMemberNames = /* @__PURE__ */ new Set();
|
|
for (const m of existingMembers) {
|
|
if (m.kind !== 299 /* PropertyAssignment */ && m.kind !== 300 /* ShorthandPropertyAssignment */ && m.kind !== 205 /* BindingElement */ && m.kind !== 171 /* MethodDeclaration */ && m.kind !== 174 /* GetAccessor */ && m.kind !== 175 /* SetAccessor */ && m.kind !== 301 /* SpreadAssignment */) {
|
|
continue;
|
|
}
|
|
if (isCurrentlyEditingNode(m)) {
|
|
continue;
|
|
}
|
|
let existingName;
|
|
if (isSpreadAssignment(m)) {
|
|
setMembersDeclaredBySpreadAssignment(m, membersDeclaredBySpreadAssignment);
|
|
} else if (isBindingElement(m) && m.propertyName) {
|
|
if (m.propertyName.kind === 79 /* Identifier */) {
|
|
existingName = m.propertyName.escapedText;
|
|
}
|
|
} else {
|
|
const name = getNameOfDeclaration(m);
|
|
existingName = name && isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : void 0;
|
|
}
|
|
if (existingName !== void 0) {
|
|
existingMemberNames.add(existingName);
|
|
}
|
|
}
|
|
const filteredSymbols = contextualMemberSymbols.filter((m) => !existingMemberNames.has(m.escapedName));
|
|
setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols);
|
|
return filteredSymbols;
|
|
}
|
|
function setMembersDeclaredBySpreadAssignment(declaration, membersDeclaredBySpreadAssignment) {
|
|
const expression = declaration.expression;
|
|
const symbol = typeChecker.getSymbolAtLocation(expression);
|
|
const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
|
|
const properties = type && type.properties;
|
|
if (properties) {
|
|
properties.forEach((property) => {
|
|
membersDeclaredBySpreadAssignment.add(property.name);
|
|
});
|
|
}
|
|
}
|
|
function setSortTextToOptionalMember() {
|
|
symbols.forEach((m) => {
|
|
var _a2;
|
|
if (m.flags & 16777216 /* Optional */) {
|
|
const symbolId = getSymbolId(m);
|
|
symbolToSortTextMap[symbolId] = (_a2 = symbolToSortTextMap[symbolId]) != null ? _a2 : SortText.OptionalMember;
|
|
}
|
|
});
|
|
}
|
|
function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, contextualMemberSymbols) {
|
|
if (membersDeclaredBySpreadAssignment.size === 0) {
|
|
return;
|
|
}
|
|
for (const contextualMemberSymbol of contextualMemberSymbols) {
|
|
if (membersDeclaredBySpreadAssignment.has(contextualMemberSymbol.name)) {
|
|
symbolToSortTextMap[getSymbolId(contextualMemberSymbol)] = SortText.MemberDeclaredBySpreadAssignment;
|
|
}
|
|
}
|
|
}
|
|
function transformObjectLiteralMembersSortText(start3) {
|
|
var _a2;
|
|
for (let i = start3; i < symbols.length; i++) {
|
|
const symbol = symbols[i];
|
|
const symbolId = getSymbolId(symbol);
|
|
const origin = symbolToOriginInfoMap == null ? void 0 : symbolToOriginInfoMap[i];
|
|
const target = getEmitScriptTarget(compilerOptions);
|
|
const displayName = getCompletionEntryDisplayNameForSymbol(
|
|
symbol,
|
|
target,
|
|
origin,
|
|
0 /* ObjectPropertyDeclaration */,
|
|
false
|
|
);
|
|
if (displayName) {
|
|
const originalSortText = (_a2 = symbolToSortTextMap[symbolId]) != null ? _a2 : SortText.LocationPriority;
|
|
const { name } = displayName;
|
|
symbolToSortTextMap[symbolId] = SortText.ObjectLiteralProperty(originalSortText, name);
|
|
}
|
|
}
|
|
}
|
|
function filterClassMembersList(baseSymbols, existingMembers, currentClassElementModifierFlags) {
|
|
const existingMemberNames = /* @__PURE__ */ new Set();
|
|
for (const m of existingMembers) {
|
|
if (m.kind !== 169 /* PropertyDeclaration */ && m.kind !== 171 /* MethodDeclaration */ && m.kind !== 174 /* GetAccessor */ && m.kind !== 175 /* SetAccessor */) {
|
|
continue;
|
|
}
|
|
if (isCurrentlyEditingNode(m)) {
|
|
continue;
|
|
}
|
|
if (hasEffectiveModifier(m, 8 /* Private */)) {
|
|
continue;
|
|
}
|
|
if (isStatic(m) !== !!(currentClassElementModifierFlags & 32 /* Static */)) {
|
|
continue;
|
|
}
|
|
const existingName = getPropertyNameForPropertyNameNode(m.name);
|
|
if (existingName) {
|
|
existingMemberNames.add(existingName);
|
|
}
|
|
}
|
|
return baseSymbols.filter((propertySymbol) => !existingMemberNames.has(propertySymbol.escapedName) && !!propertySymbol.declarations && !(getDeclarationModifierFlagsFromSymbol(propertySymbol) & 8 /* Private */) && !(propertySymbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(propertySymbol.valueDeclaration)));
|
|
}
|
|
function filterJsxAttributes(symbols2, attributes) {
|
|
const seenNames = /* @__PURE__ */ new Set();
|
|
const membersDeclaredBySpreadAssignment = /* @__PURE__ */ new Set();
|
|
for (const attr of attributes) {
|
|
if (isCurrentlyEditingNode(attr)) {
|
|
continue;
|
|
}
|
|
if (attr.kind === 288 /* JsxAttribute */) {
|
|
seenNames.add(attr.name.escapedText);
|
|
} else if (isJsxSpreadAttribute(attr)) {
|
|
setMembersDeclaredBySpreadAssignment(attr, membersDeclaredBySpreadAssignment);
|
|
}
|
|
}
|
|
const filteredSymbols = symbols2.filter((a) => !seenNames.has(a.escapedName));
|
|
setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols);
|
|
return filteredSymbols;
|
|
}
|
|
function isCurrentlyEditingNode(node2) {
|
|
return node2.getStart(sourceFile) <= position && position <= node2.getEnd();
|
|
}
|
|
}
|
|
function tryGetObjectLikeCompletionContainer(contextToken) {
|
|
if (contextToken) {
|
|
const { parent: parent2 } = contextToken;
|
|
switch (contextToken.kind) {
|
|
case 18 /* OpenBraceToken */:
|
|
case 27 /* CommaToken */:
|
|
if (isObjectLiteralExpression(parent2) || isObjectBindingPattern(parent2)) {
|
|
return parent2;
|
|
}
|
|
break;
|
|
case 41 /* AsteriskToken */:
|
|
return isMethodDeclaration(parent2) ? tryCast(parent2.parent, isObjectLiteralExpression) : void 0;
|
|
case 79 /* Identifier */:
|
|
return contextToken.text === "async" && isShorthandPropertyAssignment(contextToken.parent) ? contextToken.parent.parent : void 0;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getRelevantTokens(position, sourceFile) {
|
|
const previousToken = findPrecedingToken(position, sourceFile);
|
|
if (previousToken && position <= previousToken.end && (isMemberName(previousToken) || isKeyword(previousToken.kind))) {
|
|
const contextToken = findPrecedingToken(previousToken.getFullStart(), sourceFile, void 0);
|
|
return { contextToken, previousToken };
|
|
}
|
|
return { contextToken: previousToken, previousToken };
|
|
}
|
|
function getAutoImportSymbolFromCompletionEntryData(name, data, program, host) {
|
|
const containingProgram = data.isPackageJsonImport ? host.getPackageJsonAutoImportProvider() : program;
|
|
const checker = containingProgram.getTypeChecker();
|
|
const moduleSymbol = data.ambientModuleName ? checker.tryFindAmbientModule(data.ambientModuleName) : data.fileName ? checker.getMergedSymbol(Debug.checkDefined(containingProgram.getSourceFile(data.fileName)).symbol) : void 0;
|
|
if (!moduleSymbol)
|
|
return void 0;
|
|
let symbol = data.exportName === "export=" /* ExportEquals */ ? checker.resolveExternalModuleSymbol(moduleSymbol) : checker.tryGetMemberInModuleExportsAndProperties(data.exportName, moduleSymbol);
|
|
if (!symbol)
|
|
return void 0;
|
|
const isDefaultExport = data.exportName === "default" /* Default */;
|
|
symbol = isDefaultExport && getLocalSymbolForExportDefault(symbol) || symbol;
|
|
return { symbol, origin: completionEntryDataToSymbolOriginInfo(data, name, moduleSymbol) };
|
|
}
|
|
function getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, jsxIdentifierExpected) {
|
|
const name = originIncludesSymbolName(origin) ? origin.symbolName : symbol.name;
|
|
if (name === void 0 || symbol.flags & 1536 /* Module */ && isSingleOrDoubleQuote(name.charCodeAt(0)) || isKnownSymbol(symbol)) {
|
|
return void 0;
|
|
}
|
|
const validNameResult = { name, needsConvertPropertyAccess: false };
|
|
if (isIdentifierText(name, target, jsxIdentifierExpected ? 1 /* JSX */ : 0 /* Standard */) || symbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) {
|
|
return validNameResult;
|
|
}
|
|
switch (kind) {
|
|
case 3 /* MemberLike */:
|
|
return void 0;
|
|
case 0 /* ObjectPropertyDeclaration */:
|
|
return { name: JSON.stringify(name), needsConvertPropertyAccess: false };
|
|
case 2 /* PropertyAccess */:
|
|
case 1 /* Global */:
|
|
return name.charCodeAt(0) === 32 /* space */ ? void 0 : { name, needsConvertPropertyAccess: true };
|
|
case 5 /* None */:
|
|
case 4 /* String */:
|
|
return validNameResult;
|
|
default:
|
|
Debug.assertNever(kind);
|
|
}
|
|
}
|
|
var _keywordCompletions = [];
|
|
var allKeywordsCompletions = memoize(() => {
|
|
const res = [];
|
|
for (let i = 81 /* FirstKeyword */; i <= 162 /* LastKeyword */; i++) {
|
|
res.push({
|
|
name: tokenToString(i),
|
|
kind: "keyword" /* keyword */,
|
|
kindModifiers: "" /* none */,
|
|
sortText: SortText.GlobalsOrKeywords
|
|
});
|
|
}
|
|
return res;
|
|
});
|
|
function getKeywordCompletions(keywordFilter, filterOutTsOnlyKeywords) {
|
|
if (!filterOutTsOnlyKeywords)
|
|
return getTypescriptKeywordCompletions(keywordFilter);
|
|
const index = keywordFilter + 8 /* Last */ + 1;
|
|
return _keywordCompletions[index] || (_keywordCompletions[index] = getTypescriptKeywordCompletions(keywordFilter).filter((entry) => !isTypeScriptOnlyKeyword(stringToToken(entry.name))));
|
|
}
|
|
function getTypescriptKeywordCompletions(keywordFilter) {
|
|
return _keywordCompletions[keywordFilter] || (_keywordCompletions[keywordFilter] = allKeywordsCompletions().filter((entry) => {
|
|
const kind = stringToToken(entry.name);
|
|
switch (keywordFilter) {
|
|
case 0 /* None */:
|
|
return false;
|
|
case 1 /* All */:
|
|
return isFunctionLikeBodyKeyword(kind) || kind === 136 /* DeclareKeyword */ || kind === 142 /* ModuleKeyword */ || kind === 154 /* TypeKeyword */ || kind === 143 /* NamespaceKeyword */ || kind === 126 /* AbstractKeyword */ || isTypeKeyword(kind) && kind !== 155 /* UndefinedKeyword */;
|
|
case 5 /* FunctionLikeBodyKeywords */:
|
|
return isFunctionLikeBodyKeyword(kind);
|
|
case 2 /* ClassElementKeywords */:
|
|
return isClassMemberCompletionKeyword(kind);
|
|
case 3 /* InterfaceElementKeywords */:
|
|
return isInterfaceOrTypeLiteralCompletionKeyword(kind);
|
|
case 4 /* ConstructorParameterKeywords */:
|
|
return isParameterPropertyModifier(kind);
|
|
case 6 /* TypeAssertionKeywords */:
|
|
return isTypeKeyword(kind) || kind === 85 /* ConstKeyword */;
|
|
case 7 /* TypeKeywords */:
|
|
return isTypeKeyword(kind);
|
|
case 8 /* TypeKeyword */:
|
|
return kind === 154 /* TypeKeyword */;
|
|
default:
|
|
return Debug.assertNever(keywordFilter);
|
|
}
|
|
}));
|
|
}
|
|
function isTypeScriptOnlyKeyword(kind) {
|
|
switch (kind) {
|
|
case 126 /* AbstractKeyword */:
|
|
case 131 /* AnyKeyword */:
|
|
case 160 /* BigIntKeyword */:
|
|
case 134 /* BooleanKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 92 /* EnumKeyword */:
|
|
case 159 /* GlobalKeyword */:
|
|
case 117 /* ImplementsKeyword */:
|
|
case 138 /* InferKeyword */:
|
|
case 118 /* InterfaceKeyword */:
|
|
case 140 /* IsKeyword */:
|
|
case 141 /* KeyOfKeyword */:
|
|
case 142 /* ModuleKeyword */:
|
|
case 143 /* NamespaceKeyword */:
|
|
case 144 /* NeverKeyword */:
|
|
case 148 /* NumberKeyword */:
|
|
case 149 /* ObjectKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
case 121 /* PrivateKeyword */:
|
|
case 122 /* ProtectedKeyword */:
|
|
case 123 /* PublicKeyword */:
|
|
case 146 /* ReadonlyKeyword */:
|
|
case 152 /* StringKeyword */:
|
|
case 153 /* SymbolKeyword */:
|
|
case 154 /* TypeKeyword */:
|
|
case 156 /* UniqueKeyword */:
|
|
case 157 /* UnknownKeyword */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInterfaceOrTypeLiteralCompletionKeyword(kind) {
|
|
return kind === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function isClassMemberCompletionKeyword(kind) {
|
|
switch (kind) {
|
|
case 126 /* AbstractKeyword */:
|
|
case 127 /* AccessorKeyword */:
|
|
case 135 /* ConstructorKeyword */:
|
|
case 137 /* GetKeyword */:
|
|
case 151 /* SetKeyword */:
|
|
case 132 /* AsyncKeyword */:
|
|
case 136 /* DeclareKeyword */:
|
|
case 161 /* OverrideKeyword */:
|
|
return true;
|
|
default:
|
|
return isClassMemberModifier(kind);
|
|
}
|
|
}
|
|
function isFunctionLikeBodyKeyword(kind) {
|
|
return kind === 132 /* AsyncKeyword */ || kind === 133 /* AwaitKeyword */ || kind === 128 /* AsKeyword */ || kind === 150 /* SatisfiesKeyword */ || kind === 154 /* TypeKeyword */ || !isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind);
|
|
}
|
|
function keywordForNode(node) {
|
|
return isIdentifier(node) ? node.originalKeywordKind || 0 /* Unknown */ : node.kind;
|
|
}
|
|
function getContextualKeywords(contextToken, position) {
|
|
const entries = [];
|
|
if (contextToken) {
|
|
const file = contextToken.getSourceFile();
|
|
const parent2 = contextToken.parent;
|
|
const tokenLine = file.getLineAndCharacterOfPosition(contextToken.end).line;
|
|
const currentLine = file.getLineAndCharacterOfPosition(position).line;
|
|
if ((isImportDeclaration(parent2) || isExportDeclaration(parent2) && parent2.moduleSpecifier) && contextToken === parent2.moduleSpecifier && tokenLine === currentLine) {
|
|
entries.push({
|
|
name: tokenToString(130 /* AssertKeyword */),
|
|
kind: "keyword" /* keyword */,
|
|
kindModifiers: "" /* none */,
|
|
sortText: SortText.GlobalsOrKeywords
|
|
});
|
|
}
|
|
}
|
|
return entries;
|
|
}
|
|
function getJsDocTagAtPosition(node, position) {
|
|
return findAncestor(node, (n) => isJSDocTag(n) && rangeContainsPosition(n, position) ? true : isJSDoc(n) ? "quit" : false);
|
|
}
|
|
function getPropertiesForObjectExpression(contextualType, completionsType, obj, checker) {
|
|
const hasCompletionsType = completionsType && completionsType !== contextualType;
|
|
const type = hasCompletionsType && !(completionsType.flags & 3 /* AnyOrUnknown */) ? checker.getUnionType([contextualType, completionsType]) : contextualType;
|
|
const properties = getApparentProperties(type, obj, checker);
|
|
return type.isClass() && containsNonPublicProperties(properties) ? [] : hasCompletionsType ? filter(properties, hasDeclarationOtherThanSelf) : properties;
|
|
function hasDeclarationOtherThanSelf(member) {
|
|
if (!length(member.declarations))
|
|
return true;
|
|
return some(member.declarations, (decl) => decl.parent !== obj);
|
|
}
|
|
}
|
|
function getApparentProperties(type, node, checker) {
|
|
if (!type.isUnion())
|
|
return type.getApparentProperties();
|
|
return checker.getAllPossiblePropertiesOfTypes(filter(type.types, (memberType) => !(memberType.flags & 131068 /* Primitive */ || checker.isArrayLikeType(memberType) || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) || typeHasCallOrConstructSignatures(memberType, checker) || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties()))));
|
|
}
|
|
function containsNonPublicProperties(props) {
|
|
return some(props, (p) => !!(getDeclarationModifierFlagsFromSymbol(p) & 24 /* NonPublicAccessibilityModifier */));
|
|
}
|
|
function getPropertiesForCompletion(type, checker) {
|
|
return type.isUnion() ? Debug.checkEachDefined(checker.getAllPossiblePropertiesOfTypes(type.types), "getAllPossiblePropertiesOfTypes() should all be defined") : Debug.checkEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined");
|
|
}
|
|
function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location2, position) {
|
|
switch (location2.kind) {
|
|
case 351 /* SyntaxList */:
|
|
return tryCast(location2.parent, isObjectTypeDeclaration);
|
|
case 1 /* EndOfFileToken */:
|
|
const cls = tryCast(lastOrUndefined(cast(location2.parent, isSourceFile).statements), isObjectTypeDeclaration);
|
|
if (cls && !findChildOfKind(cls, 19 /* CloseBraceToken */, sourceFile)) {
|
|
return cls;
|
|
}
|
|
break;
|
|
case 79 /* Identifier */: {
|
|
const originalKeywordKind = location2.originalKeywordKind;
|
|
if (originalKeywordKind && isKeyword(originalKeywordKind)) {
|
|
return void 0;
|
|
}
|
|
if (isPropertyDeclaration(location2.parent) && location2.parent.initializer === location2) {
|
|
return void 0;
|
|
}
|
|
if (isFromObjectTypeDeclaration(location2)) {
|
|
return findAncestor(location2, isObjectTypeDeclaration);
|
|
}
|
|
}
|
|
}
|
|
if (!contextToken)
|
|
return void 0;
|
|
if (location2.kind === 135 /* ConstructorKeyword */ || isIdentifier(contextToken) && isPropertyDeclaration(contextToken.parent) && isClassLike(location2)) {
|
|
return findAncestor(contextToken, isClassLike);
|
|
}
|
|
switch (contextToken.kind) {
|
|
case 63 /* EqualsToken */:
|
|
return void 0;
|
|
case 26 /* SemicolonToken */:
|
|
case 19 /* CloseBraceToken */:
|
|
return isFromObjectTypeDeclaration(location2) && location2.parent.name === location2 ? location2.parent.parent : tryCast(location2, isObjectTypeDeclaration);
|
|
case 18 /* OpenBraceToken */:
|
|
case 27 /* CommaToken */:
|
|
return tryCast(contextToken.parent, isObjectTypeDeclaration);
|
|
default:
|
|
if (!isFromObjectTypeDeclaration(contextToken)) {
|
|
if (getLineAndCharacterOfPosition(sourceFile, contextToken.getEnd()).line !== getLineAndCharacterOfPosition(sourceFile, position).line && isObjectTypeDeclaration(location2)) {
|
|
return location2;
|
|
}
|
|
return void 0;
|
|
}
|
|
const isValidKeyword = isClassLike(contextToken.parent.parent) ? isClassMemberCompletionKeyword : isInterfaceOrTypeLiteralCompletionKeyword;
|
|
return isValidKeyword(contextToken.kind) || contextToken.kind === 41 /* AsteriskToken */ || isIdentifier(contextToken) && isValidKeyword(stringToToken(contextToken.text)) ? contextToken.parent.parent : void 0;
|
|
}
|
|
}
|
|
function tryGetTypeLiteralNode(node) {
|
|
if (!node)
|
|
return void 0;
|
|
const parent2 = node.parent;
|
|
switch (node.kind) {
|
|
case 18 /* OpenBraceToken */:
|
|
if (isTypeLiteralNode(parent2)) {
|
|
return parent2;
|
|
}
|
|
break;
|
|
case 26 /* SemicolonToken */:
|
|
case 27 /* CommaToken */:
|
|
case 79 /* Identifier */:
|
|
if (parent2.kind === 168 /* PropertySignature */ && isTypeLiteralNode(parent2.parent)) {
|
|
return parent2.parent;
|
|
}
|
|
break;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getConstraintOfTypeArgumentProperty(node, checker) {
|
|
if (!node)
|
|
return void 0;
|
|
if (isTypeNode(node) && isTypeReferenceType(node.parent)) {
|
|
return checker.getTypeArgumentConstraint(node);
|
|
}
|
|
const t = getConstraintOfTypeArgumentProperty(node.parent, checker);
|
|
if (!t)
|
|
return void 0;
|
|
switch (node.kind) {
|
|
case 168 /* PropertySignature */:
|
|
return checker.getTypeOfPropertyOfContextualType(t, node.symbol.escapedName);
|
|
case 190 /* IntersectionType */:
|
|
case 184 /* TypeLiteral */:
|
|
case 189 /* UnionType */:
|
|
return t;
|
|
}
|
|
}
|
|
function isFromObjectTypeDeclaration(node) {
|
|
return node.parent && isClassOrTypeElement(node.parent) && isObjectTypeDeclaration(node.parent.parent);
|
|
}
|
|
function isValidTrigger(sourceFile, triggerCharacter, contextToken, position) {
|
|
switch (triggerCharacter) {
|
|
case ".":
|
|
case "@":
|
|
return true;
|
|
case '"':
|
|
case "'":
|
|
case "`":
|
|
return !!contextToken && isStringLiteralOrTemplate(contextToken) && position === contextToken.getStart(sourceFile) + 1;
|
|
case "#":
|
|
return !!contextToken && isPrivateIdentifier(contextToken) && !!getContainingClass(contextToken);
|
|
case "<":
|
|
return !!contextToken && contextToken.kind === 29 /* LessThanToken */ && (!isBinaryExpression(contextToken.parent) || binaryExpressionMayBeOpenTag(contextToken.parent));
|
|
case "/":
|
|
return !!contextToken && (isStringLiteralLike(contextToken) ? !!tryGetImportFromModuleSpecifier(contextToken) : contextToken.kind === 43 /* SlashToken */ && isJsxClosingElement(contextToken.parent));
|
|
case " ":
|
|
return !!contextToken && isImportKeyword(contextToken) && contextToken.parent.kind === 308 /* SourceFile */;
|
|
default:
|
|
return Debug.assertNever(triggerCharacter);
|
|
}
|
|
}
|
|
function binaryExpressionMayBeOpenTag({ left }) {
|
|
return nodeIsMissing(left);
|
|
}
|
|
function isProbablyGlobalType(type, sourceFile, checker) {
|
|
const selfSymbol = checker.resolveName("self", void 0, 111551 /* Value */, false);
|
|
if (selfSymbol && checker.getTypeOfSymbolAtLocation(selfSymbol, sourceFile) === type) {
|
|
return true;
|
|
}
|
|
const globalSymbol = checker.resolveName("global", void 0, 111551 /* Value */, false);
|
|
if (globalSymbol && checker.getTypeOfSymbolAtLocation(globalSymbol, sourceFile) === type) {
|
|
return true;
|
|
}
|
|
const globalThisSymbol = checker.resolveName("globalThis", void 0, 111551 /* Value */, false);
|
|
if (globalThisSymbol && checker.getTypeOfSymbolAtLocation(globalThisSymbol, sourceFile) === type) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isStaticProperty(symbol) {
|
|
return !!(symbol.valueDeclaration && getEffectiveModifierFlags(symbol.valueDeclaration) & 32 /* Static */ && isClassLike(symbol.valueDeclaration.parent));
|
|
}
|
|
function tryGetObjectLiteralContextualType(node, typeChecker) {
|
|
const type = typeChecker.getContextualType(node);
|
|
if (type) {
|
|
return type;
|
|
}
|
|
const parent2 = walkUpParenthesizedExpressions(node.parent);
|
|
if (isBinaryExpression(parent2) && parent2.operatorToken.kind === 63 /* EqualsToken */ && node === parent2.left) {
|
|
return typeChecker.getTypeAtLocation(parent2);
|
|
}
|
|
if (isExpression(parent2)) {
|
|
return typeChecker.getContextualType(parent2);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getImportStatementCompletionInfo(contextToken) {
|
|
var _a2, _b, _c;
|
|
let keywordCompletion;
|
|
let isKeywordOnlyCompletion = false;
|
|
const candidate = getCandidate();
|
|
return {
|
|
isKeywordOnlyCompletion,
|
|
keywordCompletion,
|
|
isNewIdentifierLocation: !!(candidate || keywordCompletion === 154 /* TypeKeyword */),
|
|
isTopLevelTypeOnly: !!((_b = (_a2 = tryCast(candidate, isImportDeclaration)) == null ? void 0 : _a2.importClause) == null ? void 0 : _b.isTypeOnly) || !!((_c = tryCast(candidate, isImportEqualsDeclaration)) == null ? void 0 : _c.isTypeOnly),
|
|
couldBeTypeOnlyImportSpecifier: !!candidate && couldBeTypeOnlyImportSpecifier(candidate, contextToken),
|
|
replacementSpan: getSingleLineReplacementSpanForImportCompletionNode(candidate)
|
|
};
|
|
function getCandidate() {
|
|
const parent2 = contextToken.parent;
|
|
if (isImportEqualsDeclaration(parent2)) {
|
|
keywordCompletion = contextToken.kind === 154 /* TypeKeyword */ ? void 0 : 154 /* TypeKeyword */;
|
|
return isModuleSpecifierMissingOrEmpty(parent2.moduleReference) ? parent2 : void 0;
|
|
}
|
|
if (couldBeTypeOnlyImportSpecifier(parent2, contextToken) && canCompleteFromNamedBindings(parent2.parent)) {
|
|
return parent2;
|
|
}
|
|
if (isNamedImports(parent2) || isNamespaceImport(parent2)) {
|
|
if (!parent2.parent.isTypeOnly && (contextToken.kind === 18 /* OpenBraceToken */ || contextToken.kind === 100 /* ImportKeyword */ || contextToken.kind === 27 /* CommaToken */)) {
|
|
keywordCompletion = 154 /* TypeKeyword */;
|
|
}
|
|
if (canCompleteFromNamedBindings(parent2)) {
|
|
if (contextToken.kind === 19 /* CloseBraceToken */ || contextToken.kind === 79 /* Identifier */) {
|
|
isKeywordOnlyCompletion = true;
|
|
keywordCompletion = 158 /* FromKeyword */;
|
|
} else {
|
|
return parent2.parent.parent;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
if (isImportKeyword(contextToken) && isSourceFile(parent2)) {
|
|
keywordCompletion = 154 /* TypeKeyword */;
|
|
return contextToken;
|
|
}
|
|
if (isImportKeyword(contextToken) && isImportDeclaration(parent2)) {
|
|
keywordCompletion = 154 /* TypeKeyword */;
|
|
return isModuleSpecifierMissingOrEmpty(parent2.moduleSpecifier) ? parent2 : void 0;
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function getSingleLineReplacementSpanForImportCompletionNode(node) {
|
|
var _a2, _b, _c;
|
|
if (!node)
|
|
return void 0;
|
|
const top = (_a2 = findAncestor(node, or(isImportDeclaration, isImportEqualsDeclaration))) != null ? _a2 : node;
|
|
const sourceFile = top.getSourceFile();
|
|
if (rangeIsOnSingleLine(top, sourceFile)) {
|
|
return createTextSpanFromNode(top, sourceFile);
|
|
}
|
|
Debug.assert(top.kind !== 100 /* ImportKeyword */ && top.kind !== 273 /* ImportSpecifier */);
|
|
const potentialSplitPoint = top.kind === 269 /* ImportDeclaration */ ? (_c = getPotentiallyInvalidImportSpecifier((_b = top.importClause) == null ? void 0 : _b.namedBindings)) != null ? _c : top.moduleSpecifier : top.moduleReference;
|
|
const withoutModuleSpecifier = {
|
|
pos: top.getFirstToken().getStart(),
|
|
end: potentialSplitPoint.pos
|
|
};
|
|
if (rangeIsOnSingleLine(withoutModuleSpecifier, sourceFile)) {
|
|
return createTextSpanFromRange(withoutModuleSpecifier);
|
|
}
|
|
}
|
|
function getPotentiallyInvalidImportSpecifier(namedBindings) {
|
|
var _a2;
|
|
return find(
|
|
(_a2 = tryCast(namedBindings, isNamedImports)) == null ? void 0 : _a2.elements,
|
|
(e) => {
|
|
var _a3;
|
|
return !e.propertyName && isStringANonContextualKeyword(e.name.text) && ((_a3 = findPrecedingToken(e.name.pos, namedBindings.getSourceFile(), namedBindings)) == null ? void 0 : _a3.kind) !== 27 /* CommaToken */;
|
|
}
|
|
);
|
|
}
|
|
function couldBeTypeOnlyImportSpecifier(importSpecifier, contextToken) {
|
|
return isImportSpecifier(importSpecifier) && (importSpecifier.isTypeOnly || contextToken === importSpecifier.name && isTypeKeywordTokenOrIdentifier(contextToken));
|
|
}
|
|
function canCompleteFromNamedBindings(namedBindings) {
|
|
if (!isModuleSpecifierMissingOrEmpty(namedBindings.parent.parent.moduleSpecifier) || namedBindings.parent.name) {
|
|
return false;
|
|
}
|
|
if (isNamedImports(namedBindings)) {
|
|
const invalidNamedImport = getPotentiallyInvalidImportSpecifier(namedBindings);
|
|
const validImports = invalidNamedImport ? namedBindings.elements.indexOf(invalidNamedImport) : namedBindings.elements.length;
|
|
return validImports < 2;
|
|
}
|
|
return true;
|
|
}
|
|
function isModuleSpecifierMissingOrEmpty(specifier) {
|
|
var _a2;
|
|
if (nodeIsMissing(specifier))
|
|
return true;
|
|
return !((_a2 = tryCast(isExternalModuleReference(specifier) ? specifier.expression : specifier, isStringLiteralLike)) == null ? void 0 : _a2.text);
|
|
}
|
|
function getVariableDeclaration(property) {
|
|
const variableDeclaration = findAncestor(property, (node) => isFunctionBlock(node) || isArrowFunctionBody(node) || isBindingPattern(node) ? "quit" : isVariableDeclaration(node));
|
|
return variableDeclaration;
|
|
}
|
|
function isArrowFunctionBody(node) {
|
|
return node.parent && isArrowFunction(node.parent) && node.parent.body === node;
|
|
}
|
|
function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules = /* @__PURE__ */ new Map()) {
|
|
return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(skipAlias(symbol.exportSymbol || symbol, checker));
|
|
function nonAliasCanBeReferencedAtTypeLocation(symbol2) {
|
|
return !!(symbol2.flags & 788968 /* Type */) || checker.isUnknownSymbol(symbol2) || !!(symbol2.flags & 1536 /* Module */) && addToSeen(seenModules, getSymbolId(symbol2)) && checker.getExportsOfModule(symbol2).some((e) => symbolCanBeReferencedAtTypeLocation(e, checker, seenModules));
|
|
}
|
|
}
|
|
function isDeprecated(symbol, checker) {
|
|
const declarations = skipAlias(symbol, checker).declarations;
|
|
return !!length(declarations) && every(declarations, isDeprecatedDeclaration);
|
|
}
|
|
function charactersFuzzyMatchInString(identifierString, lowercaseCharacters) {
|
|
if (lowercaseCharacters.length === 0) {
|
|
return true;
|
|
}
|
|
let matchedFirstCharacter = false;
|
|
let prevChar;
|
|
let characterIndex = 0;
|
|
const len = identifierString.length;
|
|
for (let strIndex = 0; strIndex < len; strIndex++) {
|
|
const strChar = identifierString.charCodeAt(strIndex);
|
|
const testChar = lowercaseCharacters.charCodeAt(characterIndex);
|
|
if (strChar === testChar || strChar === toUpperCharCode(testChar)) {
|
|
matchedFirstCharacter || (matchedFirstCharacter = prevChar === void 0 || 97 /* a */ <= prevChar && prevChar <= 122 /* z */ && 65 /* A */ <= strChar && strChar <= 90 /* Z */ || prevChar === 95 /* _ */ && strChar !== 95 /* _ */);
|
|
if (matchedFirstCharacter) {
|
|
characterIndex++;
|
|
}
|
|
if (characterIndex === lowercaseCharacters.length) {
|
|
return true;
|
|
}
|
|
}
|
|
prevChar = strChar;
|
|
}
|
|
return false;
|
|
}
|
|
function toUpperCharCode(charCode) {
|
|
if (97 /* a */ <= charCode && charCode <= 122 /* z */) {
|
|
return charCode - 32;
|
|
}
|
|
return charCode;
|
|
}
|
|
|
|
// src/services/_namespaces/ts.Completions.StringCompletions.ts
|
|
var ts_Completions_StringCompletions_exports = {};
|
|
__export(ts_Completions_StringCompletions_exports, {
|
|
getStringLiteralCompletionDetails: () => getStringLiteralCompletionDetails,
|
|
getStringLiteralCompletions: () => getStringLiteralCompletions
|
|
});
|
|
|
|
// src/services/stringCompletions.ts
|
|
var kindPrecedence = {
|
|
["directory" /* directory */]: 0,
|
|
["script" /* scriptElement */]: 1,
|
|
["external module name" /* externalModuleName */]: 2
|
|
};
|
|
function createNameAndKindSet() {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
function add(value) {
|
|
const existing = map2.get(value.name);
|
|
if (!existing || kindPrecedence[existing.kind] < kindPrecedence[value.kind]) {
|
|
map2.set(value.name, value);
|
|
}
|
|
}
|
|
return {
|
|
add,
|
|
has: map2.has.bind(map2),
|
|
values: map2.values.bind(map2)
|
|
};
|
|
}
|
|
function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences) {
|
|
if (isInReferenceComment(sourceFile, position)) {
|
|
const entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);
|
|
return entries && convertPathCompletions(entries);
|
|
}
|
|
if (isInString(sourceFile, position, contextToken)) {
|
|
if (!contextToken || !isStringLiteralLike(contextToken))
|
|
return void 0;
|
|
const entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, program.getTypeChecker(), options, host, preferences);
|
|
return convertStringLiteralCompletions(entries, contextToken, sourceFile, host, program, log, options, preferences);
|
|
}
|
|
}
|
|
function convertStringLiteralCompletions(completion, contextToken, sourceFile, host, program, log, options, preferences) {
|
|
if (completion === void 0) {
|
|
return void 0;
|
|
}
|
|
const optionalReplacementSpan = createTextSpanFromStringLiteralLikeContent(contextToken);
|
|
switch (completion.kind) {
|
|
case StringLiteralCompletionKind.Paths:
|
|
return convertPathCompletions(completion.paths);
|
|
case StringLiteralCompletionKind.Properties: {
|
|
const entries = createSortedArray();
|
|
getCompletionEntriesFromSymbols(
|
|
completion.symbols,
|
|
entries,
|
|
contextToken,
|
|
contextToken,
|
|
sourceFile,
|
|
sourceFile,
|
|
host,
|
|
program,
|
|
99 /* ESNext */,
|
|
log,
|
|
4 /* String */,
|
|
preferences,
|
|
options,
|
|
void 0
|
|
);
|
|
return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan, entries };
|
|
}
|
|
case StringLiteralCompletionKind.Types: {
|
|
const entries = completion.types.map((type) => ({
|
|
name: type.value,
|
|
kindModifiers: "" /* none */,
|
|
kind: "string" /* string */,
|
|
sortText: SortText.LocationPriority,
|
|
replacementSpan: getReplacementSpanForContextToken(contextToken)
|
|
}));
|
|
return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: completion.isNewIdentifier, optionalReplacementSpan, entries };
|
|
}
|
|
default:
|
|
return Debug.assertNever(completion);
|
|
}
|
|
}
|
|
function getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, checker, options, host, cancellationToken, preferences) {
|
|
if (!contextToken || !isStringLiteralLike(contextToken))
|
|
return void 0;
|
|
const completions = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker, options, host, preferences);
|
|
return completions && stringLiteralCompletionDetails(name, contextToken, completions, sourceFile, checker, cancellationToken);
|
|
}
|
|
function stringLiteralCompletionDetails(name, location2, completion, sourceFile, checker, cancellationToken) {
|
|
switch (completion.kind) {
|
|
case StringLiteralCompletionKind.Paths: {
|
|
const match = find(completion.paths, (p) => p.name === name);
|
|
return match && createCompletionDetails(name, kindModifiersFromExtension(match.extension), match.kind, [textPart(name)]);
|
|
}
|
|
case StringLiteralCompletionKind.Properties: {
|
|
const match = find(completion.symbols, (s) => s.name === name);
|
|
return match && createCompletionDetailsForSymbol(match, checker, sourceFile, location2, cancellationToken);
|
|
}
|
|
case StringLiteralCompletionKind.Types:
|
|
return find(completion.types, (t) => t.value === name) ? createCompletionDetails(name, "" /* none */, "type" /* typeElement */, [textPart(name)]) : void 0;
|
|
default:
|
|
return Debug.assertNever(completion);
|
|
}
|
|
}
|
|
function convertPathCompletions(pathCompletions) {
|
|
const isGlobalCompletion = false;
|
|
const isNewIdentifierLocation = true;
|
|
const entries = pathCompletions.map(({ name, kind, span, extension }) => ({ name, kind, kindModifiers: kindModifiersFromExtension(extension), sortText: SortText.LocationPriority, replacementSpan: span }));
|
|
return { isGlobalCompletion, isMemberCompletion: false, isNewIdentifierLocation, entries };
|
|
}
|
|
function kindModifiersFromExtension(extension) {
|
|
switch (extension) {
|
|
case ".d.ts" /* Dts */:
|
|
return ".d.ts" /* dtsModifier */;
|
|
case ".js" /* Js */:
|
|
return ".js" /* jsModifier */;
|
|
case ".json" /* Json */:
|
|
return ".json" /* jsonModifier */;
|
|
case ".jsx" /* Jsx */:
|
|
return ".jsx" /* jsxModifier */;
|
|
case ".ts" /* Ts */:
|
|
return ".ts" /* tsModifier */;
|
|
case ".tsx" /* Tsx */:
|
|
return ".tsx" /* tsxModifier */;
|
|
case ".d.mts" /* Dmts */:
|
|
return ".d.mts" /* dmtsModifier */;
|
|
case ".mjs" /* Mjs */:
|
|
return ".mjs" /* mjsModifier */;
|
|
case ".mts" /* Mts */:
|
|
return ".mts" /* mtsModifier */;
|
|
case ".d.cts" /* Dcts */:
|
|
return ".d.cts" /* dctsModifier */;
|
|
case ".cjs" /* Cjs */:
|
|
return ".cjs" /* cjsModifier */;
|
|
case ".cts" /* Cts */:
|
|
return ".cts" /* ctsModifier */;
|
|
case ".tsbuildinfo" /* TsBuildInfo */:
|
|
return Debug.fail(`Extension ${".tsbuildinfo" /* TsBuildInfo */} is unsupported.`);
|
|
case void 0:
|
|
return "" /* none */;
|
|
default:
|
|
return Debug.assertNever(extension);
|
|
}
|
|
}
|
|
var StringLiteralCompletionKind = /* @__PURE__ */ ((StringLiteralCompletionKind2) => {
|
|
StringLiteralCompletionKind2[StringLiteralCompletionKind2["Paths"] = 0] = "Paths";
|
|
StringLiteralCompletionKind2[StringLiteralCompletionKind2["Properties"] = 1] = "Properties";
|
|
StringLiteralCompletionKind2[StringLiteralCompletionKind2["Types"] = 2] = "Types";
|
|
return StringLiteralCompletionKind2;
|
|
})(StringLiteralCompletionKind || {});
|
|
function getStringLiteralCompletionEntries(sourceFile, node, position, typeChecker, compilerOptions, host, preferences) {
|
|
const parent2 = walkUpParentheses(node.parent);
|
|
switch (parent2.kind) {
|
|
case 198 /* LiteralType */: {
|
|
const grandParent = walkUpParentheses(parent2.parent);
|
|
switch (grandParent.kind) {
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 180 /* TypeReference */: {
|
|
const typeArgument = findAncestor(parent2, (n) => n.parent === grandParent);
|
|
if (typeArgument) {
|
|
return { kind: 2 /* Types */, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(typeArgument)), isNewIdentifier: false };
|
|
}
|
|
return void 0;
|
|
}
|
|
case 196 /* IndexedAccessType */:
|
|
const { indexType, objectType } = grandParent;
|
|
if (!rangeContainsPosition(indexType, position)) {
|
|
return void 0;
|
|
}
|
|
return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode(objectType));
|
|
case 202 /* ImportType */:
|
|
return { kind: 0 /* Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
|
|
case 189 /* UnionType */: {
|
|
if (!isTypeReferenceNode(grandParent.parent)) {
|
|
return void 0;
|
|
}
|
|
const alreadyUsedTypes = getAlreadyUsedTypesInStringLiteralUnion(grandParent, parent2);
|
|
const types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(grandParent)).filter((t) => !contains(alreadyUsedTypes, t.value));
|
|
return { kind: 2 /* Types */, types, isNewIdentifier: false };
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
case 299 /* PropertyAssignment */:
|
|
if (isObjectLiteralExpression(parent2.parent) && parent2.name === node) {
|
|
return stringLiteralCompletionsForObjectLiteral(typeChecker, parent2.parent);
|
|
}
|
|
return fromContextualType();
|
|
case 209 /* ElementAccessExpression */: {
|
|
const { expression, argumentExpression } = parent2;
|
|
if (node === skipParentheses(argumentExpression)) {
|
|
return stringLiteralCompletionsFromProperties(typeChecker.getTypeAtLocation(expression));
|
|
}
|
|
return void 0;
|
|
}
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 288 /* JsxAttribute */:
|
|
if (!isRequireCallArgument(node) && !isImportCall(parent2)) {
|
|
const argumentInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(parent2.kind === 288 /* JsxAttribute */ ? parent2.parent : node, position, sourceFile);
|
|
return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType();
|
|
}
|
|
case 269 /* ImportDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 280 /* ExternalModuleReference */:
|
|
return { kind: 0 /* Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) };
|
|
default:
|
|
return fromContextualType();
|
|
}
|
|
function fromContextualType() {
|
|
return { kind: 2 /* Types */, types: getStringLiteralTypes(getContextualTypeFromParent(node, typeChecker)), isNewIdentifier: false };
|
|
}
|
|
}
|
|
function walkUpParentheses(node) {
|
|
switch (node.kind) {
|
|
case 193 /* ParenthesizedType */:
|
|
return walkUpParenthesizedTypes(node);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return walkUpParenthesizedExpressions(node);
|
|
default:
|
|
return node;
|
|
}
|
|
}
|
|
function getAlreadyUsedTypesInStringLiteralUnion(union, current) {
|
|
return mapDefined(union.types, (type) => type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : void 0);
|
|
}
|
|
function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) {
|
|
let isNewIdentifier = false;
|
|
const uniques = /* @__PURE__ */ new Map();
|
|
const candidates = [];
|
|
const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg;
|
|
checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates);
|
|
const types = flatMap(candidates, (candidate) => {
|
|
if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
|
|
return;
|
|
let type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex);
|
|
if (isJsxOpeningLikeElement(call)) {
|
|
const propType = checker.getTypeOfPropertyOfType(type, editingArgument.name.text);
|
|
if (propType) {
|
|
type = propType;
|
|
}
|
|
}
|
|
isNewIdentifier = isNewIdentifier || !!(type.flags & 4 /* String */);
|
|
return getStringLiteralTypes(type, uniques);
|
|
});
|
|
return length(types) ? { kind: 2 /* Types */, types, isNewIdentifier } : void 0;
|
|
}
|
|
function stringLiteralCompletionsFromProperties(type) {
|
|
return type && {
|
|
kind: 1 /* Properties */,
|
|
symbols: filter(type.getApparentProperties(), (prop) => !(prop.valueDeclaration && isPrivateIdentifierClassElementDeclaration(prop.valueDeclaration))),
|
|
hasIndexSignature: hasIndexSignature(type)
|
|
};
|
|
}
|
|
function stringLiteralCompletionsForObjectLiteral(checker, objectLiteralExpression) {
|
|
const contextualType = checker.getContextualType(objectLiteralExpression);
|
|
if (!contextualType)
|
|
return void 0;
|
|
const completionsType = checker.getContextualType(objectLiteralExpression, 4 /* Completions */);
|
|
const symbols = getPropertiesForObjectExpression(
|
|
contextualType,
|
|
completionsType,
|
|
objectLiteralExpression,
|
|
checker
|
|
);
|
|
return {
|
|
kind: 1 /* Properties */,
|
|
symbols,
|
|
hasIndexSignature: hasIndexSignature(contextualType)
|
|
};
|
|
}
|
|
function getStringLiteralTypes(type, uniques = /* @__PURE__ */ new Map()) {
|
|
if (!type)
|
|
return emptyArray;
|
|
type = skipConstraint(type);
|
|
return type.isUnion() ? flatMap(type.types, (t) => getStringLiteralTypes(t, uniques)) : type.isStringLiteral() && !(type.flags & 1024 /* EnumLiteral */) && addToSeen(uniques, type.value) ? [type] : emptyArray;
|
|
}
|
|
function nameAndKind(name, kind, extension) {
|
|
return { name, kind, extension };
|
|
}
|
|
function directoryResult(name) {
|
|
return nameAndKind(name, "directory" /* directory */, void 0);
|
|
}
|
|
function addReplacementSpans(text, textStart, names) {
|
|
const span = getDirectoryFragmentTextSpan(text, textStart);
|
|
const wholeSpan = text.length === 0 ? void 0 : createTextSpan(textStart, text.length);
|
|
return names.map(({ name, kind, extension }) => Math.max(name.indexOf(directorySeparator), name.indexOf(altDirectorySeparator)) !== -1 ? { name, kind, extension, span: wholeSpan } : { name, kind, extension, span });
|
|
}
|
|
function getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) {
|
|
return addReplacementSpans(node.text, node.getStart(sourceFile) + 1, getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, compilerOptions, host, typeChecker, preferences));
|
|
}
|
|
function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, compilerOptions, host, typeChecker, preferences) {
|
|
const literalValue = normalizeSlashes(node.text);
|
|
const mode = isStringLiteralLike(node) ? getModeForUsageLocation(sourceFile, node) : void 0;
|
|
const scriptPath = sourceFile.path;
|
|
const scriptDirectory = getDirectoryPath(scriptPath);
|
|
return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && (isRootedDiskPath(literalValue) || isUrl(literalValue)) ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, getIncludeExtensionOption()) : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, getIncludeExtensionOption(), typeChecker);
|
|
function getIncludeExtensionOption() {
|
|
const mode2 = isStringLiteralLike(node) ? getModeForUsageLocation(sourceFile, node) : void 0;
|
|
return preferences.importModuleSpecifierEnding === "js" || mode2 === 99 /* ESNext */ ? IncludeExtensionsOption.ModuleSpecifierCompletion : IncludeExtensionsOption.Exclude;
|
|
}
|
|
}
|
|
function getExtensionOptions(compilerOptions, includeExtensionsOption = IncludeExtensionsOption.Exclude) {
|
|
return { extensions: flatten(getSupportedExtensionsForModuleResolution(compilerOptions)), includeExtensionsOption };
|
|
}
|
|
function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, includeExtensions) {
|
|
const extensionOptions = getExtensionOptions(compilerOptions, includeExtensions);
|
|
if (compilerOptions.rootDirs) {
|
|
return getCompletionEntriesForDirectoryFragmentWithRootDirs(
|
|
compilerOptions.rootDirs,
|
|
literalValue,
|
|
scriptDirectory,
|
|
extensionOptions,
|
|
compilerOptions,
|
|
host,
|
|
scriptPath
|
|
);
|
|
} else {
|
|
return arrayFrom(getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath).values());
|
|
}
|
|
}
|
|
function isEmitResolutionKindUsingNodeModules(compilerOptions) {
|
|
return getEmitModuleResolutionKind(compilerOptions) === 2 /* NodeJs */ || getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */;
|
|
}
|
|
function isEmitModuleResolutionRespectingExportMaps(compilerOptions) {
|
|
return getEmitModuleResolutionKind(compilerOptions) === 3 /* Node16 */ || getEmitModuleResolutionKind(compilerOptions) === 99 /* NodeNext */;
|
|
}
|
|
function getSupportedExtensionsForModuleResolution(compilerOptions) {
|
|
const extensions = getSupportedExtensions(compilerOptions);
|
|
return isEmitResolutionKindUsingNodeModules(compilerOptions) ? getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, extensions) : extensions;
|
|
}
|
|
function getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase) {
|
|
rootDirs = rootDirs.map((rootDirectory) => normalizePath(isRootedDiskPath(rootDirectory) ? rootDirectory : combinePaths(basePath, rootDirectory)));
|
|
const relativeDirectory = firstDefined(rootDirs, (rootDirectory) => containsPath(rootDirectory, scriptDirectory, basePath, ignoreCase) ? scriptDirectory.substr(rootDirectory.length) : void 0);
|
|
return deduplicate(
|
|
[...rootDirs.map((rootDirectory) => combinePaths(rootDirectory, relativeDirectory)), scriptDirectory],
|
|
equateStringsCaseSensitive,
|
|
compareStringsCaseSensitive
|
|
);
|
|
}
|
|
function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, compilerOptions, host, exclude) {
|
|
const basePath = compilerOptions.project || host.getCurrentDirectory();
|
|
const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
|
|
const baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase);
|
|
return flatMap(baseDirectories, (baseDirectory) => arrayFrom(getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensionOptions, host, exclude).values()));
|
|
}
|
|
var IncludeExtensionsOption = /* @__PURE__ */ ((IncludeExtensionsOption2) => {
|
|
IncludeExtensionsOption2[IncludeExtensionsOption2["Exclude"] = 0] = "Exclude";
|
|
IncludeExtensionsOption2[IncludeExtensionsOption2["Include"] = 1] = "Include";
|
|
IncludeExtensionsOption2[IncludeExtensionsOption2["ModuleSpecifierCompletion"] = 2] = "ModuleSpecifierCompletion";
|
|
return IncludeExtensionsOption2;
|
|
})(IncludeExtensionsOption || {});
|
|
function getCompletionEntriesForDirectoryFragment(fragment, scriptPath, extensionOptions, host, exclude, result = createNameAndKindSet()) {
|
|
var _a2;
|
|
if (fragment === void 0) {
|
|
fragment = "";
|
|
}
|
|
fragment = normalizeSlashes(fragment);
|
|
if (!hasTrailingDirectorySeparator(fragment)) {
|
|
fragment = getDirectoryPath(fragment);
|
|
}
|
|
if (fragment === "") {
|
|
fragment = "." + directorySeparator;
|
|
}
|
|
fragment = ensureTrailingDirectorySeparator(fragment);
|
|
const absolutePath = resolvePath(scriptPath, fragment);
|
|
const baseDirectory = hasTrailingDirectorySeparator(absolutePath) ? absolutePath : getDirectoryPath(absolutePath);
|
|
const packageJsonPath = findPackageJson(baseDirectory, host);
|
|
if (packageJsonPath) {
|
|
const packageJson = readJson(packageJsonPath, host);
|
|
const typesVersions = packageJson.typesVersions;
|
|
if (typeof typesVersions === "object") {
|
|
const versionPaths = (_a2 = getPackageJsonTypesVersionsPaths(typesVersions)) == null ? void 0 : _a2.paths;
|
|
if (versionPaths) {
|
|
const packageDirectory = getDirectoryPath(packageJsonPath);
|
|
const pathInPackage = absolutePath.slice(ensureTrailingDirectorySeparator(packageDirectory).length);
|
|
if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, host, versionPaths)) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames());
|
|
if (!tryDirectoryExists(host, baseDirectory))
|
|
return result;
|
|
const files = tryReadDirectory(host, baseDirectory, extensionOptions.extensions, void 0, ["./*"]);
|
|
if (files) {
|
|
for (let filePath of files) {
|
|
filePath = normalizePath(filePath);
|
|
if (exclude && comparePaths(filePath, exclude, scriptPath, ignoreCase) === 0 /* EqualTo */) {
|
|
continue;
|
|
}
|
|
const { name, extension } = getFilenameWithExtensionOption(getBaseFileName(filePath), host.getCompilationSettings(), extensionOptions.includeExtensionsOption);
|
|
result.add(nameAndKind(name, "script" /* scriptElement */, extension));
|
|
}
|
|
}
|
|
const directories = tryGetDirectories(host, baseDirectory);
|
|
if (directories) {
|
|
for (const directory of directories) {
|
|
const directoryName = getBaseFileName(normalizePath(directory));
|
|
if (directoryName !== "@types") {
|
|
result.add(directoryResult(directoryName));
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getFilenameWithExtensionOption(name, compilerOptions, includeExtensionsOption) {
|
|
const outputExtension = ts_moduleSpecifiers_exports.tryGetJSExtensionForFile(name, compilerOptions);
|
|
if (includeExtensionsOption === 0 /* Exclude */ && !fileExtensionIsOneOf(name, [".json" /* Json */, ".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */])) {
|
|
return { name: removeFileExtension(name), extension: tryGetExtensionFromPath2(name) };
|
|
} else if ((fileExtensionIsOneOf(name, [".mts" /* Mts */, ".cts" /* Cts */, ".d.mts" /* Dmts */, ".d.cts" /* Dcts */, ".mjs" /* Mjs */, ".cjs" /* Cjs */]) || includeExtensionsOption === 2 /* ModuleSpecifierCompletion */) && outputExtension) {
|
|
return { name: changeExtension(name, outputExtension), extension: outputExtension };
|
|
} else {
|
|
return { name, extension: tryGetExtensionFromPath2(name) };
|
|
}
|
|
}
|
|
function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, host, paths) {
|
|
const getPatternsForKey = (key) => paths[key];
|
|
const comparePaths2 = (a, b) => {
|
|
const patternA = tryParsePattern(a);
|
|
const patternB = tryParsePattern(b);
|
|
const lengthA = typeof patternA === "object" ? patternA.prefix.length : a.length;
|
|
const lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length;
|
|
return compareValues(lengthB, lengthA);
|
|
};
|
|
return addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, getOwnKeys(paths), getPatternsForKey, comparePaths2);
|
|
}
|
|
function addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, keys, getPatternsForKey, comparePaths2) {
|
|
let pathResults = [];
|
|
let matchedPath;
|
|
for (const key of keys) {
|
|
if (key === ".")
|
|
continue;
|
|
const keyWithoutLeadingDotSlash = key.replace(/^\.\//, "");
|
|
const patterns = getPatternsForKey(key);
|
|
if (patterns) {
|
|
const pathPattern = tryParsePattern(keyWithoutLeadingDotSlash);
|
|
if (!pathPattern)
|
|
continue;
|
|
const isMatch = typeof pathPattern === "object" && isPatternMatch(pathPattern, fragment);
|
|
const isLongestMatch = isMatch && (matchedPath === void 0 || comparePaths2(key, matchedPath) === -1 /* LessThan */);
|
|
if (isLongestMatch) {
|
|
matchedPath = key;
|
|
pathResults = pathResults.filter((r) => !r.matchedPattern);
|
|
}
|
|
if (typeof pathPattern === "string" || matchedPath === void 0 || comparePaths2(key, matchedPath) !== 1 /* GreaterThan */) {
|
|
pathResults.push({
|
|
matchedPattern: isMatch,
|
|
results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, host).map(({ name, kind, extension }) => nameAndKind(name, kind, extension))
|
|
});
|
|
}
|
|
}
|
|
}
|
|
pathResults.forEach((pathResult) => pathResult.results.forEach((r) => result.add(r)));
|
|
return matchedPath !== void 0;
|
|
}
|
|
function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, compilerOptions, host, includeExtensionsOption, typeChecker) {
|
|
const { baseUrl, paths } = compilerOptions;
|
|
const result = createNameAndKindSet();
|
|
const extensionOptions = getExtensionOptions(compilerOptions, includeExtensionsOption);
|
|
if (baseUrl) {
|
|
const projectDir = compilerOptions.project || host.getCurrentDirectory();
|
|
const absolute = normalizePath(combinePaths(projectDir, baseUrl));
|
|
getCompletionEntriesForDirectoryFragment(fragment, absolute, extensionOptions, host, void 0, result);
|
|
if (paths) {
|
|
addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, host, paths);
|
|
}
|
|
}
|
|
const fragmentDirectory = getFragmentDirectory(fragment);
|
|
for (const ambientName of getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker)) {
|
|
result.add(nameAndKind(ambientName, "external module name" /* externalModuleName */, void 0));
|
|
}
|
|
getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, fragmentDirectory, extensionOptions, result);
|
|
if (isEmitResolutionKindUsingNodeModules(compilerOptions)) {
|
|
let foundGlobal = false;
|
|
if (fragmentDirectory === void 0) {
|
|
for (const moduleName of enumerateNodeModulesVisibleToScript(host, scriptPath)) {
|
|
const moduleResult = nameAndKind(moduleName, "external module name" /* externalModuleName */, void 0);
|
|
if (!result.has(moduleResult.name)) {
|
|
foundGlobal = true;
|
|
result.add(moduleResult);
|
|
}
|
|
}
|
|
}
|
|
if (!foundGlobal) {
|
|
let ancestorLookup = (ancestor) => {
|
|
const nodeModules = combinePaths(ancestor, "node_modules");
|
|
if (tryDirectoryExists(host, nodeModules)) {
|
|
getCompletionEntriesForDirectoryFragment(fragment, nodeModules, extensionOptions, host, void 0, result);
|
|
}
|
|
};
|
|
if (fragmentDirectory && isEmitModuleResolutionRespectingExportMaps(compilerOptions)) {
|
|
const nodeModulesDirectoryLookup = ancestorLookup;
|
|
ancestorLookup = (ancestor) => {
|
|
const components = getPathComponents(fragment);
|
|
components.shift();
|
|
let packagePath = components.shift();
|
|
if (!packagePath) {
|
|
return nodeModulesDirectoryLookup(ancestor);
|
|
}
|
|
if (startsWith(packagePath, "@")) {
|
|
const subName = components.shift();
|
|
if (!subName) {
|
|
return nodeModulesDirectoryLookup(ancestor);
|
|
}
|
|
packagePath = combinePaths(packagePath, subName);
|
|
}
|
|
const packageDirectory = combinePaths(ancestor, "node_modules", packagePath);
|
|
const packageFile = combinePaths(packageDirectory, "package.json");
|
|
if (tryFileExists(host, packageFile)) {
|
|
const packageJson = readJson(packageFile, host);
|
|
const exports = packageJson.exports;
|
|
if (exports) {
|
|
if (typeof exports !== "object" || exports === null) {
|
|
return;
|
|
}
|
|
const keys = getOwnKeys(exports);
|
|
const fragmentSubpath = components.join("/") + (components.length && hasTrailingDirectorySeparator(fragment) ? "/" : "");
|
|
const conditions = mode === 99 /* ESNext */ ? ["node", "import", "types"] : ["node", "require", "types"];
|
|
addCompletionEntriesFromPathsOrExports(
|
|
result,
|
|
fragmentSubpath,
|
|
packageDirectory,
|
|
extensionOptions,
|
|
host,
|
|
keys,
|
|
(key) => singleElementArray(getPatternFromFirstMatchingCondition(exports[key], conditions)),
|
|
comparePatternKeys
|
|
);
|
|
return;
|
|
}
|
|
}
|
|
return nodeModulesDirectoryLookup(ancestor);
|
|
};
|
|
}
|
|
forEachAncestorDirectory(scriptPath, ancestorLookup);
|
|
}
|
|
}
|
|
return arrayFrom(result.values());
|
|
}
|
|
function getPatternFromFirstMatchingCondition(target, conditions) {
|
|
if (typeof target === "string") {
|
|
return target;
|
|
}
|
|
if (target && typeof target === "object" && !isArray(target)) {
|
|
for (const condition in target) {
|
|
if (condition === "default" || conditions.indexOf(condition) > -1 || isApplicableVersionedTypesKey(conditions, condition)) {
|
|
const pattern = target[condition];
|
|
return getPatternFromFirstMatchingCondition(pattern, conditions);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getFragmentDirectory(fragment) {
|
|
return containsSlash(fragment) ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
|
|
}
|
|
function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, host) {
|
|
if (!endsWith(path, "*")) {
|
|
return !stringContains(path, "*") ? justPathMappingName(path, "script" /* scriptElement */) : emptyArray;
|
|
}
|
|
const pathPrefix = path.slice(0, path.length - 1);
|
|
const remainingFragment = tryRemovePrefix(fragment, pathPrefix);
|
|
if (remainingFragment === void 0) {
|
|
const starIsFullPathComponent = path[path.length - 2] === "/";
|
|
return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* directory */) : flatMap(patterns, (pattern) => {
|
|
var _a2;
|
|
return (_a2 = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, host)) == null ? void 0 : _a2.map(({ name, ...rest }) => ({ name: pathPrefix + name, ...rest }));
|
|
});
|
|
}
|
|
return flatMap(patterns, (pattern) => getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, host));
|
|
function justPathMappingName(name, kind) {
|
|
return startsWith(name, fragment) ? [{ name: removeTrailingDirectorySeparator(name), kind, extension: void 0 }] : emptyArray;
|
|
}
|
|
}
|
|
function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, host) {
|
|
if (!host.readDirectory) {
|
|
return void 0;
|
|
}
|
|
const parsed = tryParsePattern(pattern);
|
|
if (parsed === void 0 || isString(parsed)) {
|
|
return void 0;
|
|
}
|
|
const normalizedPrefix = resolvePath(parsed.prefix);
|
|
const normalizedPrefixDirectory = hasTrailingDirectorySeparator(parsed.prefix) ? normalizedPrefix : getDirectoryPath(normalizedPrefix);
|
|
const normalizedPrefixBase = hasTrailingDirectorySeparator(parsed.prefix) ? "" : getBaseFileName(normalizedPrefix);
|
|
const fragmentHasPath = containsSlash(fragment);
|
|
const fragmentDirectory = fragmentHasPath ? hasTrailingDirectorySeparator(fragment) ? fragment : getDirectoryPath(fragment) : void 0;
|
|
const expandedPrefixDirectory = fragmentHasPath ? combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + fragmentDirectory) : normalizedPrefixDirectory;
|
|
const normalizedSuffix = normalizePath(parsed.suffix);
|
|
const baseDirectory = normalizePath(combinePaths(packageDirectory, expandedPrefixDirectory));
|
|
const completePrefix = fragmentHasPath ? baseDirectory : ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase;
|
|
const includeGlob = normalizedSuffix ? "**/*" + normalizedSuffix : "./*";
|
|
const matches = mapDefined(tryReadDirectory(host, baseDirectory, extensionOptions.extensions, void 0, [includeGlob]), (match) => {
|
|
const trimmedWithPattern = trimPrefixAndSuffix(match);
|
|
if (trimmedWithPattern) {
|
|
if (containsSlash(trimmedWithPattern)) {
|
|
return directoryResult(getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]);
|
|
}
|
|
const { name, extension } = getFilenameWithExtensionOption(trimmedWithPattern, host.getCompilationSettings(), extensionOptions.includeExtensionsOption);
|
|
return nameAndKind(name, "script" /* scriptElement */, extension);
|
|
}
|
|
});
|
|
const directories = normalizedSuffix ? emptyArray : mapDefined(tryGetDirectories(host, baseDirectory), (dir) => dir === "node_modules" ? void 0 : directoryResult(dir));
|
|
return [...matches, ...directories];
|
|
function trimPrefixAndSuffix(path) {
|
|
const inner = withoutStartAndEnd(normalizePath(path), completePrefix, normalizedSuffix);
|
|
return inner === void 0 ? void 0 : removeLeadingDirectorySeparator(inner);
|
|
}
|
|
}
|
|
function withoutStartAndEnd(s, start2, end) {
|
|
return startsWith(s, start2) && endsWith(s, end) ? s.slice(start2.length, s.length - end.length) : void 0;
|
|
}
|
|
function removeLeadingDirectorySeparator(path) {
|
|
return path[0] === directorySeparator ? path.slice(1) : path;
|
|
}
|
|
function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) {
|
|
const ambientModules = checker.getAmbientModules().map((sym) => stripQuotes(sym.name));
|
|
const nonRelativeModuleNames = ambientModules.filter((moduleName) => startsWith(moduleName, fragment));
|
|
if (fragmentDirectory !== void 0) {
|
|
const moduleNameWithSeparator = ensureTrailingDirectorySeparator(fragmentDirectory);
|
|
return nonRelativeModuleNames.map((nonRelativeModuleName) => removePrefix(nonRelativeModuleName, moduleNameWithSeparator));
|
|
}
|
|
return nonRelativeModuleNames;
|
|
}
|
|
function getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions, host) {
|
|
const token = getTokenAtPosition(sourceFile, position);
|
|
const commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos);
|
|
const range = commentRanges && find(commentRanges, (commentRange) => position >= commentRange.pos && position <= commentRange.end);
|
|
if (!range) {
|
|
return void 0;
|
|
}
|
|
const text = sourceFile.text.slice(range.pos, position);
|
|
const match = tripleSlashDirectiveFragmentRegex.exec(text);
|
|
if (!match) {
|
|
return void 0;
|
|
}
|
|
const [, prefix, kind, toComplete] = match;
|
|
const scriptPath = getDirectoryPath(sourceFile.path);
|
|
const names = kind === "path" ? getCompletionEntriesForDirectoryFragment(toComplete, scriptPath, getExtensionOptions(compilerOptions, 1 /* Include */), host, sourceFile.path) : kind === "types" ? getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions)) : Debug.fail();
|
|
return addReplacementSpans(toComplete, range.pos + prefix.length, arrayFrom(names.values()));
|
|
}
|
|
function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
|
|
const seen = /* @__PURE__ */ new Map();
|
|
const typeRoots = tryAndIgnoreErrors(() => getEffectiveTypeRoots(options, host)) || emptyArray;
|
|
for (const root of typeRoots) {
|
|
getCompletionEntriesFromDirectories(root);
|
|
}
|
|
for (const packageJson of findPackageJsons(scriptPath, host)) {
|
|
const typesDir = combinePaths(getDirectoryPath(packageJson), "node_modules/@types");
|
|
getCompletionEntriesFromDirectories(typesDir);
|
|
}
|
|
return result;
|
|
function getCompletionEntriesFromDirectories(directory) {
|
|
if (!tryDirectoryExists(host, directory))
|
|
return;
|
|
for (const typeDirectoryName of tryGetDirectories(host, directory)) {
|
|
const packageName = unmangleScopedPackageName(typeDirectoryName);
|
|
if (options.types && !contains(options.types, packageName))
|
|
continue;
|
|
if (fragmentDirectory === void 0) {
|
|
if (!seen.has(packageName)) {
|
|
result.add(nameAndKind(packageName, "external module name" /* externalModuleName */, void 0));
|
|
seen.set(packageName, true);
|
|
}
|
|
} else {
|
|
const baseDirectory = combinePaths(directory, typeDirectoryName);
|
|
const remainingFragment = tryRemoveDirectoryPrefix(fragmentDirectory, packageName, hostGetCanonicalFileName(host));
|
|
if (remainingFragment !== void 0) {
|
|
getCompletionEntriesForDirectoryFragment(remainingFragment, baseDirectory, extensionOptions, host, void 0, result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function enumerateNodeModulesVisibleToScript(host, scriptPath) {
|
|
if (!host.readFile || !host.fileExists)
|
|
return emptyArray;
|
|
const result = [];
|
|
for (const packageJson of findPackageJsons(scriptPath, host)) {
|
|
const contents = readJson(packageJson, host);
|
|
for (const key of nodeModulesDependencyKeys) {
|
|
const dependencies = contents[key];
|
|
if (!dependencies)
|
|
continue;
|
|
for (const dep in dependencies) {
|
|
if (hasProperty(dependencies, dep) && !startsWith(dep, "@types/")) {
|
|
result.push(dep);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getDirectoryFragmentTextSpan(text, textStart) {
|
|
const index = Math.max(text.lastIndexOf(directorySeparator), text.lastIndexOf(altDirectorySeparator));
|
|
const offset = index !== -1 ? index + 1 : 0;
|
|
const length2 = text.length - offset;
|
|
return length2 === 0 || isIdentifierText(text.substr(offset, length2), 99 /* ESNext */) ? void 0 : createTextSpan(textStart + offset, length2);
|
|
}
|
|
function isPathRelativeToScript(path) {
|
|
if (path && path.length >= 2 && path.charCodeAt(0) === 46 /* dot */) {
|
|
const slashIndex = path.length >= 3 && path.charCodeAt(1) === 46 /* dot */ ? 2 : 1;
|
|
const slashCharCode = path.charCodeAt(slashIndex);
|
|
return slashCharCode === 47 /* slash */ || slashCharCode === 92 /* backslash */;
|
|
}
|
|
return false;
|
|
}
|
|
var tripleSlashDirectiveFragmentRegex = /^(\/\/\/\s*<reference\s+(path|types)\s*=\s*(?:'|"))([^\3"]*)$/;
|
|
var nodeModulesDependencyKeys = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
|
|
function containsSlash(fragment) {
|
|
return stringContains(fragment, directorySeparator);
|
|
}
|
|
function isRequireCallArgument(node) {
|
|
return isCallExpression(node.parent) && firstOrUndefined(node.parent.arguments) === node && isIdentifier(node.parent.expression) && node.parent.expression.escapedText === "require";
|
|
}
|
|
|
|
// src/services/_namespaces/ts.FindAllReferences.ts
|
|
var ts_FindAllReferences_exports = {};
|
|
__export(ts_FindAllReferences_exports, {
|
|
Core: () => Core,
|
|
DefinitionKind: () => DefinitionKind,
|
|
EntryKind: () => EntryKind,
|
|
ExportKind: () => ExportKind2,
|
|
FindReferencesUse: () => FindReferencesUse,
|
|
ImportExport: () => ImportExport,
|
|
createImportTracker: () => createImportTracker,
|
|
findModuleReferences: () => findModuleReferences,
|
|
findReferenceOrRenameEntries: () => findReferenceOrRenameEntries,
|
|
findReferencedSymbols: () => findReferencedSymbols,
|
|
getContextNode: () => getContextNode,
|
|
getExportInfo: () => getExportInfo,
|
|
getImplementationsAtPosition: () => getImplementationsAtPosition,
|
|
getImportOrExportSymbol: () => getImportOrExportSymbol,
|
|
getReferenceEntriesForNode: () => getReferenceEntriesForNode,
|
|
getTextSpanOfEntry: () => getTextSpanOfEntry,
|
|
isContextWithStartAndEndNode: () => isContextWithStartAndEndNode,
|
|
isDeclarationOfSymbol: () => isDeclarationOfSymbol,
|
|
nodeEntry: () => nodeEntry,
|
|
toContextSpan: () => toContextSpan,
|
|
toHighlightSpan: () => toHighlightSpan,
|
|
toReferenceEntry: () => toReferenceEntry,
|
|
toRenameLocation: () => toRenameLocation
|
|
});
|
|
|
|
// src/services/importTracker.ts
|
|
function createImportTracker(sourceFiles, sourceFilesSet, checker, cancellationToken) {
|
|
const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken);
|
|
return (exportSymbol, exportInfo, isForRename) => {
|
|
const { directImports, indirectUsers } = getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, exportInfo, checker, cancellationToken);
|
|
return { indirectUsers, ...getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename) };
|
|
};
|
|
}
|
|
var ExportKind2 = /* @__PURE__ */ ((ExportKind3) => {
|
|
ExportKind3[ExportKind3["Named"] = 0] = "Named";
|
|
ExportKind3[ExportKind3["Default"] = 1] = "Default";
|
|
ExportKind3[ExportKind3["ExportEquals"] = 2] = "ExportEquals";
|
|
return ExportKind3;
|
|
})(ExportKind2 || {});
|
|
var ImportExport = /* @__PURE__ */ ((ImportExport2) => {
|
|
ImportExport2[ImportExport2["Import"] = 0] = "Import";
|
|
ImportExport2[ImportExport2["Export"] = 1] = "Export";
|
|
return ImportExport2;
|
|
})(ImportExport || {});
|
|
function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, { exportingModuleSymbol, exportKind }, checker, cancellationToken) {
|
|
const markSeenDirectImport = nodeSeenTracker();
|
|
const markSeenIndirectUser = nodeSeenTracker();
|
|
const directImports = [];
|
|
const isAvailableThroughGlobal = !!exportingModuleSymbol.globalExports;
|
|
const indirectUserDeclarations = isAvailableThroughGlobal ? void 0 : [];
|
|
handleDirectImports(exportingModuleSymbol);
|
|
return { directImports, indirectUsers: getIndirectUsers() };
|
|
function getIndirectUsers() {
|
|
if (isAvailableThroughGlobal) {
|
|
return sourceFiles;
|
|
}
|
|
if (exportingModuleSymbol.declarations) {
|
|
for (const decl of exportingModuleSymbol.declarations) {
|
|
if (isExternalModuleAugmentation(decl) && sourceFilesSet.has(decl.getSourceFile().fileName)) {
|
|
addIndirectUser(decl);
|
|
}
|
|
}
|
|
}
|
|
return indirectUserDeclarations.map(getSourceFileOfNode);
|
|
}
|
|
function handleDirectImports(exportingModuleSymbol2) {
|
|
const theseDirectImports = getDirectImports(exportingModuleSymbol2);
|
|
if (theseDirectImports) {
|
|
for (const direct of theseDirectImports) {
|
|
if (!markSeenDirectImport(direct)) {
|
|
continue;
|
|
}
|
|
if (cancellationToken)
|
|
cancellationToken.throwIfCancellationRequested();
|
|
switch (direct.kind) {
|
|
case 210 /* CallExpression */:
|
|
if (isImportCall(direct)) {
|
|
handleImportCall(direct);
|
|
break;
|
|
}
|
|
if (!isAvailableThroughGlobal) {
|
|
const parent2 = direct.parent;
|
|
if (exportKind === 2 /* ExportEquals */ && parent2.kind === 257 /* VariableDeclaration */) {
|
|
const { name } = parent2;
|
|
if (name.kind === 79 /* Identifier */) {
|
|
directImports.push(name);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case 79 /* Identifier */:
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
handleNamespaceImport(direct, direct.name, hasSyntacticModifier(direct, 1 /* Export */), false);
|
|
break;
|
|
case 269 /* ImportDeclaration */:
|
|
directImports.push(direct);
|
|
const namedBindings = direct.importClause && direct.importClause.namedBindings;
|
|
if (namedBindings && namedBindings.kind === 271 /* NamespaceImport */) {
|
|
handleNamespaceImport(direct, namedBindings.name, false, true);
|
|
} else if (!isAvailableThroughGlobal && isDefaultImport(direct)) {
|
|
addIndirectUser(getSourceFileLikeForImportDeclaration(direct));
|
|
}
|
|
break;
|
|
case 275 /* ExportDeclaration */:
|
|
if (!direct.exportClause) {
|
|
handleDirectImports(getContainingModuleSymbol(direct, checker));
|
|
} else if (direct.exportClause.kind === 277 /* NamespaceExport */) {
|
|
addIndirectUser(getSourceFileLikeForImportDeclaration(direct), true);
|
|
} else {
|
|
directImports.push(direct);
|
|
}
|
|
break;
|
|
case 202 /* ImportType */:
|
|
if (!isAvailableThroughGlobal && direct.isTypeOf && !direct.qualifier && isExported2(direct)) {
|
|
addIndirectUser(direct.getSourceFile(), true);
|
|
}
|
|
directImports.push(direct);
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(direct, "Unexpected import kind.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function handleImportCall(importCall) {
|
|
const top = findAncestor(importCall, isAmbientModuleDeclaration) || importCall.getSourceFile();
|
|
addIndirectUser(top, !!isExported2(importCall, true));
|
|
}
|
|
function isExported2(node, stopAtAmbientModule = false) {
|
|
return findAncestor(node, (node2) => {
|
|
if (stopAtAmbientModule && isAmbientModuleDeclaration(node2))
|
|
return "quit";
|
|
return canHaveModifiers(node2) && some(node2.modifiers, isExportModifier);
|
|
});
|
|
}
|
|
function handleNamespaceImport(importDeclaration, name, isReExport, alreadyAddedDirect) {
|
|
if (exportKind === 2 /* ExportEquals */) {
|
|
if (!alreadyAddedDirect)
|
|
directImports.push(importDeclaration);
|
|
} else if (!isAvailableThroughGlobal) {
|
|
const sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration);
|
|
Debug.assert(sourceFileLike.kind === 308 /* SourceFile */ || sourceFileLike.kind === 264 /* ModuleDeclaration */);
|
|
if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) {
|
|
addIndirectUser(sourceFileLike, true);
|
|
} else {
|
|
addIndirectUser(sourceFileLike);
|
|
}
|
|
}
|
|
}
|
|
function addIndirectUser(sourceFileLike, addTransitiveDependencies = false) {
|
|
Debug.assert(!isAvailableThroughGlobal);
|
|
const isNew = markSeenIndirectUser(sourceFileLike);
|
|
if (!isNew)
|
|
return;
|
|
indirectUserDeclarations.push(sourceFileLike);
|
|
if (!addTransitiveDependencies)
|
|
return;
|
|
const moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol);
|
|
if (!moduleSymbol)
|
|
return;
|
|
Debug.assert(!!(moduleSymbol.flags & 1536 /* Module */));
|
|
const directImports2 = getDirectImports(moduleSymbol);
|
|
if (directImports2) {
|
|
for (const directImport of directImports2) {
|
|
if (!isImportTypeNode(directImport)) {
|
|
addIndirectUser(getSourceFileLikeForImportDeclaration(directImport), true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getDirectImports(moduleSymbol) {
|
|
return allDirectImports.get(getSymbolId(moduleSymbol).toString());
|
|
}
|
|
}
|
|
function getSearchesFromDirectImports(directImports, exportSymbol, exportKind, checker, isForRename) {
|
|
const importSearches = [];
|
|
const singleReferences = [];
|
|
function addSearch(location2, symbol) {
|
|
importSearches.push([location2, symbol]);
|
|
}
|
|
if (directImports) {
|
|
for (const decl of directImports) {
|
|
handleImport(decl);
|
|
}
|
|
}
|
|
return { importSearches, singleReferences };
|
|
function handleImport(decl) {
|
|
if (decl.kind === 268 /* ImportEqualsDeclaration */) {
|
|
if (isExternalModuleImportEquals(decl)) {
|
|
handleNamespaceImportLike(decl.name);
|
|
}
|
|
return;
|
|
}
|
|
if (decl.kind === 79 /* Identifier */) {
|
|
handleNamespaceImportLike(decl);
|
|
return;
|
|
}
|
|
if (decl.kind === 202 /* ImportType */) {
|
|
if (decl.qualifier) {
|
|
const firstIdentifier = getFirstIdentifier(decl.qualifier);
|
|
if (firstIdentifier.escapedText === symbolName(exportSymbol)) {
|
|
singleReferences.push(firstIdentifier);
|
|
}
|
|
} else if (exportKind === 2 /* ExportEquals */) {
|
|
singleReferences.push(decl.argument.literal);
|
|
}
|
|
return;
|
|
}
|
|
if (decl.moduleSpecifier.kind !== 10 /* StringLiteral */) {
|
|
return;
|
|
}
|
|
if (decl.kind === 275 /* ExportDeclaration */) {
|
|
if (decl.exportClause && isNamedExports(decl.exportClause)) {
|
|
searchForNamedImport(decl.exportClause);
|
|
}
|
|
return;
|
|
}
|
|
const { name, namedBindings } = decl.importClause || { name: void 0, namedBindings: void 0 };
|
|
if (namedBindings) {
|
|
switch (namedBindings.kind) {
|
|
case 271 /* NamespaceImport */:
|
|
handleNamespaceImportLike(namedBindings.name);
|
|
break;
|
|
case 272 /* NamedImports */:
|
|
if (exportKind === 0 /* Named */ || exportKind === 1 /* Default */) {
|
|
searchForNamedImport(namedBindings);
|
|
}
|
|
break;
|
|
default:
|
|
Debug.assertNever(namedBindings);
|
|
}
|
|
}
|
|
if (name && (exportKind === 1 /* Default */ || exportKind === 2 /* ExportEquals */) && (!isForRename || name.escapedText === symbolEscapedNameNoDefault(exportSymbol))) {
|
|
const defaultImportAlias = checker.getSymbolAtLocation(name);
|
|
addSearch(name, defaultImportAlias);
|
|
}
|
|
}
|
|
function handleNamespaceImportLike(importName) {
|
|
if (exportKind === 2 /* ExportEquals */ && (!isForRename || isNameMatch(importName.escapedText))) {
|
|
addSearch(importName, checker.getSymbolAtLocation(importName));
|
|
}
|
|
}
|
|
function searchForNamedImport(namedBindings) {
|
|
if (!namedBindings) {
|
|
return;
|
|
}
|
|
for (const element of namedBindings.elements) {
|
|
const { name, propertyName } = element;
|
|
if (!isNameMatch((propertyName || name).escapedText)) {
|
|
continue;
|
|
}
|
|
if (propertyName) {
|
|
singleReferences.push(propertyName);
|
|
if (!isForRename || name.escapedText === exportSymbol.escapedName) {
|
|
addSearch(name, checker.getSymbolAtLocation(name));
|
|
}
|
|
} else {
|
|
const localSymbol = element.kind === 278 /* ExportSpecifier */ && element.propertyName ? checker.getExportSpecifierLocalTargetSymbol(element) : checker.getSymbolAtLocation(name);
|
|
addSearch(name, localSymbol);
|
|
}
|
|
}
|
|
}
|
|
function isNameMatch(name) {
|
|
return name === exportSymbol.escapedName || exportKind !== 0 /* Named */ && name === "default" /* Default */;
|
|
}
|
|
}
|
|
function findNamespaceReExports(sourceFileLike, name, checker) {
|
|
const namespaceImportSymbol = checker.getSymbolAtLocation(name);
|
|
return !!forEachPossibleImportOrExportStatement(sourceFileLike, (statement) => {
|
|
if (!isExportDeclaration(statement))
|
|
return;
|
|
const { exportClause, moduleSpecifier } = statement;
|
|
return !moduleSpecifier && exportClause && isNamedExports(exportClause) && exportClause.elements.some((element) => checker.getExportSpecifierLocalTargetSymbol(element) === namespaceImportSymbol);
|
|
});
|
|
}
|
|
function findModuleReferences(program, sourceFiles, searchModuleSymbol) {
|
|
const refs = [];
|
|
const checker = program.getTypeChecker();
|
|
for (const referencingFile of sourceFiles) {
|
|
const searchSourceFile = searchModuleSymbol.valueDeclaration;
|
|
if ((searchSourceFile == null ? void 0 : searchSourceFile.kind) === 308 /* SourceFile */) {
|
|
for (const ref of referencingFile.referencedFiles) {
|
|
if (program.getSourceFileFromReference(referencingFile, ref) === searchSourceFile) {
|
|
refs.push({ kind: "reference", referencingFile, ref });
|
|
}
|
|
}
|
|
for (const ref of referencingFile.typeReferenceDirectives) {
|
|
const referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat);
|
|
if (referenced !== void 0 && referenced.resolvedFileName === searchSourceFile.fileName) {
|
|
refs.push({ kind: "reference", referencingFile, ref });
|
|
}
|
|
}
|
|
}
|
|
forEachImport(referencingFile, (_importDecl, moduleSpecifier) => {
|
|
const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
|
|
if (moduleSymbol === searchModuleSymbol) {
|
|
refs.push({ kind: "import", literal: moduleSpecifier });
|
|
}
|
|
});
|
|
}
|
|
return refs;
|
|
}
|
|
function getDirectImportsMap(sourceFiles, checker, cancellationToken) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
for (const sourceFile of sourceFiles) {
|
|
if (cancellationToken)
|
|
cancellationToken.throwIfCancellationRequested();
|
|
forEachImport(sourceFile, (importDecl, moduleSpecifier) => {
|
|
const moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier);
|
|
if (moduleSymbol) {
|
|
const id = getSymbolId(moduleSymbol).toString();
|
|
let imports = map2.get(id);
|
|
if (!imports) {
|
|
map2.set(id, imports = []);
|
|
}
|
|
imports.push(importDecl);
|
|
}
|
|
});
|
|
}
|
|
return map2;
|
|
}
|
|
function forEachPossibleImportOrExportStatement(sourceFileLike, action) {
|
|
return forEach(sourceFileLike.kind === 308 /* SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, (statement) => action(statement) || isAmbientModuleDeclaration(statement) && forEach(statement.body && statement.body.statements, action));
|
|
}
|
|
function forEachImport(sourceFile, action) {
|
|
if (sourceFile.externalModuleIndicator || sourceFile.imports !== void 0) {
|
|
for (const i of sourceFile.imports) {
|
|
action(importFromModuleSpecifier(i), i);
|
|
}
|
|
} else {
|
|
forEachPossibleImportOrExportStatement(sourceFile, (statement) => {
|
|
switch (statement.kind) {
|
|
case 275 /* ExportDeclaration */:
|
|
case 269 /* ImportDeclaration */: {
|
|
const decl = statement;
|
|
if (decl.moduleSpecifier && isStringLiteral(decl.moduleSpecifier)) {
|
|
action(decl, decl.moduleSpecifier);
|
|
}
|
|
break;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */: {
|
|
const decl = statement;
|
|
if (isExternalModuleImportEquals(decl)) {
|
|
action(decl, decl.moduleReference.expression);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function getImportOrExportSymbol(node, symbol, checker, comingFromExport) {
|
|
return comingFromExport ? getExport() : getExport() || getImport();
|
|
function getExport() {
|
|
var _a2;
|
|
const { parent: parent2 } = node;
|
|
const grandparent = parent2.parent;
|
|
if (symbol.exportSymbol) {
|
|
if (parent2.kind === 208 /* PropertyAccessExpression */) {
|
|
return ((_a2 = symbol.declarations) == null ? void 0 : _a2.some((d) => d === parent2)) && isBinaryExpression(grandparent) ? getSpecialPropertyExport(grandparent, false) : void 0;
|
|
} else {
|
|
return exportInfo(symbol.exportSymbol, getExportKindForDeclaration(parent2));
|
|
}
|
|
} else {
|
|
const exportNode = getExportNode(parent2, node);
|
|
if (exportNode && hasSyntacticModifier(exportNode, 1 /* Export */)) {
|
|
if (isImportEqualsDeclaration(exportNode) && exportNode.moduleReference === node) {
|
|
if (comingFromExport) {
|
|
return void 0;
|
|
}
|
|
const lhsSymbol = checker.getSymbolAtLocation(exportNode.name);
|
|
return { kind: 0 /* Import */, symbol: lhsSymbol };
|
|
} else {
|
|
return exportInfo(symbol, getExportKindForDeclaration(exportNode));
|
|
}
|
|
} else if (isNamespaceExport(parent2)) {
|
|
return exportInfo(symbol, 0 /* Named */);
|
|
} else if (isExportAssignment(parent2)) {
|
|
return getExportAssignmentExport(parent2);
|
|
} else if (isExportAssignment(grandparent)) {
|
|
return getExportAssignmentExport(grandparent);
|
|
} else if (isBinaryExpression(parent2)) {
|
|
return getSpecialPropertyExport(parent2, true);
|
|
} else if (isBinaryExpression(grandparent)) {
|
|
return getSpecialPropertyExport(grandparent, true);
|
|
} else if (isJSDocTypedefTag(parent2)) {
|
|
return exportInfo(symbol, 0 /* Named */);
|
|
}
|
|
}
|
|
function getExportAssignmentExport(ex) {
|
|
if (!ex.symbol.parent)
|
|
return void 0;
|
|
const exportKind = ex.isExportEquals ? 2 /* ExportEquals */ : 1 /* Default */;
|
|
return { kind: 1 /* Export */, symbol, exportInfo: { exportingModuleSymbol: ex.symbol.parent, exportKind } };
|
|
}
|
|
function getSpecialPropertyExport(node2, useLhsSymbol) {
|
|
let kind;
|
|
switch (getAssignmentDeclarationKind(node2)) {
|
|
case 1 /* ExportsProperty */:
|
|
kind = 0 /* Named */;
|
|
break;
|
|
case 2 /* ModuleExports */:
|
|
kind = 2 /* ExportEquals */;
|
|
break;
|
|
default:
|
|
return void 0;
|
|
}
|
|
const sym = useLhsSymbol ? checker.getSymbolAtLocation(getNameOfAccessExpression(cast(node2.left, isAccessExpression))) : symbol;
|
|
return sym && exportInfo(sym, kind);
|
|
}
|
|
}
|
|
function getImport() {
|
|
const isImport3 = isNodeImport(node);
|
|
if (!isImport3)
|
|
return void 0;
|
|
let importedSymbol = checker.getImmediateAliasedSymbol(symbol);
|
|
if (!importedSymbol)
|
|
return void 0;
|
|
importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker);
|
|
if (importedSymbol.escapedName === "export=") {
|
|
importedSymbol = getExportEqualsLocalSymbol(importedSymbol, checker);
|
|
if (importedSymbol === void 0)
|
|
return void 0;
|
|
}
|
|
const importedName = symbolEscapedNameNoDefault(importedSymbol);
|
|
if (importedName === void 0 || importedName === "default" /* Default */ || importedName === symbol.escapedName) {
|
|
return { kind: 0 /* Import */, symbol: importedSymbol };
|
|
}
|
|
}
|
|
function exportInfo(symbol2, kind) {
|
|
const exportInfo2 = getExportInfo(symbol2, kind, checker);
|
|
return exportInfo2 && { kind: 1 /* Export */, symbol: symbol2, exportInfo: exportInfo2 };
|
|
}
|
|
function getExportKindForDeclaration(node2) {
|
|
return hasSyntacticModifier(node2, 1024 /* Default */) ? 1 /* Default */ : 0 /* Named */;
|
|
}
|
|
}
|
|
function getExportEqualsLocalSymbol(importedSymbol, checker) {
|
|
if (importedSymbol.flags & 2097152 /* Alias */) {
|
|
return checker.getImmediateAliasedSymbol(importedSymbol);
|
|
}
|
|
const decl = Debug.checkDefined(importedSymbol.valueDeclaration);
|
|
if (isExportAssignment(decl)) {
|
|
return decl.expression.symbol;
|
|
} else if (isBinaryExpression(decl)) {
|
|
return decl.right.symbol;
|
|
} else if (isSourceFile(decl)) {
|
|
return decl.symbol;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExportNode(parent2, node) {
|
|
const declaration = isVariableDeclaration(parent2) ? parent2 : isBindingElement(parent2) ? walkUpBindingElementsAndPatterns(parent2) : void 0;
|
|
if (declaration) {
|
|
return parent2.name !== node ? void 0 : isCatchClause(declaration.parent) ? void 0 : isVariableStatement(declaration.parent.parent) ? declaration.parent.parent : void 0;
|
|
} else {
|
|
return parent2;
|
|
}
|
|
}
|
|
function isNodeImport(node) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return parent2.name === node && isExternalModuleImportEquals(parent2);
|
|
case 273 /* ImportSpecifier */:
|
|
return !parent2.propertyName;
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
Debug.assert(parent2.name === node);
|
|
return true;
|
|
case 205 /* BindingElement */:
|
|
return isInJSFile(node) && isVariableDeclarationInitializedToBareOrAccessedRequire(parent2.parent.parent);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getExportInfo(exportSymbol, exportKind, checker) {
|
|
const moduleSymbol = exportSymbol.parent;
|
|
if (!moduleSymbol)
|
|
return void 0;
|
|
const exportingModuleSymbol = checker.getMergedSymbol(moduleSymbol);
|
|
return isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol, exportKind } : void 0;
|
|
}
|
|
function skipExportSpecifierSymbol(symbol, checker) {
|
|
if (symbol.declarations) {
|
|
for (const declaration of symbol.declarations) {
|
|
if (isExportSpecifier(declaration) && !declaration.propertyName && !declaration.parent.parent.moduleSpecifier) {
|
|
return checker.getExportSpecifierLocalTargetSymbol(declaration);
|
|
} else if (isPropertyAccessExpression(declaration) && isModuleExportsAccessExpression(declaration.expression) && !isPrivateIdentifier(declaration.name)) {
|
|
return checker.getSymbolAtLocation(declaration);
|
|
} else if (isShorthandPropertyAssignment(declaration) && isBinaryExpression(declaration.parent.parent) && getAssignmentDeclarationKind(declaration.parent.parent) === 2 /* ModuleExports */) {
|
|
return checker.getExportSpecifierLocalTargetSymbol(declaration.name);
|
|
}
|
|
}
|
|
}
|
|
return symbol;
|
|
}
|
|
function getContainingModuleSymbol(importer, checker) {
|
|
return checker.getMergedSymbol(getSourceFileLikeForImportDeclaration(importer).symbol);
|
|
}
|
|
function getSourceFileLikeForImportDeclaration(node) {
|
|
if (node.kind === 210 /* CallExpression */) {
|
|
return node.getSourceFile();
|
|
}
|
|
const { parent: parent2 } = node;
|
|
if (parent2.kind === 308 /* SourceFile */) {
|
|
return parent2;
|
|
}
|
|
Debug.assert(parent2.kind === 265 /* ModuleBlock */);
|
|
return cast(parent2.parent, isAmbientModuleDeclaration);
|
|
}
|
|
function isAmbientModuleDeclaration(node) {
|
|
return node.kind === 264 /* ModuleDeclaration */ && node.name.kind === 10 /* StringLiteral */;
|
|
}
|
|
function isExternalModuleImportEquals(eq) {
|
|
return eq.moduleReference.kind === 280 /* ExternalModuleReference */ && eq.moduleReference.expression.kind === 10 /* StringLiteral */;
|
|
}
|
|
|
|
// src/services/findAllReferences.ts
|
|
var DefinitionKind = /* @__PURE__ */ ((DefinitionKind2) => {
|
|
DefinitionKind2[DefinitionKind2["Symbol"] = 0] = "Symbol";
|
|
DefinitionKind2[DefinitionKind2["Label"] = 1] = "Label";
|
|
DefinitionKind2[DefinitionKind2["Keyword"] = 2] = "Keyword";
|
|
DefinitionKind2[DefinitionKind2["This"] = 3] = "This";
|
|
DefinitionKind2[DefinitionKind2["String"] = 4] = "String";
|
|
DefinitionKind2[DefinitionKind2["TripleSlashReference"] = 5] = "TripleSlashReference";
|
|
return DefinitionKind2;
|
|
})(DefinitionKind || {});
|
|
var EntryKind = /* @__PURE__ */ ((EntryKind2) => {
|
|
EntryKind2[EntryKind2["Span"] = 0] = "Span";
|
|
EntryKind2[EntryKind2["Node"] = 1] = "Node";
|
|
EntryKind2[EntryKind2["StringLiteral"] = 2] = "StringLiteral";
|
|
EntryKind2[EntryKind2["SearchedLocalFoundProperty"] = 3] = "SearchedLocalFoundProperty";
|
|
EntryKind2[EntryKind2["SearchedPropertyFoundLocal"] = 4] = "SearchedPropertyFoundLocal";
|
|
return EntryKind2;
|
|
})(EntryKind || {});
|
|
function nodeEntry(node, kind = 1 /* Node */) {
|
|
return {
|
|
kind,
|
|
node: node.name || node,
|
|
context: getContextNodeForNodeEntry(node)
|
|
};
|
|
}
|
|
function isContextWithStartAndEndNode(node) {
|
|
return node && node.kind === void 0;
|
|
}
|
|
function getContextNodeForNodeEntry(node) {
|
|
if (isDeclaration(node)) {
|
|
return getContextNode(node);
|
|
}
|
|
if (!node.parent)
|
|
return void 0;
|
|
if (!isDeclaration(node.parent) && !isExportAssignment(node.parent)) {
|
|
if (isInJSFile(node)) {
|
|
const binaryExpression = isBinaryExpression(node.parent) ? node.parent : isAccessExpression(node.parent) && isBinaryExpression(node.parent.parent) && node.parent.parent.left === node.parent ? node.parent.parent : void 0;
|
|
if (binaryExpression && getAssignmentDeclarationKind(binaryExpression) !== 0 /* None */) {
|
|
return getContextNode(binaryExpression);
|
|
}
|
|
}
|
|
if (isJsxOpeningElement(node.parent) || isJsxClosingElement(node.parent)) {
|
|
return node.parent.parent;
|
|
} else if (isJsxSelfClosingElement(node.parent) || isLabeledStatement(node.parent) || isBreakOrContinueStatement(node.parent)) {
|
|
return node.parent;
|
|
} else if (isStringLiteralLike(node)) {
|
|
const validImport = tryGetImportFromModuleSpecifier(node);
|
|
if (validImport) {
|
|
const declOrStatement = findAncestor(
|
|
validImport,
|
|
(node2) => isDeclaration(node2) || isStatement(node2) || isJSDocTag(node2)
|
|
);
|
|
return isDeclaration(declOrStatement) ? getContextNode(declOrStatement) : declOrStatement;
|
|
}
|
|
}
|
|
const propertyName = findAncestor(node, isComputedPropertyName);
|
|
return propertyName ? getContextNode(propertyName.parent) : void 0;
|
|
}
|
|
if (node.parent.name === node || isConstructorDeclaration(node.parent) || isExportAssignment(node.parent) || (isImportOrExportSpecifier(node.parent) || isBindingElement(node.parent)) && node.parent.propertyName === node || node.kind === 88 /* DefaultKeyword */ && hasSyntacticModifier(node.parent, 1025 /* ExportDefault */)) {
|
|
return getContextNode(node.parent);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getContextNode(node) {
|
|
if (!node)
|
|
return void 0;
|
|
switch (node.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return !isVariableDeclarationList(node.parent) || node.parent.declarations.length !== 1 ? node : isVariableStatement(node.parent.parent) ? node.parent.parent : isForInOrOfStatement(node.parent.parent) ? getContextNode(node.parent.parent) : node.parent;
|
|
case 205 /* BindingElement */:
|
|
return getContextNode(node.parent.parent);
|
|
case 273 /* ImportSpecifier */:
|
|
return node.parent.parent.parent;
|
|
case 278 /* ExportSpecifier */:
|
|
case 271 /* NamespaceImport */:
|
|
return node.parent.parent;
|
|
case 270 /* ImportClause */:
|
|
case 277 /* NamespaceExport */:
|
|
return node.parent;
|
|
case 223 /* BinaryExpression */:
|
|
return isExpressionStatement(node.parent) ? node.parent : node;
|
|
case 247 /* ForOfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
return {
|
|
start: node.initializer,
|
|
end: node.expression
|
|
};
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
return isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent) ? getContextNode(
|
|
findAncestor(
|
|
node.parent,
|
|
(node2) => isBinaryExpression(node2) || isForInOrOfStatement(node2)
|
|
)
|
|
) : node;
|
|
default:
|
|
return node;
|
|
}
|
|
}
|
|
function toContextSpan(textSpan, sourceFile, context) {
|
|
if (!context)
|
|
return void 0;
|
|
const contextSpan = isContextWithStartAndEndNode(context) ? getTextSpan(context.start, sourceFile, context.end) : getTextSpan(context, sourceFile);
|
|
return contextSpan.start !== textSpan.start || contextSpan.length !== textSpan.length ? { contextSpan } : void 0;
|
|
}
|
|
var FindReferencesUse = /* @__PURE__ */ ((FindReferencesUse2) => {
|
|
FindReferencesUse2[FindReferencesUse2["Other"] = 0] = "Other";
|
|
FindReferencesUse2[FindReferencesUse2["References"] = 1] = "References";
|
|
FindReferencesUse2[FindReferencesUse2["Rename"] = 2] = "Rename";
|
|
return FindReferencesUse2;
|
|
})(FindReferencesUse || {});
|
|
function findReferencedSymbols(program, cancellationToken, sourceFiles, sourceFile, position) {
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
const options = { use: 1 /* References */ };
|
|
const referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options);
|
|
const checker = program.getTypeChecker();
|
|
const adjustedNode = Core.getAdjustedNode(node, options);
|
|
const symbol = isDefinitionForReference(adjustedNode) ? checker.getSymbolAtLocation(adjustedNode) : void 0;
|
|
return !referencedSymbols || !referencedSymbols.length ? void 0 : mapDefined(referencedSymbols, ({ definition, references }) => definition && {
|
|
definition: checker.runWithCancellationToken(cancellationToken, (checker2) => definitionToReferencedSymbolDefinitionInfo(definition, checker2, node)),
|
|
references: references.map((r) => toReferencedSymbolEntry(r, symbol))
|
|
});
|
|
}
|
|
function isDefinitionForReference(node) {
|
|
return node.kind === 88 /* DefaultKeyword */ || !!getDeclarationFromName(node) || isLiteralComputedPropertyDeclarationName(node) || node.kind === 135 /* ConstructorKeyword */ && isConstructorDeclaration(node.parent);
|
|
}
|
|
function getImplementationsAtPosition(program, cancellationToken, sourceFiles, sourceFile, position) {
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
let referenceEntries;
|
|
const entries = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position);
|
|
if (node.parent.kind === 208 /* PropertyAccessExpression */ || node.parent.kind === 205 /* BindingElement */ || node.parent.kind === 209 /* ElementAccessExpression */ || node.kind === 106 /* SuperKeyword */) {
|
|
referenceEntries = entries && [...entries];
|
|
} else if (entries) {
|
|
const queue = createQueue(entries);
|
|
const seenNodes = /* @__PURE__ */ new Map();
|
|
while (!queue.isEmpty()) {
|
|
const entry = queue.dequeue();
|
|
if (!addToSeen(seenNodes, getNodeId(entry.node))) {
|
|
continue;
|
|
}
|
|
referenceEntries = append(referenceEntries, entry);
|
|
const entries2 = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, entry.node, entry.node.pos);
|
|
if (entries2) {
|
|
queue.enqueue(...entries2);
|
|
}
|
|
}
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
return map(referenceEntries, (entry) => toImplementationLocation(entry, checker));
|
|
}
|
|
function getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position) {
|
|
if (node.kind === 308 /* SourceFile */) {
|
|
return void 0;
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
if (node.parent.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const result = [];
|
|
Core.getReferenceEntriesForShorthandPropertyAssignment(node, checker, (node2) => result.push(nodeEntry(node2)));
|
|
return result;
|
|
} else if (node.kind === 106 /* SuperKeyword */ || isSuperProperty(node.parent)) {
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
return symbol.valueDeclaration && [nodeEntry(symbol.valueDeclaration)];
|
|
} else {
|
|
return getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, { implementations: true, use: 1 /* References */ });
|
|
}
|
|
}
|
|
function findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, convertEntry) {
|
|
return map(flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options)), (entry) => convertEntry(entry, node, program.getTypeChecker()));
|
|
}
|
|
function getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
|
|
return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet));
|
|
}
|
|
function flattenEntries(referenceSymbols) {
|
|
return referenceSymbols && flatMap(referenceSymbols, (r) => r.references);
|
|
}
|
|
function definitionToReferencedSymbolDefinitionInfo(def, checker, originalNode) {
|
|
const info = (() => {
|
|
switch (def.type) {
|
|
case 0 /* Symbol */: {
|
|
const { symbol } = def;
|
|
const { displayParts: displayParts2, kind: kind2 } = getDefinitionKindAndDisplayParts(symbol, checker, originalNode);
|
|
const name2 = displayParts2.map((p) => p.text).join("");
|
|
const declaration = symbol.declarations && firstOrUndefined(symbol.declarations);
|
|
const node = declaration ? getNameOfDeclaration(declaration) || declaration : originalNode;
|
|
return {
|
|
...getFileAndTextSpanFromNode(node),
|
|
name: name2,
|
|
kind: kind2,
|
|
displayParts: displayParts2,
|
|
context: getContextNode(declaration)
|
|
};
|
|
}
|
|
case 1 /* Label */: {
|
|
const { node } = def;
|
|
return { ...getFileAndTextSpanFromNode(node), name: node.text, kind: "label" /* label */, displayParts: [displayPart(node.text, 17 /* text */)] };
|
|
}
|
|
case 2 /* Keyword */: {
|
|
const { node } = def;
|
|
const name2 = tokenToString(node.kind);
|
|
return { ...getFileAndTextSpanFromNode(node), name: name2, kind: "keyword" /* keyword */, displayParts: [{ text: name2, kind: "keyword" /* keyword */ }] };
|
|
}
|
|
case 3 /* This */: {
|
|
const { node } = def;
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
const displayParts2 = symbol && ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(
|
|
checker,
|
|
symbol,
|
|
node.getSourceFile(),
|
|
getContainerNode(node),
|
|
node
|
|
).displayParts || [textPart("this")];
|
|
return { ...getFileAndTextSpanFromNode(node), name: "this", kind: "var" /* variableElement */, displayParts: displayParts2 };
|
|
}
|
|
case 4 /* String */: {
|
|
const { node } = def;
|
|
return {
|
|
...getFileAndTextSpanFromNode(node),
|
|
name: node.text,
|
|
kind: "var" /* variableElement */,
|
|
displayParts: [displayPart(getTextOfNode(node), 8 /* stringLiteral */)]
|
|
};
|
|
}
|
|
case 5 /* TripleSlashReference */: {
|
|
return {
|
|
textSpan: createTextSpanFromRange(def.reference),
|
|
sourceFile: def.file,
|
|
name: def.reference.fileName,
|
|
kind: "string" /* string */,
|
|
displayParts: [displayPart(`"${def.reference.fileName}"`, 8 /* stringLiteral */)]
|
|
};
|
|
}
|
|
default:
|
|
return Debug.assertNever(def);
|
|
}
|
|
})();
|
|
const { sourceFile, textSpan, name, kind, displayParts, context } = info;
|
|
return {
|
|
containerKind: "" /* unknown */,
|
|
containerName: "",
|
|
fileName: sourceFile.fileName,
|
|
kind,
|
|
name,
|
|
textSpan,
|
|
displayParts,
|
|
...toContextSpan(textSpan, sourceFile, context)
|
|
};
|
|
}
|
|
function getFileAndTextSpanFromNode(node) {
|
|
const sourceFile = node.getSourceFile();
|
|
return {
|
|
sourceFile,
|
|
textSpan: getTextSpan(isComputedPropertyName(node) ? node.expression : node, sourceFile)
|
|
};
|
|
}
|
|
function getDefinitionKindAndDisplayParts(symbol, checker, node) {
|
|
const meaning = Core.getIntersectingMeaningFromDeclarations(node, symbol);
|
|
const enclosingDeclaration = symbol.declarations && firstOrUndefined(symbol.declarations) || node;
|
|
const { displayParts, symbolKind } = ts_SymbolDisplay_exports.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, enclosingDeclaration.getSourceFile(), enclosingDeclaration, enclosingDeclaration, meaning);
|
|
return { displayParts, kind: symbolKind };
|
|
}
|
|
function toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixText) {
|
|
return { ...entryToDocumentSpan(entry), ...providePrefixAndSuffixText && getPrefixAndSuffixText(entry, originalNode, checker) };
|
|
}
|
|
function toReferencedSymbolEntry(entry, symbol) {
|
|
const referenceEntry = toReferenceEntry(entry);
|
|
if (!symbol)
|
|
return referenceEntry;
|
|
return {
|
|
...referenceEntry,
|
|
isDefinition: entry.kind !== 0 /* Span */ && isDeclarationOfSymbol(entry.node, symbol)
|
|
};
|
|
}
|
|
function toReferenceEntry(entry) {
|
|
const documentSpan = entryToDocumentSpan(entry);
|
|
if (entry.kind === 0 /* Span */) {
|
|
return { ...documentSpan, isWriteAccess: false };
|
|
}
|
|
const { kind, node } = entry;
|
|
return {
|
|
...documentSpan,
|
|
isWriteAccess: isWriteAccessForReference(node),
|
|
isInString: kind === 2 /* StringLiteral */ ? true : void 0
|
|
};
|
|
}
|
|
function entryToDocumentSpan(entry) {
|
|
if (entry.kind === 0 /* Span */) {
|
|
return { textSpan: entry.textSpan, fileName: entry.fileName };
|
|
} else {
|
|
const sourceFile = entry.node.getSourceFile();
|
|
const textSpan = getTextSpan(entry.node, sourceFile);
|
|
return {
|
|
textSpan,
|
|
fileName: sourceFile.fileName,
|
|
...toContextSpan(textSpan, sourceFile, entry.context)
|
|
};
|
|
}
|
|
}
|
|
function getPrefixAndSuffixText(entry, originalNode, checker) {
|
|
if (entry.kind !== 0 /* Span */ && isIdentifier(originalNode)) {
|
|
const { node, kind } = entry;
|
|
const parent2 = node.parent;
|
|
const name = originalNode.text;
|
|
const isShorthandAssignment = isShorthandPropertyAssignment(parent2);
|
|
if (isShorthandAssignment || isObjectBindingElementWithoutPropertyName(parent2) && parent2.name === node && parent2.dotDotDotToken === void 0) {
|
|
const prefixColon = { prefixText: name + ": " };
|
|
const suffixColon = { suffixText: ": " + name };
|
|
if (kind === 3 /* SearchedLocalFoundProperty */) {
|
|
return prefixColon;
|
|
}
|
|
if (kind === 4 /* SearchedPropertyFoundLocal */) {
|
|
return suffixColon;
|
|
}
|
|
if (isShorthandAssignment) {
|
|
const grandParent = parent2.parent;
|
|
if (isObjectLiteralExpression(grandParent) && isBinaryExpression(grandParent.parent) && isModuleExportsAccessExpression(grandParent.parent.left)) {
|
|
return prefixColon;
|
|
}
|
|
return suffixColon;
|
|
} else {
|
|
return prefixColon;
|
|
}
|
|
} else if (isImportSpecifier(parent2) && !parent2.propertyName) {
|
|
const originalSymbol = isExportSpecifier(originalNode.parent) ? checker.getExportSpecifierLocalTargetSymbol(originalNode.parent) : checker.getSymbolAtLocation(originalNode);
|
|
return contains(originalSymbol.declarations, parent2) ? { prefixText: name + " as " } : emptyOptions;
|
|
} else if (isExportSpecifier(parent2) && !parent2.propertyName) {
|
|
return originalNode === entry.node || checker.getSymbolAtLocation(originalNode) === checker.getSymbolAtLocation(entry.node) ? { prefixText: name + " as " } : { suffixText: " as " + name };
|
|
}
|
|
}
|
|
return emptyOptions;
|
|
}
|
|
function toImplementationLocation(entry, checker) {
|
|
const documentSpan = entryToDocumentSpan(entry);
|
|
if (entry.kind !== 0 /* Span */) {
|
|
const { node } = entry;
|
|
return {
|
|
...documentSpan,
|
|
...implementationKindDisplayParts(node, checker)
|
|
};
|
|
} else {
|
|
return { ...documentSpan, kind: "" /* unknown */, displayParts: [] };
|
|
}
|
|
}
|
|
function implementationKindDisplayParts(node, checker) {
|
|
const symbol = checker.getSymbolAtLocation(isDeclaration(node) && node.name ? node.name : node);
|
|
if (symbol) {
|
|
return getDefinitionKindAndDisplayParts(symbol, checker, node);
|
|
} else if (node.kind === 207 /* ObjectLiteralExpression */) {
|
|
return {
|
|
kind: "interface" /* interfaceElement */,
|
|
displayParts: [punctuationPart(20 /* OpenParenToken */), textPart("object literal"), punctuationPart(21 /* CloseParenToken */)]
|
|
};
|
|
} else if (node.kind === 228 /* ClassExpression */) {
|
|
return {
|
|
kind: "local class" /* localClassElement */,
|
|
displayParts: [punctuationPart(20 /* OpenParenToken */), textPart("anonymous local class"), punctuationPart(21 /* CloseParenToken */)]
|
|
};
|
|
} else {
|
|
return { kind: getNodeKind(node), displayParts: [] };
|
|
}
|
|
}
|
|
function toHighlightSpan(entry) {
|
|
const documentSpan = entryToDocumentSpan(entry);
|
|
if (entry.kind === 0 /* Span */) {
|
|
return {
|
|
fileName: documentSpan.fileName,
|
|
span: {
|
|
textSpan: documentSpan.textSpan,
|
|
kind: "reference" /* reference */
|
|
}
|
|
};
|
|
}
|
|
const writeAccess = isWriteAccessForReference(entry.node);
|
|
const span = {
|
|
textSpan: documentSpan.textSpan,
|
|
kind: writeAccess ? "writtenReference" /* writtenReference */ : "reference" /* reference */,
|
|
isInString: entry.kind === 2 /* StringLiteral */ ? true : void 0,
|
|
...documentSpan.contextSpan && { contextSpan: documentSpan.contextSpan }
|
|
};
|
|
return { fileName: documentSpan.fileName, span };
|
|
}
|
|
function getTextSpan(node, sourceFile, endNode2) {
|
|
let start2 = node.getStart(sourceFile);
|
|
let end = (endNode2 || node).getEnd();
|
|
if (isStringLiteralLike(node) && end - start2 > 2) {
|
|
Debug.assert(endNode2 === void 0);
|
|
start2 += 1;
|
|
end -= 1;
|
|
}
|
|
return createTextSpanFromBounds(start2, end);
|
|
}
|
|
function getTextSpanOfEntry(entry) {
|
|
return entry.kind === 0 /* Span */ ? entry.textSpan : getTextSpan(entry.node, entry.node.getSourceFile());
|
|
}
|
|
function isWriteAccessForReference(node) {
|
|
const decl = getDeclarationFromName(node);
|
|
return !!decl && declarationIsWriteAccess(decl) || node.kind === 88 /* DefaultKeyword */ || isWriteAccess(node);
|
|
}
|
|
function isDeclarationOfSymbol(node, target) {
|
|
var _a2;
|
|
if (!target)
|
|
return false;
|
|
const source = getDeclarationFromName(node) || (node.kind === 88 /* DefaultKeyword */ ? node.parent : isLiteralComputedPropertyDeclarationName(node) ? node.parent.parent : node.kind === 135 /* ConstructorKeyword */ && isConstructorDeclaration(node.parent) ? node.parent.parent : void 0);
|
|
const commonjsSource = source && isBinaryExpression(source) ? source.left : void 0;
|
|
return !!(source && ((_a2 = target.declarations) == null ? void 0 : _a2.some((d) => d === source || d === commonjsSource)));
|
|
}
|
|
function declarationIsWriteAccess(decl) {
|
|
if (!!(decl.flags & 16777216 /* Ambient */))
|
|
return true;
|
|
switch (decl.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
case 205 /* BindingElement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 88 /* DefaultKeyword */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 270 /* ImportClause */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 288 /* JsxAttribute */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
case 271 /* NamespaceImport */:
|
|
case 277 /* NamespaceExport */:
|
|
case 166 /* Parameter */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 165 /* TypeParameter */:
|
|
return true;
|
|
case 299 /* PropertyAssignment */:
|
|
return !isArrayLiteralOrObjectLiteralDestructuringPattern(decl.parent);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 173 /* Constructor */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return !!decl.body;
|
|
case 257 /* VariableDeclaration */:
|
|
case 169 /* PropertyDeclaration */:
|
|
return !!decl.initializer || isCatchClause(decl.parent);
|
|
case 170 /* MethodSignature */:
|
|
case 168 /* PropertySignature */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 343 /* JSDocParameterTag */:
|
|
return false;
|
|
default:
|
|
return Debug.failBadSyntaxKind(decl);
|
|
}
|
|
}
|
|
var Core;
|
|
((Core2) => {
|
|
function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options = {}, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
|
|
var _a2, _b;
|
|
node = getAdjustedNode(node, options);
|
|
if (isSourceFile(node)) {
|
|
const resolvedRef = ts_GoToDefinition_exports.getReferenceAtPosition(node, position, program);
|
|
if (!(resolvedRef == null ? void 0 : resolvedRef.file)) {
|
|
return void 0;
|
|
}
|
|
const moduleSymbol = program.getTypeChecker().getMergedSymbol(resolvedRef.file.symbol);
|
|
if (moduleSymbol) {
|
|
return getReferencedSymbolsForModule(program, moduleSymbol, false, sourceFiles, sourceFilesSet);
|
|
}
|
|
const fileIncludeReasons = program.getFileIncludeReasons();
|
|
if (!fileIncludeReasons) {
|
|
return void 0;
|
|
}
|
|
return [{
|
|
definition: { type: 5 /* TripleSlashReference */, reference: resolvedRef.reference, file: node },
|
|
references: getReferencesForNonModule(resolvedRef.file, fileIncludeReasons, program) || emptyArray
|
|
}];
|
|
}
|
|
if (!options.implementations) {
|
|
const special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken);
|
|
if (special) {
|
|
return special;
|
|
}
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(isConstructorDeclaration(node) && node.parent.name || node);
|
|
if (!symbol) {
|
|
if (!options.implementations && isStringLiteralLike(node)) {
|
|
if (isModuleSpecifierLike(node)) {
|
|
const fileIncludeReasons = program.getFileIncludeReasons();
|
|
const referencedFileName = (_b = (_a2 = node.getSourceFile().resolvedModules) == null ? void 0 : _a2.get(node.text, getModeForUsageLocation(node.getSourceFile(), node))) == null ? void 0 : _b.resolvedFileName;
|
|
const referencedFile = referencedFileName ? program.getSourceFile(referencedFileName) : void 0;
|
|
if (referencedFile) {
|
|
return [{ definition: { type: 4 /* String */, node }, references: getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || emptyArray }];
|
|
}
|
|
}
|
|
return getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (symbol.escapedName === "export=" /* ExportEquals */) {
|
|
return getReferencedSymbolsForModule(program, symbol.parent, false, sourceFiles, sourceFilesSet);
|
|
}
|
|
const moduleReferences = getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, cancellationToken, options, sourceFilesSet);
|
|
if (moduleReferences && !(symbol.flags & 33554432 /* Transient */)) {
|
|
return moduleReferences;
|
|
}
|
|
const aliasedSymbol = getMergedAliasedSymbolOfNamespaceExportDeclaration(node, symbol, checker);
|
|
const moduleReferencesOfExportTarget = aliasedSymbol && getReferencedSymbolsForModuleIfDeclaredBySourceFile(aliasedSymbol, program, sourceFiles, cancellationToken, options, sourceFilesSet);
|
|
const references = getReferencedSymbolsForSymbol(symbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options);
|
|
return mergeReferences(program, moduleReferences, references, moduleReferencesOfExportTarget);
|
|
}
|
|
Core2.getReferencedSymbolsForNode = getReferencedSymbolsForNode;
|
|
function getAdjustedNode(node, options) {
|
|
if (options.use === 1 /* References */) {
|
|
node = getAdjustedReferenceLocation(node);
|
|
} else if (options.use === 2 /* Rename */) {
|
|
node = getAdjustedRenameLocation(node);
|
|
}
|
|
return node;
|
|
}
|
|
Core2.getAdjustedNode = getAdjustedNode;
|
|
function getReferencesForFileName(fileName, program, sourceFiles, sourceFilesSet = new Set(sourceFiles.map((f) => f.fileName))) {
|
|
var _a2, _b;
|
|
const moduleSymbol = (_a2 = program.getSourceFile(fileName)) == null ? void 0 : _a2.symbol;
|
|
if (moduleSymbol) {
|
|
return ((_b = getReferencedSymbolsForModule(program, moduleSymbol, false, sourceFiles, sourceFilesSet)[0]) == null ? void 0 : _b.references) || emptyArray;
|
|
}
|
|
const fileIncludeReasons = program.getFileIncludeReasons();
|
|
const referencedFile = program.getSourceFile(fileName);
|
|
return referencedFile && fileIncludeReasons && getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || emptyArray;
|
|
}
|
|
Core2.getReferencesForFileName = getReferencesForFileName;
|
|
function getReferencesForNonModule(referencedFile, refFileMap, program) {
|
|
let entries;
|
|
const references = refFileMap.get(referencedFile.path) || emptyArray;
|
|
for (const ref of references) {
|
|
if (isReferencedFile(ref)) {
|
|
const referencingFile = program.getSourceFileByPath(ref.file);
|
|
const location2 = getReferencedFileLocation(program.getSourceFileByPath, ref);
|
|
if (isReferenceFileLocation(location2)) {
|
|
entries = append(entries, {
|
|
kind: 0 /* Span */,
|
|
fileName: referencingFile.fileName,
|
|
textSpan: createTextSpanFromRange(location2)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return entries;
|
|
}
|
|
function getMergedAliasedSymbolOfNamespaceExportDeclaration(node, symbol, checker) {
|
|
if (node.parent && isNamespaceExportDeclaration(node.parent)) {
|
|
const aliasedSymbol = checker.getAliasedSymbol(symbol);
|
|
const targetSymbol = checker.getMergedSymbol(aliasedSymbol);
|
|
if (aliasedSymbol !== targetSymbol) {
|
|
return targetSymbol;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, cancellationToken, options, sourceFilesSet) {
|
|
const moduleSourceFile = symbol.flags & 1536 /* Module */ && symbol.declarations && find(symbol.declarations, isSourceFile);
|
|
if (!moduleSourceFile)
|
|
return void 0;
|
|
const exportEquals = symbol.exports.get("export=" /* ExportEquals */);
|
|
const moduleReferences = getReferencedSymbolsForModule(program, symbol, !!exportEquals, sourceFiles, sourceFilesSet);
|
|
if (!exportEquals || !sourceFilesSet.has(moduleSourceFile.fileName))
|
|
return moduleReferences;
|
|
const checker = program.getTypeChecker();
|
|
symbol = skipAlias(exportEquals, checker);
|
|
return mergeReferences(program, moduleReferences, getReferencedSymbolsForSymbol(symbol, void 0, sourceFiles, sourceFilesSet, checker, cancellationToken, options));
|
|
}
|
|
function mergeReferences(program, ...referencesToMerge) {
|
|
let result;
|
|
for (const references of referencesToMerge) {
|
|
if (!references || !references.length)
|
|
continue;
|
|
if (!result) {
|
|
result = references;
|
|
continue;
|
|
}
|
|
for (const entry of references) {
|
|
if (!entry.definition || entry.definition.type !== 0 /* Symbol */) {
|
|
result.push(entry);
|
|
continue;
|
|
}
|
|
const symbol = entry.definition.symbol;
|
|
const refIndex = findIndex(result, (ref) => !!ref.definition && ref.definition.type === 0 /* Symbol */ && ref.definition.symbol === symbol);
|
|
if (refIndex === -1) {
|
|
result.push(entry);
|
|
continue;
|
|
}
|
|
const reference = result[refIndex];
|
|
result[refIndex] = {
|
|
definition: reference.definition,
|
|
references: reference.references.concat(entry.references).sort((entry1, entry2) => {
|
|
const entry1File = getSourceFileIndexOfEntry(program, entry1);
|
|
const entry2File = getSourceFileIndexOfEntry(program, entry2);
|
|
if (entry1File !== entry2File) {
|
|
return compareValues(entry1File, entry2File);
|
|
}
|
|
const entry1Span = getTextSpanOfEntry(entry1);
|
|
const entry2Span = getTextSpanOfEntry(entry2);
|
|
return entry1Span.start !== entry2Span.start ? compareValues(entry1Span.start, entry2Span.start) : compareValues(entry1Span.length, entry2Span.length);
|
|
})
|
|
};
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function getSourceFileIndexOfEntry(program, entry) {
|
|
const sourceFile = entry.kind === 0 /* Span */ ? program.getSourceFile(entry.fileName) : entry.node.getSourceFile();
|
|
return program.getSourceFiles().indexOf(sourceFile);
|
|
}
|
|
function getReferencedSymbolsForModule(program, symbol, excludeImportTypeOfExportEquals, sourceFiles, sourceFilesSet) {
|
|
Debug.assert(!!symbol.valueDeclaration);
|
|
const references = mapDefined(findModuleReferences(program, sourceFiles, symbol), (reference) => {
|
|
if (reference.kind === "import") {
|
|
const parent2 = reference.literal.parent;
|
|
if (isLiteralTypeNode(parent2)) {
|
|
const importType = cast(parent2.parent, isImportTypeNode);
|
|
if (excludeImportTypeOfExportEquals && !importType.qualifier) {
|
|
return void 0;
|
|
}
|
|
}
|
|
return nodeEntry(reference.literal);
|
|
} else {
|
|
return {
|
|
kind: 0 /* Span */,
|
|
fileName: reference.referencingFile.fileName,
|
|
textSpan: createTextSpanFromRange(reference.ref)
|
|
};
|
|
}
|
|
});
|
|
if (symbol.declarations) {
|
|
for (const decl of symbol.declarations) {
|
|
switch (decl.kind) {
|
|
case 308 /* SourceFile */:
|
|
break;
|
|
case 264 /* ModuleDeclaration */:
|
|
if (sourceFilesSet.has(decl.getSourceFile().fileName)) {
|
|
references.push(nodeEntry(decl.name));
|
|
}
|
|
break;
|
|
default:
|
|
Debug.assert(!!(symbol.flags & 33554432 /* Transient */), "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration.");
|
|
}
|
|
}
|
|
}
|
|
const exported = symbol.exports.get("export=" /* ExportEquals */);
|
|
if (exported == null ? void 0 : exported.declarations) {
|
|
for (const decl of exported.declarations) {
|
|
const sourceFile = decl.getSourceFile();
|
|
if (sourceFilesSet.has(sourceFile.fileName)) {
|
|
const node = isBinaryExpression(decl) && isPropertyAccessExpression(decl.left) ? decl.left.expression : isExportAssignment(decl) ? Debug.checkDefined(findChildOfKind(decl, 93 /* ExportKeyword */, sourceFile)) : getNameOfDeclaration(decl) || decl;
|
|
references.push(nodeEntry(node));
|
|
}
|
|
}
|
|
}
|
|
return references.length ? [{ definition: { type: 0 /* Symbol */, symbol }, references }] : emptyArray;
|
|
}
|
|
function isReadonlyTypeOperator(node) {
|
|
return node.kind === 146 /* ReadonlyKeyword */ && isTypeOperatorNode(node.parent) && node.parent.operator === 146 /* ReadonlyKeyword */;
|
|
}
|
|
function getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken) {
|
|
if (isTypeKeyword(node.kind)) {
|
|
if (node.kind === 114 /* VoidKeyword */ && isVoidExpression(node.parent)) {
|
|
return void 0;
|
|
}
|
|
if (node.kind === 146 /* ReadonlyKeyword */ && !isReadonlyTypeOperator(node)) {
|
|
return void 0;
|
|
}
|
|
return getAllReferencesForKeyword(
|
|
sourceFiles,
|
|
node.kind,
|
|
cancellationToken,
|
|
node.kind === 146 /* ReadonlyKeyword */ ? isReadonlyTypeOperator : void 0
|
|
);
|
|
}
|
|
if (isImportMeta(node.parent) && node.parent.name === node) {
|
|
return getAllReferencesForImportMeta(sourceFiles, cancellationToken);
|
|
}
|
|
if (isStaticModifier(node) && isClassStaticBlockDeclaration(node.parent)) {
|
|
return [{ definition: { type: 2 /* Keyword */, node }, references: [nodeEntry(node)] }];
|
|
}
|
|
if (isJumpStatementTarget(node)) {
|
|
const labelDefinition = getTargetLabel(node.parent, node.text);
|
|
return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition);
|
|
} else if (isLabelOfLabeledStatement(node)) {
|
|
return getLabelReferencesInNode(node.parent, node);
|
|
}
|
|
if (isThis(node)) {
|
|
return getReferencesForThisKeyword(node, sourceFiles, cancellationToken);
|
|
}
|
|
if (node.kind === 106 /* SuperKeyword */) {
|
|
return getReferencesForSuperKeyword(node);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getReferencedSymbolsForSymbol(originalSymbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options) {
|
|
const symbol = node && skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker, !isForRenameWithPrefixAndSuffixText(options)) || originalSymbol;
|
|
const searchMeaning = node ? getIntersectingMeaningFromDeclarations(node, symbol) : 7 /* All */;
|
|
const result = [];
|
|
const state = new State(sourceFiles, sourceFilesSet, node ? getSpecialSearchKind(node) : SpecialSearchKind.None, checker, cancellationToken, searchMeaning, options, result);
|
|
const exportSpecifier = !isForRenameWithPrefixAndSuffixText(options) || !symbol.declarations ? void 0 : find(symbol.declarations, isExportSpecifier);
|
|
if (exportSpecifier) {
|
|
getReferencesAtExportSpecifier(exportSpecifier.name, symbol, exportSpecifier, state.createSearch(node, originalSymbol, void 0), state, true, true);
|
|
} else if (node && node.kind === 88 /* DefaultKeyword */ && symbol.escapedName === "default" /* Default */ && symbol.parent) {
|
|
addReference(node, symbol, state);
|
|
searchForImportsOfExport(node, symbol, { exportingModuleSymbol: symbol.parent, exportKind: 1 /* Default */ }, state);
|
|
} else {
|
|
const search = state.createSearch(node, symbol, void 0, { allSearchSymbols: node ? populateSearchSymbolSet(symbol, node, checker, options.use === 2 /* Rename */, !!options.providePrefixAndSuffixTextForRename, !!options.implementations) : [symbol] });
|
|
getReferencesInContainerOrFiles(symbol, state, search);
|
|
}
|
|
return result;
|
|
}
|
|
function getReferencesInContainerOrFiles(symbol, state, search) {
|
|
const scope = getSymbolScope(symbol);
|
|
if (scope) {
|
|
getReferencesInContainer(scope, scope.getSourceFile(), search, state, !(isSourceFile(scope) && !contains(state.sourceFiles, scope)));
|
|
} else {
|
|
for (const sourceFile of state.sourceFiles) {
|
|
state.cancellationToken.throwIfCancellationRequested();
|
|
searchForName(sourceFile, search, state);
|
|
}
|
|
}
|
|
}
|
|
function getSpecialSearchKind(node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 135 /* ConstructorKeyword */:
|
|
return SpecialSearchKind.Constructor;
|
|
case 79 /* Identifier */:
|
|
if (isClassLike(node.parent)) {
|
|
Debug.assert(node.parent.name === node);
|
|
return SpecialSearchKind.Class;
|
|
}
|
|
default:
|
|
return SpecialSearchKind.None;
|
|
}
|
|
}
|
|
function skipPastExportOrImportSpecifierOrUnion(symbol, node, checker, useLocalSymbolForExportSpecifier) {
|
|
const { parent: parent2 } = node;
|
|
if (isExportSpecifier(parent2) && useLocalSymbolForExportSpecifier) {
|
|
return getLocalSymbolForExportSpecifier(node, symbol, parent2, checker);
|
|
}
|
|
return firstDefined(symbol.declarations, (decl) => {
|
|
if (!decl.parent) {
|
|
if (symbol.flags & 33554432 /* Transient */)
|
|
return void 0;
|
|
Debug.fail(`Unexpected symbol at ${Debug.formatSyntaxKind(node.kind)}: ${Debug.formatSymbol(symbol)}`);
|
|
}
|
|
return isTypeLiteralNode(decl.parent) && isUnionTypeNode(decl.parent.parent) ? checker.getPropertyOfType(checker.getTypeFromTypeNode(decl.parent.parent), symbol.name) : void 0;
|
|
});
|
|
}
|
|
let SpecialSearchKind;
|
|
((SpecialSearchKind2) => {
|
|
SpecialSearchKind2[SpecialSearchKind2["None"] = 0] = "None";
|
|
SpecialSearchKind2[SpecialSearchKind2["Constructor"] = 1] = "Constructor";
|
|
SpecialSearchKind2[SpecialSearchKind2["Class"] = 2] = "Class";
|
|
})(SpecialSearchKind || (SpecialSearchKind = {}));
|
|
function getNonModuleSymbolOfMergedModuleSymbol(symbol) {
|
|
if (!(symbol.flags & (1536 /* Module */ | 33554432 /* Transient */)))
|
|
return void 0;
|
|
const decl = symbol.declarations && find(symbol.declarations, (d) => !isSourceFile(d) && !isModuleDeclaration(d));
|
|
return decl && decl.symbol;
|
|
}
|
|
class State {
|
|
constructor(sourceFiles, sourceFilesSet, specialSearchKind, checker, cancellationToken, searchMeaning, options, result) {
|
|
this.sourceFiles = sourceFiles;
|
|
this.sourceFilesSet = sourceFilesSet;
|
|
this.specialSearchKind = specialSearchKind;
|
|
this.checker = checker;
|
|
this.cancellationToken = cancellationToken;
|
|
this.searchMeaning = searchMeaning;
|
|
this.options = options;
|
|
this.result = result;
|
|
this.inheritsFromCache = /* @__PURE__ */ new Map();
|
|
this.markSeenContainingTypeReference = nodeSeenTracker();
|
|
this.markSeenReExportRHS = nodeSeenTracker();
|
|
this.symbolIdToReferences = [];
|
|
this.sourceFileToSeenSymbols = [];
|
|
}
|
|
includesSourceFile(sourceFile) {
|
|
return this.sourceFilesSet.has(sourceFile.fileName);
|
|
}
|
|
getImportSearches(exportSymbol, exportInfo) {
|
|
if (!this.importTracker)
|
|
this.importTracker = createImportTracker(this.sourceFiles, this.sourceFilesSet, this.checker, this.cancellationToken);
|
|
return this.importTracker(exportSymbol, exportInfo, this.options.use === 2 /* Rename */);
|
|
}
|
|
createSearch(location2, symbol, comingFrom, searchOptions = {}) {
|
|
const {
|
|
text = stripQuotes(symbolName(getLocalSymbolForExportDefault(symbol) || getNonModuleSymbolOfMergedModuleSymbol(symbol) || symbol)),
|
|
allSearchSymbols = [symbol]
|
|
} = searchOptions;
|
|
const escapedText = escapeLeadingUnderscores(text);
|
|
const parents = this.options.implementations && location2 ? getParentSymbolsOfPropertyAccess(location2, symbol, this.checker) : void 0;
|
|
return { symbol, comingFrom, text, escapedText, parents, allSearchSymbols, includes: (sym) => contains(allSearchSymbols, sym) };
|
|
}
|
|
referenceAdder(searchSymbol) {
|
|
const symbolId = getSymbolId(searchSymbol);
|
|
let references = this.symbolIdToReferences[symbolId];
|
|
if (!references) {
|
|
references = this.symbolIdToReferences[symbolId] = [];
|
|
this.result.push({ definition: { type: 0 /* Symbol */, symbol: searchSymbol }, references });
|
|
}
|
|
return (node, kind) => references.push(nodeEntry(node, kind));
|
|
}
|
|
addStringOrCommentReference(fileName, textSpan) {
|
|
this.result.push({
|
|
definition: void 0,
|
|
references: [{ kind: 0 /* Span */, fileName, textSpan }]
|
|
});
|
|
}
|
|
markSearchedSymbols(sourceFile, symbols) {
|
|
const sourceId = getNodeId(sourceFile);
|
|
const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = /* @__PURE__ */ new Set());
|
|
let anyNewSymbols = false;
|
|
for (const sym of symbols) {
|
|
anyNewSymbols = tryAddToSet(seenSymbols, getSymbolId(sym)) || anyNewSymbols;
|
|
}
|
|
return anyNewSymbols;
|
|
}
|
|
}
|
|
function searchForImportsOfExport(exportLocation, exportSymbol, exportInfo, state) {
|
|
const { importSearches, singleReferences, indirectUsers } = state.getImportSearches(exportSymbol, exportInfo);
|
|
if (singleReferences.length) {
|
|
const addRef = state.referenceAdder(exportSymbol);
|
|
for (const singleRef of singleReferences) {
|
|
if (shouldAddSingleReference(singleRef, state))
|
|
addRef(singleRef);
|
|
}
|
|
}
|
|
for (const [importLocation, importSymbol] of importSearches) {
|
|
getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, 1 /* Export */), state);
|
|
}
|
|
if (indirectUsers.length) {
|
|
let indirectSearch;
|
|
switch (exportInfo.exportKind) {
|
|
case 0 /* Named */:
|
|
indirectSearch = state.createSearch(exportLocation, exportSymbol, 1 /* Export */);
|
|
break;
|
|
case 1 /* Default */:
|
|
indirectSearch = state.options.use === 2 /* Rename */ ? void 0 : state.createSearch(exportLocation, exportSymbol, 1 /* Export */, { text: "default" });
|
|
break;
|
|
case 2 /* ExportEquals */:
|
|
break;
|
|
}
|
|
if (indirectSearch) {
|
|
for (const indirectUser of indirectUsers) {
|
|
searchForName(indirectUser, indirectSearch, state);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function eachExportReference(sourceFiles, checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName, isDefaultExport, cb) {
|
|
const importTracker = createImportTracker(sourceFiles, new Set(sourceFiles.map((f) => f.fileName)), checker, cancellationToken);
|
|
const { importSearches, indirectUsers, singleReferences } = importTracker(exportSymbol, { exportKind: isDefaultExport ? 1 /* Default */ : 0 /* Named */, exportingModuleSymbol }, false);
|
|
for (const [importLocation] of importSearches) {
|
|
cb(importLocation);
|
|
}
|
|
for (const singleReference of singleReferences) {
|
|
if (isIdentifier(singleReference) && isImportTypeNode(singleReference.parent)) {
|
|
cb(singleReference);
|
|
}
|
|
}
|
|
for (const indirectUser of indirectUsers) {
|
|
for (const node of getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName)) {
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
const hasExportAssignmentDeclaration = some(symbol == null ? void 0 : symbol.declarations, (d) => tryCast(d, isExportAssignment) ? true : false);
|
|
if (isIdentifier(node) && !isImportOrExportSpecifier(node.parent) && (symbol === exportSymbol || hasExportAssignmentDeclaration)) {
|
|
cb(node);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Core2.eachExportReference = eachExportReference;
|
|
function shouldAddSingleReference(singleRef, state) {
|
|
if (!hasMatchingMeaning(singleRef, state))
|
|
return false;
|
|
if (state.options.use !== 2 /* Rename */)
|
|
return true;
|
|
if (!isIdentifier(singleRef))
|
|
return false;
|
|
return !(isImportOrExportSpecifier(singleRef.parent) && singleRef.escapedText === "default" /* Default */);
|
|
}
|
|
function searchForImportedSymbol(symbol, state) {
|
|
if (!symbol.declarations)
|
|
return;
|
|
for (const declaration of symbol.declarations) {
|
|
const exportingFile = declaration.getSourceFile();
|
|
getReferencesInSourceFile(exportingFile, state.createSearch(declaration, symbol, 0 /* Import */), state, state.includesSourceFile(exportingFile));
|
|
}
|
|
}
|
|
function searchForName(sourceFile, search, state) {
|
|
if (getNameTable(sourceFile).get(search.escapedText) !== void 0) {
|
|
getReferencesInSourceFile(sourceFile, search, state);
|
|
}
|
|
}
|
|
function getPropertySymbolOfDestructuringAssignment(location2, checker) {
|
|
return isArrayLiteralOrObjectLiteralDestructuringPattern(location2.parent.parent) ? checker.getPropertySymbolOfDestructuringAssignment(location2) : void 0;
|
|
}
|
|
function getSymbolScope(symbol) {
|
|
const { declarations, flags, parent: parent2, valueDeclaration } = symbol;
|
|
if (valueDeclaration && (valueDeclaration.kind === 215 /* FunctionExpression */ || valueDeclaration.kind === 228 /* ClassExpression */)) {
|
|
return valueDeclaration;
|
|
}
|
|
if (!declarations) {
|
|
return void 0;
|
|
}
|
|
if (flags & (4 /* Property */ | 8192 /* Method */)) {
|
|
const privateDeclaration = find(declarations, (d) => hasEffectiveModifier(d, 8 /* Private */) || isPrivateIdentifierClassElementDeclaration(d));
|
|
if (privateDeclaration) {
|
|
return getAncestor(privateDeclaration, 260 /* ClassDeclaration */);
|
|
}
|
|
return void 0;
|
|
}
|
|
if (declarations.some(isObjectBindingElementWithoutPropertyName)) {
|
|
return void 0;
|
|
}
|
|
const exposedByParent = parent2 && !(symbol.flags & 262144 /* TypeParameter */);
|
|
if (exposedByParent && !(isExternalModuleSymbol(parent2) && !parent2.globalExports)) {
|
|
return void 0;
|
|
}
|
|
let scope;
|
|
for (const declaration of declarations) {
|
|
const container = getContainerNode(declaration);
|
|
if (scope && scope !== container) {
|
|
return void 0;
|
|
}
|
|
if (!container || container.kind === 308 /* SourceFile */ && !isExternalOrCommonJsModule(container)) {
|
|
return void 0;
|
|
}
|
|
scope = container;
|
|
if (isFunctionExpression(scope)) {
|
|
let next;
|
|
while (next = getNextJSDocCommentLocation(scope)) {
|
|
scope = next;
|
|
}
|
|
}
|
|
}
|
|
return exposedByParent ? scope.getSourceFile() : scope;
|
|
}
|
|
function isSymbolReferencedInFile(definition, checker, sourceFile, searchContainer = sourceFile) {
|
|
return eachSymbolReferenceInFile(definition, checker, sourceFile, () => true, searchContainer) || false;
|
|
}
|
|
Core2.isSymbolReferencedInFile = isSymbolReferencedInFile;
|
|
function eachSymbolReferenceInFile(definition, checker, sourceFile, cb, searchContainer = sourceFile) {
|
|
const symbol = isParameterPropertyDeclaration(definition.parent, definition.parent.parent) ? first(checker.getSymbolsOfParameterPropertyDeclaration(definition.parent, definition.text)) : checker.getSymbolAtLocation(definition);
|
|
if (!symbol)
|
|
return void 0;
|
|
for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer)) {
|
|
if (!isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText)
|
|
continue;
|
|
const referenceSymbol = checker.getSymbolAtLocation(token);
|
|
if (referenceSymbol === symbol || checker.getShorthandAssignmentValueSymbol(token.parent) === symbol || isExportSpecifier(token.parent) && getLocalSymbolForExportSpecifier(token, referenceSymbol, token.parent, checker) === symbol) {
|
|
const res = cb(token);
|
|
if (res)
|
|
return res;
|
|
}
|
|
}
|
|
}
|
|
Core2.eachSymbolReferenceInFile = eachSymbolReferenceInFile;
|
|
function getTopMostDeclarationNamesInFile(declarationName, sourceFile) {
|
|
const candidates = filter(getPossibleSymbolReferenceNodes(sourceFile, declarationName), (name) => !!getDeclarationFromName(name));
|
|
return candidates.reduce((topMost, decl) => {
|
|
const depth = getDepth(decl);
|
|
if (!some(topMost.declarationNames) || depth === topMost.depth) {
|
|
topMost.declarationNames.push(decl);
|
|
topMost.depth = depth;
|
|
} else if (depth < topMost.depth) {
|
|
topMost.declarationNames = [decl];
|
|
topMost.depth = depth;
|
|
}
|
|
return topMost;
|
|
}, { depth: Infinity, declarationNames: [] }).declarationNames;
|
|
function getDepth(declaration) {
|
|
let depth = 0;
|
|
while (declaration) {
|
|
declaration = getContainerNode(declaration);
|
|
depth++;
|
|
}
|
|
return depth;
|
|
}
|
|
}
|
|
Core2.getTopMostDeclarationNamesInFile = getTopMostDeclarationNamesInFile;
|
|
function someSignatureUsage(signature, sourceFiles, checker, cb) {
|
|
if (!signature.name || !isIdentifier(signature.name))
|
|
return false;
|
|
const symbol = Debug.checkDefined(checker.getSymbolAtLocation(signature.name));
|
|
for (const sourceFile of sourceFiles) {
|
|
for (const name of getPossibleSymbolReferenceNodes(sourceFile, symbol.name)) {
|
|
if (!isIdentifier(name) || name === signature.name || name.escapedText !== signature.name.escapedText)
|
|
continue;
|
|
const called = climbPastPropertyAccess(name);
|
|
const call = isCallExpression(called.parent) && called.parent.expression === called ? called.parent : void 0;
|
|
const referenceSymbol = checker.getSymbolAtLocation(name);
|
|
if (referenceSymbol && checker.getRootSymbols(referenceSymbol).some((s) => s === symbol)) {
|
|
if (cb(name, call)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
Core2.someSignatureUsage = someSignatureUsage;
|
|
function getPossibleSymbolReferenceNodes(sourceFile, symbolName2, container = sourceFile) {
|
|
return getPossibleSymbolReferencePositions(sourceFile, symbolName2, container).map((pos) => getTouchingPropertyName(sourceFile, pos));
|
|
}
|
|
function getPossibleSymbolReferencePositions(sourceFile, symbolName2, container = sourceFile) {
|
|
const positions = [];
|
|
if (!symbolName2 || !symbolName2.length) {
|
|
return positions;
|
|
}
|
|
const text = sourceFile.text;
|
|
const sourceLength = text.length;
|
|
const symbolNameLength = symbolName2.length;
|
|
let position = text.indexOf(symbolName2, container.pos);
|
|
while (position >= 0) {
|
|
if (position > container.end)
|
|
break;
|
|
const endPosition = position + symbolNameLength;
|
|
if ((position === 0 || !isIdentifierPart(text.charCodeAt(position - 1), 99 /* Latest */)) && (endPosition === sourceLength || !isIdentifierPart(text.charCodeAt(endPosition), 99 /* Latest */))) {
|
|
positions.push(position);
|
|
}
|
|
position = text.indexOf(symbolName2, position + symbolNameLength + 1);
|
|
}
|
|
return positions;
|
|
}
|
|
function getLabelReferencesInNode(container, targetLabel) {
|
|
const sourceFile = container.getSourceFile();
|
|
const labelName = targetLabel.text;
|
|
const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), (node) => node === targetLabel || isJumpStatementTarget(node) && getTargetLabel(node, labelName) === targetLabel ? nodeEntry(node) : void 0);
|
|
return [{ definition: { type: 1 /* Label */, node: targetLabel }, references }];
|
|
}
|
|
function isValidReferencePosition(node, searchSymbolName) {
|
|
switch (node.kind) {
|
|
case 80 /* PrivateIdentifier */:
|
|
if (isJSDocMemberName(node.parent)) {
|
|
return true;
|
|
}
|
|
case 79 /* Identifier */:
|
|
return node.text.length === searchSymbolName.length;
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 10 /* StringLiteral */: {
|
|
const str = node;
|
|
return (isLiteralNameOfPropertyDeclarationOrIndexAccess(str) || isNameOfModuleDeclaration(node) || isExpressionOfExternalModuleImportEqualsDeclaration(node) || isCallExpression(node.parent) && isBindableObjectDefinePropertyCall(node.parent) && node.parent.arguments[1] === node) && str.text.length === searchSymbolName.length;
|
|
}
|
|
case 8 /* NumericLiteral */:
|
|
return isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && node.text.length === searchSymbolName.length;
|
|
case 88 /* DefaultKeyword */:
|
|
return "default".length === searchSymbolName.length;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function getAllReferencesForImportMeta(sourceFiles, cancellationToken) {
|
|
const references = flatMap(sourceFiles, (sourceFile) => {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "meta", sourceFile), (node) => {
|
|
const parent2 = node.parent;
|
|
if (isImportMeta(parent2)) {
|
|
return nodeEntry(parent2);
|
|
}
|
|
});
|
|
});
|
|
return references.length ? [{ definition: { type: 2 /* Keyword */, node: references[0].node }, references }] : void 0;
|
|
}
|
|
function getAllReferencesForKeyword(sourceFiles, keywordKind, cancellationToken, filter2) {
|
|
const references = flatMap(sourceFiles, (sourceFile) => {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, tokenToString(keywordKind), sourceFile), (referenceLocation) => {
|
|
if (referenceLocation.kind === keywordKind && (!filter2 || filter2(referenceLocation))) {
|
|
return nodeEntry(referenceLocation);
|
|
}
|
|
});
|
|
});
|
|
return references.length ? [{ definition: { type: 2 /* Keyword */, node: references[0].node }, references }] : void 0;
|
|
}
|
|
function getReferencesInSourceFile(sourceFile, search, state, addReferencesHere = true) {
|
|
state.cancellationToken.throwIfCancellationRequested();
|
|
return getReferencesInContainer(sourceFile, sourceFile, search, state, addReferencesHere);
|
|
}
|
|
function getReferencesInContainer(container, sourceFile, search, state, addReferencesHere) {
|
|
if (!state.markSearchedSymbols(sourceFile, search.allSearchSymbols)) {
|
|
return;
|
|
}
|
|
for (const position of getPossibleSymbolReferencePositions(sourceFile, search.text, container)) {
|
|
getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere);
|
|
}
|
|
}
|
|
function hasMatchingMeaning(referenceLocation, state) {
|
|
return !!(getMeaningFromLocation(referenceLocation) & state.searchMeaning);
|
|
}
|
|
function getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere) {
|
|
const referenceLocation = getTouchingPropertyName(sourceFile, position);
|
|
if (!isValidReferencePosition(referenceLocation, search.text)) {
|
|
if (!state.options.implementations && (state.options.findInStrings && isInString(sourceFile, position) || state.options.findInComments && isInNonReferenceComment(sourceFile, position))) {
|
|
state.addStringOrCommentReference(sourceFile.fileName, createTextSpan(position, search.text.length));
|
|
}
|
|
return;
|
|
}
|
|
if (!hasMatchingMeaning(referenceLocation, state))
|
|
return;
|
|
let referenceSymbol = state.checker.getSymbolAtLocation(referenceLocation);
|
|
if (!referenceSymbol) {
|
|
return;
|
|
}
|
|
const parent2 = referenceLocation.parent;
|
|
if (isImportSpecifier(parent2) && parent2.propertyName === referenceLocation) {
|
|
return;
|
|
}
|
|
if (isExportSpecifier(parent2)) {
|
|
Debug.assert(referenceLocation.kind === 79 /* Identifier */);
|
|
getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, parent2, search, state, addReferencesHere);
|
|
return;
|
|
}
|
|
const relatedSymbol = getRelatedSymbol(search, referenceSymbol, referenceLocation, state);
|
|
if (!relatedSymbol) {
|
|
getReferenceForShorthandProperty(referenceSymbol, search, state);
|
|
return;
|
|
}
|
|
switch (state.specialSearchKind) {
|
|
case 0 /* None */:
|
|
if (addReferencesHere)
|
|
addReference(referenceLocation, relatedSymbol, state);
|
|
break;
|
|
case 1 /* Constructor */:
|
|
addConstructorReferences(referenceLocation, sourceFile, search, state);
|
|
break;
|
|
case 2 /* Class */:
|
|
addClassStaticThisReferences(referenceLocation, search, state);
|
|
break;
|
|
default:
|
|
Debug.assertNever(state.specialSearchKind);
|
|
}
|
|
if (isInJSFile(referenceLocation) && referenceLocation.parent.kind === 205 /* BindingElement */ && isVariableDeclarationInitializedToBareOrAccessedRequire(referenceLocation.parent.parent.parent)) {
|
|
referenceSymbol = referenceLocation.parent.symbol;
|
|
if (!referenceSymbol)
|
|
return;
|
|
}
|
|
getImportOrExportReferences(referenceLocation, referenceSymbol, search, state);
|
|
}
|
|
function getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, search, state, addReferencesHere, alwaysGetReferences) {
|
|
Debug.assert(!alwaysGetReferences || !!state.options.providePrefixAndSuffixTextForRename, "If alwaysGetReferences is true, then prefix/suffix text must be enabled");
|
|
const { parent: parent2, propertyName, name } = exportSpecifier;
|
|
const exportDeclaration = parent2.parent;
|
|
const localSymbol = getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker);
|
|
if (!alwaysGetReferences && !search.includes(localSymbol)) {
|
|
return;
|
|
}
|
|
if (!propertyName) {
|
|
if (!(state.options.use === 2 /* Rename */ && name.escapedText === "default" /* Default */)) {
|
|
addRef();
|
|
}
|
|
} else if (referenceLocation === propertyName) {
|
|
if (!exportDeclaration.moduleSpecifier) {
|
|
addRef();
|
|
}
|
|
if (addReferencesHere && state.options.use !== 2 /* Rename */ && state.markSeenReExportRHS(name)) {
|
|
addReference(name, Debug.checkDefined(exportSpecifier.symbol), state);
|
|
}
|
|
} else {
|
|
if (state.markSeenReExportRHS(referenceLocation)) {
|
|
addRef();
|
|
}
|
|
}
|
|
if (!isForRenameWithPrefixAndSuffixText(state.options) || alwaysGetReferences) {
|
|
const isDefaultExport = referenceLocation.originalKeywordKind === 88 /* DefaultKeyword */ || exportSpecifier.name.originalKeywordKind === 88 /* DefaultKeyword */;
|
|
const exportKind = isDefaultExport ? 1 /* Default */ : 0 /* Named */;
|
|
const exportSymbol = Debug.checkDefined(exportSpecifier.symbol);
|
|
const exportInfo = getExportInfo(exportSymbol, exportKind, state.checker);
|
|
if (exportInfo) {
|
|
searchForImportsOfExport(referenceLocation, exportSymbol, exportInfo, state);
|
|
}
|
|
}
|
|
if (search.comingFrom !== 1 /* Export */ && exportDeclaration.moduleSpecifier && !propertyName && !isForRenameWithPrefixAndSuffixText(state.options)) {
|
|
const imported = state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier);
|
|
if (imported)
|
|
searchForImportedSymbol(imported, state);
|
|
}
|
|
function addRef() {
|
|
if (addReferencesHere)
|
|
addReference(referenceLocation, localSymbol, state);
|
|
}
|
|
}
|
|
function getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, checker) {
|
|
return isExportSpecifierAlias(referenceLocation, exportSpecifier) && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) || referenceSymbol;
|
|
}
|
|
function isExportSpecifierAlias(referenceLocation, exportSpecifier) {
|
|
const { parent: parent2, propertyName, name } = exportSpecifier;
|
|
Debug.assert(propertyName === referenceLocation || name === referenceLocation);
|
|
if (propertyName) {
|
|
return propertyName === referenceLocation;
|
|
} else {
|
|
return !parent2.parent.moduleSpecifier;
|
|
}
|
|
}
|
|
function getImportOrExportReferences(referenceLocation, referenceSymbol, search, state) {
|
|
const importOrExport = getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom === 1 /* Export */);
|
|
if (!importOrExport)
|
|
return;
|
|
const { symbol } = importOrExport;
|
|
if (importOrExport.kind === 0 /* Import */) {
|
|
if (!isForRenameWithPrefixAndSuffixText(state.options)) {
|
|
searchForImportedSymbol(symbol, state);
|
|
}
|
|
} else {
|
|
searchForImportsOfExport(referenceLocation, symbol, importOrExport.exportInfo, state);
|
|
}
|
|
}
|
|
function getReferenceForShorthandProperty({ flags, valueDeclaration }, search, state) {
|
|
const shorthandValueSymbol = state.checker.getShorthandAssignmentValueSymbol(valueDeclaration);
|
|
const name = valueDeclaration && getNameOfDeclaration(valueDeclaration);
|
|
if (!(flags & 33554432 /* Transient */) && name && search.includes(shorthandValueSymbol)) {
|
|
addReference(name, shorthandValueSymbol, state);
|
|
}
|
|
}
|
|
function addReference(referenceLocation, relatedSymbol, state) {
|
|
const { kind, symbol } = "kind" in relatedSymbol ? relatedSymbol : { kind: void 0, symbol: relatedSymbol };
|
|
if (state.options.use === 2 /* Rename */ && referenceLocation.kind === 88 /* DefaultKeyword */) {
|
|
return;
|
|
}
|
|
const addRef = state.referenceAdder(symbol);
|
|
if (state.options.implementations) {
|
|
addImplementationReferences(referenceLocation, addRef, state);
|
|
} else {
|
|
addRef(referenceLocation, kind);
|
|
}
|
|
}
|
|
function addConstructorReferences(referenceLocation, sourceFile, search, state) {
|
|
if (isNewExpressionTarget(referenceLocation)) {
|
|
addReference(referenceLocation, search.symbol, state);
|
|
}
|
|
const pusher = () => state.referenceAdder(search.symbol);
|
|
if (isClassLike(referenceLocation.parent)) {
|
|
Debug.assert(referenceLocation.kind === 88 /* DefaultKeyword */ || referenceLocation.parent.name === referenceLocation);
|
|
findOwnConstructorReferences(search.symbol, sourceFile, pusher());
|
|
} else {
|
|
const classExtending = tryGetClassByExtendingIdentifier(referenceLocation);
|
|
if (classExtending) {
|
|
findSuperConstructorAccesses(classExtending, pusher());
|
|
findInheritedConstructorReferences(classExtending, state);
|
|
}
|
|
}
|
|
}
|
|
function addClassStaticThisReferences(referenceLocation, search, state) {
|
|
addReference(referenceLocation, search.symbol, state);
|
|
const classLike = referenceLocation.parent;
|
|
if (state.options.use === 2 /* Rename */ || !isClassLike(classLike))
|
|
return;
|
|
Debug.assert(classLike.name === referenceLocation);
|
|
const addRef = state.referenceAdder(search.symbol);
|
|
for (const member of classLike.members) {
|
|
if (!(isMethodOrAccessor(member) && isStatic(member))) {
|
|
continue;
|
|
}
|
|
if (member.body) {
|
|
member.body.forEachChild(function cb(node) {
|
|
if (node.kind === 108 /* ThisKeyword */) {
|
|
addRef(node);
|
|
} else if (!isFunctionLike(node) && !isClassLike(node)) {
|
|
node.forEachChild(cb);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function findOwnConstructorReferences(classSymbol, sourceFile, addNode) {
|
|
const constructorSymbol = getClassConstructorSymbol(classSymbol);
|
|
if (constructorSymbol && constructorSymbol.declarations) {
|
|
for (const decl of constructorSymbol.declarations) {
|
|
const ctrKeyword = findChildOfKind(decl, 135 /* ConstructorKeyword */, sourceFile);
|
|
Debug.assert(decl.kind === 173 /* Constructor */ && !!ctrKeyword);
|
|
addNode(ctrKeyword);
|
|
}
|
|
}
|
|
if (classSymbol.exports) {
|
|
classSymbol.exports.forEach((member) => {
|
|
const decl = member.valueDeclaration;
|
|
if (decl && decl.kind === 171 /* MethodDeclaration */) {
|
|
const body = decl.body;
|
|
if (body) {
|
|
forEachDescendantOfKind(body, 108 /* ThisKeyword */, (thisKeyword) => {
|
|
if (isNewExpressionTarget(thisKeyword)) {
|
|
addNode(thisKeyword);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function getClassConstructorSymbol(classSymbol) {
|
|
return classSymbol.members && classSymbol.members.get("__constructor" /* Constructor */);
|
|
}
|
|
function findSuperConstructorAccesses(classDeclaration, addNode) {
|
|
const constructor = getClassConstructorSymbol(classDeclaration.symbol);
|
|
if (!(constructor && constructor.declarations)) {
|
|
return;
|
|
}
|
|
for (const decl of constructor.declarations) {
|
|
Debug.assert(decl.kind === 173 /* Constructor */);
|
|
const body = decl.body;
|
|
if (body) {
|
|
forEachDescendantOfKind(body, 106 /* SuperKeyword */, (node) => {
|
|
if (isCallExpressionTarget(node)) {
|
|
addNode(node);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function hasOwnConstructor(classDeclaration) {
|
|
return !!getClassConstructorSymbol(classDeclaration.symbol);
|
|
}
|
|
function findInheritedConstructorReferences(classDeclaration, state) {
|
|
if (hasOwnConstructor(classDeclaration))
|
|
return;
|
|
const classSymbol = classDeclaration.symbol;
|
|
const search = state.createSearch(void 0, classSymbol, void 0);
|
|
getReferencesInContainerOrFiles(classSymbol, state, search);
|
|
}
|
|
function addImplementationReferences(refNode, addReference2, state) {
|
|
if (isDeclarationName(refNode) && isImplementation(refNode.parent)) {
|
|
addReference2(refNode);
|
|
return;
|
|
}
|
|
if (refNode.kind !== 79 /* Identifier */) {
|
|
return;
|
|
}
|
|
if (refNode.parent.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference2);
|
|
}
|
|
const containingClass = getContainingClassIfInHeritageClause(refNode);
|
|
if (containingClass) {
|
|
addReference2(containingClass);
|
|
return;
|
|
}
|
|
const typeNode = findAncestor(refNode, (a) => !isQualifiedName(a.parent) && !isTypeNode(a.parent) && !isTypeElement(a.parent));
|
|
const typeHavingNode = typeNode.parent;
|
|
if (hasType(typeHavingNode) && typeHavingNode.type === typeNode && state.markSeenContainingTypeReference(typeHavingNode)) {
|
|
if (hasInitializer(typeHavingNode)) {
|
|
addIfImplementation(typeHavingNode.initializer);
|
|
} else if (isFunctionLike(typeHavingNode) && typeHavingNode.body) {
|
|
const body = typeHavingNode.body;
|
|
if (body.kind === 238 /* Block */) {
|
|
forEachReturnStatement(body, (returnStatement) => {
|
|
if (returnStatement.expression)
|
|
addIfImplementation(returnStatement.expression);
|
|
});
|
|
} else {
|
|
addIfImplementation(body);
|
|
}
|
|
} else if (isAssertionExpression(typeHavingNode)) {
|
|
addIfImplementation(typeHavingNode.expression);
|
|
}
|
|
}
|
|
function addIfImplementation(e) {
|
|
if (isImplementationExpression(e))
|
|
addReference2(e);
|
|
}
|
|
}
|
|
function getContainingClassIfInHeritageClause(node) {
|
|
return isIdentifier(node) || isPropertyAccessExpression(node) ? getContainingClassIfInHeritageClause(node.parent) : isExpressionWithTypeArguments(node) ? tryCast(node.parent.parent, isClassLike) : void 0;
|
|
}
|
|
function isImplementationExpression(node) {
|
|
switch (node.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
return isImplementationExpression(node.expression);
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function explicitlyInheritsFrom(symbol, parent2, cachedResults, checker) {
|
|
if (symbol === parent2) {
|
|
return true;
|
|
}
|
|
const key = getSymbolId(symbol) + "," + getSymbolId(parent2);
|
|
const cached = cachedResults.get(key);
|
|
if (cached !== void 0) {
|
|
return cached;
|
|
}
|
|
cachedResults.set(key, false);
|
|
const inherits = !!symbol.declarations && symbol.declarations.some((declaration) => getAllSuperTypeNodes(declaration).some((typeReference) => {
|
|
const type = checker.getTypeAtLocation(typeReference);
|
|
return !!type && !!type.symbol && explicitlyInheritsFrom(type.symbol, parent2, cachedResults, checker);
|
|
}));
|
|
cachedResults.set(key, inherits);
|
|
return inherits;
|
|
}
|
|
function getReferencesForSuperKeyword(superKeyword) {
|
|
let searchSpaceNode = getSuperContainer(superKeyword, false);
|
|
if (!searchSpaceNode) {
|
|
return void 0;
|
|
}
|
|
let staticFlag = 32 /* Static */;
|
|
switch (searchSpaceNode.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
staticFlag &= getSyntacticModifierFlags(searchSpaceNode);
|
|
searchSpaceNode = searchSpaceNode.parent;
|
|
break;
|
|
default:
|
|
return void 0;
|
|
}
|
|
const sourceFile = searchSpaceNode.getSourceFile();
|
|
const references = mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "super", searchSpaceNode), (node) => {
|
|
if (node.kind !== 106 /* SuperKeyword */) {
|
|
return;
|
|
}
|
|
const container = getSuperContainer(node, false);
|
|
return container && isStatic(container) === !!staticFlag && container.parent.symbol === searchSpaceNode.symbol ? nodeEntry(node) : void 0;
|
|
});
|
|
return [{ definition: { type: 0 /* Symbol */, symbol: searchSpaceNode.symbol }, references }];
|
|
}
|
|
function isParameterName(node) {
|
|
return node.kind === 79 /* Identifier */ && node.parent.kind === 166 /* Parameter */ && node.parent.name === node;
|
|
}
|
|
function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles, cancellationToken) {
|
|
let searchSpaceNode = getThisContainer(thisOrSuperKeyword, false);
|
|
let staticFlag = 32 /* Static */;
|
|
switch (searchSpaceNode.kind) {
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
if (isObjectLiteralMethod(searchSpaceNode)) {
|
|
staticFlag &= getSyntacticModifierFlags(searchSpaceNode);
|
|
searchSpaceNode = searchSpaceNode.parent;
|
|
break;
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
staticFlag &= getSyntacticModifierFlags(searchSpaceNode);
|
|
searchSpaceNode = searchSpaceNode.parent;
|
|
break;
|
|
case 308 /* SourceFile */:
|
|
if (isExternalModule(searchSpaceNode) || isParameterName(thisOrSuperKeyword)) {
|
|
return void 0;
|
|
}
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
break;
|
|
default:
|
|
return void 0;
|
|
}
|
|
const references = flatMap(searchSpaceNode.kind === 308 /* SourceFile */ ? sourceFiles : [searchSpaceNode.getSourceFile()], (sourceFile) => {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
return getPossibleSymbolReferenceNodes(sourceFile, "this", isSourceFile(searchSpaceNode) ? sourceFile : searchSpaceNode).filter((node) => {
|
|
if (!isThis(node)) {
|
|
return false;
|
|
}
|
|
const container = getThisContainer(node, false);
|
|
switch (searchSpaceNode.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return searchSpaceNode.symbol === container.symbol;
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
return isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol;
|
|
case 228 /* ClassExpression */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return container.parent && searchSpaceNode.symbol === container.parent.symbol && isStatic(container) === !!staticFlag;
|
|
case 308 /* SourceFile */:
|
|
return container.kind === 308 /* SourceFile */ && !isExternalModule(container) && !isParameterName(node);
|
|
}
|
|
});
|
|
}).map((n) => nodeEntry(n));
|
|
const thisParameter = firstDefined(references, (r) => isParameter(r.node.parent) ? r.node : void 0);
|
|
return [{
|
|
definition: { type: 3 /* This */, node: thisParameter || thisOrSuperKeyword },
|
|
references
|
|
}];
|
|
}
|
|
function getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken) {
|
|
const type = getContextualTypeFromParentOrAncestorTypeNode(node, checker);
|
|
const references = flatMap(sourceFiles, (sourceFile) => {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
return mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), (ref) => {
|
|
if (isStringLiteralLike(ref) && ref.text === node.text) {
|
|
if (type) {
|
|
const refType = getContextualTypeFromParentOrAncestorTypeNode(ref, checker);
|
|
if (type !== checker.getStringType() && type === refType) {
|
|
return nodeEntry(ref, 2 /* StringLiteral */);
|
|
}
|
|
} else {
|
|
return isNoSubstitutionTemplateLiteral(ref) && !rangeIsOnSingleLine(ref, sourceFile) ? void 0 : nodeEntry(ref, 2 /* StringLiteral */);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
return [{
|
|
definition: { type: 4 /* String */, node },
|
|
references
|
|
}];
|
|
}
|
|
function populateSearchSymbolSet(symbol, location2, checker, isForRename, providePrefixAndSuffixText, implementations) {
|
|
const result = [];
|
|
forEachRelatedSymbol(
|
|
symbol,
|
|
location2,
|
|
checker,
|
|
isForRename,
|
|
!(isForRename && providePrefixAndSuffixText),
|
|
(sym, root, base) => {
|
|
if (base) {
|
|
if (isStaticSymbol(symbol) !== isStaticSymbol(base)) {
|
|
base = void 0;
|
|
}
|
|
}
|
|
result.push(base || root || sym);
|
|
},
|
|
() => !implementations
|
|
);
|
|
return result;
|
|
}
|
|
function forEachRelatedSymbol(symbol, location2, checker, isForRenamePopulateSearchSymbolSet, onlyIncludeBindingElementAtReferenceLocation, cbSymbol, allowBaseTypes) {
|
|
const containingObjectLiteralElement = getContainingObjectLiteralElement(location2);
|
|
if (containingObjectLiteralElement) {
|
|
const shorthandValueSymbol = checker.getShorthandAssignmentValueSymbol(location2.parent);
|
|
if (shorthandValueSymbol && isForRenamePopulateSearchSymbolSet) {
|
|
return cbSymbol(shorthandValueSymbol, void 0, void 0, 3 /* SearchedLocalFoundProperty */);
|
|
}
|
|
const contextualType = checker.getContextualType(containingObjectLiteralElement.parent);
|
|
const res2 = contextualType && firstDefined(
|
|
getPropertySymbolsFromContextualType(containingObjectLiteralElement, checker, contextualType, true),
|
|
(sym) => fromRoot(sym, 4 /* SearchedPropertyFoundLocal */)
|
|
);
|
|
if (res2)
|
|
return res2;
|
|
const propertySymbol = getPropertySymbolOfDestructuringAssignment(location2, checker);
|
|
const res1 = propertySymbol && cbSymbol(propertySymbol, void 0, void 0, 4 /* SearchedPropertyFoundLocal */);
|
|
if (res1)
|
|
return res1;
|
|
const res22 = shorthandValueSymbol && cbSymbol(shorthandValueSymbol, void 0, void 0, 3 /* SearchedLocalFoundProperty */);
|
|
if (res22)
|
|
return res22;
|
|
}
|
|
const aliasedSymbol = getMergedAliasedSymbolOfNamespaceExportDeclaration(location2, symbol, checker);
|
|
if (aliasedSymbol) {
|
|
const res2 = cbSymbol(aliasedSymbol, void 0, void 0, 1 /* Node */);
|
|
if (res2)
|
|
return res2;
|
|
}
|
|
const res = fromRoot(symbol);
|
|
if (res)
|
|
return res;
|
|
if (symbol.valueDeclaration && isParameterPropertyDeclaration(symbol.valueDeclaration, symbol.valueDeclaration.parent)) {
|
|
const paramProps = checker.getSymbolsOfParameterPropertyDeclaration(cast(symbol.valueDeclaration, isParameter), symbol.name);
|
|
Debug.assert(paramProps.length === 2 && !!(paramProps[0].flags & 1 /* FunctionScopedVariable */) && !!(paramProps[1].flags & 4 /* Property */));
|
|
return fromRoot(symbol.flags & 1 /* FunctionScopedVariable */ ? paramProps[1] : paramProps[0]);
|
|
}
|
|
const exportSpecifier = getDeclarationOfKind(symbol, 278 /* ExportSpecifier */);
|
|
if (!isForRenamePopulateSearchSymbolSet || exportSpecifier && !exportSpecifier.propertyName) {
|
|
const localSymbol = exportSpecifier && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier);
|
|
if (localSymbol) {
|
|
const res2 = cbSymbol(localSymbol, void 0, void 0, 1 /* Node */);
|
|
if (res2)
|
|
return res2;
|
|
}
|
|
}
|
|
if (!isForRenamePopulateSearchSymbolSet) {
|
|
let bindingElementPropertySymbol;
|
|
if (onlyIncludeBindingElementAtReferenceLocation) {
|
|
bindingElementPropertySymbol = isObjectBindingElementWithoutPropertyName(location2.parent) ? getPropertySymbolFromBindingElement(checker, location2.parent) : void 0;
|
|
} else {
|
|
bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker);
|
|
}
|
|
return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* SearchedPropertyFoundLocal */);
|
|
}
|
|
Debug.assert(isForRenamePopulateSearchSymbolSet);
|
|
const includeOriginalSymbolOfBindingElement = onlyIncludeBindingElementAtReferenceLocation;
|
|
if (includeOriginalSymbolOfBindingElement) {
|
|
const bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker);
|
|
return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* SearchedPropertyFoundLocal */);
|
|
}
|
|
function fromRoot(sym, kind) {
|
|
return firstDefined(checker.getRootSymbols(sym), (rootSymbol) => cbSymbol(sym, rootSymbol, void 0, kind) || (rootSymbol.parent && rootSymbol.parent.flags & (32 /* Class */ | 64 /* Interface */) && allowBaseTypes(rootSymbol) ? getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, checker, (base) => cbSymbol(sym, rootSymbol, base, kind)) : void 0));
|
|
}
|
|
function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol2, checker2) {
|
|
const bindingElement = getDeclarationOfKind(symbol2, 205 /* BindingElement */);
|
|
if (bindingElement && isObjectBindingElementWithoutPropertyName(bindingElement)) {
|
|
return getPropertySymbolFromBindingElement(checker2, bindingElement);
|
|
}
|
|
}
|
|
}
|
|
function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) {
|
|
const seen = /* @__PURE__ */ new Map();
|
|
return recur(symbol);
|
|
function recur(symbol2) {
|
|
if (!(symbol2.flags & (32 /* Class */ | 64 /* Interface */)) || !addToSeen(seen, getSymbolId(symbol2)))
|
|
return;
|
|
return firstDefined(symbol2.declarations, (declaration) => firstDefined(getAllSuperTypeNodes(declaration), (typeReference) => {
|
|
const type = checker.getTypeAtLocation(typeReference);
|
|
const propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName);
|
|
return type && propertySymbol && (firstDefined(checker.getRootSymbols(propertySymbol), cb) || recur(type.symbol));
|
|
}));
|
|
}
|
|
}
|
|
function isStaticSymbol(symbol) {
|
|
if (!symbol.valueDeclaration)
|
|
return false;
|
|
const modifierFlags = getEffectiveModifierFlags(symbol.valueDeclaration);
|
|
return !!(modifierFlags & 32 /* Static */);
|
|
}
|
|
function getRelatedSymbol(search, referenceSymbol, referenceLocation, state) {
|
|
const { checker } = state;
|
|
return forEachRelatedSymbol(
|
|
referenceSymbol,
|
|
referenceLocation,
|
|
checker,
|
|
false,
|
|
state.options.use !== 2 /* Rename */ || !!state.options.providePrefixAndSuffixTextForRename,
|
|
(sym, rootSymbol, baseSymbol, kind) => {
|
|
if (baseSymbol) {
|
|
if (isStaticSymbol(referenceSymbol) !== isStaticSymbol(baseSymbol)) {
|
|
baseSymbol = void 0;
|
|
}
|
|
}
|
|
return search.includes(baseSymbol || rootSymbol || sym) ? { symbol: rootSymbol && !(getCheckFlags(sym) & 6 /* Synthetic */) ? rootSymbol : sym, kind } : void 0;
|
|
},
|
|
(rootSymbol) => !(search.parents && !search.parents.some((parent2) => explicitlyInheritsFrom(rootSymbol.parent, parent2, state.inheritsFromCache, checker)))
|
|
);
|
|
}
|
|
function getIntersectingMeaningFromDeclarations(node, symbol) {
|
|
let meaning = getMeaningFromLocation(node);
|
|
const { declarations } = symbol;
|
|
if (declarations) {
|
|
let lastIterationMeaning;
|
|
do {
|
|
lastIterationMeaning = meaning;
|
|
for (const declaration of declarations) {
|
|
const declarationMeaning = getMeaningFromDeclaration(declaration);
|
|
if (declarationMeaning & meaning) {
|
|
meaning |= declarationMeaning;
|
|
}
|
|
}
|
|
} while (meaning !== lastIterationMeaning);
|
|
}
|
|
return meaning;
|
|
}
|
|
Core2.getIntersectingMeaningFromDeclarations = getIntersectingMeaningFromDeclarations;
|
|
function isImplementation(node) {
|
|
return !!(node.flags & 16777216 /* Ambient */) ? !(isInterfaceDeclaration(node) || isTypeAliasDeclaration(node)) : isVariableLike(node) ? hasInitializer(node) : isFunctionLikeDeclaration(node) ? !!node.body : isClassLike(node) || isModuleOrEnumDeclaration(node);
|
|
}
|
|
function getReferenceEntriesForShorthandPropertyAssignment(node, checker, addReference2) {
|
|
const refSymbol = checker.getSymbolAtLocation(node);
|
|
const shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration);
|
|
if (shorthandSymbol) {
|
|
for (const declaration of shorthandSymbol.getDeclarations()) {
|
|
if (getMeaningFromDeclaration(declaration) & 1 /* Value */) {
|
|
addReference2(declaration);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Core2.getReferenceEntriesForShorthandPropertyAssignment = getReferenceEntriesForShorthandPropertyAssignment;
|
|
function forEachDescendantOfKind(node, kind, action) {
|
|
forEachChild(node, (child) => {
|
|
if (child.kind === kind) {
|
|
action(child);
|
|
}
|
|
forEachDescendantOfKind(child, kind, action);
|
|
});
|
|
}
|
|
function tryGetClassByExtendingIdentifier(node) {
|
|
return tryGetClassExtendingExpressionWithTypeArguments(climbPastPropertyAccess(node).parent);
|
|
}
|
|
function getParentSymbolsOfPropertyAccess(location2, symbol, checker) {
|
|
const propertyAccessExpression = isRightSideOfPropertyAccess(location2) ? location2.parent : void 0;
|
|
const lhsType = propertyAccessExpression && checker.getTypeAtLocation(propertyAccessExpression.expression);
|
|
const res = mapDefined(lhsType && (lhsType.isUnionOrIntersection() ? lhsType.types : lhsType.symbol === symbol.parent ? void 0 : [lhsType]), (t) => t.symbol && t.symbol.flags & (32 /* Class */ | 64 /* Interface */) ? t.symbol : void 0);
|
|
return res.length === 0 ? void 0 : res;
|
|
}
|
|
function isForRenameWithPrefixAndSuffixText(options) {
|
|
return options.use === 2 /* Rename */ && options.providePrefixAndSuffixTextForRename;
|
|
}
|
|
})(Core || (Core = {}));
|
|
|
|
// src/services/_namespaces/ts.GoToDefinition.ts
|
|
var ts_GoToDefinition_exports = {};
|
|
__export(ts_GoToDefinition_exports, {
|
|
createDefinitionInfo: () => createDefinitionInfo,
|
|
findReferenceInPosition: () => findReferenceInPosition,
|
|
getDefinitionAndBoundSpan: () => getDefinitionAndBoundSpan,
|
|
getDefinitionAtPosition: () => getDefinitionAtPosition,
|
|
getReferenceAtPosition: () => getReferenceAtPosition,
|
|
getTypeDefinitionAtPosition: () => getTypeDefinitionAtPosition
|
|
});
|
|
|
|
// src/services/goToDefinition.ts
|
|
function getDefinitionAtPosition(program, sourceFile, position, searchOtherFilesOnly, stopAtAlias) {
|
|
var _a2;
|
|
const resolvedRef = getReferenceAtPosition(sourceFile, position, program);
|
|
const fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || emptyArray;
|
|
if (resolvedRef == null ? void 0 : resolvedRef.file) {
|
|
return fileReferenceDefinition;
|
|
}
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
if (node === sourceFile) {
|
|
return void 0;
|
|
}
|
|
const { parent: parent2 } = node;
|
|
const typeChecker = program.getTypeChecker();
|
|
if (node.kind === 161 /* OverrideKeyword */ || isIdentifier(node) && isJSDocOverrideTag(parent2) && parent2.tagName === node) {
|
|
return getDefinitionFromOverriddenMember(typeChecker, node) || emptyArray;
|
|
}
|
|
if (isJumpStatementTarget(node)) {
|
|
const label = getTargetLabel(node.parent, node.text);
|
|
return label ? [createDefinitionInfoFromName(typeChecker, label, "label" /* label */, node.text, void 0)] : void 0;
|
|
}
|
|
if (node.kind === 105 /* ReturnKeyword */) {
|
|
const functionDeclaration = findAncestor(node.parent, (n) => isClassStaticBlockDeclaration(n) ? "quit" : isFunctionLikeDeclaration(n));
|
|
return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
|
|
}
|
|
if (isStaticModifier(node) && isClassStaticBlockDeclaration(node.parent)) {
|
|
const classDecl = node.parent.parent;
|
|
const { symbol: symbol2, failedAliasResolution: failedAliasResolution2 } = getSymbol(classDecl, typeChecker, stopAtAlias);
|
|
const staticBlocks = filter(classDecl.members, isClassStaticBlockDeclaration);
|
|
const containerName = symbol2 ? typeChecker.symbolToString(symbol2, classDecl) : "";
|
|
const sourceFile2 = node.getSourceFile();
|
|
return map(staticBlocks, (staticBlock) => {
|
|
let { pos } = moveRangePastModifiers(staticBlock);
|
|
pos = skipTrivia(sourceFile2.text, pos);
|
|
return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* constructorImplementationElement */, "static {}", containerName, false, failedAliasResolution2, { start: pos, length: "static".length });
|
|
});
|
|
}
|
|
let { symbol, failedAliasResolution } = getSymbol(node, typeChecker, stopAtAlias);
|
|
let fallbackNode = node;
|
|
if (searchOtherFilesOnly && failedAliasResolution) {
|
|
const importDeclaration = forEach([node, ...(symbol == null ? void 0 : symbol.declarations) || emptyArray], (n) => findAncestor(n, isAnyImportOrBareOrAccessedRequire));
|
|
const moduleSpecifier = importDeclaration && tryGetModuleSpecifierFromDeclaration(importDeclaration);
|
|
if (moduleSpecifier) {
|
|
({ symbol, failedAliasResolution } = getSymbol(moduleSpecifier, typeChecker, stopAtAlias));
|
|
fallbackNode = moduleSpecifier;
|
|
}
|
|
}
|
|
if (!symbol && isModuleSpecifierLike(fallbackNode)) {
|
|
const ref = (_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.get(fallbackNode.text, getModeForUsageLocation(sourceFile, fallbackNode));
|
|
if (ref) {
|
|
return [{
|
|
name: fallbackNode.text,
|
|
fileName: ref.resolvedFileName,
|
|
containerName: void 0,
|
|
containerKind: void 0,
|
|
kind: "script" /* scriptElement */,
|
|
textSpan: createTextSpan(0, 0),
|
|
failedAliasResolution,
|
|
isAmbient: isDeclarationFileName(ref.resolvedFileName),
|
|
unverified: fallbackNode !== node
|
|
}];
|
|
}
|
|
}
|
|
if (!symbol) {
|
|
return concatenate(fileReferenceDefinition, getDefinitionInfoForIndexSignatures(node, typeChecker));
|
|
}
|
|
if (searchOtherFilesOnly && every(symbol.declarations, (d) => d.getSourceFile().fileName === sourceFile.fileName))
|
|
return void 0;
|
|
const calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
|
|
if (calledDeclaration && !(isJsxOpeningLikeElement(node.parent) && isConstructorLike(calledDeclaration))) {
|
|
const sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration, failedAliasResolution);
|
|
if (typeChecker.getRootSymbols(symbol).some((s) => symbolMatchesSignature(s, calledDeclaration))) {
|
|
return [sigInfo];
|
|
} else {
|
|
const defs = getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, calledDeclaration) || emptyArray;
|
|
return node.kind === 106 /* SuperKeyword */ ? [sigInfo, ...defs] : [...defs, sigInfo];
|
|
}
|
|
}
|
|
if (node.parent.kind === 300 /* ShorthandPropertyAssignment */) {
|
|
const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
|
|
const definitions = (shorthandSymbol == null ? void 0 : shorthandSymbol.declarations) ? shorthandSymbol.declarations.map((decl) => createDefinitionInfo(decl, typeChecker, shorthandSymbol, node, false, failedAliasResolution)) : emptyArray;
|
|
return concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node) || emptyArray);
|
|
}
|
|
if (isPropertyName(node) && isBindingElement(parent2) && isObjectBindingPattern(parent2.parent) && node === (parent2.propertyName || parent2.name)) {
|
|
const name = getNameFromPropertyName(node);
|
|
const type = typeChecker.getTypeAtLocation(parent2.parent);
|
|
return name === void 0 ? emptyArray : flatMap(type.isUnion() ? type.types : [type], (t) => {
|
|
const prop = t.getProperty(name);
|
|
return prop && getDefinitionFromSymbol(typeChecker, prop, node);
|
|
});
|
|
}
|
|
return concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution));
|
|
}
|
|
function symbolMatchesSignature(s, calledDeclaration) {
|
|
return s === calledDeclaration.symbol || s === calledDeclaration.symbol.parent || isAssignmentExpression(calledDeclaration.parent) || !isCallLikeExpression(calledDeclaration.parent) && s === calledDeclaration.parent.symbol;
|
|
}
|
|
function getDefinitionFromObjectLiteralElement(typeChecker, node) {
|
|
const element = getContainingObjectLiteralElement(node);
|
|
if (element) {
|
|
const contextualType = element && typeChecker.getContextualType(element.parent);
|
|
if (contextualType) {
|
|
return flatMap(getPropertySymbolsFromContextualType(element, typeChecker, contextualType, false), (propertySymbol) => getDefinitionFromSymbol(typeChecker, propertySymbol, node));
|
|
}
|
|
}
|
|
}
|
|
function getDefinitionFromOverriddenMember(typeChecker, node) {
|
|
const classElement = findAncestor(node, isClassElement);
|
|
if (!(classElement && classElement.name))
|
|
return;
|
|
const baseDeclaration = findAncestor(classElement, isClassLike);
|
|
if (!baseDeclaration)
|
|
return;
|
|
const baseTypeNode = getEffectiveBaseTypeNode(baseDeclaration);
|
|
if (!baseTypeNode)
|
|
return;
|
|
const expression = skipParentheses(baseTypeNode.expression);
|
|
const base = isClassExpression(expression) ? expression.symbol : typeChecker.getSymbolAtLocation(expression);
|
|
if (!base)
|
|
return;
|
|
const name = unescapeLeadingUnderscores(getTextOfPropertyName(classElement.name));
|
|
const symbol = hasStaticModifier(classElement) ? typeChecker.getPropertyOfType(typeChecker.getTypeOfSymbol(base), name) : typeChecker.getPropertyOfType(typeChecker.getDeclaredTypeOfSymbol(base), name);
|
|
if (!symbol)
|
|
return;
|
|
return getDefinitionFromSymbol(typeChecker, symbol, node);
|
|
}
|
|
function getReferenceAtPosition(sourceFile, position, program) {
|
|
var _a2, _b;
|
|
const referencePath = findReferenceInPosition(sourceFile.referencedFiles, position);
|
|
if (referencePath) {
|
|
const file = program.getSourceFileFromReference(sourceFile, referencePath);
|
|
return file && { reference: referencePath, fileName: file.fileName, file, unverified: false };
|
|
}
|
|
const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
|
|
if (typeReferenceDirective) {
|
|
const reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat);
|
|
const file = reference && program.getSourceFile(reference.resolvedFileName);
|
|
return file && { reference: typeReferenceDirective, fileName: file.fileName, file, unverified: false };
|
|
}
|
|
const libReferenceDirective = findReferenceInPosition(sourceFile.libReferenceDirectives, position);
|
|
if (libReferenceDirective) {
|
|
const file = program.getLibFileFromReference(libReferenceDirective);
|
|
return file && { reference: libReferenceDirective, fileName: file.fileName, file, unverified: false };
|
|
}
|
|
if ((_a2 = sourceFile.resolvedModules) == null ? void 0 : _a2.size()) {
|
|
const node = getTouchingToken(sourceFile, position);
|
|
if (isModuleSpecifierLike(node) && isExternalModuleNameRelative(node.text) && sourceFile.resolvedModules.has(node.text, getModeForUsageLocation(sourceFile, node))) {
|
|
const verifiedFileName = (_b = sourceFile.resolvedModules.get(node.text, getModeForUsageLocation(sourceFile, node))) == null ? void 0 : _b.resolvedFileName;
|
|
const fileName = verifiedFileName || resolvePath(getDirectoryPath(sourceFile.fileName), node.text);
|
|
return {
|
|
file: program.getSourceFile(fileName),
|
|
fileName,
|
|
reference: {
|
|
pos: node.getStart(),
|
|
end: node.getEnd(),
|
|
fileName: node.text
|
|
},
|
|
unverified: !verifiedFileName
|
|
};
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
if (node === sourceFile) {
|
|
return void 0;
|
|
}
|
|
if (isImportMeta(node.parent) && node.parent.name === node) {
|
|
return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent, false);
|
|
}
|
|
const { symbol, failedAliasResolution } = getSymbol(node, typeChecker, false);
|
|
if (!symbol)
|
|
return void 0;
|
|
const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
|
|
const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
|
|
const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution);
|
|
const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution);
|
|
return typeDefinitions.length ? typeDefinitions : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
|
|
}
|
|
function definitionFromType(type, checker, node, failedAliasResolution) {
|
|
return flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], (t) => t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution));
|
|
}
|
|
function tryGetReturnTypeOfFunction(symbol, type, checker) {
|
|
if (type.symbol === symbol || symbol.valueDeclaration && type.symbol && isVariableDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.initializer === type.symbol.valueDeclaration) {
|
|
const sigs = type.getCallSignatures();
|
|
if (sigs.length === 1)
|
|
return checker.getReturnTypeOfSignature(first(sigs));
|
|
}
|
|
return void 0;
|
|
}
|
|
function getDefinitionAndBoundSpan(program, sourceFile, position) {
|
|
const definitions = getDefinitionAtPosition(program, sourceFile, position);
|
|
if (!definitions || definitions.length === 0) {
|
|
return void 0;
|
|
}
|
|
const comment = findReferenceInPosition(sourceFile.referencedFiles, position) || findReferenceInPosition(sourceFile.typeReferenceDirectives, position) || findReferenceInPosition(sourceFile.libReferenceDirectives, position);
|
|
if (comment) {
|
|
return { definitions, textSpan: createTextSpanFromRange(comment) };
|
|
}
|
|
const node = getTouchingPropertyName(sourceFile, position);
|
|
const textSpan = createTextSpan(node.getStart(), node.getWidth());
|
|
return { definitions, textSpan };
|
|
}
|
|
function getDefinitionInfoForIndexSignatures(node, checker) {
|
|
return mapDefined(checker.getIndexInfosAtLocation(node), (info) => info.declaration && createDefinitionFromSignatureDeclaration(checker, info.declaration));
|
|
}
|
|
function getSymbol(node, checker, stopAtAlias) {
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
let failedAliasResolution = false;
|
|
if ((symbol == null ? void 0 : symbol.declarations) && symbol.flags & 2097152 /* Alias */ && !stopAtAlias && shouldSkipAlias(node, symbol.declarations[0])) {
|
|
const aliased = checker.getAliasedSymbol(symbol);
|
|
if (aliased.declarations) {
|
|
return { symbol: aliased };
|
|
} else {
|
|
failedAliasResolution = true;
|
|
}
|
|
}
|
|
return { symbol, failedAliasResolution };
|
|
}
|
|
function shouldSkipAlias(node, declaration) {
|
|
if (node.kind !== 79 /* Identifier */) {
|
|
return false;
|
|
}
|
|
if (node.parent === declaration) {
|
|
return true;
|
|
}
|
|
if (declaration.kind === 271 /* NamespaceImport */) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function isExpandoDeclaration(node) {
|
|
if (!isAssignmentDeclaration(node))
|
|
return false;
|
|
const containingAssignment = findAncestor(node, (p) => {
|
|
if (isAssignmentExpression(p))
|
|
return true;
|
|
if (!isAssignmentDeclaration(p))
|
|
return "quit";
|
|
return false;
|
|
});
|
|
return !!containingAssignment && getAssignmentDeclarationKind(containingAssignment) === 5 /* Property */;
|
|
}
|
|
function getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, excludeDeclaration) {
|
|
const filteredDeclarations = filter(symbol.declarations, (d) => d !== excludeDeclaration);
|
|
const withoutExpandos = filter(filteredDeclarations, (d) => !isExpandoDeclaration(d));
|
|
const results = some(withoutExpandos) ? withoutExpandos : filteredDeclarations;
|
|
return getConstructSignatureDefinition() || getCallSignatureDefinition() || map(results, (declaration) => createDefinitionInfo(declaration, typeChecker, symbol, node, false, failedAliasResolution));
|
|
function getConstructSignatureDefinition() {
|
|
if (symbol.flags & 32 /* Class */ && !(symbol.flags & (16 /* Function */ | 3 /* Variable */)) && (isNewExpressionTarget(node) || node.kind === 135 /* ConstructorKeyword */)) {
|
|
const cls = find(filteredDeclarations, isClassLike) || Debug.fail("Expected declaration to have at least one class-like declaration");
|
|
return getSignatureDefinition(cls.members, true);
|
|
}
|
|
}
|
|
function getCallSignatureDefinition() {
|
|
return isCallOrNewExpressionTarget(node) || isNameOfFunctionDeclaration(node) ? getSignatureDefinition(filteredDeclarations, false) : void 0;
|
|
}
|
|
function getSignatureDefinition(signatureDeclarations, selectConstructors) {
|
|
if (!signatureDeclarations) {
|
|
return void 0;
|
|
}
|
|
const declarations = signatureDeclarations.filter(selectConstructors ? isConstructorDeclaration : isFunctionLike);
|
|
const declarationsWithBody = declarations.filter((d) => !!d.body);
|
|
return declarations.length ? declarationsWithBody.length !== 0 ? declarationsWithBody.map((x) => createDefinitionInfo(x, typeChecker, symbol, node)) : [createDefinitionInfo(last(declarations), typeChecker, symbol, node, false, failedAliasResolution)] : void 0;
|
|
}
|
|
}
|
|
function createDefinitionInfo(declaration, checker, symbol, node, unverified, failedAliasResolution) {
|
|
const symbolName2 = checker.symbolToString(symbol);
|
|
const symbolKind = ts_SymbolDisplay_exports.getSymbolKind(checker, symbol, node);
|
|
const containerName = symbol.parent ? checker.symbolToString(symbol.parent, node) : "";
|
|
return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName2, containerName, unverified, failedAliasResolution);
|
|
}
|
|
function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName2, containerName, unverified, failedAliasResolution, textSpan) {
|
|
const sourceFile = declaration.getSourceFile();
|
|
if (!textSpan) {
|
|
const name = getNameOfDeclaration(declaration) || declaration;
|
|
textSpan = createTextSpanFromNode(name, sourceFile);
|
|
}
|
|
return {
|
|
fileName: sourceFile.fileName,
|
|
textSpan,
|
|
kind: symbolKind,
|
|
name: symbolName2,
|
|
containerKind: void 0,
|
|
containerName,
|
|
...ts_FindAllReferences_exports.toContextSpan(
|
|
textSpan,
|
|
sourceFile,
|
|
ts_FindAllReferences_exports.getContextNode(declaration)
|
|
),
|
|
isLocal: !isDefinitionVisible(checker, declaration),
|
|
isAmbient: !!(declaration.flags & 16777216 /* Ambient */),
|
|
unverified,
|
|
failedAliasResolution
|
|
};
|
|
}
|
|
function isDefinitionVisible(checker, declaration) {
|
|
if (checker.isDeclarationVisible(declaration))
|
|
return true;
|
|
if (!declaration.parent)
|
|
return false;
|
|
if (hasInitializer(declaration.parent) && declaration.parent.initializer === declaration)
|
|
return isDefinitionVisible(checker, declaration.parent);
|
|
switch (declaration.kind) {
|
|
case 169 /* PropertyDeclaration */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 171 /* MethodDeclaration */:
|
|
if (hasEffectiveModifier(declaration, 8 /* Private */))
|
|
return false;
|
|
case 173 /* Constructor */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 300 /* ShorthandPropertyAssignment */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 228 /* ClassExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 215 /* FunctionExpression */:
|
|
return isDefinitionVisible(checker, declaration.parent);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function createDefinitionFromSignatureDeclaration(typeChecker, decl, failedAliasResolution) {
|
|
return createDefinitionInfo(decl, typeChecker, decl.symbol, decl, false, failedAliasResolution);
|
|
}
|
|
function findReferenceInPosition(refs, pos) {
|
|
return find(refs, (ref) => textRangeContainsPositionInclusive(ref, pos));
|
|
}
|
|
function getDefinitionInfoForFileReference(name, targetFileName, unverified) {
|
|
return {
|
|
fileName: targetFileName,
|
|
textSpan: createTextSpanFromBounds(0, 0),
|
|
kind: "script" /* scriptElement */,
|
|
name,
|
|
containerName: void 0,
|
|
containerKind: void 0,
|
|
unverified
|
|
};
|
|
}
|
|
function getAncestorCallLikeExpression(node) {
|
|
const target = findAncestor(node, (n) => !isRightSideOfPropertyAccess(n));
|
|
const callLike = target == null ? void 0 : target.parent;
|
|
return callLike && isCallLikeExpression(callLike) && getInvokedExpression(callLike) === target ? callLike : void 0;
|
|
}
|
|
function tryGetSignatureDeclaration(typeChecker, node) {
|
|
const callLike = getAncestorCallLikeExpression(node);
|
|
const signature = callLike && typeChecker.getResolvedSignature(callLike);
|
|
return tryCast(signature && signature.declaration, (d) => isFunctionLike(d) && !isFunctionTypeNode(d));
|
|
}
|
|
function isConstructorLike(node) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.InlayHints.ts
|
|
var ts_InlayHints_exports = {};
|
|
__export(ts_InlayHints_exports, {
|
|
provideInlayHints: () => provideInlayHints
|
|
});
|
|
|
|
// src/services/inlayHints.ts
|
|
var maxHintsLength = 30;
|
|
var leadingParameterNameCommentRegexFactory = (name) => {
|
|
return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
|
|
};
|
|
function shouldShowParameterNameHints(preferences) {
|
|
return preferences.includeInlayParameterNameHints === "literals" || preferences.includeInlayParameterNameHints === "all";
|
|
}
|
|
function shouldShowLiteralParameterNameHintsOnly(preferences) {
|
|
return preferences.includeInlayParameterNameHints === "literals";
|
|
}
|
|
function provideInlayHints(context) {
|
|
const { file, program, span, cancellationToken, preferences } = context;
|
|
const sourceFileText = file.text;
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const checker = program.getTypeChecker();
|
|
const result = [];
|
|
visitor(file);
|
|
return result;
|
|
function visitor(node) {
|
|
if (!node || node.getFullWidth() === 0) {
|
|
return;
|
|
}
|
|
switch (node.kind) {
|
|
case 264 /* ModuleDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 216 /* ArrowFunction */:
|
|
cancellationToken.throwIfCancellationRequested();
|
|
}
|
|
if (!textSpanIntersectsWith(span, node.pos, node.getFullWidth())) {
|
|
return;
|
|
}
|
|
if (isTypeNode(node) && !isExpressionWithTypeArguments(node)) {
|
|
return;
|
|
}
|
|
if (preferences.includeInlayVariableTypeHints && isVariableDeclaration(node)) {
|
|
visitVariableLikeDeclaration(node);
|
|
} else if (preferences.includeInlayPropertyDeclarationTypeHints && isPropertyDeclaration(node)) {
|
|
visitVariableLikeDeclaration(node);
|
|
} else if (preferences.includeInlayEnumMemberValueHints && isEnumMember(node)) {
|
|
visitEnumMember(node);
|
|
} else if (shouldShowParameterNameHints(preferences) && (isCallExpression(node) || isNewExpression(node))) {
|
|
visitCallOrNewExpression(node);
|
|
} else {
|
|
if (preferences.includeInlayFunctionParameterTypeHints && isFunctionLikeDeclaration(node) && hasContextSensitiveParameters(node)) {
|
|
visitFunctionLikeForParameterType(node);
|
|
}
|
|
if (preferences.includeInlayFunctionLikeReturnTypeHints && isSignatureSupportingReturnAnnotation(node)) {
|
|
visitFunctionDeclarationLikeForReturnType(node);
|
|
}
|
|
}
|
|
return forEachChild(node, visitor);
|
|
}
|
|
function isSignatureSupportingReturnAnnotation(node) {
|
|
return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
|
|
}
|
|
function addParameterHints(text, position, isFirstVariadicArgument) {
|
|
result.push({
|
|
text: `${isFirstVariadicArgument ? "..." : ""}${truncation(text, maxHintsLength)}:`,
|
|
position,
|
|
kind: "Parameter" /* Parameter */,
|
|
whitespaceAfter: true
|
|
});
|
|
}
|
|
function addTypeHints(text, position) {
|
|
result.push({
|
|
text: `: ${truncation(text, maxHintsLength)}`,
|
|
position,
|
|
kind: "Type" /* Type */,
|
|
whitespaceBefore: true
|
|
});
|
|
}
|
|
function addEnumMemberValueHints(text, position) {
|
|
result.push({
|
|
text: `= ${truncation(text, maxHintsLength)}`,
|
|
position,
|
|
kind: "Enum" /* Enum */,
|
|
whitespaceBefore: true
|
|
});
|
|
}
|
|
function visitEnumMember(member) {
|
|
if (member.initializer) {
|
|
return;
|
|
}
|
|
const enumValue = checker.getConstantValue(member);
|
|
if (enumValue !== void 0) {
|
|
addEnumMemberValueHints(enumValue.toString(), member.end);
|
|
}
|
|
}
|
|
function isModuleReferenceType(type) {
|
|
return type.symbol && type.symbol.flags & 1536 /* Module */;
|
|
}
|
|
function visitVariableLikeDeclaration(decl) {
|
|
if (!decl.initializer || isBindingPattern(decl.name) || isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
|
|
return;
|
|
}
|
|
const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(decl);
|
|
if (effectiveTypeAnnotation) {
|
|
return;
|
|
}
|
|
const declarationType = checker.getTypeAtLocation(decl);
|
|
if (isModuleReferenceType(declarationType)) {
|
|
return;
|
|
}
|
|
const typeDisplayString = printTypeInSingleLine(declarationType);
|
|
if (typeDisplayString) {
|
|
const isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && equateStringsCaseInsensitive(decl.name.getText(), typeDisplayString);
|
|
if (isVariableNameMatchesType) {
|
|
return;
|
|
}
|
|
addTypeHints(typeDisplayString, decl.name.end);
|
|
}
|
|
}
|
|
function visitCallOrNewExpression(expr) {
|
|
const args = expr.arguments;
|
|
if (!args || !args.length) {
|
|
return;
|
|
}
|
|
const candidates = [];
|
|
const signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates);
|
|
if (!signature || !candidates.length) {
|
|
return;
|
|
}
|
|
for (let i = 0; i < args.length; ++i) {
|
|
const originalArg = args[i];
|
|
const arg = skipParentheses(originalArg);
|
|
if (shouldShowLiteralParameterNameHintsOnly(preferences) && !isHintableLiteral(arg)) {
|
|
continue;
|
|
}
|
|
const identifierNameInfo = checker.getParameterIdentifierNameAtPosition(signature, i);
|
|
if (identifierNameInfo) {
|
|
const [parameterName, isFirstVariadicArgument] = identifierNameInfo;
|
|
const isParameterNameNotSameAsArgument = preferences.includeInlayParameterNameHintsWhenArgumentMatchesName || !identifierOrAccessExpressionPostfixMatchesParameterName(arg, parameterName);
|
|
if (!isParameterNameNotSameAsArgument && !isFirstVariadicArgument) {
|
|
continue;
|
|
}
|
|
const name = unescapeLeadingUnderscores(parameterName);
|
|
if (leadingCommentsContainsParameterName(arg, name)) {
|
|
continue;
|
|
}
|
|
addParameterHints(name, originalArg.getStart(), isFirstVariadicArgument);
|
|
}
|
|
}
|
|
}
|
|
function identifierOrAccessExpressionPostfixMatchesParameterName(expr, parameterName) {
|
|
if (isIdentifier(expr)) {
|
|
return expr.text === parameterName;
|
|
}
|
|
if (isPropertyAccessExpression(expr)) {
|
|
return expr.name.text === parameterName;
|
|
}
|
|
return false;
|
|
}
|
|
function leadingCommentsContainsParameterName(node, name) {
|
|
if (!isIdentifierText(name, compilerOptions.target, getLanguageVariant(file.scriptKind))) {
|
|
return false;
|
|
}
|
|
const ranges = getLeadingCommentRanges(sourceFileText, node.pos);
|
|
if (!(ranges == null ? void 0 : ranges.length)) {
|
|
return false;
|
|
}
|
|
const regex = leadingParameterNameCommentRegexFactory(name);
|
|
return some(ranges, (range) => regex.test(sourceFileText.substring(range.pos, range.end)));
|
|
}
|
|
function isHintableLiteral(node) {
|
|
switch (node.kind) {
|
|
case 221 /* PrefixUnaryExpression */: {
|
|
const operand = node.operand;
|
|
return isLiteralExpression(operand) || isIdentifier(operand) && isInfinityOrNaNString(operand.escapedText);
|
|
}
|
|
case 110 /* TrueKeyword */:
|
|
case 95 /* FalseKeyword */:
|
|
case 104 /* NullKeyword */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 225 /* TemplateExpression */:
|
|
return true;
|
|
case 79 /* Identifier */: {
|
|
const name = node.escapedText;
|
|
return isUndefined(name) || isInfinityOrNaNString(name);
|
|
}
|
|
}
|
|
return isLiteralExpression(node);
|
|
}
|
|
function visitFunctionDeclarationLikeForReturnType(decl) {
|
|
if (isArrowFunction(decl)) {
|
|
if (!findChildOfKind(decl, 20 /* OpenParenToken */, file)) {
|
|
return;
|
|
}
|
|
}
|
|
const effectiveTypeAnnotation = getEffectiveReturnTypeNode(decl);
|
|
if (effectiveTypeAnnotation || !decl.body) {
|
|
return;
|
|
}
|
|
const signature = checker.getSignatureFromDeclaration(decl);
|
|
if (!signature) {
|
|
return;
|
|
}
|
|
const returnType = checker.getReturnTypeOfSignature(signature);
|
|
if (isModuleReferenceType(returnType)) {
|
|
return;
|
|
}
|
|
const typeDisplayString = printTypeInSingleLine(returnType);
|
|
if (!typeDisplayString) {
|
|
return;
|
|
}
|
|
addTypeHints(typeDisplayString, getTypeAnnotationPosition(decl));
|
|
}
|
|
function getTypeAnnotationPosition(decl) {
|
|
const closeParenToken = findChildOfKind(decl, 21 /* CloseParenToken */, file);
|
|
if (closeParenToken) {
|
|
return closeParenToken.end;
|
|
}
|
|
return decl.parameters.end;
|
|
}
|
|
function visitFunctionLikeForParameterType(node) {
|
|
const signature = checker.getSignatureFromDeclaration(node);
|
|
if (!signature) {
|
|
return;
|
|
}
|
|
for (let i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
|
|
const param = node.parameters[i];
|
|
if (!isHintableDeclaration(param)) {
|
|
continue;
|
|
}
|
|
const effectiveTypeAnnotation = getEffectiveTypeAnnotationNode(param);
|
|
if (effectiveTypeAnnotation) {
|
|
continue;
|
|
}
|
|
const typeDisplayString = getParameterDeclarationTypeDisplayString(signature.parameters[i]);
|
|
if (!typeDisplayString) {
|
|
continue;
|
|
}
|
|
addTypeHints(typeDisplayString, param.questionToken ? param.questionToken.end : param.name.end);
|
|
}
|
|
}
|
|
function getParameterDeclarationTypeDisplayString(symbol) {
|
|
const valueDeclaration = symbol.valueDeclaration;
|
|
if (!valueDeclaration || !isParameter(valueDeclaration)) {
|
|
return void 0;
|
|
}
|
|
const signatureParamType = checker.getTypeOfSymbolAtLocation(symbol, valueDeclaration);
|
|
if (isModuleReferenceType(signatureParamType)) {
|
|
return void 0;
|
|
}
|
|
return printTypeInSingleLine(signatureParamType);
|
|
}
|
|
function truncation(text, maxLength2) {
|
|
if (text.length > maxLength2) {
|
|
return text.substr(0, maxLength2 - "...".length) + "...";
|
|
}
|
|
return text;
|
|
}
|
|
function printTypeInSingleLine(type) {
|
|
const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
|
|
const options = { removeComments: true };
|
|
const printer = createPrinter(options);
|
|
return usingSingleLineStringWriter((writer) => {
|
|
const typeNode = checker.typeToTypeNode(type, void 0, flags, writer);
|
|
Debug.assertIsDefined(typeNode, "should always get typenode");
|
|
printer.writeNode(4 /* Unspecified */, typeNode, file, writer);
|
|
});
|
|
}
|
|
function isUndefined(name) {
|
|
return name === "undefined";
|
|
}
|
|
function isHintableDeclaration(node) {
|
|
if ((isParameterDeclaration(node) || isVariableDeclaration(node) && isVarConst(node)) && node.initializer) {
|
|
const initializer = skipParentheses(node.initializer);
|
|
return !(isHintableLiteral(initializer) || isNewExpression(initializer) || isObjectLiteralExpression(initializer) || isAssertionExpression(initializer));
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.JsDoc.ts
|
|
var ts_JsDoc_exports = {};
|
|
__export(ts_JsDoc_exports, {
|
|
getDocCommentTemplateAtPosition: () => getDocCommentTemplateAtPosition,
|
|
getJSDocParameterNameCompletionDetails: () => getJSDocParameterNameCompletionDetails,
|
|
getJSDocParameterNameCompletions: () => getJSDocParameterNameCompletions,
|
|
getJSDocTagCompletionDetails: () => getJSDocTagCompletionDetails,
|
|
getJSDocTagCompletions: () => getJSDocTagCompletions,
|
|
getJSDocTagNameCompletionDetails: () => getJSDocTagNameCompletionDetails,
|
|
getJSDocTagNameCompletions: () => getJSDocTagNameCompletions,
|
|
getJsDocCommentsFromDeclarations: () => getJsDocCommentsFromDeclarations,
|
|
getJsDocTagsFromDeclarations: () => getJsDocTagsFromDeclarations
|
|
});
|
|
|
|
// src/services/jsDoc.ts
|
|
var jsDocTagNames = [
|
|
"abstract",
|
|
"access",
|
|
"alias",
|
|
"argument",
|
|
"async",
|
|
"augments",
|
|
"author",
|
|
"borrows",
|
|
"callback",
|
|
"class",
|
|
"classdesc",
|
|
"constant",
|
|
"constructor",
|
|
"constructs",
|
|
"copyright",
|
|
"default",
|
|
"deprecated",
|
|
"description",
|
|
"emits",
|
|
"enum",
|
|
"event",
|
|
"example",
|
|
"exports",
|
|
"extends",
|
|
"external",
|
|
"field",
|
|
"file",
|
|
"fileoverview",
|
|
"fires",
|
|
"function",
|
|
"generator",
|
|
"global",
|
|
"hideconstructor",
|
|
"host",
|
|
"ignore",
|
|
"implements",
|
|
"inheritdoc",
|
|
"inner",
|
|
"instance",
|
|
"interface",
|
|
"kind",
|
|
"lends",
|
|
"license",
|
|
"link",
|
|
"listens",
|
|
"member",
|
|
"memberof",
|
|
"method",
|
|
"mixes",
|
|
"module",
|
|
"name",
|
|
"namespace",
|
|
"override",
|
|
"package",
|
|
"param",
|
|
"private",
|
|
"property",
|
|
"protected",
|
|
"public",
|
|
"readonly",
|
|
"requires",
|
|
"returns",
|
|
"see",
|
|
"since",
|
|
"static",
|
|
"summary",
|
|
"template",
|
|
"this",
|
|
"throws",
|
|
"todo",
|
|
"tutorial",
|
|
"type",
|
|
"typedef",
|
|
"var",
|
|
"variation",
|
|
"version",
|
|
"virtual",
|
|
"yields"
|
|
];
|
|
var jsDocTagNameCompletionEntries;
|
|
var jsDocTagCompletionEntries;
|
|
function getJsDocCommentsFromDeclarations(declarations, checker) {
|
|
const parts = [];
|
|
forEachUnique(declarations, (declaration) => {
|
|
for (const jsdoc of getCommentHavingNodes(declaration)) {
|
|
const inheritDoc = isJSDoc(jsdoc) && jsdoc.tags && find(jsdoc.tags, (t) => t.kind === 330 /* JSDocTag */ && (t.tagName.escapedText === "inheritDoc" || t.tagName.escapedText === "inheritdoc"));
|
|
if (jsdoc.comment === void 0 && !inheritDoc || isJSDoc(jsdoc) && declaration.kind !== 348 /* JSDocTypedefTag */ && declaration.kind !== 341 /* JSDocCallbackTag */ && jsdoc.tags && jsdoc.tags.some((t) => t.kind === 348 /* JSDocTypedefTag */ || t.kind === 341 /* JSDocCallbackTag */) && !jsdoc.tags.some((t) => t.kind === 343 /* JSDocParameterTag */ || t.kind === 344 /* JSDocReturnTag */)) {
|
|
continue;
|
|
}
|
|
let newparts = jsdoc.comment ? getDisplayPartsFromComment(jsdoc.comment, checker) : [];
|
|
if (inheritDoc && inheritDoc.comment) {
|
|
newparts = newparts.concat(getDisplayPartsFromComment(inheritDoc.comment, checker));
|
|
}
|
|
if (!contains(parts, newparts, isIdenticalListOfDisplayParts)) {
|
|
parts.push(newparts);
|
|
}
|
|
}
|
|
});
|
|
return flatten(intersperse(parts, [lineBreakPart()]));
|
|
}
|
|
function isIdenticalListOfDisplayParts(parts1, parts2) {
|
|
return arraysEqual(parts1, parts2, (p1, p2) => p1.kind === p2.kind && p1.text === p2.text);
|
|
}
|
|
function getCommentHavingNodes(declaration) {
|
|
switch (declaration.kind) {
|
|
case 343 /* JSDocParameterTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
return [declaration];
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
return [declaration, declaration.parent];
|
|
default:
|
|
return getJSDocCommentsAndTags(declaration);
|
|
}
|
|
}
|
|
function getJsDocTagsFromDeclarations(declarations, checker) {
|
|
const infos = [];
|
|
forEachUnique(declarations, (declaration) => {
|
|
const tags = getJSDocTags(declaration);
|
|
if (tags.some((t) => t.kind === 348 /* JSDocTypedefTag */ || t.kind === 341 /* JSDocCallbackTag */) && !tags.some((t) => t.kind === 343 /* JSDocParameterTag */ || t.kind === 344 /* JSDocReturnTag */)) {
|
|
return;
|
|
}
|
|
for (const tag of tags) {
|
|
infos.push({ name: tag.tagName.text, text: getCommentDisplayParts(tag, checker) });
|
|
}
|
|
});
|
|
return infos;
|
|
}
|
|
function getDisplayPartsFromComment(comment, checker) {
|
|
if (typeof comment === "string") {
|
|
return [textPart(comment)];
|
|
}
|
|
return flatMap(
|
|
comment,
|
|
(node) => node.kind === 324 /* JSDocText */ ? [textPart(node.text)] : buildLinkParts(node, checker)
|
|
);
|
|
}
|
|
function getCommentDisplayParts(tag, checker) {
|
|
const { comment, kind } = tag;
|
|
const namePart = getTagNameDisplayPart(kind);
|
|
switch (kind) {
|
|
case 332 /* JSDocImplementsTag */:
|
|
return withNode(tag.class);
|
|
case 331 /* JSDocAugmentsTag */:
|
|
return withNode(tag.class);
|
|
case 347 /* JSDocTemplateTag */:
|
|
const templateTag = tag;
|
|
const displayParts = [];
|
|
if (templateTag.constraint) {
|
|
displayParts.push(textPart(templateTag.constraint.getText()));
|
|
}
|
|
if (length(templateTag.typeParameters)) {
|
|
if (length(displayParts)) {
|
|
displayParts.push(spacePart());
|
|
}
|
|
const lastTypeParameter = templateTag.typeParameters[templateTag.typeParameters.length - 1];
|
|
forEach(templateTag.typeParameters, (tp) => {
|
|
displayParts.push(namePart(tp.getText()));
|
|
if (lastTypeParameter !== tp) {
|
|
displayParts.push(...[punctuationPart(27 /* CommaToken */), spacePart()]);
|
|
}
|
|
});
|
|
}
|
|
if (comment) {
|
|
displayParts.push(...[spacePart(), ...getDisplayPartsFromComment(comment, checker)]);
|
|
}
|
|
return displayParts;
|
|
case 346 /* JSDocTypeTag */:
|
|
return withNode(tag.typeExpression);
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 343 /* JSDocParameterTag */:
|
|
case 349 /* JSDocSeeTag */:
|
|
const { name } = tag;
|
|
return name ? withNode(name) : comment === void 0 ? void 0 : getDisplayPartsFromComment(comment, checker);
|
|
default:
|
|
return comment === void 0 ? void 0 : getDisplayPartsFromComment(comment, checker);
|
|
}
|
|
function withNode(node) {
|
|
return addComment(node.getText());
|
|
}
|
|
function addComment(s) {
|
|
if (comment) {
|
|
if (s.match(/^https?$/)) {
|
|
return [textPart(s), ...getDisplayPartsFromComment(comment, checker)];
|
|
} else {
|
|
return [namePart(s), spacePart(), ...getDisplayPartsFromComment(comment, checker)];
|
|
}
|
|
} else {
|
|
return [textPart(s)];
|
|
}
|
|
}
|
|
}
|
|
function getTagNameDisplayPart(kind) {
|
|
switch (kind) {
|
|
case 343 /* JSDocParameterTag */:
|
|
return parameterNamePart;
|
|
case 350 /* JSDocPropertyTag */:
|
|
return propertyNamePart;
|
|
case 347 /* JSDocTemplateTag */:
|
|
return typeParameterNamePart;
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
return typeAliasNamePart;
|
|
default:
|
|
return textPart;
|
|
}
|
|
}
|
|
function getJSDocTagNameCompletions() {
|
|
return jsDocTagNameCompletionEntries || (jsDocTagNameCompletionEntries = map(jsDocTagNames, (tagName) => {
|
|
return {
|
|
name: tagName,
|
|
kind: "keyword" /* keyword */,
|
|
kindModifiers: "",
|
|
sortText: ts_Completions_exports.SortText.LocationPriority
|
|
};
|
|
}));
|
|
}
|
|
var getJSDocTagNameCompletionDetails = getJSDocTagCompletionDetails;
|
|
function getJSDocTagCompletions() {
|
|
return jsDocTagCompletionEntries || (jsDocTagCompletionEntries = map(jsDocTagNames, (tagName) => {
|
|
return {
|
|
name: `@${tagName}`,
|
|
kind: "keyword" /* keyword */,
|
|
kindModifiers: "",
|
|
sortText: ts_Completions_exports.SortText.LocationPriority
|
|
};
|
|
}));
|
|
}
|
|
function getJSDocTagCompletionDetails(name) {
|
|
return {
|
|
name,
|
|
kind: "" /* unknown */,
|
|
kindModifiers: "",
|
|
displayParts: [textPart(name)],
|
|
documentation: emptyArray,
|
|
tags: void 0,
|
|
codeActions: void 0
|
|
};
|
|
}
|
|
function getJSDocParameterNameCompletions(tag) {
|
|
if (!isIdentifier(tag.name)) {
|
|
return emptyArray;
|
|
}
|
|
const nameThusFar = tag.name.text;
|
|
const jsdoc = tag.parent;
|
|
const fn = jsdoc.parent;
|
|
if (!isFunctionLike(fn))
|
|
return [];
|
|
return mapDefined(fn.parameters, (param) => {
|
|
if (!isIdentifier(param.name))
|
|
return void 0;
|
|
const name = param.name.text;
|
|
if (jsdoc.tags.some((t) => t !== tag && isJSDocParameterTag(t) && isIdentifier(t.name) && t.name.escapedText === name) || nameThusFar !== void 0 && !startsWith(name, nameThusFar)) {
|
|
return void 0;
|
|
}
|
|
return { name, kind: "parameter" /* parameterElement */, kindModifiers: "", sortText: ts_Completions_exports.SortText.LocationPriority };
|
|
});
|
|
}
|
|
function getJSDocParameterNameCompletionDetails(name) {
|
|
return {
|
|
name,
|
|
kind: "parameter" /* parameterElement */,
|
|
kindModifiers: "",
|
|
displayParts: [textPart(name)],
|
|
documentation: emptyArray,
|
|
tags: void 0,
|
|
codeActions: void 0
|
|
};
|
|
}
|
|
function getDocCommentTemplateAtPosition(newLine, sourceFile, position, options) {
|
|
const tokenAtPos = getTokenAtPosition(sourceFile, position);
|
|
const existingDocComment = findAncestor(tokenAtPos, isJSDoc);
|
|
if (existingDocComment && (existingDocComment.comment !== void 0 || length(existingDocComment.tags))) {
|
|
return void 0;
|
|
}
|
|
const tokenStart = tokenAtPos.getStart(sourceFile);
|
|
if (!existingDocComment && tokenStart < position) {
|
|
return void 0;
|
|
}
|
|
const commentOwnerInfo = getCommentOwnerInfo(tokenAtPos, options);
|
|
if (!commentOwnerInfo) {
|
|
return void 0;
|
|
}
|
|
const { commentOwner, parameters, hasReturn: hasReturn2 } = commentOwnerInfo;
|
|
const commentOwnerJsDoc = hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : void 0;
|
|
const lastJsDoc = lastOrUndefined(commentOwnerJsDoc);
|
|
if (commentOwner.getStart(sourceFile) < position || lastJsDoc && existingDocComment && lastJsDoc !== existingDocComment) {
|
|
return void 0;
|
|
}
|
|
const indentationStr = getIndentationStringAtPosition(sourceFile, position);
|
|
const isJavaScriptFile = hasJSFileExtension(sourceFile.fileName);
|
|
const tags = (parameters ? parameterDocComments(parameters || [], isJavaScriptFile, indentationStr, newLine) : "") + (hasReturn2 ? returnsDocComment(indentationStr, newLine) : "");
|
|
const openComment = "/**";
|
|
const closeComment = " */";
|
|
const hasTag = (commentOwnerJsDoc || []).some((jsDoc) => !!jsDoc.tags);
|
|
if (tags && !hasTag) {
|
|
const preamble = openComment + newLine + indentationStr + " * ";
|
|
const endLine = tokenStart === position ? newLine + indentationStr : "";
|
|
const result = preamble + newLine + tags + indentationStr + closeComment + endLine;
|
|
return { newText: result, caretOffset: preamble.length };
|
|
}
|
|
return { newText: openComment + closeComment, caretOffset: 3 };
|
|
}
|
|
function getIndentationStringAtPosition(sourceFile, position) {
|
|
const { text } = sourceFile;
|
|
const lineStart = getLineStartPositionForPosition(position, sourceFile);
|
|
let pos = lineStart;
|
|
for (; pos <= position && isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++)
|
|
;
|
|
return text.slice(lineStart, pos);
|
|
}
|
|
function parameterDocComments(parameters, isJavaScriptFile, indentationStr, newLine) {
|
|
return parameters.map(({ name, dotDotDotToken }, i) => {
|
|
const paramName = name.kind === 79 /* Identifier */ ? name.text : "param" + i;
|
|
const type = isJavaScriptFile ? dotDotDotToken ? "{...any} " : "{any} " : "";
|
|
return `${indentationStr} * @param ${type}${paramName}${newLine}`;
|
|
}).join("");
|
|
}
|
|
function returnsDocComment(indentationStr, newLine) {
|
|
return `${indentationStr} * @returns${newLine}`;
|
|
}
|
|
function getCommentOwnerInfo(tokenAtPos, options) {
|
|
return forEachAncestor(tokenAtPos, (n) => getCommentOwnerInfoWorker(n, options));
|
|
}
|
|
function getCommentOwnerInfoWorker(commentOwner, options) {
|
|
switch (commentOwner.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 170 /* MethodSignature */:
|
|
case 216 /* ArrowFunction */:
|
|
const host = commentOwner;
|
|
return { commentOwner, parameters: host.parameters, hasReturn: hasReturn(host, options) };
|
|
case 299 /* PropertyAssignment */:
|
|
return getCommentOwnerInfoWorker(commentOwner.initializer, options);
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 302 /* EnumMember */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return { commentOwner };
|
|
case 168 /* PropertySignature */: {
|
|
const host2 = commentOwner;
|
|
return host2.type && isFunctionTypeNode(host2.type) ? { commentOwner, parameters: host2.type.parameters, hasReturn: hasReturn(host2.type, options) } : { commentOwner };
|
|
}
|
|
case 240 /* VariableStatement */: {
|
|
const varStatement = commentOwner;
|
|
const varDeclarations = varStatement.declarationList.declarations;
|
|
const host2 = varDeclarations.length === 1 && varDeclarations[0].initializer ? getRightHandSideOfAssignment(varDeclarations[0].initializer) : void 0;
|
|
return host2 ? { commentOwner, parameters: host2.parameters, hasReturn: hasReturn(host2, options) } : { commentOwner };
|
|
}
|
|
case 308 /* SourceFile */:
|
|
return "quit";
|
|
case 264 /* ModuleDeclaration */:
|
|
return commentOwner.parent.kind === 264 /* ModuleDeclaration */ ? void 0 : { commentOwner };
|
|
case 241 /* ExpressionStatement */:
|
|
return getCommentOwnerInfoWorker(commentOwner.expression, options);
|
|
case 223 /* BinaryExpression */: {
|
|
const be = commentOwner;
|
|
if (getAssignmentDeclarationKind(be) === 0 /* None */) {
|
|
return "quit";
|
|
}
|
|
return isFunctionLike(be.right) ? { commentOwner, parameters: be.right.parameters, hasReturn: hasReturn(be.right, options) } : { commentOwner };
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
const init = commentOwner.initializer;
|
|
if (init && (isFunctionExpression(init) || isArrowFunction(init))) {
|
|
return { commentOwner, parameters: init.parameters, hasReturn: hasReturn(init, options) };
|
|
}
|
|
}
|
|
}
|
|
function hasReturn(node, options) {
|
|
return !!(options == null ? void 0 : options.generateReturnInDocTemplate) && (isFunctionTypeNode(node) || isArrowFunction(node) && isExpression(node.body) || isFunctionLikeDeclaration(node) && node.body && isBlock(node.body) && !!forEachReturnStatement(node.body, (n) => n));
|
|
}
|
|
function getRightHandSideOfAssignment(rightHandSide) {
|
|
while (rightHandSide.kind === 214 /* ParenthesizedExpression */) {
|
|
rightHandSide = rightHandSide.expression;
|
|
}
|
|
switch (rightHandSide.kind) {
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return rightHandSide;
|
|
case 228 /* ClassExpression */:
|
|
return find(rightHandSide.members, isConstructorDeclaration);
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.OrganizeImports.ts
|
|
var ts_OrganizeImports_exports = {};
|
|
__export(ts_OrganizeImports_exports, {
|
|
coalesceExports: () => coalesceExports,
|
|
coalesceImports: () => coalesceImports,
|
|
compareImportOrExportSpecifiers: () => compareImportOrExportSpecifiers,
|
|
compareImportsOrRequireStatements: () => compareImportsOrRequireStatements,
|
|
compareModuleSpecifiers: () => compareModuleSpecifiers2,
|
|
getImportDeclarationInsertionIndex: () => getImportDeclarationInsertionIndex,
|
|
getImportSpecifierInsertionIndex: () => getImportSpecifierInsertionIndex,
|
|
importSpecifiersAreSorted: () => importSpecifiersAreSorted,
|
|
importsAreSorted: () => importsAreSorted,
|
|
organizeImports: () => organizeImports
|
|
});
|
|
|
|
// src/services/organizeImports.ts
|
|
function organizeImports(sourceFile, formatContext, host, program, preferences, mode) {
|
|
const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext({ host, formatContext, preferences });
|
|
const shouldSort = mode === "SortAndCombine" /* SortAndCombine */ || mode === "All" /* All */;
|
|
const shouldCombine = shouldSort;
|
|
const shouldRemove = mode === "RemoveUnused" /* RemoveUnused */ || mode === "All" /* All */;
|
|
const maybeRemove = shouldRemove ? removeUnusedImports : identity;
|
|
const maybeCoalesce = shouldCombine ? coalesceImports : identity;
|
|
const processImportsOfSameModuleSpecifier = (importGroup) => {
|
|
const processedDeclarations = maybeCoalesce(maybeRemove(importGroup, sourceFile, program), sourceFile);
|
|
return shouldSort ? stableSort(processedDeclarations, (s1, s2) => compareImportsOrRequireStatements(s1, s2)) : processedDeclarations;
|
|
};
|
|
const topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(isImportDeclaration));
|
|
topLevelImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
|
|
if (mode !== "RemoveUnused" /* RemoveUnused */) {
|
|
const topLevelExportDecls = sourceFile.statements.filter(isExportDeclaration);
|
|
organizeImportsWorker(topLevelExportDecls, coalesceExports);
|
|
}
|
|
for (const ambientModule of sourceFile.statements.filter(isAmbientModule)) {
|
|
if (!ambientModule.body)
|
|
continue;
|
|
const ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(isImportDeclaration));
|
|
ambientModuleImportGroupDecls.forEach((importGroupDecl) => organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier));
|
|
if (mode !== "RemoveUnused" /* RemoveUnused */) {
|
|
const ambientModuleExportDecls = ambientModule.body.statements.filter(isExportDeclaration);
|
|
organizeImportsWorker(ambientModuleExportDecls, coalesceExports);
|
|
}
|
|
}
|
|
return changeTracker.getChanges();
|
|
function organizeImportsWorker(oldImportDecls, coalesce) {
|
|
if (length(oldImportDecls) === 0) {
|
|
return;
|
|
}
|
|
suppressLeadingTrivia(oldImportDecls[0]);
|
|
const oldImportGroups = shouldCombine ? group(oldImportDecls, (importDecl) => getExternalModuleName2(importDecl.moduleSpecifier)) : [oldImportDecls];
|
|
const sortedImportGroups = shouldSort ? stableSort(oldImportGroups, (group1, group2) => compareModuleSpecifiers2(group1[0].moduleSpecifier, group2[0].moduleSpecifier)) : oldImportGroups;
|
|
const newImportDecls = flatMap(sortedImportGroups, (importGroup) => getExternalModuleName2(importGroup[0].moduleSpecifier) ? coalesce(importGroup) : importGroup);
|
|
if (newImportDecls.length === 0) {
|
|
changeTracker.deleteNodes(sourceFile, oldImportDecls, {
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Include
|
|
}, true);
|
|
} else {
|
|
const replaceOptions = {
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Include,
|
|
suffix: getNewLineOrDefaultFromHost(host, formatContext.options)
|
|
};
|
|
changeTracker.replaceNodeWithNodes(sourceFile, oldImportDecls[0], newImportDecls, replaceOptions);
|
|
const hasTrailingComment = changeTracker.nodeHasTrailingComment(sourceFile, oldImportDecls[0], replaceOptions);
|
|
changeTracker.deleteNodes(sourceFile, oldImportDecls.slice(1), {
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Include
|
|
}, hasTrailingComment);
|
|
}
|
|
}
|
|
}
|
|
function groupImportsByNewlineContiguous(sourceFile, importDecls) {
|
|
const scanner2 = createScanner(sourceFile.languageVersion, false, sourceFile.languageVariant);
|
|
const groupImports = [];
|
|
let groupIndex = 0;
|
|
for (const topLevelImportDecl of importDecls) {
|
|
if (isNewGroup(sourceFile, topLevelImportDecl, scanner2)) {
|
|
groupIndex++;
|
|
}
|
|
if (!groupImports[groupIndex]) {
|
|
groupImports[groupIndex] = [];
|
|
}
|
|
groupImports[groupIndex].push(topLevelImportDecl);
|
|
}
|
|
return groupImports;
|
|
}
|
|
function isNewGroup(sourceFile, topLevelImportDecl, scanner2) {
|
|
const startPos = topLevelImportDecl.getFullStart();
|
|
const endPos = topLevelImportDecl.getStart();
|
|
scanner2.setText(sourceFile.text, startPos, endPos - startPos);
|
|
let numberOfNewLines = 0;
|
|
while (scanner2.getTokenPos() < endPos) {
|
|
const tokenKind = scanner2.scan();
|
|
if (tokenKind === 4 /* NewLineTrivia */) {
|
|
numberOfNewLines++;
|
|
if (numberOfNewLines >= 2) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function removeUnusedImports(oldImports, sourceFile, program) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const compilerOptions = program.getCompilerOptions();
|
|
const jsxNamespace = typeChecker.getJsxNamespace(sourceFile);
|
|
const jsxFragmentFactory = typeChecker.getJsxFragmentFactory(sourceFile);
|
|
const jsxElementsPresent = !!(sourceFile.transformFlags & 2 /* ContainsJsx */);
|
|
const usedImports = [];
|
|
for (const importDecl of oldImports) {
|
|
const { importClause, moduleSpecifier } = importDecl;
|
|
if (!importClause) {
|
|
usedImports.push(importDecl);
|
|
continue;
|
|
}
|
|
let { name, namedBindings } = importClause;
|
|
if (name && !isDeclarationUsed(name)) {
|
|
name = void 0;
|
|
}
|
|
if (namedBindings) {
|
|
if (isNamespaceImport(namedBindings)) {
|
|
if (!isDeclarationUsed(namedBindings.name)) {
|
|
namedBindings = void 0;
|
|
}
|
|
} else {
|
|
const newElements = namedBindings.elements.filter((e) => isDeclarationUsed(e.name));
|
|
if (newElements.length < namedBindings.elements.length) {
|
|
namedBindings = newElements.length ? factory.updateNamedImports(namedBindings, newElements) : void 0;
|
|
}
|
|
}
|
|
}
|
|
if (name || namedBindings) {
|
|
usedImports.push(updateImportDeclarationAndClause(importDecl, name, namedBindings));
|
|
} else if (hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier)) {
|
|
if (sourceFile.isDeclarationFile) {
|
|
usedImports.push(factory.createImportDeclaration(
|
|
importDecl.modifiers,
|
|
void 0,
|
|
moduleSpecifier,
|
|
void 0
|
|
));
|
|
} else {
|
|
usedImports.push(importDecl);
|
|
}
|
|
}
|
|
}
|
|
return usedImports;
|
|
function isDeclarationUsed(identifier) {
|
|
return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) && jsxModeNeedsExplicitImport(compilerOptions.jsx) || ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile);
|
|
}
|
|
}
|
|
function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) {
|
|
const moduleSpecifierText = isStringLiteral(moduleSpecifier) && moduleSpecifier.text;
|
|
return isString(moduleSpecifierText) && some(sourceFile.moduleAugmentations, (moduleName) => isStringLiteral(moduleName) && moduleName.text === moduleSpecifierText);
|
|
}
|
|
function getExternalModuleName2(specifier) {
|
|
return specifier !== void 0 && isStringLiteralLike(specifier) ? specifier.text : void 0;
|
|
}
|
|
function coalesceImports(importGroup, sourceFile) {
|
|
var _a2, _b, _c, _d;
|
|
if (importGroup.length === 0) {
|
|
return importGroup;
|
|
}
|
|
const { importWithoutClause, typeOnlyImports, regularImports } = getCategorizedImports(importGroup);
|
|
const coalescedImports = [];
|
|
if (importWithoutClause) {
|
|
coalescedImports.push(importWithoutClause);
|
|
}
|
|
for (const group2 of [regularImports, typeOnlyImports]) {
|
|
const isTypeOnly = group2 === typeOnlyImports;
|
|
const { defaultImports, namespaceImports, namedImports } = group2;
|
|
if (!isTypeOnly && defaultImports.length === 1 && namespaceImports.length === 1 && namedImports.length === 0) {
|
|
const defaultImport = defaultImports[0];
|
|
coalescedImports.push(
|
|
updateImportDeclarationAndClause(defaultImport, defaultImport.importClause.name, namespaceImports[0].importClause.namedBindings)
|
|
);
|
|
continue;
|
|
}
|
|
const sortedNamespaceImports = stableSort(namespaceImports, (i1, i2) => compareIdentifiers(i1.importClause.namedBindings.name, i2.importClause.namedBindings.name));
|
|
for (const namespaceImport of sortedNamespaceImports) {
|
|
coalescedImports.push(
|
|
updateImportDeclarationAndClause(namespaceImport, void 0, namespaceImport.importClause.namedBindings)
|
|
);
|
|
}
|
|
if (defaultImports.length === 0 && namedImports.length === 0) {
|
|
continue;
|
|
}
|
|
let newDefaultImport;
|
|
const newImportSpecifiers = [];
|
|
if (defaultImports.length === 1) {
|
|
newDefaultImport = defaultImports[0].importClause.name;
|
|
} else {
|
|
for (const defaultImport of defaultImports) {
|
|
newImportSpecifiers.push(
|
|
factory.createImportSpecifier(false, factory.createIdentifier("default"), defaultImport.importClause.name)
|
|
);
|
|
}
|
|
}
|
|
newImportSpecifiers.push(...getNewImportSpecifiers(namedImports));
|
|
const sortedImportSpecifiers = factory.createNodeArray(
|
|
sortSpecifiers(newImportSpecifiers),
|
|
(_b = (_a2 = namedImports[0]) == null ? void 0 : _a2.importClause.namedBindings) == null ? void 0 : _b.elements.hasTrailingComma
|
|
);
|
|
const importDecl = defaultImports.length > 0 ? defaultImports[0] : namedImports[0];
|
|
const newNamedImports = sortedImportSpecifiers.length === 0 ? newDefaultImport ? void 0 : factory.createNamedImports(emptyArray) : namedImports.length === 0 ? factory.createNamedImports(sortedImportSpecifiers) : factory.updateNamedImports(namedImports[0].importClause.namedBindings, sortedImportSpecifiers);
|
|
if (sourceFile && newNamedImports && ((_c = namedImports[0]) == null ? void 0 : _c.importClause.namedBindings) && !rangeIsOnSingleLine(namedImports[0].importClause.namedBindings, sourceFile)) {
|
|
setEmitFlags(newNamedImports, 2 /* MultiLine */);
|
|
}
|
|
if (isTypeOnly && newDefaultImport && newNamedImports) {
|
|
coalescedImports.push(
|
|
updateImportDeclarationAndClause(importDecl, newDefaultImport, void 0)
|
|
);
|
|
coalescedImports.push(
|
|
updateImportDeclarationAndClause((_d = namedImports[0]) != null ? _d : importDecl, void 0, newNamedImports)
|
|
);
|
|
} else {
|
|
coalescedImports.push(
|
|
updateImportDeclarationAndClause(importDecl, newDefaultImport, newNamedImports)
|
|
);
|
|
}
|
|
}
|
|
return coalescedImports;
|
|
}
|
|
function getCategorizedImports(importGroup) {
|
|
let importWithoutClause;
|
|
const typeOnlyImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
|
|
const regularImports = { defaultImports: [], namespaceImports: [], namedImports: [] };
|
|
for (const importDeclaration of importGroup) {
|
|
if (importDeclaration.importClause === void 0) {
|
|
importWithoutClause = importWithoutClause || importDeclaration;
|
|
continue;
|
|
}
|
|
const group2 = importDeclaration.importClause.isTypeOnly ? typeOnlyImports : regularImports;
|
|
const { name, namedBindings } = importDeclaration.importClause;
|
|
if (name) {
|
|
group2.defaultImports.push(importDeclaration);
|
|
}
|
|
if (namedBindings) {
|
|
if (isNamespaceImport(namedBindings)) {
|
|
group2.namespaceImports.push(importDeclaration);
|
|
} else {
|
|
group2.namedImports.push(importDeclaration);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
importWithoutClause,
|
|
typeOnlyImports,
|
|
regularImports
|
|
};
|
|
}
|
|
function coalesceExports(exportGroup) {
|
|
if (exportGroup.length === 0) {
|
|
return exportGroup;
|
|
}
|
|
const { exportWithoutClause, namedExports, typeOnlyExports } = getCategorizedExports(exportGroup);
|
|
const coalescedExports = [];
|
|
if (exportWithoutClause) {
|
|
coalescedExports.push(exportWithoutClause);
|
|
}
|
|
for (const exportGroup2 of [namedExports, typeOnlyExports]) {
|
|
if (exportGroup2.length === 0) {
|
|
continue;
|
|
}
|
|
const newExportSpecifiers = [];
|
|
newExportSpecifiers.push(...flatMap(exportGroup2, (i) => i.exportClause && isNamedExports(i.exportClause) ? i.exportClause.elements : emptyArray));
|
|
const sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers);
|
|
const exportDecl = exportGroup2[0];
|
|
coalescedExports.push(
|
|
factory.updateExportDeclaration(
|
|
exportDecl,
|
|
exportDecl.modifiers,
|
|
exportDecl.isTypeOnly,
|
|
exportDecl.exportClause && (isNamedExports(exportDecl.exportClause) ? factory.updateNamedExports(exportDecl.exportClause, sortedExportSpecifiers) : factory.updateNamespaceExport(exportDecl.exportClause, exportDecl.exportClause.name)),
|
|
exportDecl.moduleSpecifier,
|
|
exportDecl.assertClause
|
|
)
|
|
);
|
|
}
|
|
return coalescedExports;
|
|
function getCategorizedExports(exportGroup2) {
|
|
let exportWithoutClause2;
|
|
const namedExports2 = [];
|
|
const typeOnlyExports2 = [];
|
|
for (const exportDeclaration of exportGroup2) {
|
|
if (exportDeclaration.exportClause === void 0) {
|
|
exportWithoutClause2 = exportWithoutClause2 || exportDeclaration;
|
|
} else if (exportDeclaration.isTypeOnly) {
|
|
typeOnlyExports2.push(exportDeclaration);
|
|
} else {
|
|
namedExports2.push(exportDeclaration);
|
|
}
|
|
}
|
|
return {
|
|
exportWithoutClause: exportWithoutClause2,
|
|
namedExports: namedExports2,
|
|
typeOnlyExports: typeOnlyExports2
|
|
};
|
|
}
|
|
}
|
|
function updateImportDeclarationAndClause(importDeclaration, name, namedBindings) {
|
|
return factory.updateImportDeclaration(
|
|
importDeclaration,
|
|
importDeclaration.modifiers,
|
|
factory.updateImportClause(importDeclaration.importClause, importDeclaration.importClause.isTypeOnly, name, namedBindings),
|
|
importDeclaration.moduleSpecifier,
|
|
importDeclaration.assertClause
|
|
);
|
|
}
|
|
function sortSpecifiers(specifiers) {
|
|
return stableSort(specifiers, compareImportOrExportSpecifiers);
|
|
}
|
|
function compareImportOrExportSpecifiers(s1, s2) {
|
|
return compareBooleans(s1.isTypeOnly, s2.isTypeOnly) || compareIdentifiers(s1.propertyName || s1.name, s2.propertyName || s2.name) || compareIdentifiers(s1.name, s2.name);
|
|
}
|
|
function compareModuleSpecifiers2(m1, m2) {
|
|
const name1 = m1 === void 0 ? void 0 : getExternalModuleName2(m1);
|
|
const name2 = m2 === void 0 ? void 0 : getExternalModuleName2(m2);
|
|
return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || compareStringsCaseInsensitive(name1, name2);
|
|
}
|
|
function compareIdentifiers(s1, s2) {
|
|
return compareStringsCaseInsensitive(s1.text, s2.text);
|
|
}
|
|
function getModuleSpecifierExpression(declaration) {
|
|
var _a2;
|
|
switch (declaration.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return (_a2 = tryCast(declaration.moduleReference, isExternalModuleReference)) == null ? void 0 : _a2.expression;
|
|
case 269 /* ImportDeclaration */:
|
|
return declaration.moduleSpecifier;
|
|
case 240 /* VariableStatement */:
|
|
return declaration.declarationList.declarations[0].initializer.arguments[0];
|
|
}
|
|
}
|
|
function importsAreSorted(imports) {
|
|
return arrayIsSorted(imports, compareImportsOrRequireStatements);
|
|
}
|
|
function importSpecifiersAreSorted(imports) {
|
|
return arrayIsSorted(imports, compareImportOrExportSpecifiers);
|
|
}
|
|
function getImportDeclarationInsertionIndex(sortedImports, newImport) {
|
|
const index = binarySearch(sortedImports, newImport, identity, compareImportsOrRequireStatements);
|
|
return index < 0 ? ~index : index;
|
|
}
|
|
function getImportSpecifierInsertionIndex(sortedImports, newImport) {
|
|
const index = binarySearch(sortedImports, newImport, identity, compareImportOrExportSpecifiers);
|
|
return index < 0 ? ~index : index;
|
|
}
|
|
function compareImportsOrRequireStatements(s1, s2) {
|
|
return compareModuleSpecifiers2(getModuleSpecifierExpression(s1), getModuleSpecifierExpression(s2)) || compareImportKind(s1, s2);
|
|
}
|
|
function compareImportKind(s1, s2) {
|
|
return compareValues(getImportKindOrder(s1), getImportKindOrder(s2));
|
|
}
|
|
function getImportKindOrder(s1) {
|
|
var _a2;
|
|
switch (s1.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
if (!s1.importClause)
|
|
return 0;
|
|
if (s1.importClause.isTypeOnly)
|
|
return 1;
|
|
if (((_a2 = s1.importClause.namedBindings) == null ? void 0 : _a2.kind) === 271 /* NamespaceImport */)
|
|
return 2;
|
|
if (s1.importClause.name)
|
|
return 3;
|
|
return 4;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return 5;
|
|
case 240 /* VariableStatement */:
|
|
return 6;
|
|
}
|
|
}
|
|
function getNewImportSpecifiers(namedImports) {
|
|
return flatMap(
|
|
namedImports,
|
|
(namedImport) => map(
|
|
tryGetNamedBindingElements(namedImport),
|
|
(importSpecifier) => importSpecifier.name && importSpecifier.propertyName && importSpecifier.name.escapedText === importSpecifier.propertyName.escapedText ? factory.updateImportSpecifier(importSpecifier, importSpecifier.isTypeOnly, void 0, importSpecifier.name) : importSpecifier
|
|
)
|
|
);
|
|
}
|
|
function tryGetNamedBindingElements(namedImport) {
|
|
var _a2;
|
|
return ((_a2 = namedImport.importClause) == null ? void 0 : _a2.namedBindings) && isNamedImports(namedImport.importClause.namedBindings) ? namedImport.importClause.namedBindings.elements : void 0;
|
|
}
|
|
|
|
// src/services/_namespaces/ts.OutliningElementsCollector.ts
|
|
var ts_OutliningElementsCollector_exports = {};
|
|
__export(ts_OutliningElementsCollector_exports, {
|
|
collectElements: () => collectElements
|
|
});
|
|
|
|
// src/services/outliningElementsCollector.ts
|
|
function collectElements(sourceFile, cancellationToken) {
|
|
const res = [];
|
|
addNodeOutliningSpans(sourceFile, cancellationToken, res);
|
|
addRegionOutliningSpans(sourceFile, res);
|
|
return res.sort((span1, span2) => span1.textSpan.start - span2.textSpan.start);
|
|
}
|
|
function addNodeOutliningSpans(sourceFile, cancellationToken, out) {
|
|
let depthRemaining = 40;
|
|
let current = 0;
|
|
const statements = [...sourceFile.statements, sourceFile.endOfFileToken];
|
|
const n = statements.length;
|
|
while (current < n) {
|
|
while (current < n && !isAnyImportSyntax(statements[current])) {
|
|
visitNonImportNode(statements[current]);
|
|
current++;
|
|
}
|
|
if (current === n)
|
|
break;
|
|
const firstImport = current;
|
|
while (current < n && isAnyImportSyntax(statements[current])) {
|
|
addOutliningForLeadingCommentsForNode(statements[current], sourceFile, cancellationToken, out);
|
|
current++;
|
|
}
|
|
const lastImport = current - 1;
|
|
if (lastImport !== firstImport) {
|
|
out.push(createOutliningSpanFromBounds(findChildOfKind(statements[firstImport], 100 /* ImportKeyword */, sourceFile).getStart(sourceFile), statements[lastImport].getEnd(), "imports" /* Imports */));
|
|
}
|
|
}
|
|
function visitNonImportNode(n2) {
|
|
var _a2;
|
|
if (depthRemaining === 0)
|
|
return;
|
|
cancellationToken.throwIfCancellationRequested();
|
|
if (isDeclaration(n2) || isVariableStatement(n2) || isReturnStatement(n2) || isCallOrNewExpression(n2) || n2.kind === 1 /* EndOfFileToken */) {
|
|
addOutliningForLeadingCommentsForNode(n2, sourceFile, cancellationToken, out);
|
|
}
|
|
if (isFunctionLike(n2) && isBinaryExpression(n2.parent) && isPropertyAccessExpression(n2.parent.left)) {
|
|
addOutliningForLeadingCommentsForNode(n2.parent.left, sourceFile, cancellationToken, out);
|
|
}
|
|
if (isBlock(n2) || isModuleBlock(n2)) {
|
|
addOutliningForLeadingCommentsForPos(n2.statements.end, sourceFile, cancellationToken, out);
|
|
}
|
|
if (isClassLike(n2) || isInterfaceDeclaration(n2)) {
|
|
addOutliningForLeadingCommentsForPos(n2.members.end, sourceFile, cancellationToken, out);
|
|
}
|
|
const span = getOutliningSpanForNode(n2, sourceFile);
|
|
if (span)
|
|
out.push(span);
|
|
depthRemaining--;
|
|
if (isCallExpression(n2)) {
|
|
depthRemaining++;
|
|
visitNonImportNode(n2.expression);
|
|
depthRemaining--;
|
|
n2.arguments.forEach(visitNonImportNode);
|
|
(_a2 = n2.typeArguments) == null ? void 0 : _a2.forEach(visitNonImportNode);
|
|
} else if (isIfStatement(n2) && n2.elseStatement && isIfStatement(n2.elseStatement)) {
|
|
visitNonImportNode(n2.expression);
|
|
visitNonImportNode(n2.thenStatement);
|
|
depthRemaining++;
|
|
visitNonImportNode(n2.elseStatement);
|
|
depthRemaining--;
|
|
} else {
|
|
n2.forEachChild(visitNonImportNode);
|
|
}
|
|
depthRemaining++;
|
|
}
|
|
}
|
|
function addRegionOutliningSpans(sourceFile, out) {
|
|
const regions = [];
|
|
const lineStarts = sourceFile.getLineStarts();
|
|
for (const currentLineStart of lineStarts) {
|
|
const lineEnd = sourceFile.getLineEndOfPosition(currentLineStart);
|
|
const lineText = sourceFile.text.substring(currentLineStart, lineEnd);
|
|
const result = isRegionDelimiter(lineText);
|
|
if (!result || isInComment(sourceFile, currentLineStart)) {
|
|
continue;
|
|
}
|
|
if (!result[1]) {
|
|
const span = createTextSpanFromBounds(sourceFile.text.indexOf("//", currentLineStart), lineEnd);
|
|
regions.push(createOutliningSpan(span, "region" /* Region */, span, false, result[2] || "#region"));
|
|
} else {
|
|
const region = regions.pop();
|
|
if (region) {
|
|
region.textSpan.length = lineEnd - region.textSpan.start;
|
|
region.hintSpan.length = lineEnd - region.textSpan.start;
|
|
out.push(region);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
var regionDelimiterRegExp = /^#(end)?region(?:\s+(.*))?(?:\r)?$/;
|
|
function isRegionDelimiter(lineText) {
|
|
lineText = trimStringStart(lineText);
|
|
if (!startsWith(lineText, "//")) {
|
|
return null;
|
|
}
|
|
lineText = trimString(lineText.slice(2));
|
|
return regionDelimiterRegExp.exec(lineText);
|
|
}
|
|
function addOutliningForLeadingCommentsForPos(pos, sourceFile, cancellationToken, out) {
|
|
const comments = getLeadingCommentRanges(sourceFile.text, pos);
|
|
if (!comments)
|
|
return;
|
|
let firstSingleLineCommentStart = -1;
|
|
let lastSingleLineCommentEnd = -1;
|
|
let singleLineCommentCount = 0;
|
|
const sourceText = sourceFile.getFullText();
|
|
for (const { kind, pos: pos2, end } of comments) {
|
|
cancellationToken.throwIfCancellationRequested();
|
|
switch (kind) {
|
|
case 2 /* SingleLineCommentTrivia */:
|
|
const commentText = sourceText.slice(pos2, end);
|
|
if (isRegionDelimiter(commentText)) {
|
|
combineAndAddMultipleSingleLineComments();
|
|
singleLineCommentCount = 0;
|
|
break;
|
|
}
|
|
if (singleLineCommentCount === 0) {
|
|
firstSingleLineCommentStart = pos2;
|
|
}
|
|
lastSingleLineCommentEnd = end;
|
|
singleLineCommentCount++;
|
|
break;
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
combineAndAddMultipleSingleLineComments();
|
|
out.push(createOutliningSpanFromBounds(pos2, end, "comment" /* Comment */));
|
|
singleLineCommentCount = 0;
|
|
break;
|
|
default:
|
|
Debug.assertNever(kind);
|
|
}
|
|
}
|
|
combineAndAddMultipleSingleLineComments();
|
|
function combineAndAddMultipleSingleLineComments() {
|
|
if (singleLineCommentCount > 1) {
|
|
out.push(createOutliningSpanFromBounds(firstSingleLineCommentStart, lastSingleLineCommentEnd, "comment" /* Comment */));
|
|
}
|
|
}
|
|
}
|
|
function addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out) {
|
|
if (isJsxText(n))
|
|
return;
|
|
addOutliningForLeadingCommentsForPos(n.pos, sourceFile, cancellationToken, out);
|
|
}
|
|
function createOutliningSpanFromBounds(pos, end, kind) {
|
|
return createOutliningSpan(createTextSpanFromBounds(pos, end), kind);
|
|
}
|
|
function getOutliningSpanForNode(n, sourceFile) {
|
|
switch (n.kind) {
|
|
case 238 /* Block */:
|
|
if (isFunctionLike(n.parent)) {
|
|
return functionSpan(n.parent, n, sourceFile);
|
|
}
|
|
switch (n.parent.kind) {
|
|
case 243 /* DoStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 295 /* CatchClause */:
|
|
return spanForNode(n.parent);
|
|
case 255 /* TryStatement */:
|
|
const tryStatement = n.parent;
|
|
if (tryStatement.tryBlock === n) {
|
|
return spanForNode(n.parent);
|
|
} else if (tryStatement.finallyBlock === n) {
|
|
const node = findChildOfKind(tryStatement, 96 /* FinallyKeyword */, sourceFile);
|
|
if (node)
|
|
return spanForNode(node);
|
|
}
|
|
default:
|
|
return createOutliningSpan(createTextSpanFromNode(n, sourceFile), "code" /* Code */);
|
|
}
|
|
case 265 /* ModuleBlock */:
|
|
return spanForNode(n.parent);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 266 /* CaseBlock */:
|
|
case 184 /* TypeLiteral */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
return spanForNode(n);
|
|
case 186 /* TupleType */:
|
|
return spanForNode(n, false, !isTupleTypeNode(n.parent), 22 /* OpenBracketToken */);
|
|
case 292 /* CaseClause */:
|
|
case 293 /* DefaultClause */:
|
|
return spanForNodeArray(n.statements);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return spanForObjectOrArrayLiteral(n);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return spanForObjectOrArrayLiteral(n, 22 /* OpenBracketToken */);
|
|
case 281 /* JsxElement */:
|
|
return spanForJSXElement(n);
|
|
case 285 /* JsxFragment */:
|
|
return spanForJSXFragment(n);
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 283 /* JsxOpeningElement */:
|
|
return spanForJSXAttributes(n.attributes);
|
|
case 225 /* TemplateExpression */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
return spanForTemplateLiteral(n);
|
|
case 204 /* ArrayBindingPattern */:
|
|
return spanForNode(n, false, !isBindingElement(n.parent), 22 /* OpenBracketToken */);
|
|
case 216 /* ArrowFunction */:
|
|
return spanForArrowFunction(n);
|
|
case 210 /* CallExpression */:
|
|
return spanForCallExpression(n);
|
|
case 214 /* ParenthesizedExpression */:
|
|
return spanForParenthesizedExpression(n);
|
|
}
|
|
function spanForCallExpression(node) {
|
|
if (!node.arguments.length) {
|
|
return void 0;
|
|
}
|
|
const openToken = findChildOfKind(node, 20 /* OpenParenToken */, sourceFile);
|
|
const closeToken = findChildOfKind(node, 21 /* CloseParenToken */, sourceFile);
|
|
if (!openToken || !closeToken || positionsAreOnSameLine(openToken.pos, closeToken.pos, sourceFile)) {
|
|
return void 0;
|
|
}
|
|
return spanBetweenTokens(openToken, closeToken, node, sourceFile, false, true);
|
|
}
|
|
function spanForArrowFunction(node) {
|
|
if (isBlock(node.body) || isParenthesizedExpression(node.body) || positionsAreOnSameLine(node.body.getFullStart(), node.body.getEnd(), sourceFile)) {
|
|
return void 0;
|
|
}
|
|
const textSpan = createTextSpanFromBounds(node.body.getFullStart(), node.body.getEnd());
|
|
return createOutliningSpan(textSpan, "code" /* Code */, createTextSpanFromNode(node));
|
|
}
|
|
function spanForJSXElement(node) {
|
|
const textSpan = createTextSpanFromBounds(node.openingElement.getStart(sourceFile), node.closingElement.getEnd());
|
|
const tagName = node.openingElement.tagName.getText(sourceFile);
|
|
const bannerText = "<" + tagName + ">...</" + tagName + ">";
|
|
return createOutliningSpan(textSpan, "code" /* Code */, textSpan, false, bannerText);
|
|
}
|
|
function spanForJSXFragment(node) {
|
|
const textSpan = createTextSpanFromBounds(node.openingFragment.getStart(sourceFile), node.closingFragment.getEnd());
|
|
const bannerText = "<>...</>";
|
|
return createOutliningSpan(textSpan, "code" /* Code */, textSpan, false, bannerText);
|
|
}
|
|
function spanForJSXAttributes(node) {
|
|
if (node.properties.length === 0) {
|
|
return void 0;
|
|
}
|
|
return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* Code */);
|
|
}
|
|
function spanForTemplateLiteral(node) {
|
|
if (node.kind === 14 /* NoSubstitutionTemplateLiteral */ && node.text.length === 0) {
|
|
return void 0;
|
|
}
|
|
return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* Code */);
|
|
}
|
|
function spanForObjectOrArrayLiteral(node, open = 18 /* OpenBraceToken */) {
|
|
return spanForNode(node, false, !isArrayLiteralExpression(node.parent) && !isCallExpression(node.parent), open);
|
|
}
|
|
function spanForNode(hintSpanNode, autoCollapse = false, useFullStart = true, open = 18 /* OpenBraceToken */, close2 = open === 18 /* OpenBraceToken */ ? 19 /* CloseBraceToken */ : 23 /* CloseBracketToken */) {
|
|
const openToken = findChildOfKind(n, open, sourceFile);
|
|
const closeToken = findChildOfKind(n, close2, sourceFile);
|
|
return openToken && closeToken && spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse, useFullStart);
|
|
}
|
|
function spanForNodeArray(nodeArray) {
|
|
return nodeArray.length ? createOutliningSpan(createTextSpanFromRange(nodeArray), "code" /* Code */) : void 0;
|
|
}
|
|
function spanForParenthesizedExpression(node) {
|
|
if (positionsAreOnSameLine(node.getStart(), node.getEnd(), sourceFile))
|
|
return void 0;
|
|
const textSpan = createTextSpanFromBounds(node.getStart(), node.getEnd());
|
|
return createOutliningSpan(textSpan, "code" /* Code */, createTextSpanFromNode(node));
|
|
}
|
|
}
|
|
function functionSpan(node, body, sourceFile) {
|
|
const openToken = tryGetFunctionOpenToken(node, body, sourceFile);
|
|
const closeToken = findChildOfKind(body, 19 /* CloseBraceToken */, sourceFile);
|
|
return openToken && closeToken && spanBetweenTokens(openToken, closeToken, node, sourceFile, node.kind !== 216 /* ArrowFunction */);
|
|
}
|
|
function spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse = false, useFullStart = true) {
|
|
const textSpan = createTextSpanFromBounds(useFullStart ? openToken.getFullStart() : openToken.getStart(sourceFile), closeToken.getEnd());
|
|
return createOutliningSpan(textSpan, "code" /* Code */, createTextSpanFromNode(hintSpanNode, sourceFile), autoCollapse);
|
|
}
|
|
function createOutliningSpan(textSpan, kind, hintSpan = textSpan, autoCollapse = false, bannerText = "...") {
|
|
return { textSpan, kind, hintSpan, bannerText, autoCollapse };
|
|
}
|
|
function tryGetFunctionOpenToken(node, body, sourceFile) {
|
|
if (isNodeArrayMultiLine(node.parameters, sourceFile)) {
|
|
const openParenToken = findChildOfKind(node, 20 /* OpenParenToken */, sourceFile);
|
|
if (openParenToken) {
|
|
return openParenToken;
|
|
}
|
|
}
|
|
return findChildOfKind(body, 18 /* OpenBraceToken */, sourceFile);
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.ts
|
|
var ts_refactor_exports = {};
|
|
__export(ts_refactor_exports, {
|
|
addOrRemoveBracesToArrowFunction: () => ts_refactor_addOrRemoveBracesToArrowFunction_exports,
|
|
convertArrowFunctionOrFunctionExpression: () => ts_refactor_convertArrowFunctionOrFunctionExpression_exports,
|
|
convertParamsToDestructuredObject: () => ts_refactor_convertParamsToDestructuredObject_exports,
|
|
convertStringOrTemplateLiteral: () => ts_refactor_convertStringOrTemplateLiteral_exports,
|
|
convertToOptionalChainExpression: () => ts_refactor_convertToOptionalChainExpression_exports,
|
|
doChangeNamedToNamespaceOrDefault: () => doChangeNamedToNamespaceOrDefault,
|
|
extractSymbol: () => ts_refactor_extractSymbol_exports,
|
|
generateGetAccessorAndSetAccessor: () => ts_refactor_generateGetAccessorAndSetAccessor_exports,
|
|
getApplicableRefactors: () => getApplicableRefactors,
|
|
getEditsForRefactor: () => getEditsForRefactor,
|
|
inferFunctionReturnType: () => ts_refactor_inferFunctionReturnType_exports,
|
|
isRefactorErrorInfo: () => isRefactorErrorInfo,
|
|
refactorKindBeginsWith: () => refactorKindBeginsWith,
|
|
registerRefactor: () => registerRefactor
|
|
});
|
|
|
|
// src/services/refactorProvider.ts
|
|
var refactors = /* @__PURE__ */ new Map();
|
|
function registerRefactor(name, refactor) {
|
|
refactors.set(name, refactor);
|
|
}
|
|
function getApplicableRefactors(context) {
|
|
return arrayFrom(flatMapIterator(refactors.values(), (refactor) => {
|
|
var _a2;
|
|
return context.cancellationToken && context.cancellationToken.isCancellationRequested() || !((_a2 = refactor.kinds) == null ? void 0 : _a2.some((kind) => refactorKindBeginsWith(kind, context.kind))) ? void 0 : refactor.getAvailableActions(context);
|
|
}));
|
|
}
|
|
function getEditsForRefactor(context, refactorName13, actionName2) {
|
|
const refactor = refactors.get(refactorName13);
|
|
return refactor && refactor.getEditsForAction(context, actionName2);
|
|
}
|
|
|
|
// src/services/refactors/convertExport.ts
|
|
var refactorName = "Convert export";
|
|
var defaultToNamedAction = {
|
|
name: "Convert default export to named export",
|
|
description: Diagnostics.Convert_default_export_to_named_export.message,
|
|
kind: "refactor.rewrite.export.named"
|
|
};
|
|
var namedToDefaultAction = {
|
|
name: "Convert named export to default export",
|
|
description: Diagnostics.Convert_named_export_to_default_export.message,
|
|
kind: "refactor.rewrite.export.default"
|
|
};
|
|
registerRefactor(refactorName, {
|
|
kinds: [
|
|
defaultToNamedAction.kind,
|
|
namedToDefaultAction.kind
|
|
],
|
|
getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndDefaultExports(context) {
|
|
const info = getInfo19(context, context.triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
const action = info.wasDefault ? defaultToNamedAction : namedToDefaultAction;
|
|
return [{ name: refactorName, description: action.description, actions: [action] }];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [
|
|
{ name: refactorName, description: Diagnostics.Convert_default_export_to_named_export.message, actions: [
|
|
{ ...defaultToNamedAction, notApplicableReason: info.error },
|
|
{ ...namedToDefaultAction, notApplicableReason: info.error }
|
|
] }
|
|
];
|
|
}
|
|
return emptyArray;
|
|
},
|
|
getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndDefaultExports(context, actionName2) {
|
|
Debug.assert(actionName2 === defaultToNamedAction.name || actionName2 === namedToDefaultAction.name, "Unexpected action name");
|
|
const info = getInfo19(context);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange33(context.file, context.program, info, t, context.cancellationToken));
|
|
return { edits, renameFilename: void 0, renameLocation: void 0 };
|
|
}
|
|
});
|
|
function getInfo19(context, considerPartialSpans = true) {
|
|
const { file, program } = context;
|
|
const span = getRefactorContextSpan(context);
|
|
const token = getTokenAtPosition(file, span.start);
|
|
const exportNode = !!(token.parent && getSyntacticModifierFlags(token.parent) & 1 /* Export */) && considerPartialSpans ? token.parent : getParentNodeInSpan(token, file, span);
|
|
if (!exportNode || !isSourceFile(exportNode.parent) && !(isModuleBlock(exportNode.parent) && isAmbientModule(exportNode.parent.parent))) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_export_statement) };
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const exportingModuleSymbol = getExportingModuleSymbol(exportNode, checker);
|
|
const flags = getSyntacticModifierFlags(exportNode) || (isExportAssignment(exportNode) && !exportNode.isExportEquals ? 1025 /* ExportDefault */ : 0 /* None */);
|
|
const wasDefault = !!(flags & 1024 /* Default */);
|
|
if (!(flags & 1 /* Export */) || !wasDefault && exportingModuleSymbol.exports.has("default" /* Default */)) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.This_file_already_has_a_default_export) };
|
|
}
|
|
const noSymbolError = (id) => isIdentifier(id) && checker.getSymbolAtLocation(id) ? void 0 : { error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_named_export) };
|
|
switch (exportNode.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 264 /* ModuleDeclaration */: {
|
|
const node = exportNode;
|
|
if (!node.name)
|
|
return void 0;
|
|
return noSymbolError(node.name) || { exportNode: node, exportName: node.name, wasDefault, exportingModuleSymbol };
|
|
}
|
|
case 240 /* VariableStatement */: {
|
|
const vs = exportNode;
|
|
if (!(vs.declarationList.flags & 2 /* Const */) || vs.declarationList.declarations.length !== 1) {
|
|
return void 0;
|
|
}
|
|
const decl = first(vs.declarationList.declarations);
|
|
if (!decl.initializer)
|
|
return void 0;
|
|
Debug.assert(!wasDefault, "Can't have a default flag here");
|
|
return noSymbolError(decl.name) || { exportNode: vs, exportName: decl.name, wasDefault, exportingModuleSymbol };
|
|
}
|
|
case 274 /* ExportAssignment */: {
|
|
const node = exportNode;
|
|
if (node.isExportEquals)
|
|
return void 0;
|
|
return noSymbolError(node.expression) || { exportNode: node, exportName: node.expression, wasDefault, exportingModuleSymbol };
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function doChange33(exportingSourceFile, program, info, changes, cancellationToken) {
|
|
changeExport(exportingSourceFile, info, changes, program.getTypeChecker());
|
|
changeImports(program, info, changes, cancellationToken);
|
|
}
|
|
function changeExport(exportingSourceFile, { wasDefault, exportNode, exportName }, changes, checker) {
|
|
if (wasDefault) {
|
|
if (isExportAssignment(exportNode) && !exportNode.isExportEquals) {
|
|
const exp = exportNode.expression;
|
|
const spec = makeExportSpecifier(exp.text, exp.text);
|
|
changes.replaceNode(exportingSourceFile, exportNode, factory.createExportDeclaration(void 0, false, factory.createNamedExports([spec])));
|
|
} else {
|
|
changes.delete(exportingSourceFile, Debug.checkDefined(findModifier(exportNode, 88 /* DefaultKeyword */), "Should find a default keyword in modifier list"));
|
|
}
|
|
} else {
|
|
const exportKeyword = Debug.checkDefined(findModifier(exportNode, 93 /* ExportKeyword */), "Should find an export keyword in modifier list");
|
|
switch (exportNode.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
changes.insertNodeAfter(exportingSourceFile, exportKeyword, factory.createToken(88 /* DefaultKeyword */));
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
const decl = first(exportNode.declarationList.declarations);
|
|
if (!ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(exportName, checker, exportingSourceFile) && !decl.type) {
|
|
changes.replaceNode(exportingSourceFile, exportNode, factory.createExportDefault(Debug.checkDefined(decl.initializer, "Initializer was previously known to be present")));
|
|
break;
|
|
}
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
changes.deleteModifier(exportingSourceFile, exportKeyword);
|
|
changes.insertNodeAfter(exportingSourceFile, exportNode, factory.createExportDefault(factory.createIdentifier(exportName.text)));
|
|
break;
|
|
default:
|
|
Debug.fail(`Unexpected exportNode kind ${exportNode.kind}`);
|
|
}
|
|
}
|
|
}
|
|
function changeImports(program, { wasDefault, exportName, exportingModuleSymbol }, changes, cancellationToken) {
|
|
const checker = program.getTypeChecker();
|
|
const exportSymbol = Debug.checkDefined(checker.getSymbolAtLocation(exportName), "Export name should resolve to a symbol");
|
|
ts_FindAllReferences_exports.Core.eachExportReference(program.getSourceFiles(), checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName.text, wasDefault, (ref) => {
|
|
if (exportName === ref)
|
|
return;
|
|
const importingSourceFile = ref.getSourceFile();
|
|
if (wasDefault) {
|
|
changeDefaultToNamedImport(importingSourceFile, ref, changes, exportName.text);
|
|
} else {
|
|
changeNamedToDefaultImport(importingSourceFile, ref, changes);
|
|
}
|
|
});
|
|
}
|
|
function changeDefaultToNamedImport(importingSourceFile, ref, changes, exportName) {
|
|
const { parent: parent2 } = ref;
|
|
switch (parent2.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
changes.replaceNode(importingSourceFile, ref, factory.createIdentifier(exportName));
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
case 278 /* ExportSpecifier */: {
|
|
const spec = parent2;
|
|
changes.replaceNode(importingSourceFile, spec, makeImportSpecifier2(exportName, spec.name.text));
|
|
break;
|
|
}
|
|
case 270 /* ImportClause */: {
|
|
const clause = parent2;
|
|
Debug.assert(clause.name === ref, "Import clause name should match provided ref");
|
|
const spec = makeImportSpecifier2(exportName, ref.text);
|
|
const { namedBindings } = clause;
|
|
if (!namedBindings) {
|
|
changes.replaceNode(importingSourceFile, ref, factory.createNamedImports([spec]));
|
|
} else if (namedBindings.kind === 271 /* NamespaceImport */) {
|
|
changes.deleteRange(importingSourceFile, { pos: ref.getStart(importingSourceFile), end: namedBindings.getStart(importingSourceFile) });
|
|
const quotePreference = isStringLiteral(clause.parent.moduleSpecifier) ? quotePreferenceFromString(clause.parent.moduleSpecifier, importingSourceFile) : 1 /* Double */;
|
|
const newImport = makeImport(void 0, [makeImportSpecifier2(exportName, ref.text)], clause.parent.moduleSpecifier, quotePreference);
|
|
changes.insertNodeAfter(importingSourceFile, clause.parent, newImport);
|
|
} else {
|
|
changes.delete(importingSourceFile, ref);
|
|
changes.insertNodeAtEndOfList(importingSourceFile, namedBindings.elements, spec);
|
|
}
|
|
break;
|
|
}
|
|
case 202 /* ImportType */:
|
|
const importTypeNode = parent2;
|
|
changes.replaceNode(importingSourceFile, parent2, factory.createImportTypeNode(importTypeNode.argument, importTypeNode.assertions, factory.createIdentifier(exportName), importTypeNode.typeArguments, importTypeNode.isTypeOf));
|
|
break;
|
|
default:
|
|
Debug.failBadSyntaxKind(parent2);
|
|
}
|
|
}
|
|
function changeNamedToDefaultImport(importingSourceFile, ref, changes) {
|
|
const parent2 = ref.parent;
|
|
switch (parent2.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
changes.replaceNode(importingSourceFile, ref, factory.createIdentifier("default"));
|
|
break;
|
|
case 273 /* ImportSpecifier */: {
|
|
const defaultImport = factory.createIdentifier(parent2.name.text);
|
|
if (parent2.parent.elements.length === 1) {
|
|
changes.replaceNode(importingSourceFile, parent2.parent, defaultImport);
|
|
} else {
|
|
changes.delete(importingSourceFile, parent2);
|
|
changes.insertNodeBefore(importingSourceFile, parent2.parent, defaultImport);
|
|
}
|
|
break;
|
|
}
|
|
case 278 /* ExportSpecifier */: {
|
|
changes.replaceNode(importingSourceFile, parent2, makeExportSpecifier("default", parent2.name.text));
|
|
break;
|
|
}
|
|
default:
|
|
Debug.assertNever(parent2, `Unexpected parent kind ${parent2.kind}`);
|
|
}
|
|
}
|
|
function makeImportSpecifier2(propertyName, name) {
|
|
return factory.createImportSpecifier(false, propertyName === name ? void 0 : factory.createIdentifier(propertyName), factory.createIdentifier(name));
|
|
}
|
|
function makeExportSpecifier(propertyName, name) {
|
|
return factory.createExportSpecifier(false, propertyName === name ? void 0 : factory.createIdentifier(propertyName), factory.createIdentifier(name));
|
|
}
|
|
function getExportingModuleSymbol(node, checker) {
|
|
const parent2 = node.parent;
|
|
if (isSourceFile(parent2)) {
|
|
return parent2.symbol;
|
|
}
|
|
const symbol = parent2.parent.symbol;
|
|
if (symbol.valueDeclaration && isExternalModuleAugmentation(symbol.valueDeclaration)) {
|
|
return checker.getMergedSymbol(symbol);
|
|
}
|
|
return symbol;
|
|
}
|
|
|
|
// src/services/refactors/convertImport.ts
|
|
var refactorName2 = "Convert import";
|
|
var actions = {
|
|
[0 /* Named */]: {
|
|
name: "Convert namespace import to named imports",
|
|
description: Diagnostics.Convert_namespace_import_to_named_imports.message,
|
|
kind: "refactor.rewrite.import.named"
|
|
},
|
|
[2 /* Namespace */]: {
|
|
name: "Convert named imports to namespace import",
|
|
description: Diagnostics.Convert_named_imports_to_namespace_import.message,
|
|
kind: "refactor.rewrite.import.namespace"
|
|
},
|
|
[1 /* Default */]: {
|
|
name: "Convert named imports to default import",
|
|
description: Diagnostics.Convert_named_imports_to_default_import.message,
|
|
kind: "refactor.rewrite.import.default"
|
|
}
|
|
};
|
|
registerRefactor(refactorName2, {
|
|
kinds: getOwnValues(actions).map((a) => a.kind),
|
|
getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) {
|
|
const info = getImportConversionInfo(context, context.triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
const action = actions[info.convertTo];
|
|
return [{ name: refactorName2, description: action.description, actions: [action] }];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return getOwnValues(actions).map((action) => ({
|
|
name: refactorName2,
|
|
description: action.description,
|
|
actions: [{ ...action, notApplicableReason: info.error }]
|
|
}));
|
|
}
|
|
return emptyArray;
|
|
},
|
|
getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName2) {
|
|
Debug.assert(some(getOwnValues(actions), (action) => action.name === actionName2), "Unexpected action name");
|
|
const info = getImportConversionInfo(context);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange34(context.file, context.program, t, info));
|
|
return { edits, renameFilename: void 0, renameLocation: void 0 };
|
|
}
|
|
});
|
|
function getImportConversionInfo(context, considerPartialSpans = true) {
|
|
const { file } = context;
|
|
const span = getRefactorContextSpan(context);
|
|
const token = getTokenAtPosition(file, span.start);
|
|
const importDecl = considerPartialSpans ? findAncestor(token, isImportDeclaration) : getParentNodeInSpan(token, file, span);
|
|
if (!importDecl || !isImportDeclaration(importDecl))
|
|
return { error: "Selection is not an import declaration." };
|
|
const end = span.start + span.length;
|
|
const nextToken = findNextToken(importDecl, importDecl.parent, file);
|
|
if (nextToken && end > nextToken.getStart())
|
|
return void 0;
|
|
const { importClause } = importDecl;
|
|
if (!importClause) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_import_clause) };
|
|
}
|
|
if (!importClause.namedBindings) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_namespace_import_or_named_imports) };
|
|
}
|
|
if (importClause.namedBindings.kind === 271 /* NamespaceImport */) {
|
|
return { convertTo: 0 /* Named */, import: importClause.namedBindings };
|
|
}
|
|
const shouldUseDefault = getShouldUseDefault(context.program, importClause);
|
|
return shouldUseDefault ? { convertTo: 1 /* Default */, import: importClause.namedBindings } : { convertTo: 2 /* Namespace */, import: importClause.namedBindings };
|
|
}
|
|
function getShouldUseDefault(program, importClause) {
|
|
return getAllowSyntheticDefaultImports(program.getCompilerOptions()) && isExportEqualsModule(importClause.parent.moduleSpecifier, program.getTypeChecker());
|
|
}
|
|
function doChange34(sourceFile, program, changes, info) {
|
|
const checker = program.getTypeChecker();
|
|
if (info.convertTo === 0 /* Named */) {
|
|
doChangeNamespaceToNamed(sourceFile, checker, changes, info.import, getAllowSyntheticDefaultImports(program.getCompilerOptions()));
|
|
} else {
|
|
doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, info.import, info.convertTo === 1 /* Default */);
|
|
}
|
|
}
|
|
function doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert, allowSyntheticDefaultImports) {
|
|
let usedAsNamespaceOrDefault = false;
|
|
const nodesToReplace = [];
|
|
const conflictingNames = /* @__PURE__ */ new Map();
|
|
ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(toConvert.name, checker, sourceFile, (id) => {
|
|
if (!isPropertyAccessOrQualifiedName(id.parent)) {
|
|
usedAsNamespaceOrDefault = true;
|
|
} else {
|
|
const exportName = getRightOfPropertyAccessOrQualifiedName(id.parent).text;
|
|
if (checker.resolveName(exportName, id, 67108863 /* All */, true)) {
|
|
conflictingNames.set(exportName, true);
|
|
}
|
|
Debug.assert(getLeftOfPropertyAccessOrQualifiedName(id.parent) === id, "Parent expression should match id");
|
|
nodesToReplace.push(id.parent);
|
|
}
|
|
});
|
|
const exportNameToImportName = /* @__PURE__ */ new Map();
|
|
for (const propertyAccessOrQualifiedName of nodesToReplace) {
|
|
const exportName = getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName).text;
|
|
let importName = exportNameToImportName.get(exportName);
|
|
if (importName === void 0) {
|
|
exportNameToImportName.set(exportName, importName = conflictingNames.has(exportName) ? getUniqueName(exportName, sourceFile) : exportName);
|
|
}
|
|
changes.replaceNode(sourceFile, propertyAccessOrQualifiedName, factory.createIdentifier(importName));
|
|
}
|
|
const importSpecifiers = [];
|
|
exportNameToImportName.forEach((name, propertyName) => {
|
|
importSpecifiers.push(factory.createImportSpecifier(false, name === propertyName ? void 0 : factory.createIdentifier(propertyName), factory.createIdentifier(name)));
|
|
});
|
|
const importDecl = toConvert.parent.parent;
|
|
if (usedAsNamespaceOrDefault && !allowSyntheticDefaultImports) {
|
|
changes.insertNodeAfter(sourceFile, importDecl, updateImport(importDecl, void 0, importSpecifiers));
|
|
} else {
|
|
changes.replaceNode(sourceFile, importDecl, updateImport(importDecl, usedAsNamespaceOrDefault ? factory.createIdentifier(toConvert.name.text) : void 0, importSpecifiers));
|
|
}
|
|
}
|
|
function getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) {
|
|
return isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.name : propertyAccessOrQualifiedName.right;
|
|
}
|
|
function getLeftOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) {
|
|
return isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.expression : propertyAccessOrQualifiedName.left;
|
|
}
|
|
function doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, toConvert, shouldUseDefault = getShouldUseDefault(program, toConvert.parent)) {
|
|
const checker = program.getTypeChecker();
|
|
const importDecl = toConvert.parent.parent;
|
|
const { moduleSpecifier } = importDecl;
|
|
const toConvertSymbols = /* @__PURE__ */ new Set();
|
|
toConvert.elements.forEach((namedImport) => {
|
|
const symbol = checker.getSymbolAtLocation(namedImport.name);
|
|
if (symbol) {
|
|
toConvertSymbols.add(symbol);
|
|
}
|
|
});
|
|
const preferredName = moduleSpecifier && isStringLiteral(moduleSpecifier) ? ts_codefix_exports.moduleSpecifierToValidIdentifier(moduleSpecifier.text, 99 /* ESNext */) : "module";
|
|
function hasNamespaceNameConflict(namedImport) {
|
|
return !!ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(namedImport.name, checker, sourceFile, (id) => {
|
|
const symbol = checker.resolveName(preferredName, id, 67108863 /* All */, true);
|
|
if (symbol) {
|
|
if (toConvertSymbols.has(symbol)) {
|
|
return isExportSpecifier(id.parent);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
const namespaceNameConflicts = toConvert.elements.some(hasNamespaceNameConflict);
|
|
const namespaceImportName = namespaceNameConflicts ? getUniqueName(preferredName, sourceFile) : preferredName;
|
|
const neededNamedImports = /* @__PURE__ */ new Set();
|
|
for (const element of toConvert.elements) {
|
|
const propertyName = (element.propertyName || element.name).text;
|
|
ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, (id) => {
|
|
const access = factory.createPropertyAccessExpression(factory.createIdentifier(namespaceImportName), propertyName);
|
|
if (isShorthandPropertyAssignment(id.parent)) {
|
|
changes.replaceNode(sourceFile, id.parent, factory.createPropertyAssignment(id.text, access));
|
|
} else if (isExportSpecifier(id.parent)) {
|
|
neededNamedImports.add(element);
|
|
} else {
|
|
changes.replaceNode(sourceFile, id, access);
|
|
}
|
|
});
|
|
}
|
|
changes.replaceNode(sourceFile, toConvert, shouldUseDefault ? factory.createIdentifier(namespaceImportName) : factory.createNamespaceImport(factory.createIdentifier(namespaceImportName)));
|
|
if (neededNamedImports.size) {
|
|
const newNamedImports = arrayFrom(neededNamedImports.values()).map((element) => factory.createImportSpecifier(element.isTypeOnly, element.propertyName && factory.createIdentifier(element.propertyName.text), factory.createIdentifier(element.name.text)));
|
|
changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(importDecl, void 0, newNamedImports));
|
|
}
|
|
}
|
|
function isExportEqualsModule(moduleSpecifier, checker) {
|
|
const externalModule = checker.resolveExternalModuleName(moduleSpecifier);
|
|
if (!externalModule)
|
|
return false;
|
|
const exportEquals = checker.resolveExternalModuleSymbol(externalModule);
|
|
return externalModule !== exportEquals;
|
|
}
|
|
function updateImport(old, defaultImportName, elements) {
|
|
return factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, defaultImportName, elements && elements.length ? factory.createNamedImports(elements) : void 0),
|
|
old.moduleSpecifier,
|
|
void 0
|
|
);
|
|
}
|
|
|
|
// src/services/refactors/extractType.ts
|
|
var refactorName3 = "Extract type";
|
|
var extractToTypeAliasAction = {
|
|
name: "Extract to type alias",
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_to_type_alias),
|
|
kind: "refactor.extract.type"
|
|
};
|
|
var extractToInterfaceAction = {
|
|
name: "Extract to interface",
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_to_interface),
|
|
kind: "refactor.extract.interface"
|
|
};
|
|
var extractToTypeDefAction = {
|
|
name: "Extract to typedef",
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_to_typedef),
|
|
kind: "refactor.extract.typedef"
|
|
};
|
|
registerRefactor(refactorName3, {
|
|
kinds: [
|
|
extractToTypeAliasAction.kind,
|
|
extractToInterfaceAction.kind,
|
|
extractToTypeDefAction.kind
|
|
],
|
|
getAvailableActions: function getRefactorActionsToExtractType(context) {
|
|
const info = getRangeToExtract(context, context.triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
return [{
|
|
name: refactorName3,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_type),
|
|
actions: info.isJS ? [extractToTypeDefAction] : append([extractToTypeAliasAction], info.typeElements && extractToInterfaceAction)
|
|
}];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: refactorName3,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_type),
|
|
actions: [
|
|
{ ...extractToTypeDefAction, notApplicableReason: info.error },
|
|
{ ...extractToTypeAliasAction, notApplicableReason: info.error },
|
|
{ ...extractToInterfaceAction, notApplicableReason: info.error }
|
|
]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
},
|
|
getEditsForAction: function getRefactorEditsToExtractType(context, actionName2) {
|
|
const { file } = context;
|
|
const info = getRangeToExtract(context);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected to find a range to extract");
|
|
const name = getUniqueName("NewType", file);
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (changes) => {
|
|
switch (actionName2) {
|
|
case extractToTypeAliasAction.name:
|
|
Debug.assert(!info.isJS, "Invalid actionName/JS combo");
|
|
return doTypeAliasChange(changes, file, name, info);
|
|
case extractToTypeDefAction.name:
|
|
Debug.assert(info.isJS, "Invalid actionName/JS combo");
|
|
return doTypedefChange(changes, file, name, info);
|
|
case extractToInterfaceAction.name:
|
|
Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo");
|
|
return doInterfaceChange(changes, file, name, info);
|
|
default:
|
|
Debug.fail("Unexpected action name");
|
|
}
|
|
});
|
|
const renameFilename = file.fileName;
|
|
const renameLocation = getRenameLocation(edits, renameFilename, name, false);
|
|
return { edits, renameFilename, renameLocation };
|
|
}
|
|
});
|
|
function getRangeToExtract(context, considerEmptySpans = true) {
|
|
const { file, startPosition } = context;
|
|
const isJS = isSourceFileJS(file);
|
|
const current = getTokenAtPosition(file, startPosition);
|
|
const range = createTextRangeFromSpan(getRefactorContextSpan(context));
|
|
const cursorRequest = range.pos === range.end && considerEmptySpans;
|
|
const selection = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (cursorRequest || nodeOverlapsWithStartEnd(current, file, range.pos, range.end)));
|
|
if (!selection || !isTypeNode(selection))
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) };
|
|
const checker = context.program.getTypeChecker();
|
|
const firstStatement = Debug.checkDefined(findAncestor(selection, isStatement), "Should find a statement");
|
|
const typeParameters = collectTypeParameters(checker, selection, firstStatement, file);
|
|
if (!typeParameters)
|
|
return { error: getLocaleSpecificMessage(Diagnostics.No_type_could_be_extracted_from_this_type_node) };
|
|
const typeElements = flattenTypeLiteralNodeReference(checker, selection);
|
|
return { isJS, selection, firstStatement, typeParameters, typeElements };
|
|
}
|
|
function flattenTypeLiteralNodeReference(checker, node) {
|
|
if (!node)
|
|
return void 0;
|
|
if (isIntersectionTypeNode(node)) {
|
|
const result = [];
|
|
const seen = /* @__PURE__ */ new Map();
|
|
for (const type of node.types) {
|
|
const flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type);
|
|
if (!flattenedTypeMembers || !flattenedTypeMembers.every((type2) => type2.name && addToSeen(seen, getNameFromPropertyName(type2.name)))) {
|
|
return void 0;
|
|
}
|
|
addRange(result, flattenedTypeMembers);
|
|
}
|
|
return result;
|
|
} else if (isParenthesizedTypeNode(node)) {
|
|
return flattenTypeLiteralNodeReference(checker, node.type);
|
|
} else if (isTypeLiteralNode(node)) {
|
|
return node.members;
|
|
}
|
|
return void 0;
|
|
}
|
|
function rangeContainsSkipTrivia(r1, node, file) {
|
|
return rangeContainsStartEnd(r1, skipTrivia(file.text, node.pos), node.end);
|
|
}
|
|
function collectTypeParameters(checker, selection, statement, file) {
|
|
const result = [];
|
|
return visitor(selection) ? void 0 : result;
|
|
function visitor(node) {
|
|
if (isTypeReferenceNode(node)) {
|
|
if (isIdentifier(node.typeName)) {
|
|
const typeName = node.typeName;
|
|
const symbol = checker.resolveName(typeName.text, typeName, 262144 /* TypeParameter */, true);
|
|
for (const decl of (symbol == null ? void 0 : symbol.declarations) || emptyArray) {
|
|
if (isTypeParameterDeclaration(decl) && decl.getSourceFile() === file) {
|
|
if (decl.name.escapedText === typeName.escapedText && rangeContainsSkipTrivia(decl, selection, file)) {
|
|
return true;
|
|
}
|
|
if (rangeContainsSkipTrivia(statement, decl, file) && !rangeContainsSkipTrivia(selection, decl, file)) {
|
|
pushIfUnique(result, decl);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (isInferTypeNode(node)) {
|
|
const conditionalTypeNode = findAncestor(node, (n) => isConditionalTypeNode(n) && rangeContainsSkipTrivia(n.extendsType, node, file));
|
|
if (!conditionalTypeNode || !rangeContainsSkipTrivia(selection, conditionalTypeNode, file)) {
|
|
return true;
|
|
}
|
|
} else if (isTypePredicateNode(node) || isThisTypeNode(node)) {
|
|
const functionLikeNode = findAncestor(node.parent, isFunctionLike);
|
|
if (functionLikeNode && functionLikeNode.type && rangeContainsSkipTrivia(functionLikeNode.type, node, file) && !rangeContainsSkipTrivia(selection, functionLikeNode, file)) {
|
|
return true;
|
|
}
|
|
} else if (isTypeQueryNode(node)) {
|
|
if (isIdentifier(node.exprName)) {
|
|
const symbol = checker.resolveName(node.exprName.text, node.exprName, 111551 /* Value */, false);
|
|
if ((symbol == null ? void 0 : symbol.valueDeclaration) && rangeContainsSkipTrivia(statement, symbol.valueDeclaration, file) && !rangeContainsSkipTrivia(selection, symbol.valueDeclaration, file)) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (isThisIdentifier(node.exprName.left) && !rangeContainsSkipTrivia(selection, node.parent, file)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
|
|
setEmitFlags(node, 1 /* SingleLine */);
|
|
}
|
|
return forEachChild(node, visitor);
|
|
}
|
|
}
|
|
function doTypeAliasChange(changes, file, name, info) {
|
|
const { firstStatement, selection, typeParameters } = info;
|
|
const newTypeNode = factory.createTypeAliasDeclaration(
|
|
void 0,
|
|
name,
|
|
typeParameters.map((id) => factory.updateTypeParameterDeclaration(id, id.modifiers, id.name, id.constraint, void 0)),
|
|
selection
|
|
);
|
|
changes.insertNodeBefore(file, firstStatement, ignoreSourceNewlines(newTypeNode), true);
|
|
changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(id.name, void 0))), { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude, trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.ExcludeWhitespace });
|
|
}
|
|
function doInterfaceChange(changes, file, name, info) {
|
|
var _a2;
|
|
const { firstStatement, selection, typeParameters, typeElements } = info;
|
|
const newTypeNode = factory.createInterfaceDeclaration(
|
|
void 0,
|
|
name,
|
|
typeParameters,
|
|
void 0,
|
|
typeElements
|
|
);
|
|
setTextRange(newTypeNode, (_a2 = typeElements[0]) == null ? void 0 : _a2.parent);
|
|
changes.insertNodeBefore(file, firstStatement, ignoreSourceNewlines(newTypeNode), true);
|
|
changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(id.name, void 0))), { leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.Exclude, trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.ExcludeWhitespace });
|
|
}
|
|
function doTypedefChange(changes, file, name, info) {
|
|
const { firstStatement, selection, typeParameters } = info;
|
|
setEmitFlags(selection, 3072 /* NoComments */ | 4096 /* NoNestedComments */);
|
|
const node = factory.createJSDocTypedefTag(
|
|
factory.createIdentifier("typedef"),
|
|
factory.createJSDocTypeExpression(selection),
|
|
factory.createIdentifier(name)
|
|
);
|
|
const templates = [];
|
|
forEach(typeParameters, (typeParameter) => {
|
|
const constraint = getEffectiveConstraintOfTypeParameter(typeParameter);
|
|
const parameter = factory.createTypeParameterDeclaration(void 0, typeParameter.name);
|
|
const template = factory.createJSDocTemplateTag(
|
|
factory.createIdentifier("template"),
|
|
constraint && cast(constraint, isJSDocTypeExpression),
|
|
[parameter]
|
|
);
|
|
templates.push(template);
|
|
});
|
|
changes.insertNodeBefore(file, firstStatement, factory.createJSDocComment(void 0, factory.createNodeArray(concatenate(templates, [node]))), true);
|
|
changes.replaceNode(file, selection, factory.createTypeReferenceNode(name, typeParameters.map((id) => factory.createTypeReferenceNode(id.name, void 0))));
|
|
}
|
|
|
|
// src/services/refactors/helpers.ts
|
|
function isRefactorErrorInfo(info) {
|
|
return info.error !== void 0;
|
|
}
|
|
function refactorKindBeginsWith(known, requested) {
|
|
if (!requested)
|
|
return true;
|
|
return known.substr(0, requested.length) === requested;
|
|
}
|
|
|
|
// src/services/refactors/moveToNewFile.ts
|
|
var refactorName4 = "Move to a new file";
|
|
var description = getLocaleSpecificMessage(Diagnostics.Move_to_a_new_file);
|
|
var moveToNewFileAction = {
|
|
name: refactorName4,
|
|
description,
|
|
kind: "refactor.move.newFile"
|
|
};
|
|
registerRefactor(refactorName4, {
|
|
kinds: [moveToNewFileAction.kind],
|
|
getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
|
|
const statements = getStatementsToMove(context);
|
|
if (context.preferences.allowTextChangesInNewFiles && statements) {
|
|
return [{ name: refactorName4, description, actions: [moveToNewFileAction] }];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: refactorName4,
|
|
description,
|
|
actions: [{ ...moveToNewFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
},
|
|
getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName2) {
|
|
Debug.assert(actionName2 === refactorName4, "Wrong refactor invoked");
|
|
const statements = Debug.checkDefined(getStatementsToMove(context));
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange35(context.file, context.program, statements, t, context.host, context.preferences));
|
|
return { edits, renameFilename: void 0, renameLocation: void 0 };
|
|
}
|
|
});
|
|
function getRangeToMove(context) {
|
|
const { file } = context;
|
|
const range = createTextRangeFromSpan(getRefactorContextSpan(context));
|
|
const { statements } = file;
|
|
const startNodeIndex = findIndex(statements, (s) => s.end > range.pos);
|
|
if (startNodeIndex === -1)
|
|
return void 0;
|
|
const startStatement = statements[startNodeIndex];
|
|
if (isNamedDeclaration(startStatement) && startStatement.name && rangeContainsRange(startStatement.name, range)) {
|
|
return { toMove: [statements[startNodeIndex]], afterLast: statements[startNodeIndex + 1] };
|
|
}
|
|
if (range.pos > startStatement.getStart(file))
|
|
return void 0;
|
|
const afterEndNodeIndex = findIndex(statements, (s) => s.end > range.end, startNodeIndex);
|
|
if (afterEndNodeIndex !== -1 && (afterEndNodeIndex === 0 || statements[afterEndNodeIndex].getStart(file) < range.end))
|
|
return void 0;
|
|
return {
|
|
toMove: statements.slice(startNodeIndex, afterEndNodeIndex === -1 ? statements.length : afterEndNodeIndex),
|
|
afterLast: afterEndNodeIndex === -1 ? void 0 : statements[afterEndNodeIndex]
|
|
};
|
|
}
|
|
function doChange35(oldFile, program, toMove, changes, host, preferences) {
|
|
const checker = program.getTypeChecker();
|
|
const usage = getUsageInfo(oldFile, toMove.all, checker);
|
|
const currentDirectory = getDirectoryPath(oldFile.fileName);
|
|
const extension = extensionFromPath(oldFile.fileName);
|
|
const newModuleName = makeUniqueModuleName(getNewModuleName(usage.oldFileImportsFromNewFile, usage.movedSymbols), extension, currentDirectory, host);
|
|
const newFileNameWithExtension = newModuleName + extension;
|
|
changes.createNewFile(oldFile, combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences));
|
|
addNewFileToTsconfig(program, changes, oldFile.fileName, newFileNameWithExtension, hostGetCanonicalFileName(host));
|
|
}
|
|
function getStatementsToMove(context) {
|
|
const rangeToMove = getRangeToMove(context);
|
|
if (rangeToMove === void 0)
|
|
return void 0;
|
|
const all = [];
|
|
const ranges = [];
|
|
const { toMove, afterLast } = rangeToMove;
|
|
getRangesWhere(toMove, isAllowedStatementToMove, (start2, afterEndIndex) => {
|
|
for (let i = start2; i < afterEndIndex; i++)
|
|
all.push(toMove[i]);
|
|
ranges.push({ first: toMove[start2], afterLast });
|
|
});
|
|
return all.length === 0 ? void 0 : { all, ranges };
|
|
}
|
|
function isAllowedStatementToMove(statement) {
|
|
return !isPureImport(statement) && !isPrologueDirective(statement);
|
|
}
|
|
function isPureImport(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return true;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return !hasSyntacticModifier(node, 1 /* Export */);
|
|
case 240 /* VariableStatement */:
|
|
return node.declarationList.declarations.every((d) => !!d.initializer && isRequireCall(d.initializer, true));
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function addNewFileToTsconfig(program, changes, oldFileName, newFileNameWithExtension, getCanonicalFileName) {
|
|
const cfg = program.getCompilerOptions().configFile;
|
|
if (!cfg)
|
|
return;
|
|
const newFileAbsolutePath = normalizePath(combinePaths(oldFileName, "..", newFileNameWithExtension));
|
|
const newFilePath = getRelativePathFromFile(cfg.fileName, newFileAbsolutePath, getCanonicalFileName);
|
|
const cfgObject = cfg.statements[0] && tryCast(cfg.statements[0].expression, isObjectLiteralExpression);
|
|
const filesProp = cfgObject && find(cfgObject.properties, (prop) => isPropertyAssignment(prop) && isStringLiteral(prop.name) && prop.name.text === "files");
|
|
if (filesProp && isArrayLiteralExpression(filesProp.initializer)) {
|
|
changes.insertNodeInListAfter(cfg, last(filesProp.initializer.elements), factory.createStringLiteral(newFilePath), filesProp.initializer.elements);
|
|
}
|
|
}
|
|
function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences) {
|
|
const checker = program.getTypeChecker();
|
|
const prologueDirectives = takeWhile(oldFile.statements, isPrologueDirective);
|
|
if (oldFile.externalModuleIndicator === void 0 && oldFile.commonJsModuleIndicator === void 0 && usage.oldImportsNeededByNewFile.size() === 0) {
|
|
deleteMovedStatements(oldFile, toMove.ranges, changes);
|
|
return [...prologueDirectives, ...toMove.all];
|
|
}
|
|
const useEsModuleSyntax = !!oldFile.externalModuleIndicator;
|
|
const quotePreference = getQuotePreference(oldFile, preferences);
|
|
const importsFromNewFile = createOldFileImportsFromNewFile(usage.oldFileImportsFromNewFile, newModuleName, useEsModuleSyntax, quotePreference);
|
|
if (importsFromNewFile) {
|
|
insertImports(changes, oldFile, importsFromNewFile, true);
|
|
}
|
|
deleteUnusedOldImports(oldFile, toMove.all, changes, usage.unusedImportsFromOldFile, checker);
|
|
deleteMovedStatements(oldFile, toMove.ranges, changes);
|
|
updateImportsInOtherFiles(changes, program, oldFile, usage.movedSymbols, newModuleName);
|
|
const imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference);
|
|
const body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEsModuleSyntax);
|
|
if (imports.length && body.length) {
|
|
return [
|
|
...prologueDirectives,
|
|
...imports,
|
|
4 /* NewLineTrivia */,
|
|
...body
|
|
];
|
|
}
|
|
return [
|
|
...prologueDirectives,
|
|
...imports,
|
|
...body
|
|
];
|
|
}
|
|
function deleteMovedStatements(sourceFile, moved, changes) {
|
|
for (const { first: first2, afterLast } of moved) {
|
|
changes.deleteNodeRangeExcludingEnd(sourceFile, first2, afterLast);
|
|
}
|
|
}
|
|
function deleteUnusedOldImports(oldFile, toMove, changes, toDelete, checker) {
|
|
for (const statement of oldFile.statements) {
|
|
if (contains(toMove, statement))
|
|
continue;
|
|
forEachImportInStatement(statement, (i) => deleteUnusedImports(oldFile, i, changes, (name) => toDelete.has(checker.getSymbolAtLocation(name))));
|
|
}
|
|
}
|
|
function updateImportsInOtherFiles(changes, program, oldFile, movedSymbols, newModuleName) {
|
|
const checker = program.getTypeChecker();
|
|
for (const sourceFile of program.getSourceFiles()) {
|
|
if (sourceFile === oldFile)
|
|
continue;
|
|
for (const statement of sourceFile.statements) {
|
|
forEachImportInStatement(statement, (importNode) => {
|
|
if (checker.getSymbolAtLocation(moduleSpecifierFromImport(importNode)) !== oldFile.symbol)
|
|
return;
|
|
const shouldMove = (name) => {
|
|
const symbol = isBindingElement(name.parent) ? getPropertySymbolFromBindingElement(checker, name.parent) : skipAlias(checker.getSymbolAtLocation(name), checker);
|
|
return !!symbol && movedSymbols.has(symbol);
|
|
};
|
|
deleteUnusedImports(sourceFile, importNode, changes, shouldMove);
|
|
const newModuleSpecifier = combinePaths(getDirectoryPath(moduleSpecifierFromImport(importNode).text), newModuleName);
|
|
const newImportDeclaration = filterImport(importNode, factory.createStringLiteral(newModuleSpecifier), shouldMove);
|
|
if (newImportDeclaration)
|
|
changes.insertNodeAfter(sourceFile, statement, newImportDeclaration);
|
|
const ns = getNamespaceLikeImport(importNode);
|
|
if (ns)
|
|
updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function getNamespaceLikeImport(node) {
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 271 /* NamespaceImport */ ? node.importClause.namedBindings.name : void 0;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return node.name;
|
|
case 257 /* VariableDeclaration */:
|
|
return tryCast(node.name, isIdentifier);
|
|
default:
|
|
return Debug.assertNever(node, `Unexpected node kind ${node.kind}`);
|
|
}
|
|
}
|
|
function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, oldImportId, oldImportNode) {
|
|
const preferredNewNamespaceName = ts_codefix_exports.moduleSpecifierToValidIdentifier(newModuleName, 99 /* ESNext */);
|
|
let needUniqueName = false;
|
|
const toChange = [];
|
|
ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, (ref) => {
|
|
if (!isPropertyAccessExpression(ref.parent))
|
|
return;
|
|
needUniqueName = needUniqueName || !!checker.resolveName(preferredNewNamespaceName, ref, 67108863 /* All */, true);
|
|
if (movedSymbols.has(checker.getSymbolAtLocation(ref.parent.name))) {
|
|
toChange.push(ref);
|
|
}
|
|
});
|
|
if (toChange.length) {
|
|
const newNamespaceName = needUniqueName ? getUniqueName(preferredNewNamespaceName, sourceFile) : preferredNewNamespaceName;
|
|
for (const ref of toChange) {
|
|
changes.replaceNode(sourceFile, ref, factory.createIdentifier(newNamespaceName));
|
|
}
|
|
changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, newModuleName, newModuleSpecifier));
|
|
}
|
|
}
|
|
function updateNamespaceLikeImportNode(node, newNamespaceName, newModuleSpecifier) {
|
|
const newNamespaceId = factory.createIdentifier(newNamespaceName);
|
|
const newModuleString = factory.createStringLiteral(newModuleSpecifier);
|
|
switch (node.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
return factory.createImportDeclaration(
|
|
void 0,
|
|
factory.createImportClause(false, void 0, factory.createNamespaceImport(newNamespaceId)),
|
|
newModuleString,
|
|
void 0
|
|
);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return factory.createImportEqualsDeclaration(void 0, false, newNamespaceId, factory.createExternalModuleReference(newModuleString));
|
|
case 257 /* VariableDeclaration */:
|
|
return factory.createVariableDeclaration(newNamespaceId, void 0, void 0, createRequireCall(newModuleString));
|
|
default:
|
|
return Debug.assertNever(node, `Unexpected node kind ${node.kind}`);
|
|
}
|
|
}
|
|
function moduleSpecifierFromImport(i) {
|
|
return i.kind === 269 /* ImportDeclaration */ ? i.moduleSpecifier : i.kind === 268 /* ImportEqualsDeclaration */ ? i.moduleReference.expression : i.initializer.arguments[0];
|
|
}
|
|
function forEachImportInStatement(statement, cb) {
|
|
if (isImportDeclaration(statement)) {
|
|
if (isStringLiteral(statement.moduleSpecifier))
|
|
cb(statement);
|
|
} else if (isImportEqualsDeclaration(statement)) {
|
|
if (isExternalModuleReference(statement.moduleReference) && isStringLiteralLike(statement.moduleReference.expression)) {
|
|
cb(statement);
|
|
}
|
|
} else if (isVariableStatement(statement)) {
|
|
for (const decl of statement.declarationList.declarations) {
|
|
if (decl.initializer && isRequireCall(decl.initializer, true)) {
|
|
cb(decl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function createOldFileImportsFromNewFile(newFileNeedExport, newFileNameWithExtension, useEs6Imports, quotePreference) {
|
|
let defaultImport;
|
|
const imports = [];
|
|
newFileNeedExport.forEach((symbol) => {
|
|
if (symbol.escapedName === "default" /* Default */) {
|
|
defaultImport = factory.createIdentifier(symbolNameNoDefault(symbol));
|
|
} else {
|
|
imports.push(symbol.name);
|
|
}
|
|
});
|
|
return makeImportOrRequire(defaultImport, imports, newFileNameWithExtension, useEs6Imports, quotePreference);
|
|
}
|
|
function makeImportOrRequire(defaultImport, imports, path, useEs6Imports, quotePreference) {
|
|
path = ensurePathIsNonModuleName(path);
|
|
if (useEs6Imports) {
|
|
const specifiers = imports.map((i) => factory.createImportSpecifier(false, void 0, factory.createIdentifier(i)));
|
|
return makeImportIfNecessary(defaultImport, specifiers, path, quotePreference);
|
|
} else {
|
|
Debug.assert(!defaultImport, "No default import should exist");
|
|
const bindingElements = imports.map((i) => factory.createBindingElement(void 0, void 0, i));
|
|
return bindingElements.length ? makeVariableStatement(factory.createObjectBindingPattern(bindingElements), void 0, createRequireCall(factory.createStringLiteral(path))) : void 0;
|
|
}
|
|
}
|
|
function makeVariableStatement(name, type, initializer, flags = 2 /* Const */) {
|
|
return factory.createVariableStatement(void 0, factory.createVariableDeclarationList([factory.createVariableDeclaration(name, void 0, type, initializer)], flags));
|
|
}
|
|
function createRequireCall(moduleSpecifier) {
|
|
return factory.createCallExpression(factory.createIdentifier("require"), void 0, [moduleSpecifier]);
|
|
}
|
|
function addExports(sourceFile, toMove, needExport, useEs6Exports) {
|
|
return flatMap(toMove, (statement) => {
|
|
if (isTopLevelDeclarationStatement(statement) && !isExported(sourceFile, statement, useEs6Exports) && forEachTopLevelDeclaration(statement, (d) => needExport.has(Debug.checkDefined(d.symbol)))) {
|
|
const exports = addExport(statement, useEs6Exports);
|
|
if (exports)
|
|
return exports;
|
|
}
|
|
return statement;
|
|
});
|
|
}
|
|
function deleteUnusedImports(sourceFile, importDecl, changes, isUnused) {
|
|
switch (importDecl.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused);
|
|
break;
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
if (isUnused(importDecl.name)) {
|
|
changes.delete(sourceFile, importDecl);
|
|
}
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
deleteUnusedImportsInVariableDeclaration(sourceFile, importDecl, changes, isUnused);
|
|
break;
|
|
default:
|
|
Debug.assertNever(importDecl, `Unexpected import decl kind ${importDecl.kind}`);
|
|
}
|
|
}
|
|
function deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused) {
|
|
if (!importDecl.importClause)
|
|
return;
|
|
const { name, namedBindings } = importDecl.importClause;
|
|
const defaultUnused = !name || isUnused(name);
|
|
const namedBindingsUnused = !namedBindings || (namedBindings.kind === 271 /* NamespaceImport */ ? isUnused(namedBindings.name) : namedBindings.elements.length !== 0 && namedBindings.elements.every((e) => isUnused(e.name)));
|
|
if (defaultUnused && namedBindingsUnused) {
|
|
changes.delete(sourceFile, importDecl);
|
|
} else {
|
|
if (name && defaultUnused) {
|
|
changes.delete(sourceFile, name);
|
|
}
|
|
if (namedBindings) {
|
|
if (namedBindingsUnused) {
|
|
changes.replaceNode(
|
|
sourceFile,
|
|
importDecl.importClause,
|
|
factory.updateImportClause(importDecl.importClause, importDecl.importClause.isTypeOnly, name, void 0)
|
|
);
|
|
} else if (namedBindings.kind === 272 /* NamedImports */) {
|
|
for (const element of namedBindings.elements) {
|
|
if (isUnused(element.name))
|
|
changes.delete(sourceFile, element);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function deleteUnusedImportsInVariableDeclaration(sourceFile, varDecl, changes, isUnused) {
|
|
const { name } = varDecl;
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
if (isUnused(name)) {
|
|
if (varDecl.initializer && isRequireCall(varDecl.initializer, true)) {
|
|
changes.delete(
|
|
sourceFile,
|
|
isVariableDeclarationList(varDecl.parent) && length(varDecl.parent.declarations) === 1 ? varDecl.parent.parent : varDecl
|
|
);
|
|
} else {
|
|
changes.delete(sourceFile, name);
|
|
}
|
|
}
|
|
break;
|
|
case 204 /* ArrayBindingPattern */:
|
|
break;
|
|
case 203 /* ObjectBindingPattern */:
|
|
if (name.elements.every((e) => isIdentifier(e.name) && isUnused(e.name))) {
|
|
changes.delete(
|
|
sourceFile,
|
|
isVariableDeclarationList(varDecl.parent) && varDecl.parent.declarations.length === 1 ? varDecl.parent.parent : varDecl
|
|
);
|
|
} else {
|
|
for (const element of name.elements) {
|
|
if (isIdentifier(element.name) && isUnused(element.name)) {
|
|
changes.delete(sourceFile, element.name);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference) {
|
|
const copiedOldImports = [];
|
|
for (const oldStatement of oldFile.statements) {
|
|
forEachImportInStatement(oldStatement, (i) => {
|
|
append(copiedOldImports, filterImport(i, moduleSpecifierFromImport(i), (name) => importsToCopy.has(checker.getSymbolAtLocation(name))));
|
|
});
|
|
}
|
|
let oldFileDefault;
|
|
const oldFileNamedImports = [];
|
|
const markSeenTop = nodeSeenTracker();
|
|
newFileImportsFromOldFile.forEach((symbol) => {
|
|
if (!symbol.declarations) {
|
|
return;
|
|
}
|
|
for (const decl of symbol.declarations) {
|
|
if (!isTopLevelDeclaration(decl))
|
|
continue;
|
|
const name = nameOfTopLevelDeclaration(decl);
|
|
if (!name)
|
|
continue;
|
|
const top = getTopLevelDeclarationStatement(decl);
|
|
if (markSeenTop(top)) {
|
|
addExportToChanges(oldFile, top, name, changes, useEsModuleSyntax);
|
|
}
|
|
if (hasSyntacticModifier(decl, 1024 /* Default */)) {
|
|
oldFileDefault = name;
|
|
} else {
|
|
oldFileNamedImports.push(name.text);
|
|
}
|
|
}
|
|
});
|
|
append(copiedOldImports, makeImportOrRequire(oldFileDefault, oldFileNamedImports, removeFileExtension(getBaseFileName(oldFile.fileName)), useEsModuleSyntax, quotePreference));
|
|
return copiedOldImports;
|
|
}
|
|
function makeUniqueModuleName(moduleName, extension, inDirectory, host) {
|
|
let newModuleName = moduleName;
|
|
for (let i = 1; ; i++) {
|
|
const name = combinePaths(inDirectory, newModuleName + extension);
|
|
if (!host.fileExists(name))
|
|
return newModuleName;
|
|
newModuleName = `${moduleName}.${i}`;
|
|
}
|
|
}
|
|
function getNewModuleName(importsFromNewFile, movedSymbols) {
|
|
return importsFromNewFile.forEachEntry(symbolNameNoDefault) || movedSymbols.forEachEntry(symbolNameNoDefault) || "newFile";
|
|
}
|
|
function getUsageInfo(oldFile, toMove, checker) {
|
|
const movedSymbols = new SymbolSet();
|
|
const oldImportsNeededByNewFile = new SymbolSet();
|
|
const newFileImportsFromOldFile = new SymbolSet();
|
|
const containsJsx = find(toMove, (statement) => !!(statement.transformFlags & 2 /* ContainsJsx */));
|
|
const jsxNamespaceSymbol = getJsxNamespaceSymbol(containsJsx);
|
|
if (jsxNamespaceSymbol) {
|
|
oldImportsNeededByNewFile.add(jsxNamespaceSymbol);
|
|
}
|
|
for (const statement of toMove) {
|
|
forEachTopLevelDeclaration(statement, (decl) => {
|
|
movedSymbols.add(Debug.checkDefined(isExpressionStatement(decl) ? checker.getSymbolAtLocation(decl.expression.left) : decl.symbol, "Need a symbol here"));
|
|
});
|
|
}
|
|
for (const statement of toMove) {
|
|
forEachReference(statement, checker, (symbol) => {
|
|
if (!symbol.declarations)
|
|
return;
|
|
for (const decl of symbol.declarations) {
|
|
if (isInImport(decl)) {
|
|
oldImportsNeededByNewFile.add(symbol);
|
|
} else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) {
|
|
newFileImportsFromOldFile.add(symbol);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
const unusedImportsFromOldFile = oldImportsNeededByNewFile.clone();
|
|
const oldFileImportsFromNewFile = new SymbolSet();
|
|
for (const statement of oldFile.statements) {
|
|
if (contains(toMove, statement))
|
|
continue;
|
|
if (jsxNamespaceSymbol && !!(statement.transformFlags & 2 /* ContainsJsx */)) {
|
|
unusedImportsFromOldFile.delete(jsxNamespaceSymbol);
|
|
}
|
|
forEachReference(statement, checker, (symbol) => {
|
|
if (movedSymbols.has(symbol))
|
|
oldFileImportsFromNewFile.add(symbol);
|
|
unusedImportsFromOldFile.delete(symbol);
|
|
});
|
|
}
|
|
return { movedSymbols, newFileImportsFromOldFile, oldFileImportsFromNewFile, oldImportsNeededByNewFile, unusedImportsFromOldFile };
|
|
function getJsxNamespaceSymbol(containsJsx2) {
|
|
if (containsJsx2 === void 0) {
|
|
return void 0;
|
|
}
|
|
const jsxNamespace = checker.getJsxNamespace(containsJsx2);
|
|
const jsxNamespaceSymbol2 = checker.resolveName(jsxNamespace, containsJsx2, 1920 /* Namespace */, true);
|
|
return !!jsxNamespaceSymbol2 && some(jsxNamespaceSymbol2.declarations, isInImport) ? jsxNamespaceSymbol2 : void 0;
|
|
}
|
|
}
|
|
function isInImport(decl) {
|
|
switch (decl.kind) {
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 270 /* ImportClause */:
|
|
case 271 /* NamespaceImport */:
|
|
return true;
|
|
case 257 /* VariableDeclaration */:
|
|
return isVariableDeclarationInImport(decl);
|
|
case 205 /* BindingElement */:
|
|
return isVariableDeclaration(decl.parent.parent) && isVariableDeclarationInImport(decl.parent.parent);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isVariableDeclarationInImport(decl) {
|
|
return isSourceFile(decl.parent.parent.parent) && !!decl.initializer && isRequireCall(decl.initializer, true);
|
|
}
|
|
function filterImport(i, moduleSpecifier, keep) {
|
|
switch (i.kind) {
|
|
case 269 /* ImportDeclaration */: {
|
|
const clause = i.importClause;
|
|
if (!clause)
|
|
return void 0;
|
|
const defaultImport = clause.name && keep(clause.name) ? clause.name : void 0;
|
|
const namedBindings = clause.namedBindings && filterNamedBindings(clause.namedBindings, keep);
|
|
return defaultImport || namedBindings ? factory.createImportDeclaration(void 0, factory.createImportClause(false, defaultImport, namedBindings), moduleSpecifier, void 0) : void 0;
|
|
}
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return keep(i.name) ? i : void 0;
|
|
case 257 /* VariableDeclaration */: {
|
|
const name = filterBindingName(i.name, keep);
|
|
return name ? makeVariableStatement(name, i.type, createRequireCall(moduleSpecifier), i.parent.flags) : void 0;
|
|
}
|
|
default:
|
|
return Debug.assertNever(i, `Unexpected import kind ${i.kind}`);
|
|
}
|
|
}
|
|
function filterNamedBindings(namedBindings, keep) {
|
|
if (namedBindings.kind === 271 /* NamespaceImport */) {
|
|
return keep(namedBindings.name) ? namedBindings : void 0;
|
|
} else {
|
|
const newElements = namedBindings.elements.filter((e) => keep(e.name));
|
|
return newElements.length ? factory.createNamedImports(newElements) : void 0;
|
|
}
|
|
}
|
|
function filterBindingName(name, keep) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return keep(name) ? name : void 0;
|
|
case 204 /* ArrayBindingPattern */:
|
|
return name;
|
|
case 203 /* ObjectBindingPattern */: {
|
|
const newElements = name.elements.filter((prop) => prop.propertyName || !isIdentifier(prop.name) || keep(prop.name));
|
|
return newElements.length ? factory.createObjectBindingPattern(newElements) : void 0;
|
|
}
|
|
}
|
|
}
|
|
function forEachReference(node, checker, onReference) {
|
|
node.forEachChild(function cb(node2) {
|
|
if (isIdentifier(node2) && !isDeclarationName(node2)) {
|
|
const sym = checker.getSymbolAtLocation(node2);
|
|
if (sym)
|
|
onReference(sym);
|
|
} else {
|
|
node2.forEachChild(cb);
|
|
}
|
|
});
|
|
}
|
|
var SymbolSet = class {
|
|
constructor() {
|
|
this.map = /* @__PURE__ */ new Map();
|
|
}
|
|
add(symbol) {
|
|
this.map.set(String(getSymbolId(symbol)), symbol);
|
|
}
|
|
has(symbol) {
|
|
return this.map.has(String(getSymbolId(symbol)));
|
|
}
|
|
delete(symbol) {
|
|
this.map.delete(String(getSymbolId(symbol)));
|
|
}
|
|
forEach(cb) {
|
|
this.map.forEach(cb);
|
|
}
|
|
forEachEntry(cb) {
|
|
return forEachEntry(this.map, cb);
|
|
}
|
|
clone() {
|
|
const clone2 = new SymbolSet();
|
|
copyEntries(this.map, clone2.map);
|
|
return clone2;
|
|
}
|
|
size() {
|
|
return this.map.size;
|
|
}
|
|
};
|
|
function isTopLevelDeclaration(node) {
|
|
return isNonVariableTopLevelDeclaration(node) && isSourceFile(node.parent) || isVariableDeclaration(node) && isSourceFile(node.parent.parent.parent);
|
|
}
|
|
function sourceFileOfTopLevelDeclaration(node) {
|
|
return isVariableDeclaration(node) ? node.parent.parent.parent : node.parent;
|
|
}
|
|
function isTopLevelDeclarationStatement(node) {
|
|
Debug.assert(isSourceFile(node.parent), "Node parent should be a SourceFile");
|
|
return isNonVariableTopLevelDeclaration(node) || isVariableStatement(node);
|
|
}
|
|
function isNonVariableTopLevelDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function forEachTopLevelDeclaration(statement, cb) {
|
|
switch (statement.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return cb(statement);
|
|
case 240 /* VariableStatement */:
|
|
return firstDefined(statement.declarationList.declarations, (decl) => forEachTopLevelDeclarationInBindingName(decl.name, cb));
|
|
case 241 /* ExpressionStatement */: {
|
|
const { expression } = statement;
|
|
return isBinaryExpression(expression) && getAssignmentDeclarationKind(expression) === 1 /* ExportsProperty */ ? cb(statement) : void 0;
|
|
}
|
|
}
|
|
}
|
|
function forEachTopLevelDeclarationInBindingName(name, cb) {
|
|
switch (name.kind) {
|
|
case 79 /* Identifier */:
|
|
return cb(cast(name.parent, (x) => isVariableDeclaration(x) || isBindingElement(x)));
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
return firstDefined(name.elements, (em) => isOmittedExpression(em) ? void 0 : forEachTopLevelDeclarationInBindingName(em.name, cb));
|
|
default:
|
|
return Debug.assertNever(name, `Unexpected name kind ${name.kind}`);
|
|
}
|
|
}
|
|
function nameOfTopLevelDeclaration(d) {
|
|
return isExpressionStatement(d) ? tryCast(d.expression.left.name, isIdentifier) : tryCast(d.name, isIdentifier);
|
|
}
|
|
function getTopLevelDeclarationStatement(d) {
|
|
switch (d.kind) {
|
|
case 257 /* VariableDeclaration */:
|
|
return d.parent.parent;
|
|
case 205 /* BindingElement */:
|
|
return getTopLevelDeclarationStatement(
|
|
cast(d.parent.parent, (p) => isVariableDeclaration(p) || isBindingElement(p))
|
|
);
|
|
default:
|
|
return d;
|
|
}
|
|
}
|
|
function addExportToChanges(sourceFile, decl, name, changes, useEs6Exports) {
|
|
if (isExported(sourceFile, decl, useEs6Exports, name))
|
|
return;
|
|
if (useEs6Exports) {
|
|
if (!isExpressionStatement(decl))
|
|
changes.insertExportModifier(sourceFile, decl);
|
|
} else {
|
|
const names = getNamesToExportInCommonJS(decl);
|
|
if (names.length !== 0)
|
|
changes.insertNodesAfter(sourceFile, decl, names.map(createExportAssignment));
|
|
}
|
|
}
|
|
function isExported(sourceFile, decl, useEs6Exports, name) {
|
|
var _a2;
|
|
if (useEs6Exports) {
|
|
return !isExpressionStatement(decl) && hasSyntacticModifier(decl, 1 /* Export */) || !!(name && ((_a2 = sourceFile.symbol.exports) == null ? void 0 : _a2.has(name.escapedText)));
|
|
}
|
|
return !!sourceFile.symbol && !!sourceFile.symbol.exports && getNamesToExportInCommonJS(decl).some((name2) => sourceFile.symbol.exports.has(escapeLeadingUnderscores(name2)));
|
|
}
|
|
function addExport(decl, useEs6Exports) {
|
|
return useEs6Exports ? [addEs6Export(decl)] : addCommonjsExport(decl);
|
|
}
|
|
function addEs6Export(d) {
|
|
const modifiers = canHaveModifiers(d) ? concatenate([factory.createModifier(93 /* ExportKeyword */)], getModifiers(d)) : void 0;
|
|
switch (d.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return factory.updateFunctionDeclaration(d, modifiers, d.asteriskToken, d.name, d.typeParameters, d.parameters, d.type, d.body);
|
|
case 260 /* ClassDeclaration */:
|
|
const decorators = canHaveDecorators(d) ? getDecorators(d) : void 0;
|
|
return factory.updateClassDeclaration(d, concatenate(decorators, modifiers), d.name, d.typeParameters, d.heritageClauses, d.members);
|
|
case 240 /* VariableStatement */:
|
|
return factory.updateVariableStatement(d, modifiers, d.declarationList);
|
|
case 264 /* ModuleDeclaration */:
|
|
return factory.updateModuleDeclaration(d, modifiers, d.name, d.body);
|
|
case 263 /* EnumDeclaration */:
|
|
return factory.updateEnumDeclaration(d, modifiers, d.name, d.members);
|
|
case 262 /* TypeAliasDeclaration */:
|
|
return factory.updateTypeAliasDeclaration(d, modifiers, d.name, d.typeParameters, d.type);
|
|
case 261 /* InterfaceDeclaration */:
|
|
return factory.updateInterfaceDeclaration(d, modifiers, d.name, d.typeParameters, d.heritageClauses, d.members);
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return factory.updateImportEqualsDeclaration(d, modifiers, d.isTypeOnly, d.name, d.moduleReference);
|
|
case 241 /* ExpressionStatement */:
|
|
return Debug.fail();
|
|
default:
|
|
return Debug.assertNever(d, `Unexpected declaration kind ${d.kind}`);
|
|
}
|
|
}
|
|
function addCommonjsExport(decl) {
|
|
return [decl, ...getNamesToExportInCommonJS(decl).map(createExportAssignment)];
|
|
}
|
|
function getNamesToExportInCommonJS(decl) {
|
|
switch (decl.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
return [decl.name.text];
|
|
case 240 /* VariableStatement */:
|
|
return mapDefined(decl.declarationList.declarations, (d) => isIdentifier(d.name) ? d.name.text : void 0);
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
return emptyArray;
|
|
case 241 /* ExpressionStatement */:
|
|
return Debug.fail("Can't export an ExpressionStatement");
|
|
default:
|
|
return Debug.assertNever(decl, `Unexpected decl kind ${decl.kind}`);
|
|
}
|
|
}
|
|
function createExportAssignment(name) {
|
|
return factory.createExpressionStatement(
|
|
factory.createBinaryExpression(
|
|
factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(name)),
|
|
63 /* EqualsToken */,
|
|
factory.createIdentifier(name)
|
|
)
|
|
);
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.addOrRemoveBracesToArrowFunction.ts
|
|
var ts_refactor_addOrRemoveBracesToArrowFunction_exports = {};
|
|
|
|
// src/services/refactors/convertOverloadListToSingleSignature.ts
|
|
var refactorName5 = "Convert overload list to single signature";
|
|
var refactorDescription = Diagnostics.Convert_overload_list_to_single_signature.message;
|
|
var functionOverloadAction = {
|
|
name: refactorName5,
|
|
description: refactorDescription,
|
|
kind: "refactor.rewrite.function.overloadList"
|
|
};
|
|
registerRefactor(refactorName5, {
|
|
kinds: [functionOverloadAction.kind],
|
|
getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
|
|
getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
|
|
});
|
|
function getRefactorActionsToConvertOverloadsToOneSignature(context) {
|
|
const { file, startPosition, program } = context;
|
|
const info = getConvertableOverloadListAtPosition(file, startPosition, program);
|
|
if (!info)
|
|
return emptyArray;
|
|
return [{
|
|
name: refactorName5,
|
|
description: refactorDescription,
|
|
actions: [functionOverloadAction]
|
|
}];
|
|
}
|
|
function getRefactorEditsToConvertOverloadsToOneSignature(context) {
|
|
const { file, startPosition, program } = context;
|
|
const signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program);
|
|
if (!signatureDecls)
|
|
return void 0;
|
|
const checker = program.getTypeChecker();
|
|
const lastDeclaration = signatureDecls[signatureDecls.length - 1];
|
|
let updated = lastDeclaration;
|
|
switch (lastDeclaration.kind) {
|
|
case 170 /* MethodSignature */: {
|
|
updated = factory.updateMethodSignature(
|
|
lastDeclaration,
|
|
lastDeclaration.modifiers,
|
|
lastDeclaration.name,
|
|
lastDeclaration.questionToken,
|
|
lastDeclaration.typeParameters,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.type
|
|
);
|
|
break;
|
|
}
|
|
case 171 /* MethodDeclaration */: {
|
|
updated = factory.updateMethodDeclaration(
|
|
lastDeclaration,
|
|
lastDeclaration.modifiers,
|
|
lastDeclaration.asteriskToken,
|
|
lastDeclaration.name,
|
|
lastDeclaration.questionToken,
|
|
lastDeclaration.typeParameters,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.type,
|
|
lastDeclaration.body
|
|
);
|
|
break;
|
|
}
|
|
case 176 /* CallSignature */: {
|
|
updated = factory.updateCallSignature(
|
|
lastDeclaration,
|
|
lastDeclaration.typeParameters,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.type
|
|
);
|
|
break;
|
|
}
|
|
case 173 /* Constructor */: {
|
|
updated = factory.updateConstructorDeclaration(
|
|
lastDeclaration,
|
|
lastDeclaration.modifiers,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.body
|
|
);
|
|
break;
|
|
}
|
|
case 177 /* ConstructSignature */: {
|
|
updated = factory.updateConstructSignature(
|
|
lastDeclaration,
|
|
lastDeclaration.typeParameters,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.type
|
|
);
|
|
break;
|
|
}
|
|
case 259 /* FunctionDeclaration */: {
|
|
updated = factory.updateFunctionDeclaration(
|
|
lastDeclaration,
|
|
lastDeclaration.modifiers,
|
|
lastDeclaration.asteriskToken,
|
|
lastDeclaration.name,
|
|
lastDeclaration.typeParameters,
|
|
getNewParametersForCombinedSignature(signatureDecls),
|
|
lastDeclaration.type,
|
|
lastDeclaration.body
|
|
);
|
|
break;
|
|
}
|
|
default:
|
|
return Debug.failBadSyntaxKind(lastDeclaration, "Unhandled signature kind in overload list conversion refactoring");
|
|
}
|
|
if (updated === lastDeclaration) {
|
|
return;
|
|
}
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
t.replaceNodeRange(file, signatureDecls[0], signatureDecls[signatureDecls.length - 1], updated);
|
|
});
|
|
return { renameFilename: void 0, renameLocation: void 0, edits };
|
|
function getNewParametersForCombinedSignature(signatureDeclarations) {
|
|
const lastSig = signatureDeclarations[signatureDeclarations.length - 1];
|
|
if (isFunctionLikeDeclaration(lastSig) && lastSig.body) {
|
|
signatureDeclarations = signatureDeclarations.slice(0, signatureDeclarations.length - 1);
|
|
}
|
|
return factory.createNodeArray([
|
|
factory.createParameterDeclaration(
|
|
void 0,
|
|
factory.createToken(25 /* DotDotDotToken */),
|
|
"args",
|
|
void 0,
|
|
factory.createUnionTypeNode(map(signatureDeclarations, convertSignatureParametersToTuple))
|
|
)
|
|
]);
|
|
}
|
|
function convertSignatureParametersToTuple(decl) {
|
|
const members = map(decl.parameters, convertParameterToNamedTupleMember);
|
|
return setEmitFlags(factory.createTupleTypeNode(members), some(members, (m) => !!length(getSyntheticLeadingComments(m))) ? 0 /* None */ : 1 /* SingleLine */);
|
|
}
|
|
function convertParameterToNamedTupleMember(p) {
|
|
Debug.assert(isIdentifier(p.name));
|
|
const result = setTextRange(factory.createNamedTupleMember(
|
|
p.dotDotDotToken,
|
|
p.name,
|
|
p.questionToken,
|
|
p.type || factory.createKeywordTypeNode(131 /* AnyKeyword */)
|
|
), p);
|
|
const parameterDocComment = p.symbol && p.symbol.getDocumentationComment(checker);
|
|
if (parameterDocComment) {
|
|
const newComment = displayPartsToString(parameterDocComment);
|
|
if (newComment.length) {
|
|
setSyntheticLeadingComments(result, [{
|
|
text: `*
|
|
${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
|
|
`,
|
|
kind: 3 /* MultiLineCommentTrivia */,
|
|
pos: -1,
|
|
end: -1,
|
|
hasTrailingNewLine: true,
|
|
hasLeadingNewline: true
|
|
}]);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
function isConvertableSignatureDeclaration(d) {
|
|
switch (d.kind) {
|
|
case 170 /* MethodSignature */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 176 /* CallSignature */:
|
|
case 173 /* Constructor */:
|
|
case 177 /* ConstructSignature */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function getConvertableOverloadListAtPosition(file, startPosition, program) {
|
|
const node = getTokenAtPosition(file, startPosition);
|
|
const containingDecl = findAncestor(node, isConvertableSignatureDeclaration);
|
|
if (!containingDecl) {
|
|
return;
|
|
}
|
|
if (isFunctionLikeDeclaration(containingDecl) && containingDecl.body && rangeContainsPosition(containingDecl.body, startPosition)) {
|
|
return;
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const signatureSymbol = containingDecl.symbol;
|
|
if (!signatureSymbol) {
|
|
return;
|
|
}
|
|
const decls = signatureSymbol.declarations;
|
|
if (length(decls) <= 1) {
|
|
return;
|
|
}
|
|
if (!every(decls, (d) => getSourceFileOfNode(d) === file)) {
|
|
return;
|
|
}
|
|
if (!isConvertableSignatureDeclaration(decls[0])) {
|
|
return;
|
|
}
|
|
const kindOne = decls[0].kind;
|
|
if (!every(decls, (d) => d.kind === kindOne)) {
|
|
return;
|
|
}
|
|
const signatureDecls = decls;
|
|
if (some(signatureDecls, (d) => !!d.typeParameters || some(d.parameters, (p) => !!p.modifiers || !isIdentifier(p.name)))) {
|
|
return;
|
|
}
|
|
const signatures = mapDefined(signatureDecls, (d) => checker.getSignatureFromDeclaration(d));
|
|
if (length(signatures) !== length(decls)) {
|
|
return;
|
|
}
|
|
const returnOne = checker.getReturnTypeOfSignature(signatures[0]);
|
|
if (!every(signatures, (s) => checker.getReturnTypeOfSignature(s) === returnOne)) {
|
|
return;
|
|
}
|
|
return signatureDecls;
|
|
}
|
|
|
|
// src/services/refactors/addOrRemoveBracesToArrowFunction.ts
|
|
var refactorName6 = "Add or remove braces in an arrow function";
|
|
var refactorDescription2 = Diagnostics.Add_or_remove_braces_in_an_arrow_function.message;
|
|
var addBracesAction = {
|
|
name: "Add braces to arrow function",
|
|
description: Diagnostics.Add_braces_to_arrow_function.message,
|
|
kind: "refactor.rewrite.arrow.braces.add"
|
|
};
|
|
var removeBracesAction = {
|
|
name: "Remove braces from arrow function",
|
|
description: Diagnostics.Remove_braces_from_arrow_function.message,
|
|
kind: "refactor.rewrite.arrow.braces.remove"
|
|
};
|
|
registerRefactor(refactorName6, {
|
|
kinds: [removeBracesAction.kind],
|
|
getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
|
|
getAvailableActions: getRefactorActionsToRemoveFunctionBraces
|
|
});
|
|
function getRefactorActionsToRemoveFunctionBraces(context) {
|
|
const { file, startPosition, triggerReason } = context;
|
|
const info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
return [{
|
|
name: refactorName6,
|
|
description: refactorDescription2,
|
|
actions: [
|
|
info.addBraces ? addBracesAction : removeBracesAction
|
|
]
|
|
}];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: refactorName6,
|
|
description: refactorDescription2,
|
|
actions: [
|
|
{ ...addBracesAction, notApplicableReason: info.error },
|
|
{ ...removeBracesAction, notApplicableReason: info.error }
|
|
]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getRefactorEditsToRemoveFunctionBraces(context, actionName2) {
|
|
const { file, startPosition } = context;
|
|
const info = getConvertibleArrowFunctionAtPosition(file, startPosition);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
|
|
const { expression, returnStatement, func } = info;
|
|
let body;
|
|
if (actionName2 === addBracesAction.name) {
|
|
const returnStatement2 = factory.createReturnStatement(expression);
|
|
body = factory.createBlock([returnStatement2], true);
|
|
copyLeadingComments(expression, returnStatement2, file, 3 /* MultiLineCommentTrivia */, true);
|
|
} else if (actionName2 === removeBracesAction.name && returnStatement) {
|
|
const actualExpression = expression || factory.createVoidZero();
|
|
body = needsParentheses(actualExpression) ? factory.createParenthesizedExpression(actualExpression) : actualExpression;
|
|
copyTrailingAsLeadingComments(returnStatement, body, file, 3 /* MultiLineCommentTrivia */, false);
|
|
copyLeadingComments(returnStatement, body, file, 3 /* MultiLineCommentTrivia */, false);
|
|
copyTrailingComments(returnStatement, body, file, 3 /* MultiLineCommentTrivia */, false);
|
|
} else {
|
|
Debug.fail("invalid action");
|
|
}
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
t.replaceNode(file, func.body, body);
|
|
});
|
|
return { renameFilename: void 0, renameLocation: void 0, edits };
|
|
}
|
|
function getConvertibleArrowFunctionAtPosition(file, startPosition, considerFunctionBodies = true, kind) {
|
|
const node = getTokenAtPosition(file, startPosition);
|
|
const func = getContainingFunction(node);
|
|
if (!func) {
|
|
return {
|
|
error: getLocaleSpecificMessage(Diagnostics.Could_not_find_a_containing_arrow_function)
|
|
};
|
|
}
|
|
if (!isArrowFunction(func)) {
|
|
return {
|
|
error: getLocaleSpecificMessage(Diagnostics.Containing_function_is_not_an_arrow_function)
|
|
};
|
|
}
|
|
if (!rangeContainsRange(func, node) || rangeContainsRange(func.body, node) && !considerFunctionBodies) {
|
|
return void 0;
|
|
}
|
|
if (refactorKindBeginsWith(addBracesAction.kind, kind) && isExpression(func.body)) {
|
|
return { func, addBraces: true, expression: func.body };
|
|
} else if (refactorKindBeginsWith(removeBracesAction.kind, kind) && isBlock(func.body) && func.body.statements.length === 1) {
|
|
const firstStatement = first(func.body.statements);
|
|
if (isReturnStatement(firstStatement)) {
|
|
return { func, addBraces: false, expression: firstStatement.expression, returnStatement: firstStatement };
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.convertArrowFunctionOrFunctionExpression.ts
|
|
var ts_refactor_convertArrowFunctionOrFunctionExpression_exports = {};
|
|
|
|
// src/services/refactors/convertArrowFunctionOrFunctionExpression.ts
|
|
var refactorName7 = "Convert arrow function or function expression";
|
|
var refactorDescription3 = getLocaleSpecificMessage(Diagnostics.Convert_arrow_function_or_function_expression);
|
|
var toAnonymousFunctionAction = {
|
|
name: "Convert to anonymous function",
|
|
description: getLocaleSpecificMessage(Diagnostics.Convert_to_anonymous_function),
|
|
kind: "refactor.rewrite.function.anonymous"
|
|
};
|
|
var toNamedFunctionAction = {
|
|
name: "Convert to named function",
|
|
description: getLocaleSpecificMessage(Diagnostics.Convert_to_named_function),
|
|
kind: "refactor.rewrite.function.named"
|
|
};
|
|
var toArrowFunctionAction = {
|
|
name: "Convert to arrow function",
|
|
description: getLocaleSpecificMessage(Diagnostics.Convert_to_arrow_function),
|
|
kind: "refactor.rewrite.function.arrow"
|
|
};
|
|
registerRefactor(refactorName7, {
|
|
kinds: [
|
|
toAnonymousFunctionAction.kind,
|
|
toNamedFunctionAction.kind,
|
|
toArrowFunctionAction.kind
|
|
],
|
|
getEditsForAction: getRefactorEditsToConvertFunctionExpressions,
|
|
getAvailableActions: getRefactorActionsToConvertFunctionExpressions
|
|
});
|
|
function getRefactorActionsToConvertFunctionExpressions(context) {
|
|
const { file, startPosition, program, kind } = context;
|
|
const info = getFunctionInfo(file, startPosition, program);
|
|
if (!info)
|
|
return emptyArray;
|
|
const { selectedVariableDeclaration, func } = info;
|
|
const possibleActions = [];
|
|
const errors = [];
|
|
if (refactorKindBeginsWith(toNamedFunctionAction.kind, kind)) {
|
|
const error = selectedVariableDeclaration || isArrowFunction(func) && isVariableDeclaration(func.parent) ? void 0 : getLocaleSpecificMessage(Diagnostics.Could_not_convert_to_named_function);
|
|
if (error) {
|
|
errors.push({ ...toNamedFunctionAction, notApplicableReason: error });
|
|
} else {
|
|
possibleActions.push(toNamedFunctionAction);
|
|
}
|
|
}
|
|
if (refactorKindBeginsWith(toAnonymousFunctionAction.kind, kind)) {
|
|
const error = !selectedVariableDeclaration && isArrowFunction(func) ? void 0 : getLocaleSpecificMessage(Diagnostics.Could_not_convert_to_anonymous_function);
|
|
if (error) {
|
|
errors.push({ ...toAnonymousFunctionAction, notApplicableReason: error });
|
|
} else {
|
|
possibleActions.push(toAnonymousFunctionAction);
|
|
}
|
|
}
|
|
if (refactorKindBeginsWith(toArrowFunctionAction.kind, kind)) {
|
|
const error = isFunctionExpression(func) ? void 0 : getLocaleSpecificMessage(Diagnostics.Could_not_convert_to_arrow_function);
|
|
if (error) {
|
|
errors.push({ ...toArrowFunctionAction, notApplicableReason: error });
|
|
} else {
|
|
possibleActions.push(toArrowFunctionAction);
|
|
}
|
|
}
|
|
return [{
|
|
name: refactorName7,
|
|
description: refactorDescription3,
|
|
actions: possibleActions.length === 0 && context.preferences.provideRefactorNotApplicableReason ? errors : possibleActions
|
|
}];
|
|
}
|
|
function getRefactorEditsToConvertFunctionExpressions(context, actionName2) {
|
|
const { file, startPosition, program } = context;
|
|
const info = getFunctionInfo(file, startPosition, program);
|
|
if (!info)
|
|
return void 0;
|
|
const { func } = info;
|
|
const edits = [];
|
|
switch (actionName2) {
|
|
case toAnonymousFunctionAction.name:
|
|
edits.push(...getEditInfoForConvertToAnonymousFunction(context, func));
|
|
break;
|
|
case toNamedFunctionAction.name:
|
|
const variableInfo = getVariableInfo(func);
|
|
if (!variableInfo)
|
|
return void 0;
|
|
edits.push(...getEditInfoForConvertToNamedFunction(context, func, variableInfo));
|
|
break;
|
|
case toArrowFunctionAction.name:
|
|
if (!isFunctionExpression(func))
|
|
return void 0;
|
|
edits.push(...getEditInfoForConvertToArrowFunction(context, func));
|
|
break;
|
|
default:
|
|
return Debug.fail("invalid action");
|
|
}
|
|
return { renameFilename: void 0, renameLocation: void 0, edits };
|
|
}
|
|
function containingThis(node) {
|
|
let containsThis = false;
|
|
node.forEachChild(function checkThis(child) {
|
|
if (isThis(child)) {
|
|
containsThis = true;
|
|
return;
|
|
}
|
|
if (!isClassLike(child) && !isFunctionDeclaration(child) && !isFunctionExpression(child)) {
|
|
forEachChild(child, checkThis);
|
|
}
|
|
});
|
|
return containsThis;
|
|
}
|
|
function getFunctionInfo(file, startPosition, program) {
|
|
const token = getTokenAtPosition(file, startPosition);
|
|
const typeChecker = program.getTypeChecker();
|
|
const func = tryGetFunctionFromVariableDeclaration(file, typeChecker, token.parent);
|
|
if (func && !containingThis(func.body) && !typeChecker.containsArgumentsReference(func)) {
|
|
return { selectedVariableDeclaration: true, func };
|
|
}
|
|
const maybeFunc = getContainingFunction(token);
|
|
if (maybeFunc && (isFunctionExpression(maybeFunc) || isArrowFunction(maybeFunc)) && !rangeContainsRange(maybeFunc.body, token) && !containingThis(maybeFunc.body) && !typeChecker.containsArgumentsReference(maybeFunc)) {
|
|
if (isFunctionExpression(maybeFunc) && isFunctionReferencedInFile(file, typeChecker, maybeFunc))
|
|
return void 0;
|
|
return { selectedVariableDeclaration: false, func: maybeFunc };
|
|
}
|
|
return void 0;
|
|
}
|
|
function isSingleVariableDeclaration(parent2) {
|
|
return isVariableDeclaration(parent2) || isVariableDeclarationList(parent2) && parent2.declarations.length === 1;
|
|
}
|
|
function tryGetFunctionFromVariableDeclaration(sourceFile, typeChecker, parent2) {
|
|
if (!isSingleVariableDeclaration(parent2)) {
|
|
return void 0;
|
|
}
|
|
const variableDeclaration = isVariableDeclaration(parent2) ? parent2 : first(parent2.declarations);
|
|
const initializer = variableDeclaration.initializer;
|
|
if (initializer && (isArrowFunction(initializer) || isFunctionExpression(initializer) && !isFunctionReferencedInFile(sourceFile, typeChecker, initializer))) {
|
|
return initializer;
|
|
}
|
|
return void 0;
|
|
}
|
|
function convertToBlock(body) {
|
|
if (isExpression(body)) {
|
|
const returnStatement = factory.createReturnStatement(body);
|
|
const file = body.getSourceFile();
|
|
suppressLeadingAndTrailingTrivia(returnStatement);
|
|
copyTrailingAsLeadingComments(body, returnStatement, file, void 0, true);
|
|
return factory.createBlock([returnStatement], true);
|
|
} else {
|
|
return body;
|
|
}
|
|
}
|
|
function getVariableInfo(func) {
|
|
const variableDeclaration = func.parent;
|
|
if (!isVariableDeclaration(variableDeclaration) || !isVariableDeclarationInVariableStatement(variableDeclaration))
|
|
return void 0;
|
|
const variableDeclarationList = variableDeclaration.parent;
|
|
const statement = variableDeclarationList.parent;
|
|
if (!isVariableDeclarationList(variableDeclarationList) || !isVariableStatement(statement) || !isIdentifier(variableDeclaration.name))
|
|
return void 0;
|
|
return { variableDeclaration, variableDeclarationList, statement, name: variableDeclaration.name };
|
|
}
|
|
function getEditInfoForConvertToAnonymousFunction(context, func) {
|
|
const { file } = context;
|
|
const body = convertToBlock(func.body);
|
|
const newNode = factory.createFunctionExpression(func.modifiers, func.asteriskToken, void 0, func.typeParameters, func.parameters, func.type, body);
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(file, func, newNode));
|
|
}
|
|
function getEditInfoForConvertToNamedFunction(context, func, variableInfo) {
|
|
const { file } = context;
|
|
const body = convertToBlock(func.body);
|
|
const { variableDeclaration, variableDeclarationList, statement, name } = variableInfo;
|
|
suppressLeadingTrivia(statement);
|
|
const modifiersFlags = getCombinedModifierFlags(variableDeclaration) & 1 /* Export */ | getEffectiveModifierFlags(func);
|
|
const modifiers = factory.createModifiersFromModifierFlags(modifiersFlags);
|
|
const newNode = factory.createFunctionDeclaration(length(modifiers) ? modifiers : void 0, func.asteriskToken, name, func.typeParameters, func.parameters, func.type, body);
|
|
if (variableDeclarationList.declarations.length === 1) {
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(file, statement, newNode));
|
|
} else {
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
t.delete(file, variableDeclaration);
|
|
t.insertNodeAfter(file, statement, newNode);
|
|
});
|
|
}
|
|
}
|
|
function getEditInfoForConvertToArrowFunction(context, func) {
|
|
const { file } = context;
|
|
const statements = func.body.statements;
|
|
const head = statements[0];
|
|
let body;
|
|
if (canBeConvertedToExpression(func.body, head)) {
|
|
body = head.expression;
|
|
suppressLeadingAndTrailingTrivia(body);
|
|
copyComments(head, body);
|
|
} else {
|
|
body = func.body;
|
|
}
|
|
const newNode = factory.createArrowFunction(func.modifiers, func.typeParameters, func.parameters, func.type, factory.createToken(38 /* EqualsGreaterThanToken */), body);
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(file, func, newNode));
|
|
}
|
|
function canBeConvertedToExpression(body, head) {
|
|
return body.statements.length === 1 && (isReturnStatement(head) && !!head.expression);
|
|
}
|
|
function isFunctionReferencedInFile(sourceFile, typeChecker, node) {
|
|
return !!node.name && ts_FindAllReferences_exports.Core.isSymbolReferencedInFile(node.name, typeChecker, sourceFile);
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.convertParamsToDestructuredObject.ts
|
|
var ts_refactor_convertParamsToDestructuredObject_exports = {};
|
|
|
|
// src/services/refactors/convertParamsToDestructuredObject.ts
|
|
var refactorName8 = "Convert parameters to destructured object";
|
|
var minimumParameterLength = 1;
|
|
var refactorDescription4 = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
|
|
var toDestructuredAction = {
|
|
name: refactorName8,
|
|
description: refactorDescription4,
|
|
kind: "refactor.rewrite.parameters.toDestructured"
|
|
};
|
|
registerRefactor(refactorName8, {
|
|
kinds: [toDestructuredAction.kind],
|
|
getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
|
|
getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
|
|
});
|
|
function getRefactorActionsToConvertParametersToDestructuredObject(context) {
|
|
const { file, startPosition } = context;
|
|
const isJSFile = isSourceFileJS(file);
|
|
if (isJSFile)
|
|
return emptyArray;
|
|
const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, context.program.getTypeChecker());
|
|
if (!functionDeclaration)
|
|
return emptyArray;
|
|
return [{
|
|
name: refactorName8,
|
|
description: refactorDescription4,
|
|
actions: [toDestructuredAction]
|
|
}];
|
|
}
|
|
function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName2) {
|
|
Debug.assert(actionName2 === refactorName8, "Unexpected action name");
|
|
const { file, startPosition, program, cancellationToken, host } = context;
|
|
const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
|
|
if (!functionDeclaration || !cancellationToken)
|
|
return void 0;
|
|
const groupedReferences = getGroupedReferences(functionDeclaration, program, cancellationToken);
|
|
if (groupedReferences.valid) {
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange36(file, program, host, t, functionDeclaration, groupedReferences));
|
|
return { renameFilename: void 0, renameLocation: void 0, edits };
|
|
}
|
|
return { edits: [] };
|
|
}
|
|
function doChange36(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
|
|
const signature = groupedReferences.signature;
|
|
const newFunctionDeclarationParams = map(createNewParameters(functionDeclaration, program, host), (param) => getSynthesizedDeepClone(param));
|
|
if (signature) {
|
|
const newSignatureParams = map(createNewParameters(signature, program, host), (param) => getSynthesizedDeepClone(param));
|
|
replaceParameters(signature, newSignatureParams);
|
|
}
|
|
replaceParameters(functionDeclaration, newFunctionDeclarationParams);
|
|
const functionCalls = sortAndDeduplicate(groupedReferences.functionCalls, (a, b) => compareValues(a.pos, b.pos));
|
|
for (const call of functionCalls) {
|
|
if (call.arguments && call.arguments.length) {
|
|
const newArgument = getSynthesizedDeepClone(createNewArgument(functionDeclaration, call.arguments), true);
|
|
changes.replaceNodeRange(
|
|
getSourceFileOfNode(call),
|
|
first(call.arguments),
|
|
last(call.arguments),
|
|
newArgument,
|
|
{ leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.IncludeAll, trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Include }
|
|
);
|
|
}
|
|
}
|
|
function replaceParameters(declarationOrSignature, parameterDeclarations) {
|
|
changes.replaceNodeRangeWithNodes(
|
|
sourceFile,
|
|
first(declarationOrSignature.parameters),
|
|
last(declarationOrSignature.parameters),
|
|
parameterDeclarations,
|
|
{
|
|
joiner: ", ",
|
|
indentation: 0,
|
|
leadingTriviaOption: ts_textChanges_exports.LeadingTriviaOption.IncludeAll,
|
|
trailingTriviaOption: ts_textChanges_exports.TrailingTriviaOption.Include
|
|
}
|
|
);
|
|
}
|
|
}
|
|
function getGroupedReferences(functionDeclaration, program, cancellationToken) {
|
|
const functionNames = getFunctionNames(functionDeclaration);
|
|
const classNames = isConstructorDeclaration(functionDeclaration) ? getClassNames(functionDeclaration) : [];
|
|
const names = deduplicate([...functionNames, ...classNames], equateValues);
|
|
const checker = program.getTypeChecker();
|
|
const references = flatMap(names, (name) => ts_FindAllReferences_exports.getReferenceEntriesForNode(-1, name, program, program.getSourceFiles(), cancellationToken));
|
|
const groupedReferences = groupReferences(references);
|
|
if (!every(groupedReferences.declarations, (decl) => contains(names, decl))) {
|
|
groupedReferences.valid = false;
|
|
}
|
|
return groupedReferences;
|
|
function groupReferences(referenceEntries) {
|
|
const classReferences = { accessExpressions: [], typeUsages: [] };
|
|
const groupedReferences2 = { functionCalls: [], declarations: [], classReferences, valid: true };
|
|
const functionSymbols = map(functionNames, getSymbolTargetAtLocation);
|
|
const classSymbols = map(classNames, getSymbolTargetAtLocation);
|
|
const isConstructor = isConstructorDeclaration(functionDeclaration);
|
|
const contextualSymbols = map(functionNames, (name) => getSymbolForContextualType(name, checker));
|
|
for (const entry of referenceEntries) {
|
|
if (entry.kind === ts_FindAllReferences_exports.EntryKind.Span) {
|
|
groupedReferences2.valid = false;
|
|
continue;
|
|
}
|
|
if (contains(contextualSymbols, getSymbolTargetAtLocation(entry.node))) {
|
|
if (isValidMethodSignature(entry.node.parent)) {
|
|
groupedReferences2.signature = entry.node.parent;
|
|
continue;
|
|
}
|
|
const call = entryToFunctionCall(entry);
|
|
if (call) {
|
|
groupedReferences2.functionCalls.push(call);
|
|
continue;
|
|
}
|
|
}
|
|
const contextualSymbol = getSymbolForContextualType(entry.node, checker);
|
|
if (contextualSymbol && contains(contextualSymbols, contextualSymbol)) {
|
|
const decl = entryToDeclaration(entry);
|
|
if (decl) {
|
|
groupedReferences2.declarations.push(decl);
|
|
continue;
|
|
}
|
|
}
|
|
if (contains(functionSymbols, getSymbolTargetAtLocation(entry.node)) || isNewExpressionTarget(entry.node)) {
|
|
const importOrExportReference = entryToImportOrExport(entry);
|
|
if (importOrExportReference) {
|
|
continue;
|
|
}
|
|
const decl = entryToDeclaration(entry);
|
|
if (decl) {
|
|
groupedReferences2.declarations.push(decl);
|
|
continue;
|
|
}
|
|
const call = entryToFunctionCall(entry);
|
|
if (call) {
|
|
groupedReferences2.functionCalls.push(call);
|
|
continue;
|
|
}
|
|
}
|
|
if (isConstructor && contains(classSymbols, getSymbolTargetAtLocation(entry.node))) {
|
|
const importOrExportReference = entryToImportOrExport(entry);
|
|
if (importOrExportReference) {
|
|
continue;
|
|
}
|
|
const decl = entryToDeclaration(entry);
|
|
if (decl) {
|
|
groupedReferences2.declarations.push(decl);
|
|
continue;
|
|
}
|
|
const accessExpression = entryToAccessExpression(entry);
|
|
if (accessExpression) {
|
|
classReferences.accessExpressions.push(accessExpression);
|
|
continue;
|
|
}
|
|
if (isClassDeclaration(functionDeclaration.parent)) {
|
|
const type = entryToType(entry);
|
|
if (type) {
|
|
classReferences.typeUsages.push(type);
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
groupedReferences2.valid = false;
|
|
}
|
|
return groupedReferences2;
|
|
}
|
|
function getSymbolTargetAtLocation(node) {
|
|
const symbol = checker.getSymbolAtLocation(node);
|
|
return symbol && getSymbolTarget(symbol, checker);
|
|
}
|
|
}
|
|
function getSymbolForContextualType(node, checker) {
|
|
const element = getContainingObjectLiteralElement(node);
|
|
if (element) {
|
|
const contextualType = checker.getContextualTypeForObjectLiteralElement(element);
|
|
const symbol = contextualType == null ? void 0 : contextualType.getSymbol();
|
|
if (symbol && !(getCheckFlags(symbol) & 6 /* Synthetic */)) {
|
|
return symbol;
|
|
}
|
|
}
|
|
}
|
|
function entryToImportOrExport(entry) {
|
|
const node = entry.node;
|
|
if (isImportSpecifier(node.parent) || isImportClause(node.parent) || isImportEqualsDeclaration(node.parent) || isNamespaceImport(node.parent)) {
|
|
return node;
|
|
}
|
|
if (isExportSpecifier(node.parent) || isExportAssignment(node.parent)) {
|
|
return node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function entryToDeclaration(entry) {
|
|
if (isDeclaration(entry.node.parent)) {
|
|
return entry.node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function entryToFunctionCall(entry) {
|
|
if (entry.node.parent) {
|
|
const functionReference = entry.node;
|
|
const parent2 = functionReference.parent;
|
|
switch (parent2.kind) {
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
const callOrNewExpression = tryCast(parent2, isCallOrNewExpression);
|
|
if (callOrNewExpression && callOrNewExpression.expression === functionReference) {
|
|
return callOrNewExpression;
|
|
}
|
|
break;
|
|
case 208 /* PropertyAccessExpression */:
|
|
const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression);
|
|
if (propertyAccessExpression && propertyAccessExpression.parent && propertyAccessExpression.name === functionReference) {
|
|
const callOrNewExpression2 = tryCast(propertyAccessExpression.parent, isCallOrNewExpression);
|
|
if (callOrNewExpression2 && callOrNewExpression2.expression === propertyAccessExpression) {
|
|
return callOrNewExpression2;
|
|
}
|
|
}
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
const elementAccessExpression = tryCast(parent2, isElementAccessExpression);
|
|
if (elementAccessExpression && elementAccessExpression.parent && elementAccessExpression.argumentExpression === functionReference) {
|
|
const callOrNewExpression2 = tryCast(elementAccessExpression.parent, isCallOrNewExpression);
|
|
if (callOrNewExpression2 && callOrNewExpression2.expression === elementAccessExpression) {
|
|
return callOrNewExpression2;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function entryToAccessExpression(entry) {
|
|
if (entry.node.parent) {
|
|
const reference = entry.node;
|
|
const parent2 = reference.parent;
|
|
switch (parent2.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression);
|
|
if (propertyAccessExpression && propertyAccessExpression.expression === reference) {
|
|
return propertyAccessExpression;
|
|
}
|
|
break;
|
|
case 209 /* ElementAccessExpression */:
|
|
const elementAccessExpression = tryCast(parent2, isElementAccessExpression);
|
|
if (elementAccessExpression && elementAccessExpression.expression === reference) {
|
|
return elementAccessExpression;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function entryToType(entry) {
|
|
const reference = entry.node;
|
|
if (getMeaningFromLocation(reference) === 2 /* Type */ || isExpressionWithTypeArgumentsInClassExtendsClause(reference.parent)) {
|
|
return reference;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getFunctionDeclarationAtPosition(file, startPosition, checker) {
|
|
const node = getTouchingToken(file, startPosition);
|
|
const functionDeclaration = getContainingFunctionDeclaration(node);
|
|
if (isTopLevelJSDoc(node))
|
|
return void 0;
|
|
if (functionDeclaration && isValidFunctionDeclaration(functionDeclaration, checker) && rangeContainsRange(functionDeclaration, node) && !(functionDeclaration.body && rangeContainsRange(functionDeclaration.body, node)))
|
|
return functionDeclaration;
|
|
return void 0;
|
|
}
|
|
function isTopLevelJSDoc(node) {
|
|
const containingJSDoc = findAncestor(node, isJSDocNode);
|
|
if (containingJSDoc) {
|
|
const containingNonJSDoc = findAncestor(containingJSDoc, (n) => !isJSDocNode(n));
|
|
return !!containingNonJSDoc && isFunctionLikeDeclaration(containingNonJSDoc);
|
|
}
|
|
return false;
|
|
}
|
|
function isValidMethodSignature(node) {
|
|
return isMethodSignature(node) && (isInterfaceDeclaration(node.parent) || isTypeLiteralNode(node.parent));
|
|
}
|
|
function isValidFunctionDeclaration(functionDeclaration, checker) {
|
|
var _a2;
|
|
if (!isValidParameterNodeArray(functionDeclaration.parameters, checker))
|
|
return false;
|
|
switch (functionDeclaration.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
return hasNameOrDefault(functionDeclaration) && isSingleImplementation(functionDeclaration, checker);
|
|
case 171 /* MethodDeclaration */:
|
|
if (isObjectLiteralExpression(functionDeclaration.parent)) {
|
|
const contextualSymbol = getSymbolForContextualType(functionDeclaration.name, checker);
|
|
return ((_a2 = contextualSymbol == null ? void 0 : contextualSymbol.declarations) == null ? void 0 : _a2.length) === 1 && isSingleImplementation(functionDeclaration, checker);
|
|
}
|
|
return isSingleImplementation(functionDeclaration, checker);
|
|
case 173 /* Constructor */:
|
|
if (isClassDeclaration(functionDeclaration.parent)) {
|
|
return hasNameOrDefault(functionDeclaration.parent) && isSingleImplementation(functionDeclaration, checker);
|
|
} else {
|
|
return isValidVariableDeclaration(functionDeclaration.parent.parent) && isSingleImplementation(functionDeclaration, checker);
|
|
}
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
return isValidVariableDeclaration(functionDeclaration.parent);
|
|
}
|
|
return false;
|
|
}
|
|
function isSingleImplementation(functionDeclaration, checker) {
|
|
return !!functionDeclaration.body && !checker.isImplementationOfOverload(functionDeclaration);
|
|
}
|
|
function hasNameOrDefault(functionOrClassDeclaration) {
|
|
if (!functionOrClassDeclaration.name) {
|
|
const defaultKeyword = findModifier(functionOrClassDeclaration, 88 /* DefaultKeyword */);
|
|
return !!defaultKeyword;
|
|
}
|
|
return true;
|
|
}
|
|
function isValidParameterNodeArray(parameters, checker) {
|
|
return getRefactorableParametersLength(parameters) >= minimumParameterLength && every(parameters, (paramDecl) => isValidParameterDeclaration(paramDecl, checker));
|
|
}
|
|
function isValidParameterDeclaration(parameterDeclaration, checker) {
|
|
if (isRestParameter(parameterDeclaration)) {
|
|
const type = checker.getTypeAtLocation(parameterDeclaration);
|
|
if (!checker.isArrayType(type) && !checker.isTupleType(type))
|
|
return false;
|
|
}
|
|
return !parameterDeclaration.modifiers && isIdentifier(parameterDeclaration.name);
|
|
}
|
|
function isValidVariableDeclaration(node) {
|
|
return isVariableDeclaration(node) && isVarConst(node) && isIdentifier(node.name) && !node.type;
|
|
}
|
|
function hasThisParameter(parameters) {
|
|
return parameters.length > 0 && isThis(parameters[0].name);
|
|
}
|
|
function getRefactorableParametersLength(parameters) {
|
|
if (hasThisParameter(parameters)) {
|
|
return parameters.length - 1;
|
|
}
|
|
return parameters.length;
|
|
}
|
|
function getRefactorableParameters(parameters) {
|
|
if (hasThisParameter(parameters)) {
|
|
parameters = factory.createNodeArray(parameters.slice(1), parameters.hasTrailingComma);
|
|
}
|
|
return parameters;
|
|
}
|
|
function createPropertyOrShorthandAssignment(name, initializer) {
|
|
if (isIdentifier(initializer) && getTextOfIdentifierOrLiteral(initializer) === name) {
|
|
return factory.createShorthandPropertyAssignment(name);
|
|
}
|
|
return factory.createPropertyAssignment(name, initializer);
|
|
}
|
|
function createNewArgument(functionDeclaration, functionArguments) {
|
|
const parameters = getRefactorableParameters(functionDeclaration.parameters);
|
|
const hasRestParameter2 = isRestParameter(last(parameters));
|
|
const nonRestArguments = hasRestParameter2 ? functionArguments.slice(0, parameters.length - 1) : functionArguments;
|
|
const properties = map(nonRestArguments, (arg, i) => {
|
|
const parameterName = getParameterName(parameters[i]);
|
|
const property = createPropertyOrShorthandAssignment(parameterName, arg);
|
|
suppressLeadingAndTrailingTrivia(property.name);
|
|
if (isPropertyAssignment(property))
|
|
suppressLeadingAndTrailingTrivia(property.initializer);
|
|
copyComments(arg, property);
|
|
return property;
|
|
});
|
|
if (hasRestParameter2 && functionArguments.length >= parameters.length) {
|
|
const restArguments = functionArguments.slice(parameters.length - 1);
|
|
const restProperty = factory.createPropertyAssignment(getParameterName(last(parameters)), factory.createArrayLiteralExpression(restArguments));
|
|
properties.push(restProperty);
|
|
}
|
|
const objectLiteral = factory.createObjectLiteralExpression(properties, false);
|
|
return objectLiteral;
|
|
}
|
|
function createNewParameters(functionDeclaration, program, host) {
|
|
const checker = program.getTypeChecker();
|
|
const refactorableParameters = getRefactorableParameters(functionDeclaration.parameters);
|
|
const bindingElements = map(refactorableParameters, createBindingElementFromParameterDeclaration);
|
|
const objectParameterName = factory.createObjectBindingPattern(bindingElements);
|
|
const objectParameterType = createParameterTypeNode(refactorableParameters);
|
|
let objectInitializer;
|
|
if (every(refactorableParameters, isOptionalParameter)) {
|
|
objectInitializer = factory.createObjectLiteralExpression();
|
|
}
|
|
const objectParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
objectParameterName,
|
|
void 0,
|
|
objectParameterType,
|
|
objectInitializer
|
|
);
|
|
if (hasThisParameter(functionDeclaration.parameters)) {
|
|
const thisParameter = functionDeclaration.parameters[0];
|
|
const newThisParameter = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
thisParameter.name,
|
|
void 0,
|
|
thisParameter.type
|
|
);
|
|
suppressLeadingAndTrailingTrivia(newThisParameter.name);
|
|
copyComments(thisParameter.name, newThisParameter.name);
|
|
if (thisParameter.type) {
|
|
suppressLeadingAndTrailingTrivia(newThisParameter.type);
|
|
copyComments(thisParameter.type, newThisParameter.type);
|
|
}
|
|
return factory.createNodeArray([newThisParameter, objectParameter]);
|
|
}
|
|
return factory.createNodeArray([objectParameter]);
|
|
function createBindingElementFromParameterDeclaration(parameterDeclaration) {
|
|
const element = factory.createBindingElement(
|
|
void 0,
|
|
void 0,
|
|
getParameterName(parameterDeclaration),
|
|
isRestParameter(parameterDeclaration) && isOptionalParameter(parameterDeclaration) ? factory.createArrayLiteralExpression() : parameterDeclaration.initializer
|
|
);
|
|
suppressLeadingAndTrailingTrivia(element);
|
|
if (parameterDeclaration.initializer && element.initializer) {
|
|
copyComments(parameterDeclaration.initializer, element.initializer);
|
|
}
|
|
return element;
|
|
}
|
|
function createParameterTypeNode(parameters) {
|
|
const members = map(parameters, createPropertySignatureFromParameterDeclaration);
|
|
const typeNode = addEmitFlags(factory.createTypeLiteralNode(members), 1 /* SingleLine */);
|
|
return typeNode;
|
|
}
|
|
function createPropertySignatureFromParameterDeclaration(parameterDeclaration) {
|
|
let parameterType = parameterDeclaration.type;
|
|
if (!parameterType && (parameterDeclaration.initializer || isRestParameter(parameterDeclaration))) {
|
|
parameterType = getTypeNode3(parameterDeclaration);
|
|
}
|
|
const propertySignature = factory.createPropertySignature(
|
|
void 0,
|
|
getParameterName(parameterDeclaration),
|
|
isOptionalParameter(parameterDeclaration) ? factory.createToken(57 /* QuestionToken */) : parameterDeclaration.questionToken,
|
|
parameterType
|
|
);
|
|
suppressLeadingAndTrailingTrivia(propertySignature);
|
|
copyComments(parameterDeclaration.name, propertySignature.name);
|
|
if (parameterDeclaration.type && propertySignature.type) {
|
|
copyComments(parameterDeclaration.type, propertySignature.type);
|
|
}
|
|
return propertySignature;
|
|
}
|
|
function getTypeNode3(node) {
|
|
const type = checker.getTypeAtLocation(node);
|
|
return getTypeNodeIfAccessible(type, node, program, host);
|
|
}
|
|
function isOptionalParameter(parameterDeclaration) {
|
|
if (isRestParameter(parameterDeclaration)) {
|
|
const type = checker.getTypeAtLocation(parameterDeclaration);
|
|
return !checker.isTupleType(type);
|
|
}
|
|
return checker.isOptionalParameter(parameterDeclaration);
|
|
}
|
|
}
|
|
function getParameterName(paramDeclaration) {
|
|
return getTextOfIdentifierOrLiteral(paramDeclaration.name);
|
|
}
|
|
function getClassNames(constructorDeclaration) {
|
|
switch (constructorDeclaration.parent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
const classDeclaration = constructorDeclaration.parent;
|
|
if (classDeclaration.name)
|
|
return [classDeclaration.name];
|
|
const defaultModifier = Debug.checkDefined(
|
|
findModifier(classDeclaration, 88 /* DefaultKeyword */),
|
|
"Nameless class declaration should be a default export"
|
|
);
|
|
return [defaultModifier];
|
|
case 228 /* ClassExpression */:
|
|
const classExpression = constructorDeclaration.parent;
|
|
const variableDeclaration = constructorDeclaration.parent.parent;
|
|
const className = classExpression.name;
|
|
if (className)
|
|
return [className, variableDeclaration.name];
|
|
return [variableDeclaration.name];
|
|
}
|
|
}
|
|
function getFunctionNames(functionDeclaration) {
|
|
switch (functionDeclaration.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
if (functionDeclaration.name)
|
|
return [functionDeclaration.name];
|
|
const defaultModifier = Debug.checkDefined(
|
|
findModifier(functionDeclaration, 88 /* DefaultKeyword */),
|
|
"Nameless function declaration should be a default export"
|
|
);
|
|
return [defaultModifier];
|
|
case 171 /* MethodDeclaration */:
|
|
return [functionDeclaration.name];
|
|
case 173 /* Constructor */:
|
|
const ctrKeyword = Debug.checkDefined(
|
|
findChildOfKind(functionDeclaration, 135 /* ConstructorKeyword */, functionDeclaration.getSourceFile()),
|
|
"Constructor declaration should have constructor keyword"
|
|
);
|
|
if (functionDeclaration.parent.kind === 228 /* ClassExpression */) {
|
|
const variableDeclaration = functionDeclaration.parent.parent;
|
|
return [variableDeclaration.name, ctrKeyword];
|
|
}
|
|
return [ctrKeyword];
|
|
case 216 /* ArrowFunction */:
|
|
return [functionDeclaration.parent.name];
|
|
case 215 /* FunctionExpression */:
|
|
if (functionDeclaration.name)
|
|
return [functionDeclaration.name, functionDeclaration.parent.name];
|
|
return [functionDeclaration.parent.name];
|
|
default:
|
|
return Debug.assertNever(functionDeclaration, `Unexpected function declaration kind ${functionDeclaration.kind}`);
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.convertStringOrTemplateLiteral.ts
|
|
var ts_refactor_convertStringOrTemplateLiteral_exports = {};
|
|
|
|
// src/services/refactors/convertStringOrTemplateLiteral.ts
|
|
var refactorName9 = "Convert to template string";
|
|
var refactorDescription5 = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
|
|
var convertStringAction = {
|
|
name: refactorName9,
|
|
description: refactorDescription5,
|
|
kind: "refactor.rewrite.string"
|
|
};
|
|
registerRefactor(refactorName9, {
|
|
kinds: [convertStringAction.kind],
|
|
getEditsForAction: getRefactorEditsToConvertToTemplateString,
|
|
getAvailableActions: getRefactorActionsToConvertToTemplateString
|
|
});
|
|
function getRefactorActionsToConvertToTemplateString(context) {
|
|
const { file, startPosition } = context;
|
|
const node = getNodeOrParentOfParentheses(file, startPosition);
|
|
const maybeBinary = getParentBinaryExpression(node);
|
|
const refactorInfo = { name: refactorName9, description: refactorDescription5, actions: [] };
|
|
if (isBinaryExpression(maybeBinary) && treeToArray(maybeBinary).isValidConcatenation) {
|
|
refactorInfo.actions.push(convertStringAction);
|
|
return [refactorInfo];
|
|
} else if (context.preferences.provideRefactorNotApplicableReason) {
|
|
refactorInfo.actions.push({
|
|
...convertStringAction,
|
|
notApplicableReason: getLocaleSpecificMessage(Diagnostics.Can_only_convert_string_concatenation)
|
|
});
|
|
return [refactorInfo];
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getNodeOrParentOfParentheses(file, startPosition) {
|
|
const node = getTokenAtPosition(file, startPosition);
|
|
const nestedBinary = getParentBinaryExpression(node);
|
|
const isNonStringBinary = !treeToArray(nestedBinary).isValidConcatenation;
|
|
if (isNonStringBinary && isParenthesizedExpression(nestedBinary.parent) && isBinaryExpression(nestedBinary.parent.parent)) {
|
|
return nestedBinary.parent.parent;
|
|
}
|
|
return node;
|
|
}
|
|
function getRefactorEditsToConvertToTemplateString(context, actionName2) {
|
|
const { file, startPosition } = context;
|
|
const node = getNodeOrParentOfParentheses(file, startPosition);
|
|
switch (actionName2) {
|
|
case refactorDescription5:
|
|
return { edits: getEditsForToTemplateLiteral(context, node) };
|
|
default:
|
|
return Debug.fail("invalid action");
|
|
}
|
|
}
|
|
function getEditsForToTemplateLiteral(context, node) {
|
|
const maybeBinary = getParentBinaryExpression(node);
|
|
const file = context.file;
|
|
const templateLiteral = nodesToTemplate(treeToArray(maybeBinary), file);
|
|
const trailingCommentRanges = getTrailingCommentRanges(file.text, maybeBinary.end);
|
|
if (trailingCommentRanges) {
|
|
const lastComment = trailingCommentRanges[trailingCommentRanges.length - 1];
|
|
const trailingRange = { pos: trailingCommentRanges[0].pos, end: lastComment.end };
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => {
|
|
t.deleteRange(file, trailingRange);
|
|
t.replaceNode(file, maybeBinary, templateLiteral);
|
|
});
|
|
} else {
|
|
return ts_textChanges_exports.ChangeTracker.with(context, (t) => t.replaceNode(file, maybeBinary, templateLiteral));
|
|
}
|
|
}
|
|
function isNotEqualsOperator(node) {
|
|
return node.operatorToken.kind !== 63 /* EqualsToken */;
|
|
}
|
|
function getParentBinaryExpression(expr) {
|
|
const container = findAncestor(expr.parent, (n) => {
|
|
switch (n.kind) {
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 209 /* ElementAccessExpression */:
|
|
return false;
|
|
case 225 /* TemplateExpression */:
|
|
case 223 /* BinaryExpression */:
|
|
return !(isBinaryExpression(n.parent) && isNotEqualsOperator(n.parent));
|
|
default:
|
|
return "quit";
|
|
}
|
|
});
|
|
return container || expr;
|
|
}
|
|
function treeToArray(current) {
|
|
const loop = (current2) => {
|
|
if (!isBinaryExpression(current2)) {
|
|
return {
|
|
nodes: [current2],
|
|
operators: [],
|
|
validOperators: true,
|
|
hasString: isStringLiteral(current2) || isNoSubstitutionTemplateLiteral(current2)
|
|
};
|
|
}
|
|
const { nodes: nodes2, operators: operators2, hasString: leftHasString, validOperators: leftOperatorValid } = loop(current2.left);
|
|
if (!(leftHasString || isStringLiteral(current2.right) || isTemplateExpression(current2.right))) {
|
|
return { nodes: [current2], operators: [], hasString: false, validOperators: true };
|
|
}
|
|
const currentOperatorValid = current2.operatorToken.kind === 39 /* PlusToken */;
|
|
const validOperators2 = leftOperatorValid && currentOperatorValid;
|
|
nodes2.push(current2.right);
|
|
operators2.push(current2.operatorToken);
|
|
return { nodes: nodes2, operators: operators2, hasString: true, validOperators: validOperators2 };
|
|
};
|
|
const { nodes, operators, validOperators, hasString } = loop(current);
|
|
return { nodes, operators, isValidConcatenation: validOperators && hasString };
|
|
}
|
|
var copyTrailingOperatorComments = (operators, file) => (index, targetNode) => {
|
|
if (index < operators.length) {
|
|
copyTrailingComments(operators[index], targetNode, file, 3 /* MultiLineCommentTrivia */, false);
|
|
}
|
|
};
|
|
var copyCommentFromMultiNode = (nodes, file, copyOperatorComments) => (indexes, targetNode) => {
|
|
while (indexes.length > 0) {
|
|
const index = indexes.shift();
|
|
copyTrailingComments(nodes[index], targetNode, file, 3 /* MultiLineCommentTrivia */, false);
|
|
copyOperatorComments(index, targetNode);
|
|
}
|
|
};
|
|
function escapeRawStringForTemplate(s) {
|
|
return s.replace(/\\.|[$`]/g, (m) => m[0] === "\\" ? m : "\\" + m);
|
|
}
|
|
function getRawTextOfTemplate(node) {
|
|
const rightShaving = isTemplateHead(node) || isTemplateMiddle(node) ? -2 : -1;
|
|
return getTextOfNode(node).slice(1, rightShaving);
|
|
}
|
|
function concatConsecutiveString(index, nodes) {
|
|
const indexes = [];
|
|
let text = "", rawText = "";
|
|
while (index < nodes.length) {
|
|
const node = nodes[index];
|
|
if (isStringLiteralLike(node)) {
|
|
text += node.text;
|
|
rawText += escapeRawStringForTemplate(getTextOfNode(node).slice(1, -1));
|
|
indexes.push(index);
|
|
index++;
|
|
} else if (isTemplateExpression(node)) {
|
|
text += node.head.text;
|
|
rawText += getRawTextOfTemplate(node.head);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return [index, text, rawText, indexes];
|
|
}
|
|
function nodesToTemplate({ nodes, operators }, file) {
|
|
const copyOperatorComments = copyTrailingOperatorComments(operators, file);
|
|
const copyCommentFromStringLiterals = copyCommentFromMultiNode(nodes, file, copyOperatorComments);
|
|
const [begin, headText, rawHeadText, headIndexes] = concatConsecutiveString(0, nodes);
|
|
if (begin === nodes.length) {
|
|
const noSubstitutionTemplateLiteral = factory.createNoSubstitutionTemplateLiteral(headText, rawHeadText);
|
|
copyCommentFromStringLiterals(headIndexes, noSubstitutionTemplateLiteral);
|
|
return noSubstitutionTemplateLiteral;
|
|
}
|
|
const templateSpans = [];
|
|
const templateHead = factory.createTemplateHead(headText, rawHeadText);
|
|
copyCommentFromStringLiterals(headIndexes, templateHead);
|
|
for (let i = begin; i < nodes.length; i++) {
|
|
const currentNode = getExpressionFromParenthesesOrExpression(nodes[i]);
|
|
copyOperatorComments(i, currentNode);
|
|
const [newIndex, subsequentText, rawSubsequentText, stringIndexes] = concatConsecutiveString(i + 1, nodes);
|
|
i = newIndex - 1;
|
|
const isLast = i === nodes.length - 1;
|
|
if (isTemplateExpression(currentNode)) {
|
|
const spans = map(currentNode.templateSpans, (span, index) => {
|
|
copyExpressionComments(span);
|
|
const isLastSpan = index === currentNode.templateSpans.length - 1;
|
|
const text = span.literal.text + (isLastSpan ? subsequentText : "");
|
|
const rawText = getRawTextOfTemplate(span.literal) + (isLastSpan ? rawSubsequentText : "");
|
|
return factory.createTemplateSpan(span.expression, isLast && isLastSpan ? factory.createTemplateTail(text, rawText) : factory.createTemplateMiddle(text, rawText));
|
|
});
|
|
templateSpans.push(...spans);
|
|
} else {
|
|
const templatePart = isLast ? factory.createTemplateTail(subsequentText, rawSubsequentText) : factory.createTemplateMiddle(subsequentText, rawSubsequentText);
|
|
copyCommentFromStringLiterals(stringIndexes, templatePart);
|
|
templateSpans.push(factory.createTemplateSpan(currentNode, templatePart));
|
|
}
|
|
}
|
|
return factory.createTemplateExpression(templateHead, templateSpans);
|
|
}
|
|
function copyExpressionComments(node) {
|
|
const file = node.getSourceFile();
|
|
copyTrailingComments(node, node.expression, file, 3 /* MultiLineCommentTrivia */, false);
|
|
copyTrailingAsLeadingComments(node.expression, node.expression, file, 3 /* MultiLineCommentTrivia */, false);
|
|
}
|
|
function getExpressionFromParenthesesOrExpression(node) {
|
|
if (isParenthesizedExpression(node)) {
|
|
copyExpressionComments(node);
|
|
node = node.expression;
|
|
}
|
|
return node;
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.convertToOptionalChainExpression.ts
|
|
var ts_refactor_convertToOptionalChainExpression_exports = {};
|
|
|
|
// src/services/refactors/convertToOptionalChainExpression.ts
|
|
var refactorName10 = "Convert to optional chain expression";
|
|
var convertToOptionalChainExpressionMessage = getLocaleSpecificMessage(Diagnostics.Convert_to_optional_chain_expression);
|
|
var toOptionalChainAction = {
|
|
name: refactorName10,
|
|
description: convertToOptionalChainExpressionMessage,
|
|
kind: "refactor.rewrite.expression.optionalChain"
|
|
};
|
|
registerRefactor(refactorName10, {
|
|
kinds: [toOptionalChainAction.kind],
|
|
getEditsForAction: getRefactorEditsToConvertToOptionalChain,
|
|
getAvailableActions: getRefactorActionsToConvertToOptionalChain
|
|
});
|
|
function getRefactorActionsToConvertToOptionalChain(context) {
|
|
const info = getInfo20(context, context.triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
return [{
|
|
name: refactorName10,
|
|
description: convertToOptionalChainExpressionMessage,
|
|
actions: [toOptionalChainAction]
|
|
}];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: refactorName10,
|
|
description: convertToOptionalChainExpressionMessage,
|
|
actions: [{ ...toOptionalChainAction, notApplicableReason: info.error }]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getRefactorEditsToConvertToOptionalChain(context, actionName2) {
|
|
const info = getInfo20(context);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(
|
|
context,
|
|
(t) => doChange37(context.file, context.program.getTypeChecker(), t, info, actionName2)
|
|
);
|
|
return { edits, renameFilename: void 0, renameLocation: void 0 };
|
|
}
|
|
function isValidExpression(node) {
|
|
return isBinaryExpression(node) || isConditionalExpression(node);
|
|
}
|
|
function isValidStatement(node) {
|
|
return isExpressionStatement(node) || isReturnStatement(node) || isVariableStatement(node);
|
|
}
|
|
function isValidExpressionOrStatement(node) {
|
|
return isValidExpression(node) || isValidStatement(node);
|
|
}
|
|
function getInfo20(context, considerEmptySpans = true) {
|
|
const { file, program } = context;
|
|
const span = getRefactorContextSpan(context);
|
|
const forEmptySpan = span.length === 0;
|
|
if (forEmptySpan && !considerEmptySpans)
|
|
return void 0;
|
|
const startToken = getTokenAtPosition(file, span.start);
|
|
const endToken = findTokenOnLeftOfPosition(file, span.start + span.length);
|
|
const adjustedSpan = createTextSpanFromBounds(startToken.pos, endToken && endToken.end >= startToken.pos ? endToken.getEnd() : startToken.getEnd());
|
|
const parent2 = forEmptySpan ? getValidParentNodeOfEmptySpan(startToken) : getValidParentNodeContainingSpan(startToken, adjustedSpan);
|
|
const expression = parent2 && isValidExpressionOrStatement(parent2) ? getExpression(parent2) : void 0;
|
|
if (!expression)
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_convertible_access_expression) };
|
|
const checker = program.getTypeChecker();
|
|
return isConditionalExpression(expression) ? getConditionalInfo(expression, checker) : getBinaryInfo(expression);
|
|
}
|
|
function getConditionalInfo(expression, checker) {
|
|
const condition = expression.condition;
|
|
const finalExpression = getFinalExpressionInChain(expression.whenTrue);
|
|
if (!finalExpression || checker.isNullableType(checker.getTypeAtLocation(finalExpression))) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_convertible_access_expression) };
|
|
}
|
|
if ((isPropertyAccessExpression(condition) || isIdentifier(condition)) && getMatchingStart(condition, finalExpression.expression)) {
|
|
return { finalExpression, occurrences: [condition], expression };
|
|
} else if (isBinaryExpression(condition)) {
|
|
const occurrences = getOccurrencesInExpression(finalExpression.expression, condition);
|
|
return occurrences ? { finalExpression, occurrences, expression } : { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_matching_access_expressions) };
|
|
}
|
|
}
|
|
function getBinaryInfo(expression) {
|
|
if (expression.operatorToken.kind !== 55 /* AmpersandAmpersandToken */) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Can_only_convert_logical_AND_access_chains) };
|
|
}
|
|
const finalExpression = getFinalExpressionInChain(expression.right);
|
|
if (!finalExpression)
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_convertible_access_expression) };
|
|
const occurrences = getOccurrencesInExpression(finalExpression.expression, expression.left);
|
|
return occurrences ? { finalExpression, occurrences, expression } : { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_matching_access_expressions) };
|
|
}
|
|
function getOccurrencesInExpression(matchTo, expression) {
|
|
const occurrences = [];
|
|
while (isBinaryExpression(expression) && expression.operatorToken.kind === 55 /* AmpersandAmpersandToken */) {
|
|
const match = getMatchingStart(skipParentheses(matchTo), skipParentheses(expression.right));
|
|
if (!match) {
|
|
break;
|
|
}
|
|
occurrences.push(match);
|
|
matchTo = match;
|
|
expression = expression.left;
|
|
}
|
|
const finalMatch = getMatchingStart(matchTo, expression);
|
|
if (finalMatch) {
|
|
occurrences.push(finalMatch);
|
|
}
|
|
return occurrences.length > 0 ? occurrences : void 0;
|
|
}
|
|
function getMatchingStart(chain, subchain) {
|
|
if (!isIdentifier(subchain) && !isPropertyAccessExpression(subchain) && !isElementAccessExpression(subchain)) {
|
|
return void 0;
|
|
}
|
|
return chainStartsWith(chain, subchain) ? subchain : void 0;
|
|
}
|
|
function chainStartsWith(chain, subchain) {
|
|
while (isCallExpression(chain) || isPropertyAccessExpression(chain) || isElementAccessExpression(chain)) {
|
|
if (getTextOfChainNode(chain) === getTextOfChainNode(subchain))
|
|
break;
|
|
chain = chain.expression;
|
|
}
|
|
while (isPropertyAccessExpression(chain) && isPropertyAccessExpression(subchain) || isElementAccessExpression(chain) && isElementAccessExpression(subchain)) {
|
|
if (getTextOfChainNode(chain) !== getTextOfChainNode(subchain))
|
|
return false;
|
|
chain = chain.expression;
|
|
subchain = subchain.expression;
|
|
}
|
|
return isIdentifier(chain) && isIdentifier(subchain) && chain.getText() === subchain.getText();
|
|
}
|
|
function getTextOfChainNode(node) {
|
|
if (isIdentifier(node) || isStringOrNumericLiteralLike(node)) {
|
|
return node.getText();
|
|
}
|
|
if (isPropertyAccessExpression(node)) {
|
|
return getTextOfChainNode(node.name);
|
|
}
|
|
if (isElementAccessExpression(node)) {
|
|
return getTextOfChainNode(node.argumentExpression);
|
|
}
|
|
return void 0;
|
|
}
|
|
function getValidParentNodeContainingSpan(node, span) {
|
|
while (node.parent) {
|
|
if (isValidExpressionOrStatement(node) && span.length !== 0 && node.end >= span.start + span.length) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getValidParentNodeOfEmptySpan(node) {
|
|
while (node.parent) {
|
|
if (isValidExpressionOrStatement(node) && !isValidExpressionOrStatement(node.parent)) {
|
|
return node;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return void 0;
|
|
}
|
|
function getExpression(node) {
|
|
if (isValidExpression(node)) {
|
|
return node;
|
|
}
|
|
if (isVariableStatement(node)) {
|
|
const variable = getSingleVariableOfVariableStatement(node);
|
|
const initializer = variable == null ? void 0 : variable.initializer;
|
|
return initializer && isValidExpression(initializer) ? initializer : void 0;
|
|
}
|
|
return node.expression && isValidExpression(node.expression) ? node.expression : void 0;
|
|
}
|
|
function getFinalExpressionInChain(node) {
|
|
node = skipParentheses(node);
|
|
if (isBinaryExpression(node)) {
|
|
return getFinalExpressionInChain(node.left);
|
|
} else if ((isPropertyAccessExpression(node) || isElementAccessExpression(node) || isCallExpression(node)) && !isOptionalChain(node)) {
|
|
return node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function convertOccurrences(checker, toConvert, occurrences) {
|
|
if (isPropertyAccessExpression(toConvert) || isElementAccessExpression(toConvert) || isCallExpression(toConvert)) {
|
|
const chain = convertOccurrences(checker, toConvert.expression, occurrences);
|
|
const lastOccurrence = occurrences.length > 0 ? occurrences[occurrences.length - 1] : void 0;
|
|
const isOccurrence = (lastOccurrence == null ? void 0 : lastOccurrence.getText()) === toConvert.expression.getText();
|
|
if (isOccurrence)
|
|
occurrences.pop();
|
|
if (isCallExpression(toConvert)) {
|
|
return isOccurrence ? factory.createCallChain(chain, factory.createToken(28 /* QuestionDotToken */), toConvert.typeArguments, toConvert.arguments) : factory.createCallChain(chain, toConvert.questionDotToken, toConvert.typeArguments, toConvert.arguments);
|
|
} else if (isPropertyAccessExpression(toConvert)) {
|
|
return isOccurrence ? factory.createPropertyAccessChain(chain, factory.createToken(28 /* QuestionDotToken */), toConvert.name) : factory.createPropertyAccessChain(chain, toConvert.questionDotToken, toConvert.name);
|
|
} else if (isElementAccessExpression(toConvert)) {
|
|
return isOccurrence ? factory.createElementAccessChain(chain, factory.createToken(28 /* QuestionDotToken */), toConvert.argumentExpression) : factory.createElementAccessChain(chain, toConvert.questionDotToken, toConvert.argumentExpression);
|
|
}
|
|
}
|
|
return toConvert;
|
|
}
|
|
function doChange37(sourceFile, checker, changes, info, _actionName) {
|
|
const { finalExpression, occurrences, expression } = info;
|
|
const firstOccurrence = occurrences[occurrences.length - 1];
|
|
const convertedChain = convertOccurrences(checker, finalExpression, occurrences);
|
|
if (convertedChain && (isPropertyAccessExpression(convertedChain) || isElementAccessExpression(convertedChain) || isCallExpression(convertedChain))) {
|
|
if (isBinaryExpression(expression)) {
|
|
changes.replaceNodeRange(sourceFile, firstOccurrence, finalExpression, convertedChain);
|
|
} else if (isConditionalExpression(expression)) {
|
|
changes.replaceNode(
|
|
sourceFile,
|
|
expression,
|
|
factory.createBinaryExpression(convertedChain, factory.createToken(60 /* QuestionQuestionToken */), expression.whenFalse)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.extractSymbol.ts
|
|
var ts_refactor_extractSymbol_exports = {};
|
|
__export(ts_refactor_extractSymbol_exports, {
|
|
Messages: () => Messages,
|
|
RangeFacts: () => RangeFacts,
|
|
getRangeToExtract: () => getRangeToExtract2,
|
|
getRefactorActionsToExtractSymbol: () => getRefactorActionsToExtractSymbol,
|
|
getRefactorEditsToExtractSymbol: () => getRefactorEditsToExtractSymbol
|
|
});
|
|
|
|
// src/services/refactors/extractSymbol.ts
|
|
var refactorName11 = "Extract Symbol";
|
|
var extractConstantAction = {
|
|
name: "Extract Constant",
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
|
|
kind: "refactor.extract.constant"
|
|
};
|
|
var extractFunctionAction = {
|
|
name: "Extract Function",
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_function),
|
|
kind: "refactor.extract.function"
|
|
};
|
|
registerRefactor(refactorName11, {
|
|
kinds: [
|
|
extractConstantAction.kind,
|
|
extractFunctionAction.kind
|
|
],
|
|
getEditsForAction: getRefactorEditsToExtractSymbol,
|
|
getAvailableActions: getRefactorActionsToExtractSymbol
|
|
});
|
|
function getRefactorActionsToExtractSymbol(context) {
|
|
const requestedRefactor = context.kind;
|
|
const rangeToExtract = getRangeToExtract2(context.file, getRefactorContextSpan(context), context.triggerReason === "invoked");
|
|
const targetRange = rangeToExtract.targetRange;
|
|
if (targetRange === void 0) {
|
|
if (!rangeToExtract.errors || rangeToExtract.errors.length === 0 || !context.preferences.provideRefactorNotApplicableReason) {
|
|
return emptyArray;
|
|
}
|
|
const errors = [];
|
|
if (refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
|
|
errors.push({
|
|
name: refactorName11,
|
|
description: extractFunctionAction.description,
|
|
actions: [{ ...extractFunctionAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
|
|
});
|
|
}
|
|
if (refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
|
|
errors.push({
|
|
name: refactorName11,
|
|
description: extractConstantAction.description,
|
|
actions: [{ ...extractConstantAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
|
|
});
|
|
}
|
|
return errors;
|
|
}
|
|
const extractions = getPossibleExtractions(targetRange, context);
|
|
if (extractions === void 0) {
|
|
return emptyArray;
|
|
}
|
|
const functionActions = [];
|
|
const usedFunctionNames = /* @__PURE__ */ new Map();
|
|
let innermostErrorFunctionAction;
|
|
const constantActions = [];
|
|
const usedConstantNames = /* @__PURE__ */ new Map();
|
|
let innermostErrorConstantAction;
|
|
let i = 0;
|
|
for (const { functionExtraction, constantExtraction } of extractions) {
|
|
if (refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
|
|
const description2 = functionExtraction.description;
|
|
if (functionExtraction.errors.length === 0) {
|
|
if (!usedFunctionNames.has(description2)) {
|
|
usedFunctionNames.set(description2, true);
|
|
functionActions.push({
|
|
description: description2,
|
|
name: `function_scope_${i}`,
|
|
kind: extractFunctionAction.kind
|
|
});
|
|
}
|
|
} else if (!innermostErrorFunctionAction) {
|
|
innermostErrorFunctionAction = {
|
|
description: description2,
|
|
name: `function_scope_${i}`,
|
|
notApplicableReason: getStringError(functionExtraction.errors),
|
|
kind: extractFunctionAction.kind
|
|
};
|
|
}
|
|
}
|
|
if (refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
|
|
const description2 = constantExtraction.description;
|
|
if (constantExtraction.errors.length === 0) {
|
|
if (!usedConstantNames.has(description2)) {
|
|
usedConstantNames.set(description2, true);
|
|
constantActions.push({
|
|
description: description2,
|
|
name: `constant_scope_${i}`,
|
|
kind: extractConstantAction.kind
|
|
});
|
|
}
|
|
} else if (!innermostErrorConstantAction) {
|
|
innermostErrorConstantAction = {
|
|
description: description2,
|
|
name: `constant_scope_${i}`,
|
|
notApplicableReason: getStringError(constantExtraction.errors),
|
|
kind: extractConstantAction.kind
|
|
};
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
const infos = [];
|
|
if (functionActions.length) {
|
|
infos.push({
|
|
name: refactorName11,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_function),
|
|
actions: functionActions
|
|
});
|
|
} else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorFunctionAction) {
|
|
infos.push({
|
|
name: refactorName11,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_function),
|
|
actions: [innermostErrorFunctionAction]
|
|
});
|
|
}
|
|
if (constantActions.length) {
|
|
infos.push({
|
|
name: refactorName11,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
|
|
actions: constantActions
|
|
});
|
|
} else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorConstantAction) {
|
|
infos.push({
|
|
name: refactorName11,
|
|
description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
|
|
actions: [innermostErrorConstantAction]
|
|
});
|
|
}
|
|
return infos.length ? infos : emptyArray;
|
|
function getStringError(errors) {
|
|
let error = errors[0].messageText;
|
|
if (typeof error !== "string") {
|
|
error = error.messageText;
|
|
}
|
|
return error;
|
|
}
|
|
}
|
|
function getRefactorEditsToExtractSymbol(context, actionName2) {
|
|
const rangeToExtract = getRangeToExtract2(context.file, getRefactorContextSpan(context));
|
|
const targetRange = rangeToExtract.targetRange;
|
|
const parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName2);
|
|
if (parsedFunctionIndexMatch) {
|
|
const index = +parsedFunctionIndexMatch[1];
|
|
Debug.assert(isFinite(index), "Expected to parse a finite number from the function scope index");
|
|
return getFunctionExtractionAtIndex(targetRange, context, index);
|
|
}
|
|
const parsedConstantIndexMatch = /^constant_scope_(\d+)$/.exec(actionName2);
|
|
if (parsedConstantIndexMatch) {
|
|
const index = +parsedConstantIndexMatch[1];
|
|
Debug.assert(isFinite(index), "Expected to parse a finite number from the constant scope index");
|
|
return getConstantExtractionAtIndex(targetRange, context, index);
|
|
}
|
|
Debug.fail("Unrecognized action name");
|
|
}
|
|
var Messages;
|
|
((Messages2) => {
|
|
function createMessage(message) {
|
|
return { message, code: 0, category: 3 /* Message */, key: message };
|
|
}
|
|
Messages2.cannotExtractRange = createMessage("Cannot extract range.");
|
|
Messages2.cannotExtractImport = createMessage("Cannot extract import statement.");
|
|
Messages2.cannotExtractSuper = createMessage("Cannot extract super call.");
|
|
Messages2.cannotExtractJSDoc = createMessage("Cannot extract JSDoc.");
|
|
Messages2.cannotExtractEmpty = createMessage("Cannot extract empty range.");
|
|
Messages2.expressionExpected = createMessage("expression expected.");
|
|
Messages2.uselessConstantType = createMessage("No reason to extract constant of type.");
|
|
Messages2.statementOrExpressionExpected = createMessage("Statement or expression expected.");
|
|
Messages2.cannotExtractRangeContainingConditionalBreakOrContinueStatements = createMessage("Cannot extract range containing conditional break or continue statements.");
|
|
Messages2.cannotExtractRangeContainingConditionalReturnStatement = createMessage("Cannot extract range containing conditional return statement.");
|
|
Messages2.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange = createMessage("Cannot extract range containing labeled break or continue with target outside of the range.");
|
|
Messages2.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators = createMessage("Cannot extract range containing writes to references located outside of the target range in generators.");
|
|
Messages2.typeWillNotBeVisibleInTheNewScope = createMessage("Type will not visible in the new scope.");
|
|
Messages2.functionWillNotBeVisibleInTheNewScope = createMessage("Function will not visible in the new scope.");
|
|
Messages2.cannotExtractIdentifier = createMessage("Select more than a single identifier.");
|
|
Messages2.cannotExtractExportedEntity = createMessage("Cannot extract exported declaration");
|
|
Messages2.cannotWriteInExpression = createMessage("Cannot write back side-effects when extracting an expression");
|
|
Messages2.cannotExtractReadonlyPropertyInitializerOutsideConstructor = createMessage("Cannot move initialization of read-only class property outside of the constructor");
|
|
Messages2.cannotExtractAmbientBlock = createMessage("Cannot extract code from ambient contexts");
|
|
Messages2.cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes");
|
|
Messages2.cannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS");
|
|
Messages2.cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block");
|
|
Messages2.cannotExtractFunctionsContainingThisToMethod = createMessage("Cannot extract functions containing this to method");
|
|
})(Messages || (Messages = {}));
|
|
var RangeFacts = /* @__PURE__ */ ((RangeFacts2) => {
|
|
RangeFacts2[RangeFacts2["None"] = 0] = "None";
|
|
RangeFacts2[RangeFacts2["HasReturn"] = 1] = "HasReturn";
|
|
RangeFacts2[RangeFacts2["IsGenerator"] = 2] = "IsGenerator";
|
|
RangeFacts2[RangeFacts2["IsAsyncFunction"] = 4] = "IsAsyncFunction";
|
|
RangeFacts2[RangeFacts2["UsesThis"] = 8] = "UsesThis";
|
|
RangeFacts2[RangeFacts2["UsesThisInFunction"] = 16] = "UsesThisInFunction";
|
|
RangeFacts2[RangeFacts2["InStaticRegion"] = 32] = "InStaticRegion";
|
|
return RangeFacts2;
|
|
})(RangeFacts || {});
|
|
function getRangeToExtract2(sourceFile, span, invoked = true) {
|
|
const { length: length2 } = span;
|
|
if (length2 === 0 && !invoked) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractEmpty)] };
|
|
}
|
|
const cursorRequest = length2 === 0 && invoked;
|
|
const startToken = findFirstNonJsxWhitespaceToken(sourceFile, span.start);
|
|
const endToken = findTokenOnLeftOfPosition(sourceFile, textSpanEnd(span));
|
|
const adjustedSpan = startToken && endToken && invoked ? getAdjustedSpanFromNodes(startToken, endToken, sourceFile) : span;
|
|
const start2 = cursorRequest ? getExtractableParent(startToken) : getParentNodeInSpan(startToken, sourceFile, adjustedSpan);
|
|
const end = cursorRequest ? start2 : getParentNodeInSpan(endToken, sourceFile, adjustedSpan);
|
|
let rangeFacts = 0 /* None */;
|
|
let thisNode;
|
|
if (!start2 || !end) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractRange)] };
|
|
}
|
|
if (start2.flags & 8388608 /* JSDoc */) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractJSDoc)] };
|
|
}
|
|
if (start2.parent !== end.parent) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractRange)] };
|
|
}
|
|
if (start2 !== end) {
|
|
if (!isBlockLike(start2.parent)) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractRange)] };
|
|
}
|
|
const statements = [];
|
|
for (const statement of start2.parent.statements) {
|
|
if (statement === start2 || statements.length) {
|
|
const errors2 = checkNode(statement);
|
|
if (errors2) {
|
|
return { errors: errors2 };
|
|
}
|
|
statements.push(statement);
|
|
}
|
|
if (statement === end) {
|
|
break;
|
|
}
|
|
}
|
|
if (!statements.length) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractRange)] };
|
|
}
|
|
return { targetRange: { range: statements, facts: rangeFacts, thisNode } };
|
|
}
|
|
if (isReturnStatement(start2) && !start2.expression) {
|
|
return { errors: [createFileDiagnostic(sourceFile, span.start, length2, Messages.cannotExtractRange)] };
|
|
}
|
|
const node = refineNode(start2);
|
|
const errors = checkRootNode(node) || checkNode(node);
|
|
if (errors) {
|
|
return { errors };
|
|
}
|
|
return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, thisNode } };
|
|
function refineNode(node2) {
|
|
if (isReturnStatement(node2)) {
|
|
if (node2.expression) {
|
|
return node2.expression;
|
|
}
|
|
} else if (isVariableStatement(node2) || isVariableDeclarationList(node2)) {
|
|
const declarations = isVariableStatement(node2) ? node2.declarationList.declarations : node2.declarations;
|
|
let numInitializers = 0;
|
|
let lastInitializer;
|
|
for (const declaration of declarations) {
|
|
if (declaration.initializer) {
|
|
numInitializers++;
|
|
lastInitializer = declaration.initializer;
|
|
}
|
|
}
|
|
if (numInitializers === 1) {
|
|
return lastInitializer;
|
|
}
|
|
} else if (isVariableDeclaration(node2)) {
|
|
if (node2.initializer) {
|
|
return node2.initializer;
|
|
}
|
|
}
|
|
return node2;
|
|
}
|
|
function checkRootNode(node2) {
|
|
if (isIdentifier(isExpressionStatement(node2) ? node2.expression : node2)) {
|
|
return [createDiagnosticForNode(node2, Messages.cannotExtractIdentifier)];
|
|
}
|
|
return void 0;
|
|
}
|
|
function checkForStaticContext(nodeToCheck, containingClass) {
|
|
let current = nodeToCheck;
|
|
while (current !== containingClass) {
|
|
if (current.kind === 169 /* PropertyDeclaration */) {
|
|
if (isStatic(current)) {
|
|
rangeFacts |= 32 /* InStaticRegion */;
|
|
}
|
|
break;
|
|
} else if (current.kind === 166 /* Parameter */) {
|
|
const ctorOrMethod = getContainingFunction(current);
|
|
if (ctorOrMethod.kind === 173 /* Constructor */) {
|
|
rangeFacts |= 32 /* InStaticRegion */;
|
|
}
|
|
break;
|
|
} else if (current.kind === 171 /* MethodDeclaration */) {
|
|
if (isStatic(current)) {
|
|
rangeFacts |= 32 /* InStaticRegion */;
|
|
}
|
|
}
|
|
current = current.parent;
|
|
}
|
|
}
|
|
function checkNode(nodeToCheck) {
|
|
let PermittedJumps;
|
|
((PermittedJumps2) => {
|
|
PermittedJumps2[PermittedJumps2["None"] = 0] = "None";
|
|
PermittedJumps2[PermittedJumps2["Break"] = 1] = "Break";
|
|
PermittedJumps2[PermittedJumps2["Continue"] = 2] = "Continue";
|
|
PermittedJumps2[PermittedJumps2["Return"] = 4] = "Return";
|
|
})(PermittedJumps || (PermittedJumps = {}));
|
|
Debug.assert(nodeToCheck.pos <= nodeToCheck.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (1)");
|
|
Debug.assert(!positionIsSynthesized(nodeToCheck.pos), "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (2)");
|
|
if (!isStatement(nodeToCheck) && !(isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck)) && !isStringLiteralJsxAttribute(nodeToCheck)) {
|
|
return [createDiagnosticForNode(nodeToCheck, Messages.statementOrExpressionExpected)];
|
|
}
|
|
if (nodeToCheck.flags & 16777216 /* Ambient */) {
|
|
return [createDiagnosticForNode(nodeToCheck, Messages.cannotExtractAmbientBlock)];
|
|
}
|
|
const containingClass = getContainingClass(nodeToCheck);
|
|
if (containingClass) {
|
|
checkForStaticContext(nodeToCheck, containingClass);
|
|
}
|
|
let errors2;
|
|
let permittedJumps = 4 /* Return */;
|
|
let seenLabels;
|
|
visit(nodeToCheck);
|
|
if (rangeFacts & 8 /* UsesThis */) {
|
|
const container = getThisContainer(nodeToCheck, false);
|
|
if (container.kind === 259 /* FunctionDeclaration */ || container.kind === 171 /* MethodDeclaration */ && container.parent.kind === 207 /* ObjectLiteralExpression */ || container.kind === 215 /* FunctionExpression */) {
|
|
rangeFacts |= 16 /* UsesThisInFunction */;
|
|
}
|
|
}
|
|
return errors2;
|
|
function visit(node2) {
|
|
if (errors2) {
|
|
return true;
|
|
}
|
|
if (isDeclaration(node2)) {
|
|
const declaringNode = node2.kind === 257 /* VariableDeclaration */ ? node2.parent.parent : node2;
|
|
if (hasSyntacticModifier(declaringNode, 1 /* Export */)) {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractExportedEntity));
|
|
return true;
|
|
}
|
|
}
|
|
switch (node2.kind) {
|
|
case 269 /* ImportDeclaration */:
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractImport));
|
|
return true;
|
|
case 274 /* ExportAssignment */:
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractExportedEntity));
|
|
return true;
|
|
case 106 /* SuperKeyword */:
|
|
if (node2.parent.kind === 210 /* CallExpression */) {
|
|
const containingClass2 = getContainingClass(node2);
|
|
if (containingClass2 === void 0 || containingClass2.pos < span.start || containingClass2.end >= span.start + span.length) {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractSuper));
|
|
return true;
|
|
}
|
|
} else {
|
|
rangeFacts |= 8 /* UsesThis */;
|
|
thisNode = node2;
|
|
}
|
|
break;
|
|
case 216 /* ArrowFunction */:
|
|
forEachChild(node2, function check(n) {
|
|
if (isThis(n)) {
|
|
rangeFacts |= 8 /* UsesThis */;
|
|
thisNode = node2;
|
|
} else if (isClassLike(n) || isFunctionLike(n) && !isArrowFunction(n)) {
|
|
return false;
|
|
} else {
|
|
forEachChild(n, check);
|
|
}
|
|
});
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
if (isSourceFile(node2.parent) && node2.parent.externalModuleIndicator === void 0) {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.functionWillNotBeVisibleInTheNewScope));
|
|
}
|
|
case 228 /* ClassExpression */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return false;
|
|
}
|
|
const savedPermittedJumps = permittedJumps;
|
|
switch (node2.kind) {
|
|
case 242 /* IfStatement */:
|
|
permittedJumps &= ~4 /* Return */;
|
|
break;
|
|
case 255 /* TryStatement */:
|
|
permittedJumps = 0 /* None */;
|
|
break;
|
|
case 238 /* Block */:
|
|
if (node2.parent && node2.parent.kind === 255 /* TryStatement */ && node2.parent.finallyBlock === node2) {
|
|
permittedJumps = 4 /* Return */;
|
|
}
|
|
break;
|
|
case 293 /* DefaultClause */:
|
|
case 292 /* CaseClause */:
|
|
permittedJumps |= 1 /* Break */;
|
|
break;
|
|
default:
|
|
if (isIterationStatement(node2, false)) {
|
|
permittedJumps |= 1 /* Break */ | 2 /* Continue */;
|
|
}
|
|
break;
|
|
}
|
|
switch (node2.kind) {
|
|
case 194 /* ThisType */:
|
|
case 108 /* ThisKeyword */:
|
|
rangeFacts |= 8 /* UsesThis */;
|
|
thisNode = node2;
|
|
break;
|
|
case 253 /* LabeledStatement */: {
|
|
const label = node2.label;
|
|
(seenLabels || (seenLabels = [])).push(label.escapedText);
|
|
forEachChild(node2, visit);
|
|
seenLabels.pop();
|
|
break;
|
|
}
|
|
case 249 /* BreakStatement */:
|
|
case 248 /* ContinueStatement */: {
|
|
const label = node2.label;
|
|
if (label) {
|
|
if (!contains(seenLabels, label.escapedText)) {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange));
|
|
}
|
|
} else {
|
|
if (!(permittedJumps & (node2.kind === 249 /* BreakStatement */ ? 1 /* Break */ : 2 /* Continue */))) {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractRangeContainingConditionalBreakOrContinueStatements));
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case 220 /* AwaitExpression */:
|
|
rangeFacts |= 4 /* IsAsyncFunction */;
|
|
break;
|
|
case 226 /* YieldExpression */:
|
|
rangeFacts |= 2 /* IsGenerator */;
|
|
break;
|
|
case 250 /* ReturnStatement */:
|
|
if (permittedJumps & 4 /* Return */) {
|
|
rangeFacts |= 1 /* HasReturn */;
|
|
} else {
|
|
(errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.cannotExtractRangeContainingConditionalReturnStatement));
|
|
}
|
|
break;
|
|
default:
|
|
forEachChild(node2, visit);
|
|
break;
|
|
}
|
|
permittedJumps = savedPermittedJumps;
|
|
}
|
|
}
|
|
}
|
|
function getAdjustedSpanFromNodes(startNode2, endNode2, sourceFile) {
|
|
const start2 = startNode2.getStart(sourceFile);
|
|
let end = endNode2.getEnd();
|
|
if (sourceFile.text.charCodeAt(end) === 59 /* semicolon */) {
|
|
end++;
|
|
}
|
|
return { start: start2, length: end - start2 };
|
|
}
|
|
function getStatementOrExpressionRange(node) {
|
|
if (isStatement(node)) {
|
|
return [node];
|
|
}
|
|
if (isExpressionNode(node)) {
|
|
return isExpressionStatement(node.parent) ? [node.parent] : node;
|
|
}
|
|
if (isStringLiteralJsxAttribute(node)) {
|
|
return node;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isScope(node) {
|
|
return isArrowFunction(node) ? isFunctionBody(node.body) : isFunctionLikeDeclaration(node) || isSourceFile(node) || isModuleBlock(node) || isClassLike(node);
|
|
}
|
|
function collectEnclosingScopes(range) {
|
|
let current = isReadonlyArray(range.range) ? first(range.range) : range.range;
|
|
if (range.facts & 8 /* UsesThis */ && !(range.facts & 16 /* UsesThisInFunction */)) {
|
|
const containingClass = getContainingClass(current);
|
|
if (containingClass) {
|
|
const containingFunction = findAncestor(current, isFunctionLikeDeclaration);
|
|
return containingFunction ? [containingFunction, containingClass] : [containingClass];
|
|
}
|
|
}
|
|
const scopes = [];
|
|
while (true) {
|
|
current = current.parent;
|
|
if (current.kind === 166 /* Parameter */) {
|
|
current = findAncestor(current, (parent2) => isFunctionLikeDeclaration(parent2)).parent;
|
|
}
|
|
if (isScope(current)) {
|
|
scopes.push(current);
|
|
if (current.kind === 308 /* SourceFile */) {
|
|
return scopes;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function getFunctionExtractionAtIndex(targetRange, context, requestedChangesIndex) {
|
|
const { scopes, readsAndWrites: { target, usagesPerScope, functionErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
|
|
Debug.assert(!functionErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
|
|
context.cancellationToken.throwIfCancellationRequested();
|
|
return extractFunctionInScope(target, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], exposedVariableDeclarations, targetRange, context);
|
|
}
|
|
function getConstantExtractionAtIndex(targetRange, context, requestedChangesIndex) {
|
|
const { scopes, readsAndWrites: { target, usagesPerScope, constantErrorsPerScope, exposedVariableDeclarations } } = getPossibleExtractionsWorker(targetRange, context);
|
|
Debug.assert(!constantErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?");
|
|
Debug.assert(exposedVariableDeclarations.length === 0, "Extract constant accepted a range containing a variable declaration?");
|
|
context.cancellationToken.throwIfCancellationRequested();
|
|
const expression = isExpression(target) ? target : target.statements[0].expression;
|
|
return extractConstantInScope(expression, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], targetRange.facts, context);
|
|
}
|
|
function getPossibleExtractions(targetRange, context) {
|
|
const { scopes, readsAndWrites: { functionErrorsPerScope, constantErrorsPerScope } } = getPossibleExtractionsWorker(targetRange, context);
|
|
const extractions = scopes.map((scope, i) => {
|
|
const functionDescriptionPart = getDescriptionForFunctionInScope(scope);
|
|
const constantDescriptionPart = getDescriptionForConstantInScope(scope);
|
|
const scopeDescription = isFunctionLikeDeclaration(scope) ? getDescriptionForFunctionLikeDeclaration(scope) : isClassLike(scope) ? getDescriptionForClassLikeDeclaration(scope) : getDescriptionForModuleLikeDeclaration(scope);
|
|
let functionDescription;
|
|
let constantDescription;
|
|
if (scopeDescription === SpecialScope.Global) {
|
|
functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "global"]);
|
|
constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "global"]);
|
|
} else if (scopeDescription === SpecialScope.Module) {
|
|
functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "module"]);
|
|
constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "module"]);
|
|
} else {
|
|
functionDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [functionDescriptionPart, scopeDescription]);
|
|
constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_1), [constantDescriptionPart, scopeDescription]);
|
|
}
|
|
if (i === 0 && !isClassLike(scope)) {
|
|
constantDescription = formatStringFromArgs(getLocaleSpecificMessage(Diagnostics.Extract_to_0_in_enclosing_scope), [constantDescriptionPart]);
|
|
}
|
|
return {
|
|
functionExtraction: {
|
|
description: functionDescription,
|
|
errors: functionErrorsPerScope[i]
|
|
},
|
|
constantExtraction: {
|
|
description: constantDescription,
|
|
errors: constantErrorsPerScope[i]
|
|
}
|
|
};
|
|
});
|
|
return extractions;
|
|
}
|
|
function getPossibleExtractionsWorker(targetRange, context) {
|
|
const { file: sourceFile } = context;
|
|
const scopes = collectEnclosingScopes(targetRange);
|
|
const enclosingTextRange = getEnclosingTextRange(targetRange, sourceFile);
|
|
const readsAndWrites = collectReadsAndWrites(
|
|
targetRange,
|
|
scopes,
|
|
enclosingTextRange,
|
|
sourceFile,
|
|
context.program.getTypeChecker(),
|
|
context.cancellationToken
|
|
);
|
|
return { scopes, readsAndWrites };
|
|
}
|
|
function getDescriptionForFunctionInScope(scope) {
|
|
return isFunctionLikeDeclaration(scope) ? "inner function" : isClassLike(scope) ? "method" : "function";
|
|
}
|
|
function getDescriptionForConstantInScope(scope) {
|
|
return isClassLike(scope) ? "readonly field" : "constant";
|
|
}
|
|
function getDescriptionForFunctionLikeDeclaration(scope) {
|
|
switch (scope.kind) {
|
|
case 173 /* Constructor */:
|
|
return "constructor";
|
|
case 215 /* FunctionExpression */:
|
|
case 259 /* FunctionDeclaration */:
|
|
return scope.name ? `function '${scope.name.text}'` : ANONYMOUS;
|
|
case 216 /* ArrowFunction */:
|
|
return "arrow function";
|
|
case 171 /* MethodDeclaration */:
|
|
return `method '${scope.name.getText()}'`;
|
|
case 174 /* GetAccessor */:
|
|
return `'get ${scope.name.getText()}'`;
|
|
case 175 /* SetAccessor */:
|
|
return `'set ${scope.name.getText()}'`;
|
|
default:
|
|
throw Debug.assertNever(scope, `Unexpected scope kind ${scope.kind}`);
|
|
}
|
|
}
|
|
function getDescriptionForClassLikeDeclaration(scope) {
|
|
return scope.kind === 260 /* ClassDeclaration */ ? scope.name ? `class '${scope.name.text}'` : "anonymous class declaration" : scope.name ? `class expression '${scope.name.text}'` : "anonymous class expression";
|
|
}
|
|
function getDescriptionForModuleLikeDeclaration(scope) {
|
|
return scope.kind === 265 /* ModuleBlock */ ? `namespace '${scope.parent.name.getText()}'` : scope.externalModuleIndicator ? SpecialScope.Module : SpecialScope.Global;
|
|
}
|
|
var SpecialScope = /* @__PURE__ */ ((SpecialScope2) => {
|
|
SpecialScope2[SpecialScope2["Module"] = 0] = "Module";
|
|
SpecialScope2[SpecialScope2["Global"] = 1] = "Global";
|
|
return SpecialScope2;
|
|
})(SpecialScope || {});
|
|
function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range, context) {
|
|
const checker = context.program.getTypeChecker();
|
|
const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
|
|
const importAdder = ts_codefix_exports.createImportAdder(context.file, context.program, context.preferences, context.host);
|
|
const file = scope.getSourceFile();
|
|
const functionNameText = getUniqueName(isClassLike(scope) ? "newMethod" : "newFunction", file);
|
|
const isJS = isInJSFile(scope);
|
|
const functionName = factory.createIdentifier(functionNameText);
|
|
let returnType;
|
|
const parameters = [];
|
|
const callArguments = [];
|
|
let writes;
|
|
usagesInScope.forEach((usage, name) => {
|
|
let typeNode;
|
|
if (!isJS) {
|
|
let type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node);
|
|
type = checker.getBaseTypeOfLiteralType(type);
|
|
typeNode = ts_codefix_exports.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NoTruncation */);
|
|
}
|
|
const paramDecl = factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
name,
|
|
void 0,
|
|
typeNode
|
|
);
|
|
parameters.push(paramDecl);
|
|
if (usage.usage === Usage.Write) {
|
|
(writes || (writes = [])).push(usage);
|
|
}
|
|
callArguments.push(factory.createIdentifier(name));
|
|
});
|
|
const typeParametersAndDeclarations = arrayFrom(typeParameterUsages.values()).map((type) => ({ type, declaration: getFirstDeclaration(type) }));
|
|
const sortedTypeParametersAndDeclarations = typeParametersAndDeclarations.sort(compareTypesByDeclarationOrder);
|
|
const typeParameters = sortedTypeParametersAndDeclarations.length === 0 ? void 0 : sortedTypeParametersAndDeclarations.map((t) => t.declaration);
|
|
const callTypeArguments = typeParameters !== void 0 ? typeParameters.map((decl) => factory.createTypeReferenceNode(decl.name, void 0)) : void 0;
|
|
if (isExpression(node) && !isJS) {
|
|
const contextualType = checker.getContextualType(node);
|
|
returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NoTruncation */);
|
|
}
|
|
const { body, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & 1 /* HasReturn */));
|
|
suppressLeadingAndTrailingTrivia(body);
|
|
let newFunction;
|
|
const callThis = !!(range.facts & 16 /* UsesThisInFunction */);
|
|
if (isClassLike(scope)) {
|
|
const modifiers = isJS ? [] : [factory.createModifier(121 /* PrivateKeyword */)];
|
|
if (range.facts & 32 /* InStaticRegion */) {
|
|
modifiers.push(factory.createModifier(124 /* StaticKeyword */));
|
|
}
|
|
if (range.facts & 4 /* IsAsyncFunction */) {
|
|
modifiers.push(factory.createModifier(132 /* AsyncKeyword */));
|
|
}
|
|
newFunction = factory.createMethodDeclaration(
|
|
modifiers.length ? modifiers : void 0,
|
|
range.facts & 2 /* IsGenerator */ ? factory.createToken(41 /* AsteriskToken */) : void 0,
|
|
functionName,
|
|
void 0,
|
|
typeParameters,
|
|
parameters,
|
|
returnType,
|
|
body
|
|
);
|
|
} else {
|
|
if (callThis) {
|
|
parameters.unshift(
|
|
factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"this",
|
|
void 0,
|
|
checker.typeToTypeNode(
|
|
checker.getTypeAtLocation(range.thisNode),
|
|
scope,
|
|
1 /* NoTruncation */
|
|
),
|
|
void 0
|
|
)
|
|
);
|
|
}
|
|
newFunction = factory.createFunctionDeclaration(
|
|
range.facts & 4 /* IsAsyncFunction */ ? [factory.createToken(132 /* AsyncKeyword */)] : void 0,
|
|
range.facts & 2 /* IsGenerator */ ? factory.createToken(41 /* AsteriskToken */) : void 0,
|
|
functionName,
|
|
typeParameters,
|
|
parameters,
|
|
returnType,
|
|
body
|
|
);
|
|
}
|
|
const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext(context);
|
|
const minInsertionPos = (isReadonlyArray(range.range) ? last(range.range) : range.range).end;
|
|
const nodeToInsertBefore = getNodeToInsertFunctionBefore(minInsertionPos, scope);
|
|
if (nodeToInsertBefore) {
|
|
changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newFunction, true);
|
|
} else {
|
|
changeTracker.insertNodeAtEndOfScope(context.file, scope, newFunction);
|
|
}
|
|
importAdder.writeFixes(changeTracker);
|
|
const newNodes = [];
|
|
const called = getCalledExpression(scope, range, functionNameText);
|
|
if (callThis) {
|
|
callArguments.unshift(factory.createIdentifier("this"));
|
|
}
|
|
let call = factory.createCallExpression(
|
|
callThis ? factory.createPropertyAccessExpression(
|
|
called,
|
|
"call"
|
|
) : called,
|
|
callTypeArguments,
|
|
callArguments
|
|
);
|
|
if (range.facts & 2 /* IsGenerator */) {
|
|
call = factory.createYieldExpression(factory.createToken(41 /* AsteriskToken */), call);
|
|
}
|
|
if (range.facts & 4 /* IsAsyncFunction */) {
|
|
call = factory.createAwaitExpression(call);
|
|
}
|
|
if (isInJSXContent(node)) {
|
|
call = factory.createJsxExpression(void 0, call);
|
|
}
|
|
if (exposedVariableDeclarations.length && !writes) {
|
|
Debug.assert(!returnValueProperty, "Expected no returnValueProperty");
|
|
Debug.assert(!(range.facts & 1 /* HasReturn */), "Expected RangeFacts.HasReturn flag to be unset");
|
|
if (exposedVariableDeclarations.length === 1) {
|
|
const variableDeclaration = exposedVariableDeclarations[0];
|
|
newNodes.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[factory.createVariableDeclaration(getSynthesizedDeepClone(variableDeclaration.name), void 0, getSynthesizedDeepClone(variableDeclaration.type), call)],
|
|
variableDeclaration.parent.flags
|
|
)
|
|
));
|
|
} else {
|
|
const bindingElements = [];
|
|
const typeElements = [];
|
|
let commonNodeFlags = exposedVariableDeclarations[0].parent.flags;
|
|
let sawExplicitType = false;
|
|
for (const variableDeclaration of exposedVariableDeclarations) {
|
|
bindingElements.push(factory.createBindingElement(
|
|
void 0,
|
|
void 0,
|
|
getSynthesizedDeepClone(variableDeclaration.name)
|
|
));
|
|
const variableType = checker.typeToTypeNode(
|
|
checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(variableDeclaration)),
|
|
scope,
|
|
1 /* NoTruncation */
|
|
);
|
|
typeElements.push(factory.createPropertySignature(
|
|
void 0,
|
|
variableDeclaration.symbol.name,
|
|
void 0,
|
|
variableType
|
|
));
|
|
sawExplicitType = sawExplicitType || variableDeclaration.type !== void 0;
|
|
commonNodeFlags = commonNodeFlags & variableDeclaration.parent.flags;
|
|
}
|
|
const typeLiteral = sawExplicitType ? factory.createTypeLiteralNode(typeElements) : void 0;
|
|
if (typeLiteral) {
|
|
setEmitFlags(typeLiteral, 1 /* SingleLine */);
|
|
}
|
|
newNodes.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[factory.createVariableDeclaration(
|
|
factory.createObjectBindingPattern(bindingElements),
|
|
void 0,
|
|
typeLiteral,
|
|
call
|
|
)],
|
|
commonNodeFlags
|
|
)
|
|
));
|
|
}
|
|
} else if (exposedVariableDeclarations.length || writes) {
|
|
if (exposedVariableDeclarations.length) {
|
|
for (const variableDeclaration of exposedVariableDeclarations) {
|
|
let flags = variableDeclaration.parent.flags;
|
|
if (flags & 2 /* Const */) {
|
|
flags = flags & ~2 /* Const */ | 1 /* Let */;
|
|
}
|
|
newNodes.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[factory.createVariableDeclaration(variableDeclaration.symbol.name, void 0, getTypeDeepCloneUnionUndefined(variableDeclaration.type))],
|
|
flags
|
|
)
|
|
));
|
|
}
|
|
}
|
|
if (returnValueProperty) {
|
|
newNodes.push(factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList(
|
|
[factory.createVariableDeclaration(returnValueProperty, void 0, getTypeDeepCloneUnionUndefined(returnType))],
|
|
1 /* Let */
|
|
)
|
|
));
|
|
}
|
|
const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
|
|
if (returnValueProperty) {
|
|
assignments.unshift(factory.createShorthandPropertyAssignment(returnValueProperty));
|
|
}
|
|
if (assignments.length === 1) {
|
|
Debug.assert(!returnValueProperty, "Shouldn't have returnValueProperty here");
|
|
newNodes.push(factory.createExpressionStatement(factory.createAssignment(assignments[0].name, call)));
|
|
if (range.facts & 1 /* HasReturn */) {
|
|
newNodes.push(factory.createReturnStatement());
|
|
}
|
|
} else {
|
|
newNodes.push(factory.createExpressionStatement(factory.createAssignment(factory.createObjectLiteralExpression(assignments), call)));
|
|
if (returnValueProperty) {
|
|
newNodes.push(factory.createReturnStatement(factory.createIdentifier(returnValueProperty)));
|
|
}
|
|
}
|
|
} else {
|
|
if (range.facts & 1 /* HasReturn */) {
|
|
newNodes.push(factory.createReturnStatement(call));
|
|
} else if (isReadonlyArray(range.range)) {
|
|
newNodes.push(factory.createExpressionStatement(call));
|
|
} else {
|
|
newNodes.push(call);
|
|
}
|
|
}
|
|
if (isReadonlyArray(range.range)) {
|
|
changeTracker.replaceNodeRangeWithNodes(context.file, first(range.range), last(range.range), newNodes);
|
|
} else {
|
|
changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes);
|
|
}
|
|
const edits = changeTracker.getChanges();
|
|
const renameRange = isReadonlyArray(range.range) ? first(range.range) : range.range;
|
|
const renameFilename = renameRange.getSourceFile().fileName;
|
|
const renameLocation = getRenameLocation(edits, renameFilename, functionNameText, false);
|
|
return { renameFilename, renameLocation, edits };
|
|
function getTypeDeepCloneUnionUndefined(typeNode) {
|
|
if (typeNode === void 0) {
|
|
return void 0;
|
|
}
|
|
const clone2 = getSynthesizedDeepClone(typeNode);
|
|
let withoutParens = clone2;
|
|
while (isParenthesizedTypeNode(withoutParens)) {
|
|
withoutParens = withoutParens.type;
|
|
}
|
|
return isUnionTypeNode(withoutParens) && find(withoutParens.types, (t) => t.kind === 155 /* UndefinedKeyword */) ? clone2 : factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(155 /* UndefinedKeyword */)]);
|
|
}
|
|
}
|
|
function extractConstantInScope(node, scope, { substitutions }, rangeFacts, context) {
|
|
const checker = context.program.getTypeChecker();
|
|
const file = scope.getSourceFile();
|
|
const localNameText = isPropertyAccessExpression(node) && !isClassLike(scope) && !checker.resolveName(node.name.text, node, 111551 /* Value */, false) && !isPrivateIdentifier(node.name) && !isKeyword(node.name.originalKeywordKind) ? node.name.text : getUniqueName(isClassLike(scope) ? "newProperty" : "newLocal", file);
|
|
const isJS = isInJSFile(scope);
|
|
let variableType = isJS || !checker.isContextSensitive(node) ? void 0 : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NoTruncation */);
|
|
let initializer = transformConstantInitializer(skipParentheses(node), substitutions);
|
|
({ variableType, initializer } = transformFunctionInitializerAndType(variableType, initializer));
|
|
suppressLeadingAndTrailingTrivia(initializer);
|
|
const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext(context);
|
|
if (isClassLike(scope)) {
|
|
Debug.assert(!isJS, "Cannot extract to a JS class");
|
|
const modifiers = [];
|
|
modifiers.push(factory.createModifier(121 /* PrivateKeyword */));
|
|
if (rangeFacts & 32 /* InStaticRegion */) {
|
|
modifiers.push(factory.createModifier(124 /* StaticKeyword */));
|
|
}
|
|
modifiers.push(factory.createModifier(146 /* ReadonlyKeyword */));
|
|
const newVariable = factory.createPropertyDeclaration(
|
|
modifiers,
|
|
localNameText,
|
|
void 0,
|
|
variableType,
|
|
initializer
|
|
);
|
|
let localReference = factory.createPropertyAccessExpression(
|
|
rangeFacts & 32 /* InStaticRegion */ ? factory.createIdentifier(scope.name.getText()) : factory.createThis(),
|
|
factory.createIdentifier(localNameText)
|
|
);
|
|
if (isInJSXContent(node)) {
|
|
localReference = factory.createJsxExpression(void 0, localReference);
|
|
}
|
|
const maxInsertionPos = node.pos;
|
|
const nodeToInsertBefore = getNodeToInsertPropertyBefore(maxInsertionPos, scope);
|
|
changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariable, true);
|
|
changeTracker.replaceNode(context.file, node, localReference);
|
|
} else {
|
|
const newVariableDeclaration = factory.createVariableDeclaration(localNameText, void 0, variableType, initializer);
|
|
const oldVariableDeclaration = getContainingVariableDeclarationIfInList(node, scope);
|
|
if (oldVariableDeclaration) {
|
|
changeTracker.insertNodeBefore(context.file, oldVariableDeclaration, newVariableDeclaration);
|
|
const localReference = factory.createIdentifier(localNameText);
|
|
changeTracker.replaceNode(context.file, node, localReference);
|
|
} else if (node.parent.kind === 241 /* ExpressionStatement */ && scope === findAncestor(node, isScope)) {
|
|
const newVariableStatement = factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList([newVariableDeclaration], 2 /* Const */)
|
|
);
|
|
changeTracker.replaceNode(context.file, node.parent, newVariableStatement);
|
|
} else {
|
|
const newVariableStatement = factory.createVariableStatement(
|
|
void 0,
|
|
factory.createVariableDeclarationList([newVariableDeclaration], 2 /* Const */)
|
|
);
|
|
const nodeToInsertBefore = getNodeToInsertConstantBefore(node, scope);
|
|
if (nodeToInsertBefore.pos === 0) {
|
|
changeTracker.insertNodeAtTopOfFile(context.file, newVariableStatement, false);
|
|
} else {
|
|
changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariableStatement, false);
|
|
}
|
|
if (node.parent.kind === 241 /* ExpressionStatement */) {
|
|
changeTracker.delete(context.file, node.parent);
|
|
} else {
|
|
let localReference = factory.createIdentifier(localNameText);
|
|
if (isInJSXContent(node)) {
|
|
localReference = factory.createJsxExpression(void 0, localReference);
|
|
}
|
|
changeTracker.replaceNode(context.file, node, localReference);
|
|
}
|
|
}
|
|
}
|
|
const edits = changeTracker.getChanges();
|
|
const renameFilename = node.getSourceFile().fileName;
|
|
const renameLocation = getRenameLocation(edits, renameFilename, localNameText, true);
|
|
return { renameFilename, renameLocation, edits };
|
|
function transformFunctionInitializerAndType(variableType2, initializer2) {
|
|
if (variableType2 === void 0)
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
if (!isFunctionExpression(initializer2) && !isArrowFunction(initializer2) || !!initializer2.typeParameters)
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
const functionType = checker.getTypeAtLocation(node);
|
|
const functionSignature = singleOrUndefined(checker.getSignaturesOfType(functionType, 0 /* Call */));
|
|
if (!functionSignature)
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
if (!!functionSignature.getTypeParameters())
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
const parameters = [];
|
|
let hasAny = false;
|
|
for (const p of initializer2.parameters) {
|
|
if (p.type) {
|
|
parameters.push(p);
|
|
} else {
|
|
const paramType = checker.getTypeAtLocation(p);
|
|
if (paramType === checker.getAnyType())
|
|
hasAny = true;
|
|
parameters.push(factory.updateParameterDeclaration(
|
|
p,
|
|
p.modifiers,
|
|
p.dotDotDotToken,
|
|
p.name,
|
|
p.questionToken,
|
|
p.type || checker.typeToTypeNode(paramType, scope, 1 /* NoTruncation */),
|
|
p.initializer
|
|
));
|
|
}
|
|
}
|
|
if (hasAny)
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
variableType2 = void 0;
|
|
if (isArrowFunction(initializer2)) {
|
|
initializer2 = factory.updateArrowFunction(
|
|
initializer2,
|
|
canHaveModifiers(node) ? getModifiers(node) : void 0,
|
|
initializer2.typeParameters,
|
|
parameters,
|
|
initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */),
|
|
initializer2.equalsGreaterThanToken,
|
|
initializer2.body
|
|
);
|
|
} else {
|
|
if (functionSignature && !!functionSignature.thisParameter) {
|
|
const firstParameter = firstOrUndefined(parameters);
|
|
if (!firstParameter || isIdentifier(firstParameter.name) && firstParameter.name.escapedText !== "this") {
|
|
const thisType = checker.getTypeOfSymbolAtLocation(functionSignature.thisParameter, node);
|
|
parameters.splice(0, 0, factory.createParameterDeclaration(
|
|
void 0,
|
|
void 0,
|
|
"this",
|
|
void 0,
|
|
checker.typeToTypeNode(thisType, scope, 1 /* NoTruncation */)
|
|
));
|
|
}
|
|
}
|
|
initializer2 = factory.updateFunctionExpression(
|
|
initializer2,
|
|
canHaveModifiers(node) ? getModifiers(node) : void 0,
|
|
initializer2.asteriskToken,
|
|
initializer2.name,
|
|
initializer2.typeParameters,
|
|
parameters,
|
|
initializer2.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NoTruncation */),
|
|
initializer2.body
|
|
);
|
|
}
|
|
return { variableType: variableType2, initializer: initializer2 };
|
|
}
|
|
}
|
|
function getContainingVariableDeclarationIfInList(node, scope) {
|
|
let prevNode;
|
|
while (node !== void 0 && node !== scope) {
|
|
if (isVariableDeclaration(node) && node.initializer === prevNode && isVariableDeclarationList(node.parent) && node.parent.declarations.length > 1) {
|
|
return node;
|
|
}
|
|
prevNode = node;
|
|
node = node.parent;
|
|
}
|
|
}
|
|
function getFirstDeclaration(type) {
|
|
let firstDeclaration;
|
|
const symbol = type.symbol;
|
|
if (symbol && symbol.declarations) {
|
|
for (const declaration of symbol.declarations) {
|
|
if (firstDeclaration === void 0 || declaration.pos < firstDeclaration.pos) {
|
|
firstDeclaration = declaration;
|
|
}
|
|
}
|
|
}
|
|
return firstDeclaration;
|
|
}
|
|
function compareTypesByDeclarationOrder({ type: type1, declaration: declaration1 }, { type: type2, declaration: declaration2 }) {
|
|
return compareProperties(declaration1, declaration2, "pos", compareValues) || compareStringsCaseSensitive(
|
|
type1.symbol ? type1.symbol.getName() : "",
|
|
type2.symbol ? type2.symbol.getName() : ""
|
|
) || compareValues(type1.id, type2.id);
|
|
}
|
|
function getCalledExpression(scope, range, functionNameText) {
|
|
const functionReference = factory.createIdentifier(functionNameText);
|
|
if (isClassLike(scope)) {
|
|
const lhs = range.facts & 32 /* InStaticRegion */ ? factory.createIdentifier(scope.name.text) : factory.createThis();
|
|
return factory.createPropertyAccessExpression(lhs, functionReference);
|
|
} else {
|
|
return functionReference;
|
|
}
|
|
}
|
|
function transformFunctionBody(body, exposedVariableDeclarations, writes, substitutions, hasReturn2) {
|
|
const hasWritesOrVariableDeclarations = writes !== void 0 || exposedVariableDeclarations.length > 0;
|
|
if (isBlock(body) && !hasWritesOrVariableDeclarations && substitutions.size === 0) {
|
|
return { body: factory.createBlock(body.statements, true), returnValueProperty: void 0 };
|
|
}
|
|
let returnValueProperty;
|
|
let ignoreReturns = false;
|
|
const statements = factory.createNodeArray(isBlock(body) ? body.statements.slice(0) : [isStatement(body) ? body : factory.createReturnStatement(skipParentheses(body))]);
|
|
if (hasWritesOrVariableDeclarations || substitutions.size) {
|
|
const rewrittenStatements = visitNodes2(statements, visitor).slice();
|
|
if (hasWritesOrVariableDeclarations && !hasReturn2 && isStatement(body)) {
|
|
const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
|
|
if (assignments.length === 1) {
|
|
rewrittenStatements.push(factory.createReturnStatement(assignments[0].name));
|
|
} else {
|
|
rewrittenStatements.push(factory.createReturnStatement(factory.createObjectLiteralExpression(assignments)));
|
|
}
|
|
}
|
|
return { body: factory.createBlock(rewrittenStatements, true), returnValueProperty };
|
|
} else {
|
|
return { body: factory.createBlock(statements, true), returnValueProperty: void 0 };
|
|
}
|
|
function visitor(node) {
|
|
if (!ignoreReturns && isReturnStatement(node) && hasWritesOrVariableDeclarations) {
|
|
const assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes);
|
|
if (node.expression) {
|
|
if (!returnValueProperty) {
|
|
returnValueProperty = "__return";
|
|
}
|
|
assignments.unshift(factory.createPropertyAssignment(returnValueProperty, visitNode(node.expression, visitor)));
|
|
}
|
|
if (assignments.length === 1) {
|
|
return factory.createReturnStatement(assignments[0].name);
|
|
} else {
|
|
return factory.createReturnStatement(factory.createObjectLiteralExpression(assignments));
|
|
}
|
|
} else {
|
|
const oldIgnoreReturns = ignoreReturns;
|
|
ignoreReturns = ignoreReturns || isFunctionLikeDeclaration(node) || isClassLike(node);
|
|
const substitution = substitutions.get(getNodeId(node).toString());
|
|
const result = substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
|
|
ignoreReturns = oldIgnoreReturns;
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
function transformConstantInitializer(initializer, substitutions) {
|
|
return substitutions.size ? visitor(initializer) : initializer;
|
|
function visitor(node) {
|
|
const substitution = substitutions.get(getNodeId(node).toString());
|
|
return substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
|
|
}
|
|
}
|
|
function getStatementsOrClassElements(scope) {
|
|
if (isFunctionLikeDeclaration(scope)) {
|
|
const body = scope.body;
|
|
if (isBlock(body)) {
|
|
return body.statements;
|
|
}
|
|
} else if (isModuleBlock(scope) || isSourceFile(scope)) {
|
|
return scope.statements;
|
|
} else if (isClassLike(scope)) {
|
|
return scope.members;
|
|
} else {
|
|
assertType(scope);
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function getNodeToInsertFunctionBefore(minPos, scope) {
|
|
return find(getStatementsOrClassElements(scope), (child) => child.pos >= minPos && isFunctionLikeDeclaration(child) && !isConstructorDeclaration(child));
|
|
}
|
|
function getNodeToInsertPropertyBefore(maxPos, scope) {
|
|
const members = scope.members;
|
|
Debug.assert(members.length > 0, "Found no members");
|
|
let prevMember;
|
|
let allProperties = true;
|
|
for (const member of members) {
|
|
if (member.pos > maxPos) {
|
|
return prevMember || members[0];
|
|
}
|
|
if (allProperties && !isPropertyDeclaration(member)) {
|
|
if (prevMember !== void 0) {
|
|
return member;
|
|
}
|
|
allProperties = false;
|
|
}
|
|
prevMember = member;
|
|
}
|
|
if (prevMember === void 0)
|
|
return Debug.fail();
|
|
return prevMember;
|
|
}
|
|
function getNodeToInsertConstantBefore(node, scope) {
|
|
Debug.assert(!isClassLike(scope));
|
|
let prevScope;
|
|
for (let curr = node; curr !== scope; curr = curr.parent) {
|
|
if (isScope(curr)) {
|
|
prevScope = curr;
|
|
}
|
|
}
|
|
for (let curr = (prevScope || node).parent; ; curr = curr.parent) {
|
|
if (isBlockLike(curr)) {
|
|
let prevStatement;
|
|
for (const statement of curr.statements) {
|
|
if (statement.pos > node.pos) {
|
|
break;
|
|
}
|
|
prevStatement = statement;
|
|
}
|
|
if (!prevStatement && isCaseClause(curr)) {
|
|
Debug.assert(isSwitchStatement(curr.parent.parent), "Grandparent isn't a switch statement");
|
|
return curr.parent.parent;
|
|
}
|
|
return Debug.checkDefined(prevStatement, "prevStatement failed to get set");
|
|
}
|
|
Debug.assert(curr !== scope, "Didn't encounter a block-like before encountering scope");
|
|
}
|
|
}
|
|
function getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes) {
|
|
const variableAssignments = map(exposedVariableDeclarations, (v) => factory.createShorthandPropertyAssignment(v.symbol.name));
|
|
const writeAssignments = map(writes, (w) => factory.createShorthandPropertyAssignment(w.symbol.name));
|
|
return variableAssignments === void 0 ? writeAssignments : writeAssignments === void 0 ? variableAssignments : variableAssignments.concat(writeAssignments);
|
|
}
|
|
function isReadonlyArray(v) {
|
|
return isArray(v);
|
|
}
|
|
function getEnclosingTextRange(targetRange, sourceFile) {
|
|
return isReadonlyArray(targetRange.range) ? { pos: first(targetRange.range).getStart(sourceFile), end: last(targetRange.range).getEnd() } : targetRange.range;
|
|
}
|
|
var Usage = /* @__PURE__ */ ((Usage2) => {
|
|
Usage2[Usage2["Read"] = 1] = "Read";
|
|
Usage2[Usage2["Write"] = 2] = "Write";
|
|
return Usage2;
|
|
})(Usage || {});
|
|
function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, checker, cancellationToken) {
|
|
const allTypeParameterUsages = /* @__PURE__ */ new Map();
|
|
const usagesPerScope = [];
|
|
const substitutionsPerScope = [];
|
|
const functionErrorsPerScope = [];
|
|
const constantErrorsPerScope = [];
|
|
const visibleDeclarationsInExtractedRange = [];
|
|
const exposedVariableSymbolSet = /* @__PURE__ */ new Map();
|
|
const exposedVariableDeclarations = [];
|
|
let firstExposedNonVariableDeclaration;
|
|
const expression = !isReadonlyArray(targetRange.range) ? targetRange.range : targetRange.range.length === 1 && isExpressionStatement(targetRange.range[0]) ? targetRange.range[0].expression : void 0;
|
|
let expressionDiagnostic;
|
|
if (expression === void 0) {
|
|
const statements = targetRange.range;
|
|
const start2 = first(statements).getStart();
|
|
const end = last(statements).end;
|
|
expressionDiagnostic = createFileDiagnostic(sourceFile, start2, end - start2, Messages.expressionExpected);
|
|
} else if (checker.getTypeAtLocation(expression).flags & (16384 /* Void */ | 131072 /* Never */)) {
|
|
expressionDiagnostic = createDiagnosticForNode(expression, Messages.uselessConstantType);
|
|
}
|
|
for (const scope of scopes) {
|
|
usagesPerScope.push({ usages: /* @__PURE__ */ new Map(), typeParameterUsages: /* @__PURE__ */ new Map(), substitutions: /* @__PURE__ */ new Map() });
|
|
substitutionsPerScope.push(/* @__PURE__ */ new Map());
|
|
functionErrorsPerScope.push([]);
|
|
const constantErrors = [];
|
|
if (expressionDiagnostic) {
|
|
constantErrors.push(expressionDiagnostic);
|
|
}
|
|
if (isClassLike(scope) && isInJSFile(scope)) {
|
|
constantErrors.push(createDiagnosticForNode(scope, Messages.cannotExtractToJSClass));
|
|
}
|
|
if (isArrowFunction(scope) && !isBlock(scope.body)) {
|
|
constantErrors.push(createDiagnosticForNode(scope, Messages.cannotExtractToExpressionArrowFunction));
|
|
}
|
|
constantErrorsPerScope.push(constantErrors);
|
|
}
|
|
const seenUsages = /* @__PURE__ */ new Map();
|
|
const target = isReadonlyArray(targetRange.range) ? factory.createBlock(targetRange.range) : targetRange.range;
|
|
const unmodifiedNode = isReadonlyArray(targetRange.range) ? first(targetRange.range) : targetRange.range;
|
|
const inGenericContext = isInGenericContext(unmodifiedNode);
|
|
collectUsages(target);
|
|
if (inGenericContext && !isReadonlyArray(targetRange.range) && !isJsxAttribute(targetRange.range)) {
|
|
const contextualType = checker.getContextualType(targetRange.range);
|
|
recordTypeParameterUsages(contextualType);
|
|
}
|
|
if (allTypeParameterUsages.size > 0) {
|
|
const seenTypeParameterUsages = /* @__PURE__ */ new Map();
|
|
let i = 0;
|
|
for (let curr = unmodifiedNode; curr !== void 0 && i < scopes.length; curr = curr.parent) {
|
|
if (curr === scopes[i]) {
|
|
seenTypeParameterUsages.forEach((typeParameter, id) => {
|
|
usagesPerScope[i].typeParameterUsages.set(id, typeParameter);
|
|
});
|
|
i++;
|
|
}
|
|
if (isDeclarationWithTypeParameters(curr)) {
|
|
for (const typeParameterDecl of getEffectiveTypeParameterDeclarations(curr)) {
|
|
const typeParameter = checker.getTypeAtLocation(typeParameterDecl);
|
|
if (allTypeParameterUsages.has(typeParameter.id.toString())) {
|
|
seenTypeParameterUsages.set(typeParameter.id.toString(), typeParameter);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Debug.assert(i === scopes.length, "Should have iterated all scopes");
|
|
}
|
|
if (visibleDeclarationsInExtractedRange.length) {
|
|
const containingLexicalScopeOfExtraction = isBlockScope(scopes[0], scopes[0].parent) ? scopes[0] : getEnclosingBlockScopeContainer(scopes[0]);
|
|
forEachChild(containingLexicalScopeOfExtraction, checkForUsedDeclarations);
|
|
}
|
|
for (let i = 0; i < scopes.length; i++) {
|
|
const scopeUsages = usagesPerScope[i];
|
|
if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) {
|
|
const errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range;
|
|
constantErrorsPerScope[i].push(createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes));
|
|
}
|
|
if (targetRange.facts & 16 /* UsesThisInFunction */ && isClassLike(scopes[i])) {
|
|
functionErrorsPerScope[i].push(createDiagnosticForNode(targetRange.thisNode, Messages.cannotExtractFunctionsContainingThisToMethod));
|
|
}
|
|
let hasWrite = false;
|
|
let readonlyClassPropertyWrite;
|
|
usagesPerScope[i].usages.forEach((value) => {
|
|
if (value.usage === 2 /* Write */) {
|
|
hasWrite = true;
|
|
if (value.symbol.flags & 106500 /* ClassMember */ && value.symbol.valueDeclaration && hasEffectiveModifier(value.symbol.valueDeclaration, 64 /* Readonly */)) {
|
|
readonlyClassPropertyWrite = value.symbol.valueDeclaration;
|
|
}
|
|
}
|
|
});
|
|
Debug.assert(isReadonlyArray(targetRange.range) || exposedVariableDeclarations.length === 0, "No variable declarations expected if something was extracted");
|
|
if (hasWrite && !isReadonlyArray(targetRange.range)) {
|
|
const diag2 = createDiagnosticForNode(targetRange.range, Messages.cannotWriteInExpression);
|
|
functionErrorsPerScope[i].push(diag2);
|
|
constantErrorsPerScope[i].push(diag2);
|
|
} else if (readonlyClassPropertyWrite && i > 0) {
|
|
const diag2 = createDiagnosticForNode(readonlyClassPropertyWrite, Messages.cannotExtractReadonlyPropertyInitializerOutsideConstructor);
|
|
functionErrorsPerScope[i].push(diag2);
|
|
constantErrorsPerScope[i].push(diag2);
|
|
} else if (firstExposedNonVariableDeclaration) {
|
|
const diag2 = createDiagnosticForNode(firstExposedNonVariableDeclaration, Messages.cannotExtractExportedEntity);
|
|
functionErrorsPerScope[i].push(diag2);
|
|
constantErrorsPerScope[i].push(diag2);
|
|
}
|
|
}
|
|
return { target, usagesPerScope, functionErrorsPerScope, constantErrorsPerScope, exposedVariableDeclarations };
|
|
function isInGenericContext(node) {
|
|
return !!findAncestor(node, (n) => isDeclarationWithTypeParameters(n) && getEffectiveTypeParameterDeclarations(n).length !== 0);
|
|
}
|
|
function recordTypeParameterUsages(type) {
|
|
const symbolWalker = checker.getSymbolWalker(() => (cancellationToken.throwIfCancellationRequested(), true));
|
|
const { visitedTypes } = symbolWalker.walkType(type);
|
|
for (const visitedType of visitedTypes) {
|
|
if (visitedType.isTypeParameter()) {
|
|
allTypeParameterUsages.set(visitedType.id.toString(), visitedType);
|
|
}
|
|
}
|
|
}
|
|
function collectUsages(node, valueUsage = 1 /* Read */) {
|
|
if (inGenericContext) {
|
|
const type = checker.getTypeAtLocation(node);
|
|
recordTypeParameterUsages(type);
|
|
}
|
|
if (isDeclaration(node) && node.symbol) {
|
|
visibleDeclarationsInExtractedRange.push(node);
|
|
}
|
|
if (isAssignmentExpression(node)) {
|
|
collectUsages(node.left, 2 /* Write */);
|
|
collectUsages(node.right);
|
|
} else if (isUnaryExpressionWithWrite(node)) {
|
|
collectUsages(node.operand, 2 /* Write */);
|
|
} else if (isPropertyAccessExpression(node) || isElementAccessExpression(node)) {
|
|
forEachChild(node, collectUsages);
|
|
} else if (isIdentifier(node)) {
|
|
if (!node.parent) {
|
|
return;
|
|
}
|
|
if (isQualifiedName(node.parent) && node !== node.parent.left) {
|
|
return;
|
|
}
|
|
if (isPropertyAccessExpression(node.parent) && node !== node.parent.expression) {
|
|
return;
|
|
}
|
|
recordUsage(node, valueUsage, isPartOfTypeNode(node));
|
|
} else {
|
|
forEachChild(node, collectUsages);
|
|
}
|
|
}
|
|
function recordUsage(n, usage, isTypeNode2) {
|
|
const symbolId = recordUsagebySymbol(n, usage, isTypeNode2);
|
|
if (symbolId) {
|
|
for (let i = 0; i < scopes.length; i++) {
|
|
const substitution = substitutionsPerScope[i].get(symbolId);
|
|
if (substitution) {
|
|
usagesPerScope[i].substitutions.set(getNodeId(n).toString(), substitution);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function recordUsagebySymbol(identifier, usage, isTypeName) {
|
|
const symbol = getSymbolReferencedByIdentifier(identifier);
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
const symbolId = getSymbolId(symbol).toString();
|
|
const lastUsage = seenUsages.get(symbolId);
|
|
if (lastUsage && lastUsage >= usage) {
|
|
return symbolId;
|
|
}
|
|
seenUsages.set(symbolId, usage);
|
|
if (lastUsage) {
|
|
for (const perScope of usagesPerScope) {
|
|
const prevEntry = perScope.usages.get(identifier.text);
|
|
if (prevEntry) {
|
|
perScope.usages.set(identifier.text, { usage, symbol, node: identifier });
|
|
}
|
|
}
|
|
return symbolId;
|
|
}
|
|
const decls = symbol.getDeclarations();
|
|
const declInFile = decls && find(decls, (d) => d.getSourceFile() === sourceFile);
|
|
if (!declInFile) {
|
|
return void 0;
|
|
}
|
|
if (rangeContainsStartEnd(enclosingTextRange, declInFile.getStart(), declInFile.end)) {
|
|
return void 0;
|
|
}
|
|
if (targetRange.facts & 2 /* IsGenerator */ && usage === 2 /* Write */) {
|
|
const diag2 = createDiagnosticForNode(identifier, Messages.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators);
|
|
for (const errors of functionErrorsPerScope) {
|
|
errors.push(diag2);
|
|
}
|
|
for (const errors of constantErrorsPerScope) {
|
|
errors.push(diag2);
|
|
}
|
|
}
|
|
for (let i = 0; i < scopes.length; i++) {
|
|
const scope = scopes[i];
|
|
const resolvedSymbol = checker.resolveName(symbol.name, scope, symbol.flags, false);
|
|
if (resolvedSymbol === symbol) {
|
|
continue;
|
|
}
|
|
if (!substitutionsPerScope[i].has(symbolId)) {
|
|
const substitution = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.exportSymbol || symbol, scope, isTypeName);
|
|
if (substitution) {
|
|
substitutionsPerScope[i].set(symbolId, substitution);
|
|
} else if (isTypeName) {
|
|
if (!(symbol.flags & 262144 /* TypeParameter */)) {
|
|
const diag2 = createDiagnosticForNode(identifier, Messages.typeWillNotBeVisibleInTheNewScope);
|
|
functionErrorsPerScope[i].push(diag2);
|
|
constantErrorsPerScope[i].push(diag2);
|
|
}
|
|
} else {
|
|
usagesPerScope[i].usages.set(identifier.text, { usage, symbol, node: identifier });
|
|
}
|
|
}
|
|
}
|
|
return symbolId;
|
|
}
|
|
function checkForUsedDeclarations(node) {
|
|
if (node === targetRange.range || isReadonlyArray(targetRange.range) && targetRange.range.indexOf(node) >= 0) {
|
|
return;
|
|
}
|
|
const sym = isIdentifier(node) ? getSymbolReferencedByIdentifier(node) : checker.getSymbolAtLocation(node);
|
|
if (sym) {
|
|
const decl = find(visibleDeclarationsInExtractedRange, (d) => d.symbol === sym);
|
|
if (decl) {
|
|
if (isVariableDeclaration(decl)) {
|
|
const idString = decl.symbol.id.toString();
|
|
if (!exposedVariableSymbolSet.has(idString)) {
|
|
exposedVariableDeclarations.push(decl);
|
|
exposedVariableSymbolSet.set(idString, true);
|
|
}
|
|
} else {
|
|
firstExposedNonVariableDeclaration = firstExposedNonVariableDeclaration || decl;
|
|
}
|
|
}
|
|
}
|
|
forEachChild(node, checkForUsedDeclarations);
|
|
}
|
|
function getSymbolReferencedByIdentifier(identifier) {
|
|
return identifier.parent && isShorthandPropertyAssignment(identifier.parent) && identifier.parent.name === identifier ? checker.getShorthandAssignmentValueSymbol(identifier.parent) : checker.getSymbolAtLocation(identifier);
|
|
}
|
|
function tryReplaceWithQualifiedNameOrPropertyAccess(symbol, scopeDecl, isTypeNode2) {
|
|
if (!symbol) {
|
|
return void 0;
|
|
}
|
|
const decls = symbol.getDeclarations();
|
|
if (decls && decls.some((d) => d.parent === scopeDecl)) {
|
|
return factory.createIdentifier(symbol.name);
|
|
}
|
|
const prefix = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.parent, scopeDecl, isTypeNode2);
|
|
if (prefix === void 0) {
|
|
return void 0;
|
|
}
|
|
return isTypeNode2 ? factory.createQualifiedName(prefix, factory.createIdentifier(symbol.name)) : factory.createPropertyAccessExpression(prefix, symbol.name);
|
|
}
|
|
}
|
|
function getExtractableParent(node) {
|
|
return findAncestor(node, (node2) => node2.parent && isExtractableExpression(node2) && !isBinaryExpression(node2.parent));
|
|
}
|
|
function isExtractableExpression(node) {
|
|
const { parent: parent2 } = node;
|
|
switch (parent2.kind) {
|
|
case 302 /* EnumMember */:
|
|
return false;
|
|
}
|
|
switch (node.kind) {
|
|
case 10 /* StringLiteral */:
|
|
return parent2.kind !== 269 /* ImportDeclaration */ && parent2.kind !== 273 /* ImportSpecifier */;
|
|
case 227 /* SpreadElement */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 205 /* BindingElement */:
|
|
return false;
|
|
case 79 /* Identifier */:
|
|
return parent2.kind !== 205 /* BindingElement */ && parent2.kind !== 273 /* ImportSpecifier */ && parent2.kind !== 278 /* ExportSpecifier */;
|
|
}
|
|
return true;
|
|
}
|
|
function isBlockLike(node) {
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 308 /* SourceFile */:
|
|
case 265 /* ModuleBlock */:
|
|
case 292 /* CaseClause */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isInJSXContent(node) {
|
|
return isStringLiteralJsxAttribute(node) || (isJsxElement(node) || isJsxSelfClosingElement(node) || isJsxFragment(node)) && (isJsxElement(node.parent) || isJsxFragment(node.parent));
|
|
}
|
|
function isStringLiteralJsxAttribute(node) {
|
|
return isStringLiteral(node) && node.parent && isJsxAttribute(node.parent);
|
|
}
|
|
|
|
// src/services/_namespaces/ts.refactor.generateGetAccessorAndSetAccessor.ts
|
|
var ts_refactor_generateGetAccessorAndSetAccessor_exports = {};
|
|
|
|
// src/services/refactors/generateGetAccessorAndSetAccessor.ts
|
|
var actionName = "Generate 'get' and 'set' accessors";
|
|
var actionDescription = Diagnostics.Generate_get_and_set_accessors.message;
|
|
var generateGetSetAction = {
|
|
name: actionName,
|
|
description: actionDescription,
|
|
kind: "refactor.rewrite.property.generateAccessors"
|
|
};
|
|
registerRefactor(actionName, {
|
|
kinds: [generateGetSetAction.kind],
|
|
getEditsForAction: function getRefactorActionsToGenerateGetAndSetAccessors(context, actionName2) {
|
|
if (!context.endPosition)
|
|
return void 0;
|
|
const info = ts_codefix_exports.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition);
|
|
Debug.assert(info && !isRefactorErrorInfo(info), "Expected applicable refactor info");
|
|
const edits = ts_codefix_exports.generateAccessorFromProperty(context.file, context.program, context.startPosition, context.endPosition, context, actionName2);
|
|
if (!edits)
|
|
return void 0;
|
|
const renameFilename = context.file.fileName;
|
|
const nameNeedRename = info.renameAccessor ? info.accessorName : info.fieldName;
|
|
const renameLocationOffset = isIdentifier(nameNeedRename) ? 0 : -1;
|
|
const renameLocation = renameLocationOffset + getRenameLocation(edits, renameFilename, nameNeedRename.text, isParameter(info.declaration));
|
|
return { renameFilename, renameLocation, edits };
|
|
},
|
|
getAvailableActions(context) {
|
|
if (!context.endPosition)
|
|
return emptyArray;
|
|
const info = ts_codefix_exports.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition, context.triggerReason === "invoked");
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
return [{
|
|
name: actionName,
|
|
description: actionDescription,
|
|
actions: [generateGetSetAction]
|
|
}];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: actionName,
|
|
description: actionDescription,
|
|
actions: [{ ...generateGetSetAction, notApplicableReason: info.error }]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
}
|
|
});
|
|
|
|
// src/services/_namespaces/ts.refactor.inferFunctionReturnType.ts
|
|
var ts_refactor_inferFunctionReturnType_exports = {};
|
|
|
|
// src/services/refactors/inferFunctionReturnType.ts
|
|
var refactorName12 = "Infer function return type";
|
|
var refactorDescription6 = Diagnostics.Infer_function_return_type.message;
|
|
var inferReturnTypeAction = {
|
|
name: refactorName12,
|
|
description: refactorDescription6,
|
|
kind: "refactor.rewrite.function.returnType"
|
|
};
|
|
registerRefactor(refactorName12, {
|
|
kinds: [inferReturnTypeAction.kind],
|
|
getEditsForAction: getRefactorEditsToInferReturnType,
|
|
getAvailableActions: getRefactorActionsToInferReturnType
|
|
});
|
|
function getRefactorEditsToInferReturnType(context) {
|
|
const info = getInfo21(context);
|
|
if (info && !isRefactorErrorInfo(info)) {
|
|
const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange38(context.file, t, info.declaration, info.returnTypeNode));
|
|
return { renameFilename: void 0, renameLocation: void 0, edits };
|
|
}
|
|
return void 0;
|
|
}
|
|
function getRefactorActionsToInferReturnType(context) {
|
|
const info = getInfo21(context);
|
|
if (!info)
|
|
return emptyArray;
|
|
if (!isRefactorErrorInfo(info)) {
|
|
return [{
|
|
name: refactorName12,
|
|
description: refactorDescription6,
|
|
actions: [inferReturnTypeAction]
|
|
}];
|
|
}
|
|
if (context.preferences.provideRefactorNotApplicableReason) {
|
|
return [{
|
|
name: refactorName12,
|
|
description: refactorDescription6,
|
|
actions: [{ ...inferReturnTypeAction, notApplicableReason: info.error }]
|
|
}];
|
|
}
|
|
return emptyArray;
|
|
}
|
|
function doChange38(sourceFile, changes, declaration, typeNode) {
|
|
const closeParen = findChildOfKind(declaration, 21 /* CloseParenToken */, sourceFile);
|
|
const needParens = isArrowFunction(declaration) && closeParen === void 0;
|
|
const endNode2 = needParens ? first(declaration.parameters) : closeParen;
|
|
if (endNode2) {
|
|
if (needParens) {
|
|
changes.insertNodeBefore(sourceFile, endNode2, factory.createToken(20 /* OpenParenToken */));
|
|
changes.insertNodeAfter(sourceFile, endNode2, factory.createToken(21 /* CloseParenToken */));
|
|
}
|
|
changes.insertNodeAt(sourceFile, endNode2.end, typeNode, { prefix: ": " });
|
|
}
|
|
}
|
|
function getInfo21(context) {
|
|
if (isInJSFile(context.file) || !refactorKindBeginsWith(inferReturnTypeAction.kind, context.kind))
|
|
return;
|
|
const token = getTokenAtPosition(context.file, context.startPosition);
|
|
const declaration = findAncestor(token, (n) => isBlock(n) || n.parent && isArrowFunction(n.parent) && (n.kind === 38 /* EqualsGreaterThanToken */ || n.parent.body === n) ? "quit" : isConvertibleDeclaration(n));
|
|
if (!declaration || !declaration.body || declaration.type) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Return_type_must_be_inferred_from_a_function) };
|
|
}
|
|
const typeChecker = context.program.getTypeChecker();
|
|
const returnType = tryGetReturnType(typeChecker, declaration);
|
|
if (!returnType) {
|
|
return { error: getLocaleSpecificMessage(Diagnostics.Could_not_determine_function_return_type) };
|
|
}
|
|
const returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NoTruncation */);
|
|
if (returnTypeNode) {
|
|
return { declaration, returnTypeNode };
|
|
}
|
|
}
|
|
function isConvertibleDeclaration(node) {
|
|
switch (node.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function tryGetReturnType(typeChecker, node) {
|
|
if (typeChecker.isImplementationOfOverload(node)) {
|
|
const signatures = typeChecker.getTypeAtLocation(node).getCallSignatures();
|
|
if (signatures.length > 1) {
|
|
return typeChecker.getUnionType(mapDefined(signatures, (s) => s.getReturnType()));
|
|
}
|
|
}
|
|
const signature = typeChecker.getSignatureFromDeclaration(node);
|
|
if (signature) {
|
|
return typeChecker.getReturnTypeOfSignature(signature);
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.Rename.ts
|
|
var ts_Rename_exports = {};
|
|
__export(ts_Rename_exports, {
|
|
getRenameInfo: () => getRenameInfo,
|
|
nodeIsEligibleForRename: () => nodeIsEligibleForRename
|
|
});
|
|
|
|
// src/services/rename.ts
|
|
function getRenameInfo(program, sourceFile, position, preferences) {
|
|
const node = getAdjustedRenameLocation(getTouchingPropertyName(sourceFile, position));
|
|
if (nodeIsEligibleForRename(node)) {
|
|
const renameInfo = getRenameInfoForNode(node, program.getTypeChecker(), sourceFile, program, preferences);
|
|
if (renameInfo) {
|
|
return renameInfo;
|
|
}
|
|
}
|
|
return getRenameInfoError(Diagnostics.You_cannot_rename_this_element);
|
|
}
|
|
function getRenameInfoForNode(node, typeChecker, sourceFile, program, preferences) {
|
|
const symbol = typeChecker.getSymbolAtLocation(node);
|
|
if (!symbol) {
|
|
if (isStringLiteralLike(node)) {
|
|
const type = getContextualTypeFromParentOrAncestorTypeNode(node, typeChecker);
|
|
if (type && (type.flags & 128 /* StringLiteral */ || type.flags & 1048576 /* Union */ && every(type.types, (type2) => !!(type2.flags & 128 /* StringLiteral */)))) {
|
|
return getRenameInfoSuccess(node.text, node.text, "string" /* string */, "", node, sourceFile);
|
|
}
|
|
} else if (isLabelName(node)) {
|
|
const name = getTextOfNode(node);
|
|
return getRenameInfoSuccess(name, name, "label" /* label */, "" /* none */, node, sourceFile);
|
|
}
|
|
return void 0;
|
|
}
|
|
const { declarations } = symbol;
|
|
if (!declarations || declarations.length === 0)
|
|
return;
|
|
if (declarations.some((declaration) => isDefinedInLibraryFile(program, declaration))) {
|
|
return getRenameInfoError(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library);
|
|
}
|
|
if (isIdentifier(node) && node.originalKeywordKind === 88 /* DefaultKeyword */ && symbol.parent && symbol.parent.flags & 1536 /* Module */) {
|
|
return void 0;
|
|
}
|
|
if (isStringLiteralLike(node) && tryGetImportFromModuleSpecifier(node)) {
|
|
return preferences.allowRenameOfImportPath ? getRenameInfoForModule(node, sourceFile, symbol) : void 0;
|
|
}
|
|
const wouldRenameNodeModules = wouldRenameInOtherNodeModules(sourceFile, symbol, typeChecker, preferences);
|
|
if (wouldRenameNodeModules) {
|
|
return getRenameInfoError(wouldRenameNodeModules);
|
|
}
|
|
const kind = ts_SymbolDisplay_exports.getSymbolKind(typeChecker, symbol, node);
|
|
const specifierName = isImportOrExportSpecifierName(node) || isStringOrNumericLiteralLike(node) && node.parent.kind === 164 /* ComputedPropertyName */ ? stripQuotes(getTextOfIdentifierOrLiteral(node)) : void 0;
|
|
const displayName = specifierName || typeChecker.symbolToString(symbol);
|
|
const fullDisplayName = specifierName || typeChecker.getFullyQualifiedName(symbol);
|
|
return getRenameInfoSuccess(displayName, fullDisplayName, kind, ts_SymbolDisplay_exports.getSymbolModifiers(typeChecker, symbol), node, sourceFile);
|
|
}
|
|
function isDefinedInLibraryFile(program, declaration) {
|
|
const sourceFile = declaration.getSourceFile();
|
|
return program.isSourceFileDefaultLibrary(sourceFile) && fileExtensionIs(sourceFile.fileName, ".d.ts" /* Dts */);
|
|
}
|
|
function wouldRenameInOtherNodeModules(originalFile, symbol, checker, preferences) {
|
|
if (!preferences.providePrefixAndSuffixTextForRename && symbol.flags & 2097152 /* Alias */) {
|
|
const importSpecifier = symbol.declarations && find(symbol.declarations, (decl) => isImportSpecifier(decl));
|
|
if (importSpecifier && !importSpecifier.propertyName) {
|
|
symbol = checker.getAliasedSymbol(symbol);
|
|
}
|
|
}
|
|
const { declarations } = symbol;
|
|
if (!declarations) {
|
|
return void 0;
|
|
}
|
|
const originalPackage = getPackagePathComponents(originalFile.path);
|
|
if (originalPackage === void 0) {
|
|
if (some(declarations, (declaration) => isInsideNodeModules(declaration.getSourceFile().path))) {
|
|
return Diagnostics.You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder;
|
|
} else {
|
|
return void 0;
|
|
}
|
|
}
|
|
for (const declaration of declarations) {
|
|
const declPackage = getPackagePathComponents(declaration.getSourceFile().path);
|
|
if (declPackage) {
|
|
const length2 = Math.min(originalPackage.length, declPackage.length);
|
|
for (let i = 0; i <= length2; i++) {
|
|
if (compareStringsCaseSensitive(originalPackage[i], declPackage[i]) !== 0 /* EqualTo */) {
|
|
return Diagnostics.You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getPackagePathComponents(filePath) {
|
|
const components = getPathComponents(filePath);
|
|
const nodeModulesIdx = components.lastIndexOf("node_modules");
|
|
if (nodeModulesIdx === -1) {
|
|
return void 0;
|
|
}
|
|
return components.slice(0, nodeModulesIdx + 2);
|
|
}
|
|
function getRenameInfoForModule(node, sourceFile, moduleSymbol) {
|
|
if (!isExternalModuleNameRelative(node.text)) {
|
|
return getRenameInfoError(Diagnostics.You_cannot_rename_a_module_via_a_global_import);
|
|
}
|
|
const moduleSourceFile = moduleSymbol.declarations && find(moduleSymbol.declarations, isSourceFile);
|
|
if (!moduleSourceFile)
|
|
return void 0;
|
|
const withoutIndex = endsWith(node.text, "/index") || endsWith(node.text, "/index.js") ? void 0 : tryRemoveSuffix(removeFileExtension(moduleSourceFile.fileName), "/index");
|
|
const name = withoutIndex === void 0 ? moduleSourceFile.fileName : withoutIndex;
|
|
const kind = withoutIndex === void 0 ? "module" /* moduleElement */ : "directory" /* directory */;
|
|
const indexAfterLastSlash = node.text.lastIndexOf("/") + 1;
|
|
const triggerSpan = createTextSpan(node.getStart(sourceFile) + 1 + indexAfterLastSlash, node.text.length - indexAfterLastSlash);
|
|
return {
|
|
canRename: true,
|
|
fileToRename: name,
|
|
kind,
|
|
displayName: name,
|
|
fullDisplayName: name,
|
|
kindModifiers: "" /* none */,
|
|
triggerSpan
|
|
};
|
|
}
|
|
function getRenameInfoSuccess(displayName, fullDisplayName, kind, kindModifiers, node, sourceFile) {
|
|
return {
|
|
canRename: true,
|
|
fileToRename: void 0,
|
|
kind,
|
|
displayName,
|
|
fullDisplayName,
|
|
kindModifiers,
|
|
triggerSpan: createTriggerSpanForNode(node, sourceFile)
|
|
};
|
|
}
|
|
function getRenameInfoError(diagnostic) {
|
|
return { canRename: false, localizedErrorMessage: getLocaleSpecificMessage(diagnostic) };
|
|
}
|
|
function createTriggerSpanForNode(node, sourceFile) {
|
|
let start2 = node.getStart(sourceFile);
|
|
let width = node.getWidth(sourceFile);
|
|
if (isStringLiteralLike(node)) {
|
|
start2 += 1;
|
|
width -= 2;
|
|
}
|
|
return createTextSpan(start2, width);
|
|
}
|
|
function nodeIsEligibleForRename(node) {
|
|
switch (node.kind) {
|
|
case 79 /* Identifier */:
|
|
case 80 /* PrivateIdentifier */:
|
|
case 10 /* StringLiteral */:
|
|
case 14 /* NoSubstitutionTemplateLiteral */:
|
|
case 108 /* ThisKeyword */:
|
|
return true;
|
|
case 8 /* NumericLiteral */:
|
|
return isLiteralNameOfPropertyDeclarationOrIndexAccess(node);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.SignatureHelp.ts
|
|
var ts_SignatureHelp_exports = {};
|
|
__export(ts_SignatureHelp_exports, {
|
|
getArgumentInfoForCompletions: () => getArgumentInfoForCompletions,
|
|
getSignatureHelpItems: () => getSignatureHelpItems
|
|
});
|
|
|
|
// src/services/signatureHelp.ts
|
|
function getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken) {
|
|
const typeChecker = program.getTypeChecker();
|
|
const startingToken = findTokenOnLeftOfPosition(sourceFile, position);
|
|
if (!startingToken) {
|
|
return void 0;
|
|
}
|
|
const onlyUseSyntacticOwners = !!triggerReason && triggerReason.kind === "characterTyped";
|
|
if (onlyUseSyntacticOwners && (isInString(sourceFile, position, startingToken) || isInComment(sourceFile, position))) {
|
|
return void 0;
|
|
}
|
|
const isManuallyInvoked = !!triggerReason && triggerReason.kind === "invoked";
|
|
const argumentInfo = getContainingArgumentInfo(startingToken, position, sourceFile, typeChecker, isManuallyInvoked);
|
|
if (!argumentInfo)
|
|
return void 0;
|
|
cancellationToken.throwIfCancellationRequested();
|
|
const candidateInfo = getCandidateOrTypeInfo(argumentInfo, typeChecker, sourceFile, startingToken, onlyUseSyntacticOwners);
|
|
cancellationToken.throwIfCancellationRequested();
|
|
if (!candidateInfo) {
|
|
return isSourceFileJS(sourceFile) ? createJSSignatureHelpItems(argumentInfo, program, cancellationToken) : void 0;
|
|
}
|
|
return typeChecker.runWithCancellationToken(cancellationToken, (typeChecker2) => candidateInfo.kind === CandidateOrTypeKind.Candidate ? createSignatureHelpItems(candidateInfo.candidates, candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker2) : createTypeHelpItems(candidateInfo.symbol, argumentInfo, sourceFile, typeChecker2));
|
|
}
|
|
var CandidateOrTypeKind = /* @__PURE__ */ ((CandidateOrTypeKind2) => {
|
|
CandidateOrTypeKind2[CandidateOrTypeKind2["Candidate"] = 0] = "Candidate";
|
|
CandidateOrTypeKind2[CandidateOrTypeKind2["Type"] = 1] = "Type";
|
|
return CandidateOrTypeKind2;
|
|
})(CandidateOrTypeKind || {});
|
|
function getCandidateOrTypeInfo({ invocation, argumentCount }, checker, sourceFile, startingToken, onlyUseSyntacticOwners) {
|
|
switch (invocation.kind) {
|
|
case 0 /* Call */: {
|
|
if (onlyUseSyntacticOwners && !isSyntacticOwner(startingToken, invocation.node, sourceFile)) {
|
|
return void 0;
|
|
}
|
|
const candidates = [];
|
|
const resolvedSignature = checker.getResolvedSignatureForSignatureHelp(invocation.node, candidates, argumentCount);
|
|
return candidates.length === 0 ? void 0 : { kind: 0 /* Candidate */, candidates, resolvedSignature };
|
|
}
|
|
case 1 /* TypeArgs */: {
|
|
const { called } = invocation;
|
|
if (onlyUseSyntacticOwners && !containsPrecedingToken(startingToken, sourceFile, isIdentifier(called) ? called.parent : called)) {
|
|
return void 0;
|
|
}
|
|
const candidates = getPossibleGenericSignatures(called, argumentCount, checker);
|
|
if (candidates.length !== 0)
|
|
return { kind: 0 /* Candidate */, candidates, resolvedSignature: first(candidates) };
|
|
const symbol = checker.getSymbolAtLocation(called);
|
|
return symbol && { kind: 1 /* Type */, symbol };
|
|
}
|
|
case 2 /* Contextual */:
|
|
return { kind: 0 /* Candidate */, candidates: [invocation.signature], resolvedSignature: invocation.signature };
|
|
default:
|
|
return Debug.assertNever(invocation);
|
|
}
|
|
}
|
|
function isSyntacticOwner(startingToken, node, sourceFile) {
|
|
if (!isCallOrNewExpression(node))
|
|
return false;
|
|
const invocationChildren = node.getChildren(sourceFile);
|
|
switch (startingToken.kind) {
|
|
case 20 /* OpenParenToken */:
|
|
return contains(invocationChildren, startingToken);
|
|
case 27 /* CommaToken */: {
|
|
const containingList = findContainingList(startingToken);
|
|
return !!containingList && contains(invocationChildren, containingList);
|
|
}
|
|
case 29 /* LessThanToken */:
|
|
return containsPrecedingToken(startingToken, sourceFile, node.expression);
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function createJSSignatureHelpItems(argumentInfo, program, cancellationToken) {
|
|
if (argumentInfo.invocation.kind === 2 /* Contextual */)
|
|
return void 0;
|
|
const expression = getExpressionFromInvocation(argumentInfo.invocation);
|
|
const name = isPropertyAccessExpression(expression) ? expression.name.text : void 0;
|
|
const typeChecker = program.getTypeChecker();
|
|
return name === void 0 ? void 0 : firstDefined(program.getSourceFiles(), (sourceFile) => firstDefined(sourceFile.getNamedDeclarations().get(name), (declaration) => {
|
|
const type = declaration.symbol && typeChecker.getTypeOfSymbolAtLocation(declaration.symbol, declaration);
|
|
const callSignatures = type && type.getCallSignatures();
|
|
if (callSignatures && callSignatures.length) {
|
|
return typeChecker.runWithCancellationToken(
|
|
cancellationToken,
|
|
(typeChecker2) => createSignatureHelpItems(
|
|
callSignatures,
|
|
callSignatures[0],
|
|
argumentInfo,
|
|
sourceFile,
|
|
typeChecker2,
|
|
true
|
|
)
|
|
);
|
|
}
|
|
}));
|
|
}
|
|
function containsPrecedingToken(startingToken, sourceFile, container) {
|
|
const pos = startingToken.getFullStart();
|
|
let currentParent = startingToken.parent;
|
|
while (currentParent) {
|
|
const precedingToken = findPrecedingToken(pos, sourceFile, currentParent, true);
|
|
if (precedingToken) {
|
|
return rangeContainsRange(container, precedingToken);
|
|
}
|
|
currentParent = currentParent.parent;
|
|
}
|
|
return Debug.fail("Could not find preceding token");
|
|
}
|
|
function getArgumentInfoForCompletions(node, position, sourceFile) {
|
|
const info = getImmediatelyContainingArgumentInfo(node, position, sourceFile);
|
|
return !info || info.isTypeParameterList || info.invocation.kind !== 0 /* Call */ ? void 0 : { invocation: info.invocation.node, argumentCount: info.argumentCount, argumentIndex: info.argumentIndex };
|
|
}
|
|
function getArgumentOrParameterListInfo(node, position, sourceFile) {
|
|
const info = getArgumentOrParameterListAndIndex(node, sourceFile);
|
|
if (!info)
|
|
return void 0;
|
|
const { list, argumentIndex } = info;
|
|
const argumentCount = getArgumentCount(list, isInString(sourceFile, position, node));
|
|
if (argumentIndex !== 0) {
|
|
Debug.assertLessThan(argumentIndex, argumentCount);
|
|
}
|
|
const argumentsSpan = getApplicableSpanForArguments(list, sourceFile);
|
|
return { list, argumentIndex, argumentCount, argumentsSpan };
|
|
}
|
|
function getArgumentOrParameterListAndIndex(node, sourceFile) {
|
|
if (node.kind === 29 /* LessThanToken */ || node.kind === 20 /* OpenParenToken */) {
|
|
return { list: getChildListThatStartsWithOpenerToken(node.parent, node, sourceFile), argumentIndex: 0 };
|
|
} else {
|
|
const list = findContainingList(node);
|
|
return list && { list, argumentIndex: getArgumentIndex(list, node) };
|
|
}
|
|
}
|
|
function getImmediatelyContainingArgumentInfo(node, position, sourceFile) {
|
|
const { parent: parent2 } = node;
|
|
if (isCallOrNewExpression(parent2)) {
|
|
const invocation = parent2;
|
|
const info = getArgumentOrParameterListInfo(node, position, sourceFile);
|
|
if (!info)
|
|
return void 0;
|
|
const { list, argumentIndex, argumentCount, argumentsSpan } = info;
|
|
const isTypeParameterList = !!parent2.typeArguments && parent2.typeArguments.pos === list.pos;
|
|
return { isTypeParameterList, invocation: { kind: 0 /* Call */, node: invocation }, argumentsSpan, argumentIndex, argumentCount };
|
|
} else if (isNoSubstitutionTemplateLiteral(node) && isTaggedTemplateExpression(parent2)) {
|
|
if (isInsideTemplateLiteral(node, position, sourceFile)) {
|
|
return getArgumentListInfoForTemplate(parent2, 0, sourceFile);
|
|
}
|
|
return void 0;
|
|
} else if (isTemplateHead(node) && parent2.parent.kind === 212 /* TaggedTemplateExpression */) {
|
|
const templateExpression = parent2;
|
|
const tagExpression = templateExpression.parent;
|
|
Debug.assert(templateExpression.kind === 225 /* TemplateExpression */);
|
|
const argumentIndex = isInsideTemplateLiteral(node, position, sourceFile) ? 0 : 1;
|
|
return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);
|
|
} else if (isTemplateSpan(parent2) && isTaggedTemplateExpression(parent2.parent.parent)) {
|
|
const templateSpan = parent2;
|
|
const tagExpression = parent2.parent.parent;
|
|
if (isTemplateTail(node) && !isInsideTemplateLiteral(node, position, sourceFile)) {
|
|
return void 0;
|
|
}
|
|
const spanIndex = templateSpan.parent.templateSpans.indexOf(templateSpan);
|
|
const argumentIndex = getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile);
|
|
return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile);
|
|
} else if (isJsxOpeningLikeElement(parent2)) {
|
|
const attributeSpanStart = parent2.attributes.pos;
|
|
const attributeSpanEnd = skipTrivia(sourceFile.text, parent2.attributes.end, false);
|
|
return {
|
|
isTypeParameterList: false,
|
|
invocation: { kind: 0 /* Call */, node: parent2 },
|
|
argumentsSpan: createTextSpan(attributeSpanStart, attributeSpanEnd - attributeSpanStart),
|
|
argumentIndex: 0,
|
|
argumentCount: 1
|
|
};
|
|
} else {
|
|
const typeArgInfo = getPossibleTypeArgumentsInfo(node, sourceFile);
|
|
if (typeArgInfo) {
|
|
const { called, nTypeArguments } = typeArgInfo;
|
|
const invocation = { kind: 1 /* TypeArgs */, called };
|
|
const argumentsSpan = createTextSpanFromBounds(called.getStart(sourceFile), node.end);
|
|
return { isTypeParameterList: true, invocation, argumentsSpan, argumentIndex: nTypeArguments, argumentCount: nTypeArguments + 1 };
|
|
}
|
|
return void 0;
|
|
}
|
|
}
|
|
function getImmediatelyContainingArgumentOrContextualParameterInfo(node, position, sourceFile, checker) {
|
|
return tryGetParameterInfo(node, position, sourceFile, checker) || getImmediatelyContainingArgumentInfo(node, position, sourceFile);
|
|
}
|
|
function getHighestBinary(b) {
|
|
return isBinaryExpression(b.parent) ? getHighestBinary(b.parent) : b;
|
|
}
|
|
function countBinaryExpressionParameters(b) {
|
|
return isBinaryExpression(b.left) ? countBinaryExpressionParameters(b.left) + 1 : 2;
|
|
}
|
|
function tryGetParameterInfo(startingToken, position, sourceFile, checker) {
|
|
const info = getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker);
|
|
if (!info)
|
|
return void 0;
|
|
const { contextualType, argumentIndex, argumentCount, argumentsSpan } = info;
|
|
const nonNullableContextualType = contextualType.getNonNullableType();
|
|
const symbol = nonNullableContextualType.symbol;
|
|
if (symbol === void 0)
|
|
return void 0;
|
|
const signature = lastOrUndefined(nonNullableContextualType.getCallSignatures());
|
|
if (signature === void 0)
|
|
return void 0;
|
|
const invocation = { kind: 2 /* Contextual */, signature, node: startingToken, symbol: chooseBetterSymbol(symbol) };
|
|
return { isTypeParameterList: false, invocation, argumentsSpan, argumentIndex, argumentCount };
|
|
}
|
|
function getContextualSignatureLocationInfo(startingToken, sourceFile, position, checker) {
|
|
if (startingToken.kind !== 20 /* OpenParenToken */ && startingToken.kind !== 27 /* CommaToken */)
|
|
return void 0;
|
|
const { parent: parent2 } = startingToken;
|
|
switch (parent2.kind) {
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
const info = getArgumentOrParameterListInfo(startingToken, position, sourceFile);
|
|
if (!info)
|
|
return void 0;
|
|
const { argumentIndex, argumentCount, argumentsSpan } = info;
|
|
const contextualType = isMethodDeclaration(parent2) ? checker.getContextualTypeForObjectLiteralElement(parent2) : checker.getContextualType(parent2);
|
|
return contextualType && { contextualType, argumentIndex, argumentCount, argumentsSpan };
|
|
case 223 /* BinaryExpression */: {
|
|
const highestBinary = getHighestBinary(parent2);
|
|
const contextualType2 = checker.getContextualType(highestBinary);
|
|
const argumentIndex2 = startingToken.kind === 20 /* OpenParenToken */ ? 0 : countBinaryExpressionParameters(parent2) - 1;
|
|
const argumentCount2 = countBinaryExpressionParameters(highestBinary);
|
|
return contextualType2 && { contextualType: contextualType2, argumentIndex: argumentIndex2, argumentCount: argumentCount2, argumentsSpan: createTextSpanFromNode(parent2) };
|
|
}
|
|
default:
|
|
return void 0;
|
|
}
|
|
}
|
|
function chooseBetterSymbol(s) {
|
|
return s.name === "__type" /* Type */ ? firstDefined(s.declarations, (d) => isFunctionTypeNode(d) ? d.parent.symbol : void 0) || s : s;
|
|
}
|
|
function getArgumentIndex(argumentsList, node) {
|
|
let argumentIndex = 0;
|
|
for (const child of argumentsList.getChildren()) {
|
|
if (child === node) {
|
|
break;
|
|
}
|
|
if (child.kind !== 27 /* CommaToken */) {
|
|
argumentIndex++;
|
|
}
|
|
}
|
|
return argumentIndex;
|
|
}
|
|
function getArgumentCount(argumentsList, ignoreTrailingComma) {
|
|
const listChildren = argumentsList.getChildren();
|
|
let argumentCount = countWhere(listChildren, (arg) => arg.kind !== 27 /* CommaToken */);
|
|
if (!ignoreTrailingComma && listChildren.length > 0 && last(listChildren).kind === 27 /* CommaToken */) {
|
|
argumentCount++;
|
|
}
|
|
return argumentCount;
|
|
}
|
|
function getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile) {
|
|
Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node.");
|
|
if (isTemplateLiteralToken(node)) {
|
|
if (isInsideTemplateLiteral(node, position, sourceFile)) {
|
|
return 0;
|
|
}
|
|
return spanIndex + 2;
|
|
}
|
|
return spanIndex + 1;
|
|
}
|
|
function getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile) {
|
|
const argumentCount = isNoSubstitutionTemplateLiteral(tagExpression.template) ? 1 : tagExpression.template.templateSpans.length + 1;
|
|
if (argumentIndex !== 0) {
|
|
Debug.assertLessThan(argumentIndex, argumentCount);
|
|
}
|
|
return {
|
|
isTypeParameterList: false,
|
|
invocation: { kind: 0 /* Call */, node: tagExpression },
|
|
argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression, sourceFile),
|
|
argumentIndex,
|
|
argumentCount
|
|
};
|
|
}
|
|
function getApplicableSpanForArguments(argumentsList, sourceFile) {
|
|
const applicableSpanStart = argumentsList.getFullStart();
|
|
const applicableSpanEnd = skipTrivia(sourceFile.text, argumentsList.getEnd(), false);
|
|
return createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
|
|
}
|
|
function getApplicableSpanForTaggedTemplate(taggedTemplate, sourceFile) {
|
|
const template = taggedTemplate.template;
|
|
const applicableSpanStart = template.getStart();
|
|
let applicableSpanEnd = template.getEnd();
|
|
if (template.kind === 225 /* TemplateExpression */) {
|
|
const lastSpan = last(template.templateSpans);
|
|
if (lastSpan.literal.getFullWidth() === 0) {
|
|
applicableSpanEnd = skipTrivia(sourceFile.text, applicableSpanEnd, false);
|
|
}
|
|
}
|
|
return createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart);
|
|
}
|
|
function getContainingArgumentInfo(node, position, sourceFile, checker, isManuallyInvoked) {
|
|
for (let n = node; !isSourceFile(n) && (isManuallyInvoked || !isBlock(n)); n = n.parent) {
|
|
Debug.assert(rangeContainsRange(n.parent, n), "Not a subspan", () => `Child: ${Debug.formatSyntaxKind(n.kind)}, parent: ${Debug.formatSyntaxKind(n.parent.kind)}`);
|
|
const argumentInfo = getImmediatelyContainingArgumentOrContextualParameterInfo(n, position, sourceFile, checker);
|
|
if (argumentInfo) {
|
|
return argumentInfo;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getChildListThatStartsWithOpenerToken(parent2, openerToken, sourceFile) {
|
|
const children = parent2.getChildren(sourceFile);
|
|
const indexOfOpenerToken = children.indexOf(openerToken);
|
|
Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1);
|
|
return children[indexOfOpenerToken + 1];
|
|
}
|
|
function getExpressionFromInvocation(invocation) {
|
|
return invocation.kind === 0 /* Call */ ? getInvokedExpression(invocation.node) : invocation.called;
|
|
}
|
|
function getEnclosingDeclarationFromInvocation(invocation) {
|
|
return invocation.kind === 0 /* Call */ ? invocation.node : invocation.kind === 1 /* TypeArgs */ ? invocation.called : invocation.node;
|
|
}
|
|
var signatureHelpNodeBuilderFlags = 8192 /* OmitParameterModifiers */ | 70221824 /* IgnoreErrors */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
|
|
function createSignatureHelpItems(candidates, resolvedSignature, { isTypeParameterList, argumentCount, argumentsSpan: applicableSpan, invocation, argumentIndex }, sourceFile, typeChecker, useFullPrefix) {
|
|
var _a2;
|
|
const enclosingDeclaration = getEnclosingDeclarationFromInvocation(invocation);
|
|
const callTargetSymbol = invocation.kind === 2 /* Contextual */ ? invocation.symbol : typeChecker.getSymbolAtLocation(getExpressionFromInvocation(invocation)) || useFullPrefix && ((_a2 = resolvedSignature.declaration) == null ? void 0 : _a2.symbol);
|
|
const callTargetDisplayParts = callTargetSymbol ? symbolToDisplayParts(typeChecker, callTargetSymbol, useFullPrefix ? sourceFile : void 0, void 0) : emptyArray;
|
|
const items = map(candidates, (candidateSignature) => getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile));
|
|
if (argumentIndex !== 0) {
|
|
Debug.assertLessThan(argumentIndex, argumentCount);
|
|
}
|
|
let selectedItemIndex = 0;
|
|
let itemsSeen = 0;
|
|
for (let i = 0; i < items.length; i++) {
|
|
const item = items[i];
|
|
if (candidates[i] === resolvedSignature) {
|
|
selectedItemIndex = itemsSeen;
|
|
if (item.length > 1) {
|
|
let count = 0;
|
|
for (const i2 of item) {
|
|
if (i2.isVariadic || i2.parameters.length >= argumentCount) {
|
|
selectedItemIndex = itemsSeen + count;
|
|
break;
|
|
}
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
itemsSeen += item.length;
|
|
}
|
|
Debug.assert(selectedItemIndex !== -1);
|
|
const help = { items: flatMapToMutable(items, identity), applicableSpan, selectedItemIndex, argumentIndex, argumentCount };
|
|
const selected = help.items[selectedItemIndex];
|
|
if (selected.isVariadic) {
|
|
const firstRest = findIndex(selected.parameters, (p) => !!p.isRest);
|
|
if (-1 < firstRest && firstRest < selected.parameters.length - 1) {
|
|
help.argumentIndex = selected.parameters.length;
|
|
} else {
|
|
help.argumentIndex = Math.min(help.argumentIndex, selected.parameters.length - 1);
|
|
}
|
|
}
|
|
return help;
|
|
}
|
|
function createTypeHelpItems(symbol, { argumentCount, argumentsSpan: applicableSpan, invocation, argumentIndex }, sourceFile, checker) {
|
|
const typeParameters = checker.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
|
|
if (!typeParameters)
|
|
return void 0;
|
|
const items = [getTypeHelpItem(symbol, typeParameters, checker, getEnclosingDeclarationFromInvocation(invocation), sourceFile)];
|
|
return { items, applicableSpan, selectedItemIndex: 0, argumentIndex, argumentCount };
|
|
}
|
|
function getTypeHelpItem(symbol, typeParameters, checker, enclosingDeclaration, sourceFile) {
|
|
const typeSymbolDisplay = symbolToDisplayParts(checker, symbol);
|
|
const printer = createPrinter({ removeComments: true });
|
|
const parameters = typeParameters.map((t) => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));
|
|
const documentation = symbol.getDocumentationComment(checker);
|
|
const tags = symbol.getJsDocTags(checker);
|
|
const prefixDisplayParts = [...typeSymbolDisplay, punctuationPart(29 /* LessThanToken */)];
|
|
return { isVariadic: false, prefixDisplayParts, suffixDisplayParts: [punctuationPart(31 /* GreaterThanToken */)], separatorDisplayParts, parameters, documentation, tags };
|
|
}
|
|
var separatorDisplayParts = [punctuationPart(27 /* CommaToken */), spacePart()];
|
|
function getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, checker, enclosingDeclaration, sourceFile) {
|
|
const infos = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile);
|
|
return map(infos, ({ isVariadic, parameters, prefix, suffix }) => {
|
|
const prefixDisplayParts = [...callTargetDisplayParts, ...prefix];
|
|
const suffixDisplayParts = [...suffix, ...returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker)];
|
|
const documentation = candidateSignature.getDocumentationComment(checker);
|
|
const tags = candidateSignature.getJsDocTags();
|
|
return { isVariadic, prefixDisplayParts, suffixDisplayParts, separatorDisplayParts, parameters, documentation, tags };
|
|
});
|
|
}
|
|
function returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker) {
|
|
return mapToDisplayParts((writer) => {
|
|
writer.writePunctuation(":");
|
|
writer.writeSpace(" ");
|
|
const predicate = checker.getTypePredicateOfSignature(candidateSignature);
|
|
if (predicate) {
|
|
checker.writeTypePredicate(predicate, enclosingDeclaration, void 0, writer);
|
|
} else {
|
|
checker.writeType(checker.getReturnTypeOfSignature(candidateSignature), enclosingDeclaration, void 0, writer);
|
|
}
|
|
});
|
|
}
|
|
function itemInfoForTypeParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) {
|
|
const typeParameters = (candidateSignature.target || candidateSignature).typeParameters;
|
|
const printer = createPrinter({ removeComments: true });
|
|
const parameters = (typeParameters || emptyArray).map((t) => createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer));
|
|
const thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)] : [];
|
|
return checker.getExpandedParameters(candidateSignature).map((paramList) => {
|
|
const params = factory.createNodeArray([...thisParameter, ...map(paramList, (param) => checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags))]);
|
|
const parameterParts = mapToDisplayParts((writer) => {
|
|
printer.writeList(2576 /* CallExpressionArguments */, params, sourceFile, writer);
|
|
});
|
|
return { isVariadic: false, parameters, prefix: [punctuationPart(29 /* LessThanToken */)], suffix: [punctuationPart(31 /* GreaterThanToken */), ...parameterParts] };
|
|
});
|
|
}
|
|
function itemInfoForParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) {
|
|
const printer = createPrinter({ removeComments: true });
|
|
const typeParameterParts = mapToDisplayParts((writer) => {
|
|
if (candidateSignature.typeParameters && candidateSignature.typeParameters.length) {
|
|
const args = factory.createNodeArray(candidateSignature.typeParameters.map((p) => checker.typeParameterToDeclaration(p, enclosingDeclaration, signatureHelpNodeBuilderFlags)));
|
|
printer.writeList(53776 /* TypeParameters */, args, sourceFile, writer);
|
|
}
|
|
});
|
|
const lists = checker.getExpandedParameters(candidateSignature);
|
|
const isVariadic = !checker.hasEffectiveRestParameter(candidateSignature) ? (_) => false : lists.length === 1 ? (_) => true : (pList) => !!(pList.length && pList[pList.length - 1].checkFlags & 32768 /* RestParameter */);
|
|
return lists.map((parameterList) => ({
|
|
isVariadic: isVariadic(parameterList),
|
|
parameters: parameterList.map((p) => createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer)),
|
|
prefix: [...typeParameterParts, punctuationPart(20 /* OpenParenToken */)],
|
|
suffix: [punctuationPart(21 /* CloseParenToken */)]
|
|
}));
|
|
}
|
|
function createSignatureHelpParameterForParameter(parameter, checker, enclosingDeclaration, sourceFile, printer) {
|
|
const displayParts = mapToDisplayParts((writer) => {
|
|
const param = checker.symbolToParameterDeclaration(parameter, enclosingDeclaration, signatureHelpNodeBuilderFlags);
|
|
printer.writeNode(4 /* Unspecified */, param, sourceFile, writer);
|
|
});
|
|
const isOptional = checker.isOptionalParameter(parameter.valueDeclaration);
|
|
const isRest = !!(parameter.checkFlags & 32768 /* RestParameter */);
|
|
return { name: parameter.name, documentation: parameter.getDocumentationComment(checker), displayParts, isOptional, isRest };
|
|
}
|
|
function createSignatureHelpParameterForTypeParameter(typeParameter, checker, enclosingDeclaration, sourceFile, printer) {
|
|
const displayParts = mapToDisplayParts((writer) => {
|
|
const param = checker.typeParameterToDeclaration(typeParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags);
|
|
printer.writeNode(4 /* Unspecified */, param, sourceFile, writer);
|
|
});
|
|
return { name: typeParameter.symbol.name, documentation: typeParameter.symbol.getDocumentationComment(checker), displayParts, isOptional: false, isRest: false };
|
|
}
|
|
|
|
// src/services/_namespaces/ts.SmartSelectionRange.ts
|
|
var ts_SmartSelectionRange_exports = {};
|
|
__export(ts_SmartSelectionRange_exports, {
|
|
getSmartSelectionRange: () => getSmartSelectionRange
|
|
});
|
|
|
|
// src/services/smartSelection.ts
|
|
function getSmartSelectionRange(pos, sourceFile) {
|
|
var _a2, _b;
|
|
let selectionRange = {
|
|
textSpan: createTextSpanFromBounds(sourceFile.getFullStart(), sourceFile.getEnd())
|
|
};
|
|
let parentNode = sourceFile;
|
|
outer:
|
|
while (true) {
|
|
const children = getSelectionChildren(parentNode);
|
|
if (!children.length)
|
|
break;
|
|
for (let i = 0; i < children.length; i++) {
|
|
const prevNode = children[i - 1];
|
|
const node = children[i];
|
|
const nextNode = children[i + 1];
|
|
if (getTokenPosOfNode(node, sourceFile, true) > pos) {
|
|
break outer;
|
|
}
|
|
const comment = singleOrUndefined(getTrailingCommentRanges(sourceFile.text, node.end));
|
|
if (comment && comment.kind === 2 /* SingleLineCommentTrivia */) {
|
|
pushSelectionCommentRange(comment.pos, comment.end);
|
|
}
|
|
if (positionShouldSnapToNode(sourceFile, pos, node)) {
|
|
if (isFunctionBody(node) && isFunctionLikeDeclaration(parentNode) && !positionsAreOnSameLine(node.getStart(sourceFile), node.getEnd(), sourceFile)) {
|
|
pushSelectionRange(node.getStart(sourceFile), node.getEnd());
|
|
}
|
|
if (isBlock(node) || isTemplateSpan(node) || isTemplateHead(node) || isTemplateTail(node) || prevNode && isTemplateHead(prevNode) || isVariableDeclarationList(node) && isVariableStatement(parentNode) || isSyntaxList(node) && isVariableDeclarationList(parentNode) || isVariableDeclaration(node) && isSyntaxList(parentNode) && children.length === 1 || isJSDocTypeExpression(node) || isJSDocSignature(node) || isJSDocTypeLiteral(node)) {
|
|
parentNode = node;
|
|
break;
|
|
}
|
|
if (isTemplateSpan(parentNode) && nextNode && isTemplateMiddleOrTemplateTail(nextNode)) {
|
|
const start3 = node.getFullStart() - "${".length;
|
|
const end2 = nextNode.getStart() + "}".length;
|
|
pushSelectionRange(start3, end2);
|
|
}
|
|
const isBetweenMultiLineBookends = isSyntaxList(node) && isListOpener(prevNode) && isListCloser(nextNode) && !positionsAreOnSameLine(prevNode.getStart(), nextNode.getStart(), sourceFile);
|
|
let start2 = isBetweenMultiLineBookends ? prevNode.getEnd() : node.getStart();
|
|
const end = isBetweenMultiLineBookends ? nextNode.getStart() : getEndPos(sourceFile, node);
|
|
if (hasJSDocNodes(node) && ((_a2 = node.jsDoc) == null ? void 0 : _a2.length)) {
|
|
pushSelectionRange(first(node.jsDoc).getStart(), end);
|
|
}
|
|
if (isSyntaxList(node)) {
|
|
const firstChild = node.getChildren()[0];
|
|
if (firstChild && hasJSDocNodes(firstChild) && ((_b = firstChild.jsDoc) == null ? void 0 : _b.length) && firstChild.getStart() !== node.pos) {
|
|
start2 = Math.min(start2, first(firstChild.jsDoc).getStart());
|
|
}
|
|
}
|
|
pushSelectionRange(start2, end);
|
|
if (isStringLiteral(node) || isTemplateLiteral(node)) {
|
|
pushSelectionRange(start2 + 1, end - 1);
|
|
}
|
|
parentNode = node;
|
|
break;
|
|
}
|
|
if (i === children.length - 1) {
|
|
break outer;
|
|
}
|
|
}
|
|
}
|
|
return selectionRange;
|
|
function pushSelectionRange(start2, end) {
|
|
if (start2 !== end) {
|
|
const textSpan = createTextSpanFromBounds(start2, end);
|
|
if (!selectionRange || !textSpansEqual(textSpan, selectionRange.textSpan) && textSpanIntersectsWithPosition(textSpan, pos)) {
|
|
selectionRange = { textSpan, ...selectionRange && { parent: selectionRange } };
|
|
}
|
|
}
|
|
}
|
|
function pushSelectionCommentRange(start2, end) {
|
|
pushSelectionRange(start2, end);
|
|
let pos2 = start2;
|
|
while (sourceFile.text.charCodeAt(pos2) === 47 /* slash */) {
|
|
pos2++;
|
|
}
|
|
pushSelectionRange(pos2, end);
|
|
}
|
|
}
|
|
function positionShouldSnapToNode(sourceFile, pos, node) {
|
|
Debug.assert(node.pos <= pos);
|
|
if (pos < node.end) {
|
|
return true;
|
|
}
|
|
const nodeEnd = node.getEnd();
|
|
if (nodeEnd === pos) {
|
|
return getTouchingPropertyName(sourceFile, pos).pos < node.end;
|
|
}
|
|
return false;
|
|
}
|
|
var isImport2 = or(isImportDeclaration, isImportEqualsDeclaration);
|
|
function getSelectionChildren(node) {
|
|
var _a2;
|
|
if (isSourceFile(node)) {
|
|
return groupChildren(node.getChildAt(0).getChildren(), isImport2);
|
|
}
|
|
if (isMappedTypeNode(node)) {
|
|
const [openBraceToken, ...children] = node.getChildren();
|
|
const closeBraceToken = Debug.checkDefined(children.pop());
|
|
Debug.assertEqual(openBraceToken.kind, 18 /* OpenBraceToken */);
|
|
Debug.assertEqual(closeBraceToken.kind, 19 /* CloseBraceToken */);
|
|
const groupedWithPlusMinusTokens = groupChildren(children, (child) => child === node.readonlyToken || child.kind === 146 /* ReadonlyKeyword */ || child === node.questionToken || child.kind === 57 /* QuestionToken */);
|
|
const groupedWithBrackets = groupChildren(
|
|
groupedWithPlusMinusTokens,
|
|
({ kind }) => kind === 22 /* OpenBracketToken */ || kind === 165 /* TypeParameter */ || kind === 23 /* CloseBracketToken */
|
|
);
|
|
return [
|
|
openBraceToken,
|
|
createSyntaxList2(splitChildren(groupedWithBrackets, ({ kind }) => kind === 58 /* ColonToken */)),
|
|
closeBraceToken
|
|
];
|
|
}
|
|
if (isPropertySignature(node)) {
|
|
const children = groupChildren(node.getChildren(), (child) => child === node.name || contains(node.modifiers, child));
|
|
const firstJSDocChild = ((_a2 = children[0]) == null ? void 0 : _a2.kind) === 323 /* JSDoc */ ? children[0] : void 0;
|
|
const withJSDocSeparated = firstJSDocChild ? children.slice(1) : children;
|
|
const splittedChildren = splitChildren(withJSDocSeparated, ({ kind }) => kind === 58 /* ColonToken */);
|
|
return firstJSDocChild ? [firstJSDocChild, createSyntaxList2(splittedChildren)] : splittedChildren;
|
|
}
|
|
if (isParameter(node)) {
|
|
const groupedDotDotDotAndName = groupChildren(node.getChildren(), (child) => child === node.dotDotDotToken || child === node.name);
|
|
const groupedWithQuestionToken = groupChildren(groupedDotDotDotAndName, (child) => child === groupedDotDotDotAndName[0] || child === node.questionToken);
|
|
return splitChildren(groupedWithQuestionToken, ({ kind }) => kind === 63 /* EqualsToken */);
|
|
}
|
|
if (isBindingElement(node)) {
|
|
return splitChildren(node.getChildren(), ({ kind }) => kind === 63 /* EqualsToken */);
|
|
}
|
|
return node.getChildren();
|
|
}
|
|
function groupChildren(children, groupOn) {
|
|
const result = [];
|
|
let group2;
|
|
for (const child of children) {
|
|
if (groupOn(child)) {
|
|
group2 = group2 || [];
|
|
group2.push(child);
|
|
} else {
|
|
if (group2) {
|
|
result.push(createSyntaxList2(group2));
|
|
group2 = void 0;
|
|
}
|
|
result.push(child);
|
|
}
|
|
}
|
|
if (group2) {
|
|
result.push(createSyntaxList2(group2));
|
|
}
|
|
return result;
|
|
}
|
|
function splitChildren(children, pivotOn, separateTrailingSemicolon = true) {
|
|
if (children.length < 2) {
|
|
return children;
|
|
}
|
|
const splitTokenIndex = findIndex(children, pivotOn);
|
|
if (splitTokenIndex === -1) {
|
|
return children;
|
|
}
|
|
const leftChildren = children.slice(0, splitTokenIndex);
|
|
const splitToken = children[splitTokenIndex];
|
|
const lastToken = last(children);
|
|
const separateLastToken = separateTrailingSemicolon && lastToken.kind === 26 /* SemicolonToken */;
|
|
const rightChildren = children.slice(splitTokenIndex + 1, separateLastToken ? children.length - 1 : void 0);
|
|
const result = compact([
|
|
leftChildren.length ? createSyntaxList2(leftChildren) : void 0,
|
|
splitToken,
|
|
rightChildren.length ? createSyntaxList2(rightChildren) : void 0
|
|
]);
|
|
return separateLastToken ? result.concat(lastToken) : result;
|
|
}
|
|
function createSyntaxList2(children) {
|
|
Debug.assertGreaterThanOrEqual(children.length, 1);
|
|
return setTextRangePosEnd(parseNodeFactory.createSyntaxList(children), children[0].pos, last(children).end);
|
|
}
|
|
function isListOpener(token) {
|
|
const kind = token && token.kind;
|
|
return kind === 18 /* OpenBraceToken */ || kind === 22 /* OpenBracketToken */ || kind === 20 /* OpenParenToken */ || kind === 283 /* JsxOpeningElement */;
|
|
}
|
|
function isListCloser(token) {
|
|
const kind = token && token.kind;
|
|
return kind === 19 /* CloseBraceToken */ || kind === 23 /* CloseBracketToken */ || kind === 21 /* CloseParenToken */ || kind === 284 /* JsxClosingElement */;
|
|
}
|
|
function getEndPos(sourceFile, node) {
|
|
switch (node.kind) {
|
|
case 343 /* JSDocParameterTag */:
|
|
case 341 /* JSDocCallbackTag */:
|
|
case 350 /* JSDocPropertyTag */:
|
|
case 348 /* JSDocTypedefTag */:
|
|
case 345 /* JSDocThisTag */:
|
|
return sourceFile.getLineEndOfPosition(node.getStart());
|
|
default:
|
|
return node.getEnd();
|
|
}
|
|
}
|
|
|
|
// src/services/_namespaces/ts.SymbolDisplay.ts
|
|
var ts_SymbolDisplay_exports = {};
|
|
__export(ts_SymbolDisplay_exports, {
|
|
getSymbolDisplayPartsDocumentationAndSymbolKind: () => getSymbolDisplayPartsDocumentationAndSymbolKind,
|
|
getSymbolKind: () => getSymbolKind,
|
|
getSymbolModifiers: () => getSymbolModifiers
|
|
});
|
|
|
|
// src/services/symbolDisplay.ts
|
|
var symbolDisplayNodeBuilderFlags = 8192 /* OmitParameterModifiers */ | 70221824 /* IgnoreErrors */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
|
|
function getSymbolKind(typeChecker, symbol, location2) {
|
|
const result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location2);
|
|
if (result !== "" /* unknown */) {
|
|
return result;
|
|
}
|
|
const flags = getCombinedLocalAndExportSymbolFlags(symbol);
|
|
if (flags & 32 /* Class */) {
|
|
return getDeclarationOfKind(symbol, 228 /* ClassExpression */) ? "local class" /* localClassElement */ : "class" /* classElement */;
|
|
}
|
|
if (flags & 384 /* Enum */)
|
|
return "enum" /* enumElement */;
|
|
if (flags & 524288 /* TypeAlias */)
|
|
return "type" /* typeElement */;
|
|
if (flags & 64 /* Interface */)
|
|
return "interface" /* interfaceElement */;
|
|
if (flags & 262144 /* TypeParameter */)
|
|
return "type parameter" /* typeParameterElement */;
|
|
if (flags & 8 /* EnumMember */)
|
|
return "enum member" /* enumMemberElement */;
|
|
if (flags & 2097152 /* Alias */)
|
|
return "alias" /* alias */;
|
|
if (flags & 1536 /* Module */)
|
|
return "module" /* moduleElement */;
|
|
return result;
|
|
}
|
|
function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location2) {
|
|
const roots = typeChecker.getRootSymbols(symbol);
|
|
if (roots.length === 1 && first(roots).flags & 8192 /* Method */ && typeChecker.getTypeOfSymbolAtLocation(symbol, location2).getNonNullableType().getCallSignatures().length !== 0) {
|
|
return "method" /* memberFunctionElement */;
|
|
}
|
|
if (typeChecker.isUndefinedSymbol(symbol)) {
|
|
return "var" /* variableElement */;
|
|
}
|
|
if (typeChecker.isArgumentsSymbol(symbol)) {
|
|
return "local var" /* localVariableElement */;
|
|
}
|
|
if (location2.kind === 108 /* ThisKeyword */ && isExpression(location2) || isThisInTypeQuery(location2)) {
|
|
return "parameter" /* parameterElement */;
|
|
}
|
|
const flags = getCombinedLocalAndExportSymbolFlags(symbol);
|
|
if (flags & 3 /* Variable */) {
|
|
if (isFirstDeclarationOfSymbolParameter(symbol)) {
|
|
return "parameter" /* parameterElement */;
|
|
} else if (symbol.valueDeclaration && isVarConst(symbol.valueDeclaration)) {
|
|
return "const" /* constElement */;
|
|
} else if (forEach(symbol.declarations, isLet)) {
|
|
return "let" /* letElement */;
|
|
}
|
|
return isLocalVariableOrFunction(symbol) ? "local var" /* localVariableElement */ : "var" /* variableElement */;
|
|
}
|
|
if (flags & 16 /* Function */)
|
|
return isLocalVariableOrFunction(symbol) ? "local function" /* localFunctionElement */ : "function" /* functionElement */;
|
|
if (flags & 32768 /* GetAccessor */)
|
|
return "getter" /* memberGetAccessorElement */;
|
|
if (flags & 65536 /* SetAccessor */)
|
|
return "setter" /* memberSetAccessorElement */;
|
|
if (flags & 8192 /* Method */)
|
|
return "method" /* memberFunctionElement */;
|
|
if (flags & 16384 /* Constructor */)
|
|
return "constructor" /* constructorImplementationElement */;
|
|
if (flags & 131072 /* Signature */)
|
|
return "index" /* indexSignatureElement */;
|
|
if (flags & 4 /* Property */) {
|
|
if (flags & 33554432 /* Transient */ && symbol.checkFlags & 6 /* Synthetic */) {
|
|
const unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), (rootSymbol) => {
|
|
const rootSymbolFlags = rootSymbol.getFlags();
|
|
if (rootSymbolFlags & (98308 /* PropertyOrAccessor */ | 3 /* Variable */)) {
|
|
return "property" /* memberVariableElement */;
|
|
}
|
|
});
|
|
if (!unionPropertyKind) {
|
|
const typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location2);
|
|
if (typeOfUnionProperty.getCallSignatures().length) {
|
|
return "method" /* memberFunctionElement */;
|
|
}
|
|
return "property" /* memberVariableElement */;
|
|
}
|
|
return unionPropertyKind;
|
|
}
|
|
return "property" /* memberVariableElement */;
|
|
}
|
|
return "" /* unknown */;
|
|
}
|
|
function getNormalizedSymbolModifiers(symbol) {
|
|
if (symbol.declarations && symbol.declarations.length) {
|
|
const [declaration, ...declarations] = symbol.declarations;
|
|
const excludeFlags = length(declarations) && isDeprecatedDeclaration(declaration) && some(declarations, (d) => !isDeprecatedDeclaration(d)) ? 8192 /* Deprecated */ : 0 /* None */;
|
|
const modifiers = getNodeModifiers(declaration, excludeFlags);
|
|
if (modifiers) {
|
|
return modifiers.split(",");
|
|
}
|
|
}
|
|
return [];
|
|
}
|
|
function getSymbolModifiers(typeChecker, symbol) {
|
|
if (!symbol) {
|
|
return "" /* none */;
|
|
}
|
|
const modifiers = new Set(getNormalizedSymbolModifiers(symbol));
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
const resolvedSymbol = typeChecker.getAliasedSymbol(symbol);
|
|
if (resolvedSymbol !== symbol) {
|
|
forEach(getNormalizedSymbolModifiers(resolvedSymbol), (modifier) => {
|
|
modifiers.add(modifier);
|
|
});
|
|
}
|
|
}
|
|
if (symbol.flags & 16777216 /* Optional */) {
|
|
modifiers.add("optional" /* optionalModifier */);
|
|
}
|
|
return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
|
|
}
|
|
function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location2, semanticMeaning = getMeaningFromLocation(location2), alias) {
|
|
var _a2;
|
|
const displayParts = [];
|
|
let documentation = [];
|
|
let tags = [];
|
|
const symbolFlags = getCombinedLocalAndExportSymbolFlags(symbol);
|
|
let symbolKind = semanticMeaning & 1 /* Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location2) : "" /* unknown */;
|
|
let hasAddedSymbolInfo = false;
|
|
const isThisExpression = location2.kind === 108 /* ThisKeyword */ && isInExpressionContext(location2) || isThisInTypeQuery(location2);
|
|
let type;
|
|
let printer;
|
|
let documentationFromAlias;
|
|
let tagsFromAlias;
|
|
let hasMultipleSignatures = false;
|
|
if (location2.kind === 108 /* ThisKeyword */ && !isThisExpression) {
|
|
return { displayParts: [keywordPart(108 /* ThisKeyword */)], documentation: [], symbolKind: "primitive type" /* primitiveType */, tags: void 0 };
|
|
}
|
|
if (symbolKind !== "" /* unknown */ || symbolFlags & 32 /* Class */ || symbolFlags & 2097152 /* Alias */) {
|
|
if (symbolKind === "getter" /* memberGetAccessorElement */ || symbolKind === "setter" /* memberSetAccessorElement */) {
|
|
const declaration = find(symbol.declarations, (declaration2) => declaration2.name === location2);
|
|
if (declaration) {
|
|
switch (declaration.kind) {
|
|
case 174 /* GetAccessor */:
|
|
symbolKind = "getter" /* memberGetAccessorElement */;
|
|
break;
|
|
case 175 /* SetAccessor */:
|
|
symbolKind = "setter" /* memberSetAccessorElement */;
|
|
break;
|
|
case 169 /* PropertyDeclaration */:
|
|
symbolKind = "accessor" /* memberAccessorVariableElement */;
|
|
break;
|
|
default:
|
|
Debug.assertNever(declaration);
|
|
}
|
|
} else {
|
|
symbolKind = "property" /* memberVariableElement */;
|
|
}
|
|
}
|
|
let signature;
|
|
type = isThisExpression ? typeChecker.getTypeAtLocation(location2) : typeChecker.getTypeOfSymbolAtLocation(symbol, location2);
|
|
if (location2.parent && location2.parent.kind === 208 /* PropertyAccessExpression */) {
|
|
const right = location2.parent.name;
|
|
if (right === location2 || right && right.getFullWidth() === 0) {
|
|
location2 = location2.parent;
|
|
}
|
|
}
|
|
let callExpressionLike;
|
|
if (isCallOrNewExpression(location2)) {
|
|
callExpressionLike = location2;
|
|
} else if (isCallExpressionTarget(location2) || isNewExpressionTarget(location2)) {
|
|
callExpressionLike = location2.parent;
|
|
} else if (location2.parent && (isJsxOpeningLikeElement(location2.parent) || isTaggedTemplateExpression(location2.parent)) && isFunctionLike(symbol.valueDeclaration)) {
|
|
callExpressionLike = location2.parent;
|
|
}
|
|
if (callExpressionLike) {
|
|
signature = typeChecker.getResolvedSignature(callExpressionLike);
|
|
const useConstructSignatures = callExpressionLike.kind === 211 /* NewExpression */ || isCallExpression(callExpressionLike) && callExpressionLike.expression.kind === 106 /* SuperKeyword */;
|
|
const allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
|
|
if (signature && !contains(allSignatures, signature.target) && !contains(allSignatures, signature)) {
|
|
signature = allSignatures.length ? allSignatures[0] : void 0;
|
|
}
|
|
if (signature) {
|
|
if (useConstructSignatures && symbolFlags & 32 /* Class */) {
|
|
symbolKind = "constructor" /* constructorImplementationElement */;
|
|
addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
|
|
} else if (symbolFlags & 2097152 /* Alias */) {
|
|
symbolKind = "alias" /* alias */;
|
|
pushSymbolKind(symbolKind);
|
|
displayParts.push(spacePart());
|
|
if (useConstructSignatures) {
|
|
if (signature.flags & 4 /* Abstract */) {
|
|
displayParts.push(keywordPart(126 /* AbstractKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
displayParts.push(keywordPart(103 /* NewKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
addFullSymbolName(symbol);
|
|
} else {
|
|
addPrefixForAnyFunctionOrVar(symbol, symbolKind);
|
|
}
|
|
switch (symbolKind) {
|
|
case "JSX attribute" /* jsxAttribute */:
|
|
case "property" /* memberVariableElement */:
|
|
case "var" /* variableElement */:
|
|
case "const" /* constElement */:
|
|
case "let" /* letElement */:
|
|
case "parameter" /* parameterElement */:
|
|
case "local var" /* localVariableElement */:
|
|
displayParts.push(punctuationPart(58 /* ColonToken */));
|
|
displayParts.push(spacePart());
|
|
if (!(getObjectFlags(type) & 16 /* Anonymous */) && type.symbol) {
|
|
addRange(displayParts, symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, void 0, 4 /* AllowAnyNodeKind */ | 1 /* WriteTypeParametersOrArguments */));
|
|
displayParts.push(lineBreakPart());
|
|
}
|
|
if (useConstructSignatures) {
|
|
if (signature.flags & 4 /* Abstract */) {
|
|
displayParts.push(keywordPart(126 /* AbstractKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
displayParts.push(keywordPart(103 /* NewKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
addSignatureDisplayParts(signature, allSignatures, 262144 /* WriteArrowStyleSignature */);
|
|
break;
|
|
default:
|
|
addSignatureDisplayParts(signature, allSignatures);
|
|
}
|
|
hasAddedSymbolInfo = true;
|
|
hasMultipleSignatures = allSignatures.length > 1;
|
|
}
|
|
} else if (isNameOfFunctionDeclaration(location2) && !(symbolFlags & 98304 /* Accessor */) || location2.kind === 135 /* ConstructorKeyword */ && location2.parent.kind === 173 /* Constructor */) {
|
|
const functionDeclaration = location2.parent;
|
|
const locationIsSymbolDeclaration = symbol.declarations && find(symbol.declarations, (declaration) => declaration === (location2.kind === 135 /* ConstructorKeyword */ ? functionDeclaration.parent : functionDeclaration));
|
|
if (locationIsSymbolDeclaration) {
|
|
const allSignatures = functionDeclaration.kind === 173 /* Constructor */ ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();
|
|
if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {
|
|
signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);
|
|
} else {
|
|
signature = allSignatures[0];
|
|
}
|
|
if (functionDeclaration.kind === 173 /* Constructor */) {
|
|
symbolKind = "constructor" /* constructorImplementationElement */;
|
|
addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
|
|
} else {
|
|
addPrefixForAnyFunctionOrVar(functionDeclaration.kind === 176 /* CallSignature */ && !(type.symbol.flags & 2048 /* TypeLiteral */ || type.symbol.flags & 4096 /* ObjectLiteral */) ? type.symbol : symbol, symbolKind);
|
|
}
|
|
if (signature) {
|
|
addSignatureDisplayParts(signature, allSignatures);
|
|
}
|
|
hasAddedSymbolInfo = true;
|
|
hasMultipleSignatures = allSignatures.length > 1;
|
|
}
|
|
}
|
|
}
|
|
if (symbolFlags & 32 /* Class */ && !hasAddedSymbolInfo && !isThisExpression) {
|
|
addAliasPrefixIfNecessary();
|
|
if (getDeclarationOfKind(symbol, 228 /* ClassExpression */)) {
|
|
pushSymbolKind("local class" /* localClassElement */);
|
|
} else {
|
|
displayParts.push(keywordPart(84 /* ClassKeyword */));
|
|
}
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
writeTypeParametersOfSymbol(symbol, sourceFile);
|
|
}
|
|
if (symbolFlags & 64 /* Interface */ && semanticMeaning & 2 /* Type */) {
|
|
prefixNextMeaning();
|
|
displayParts.push(keywordPart(118 /* InterfaceKeyword */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
writeTypeParametersOfSymbol(symbol, sourceFile);
|
|
}
|
|
if (symbolFlags & 524288 /* TypeAlias */ && semanticMeaning & 2 /* Type */) {
|
|
prefixNextMeaning();
|
|
displayParts.push(keywordPart(154 /* TypeKeyword */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
writeTypeParametersOfSymbol(symbol, sourceFile);
|
|
displayParts.push(spacePart());
|
|
displayParts.push(operatorPart(63 /* EqualsToken */));
|
|
displayParts.push(spacePart());
|
|
addRange(displayParts, typeToDisplayParts(typeChecker, isConstTypeReference(location2.parent) ? typeChecker.getTypeAtLocation(location2.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* InTypeAlias */));
|
|
}
|
|
if (symbolFlags & 384 /* Enum */) {
|
|
prefixNextMeaning();
|
|
if (some(symbol.declarations, (d) => isEnumDeclaration(d) && isEnumConst(d))) {
|
|
displayParts.push(keywordPart(85 /* ConstKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
displayParts.push(keywordPart(92 /* EnumKeyword */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
}
|
|
if (symbolFlags & 1536 /* Module */ && !isThisExpression) {
|
|
prefixNextMeaning();
|
|
const declaration = getDeclarationOfKind(symbol, 264 /* ModuleDeclaration */);
|
|
const isNamespace = declaration && declaration.name && declaration.name.kind === 79 /* Identifier */;
|
|
displayParts.push(keywordPart(isNamespace ? 143 /* NamespaceKeyword */ : 142 /* ModuleKeyword */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
}
|
|
if (symbolFlags & 262144 /* TypeParameter */ && semanticMeaning & 2 /* Type */) {
|
|
prefixNextMeaning();
|
|
displayParts.push(punctuationPart(20 /* OpenParenToken */));
|
|
displayParts.push(textPart("type parameter"));
|
|
displayParts.push(punctuationPart(21 /* CloseParenToken */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
if (symbol.parent) {
|
|
addInPrefix();
|
|
addFullSymbolName(symbol.parent, enclosingDeclaration);
|
|
writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration);
|
|
} else {
|
|
const decl = getDeclarationOfKind(symbol, 165 /* TypeParameter */);
|
|
if (decl === void 0)
|
|
return Debug.fail();
|
|
const declaration = decl.parent;
|
|
if (declaration) {
|
|
if (isFunctionLikeKind(declaration.kind)) {
|
|
addInPrefix();
|
|
const signature = typeChecker.getSignatureFromDeclaration(declaration);
|
|
if (declaration.kind === 177 /* ConstructSignature */) {
|
|
displayParts.push(keywordPart(103 /* NewKeyword */));
|
|
displayParts.push(spacePart());
|
|
} else if (declaration.kind !== 176 /* CallSignature */ && declaration.name) {
|
|
addFullSymbolName(declaration.symbol);
|
|
}
|
|
addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* WriteTypeArgumentsOfSignature */));
|
|
} else if (declaration.kind === 262 /* TypeAliasDeclaration */) {
|
|
addInPrefix();
|
|
displayParts.push(keywordPart(154 /* TypeKeyword */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(declaration.symbol);
|
|
writeTypeParametersOfSymbol(declaration.symbol, sourceFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (symbolFlags & 8 /* EnumMember */) {
|
|
symbolKind = "enum member" /* enumMemberElement */;
|
|
addPrefixForAnyFunctionOrVar(symbol, "enum member");
|
|
const declaration = (_a2 = symbol.declarations) == null ? void 0 : _a2[0];
|
|
if ((declaration == null ? void 0 : declaration.kind) === 302 /* EnumMember */) {
|
|
const constantValue = typeChecker.getConstantValue(declaration);
|
|
if (constantValue !== void 0) {
|
|
displayParts.push(spacePart());
|
|
displayParts.push(operatorPart(63 /* EqualsToken */));
|
|
displayParts.push(spacePart());
|
|
displayParts.push(displayPart(
|
|
getTextOfConstantValue(constantValue),
|
|
typeof constantValue === "number" ? 7 /* numericLiteral */ : 8 /* stringLiteral */
|
|
));
|
|
}
|
|
}
|
|
}
|
|
if (symbol.flags & 2097152 /* Alias */) {
|
|
prefixNextMeaning();
|
|
if (!hasAddedSymbolInfo) {
|
|
const resolvedSymbol = typeChecker.getAliasedSymbol(symbol);
|
|
if (resolvedSymbol !== symbol && resolvedSymbol.declarations && resolvedSymbol.declarations.length > 0) {
|
|
const resolvedNode = resolvedSymbol.declarations[0];
|
|
const declarationName = getNameOfDeclaration(resolvedNode);
|
|
if (declarationName) {
|
|
const isExternalModuleDeclaration = isModuleWithStringLiteralName(resolvedNode) && hasSyntacticModifier(resolvedNode, 2 /* Ambient */);
|
|
const shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration;
|
|
const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind(
|
|
typeChecker,
|
|
resolvedSymbol,
|
|
getSourceFileOfNode(resolvedNode),
|
|
resolvedNode,
|
|
declarationName,
|
|
semanticMeaning,
|
|
shouldUseAliasName ? symbol : resolvedSymbol
|
|
);
|
|
displayParts.push(...resolvedInfo.displayParts);
|
|
displayParts.push(lineBreakPart());
|
|
documentationFromAlias = resolvedInfo.documentation;
|
|
tagsFromAlias = resolvedInfo.tags;
|
|
} else {
|
|
documentationFromAlias = resolvedSymbol.getContextualDocumentationComment(resolvedNode, typeChecker);
|
|
tagsFromAlias = resolvedSymbol.getJsDocTags(typeChecker);
|
|
}
|
|
}
|
|
}
|
|
if (symbol.declarations) {
|
|
switch (symbol.declarations[0].kind) {
|
|
case 267 /* NamespaceExportDeclaration */:
|
|
displayParts.push(keywordPart(93 /* ExportKeyword */));
|
|
displayParts.push(spacePart());
|
|
displayParts.push(keywordPart(143 /* NamespaceKeyword */));
|
|
break;
|
|
case 274 /* ExportAssignment */:
|
|
displayParts.push(keywordPart(93 /* ExportKeyword */));
|
|
displayParts.push(spacePart());
|
|
displayParts.push(keywordPart(symbol.declarations[0].isExportEquals ? 63 /* EqualsToken */ : 88 /* DefaultKeyword */));
|
|
break;
|
|
case 278 /* ExportSpecifier */:
|
|
displayParts.push(keywordPart(93 /* ExportKeyword */));
|
|
break;
|
|
default:
|
|
displayParts.push(keywordPart(100 /* ImportKeyword */));
|
|
}
|
|
}
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol);
|
|
forEach(symbol.declarations, (declaration) => {
|
|
if (declaration.kind === 268 /* ImportEqualsDeclaration */) {
|
|
const importEqualsDeclaration = declaration;
|
|
if (isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) {
|
|
displayParts.push(spacePart());
|
|
displayParts.push(operatorPart(63 /* EqualsToken */));
|
|
displayParts.push(spacePart());
|
|
displayParts.push(keywordPart(147 /* RequireKeyword */));
|
|
displayParts.push(punctuationPart(20 /* OpenParenToken */));
|
|
displayParts.push(displayPart(getTextOfNode(getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), 8 /* stringLiteral */));
|
|
displayParts.push(punctuationPart(21 /* CloseParenToken */));
|
|
} else {
|
|
const internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference);
|
|
if (internalAliasSymbol) {
|
|
displayParts.push(spacePart());
|
|
displayParts.push(operatorPart(63 /* EqualsToken */));
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(internalAliasSymbol, enclosingDeclaration);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
if (!hasAddedSymbolInfo) {
|
|
if (symbolKind !== "" /* unknown */) {
|
|
if (type) {
|
|
if (isThisExpression) {
|
|
prefixNextMeaning();
|
|
displayParts.push(keywordPart(108 /* ThisKeyword */));
|
|
} else {
|
|
addPrefixForAnyFunctionOrVar(symbol, symbolKind);
|
|
}
|
|
if (symbolKind === "property" /* memberVariableElement */ || symbolKind === "accessor" /* memberAccessorVariableElement */ || symbolKind === "getter" /* memberGetAccessorElement */ || symbolKind === "setter" /* memberSetAccessorElement */ || symbolKind === "JSX attribute" /* jsxAttribute */ || symbolFlags & 3 /* Variable */ || symbolKind === "local var" /* localVariableElement */ || symbolKind === "index" /* indexSignatureElement */ || isThisExpression) {
|
|
displayParts.push(punctuationPart(58 /* ColonToken */));
|
|
displayParts.push(spacePart());
|
|
if (type.symbol && type.symbol.flags & 262144 /* TypeParameter */ && symbolKind !== "index" /* indexSignatureElement */) {
|
|
const typeParameterParts = mapToDisplayParts((writer) => {
|
|
const param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags);
|
|
getPrinter().writeNode(4 /* Unspecified */, param, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration)), writer);
|
|
});
|
|
addRange(displayParts, typeParameterParts);
|
|
} else {
|
|
addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
|
|
}
|
|
if (symbol.target && symbol.target.tupleLabelDeclaration) {
|
|
const labelDecl = symbol.target.tupleLabelDeclaration;
|
|
Debug.assertNode(labelDecl.name, isIdentifier);
|
|
displayParts.push(spacePart());
|
|
displayParts.push(punctuationPart(20 /* OpenParenToken */));
|
|
displayParts.push(textPart(idText(labelDecl.name)));
|
|
displayParts.push(punctuationPart(21 /* CloseParenToken */));
|
|
}
|
|
} else if (symbolFlags & 16 /* Function */ || symbolFlags & 8192 /* Method */ || symbolFlags & 16384 /* Constructor */ || symbolFlags & 131072 /* Signature */ || symbolFlags & 98304 /* Accessor */ || symbolKind === "method" /* memberFunctionElement */) {
|
|
const allSignatures = type.getNonNullableType().getCallSignatures();
|
|
if (allSignatures.length) {
|
|
addSignatureDisplayParts(allSignatures[0], allSignatures);
|
|
hasMultipleSignatures = allSignatures.length > 1;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
symbolKind = getSymbolKind(typeChecker, symbol, location2);
|
|
}
|
|
}
|
|
if (documentation.length === 0 && !hasMultipleSignatures) {
|
|
documentation = symbol.getContextualDocumentationComment(enclosingDeclaration, typeChecker);
|
|
}
|
|
if (documentation.length === 0 && symbolFlags & 4 /* Property */) {
|
|
if (symbol.parent && symbol.declarations && forEach(symbol.parent.declarations, (declaration) => declaration.kind === 308 /* SourceFile */)) {
|
|
for (const declaration of symbol.declarations) {
|
|
if (!declaration.parent || declaration.parent.kind !== 223 /* BinaryExpression */) {
|
|
continue;
|
|
}
|
|
const rhsSymbol = typeChecker.getSymbolAtLocation(declaration.parent.right);
|
|
if (!rhsSymbol) {
|
|
continue;
|
|
}
|
|
documentation = rhsSymbol.getDocumentationComment(typeChecker);
|
|
tags = rhsSymbol.getJsDocTags(typeChecker);
|
|
if (documentation.length > 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (documentation.length === 0 && isIdentifier(location2) && symbol.valueDeclaration && isBindingElement(symbol.valueDeclaration)) {
|
|
const declaration = symbol.valueDeclaration;
|
|
const parent2 = declaration.parent;
|
|
if (isIdentifier(declaration.name) && isObjectBindingPattern(parent2)) {
|
|
const name = getTextOfIdentifierOrLiteral(declaration.name);
|
|
const objectType = typeChecker.getTypeAtLocation(parent2);
|
|
documentation = firstDefined(objectType.isUnion() ? objectType.types : [objectType], (t) => {
|
|
const prop = t.getProperty(name);
|
|
return prop ? prop.getDocumentationComment(typeChecker) : void 0;
|
|
}) || emptyArray;
|
|
}
|
|
}
|
|
if (tags.length === 0 && !hasMultipleSignatures) {
|
|
tags = symbol.getContextualJsDocTags(enclosingDeclaration, typeChecker);
|
|
}
|
|
if (documentation.length === 0 && documentationFromAlias) {
|
|
documentation = documentationFromAlias;
|
|
}
|
|
if (tags.length === 0 && tagsFromAlias) {
|
|
tags = tagsFromAlias;
|
|
}
|
|
return { displayParts, documentation, symbolKind, tags: tags.length === 0 ? void 0 : tags };
|
|
function getPrinter() {
|
|
if (!printer) {
|
|
printer = createPrinter({ removeComments: true });
|
|
}
|
|
return printer;
|
|
}
|
|
function prefixNextMeaning() {
|
|
if (displayParts.length) {
|
|
displayParts.push(lineBreakPart());
|
|
}
|
|
addAliasPrefixIfNecessary();
|
|
}
|
|
function addAliasPrefixIfNecessary() {
|
|
if (alias) {
|
|
pushSymbolKind("alias" /* alias */);
|
|
displayParts.push(spacePart());
|
|
}
|
|
}
|
|
function addInPrefix() {
|
|
displayParts.push(spacePart());
|
|
displayParts.push(keywordPart(101 /* InKeyword */));
|
|
displayParts.push(spacePart());
|
|
}
|
|
function addFullSymbolName(symbolToDisplay, enclosingDeclaration2) {
|
|
let indexInfos;
|
|
if (alias && symbolToDisplay === symbol) {
|
|
symbolToDisplay = alias;
|
|
}
|
|
if (symbolKind === "index" /* indexSignatureElement */) {
|
|
indexInfos = typeChecker.getIndexInfosOfIndexSymbol(symbolToDisplay);
|
|
}
|
|
let fullSymbolDisplayParts = [];
|
|
if (symbolToDisplay.flags & 131072 /* Signature */ && indexInfos) {
|
|
if (symbolToDisplay.parent) {
|
|
fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbolToDisplay.parent);
|
|
}
|
|
fullSymbolDisplayParts.push(punctuationPart(22 /* OpenBracketToken */));
|
|
indexInfos.forEach((info, i) => {
|
|
fullSymbolDisplayParts.push(...typeToDisplayParts(typeChecker, info.keyType));
|
|
if (i !== indexInfos.length - 1) {
|
|
fullSymbolDisplayParts.push(spacePart());
|
|
fullSymbolDisplayParts.push(punctuationPart(51 /* BarToken */));
|
|
fullSymbolDisplayParts.push(spacePart());
|
|
}
|
|
});
|
|
fullSymbolDisplayParts.push(punctuationPart(23 /* CloseBracketToken */));
|
|
} else {
|
|
fullSymbolDisplayParts = symbolToDisplayParts(
|
|
typeChecker,
|
|
symbolToDisplay,
|
|
enclosingDeclaration2 || sourceFile,
|
|
void 0,
|
|
1 /* WriteTypeParametersOrArguments */ | 2 /* UseOnlyExternalAliasing */ | 4 /* AllowAnyNodeKind */
|
|
);
|
|
}
|
|
addRange(displayParts, fullSymbolDisplayParts);
|
|
if (symbol.flags & 16777216 /* Optional */) {
|
|
displayParts.push(punctuationPart(57 /* QuestionToken */));
|
|
}
|
|
}
|
|
function addPrefixForAnyFunctionOrVar(symbol2, symbolKind2) {
|
|
prefixNextMeaning();
|
|
if (symbolKind2) {
|
|
pushSymbolKind(symbolKind2);
|
|
if (symbol2 && !some(symbol2.declarations, (d) => isArrowFunction(d) || (isFunctionExpression(d) || isClassExpression(d)) && !d.name)) {
|
|
displayParts.push(spacePart());
|
|
addFullSymbolName(symbol2);
|
|
}
|
|
}
|
|
}
|
|
function pushSymbolKind(symbolKind2) {
|
|
switch (symbolKind2) {
|
|
case "var" /* variableElement */:
|
|
case "function" /* functionElement */:
|
|
case "let" /* letElement */:
|
|
case "const" /* constElement */:
|
|
case "constructor" /* constructorImplementationElement */:
|
|
displayParts.push(textOrKeywordPart(symbolKind2));
|
|
return;
|
|
default:
|
|
displayParts.push(punctuationPart(20 /* OpenParenToken */));
|
|
displayParts.push(textOrKeywordPart(symbolKind2));
|
|
displayParts.push(punctuationPart(21 /* CloseParenToken */));
|
|
return;
|
|
}
|
|
}
|
|
function addSignatureDisplayParts(signature, allSignatures, flags = 0 /* None */) {
|
|
addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* WriteTypeArgumentsOfSignature */));
|
|
if (allSignatures.length > 1) {
|
|
displayParts.push(spacePart());
|
|
displayParts.push(punctuationPart(20 /* OpenParenToken */));
|
|
displayParts.push(operatorPart(39 /* PlusToken */));
|
|
displayParts.push(displayPart((allSignatures.length - 1).toString(), 7 /* numericLiteral */));
|
|
displayParts.push(spacePart());
|
|
displayParts.push(textPart(allSignatures.length === 2 ? "overload" : "overloads"));
|
|
displayParts.push(punctuationPart(21 /* CloseParenToken */));
|
|
}
|
|
documentation = signature.getDocumentationComment(typeChecker);
|
|
tags = signature.getJsDocTags();
|
|
if (allSignatures.length > 1 && documentation.length === 0 && tags.length === 0) {
|
|
documentation = allSignatures[0].getDocumentationComment(typeChecker);
|
|
tags = allSignatures[0].getJsDocTags().filter((tag) => tag.name !== "deprecated");
|
|
}
|
|
}
|
|
function writeTypeParametersOfSymbol(symbol2, enclosingDeclaration2) {
|
|
const typeParameterParts = mapToDisplayParts((writer) => {
|
|
const params = typeChecker.symbolToTypeParameterDeclarations(symbol2, enclosingDeclaration2, symbolDisplayNodeBuilderFlags);
|
|
getPrinter().writeList(53776 /* TypeParameters */, params, getSourceFileOfNode(getParseTreeNode(enclosingDeclaration2)), writer);
|
|
});
|
|
addRange(displayParts, typeParameterParts);
|
|
}
|
|
}
|
|
function isLocalVariableOrFunction(symbol) {
|
|
if (symbol.parent) {
|
|
return false;
|
|
}
|
|
return forEach(symbol.declarations, (declaration) => {
|
|
if (declaration.kind === 215 /* FunctionExpression */) {
|
|
return true;
|
|
}
|
|
if (declaration.kind !== 257 /* VariableDeclaration */ && declaration.kind !== 259 /* FunctionDeclaration */) {
|
|
return false;
|
|
}
|
|
for (let parent2 = declaration.parent; !isFunctionBlock(parent2); parent2 = parent2.parent) {
|
|
if (parent2.kind === 308 /* SourceFile */ || parent2.kind === 265 /* ModuleBlock */) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
// src/services/_namespaces/ts.textChanges.ts
|
|
var ts_textChanges_exports = {};
|
|
__export(ts_textChanges_exports, {
|
|
ChangeTracker: () => ChangeTracker,
|
|
LeadingTriviaOption: () => LeadingTriviaOption,
|
|
TrailingTriviaOption: () => TrailingTriviaOption,
|
|
applyChanges: () => applyChanges,
|
|
assignPositionsToNode: () => assignPositionsToNode,
|
|
createWriter: () => createWriter,
|
|
deleteNode: () => deleteNode,
|
|
getNewFileText: () => getNewFileText,
|
|
isThisTypeAnnotatable: () => isThisTypeAnnotatable,
|
|
isValidLocationToAddComment: () => isValidLocationToAddComment
|
|
});
|
|
|
|
// src/services/textChanges.ts
|
|
function getPos2(n) {
|
|
const result = n.__pos;
|
|
Debug.assert(typeof result === "number");
|
|
return result;
|
|
}
|
|
function setPos(n, pos) {
|
|
Debug.assert(typeof pos === "number");
|
|
n.__pos = pos;
|
|
}
|
|
function getEnd(n) {
|
|
const result = n.__end;
|
|
Debug.assert(typeof result === "number");
|
|
return result;
|
|
}
|
|
function setEnd(n, end) {
|
|
Debug.assert(typeof end === "number");
|
|
n.__end = end;
|
|
}
|
|
var LeadingTriviaOption = /* @__PURE__ */ ((LeadingTriviaOption2) => {
|
|
LeadingTriviaOption2[LeadingTriviaOption2["Exclude"] = 0] = "Exclude";
|
|
LeadingTriviaOption2[LeadingTriviaOption2["IncludeAll"] = 1] = "IncludeAll";
|
|
LeadingTriviaOption2[LeadingTriviaOption2["JSDoc"] = 2] = "JSDoc";
|
|
LeadingTriviaOption2[LeadingTriviaOption2["StartLine"] = 3] = "StartLine";
|
|
return LeadingTriviaOption2;
|
|
})(LeadingTriviaOption || {});
|
|
var TrailingTriviaOption = /* @__PURE__ */ ((TrailingTriviaOption2) => {
|
|
TrailingTriviaOption2[TrailingTriviaOption2["Exclude"] = 0] = "Exclude";
|
|
TrailingTriviaOption2[TrailingTriviaOption2["ExcludeWhitespace"] = 1] = "ExcludeWhitespace";
|
|
TrailingTriviaOption2[TrailingTriviaOption2["Include"] = 2] = "Include";
|
|
return TrailingTriviaOption2;
|
|
})(TrailingTriviaOption || {});
|
|
function skipWhitespacesAndLineBreaks(text, start2) {
|
|
return skipTrivia(text, start2, false, true);
|
|
}
|
|
function hasCommentsBeforeLineBreak(text, start2) {
|
|
let i = start2;
|
|
while (i < text.length) {
|
|
const ch = text.charCodeAt(i);
|
|
if (isWhiteSpaceSingleLine(ch)) {
|
|
i++;
|
|
continue;
|
|
}
|
|
return ch === 47 /* slash */;
|
|
}
|
|
return false;
|
|
}
|
|
var useNonAdjustedPositions = {
|
|
leadingTriviaOption: 0 /* Exclude */,
|
|
trailingTriviaOption: 0 /* Exclude */
|
|
};
|
|
function getAdjustedRange(sourceFile, startNode2, endNode2, options) {
|
|
return { pos: getAdjustedStartPosition(sourceFile, startNode2, options), end: getAdjustedEndPosition(sourceFile, endNode2, options) };
|
|
}
|
|
function getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment = false) {
|
|
var _a2, _b;
|
|
const { leadingTriviaOption } = options;
|
|
if (leadingTriviaOption === 0 /* Exclude */) {
|
|
return node.getStart(sourceFile);
|
|
}
|
|
if (leadingTriviaOption === 3 /* StartLine */) {
|
|
const startPos = node.getStart(sourceFile);
|
|
const pos = getLineStartPositionForPosition(startPos, sourceFile);
|
|
return rangeContainsPosition(node, pos) ? pos : startPos;
|
|
}
|
|
if (leadingTriviaOption === 2 /* JSDoc */) {
|
|
const JSDocComments = getJSDocCommentRanges(node, sourceFile.text);
|
|
if (JSDocComments == null ? void 0 : JSDocComments.length) {
|
|
return getLineStartPositionForPosition(JSDocComments[0].pos, sourceFile);
|
|
}
|
|
}
|
|
const fullStart = node.getFullStart();
|
|
const start2 = node.getStart(sourceFile);
|
|
if (fullStart === start2) {
|
|
return start2;
|
|
}
|
|
const fullStartLine = getLineStartPositionForPosition(fullStart, sourceFile);
|
|
const startLine = getLineStartPositionForPosition(start2, sourceFile);
|
|
if (startLine === fullStartLine) {
|
|
return leadingTriviaOption === 1 /* IncludeAll */ ? fullStart : start2;
|
|
}
|
|
if (hasTrailingComment) {
|
|
const comment = ((_a2 = getLeadingCommentRanges(sourceFile.text, fullStart)) == null ? void 0 : _a2[0]) || ((_b = getTrailingCommentRanges(sourceFile.text, fullStart)) == null ? void 0 : _b[0]);
|
|
if (comment) {
|
|
return skipTrivia(sourceFile.text, comment.end, true, true);
|
|
}
|
|
}
|
|
const nextLineStart = fullStart > 0 ? 1 : 0;
|
|
let adjustedStartPosition = getStartPositionOfLine(getLineOfLocalPosition(sourceFile, fullStartLine) + nextLineStart, sourceFile);
|
|
adjustedStartPosition = skipWhitespacesAndLineBreaks(sourceFile.text, adjustedStartPosition);
|
|
return getStartPositionOfLine(getLineOfLocalPosition(sourceFile, adjustedStartPosition), sourceFile);
|
|
}
|
|
function getEndPositionOfMultilineTrailingComment(sourceFile, node, options) {
|
|
const { end } = node;
|
|
const { trailingTriviaOption } = options;
|
|
if (trailingTriviaOption === 2 /* Include */) {
|
|
const comments = getTrailingCommentRanges(sourceFile.text, end);
|
|
if (comments) {
|
|
const nodeEndLine = getLineOfLocalPosition(sourceFile, node.end);
|
|
for (const comment of comments) {
|
|
if (comment.kind === 2 /* SingleLineCommentTrivia */ || getLineOfLocalPosition(sourceFile, comment.pos) > nodeEndLine) {
|
|
break;
|
|
}
|
|
const commentEndLine = getLineOfLocalPosition(sourceFile, comment.end);
|
|
if (commentEndLine > nodeEndLine) {
|
|
return skipTrivia(sourceFile.text, comment.end, true, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAdjustedEndPosition(sourceFile, node, options) {
|
|
var _a2;
|
|
const { end } = node;
|
|
const { trailingTriviaOption } = options;
|
|
if (trailingTriviaOption === 0 /* Exclude */) {
|
|
return end;
|
|
}
|
|
if (trailingTriviaOption === 1 /* ExcludeWhitespace */) {
|
|
const comments = concatenate(getTrailingCommentRanges(sourceFile.text, end), getLeadingCommentRanges(sourceFile.text, end));
|
|
const realEnd = (_a2 = comments == null ? void 0 : comments[comments.length - 1]) == null ? void 0 : _a2.end;
|
|
if (realEnd) {
|
|
return realEnd;
|
|
}
|
|
return end;
|
|
}
|
|
const multilineEndPosition = getEndPositionOfMultilineTrailingComment(sourceFile, node, options);
|
|
if (multilineEndPosition) {
|
|
return multilineEndPosition;
|
|
}
|
|
const newEnd = skipTrivia(sourceFile.text, end, true);
|
|
return newEnd !== end && (trailingTriviaOption === 2 /* Include */ || isLineBreak(sourceFile.text.charCodeAt(newEnd - 1))) ? newEnd : end;
|
|
}
|
|
function isSeparator(node, candidate) {
|
|
return !!candidate && !!node.parent && (candidate.kind === 27 /* CommaToken */ || candidate.kind === 26 /* SemicolonToken */ && node.parent.kind === 207 /* ObjectLiteralExpression */);
|
|
}
|
|
function isThisTypeAnnotatable(containingFunction) {
|
|
return isFunctionExpression(containingFunction) || isFunctionDeclaration(containingFunction);
|
|
}
|
|
var ChangeTracker = class {
|
|
constructor(newLineCharacter, formatContext) {
|
|
this.newLineCharacter = newLineCharacter;
|
|
this.formatContext = formatContext;
|
|
this.changes = [];
|
|
this.newFiles = [];
|
|
this.classesWithNodesInsertedAtStart = /* @__PURE__ */ new Map();
|
|
this.deletedNodes = [];
|
|
}
|
|
static fromContext(context) {
|
|
return new ChangeTracker(getNewLineOrDefaultFromHost(context.host, context.formatContext.options), context.formatContext);
|
|
}
|
|
static with(context, cb) {
|
|
const tracker = ChangeTracker.fromContext(context);
|
|
cb(tracker);
|
|
return tracker.getChanges();
|
|
}
|
|
pushRaw(sourceFile, change) {
|
|
Debug.assertEqual(sourceFile.fileName, change.fileName);
|
|
for (const c of change.textChanges) {
|
|
this.changes.push({
|
|
kind: 3 /* Text */,
|
|
sourceFile,
|
|
text: c.newText,
|
|
range: createTextRangeFromSpan(c.span)
|
|
});
|
|
}
|
|
}
|
|
deleteRange(sourceFile, range) {
|
|
this.changes.push({ kind: 0 /* Remove */, sourceFile, range });
|
|
}
|
|
delete(sourceFile, node) {
|
|
this.deletedNodes.push({ sourceFile, node });
|
|
}
|
|
deleteNode(sourceFile, node, options = { leadingTriviaOption: 1 /* IncludeAll */ }) {
|
|
this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));
|
|
}
|
|
deleteNodes(sourceFile, nodes, options = { leadingTriviaOption: 1 /* IncludeAll */ }, hasTrailingComment) {
|
|
for (const node of nodes) {
|
|
const pos = getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment);
|
|
const end = getAdjustedEndPosition(sourceFile, node, options);
|
|
this.deleteRange(sourceFile, { pos, end });
|
|
hasTrailingComment = !!getEndPositionOfMultilineTrailingComment(sourceFile, node, options);
|
|
}
|
|
}
|
|
deleteModifier(sourceFile, modifier) {
|
|
this.deleteRange(sourceFile, { pos: modifier.getStart(sourceFile), end: skipTrivia(sourceFile.text, modifier.end, true) });
|
|
}
|
|
deleteNodeRange(sourceFile, startNode2, endNode2, options = { leadingTriviaOption: 1 /* IncludeAll */ }) {
|
|
const startPosition = getAdjustedStartPosition(sourceFile, startNode2, options);
|
|
const endPosition = getAdjustedEndPosition(sourceFile, endNode2, options);
|
|
this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
|
|
}
|
|
deleteNodeRangeExcludingEnd(sourceFile, startNode2, afterEndNode, options = { leadingTriviaOption: 1 /* IncludeAll */ }) {
|
|
const startPosition = getAdjustedStartPosition(sourceFile, startNode2, options);
|
|
const endPosition = afterEndNode === void 0 ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options);
|
|
this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
|
|
}
|
|
replaceRange(sourceFile, range, newNode, options = {}) {
|
|
this.changes.push({ kind: 1 /* ReplaceWithSingleNode */, sourceFile, range, options, node: newNode });
|
|
}
|
|
replaceNode(sourceFile, oldNode, newNode, options = useNonAdjustedPositions) {
|
|
this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options);
|
|
}
|
|
replaceNodeRange(sourceFile, startNode2, endNode2, newNode, options = useNonAdjustedPositions) {
|
|
this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode2, endNode2, options), newNode, options);
|
|
}
|
|
replaceRangeWithNodes(sourceFile, range, newNodes, options = {}) {
|
|
this.changes.push({ kind: 2 /* ReplaceWithMultipleNodes */, sourceFile, range, options, nodes: newNodes });
|
|
}
|
|
replaceNodeWithNodes(sourceFile, oldNode, newNodes, options = useNonAdjustedPositions) {
|
|
this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options);
|
|
}
|
|
replaceNodeWithText(sourceFile, oldNode, text) {
|
|
this.replaceRangeWithText(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, useNonAdjustedPositions), text);
|
|
}
|
|
replaceNodeRangeWithNodes(sourceFile, startNode2, endNode2, newNodes, options = useNonAdjustedPositions) {
|
|
this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, startNode2, endNode2, options), newNodes, options);
|
|
}
|
|
nodeHasTrailingComment(sourceFile, oldNode, configurableEnd = useNonAdjustedPositions) {
|
|
return !!getEndPositionOfMultilineTrailingComment(sourceFile, oldNode, configurableEnd);
|
|
}
|
|
nextCommaToken(sourceFile, node) {
|
|
const next = findNextToken(node, node.parent, sourceFile);
|
|
return next && next.kind === 27 /* CommaToken */ ? next : void 0;
|
|
}
|
|
replacePropertyAssignment(sourceFile, oldNode, newNode) {
|
|
const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : "," + this.newLineCharacter;
|
|
this.replaceNode(sourceFile, oldNode, newNode, { suffix });
|
|
}
|
|
insertNodeAt(sourceFile, pos, newNode, options = {}) {
|
|
this.replaceRange(sourceFile, createRange(pos), newNode, options);
|
|
}
|
|
insertNodesAt(sourceFile, pos, newNodes, options = {}) {
|
|
this.replaceRangeWithNodes(sourceFile, createRange(pos), newNodes, options);
|
|
}
|
|
insertNodeAtTopOfFile(sourceFile, newNode, blankLineBetween) {
|
|
this.insertAtTopOfFile(sourceFile, newNode, blankLineBetween);
|
|
}
|
|
insertNodesAtTopOfFile(sourceFile, newNodes, blankLineBetween) {
|
|
this.insertAtTopOfFile(sourceFile, newNodes, blankLineBetween);
|
|
}
|
|
insertAtTopOfFile(sourceFile, insert, blankLineBetween) {
|
|
const pos = getInsertionPositionAtSourceFileTop(sourceFile);
|
|
const options = {
|
|
prefix: pos === 0 ? void 0 : this.newLineCharacter,
|
|
suffix: (isLineBreak(sourceFile.text.charCodeAt(pos)) ? "" : this.newLineCharacter) + (blankLineBetween ? this.newLineCharacter : "")
|
|
};
|
|
if (isArray(insert)) {
|
|
this.insertNodesAt(sourceFile, pos, insert, options);
|
|
} else {
|
|
this.insertNodeAt(sourceFile, pos, insert, options);
|
|
}
|
|
}
|
|
insertFirstParameter(sourceFile, parameters, newParam) {
|
|
const p0 = firstOrUndefined(parameters);
|
|
if (p0) {
|
|
this.insertNodeBefore(sourceFile, p0, newParam);
|
|
} else {
|
|
this.insertNodeAt(sourceFile, parameters.pos, newParam);
|
|
}
|
|
}
|
|
insertNodeBefore(sourceFile, before, newNode, blankLineBetween = false, options = {}) {
|
|
this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));
|
|
}
|
|
insertModifierAt(sourceFile, pos, modifier, options = {}) {
|
|
this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), options);
|
|
}
|
|
insertModifierBefore(sourceFile, modifier, before) {
|
|
return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " });
|
|
}
|
|
insertCommentBeforeLine(sourceFile, lineNumber, position, commentText) {
|
|
const lineStartPosition = getStartPositionOfLine(lineNumber, sourceFile);
|
|
const startPosition = getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition);
|
|
const insertAtLineStart = isValidLocationToAddComment(sourceFile, startPosition);
|
|
const token = getTouchingToken(sourceFile, insertAtLineStart ? startPosition : position);
|
|
const indent3 = sourceFile.text.slice(lineStartPosition, startPosition);
|
|
const text = `${insertAtLineStart ? "" : this.newLineCharacter}//${commentText}${this.newLineCharacter}${indent3}`;
|
|
this.insertText(sourceFile, token.getStart(sourceFile), text);
|
|
}
|
|
insertJsdocCommentBefore(sourceFile, node, tag) {
|
|
const fnStart = node.getStart(sourceFile);
|
|
if (node.jsDoc) {
|
|
for (const jsdoc of node.jsDoc) {
|
|
this.deleteRange(sourceFile, {
|
|
pos: getLineStartPositionForPosition(jsdoc.getStart(sourceFile), sourceFile),
|
|
end: getAdjustedEndPosition(sourceFile, jsdoc, {})
|
|
});
|
|
}
|
|
}
|
|
const startPosition = getPrecedingNonSpaceCharacterPosition(sourceFile.text, fnStart - 1);
|
|
const indent3 = sourceFile.text.slice(startPosition, fnStart);
|
|
this.insertNodeAt(sourceFile, fnStart, tag, { suffix: this.newLineCharacter + indent3 });
|
|
}
|
|
createJSDocText(sourceFile, node) {
|
|
const comments = flatMap(node.jsDoc, (jsDoc2) => isString(jsDoc2.comment) ? factory.createJSDocText(jsDoc2.comment) : jsDoc2.comment);
|
|
const jsDoc = singleOrUndefined(node.jsDoc);
|
|
return jsDoc && positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && length(comments) === 0 ? void 0 : factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n")));
|
|
}
|
|
replaceJSDocComment(sourceFile, node, tags) {
|
|
this.insertJsdocCommentBefore(sourceFile, updateJSDocHost(node), factory.createJSDocComment(this.createJSDocText(sourceFile, node), factory.createNodeArray(tags)));
|
|
}
|
|
addJSDocTags(sourceFile, parent2, newTags) {
|
|
const oldTags = flatMapToMutable(parent2.jsDoc, (j) => j.tags);
|
|
const unmergedNewTags = newTags.filter((newTag) => !oldTags.some((tag, i) => {
|
|
const merged = tryMergeJsdocTags(tag, newTag);
|
|
if (merged)
|
|
oldTags[i] = merged;
|
|
return !!merged;
|
|
}));
|
|
this.replaceJSDocComment(sourceFile, parent2, [...oldTags, ...unmergedNewTags]);
|
|
}
|
|
filterJSDocTags(sourceFile, parent2, predicate) {
|
|
this.replaceJSDocComment(sourceFile, parent2, filter(flatMapToMutable(parent2.jsDoc, (j) => j.tags), predicate));
|
|
}
|
|
replaceRangeWithText(sourceFile, range, text) {
|
|
this.changes.push({ kind: 3 /* Text */, sourceFile, range, text });
|
|
}
|
|
insertText(sourceFile, pos, text) {
|
|
this.replaceRangeWithText(sourceFile, createRange(pos), text);
|
|
}
|
|
tryInsertTypeAnnotation(sourceFile, node, type) {
|
|
var _a2;
|
|
let endNode2;
|
|
if (isFunctionLike(node)) {
|
|
endNode2 = findChildOfKind(node, 21 /* CloseParenToken */, sourceFile);
|
|
if (!endNode2) {
|
|
if (!isArrowFunction(node))
|
|
return false;
|
|
endNode2 = first(node.parameters);
|
|
}
|
|
} else {
|
|
endNode2 = (_a2 = node.kind === 257 /* VariableDeclaration */ ? node.exclamationToken : node.questionToken) != null ? _a2 : node.name;
|
|
}
|
|
this.insertNodeAt(sourceFile, endNode2.end, type, { prefix: ": " });
|
|
return true;
|
|
}
|
|
tryInsertThisTypeAnnotation(sourceFile, node, type) {
|
|
const start2 = findChildOfKind(node, 20 /* OpenParenToken */, sourceFile).getStart(sourceFile) + 1;
|
|
const suffix = node.parameters.length ? ", " : "";
|
|
this.insertNodeAt(sourceFile, start2, type, { prefix: "this: ", suffix });
|
|
}
|
|
insertTypeParameters(sourceFile, node, typeParameters) {
|
|
const start2 = (findChildOfKind(node, 20 /* OpenParenToken */, sourceFile) || first(node.parameters)).getStart(sourceFile);
|
|
this.insertNodesAt(sourceFile, start2, typeParameters, { prefix: "<", suffix: ">", joiner: ", " });
|
|
}
|
|
getOptionsForInsertNodeBefore(before, inserted, blankLineBetween) {
|
|
if (isStatement(before) || isClassElement(before)) {
|
|
return { suffix: blankLineBetween ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter };
|
|
} else if (isVariableDeclaration(before)) {
|
|
return { suffix: ", " };
|
|
} else if (isParameter(before)) {
|
|
return isParameter(inserted) ? { suffix: ", " } : {};
|
|
} else if (isStringLiteral(before) && isImportDeclaration(before.parent) || isNamedImports(before)) {
|
|
return { suffix: ", " };
|
|
} else if (isImportSpecifier(before)) {
|
|
return { suffix: "," + (blankLineBetween ? this.newLineCharacter : " ") };
|
|
}
|
|
return Debug.failBadSyntaxKind(before);
|
|
}
|
|
insertNodeAtConstructorStart(sourceFile, ctr, newStatement) {
|
|
const firstStatement = firstOrUndefined(ctr.body.statements);
|
|
if (!firstStatement || !ctr.body.multiLine) {
|
|
this.replaceConstructorBody(sourceFile, ctr, [newStatement, ...ctr.body.statements]);
|
|
} else {
|
|
this.insertNodeBefore(sourceFile, firstStatement, newStatement);
|
|
}
|
|
}
|
|
insertNodeAtConstructorStartAfterSuperCall(sourceFile, ctr, newStatement) {
|
|
const superCallStatement = find(ctr.body.statements, (stmt) => isExpressionStatement(stmt) && isSuperCall(stmt.expression));
|
|
if (!superCallStatement || !ctr.body.multiLine) {
|
|
this.replaceConstructorBody(sourceFile, ctr, [...ctr.body.statements, newStatement]);
|
|
} else {
|
|
this.insertNodeAfter(sourceFile, superCallStatement, newStatement);
|
|
}
|
|
}
|
|
insertNodeAtConstructorEnd(sourceFile, ctr, newStatement) {
|
|
const lastStatement = lastOrUndefined(ctr.body.statements);
|
|
if (!lastStatement || !ctr.body.multiLine) {
|
|
this.replaceConstructorBody(sourceFile, ctr, [...ctr.body.statements, newStatement]);
|
|
} else {
|
|
this.insertNodeAfter(sourceFile, lastStatement, newStatement);
|
|
}
|
|
}
|
|
replaceConstructorBody(sourceFile, ctr, statements) {
|
|
this.replaceNode(sourceFile, ctr.body, factory.createBlock(statements, true));
|
|
}
|
|
insertNodeAtEndOfScope(sourceFile, scope, newNode) {
|
|
const pos = getAdjustedStartPosition(sourceFile, scope.getLastToken(), {});
|
|
this.insertNodeAt(sourceFile, pos, newNode, {
|
|
prefix: isLineBreak(sourceFile.text.charCodeAt(scope.getLastToken().pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter,
|
|
suffix: this.newLineCharacter
|
|
});
|
|
}
|
|
insertMemberAtStart(sourceFile, node, newElement) {
|
|
this.insertNodeAtStartWorker(sourceFile, node, newElement);
|
|
}
|
|
insertNodeAtObjectStart(sourceFile, obj, newElement) {
|
|
this.insertNodeAtStartWorker(sourceFile, obj, newElement);
|
|
}
|
|
insertNodeAtStartWorker(sourceFile, node, newElement) {
|
|
var _a2;
|
|
const indentation = (_a2 = this.guessIndentationFromExistingMembers(sourceFile, node)) != null ? _a2 : this.computeIndentationForNewMember(sourceFile, node);
|
|
this.insertNodeAt(sourceFile, getMembersOrProperties(node).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, node, indentation));
|
|
}
|
|
guessIndentationFromExistingMembers(sourceFile, node) {
|
|
let indentation;
|
|
let lastRange = node;
|
|
for (const member of getMembersOrProperties(node)) {
|
|
if (rangeStartPositionsAreOnSameLine(lastRange, member, sourceFile)) {
|
|
return void 0;
|
|
}
|
|
const memberStart = member.getStart(sourceFile);
|
|
const memberIndentation = ts_formatting_exports.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(memberStart, sourceFile), memberStart, sourceFile, this.formatContext.options);
|
|
if (indentation === void 0) {
|
|
indentation = memberIndentation;
|
|
} else if (memberIndentation !== indentation) {
|
|
return void 0;
|
|
}
|
|
lastRange = member;
|
|
}
|
|
return indentation;
|
|
}
|
|
computeIndentationForNewMember(sourceFile, node) {
|
|
var _a2;
|
|
const nodeStart = node.getStart(sourceFile);
|
|
return ts_formatting_exports.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(nodeStart, sourceFile), nodeStart, sourceFile, this.formatContext.options) + ((_a2 = this.formatContext.options.indentSize) != null ? _a2 : 4);
|
|
}
|
|
getInsertNodeAtStartInsertOptions(sourceFile, node, indentation) {
|
|
const members = getMembersOrProperties(node);
|
|
const isEmpty = members.length === 0;
|
|
const isFirstInsertion = addToSeen(this.classesWithNodesInsertedAtStart, getNodeId(node), { node, sourceFile });
|
|
const insertTrailingComma = isObjectLiteralExpression(node) && (!isJsonSourceFile(sourceFile) || !isEmpty);
|
|
const insertLeadingComma = isObjectLiteralExpression(node) && isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;
|
|
return {
|
|
indentation,
|
|
prefix: (insertLeadingComma ? "," : "") + this.newLineCharacter,
|
|
suffix: insertTrailingComma ? "," : isInterfaceDeclaration(node) && isEmpty ? ";" : ""
|
|
};
|
|
}
|
|
insertNodeAfterComma(sourceFile, after, newNode) {
|
|
const endPosition = this.insertNodeAfterWorker(sourceFile, this.nextCommaToken(sourceFile, after) || after, newNode);
|
|
this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));
|
|
}
|
|
insertNodeAfter(sourceFile, after, newNode) {
|
|
const endPosition = this.insertNodeAfterWorker(sourceFile, after, newNode);
|
|
this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));
|
|
}
|
|
insertNodeAtEndOfList(sourceFile, list, newNode) {
|
|
this.insertNodeAt(sourceFile, list.end, newNode, { prefix: ", " });
|
|
}
|
|
insertNodesAfter(sourceFile, after, newNodes) {
|
|
const endPosition = this.insertNodeAfterWorker(sourceFile, after, first(newNodes));
|
|
this.insertNodesAt(sourceFile, endPosition, newNodes, this.getInsertNodeAfterOptions(sourceFile, after));
|
|
}
|
|
insertNodeAfterWorker(sourceFile, after, newNode) {
|
|
if (needSemicolonBetween(after, newNode)) {
|
|
if (sourceFile.text.charCodeAt(after.end - 1) !== 59 /* semicolon */) {
|
|
this.replaceRange(sourceFile, createRange(after.end), factory.createToken(26 /* SemicolonToken */));
|
|
}
|
|
}
|
|
const endPosition = getAdjustedEndPosition(sourceFile, after, {});
|
|
return endPosition;
|
|
}
|
|
getInsertNodeAfterOptions(sourceFile, after) {
|
|
const options = this.getInsertNodeAfterOptionsWorker(after);
|
|
return {
|
|
...options,
|
|
prefix: after.end === sourceFile.end && isStatement(after) ? options.prefix ? `
|
|
${options.prefix}` : "\n" : options.prefix
|
|
};
|
|
}
|
|
getInsertNodeAfterOptionsWorker(node) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
return { prefix: this.newLineCharacter, suffix: this.newLineCharacter };
|
|
case 257 /* VariableDeclaration */:
|
|
case 10 /* StringLiteral */:
|
|
case 79 /* Identifier */:
|
|
return { prefix: ", " };
|
|
case 299 /* PropertyAssignment */:
|
|
return { suffix: "," + this.newLineCharacter };
|
|
case 93 /* ExportKeyword */:
|
|
return { prefix: " " };
|
|
case 166 /* Parameter */:
|
|
return {};
|
|
default:
|
|
Debug.assert(isStatement(node) || isClassOrTypeElement(node));
|
|
return { suffix: this.newLineCharacter };
|
|
}
|
|
}
|
|
insertName(sourceFile, node, name) {
|
|
Debug.assert(!node.name);
|
|
if (node.kind === 216 /* ArrowFunction */) {
|
|
const arrow = findChildOfKind(node, 38 /* EqualsGreaterThanToken */, sourceFile);
|
|
const lparen = findChildOfKind(node, 20 /* OpenParenToken */, sourceFile);
|
|
if (lparen) {
|
|
this.insertNodesAt(sourceFile, lparen.getStart(sourceFile), [factory.createToken(98 /* FunctionKeyword */), factory.createIdentifier(name)], { joiner: " " });
|
|
deleteNode(this, sourceFile, arrow);
|
|
} else {
|
|
this.insertText(sourceFile, first(node.parameters).getStart(sourceFile), `function ${name}(`);
|
|
this.replaceRange(sourceFile, arrow, factory.createToken(21 /* CloseParenToken */));
|
|
}
|
|
if (node.body.kind !== 238 /* Block */) {
|
|
this.insertNodesAt(sourceFile, node.body.getStart(sourceFile), [factory.createToken(18 /* OpenBraceToken */), factory.createToken(105 /* ReturnKeyword */)], { joiner: " ", suffix: " " });
|
|
this.insertNodesAt(sourceFile, node.body.end, [factory.createToken(26 /* SemicolonToken */), factory.createToken(19 /* CloseBraceToken */)], { joiner: " " });
|
|
}
|
|
} else {
|
|
const pos = findChildOfKind(node, node.kind === 215 /* FunctionExpression */ ? 98 /* FunctionKeyword */ : 84 /* ClassKeyword */, sourceFile).end;
|
|
this.insertNodeAt(sourceFile, pos, factory.createIdentifier(name), { prefix: " " });
|
|
}
|
|
}
|
|
insertExportModifier(sourceFile, node) {
|
|
this.insertText(sourceFile, node.getStart(sourceFile), "export ");
|
|
}
|
|
insertImportSpecifierAtIndex(sourceFile, importSpecifier, namedImports, index) {
|
|
const prevSpecifier = namedImports.elements[index - 1];
|
|
if (prevSpecifier) {
|
|
this.insertNodeInListAfter(sourceFile, prevSpecifier, importSpecifier);
|
|
} else {
|
|
this.insertNodeBefore(
|
|
sourceFile,
|
|
namedImports.elements[0],
|
|
importSpecifier,
|
|
!positionsAreOnSameLine(namedImports.elements[0].getStart(), namedImports.parent.parent.getStart(), sourceFile)
|
|
);
|
|
}
|
|
}
|
|
insertNodeInListAfter(sourceFile, after, newNode, containingList = ts_formatting_exports.SmartIndenter.getContainingList(after, sourceFile)) {
|
|
if (!containingList) {
|
|
Debug.fail("node is not a list element");
|
|
return;
|
|
}
|
|
const index = indexOfNode(containingList, after);
|
|
if (index < 0) {
|
|
return;
|
|
}
|
|
const end = after.getEnd();
|
|
if (index !== containingList.length - 1) {
|
|
const nextToken = getTokenAtPosition(sourceFile, after.end);
|
|
if (nextToken && isSeparator(after, nextToken)) {
|
|
const nextNode = containingList[index + 1];
|
|
const startPos = skipWhitespacesAndLineBreaks(sourceFile.text, nextNode.getFullStart());
|
|
const suffix = `${tokenToString(nextToken.kind)}${sourceFile.text.substring(nextToken.end, startPos)}`;
|
|
this.insertNodesAt(sourceFile, startPos, [newNode], { suffix });
|
|
}
|
|
} else {
|
|
const afterStart = after.getStart(sourceFile);
|
|
const afterStartLinePosition = getLineStartPositionForPosition(afterStart, sourceFile);
|
|
let separator;
|
|
let multilineList = false;
|
|
if (containingList.length === 1) {
|
|
separator = 27 /* CommaToken */;
|
|
} else {
|
|
const tokenBeforeInsertPosition = findPrecedingToken(after.pos, sourceFile);
|
|
separator = isSeparator(after, tokenBeforeInsertPosition) ? tokenBeforeInsertPosition.kind : 27 /* CommaToken */;
|
|
const afterMinusOneStartLinePosition = getLineStartPositionForPosition(containingList[index - 1].getStart(sourceFile), sourceFile);
|
|
multilineList = afterMinusOneStartLinePosition !== afterStartLinePosition;
|
|
}
|
|
if (hasCommentsBeforeLineBreak(sourceFile.text, after.end)) {
|
|
multilineList = true;
|
|
}
|
|
if (multilineList) {
|
|
this.replaceRange(sourceFile, createRange(end), factory.createToken(separator));
|
|
const indentation = ts_formatting_exports.SmartIndenter.findFirstNonWhitespaceColumn(afterStartLinePosition, afterStart, sourceFile, this.formatContext.options);
|
|
let insertPos = skipTrivia(sourceFile.text, end, true, false);
|
|
while (insertPos !== end && isLineBreak(sourceFile.text.charCodeAt(insertPos - 1))) {
|
|
insertPos--;
|
|
}
|
|
this.replaceRange(sourceFile, createRange(insertPos), newNode, { indentation, prefix: this.newLineCharacter });
|
|
} else {
|
|
this.replaceRange(sourceFile, createRange(end), newNode, { prefix: `${tokenToString(separator)} ` });
|
|
}
|
|
}
|
|
}
|
|
parenthesizeExpression(sourceFile, expression) {
|
|
this.replaceRange(sourceFile, rangeOfNode(expression), factory.createParenthesizedExpression(expression));
|
|
}
|
|
finishClassesWithNodesInsertedAtStart() {
|
|
this.classesWithNodesInsertedAtStart.forEach(({ node, sourceFile }) => {
|
|
const [openBraceEnd, closeBraceEnd] = getClassOrObjectBraceEnds(node, sourceFile);
|
|
if (openBraceEnd !== void 0 && closeBraceEnd !== void 0) {
|
|
const isEmpty = getMembersOrProperties(node).length === 0;
|
|
const isSingleLine = positionsAreOnSameLine(openBraceEnd, closeBraceEnd, sourceFile);
|
|
if (isEmpty && isSingleLine && openBraceEnd !== closeBraceEnd - 1) {
|
|
this.deleteRange(sourceFile, createRange(openBraceEnd, closeBraceEnd - 1));
|
|
}
|
|
if (isSingleLine) {
|
|
this.insertText(sourceFile, closeBraceEnd - 1, this.newLineCharacter);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
finishDeleteDeclarations() {
|
|
const deletedNodesInLists = /* @__PURE__ */ new Set();
|
|
for (const { sourceFile, node } of this.deletedNodes) {
|
|
if (!this.deletedNodes.some((d) => d.sourceFile === sourceFile && rangeContainsRangeExclusive(d.node, node))) {
|
|
if (isArray(node)) {
|
|
this.deleteRange(sourceFile, rangeOfTypeParameters(sourceFile, node));
|
|
} else {
|
|
deleteDeclaration.deleteDeclaration(this, deletedNodesInLists, sourceFile, node);
|
|
}
|
|
}
|
|
}
|
|
deletedNodesInLists.forEach((node) => {
|
|
const sourceFile = node.getSourceFile();
|
|
const list = ts_formatting_exports.SmartIndenter.getContainingList(node, sourceFile);
|
|
if (node !== last(list))
|
|
return;
|
|
const lastNonDeletedIndex = findLastIndex(list, (n) => !deletedNodesInLists.has(n), list.length - 2);
|
|
if (lastNonDeletedIndex !== -1) {
|
|
this.deleteRange(sourceFile, { pos: list[lastNonDeletedIndex].end, end: startPositionToDeleteNodeInList(sourceFile, list[lastNonDeletedIndex + 1]) });
|
|
}
|
|
});
|
|
}
|
|
getChanges(validate) {
|
|
this.finishDeleteDeclarations();
|
|
this.finishClassesWithNodesInsertedAtStart();
|
|
const changes = changesToText.getTextChangesFromChanges(this.changes, this.newLineCharacter, this.formatContext, validate);
|
|
for (const { oldFile, fileName, statements } of this.newFiles) {
|
|
changes.push(changesToText.newFileChanges(oldFile, fileName, statements, this.newLineCharacter, this.formatContext));
|
|
}
|
|
return changes;
|
|
}
|
|
createNewFile(oldFile, fileName, statements) {
|
|
this.newFiles.push({ oldFile, fileName, statements });
|
|
}
|
|
};
|
|
function updateJSDocHost(parent2) {
|
|
if (parent2.kind !== 216 /* ArrowFunction */) {
|
|
return parent2;
|
|
}
|
|
const jsDocNode = parent2.parent.kind === 169 /* PropertyDeclaration */ ? parent2.parent : parent2.parent.parent;
|
|
jsDocNode.jsDoc = parent2.jsDoc;
|
|
jsDocNode.jsDocCache = parent2.jsDocCache;
|
|
return jsDocNode;
|
|
}
|
|
function tryMergeJsdocTags(oldTag, newTag) {
|
|
if (oldTag.kind !== newTag.kind) {
|
|
return void 0;
|
|
}
|
|
switch (oldTag.kind) {
|
|
case 343 /* JSDocParameterTag */: {
|
|
const oldParam = oldTag;
|
|
const newParam = newTag;
|
|
return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText ? factory.createJSDocParameterTag(void 0, newParam.name, false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment) : void 0;
|
|
}
|
|
case 344 /* JSDocReturnTag */:
|
|
return factory.createJSDocReturnTag(void 0, newTag.typeExpression, oldTag.comment);
|
|
case 346 /* JSDocTypeTag */:
|
|
return factory.createJSDocTypeTag(void 0, newTag.typeExpression, oldTag.comment);
|
|
}
|
|
}
|
|
function startPositionToDeleteNodeInList(sourceFile, node) {
|
|
return skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: 1 /* IncludeAll */ }), false, true);
|
|
}
|
|
function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) {
|
|
const end = startPositionToDeleteNodeInList(sourceFile, nextNode);
|
|
if (prevNode === void 0 || positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) {
|
|
return end;
|
|
}
|
|
const token = findPrecedingToken(nextNode.getStart(sourceFile), sourceFile);
|
|
if (isSeparator(node, token)) {
|
|
const prevToken = findPrecedingToken(node.getStart(sourceFile), sourceFile);
|
|
if (isSeparator(prevNode, prevToken)) {
|
|
const pos = skipTrivia(sourceFile.text, token.getEnd(), true, true);
|
|
if (positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) {
|
|
return isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos;
|
|
}
|
|
if (isLineBreak(sourceFile.text.charCodeAt(pos))) {
|
|
return pos;
|
|
}
|
|
}
|
|
}
|
|
return end;
|
|
}
|
|
function getClassOrObjectBraceEnds(cls, sourceFile) {
|
|
const open = findChildOfKind(cls, 18 /* OpenBraceToken */, sourceFile);
|
|
const close2 = findChildOfKind(cls, 19 /* CloseBraceToken */, sourceFile);
|
|
return [open == null ? void 0 : open.end, close2 == null ? void 0 : close2.end];
|
|
}
|
|
function getMembersOrProperties(node) {
|
|
return isObjectLiteralExpression(node) ? node.properties : node.members;
|
|
}
|
|
function getNewFileText(statements, scriptKind, newLineCharacter, formatContext) {
|
|
return changesToText.newFileChangesWorker(void 0, scriptKind, statements, newLineCharacter, formatContext);
|
|
}
|
|
var changesToText;
|
|
((changesToText2) => {
|
|
function getTextChangesFromChanges(changes, newLineCharacter, formatContext, validate) {
|
|
return mapDefined(group(changes, (c) => c.sourceFile.path), (changesInFile) => {
|
|
const sourceFile = changesInFile[0].sourceFile;
|
|
const normalized = stableSort(changesInFile, (a, b) => a.range.pos - b.range.pos || a.range.end - b.range.end);
|
|
for (let i = 0; i < normalized.length - 1; i++) {
|
|
Debug.assert(normalized[i].range.end <= normalized[i + 1].range.pos, "Changes overlap", () => `${JSON.stringify(normalized[i].range)} and ${JSON.stringify(normalized[i + 1].range)}`);
|
|
}
|
|
const textChanges2 = mapDefined(normalized, (c) => {
|
|
const span = createTextSpanFromRange(c.range);
|
|
const newText = computeNewText(c, sourceFile, newLineCharacter, formatContext, validate);
|
|
if (span.length === newText.length && stringContainsAt(sourceFile.text, newText, span.start)) {
|
|
return void 0;
|
|
}
|
|
return createTextChange(span, newText);
|
|
});
|
|
return textChanges2.length > 0 ? { fileName: sourceFile.fileName, textChanges: textChanges2 } : void 0;
|
|
});
|
|
}
|
|
changesToText2.getTextChangesFromChanges = getTextChangesFromChanges;
|
|
function newFileChanges(oldFile, fileName, statements, newLineCharacter, formatContext) {
|
|
const text = newFileChangesWorker(oldFile, getScriptKindFromFileName(fileName), statements, newLineCharacter, formatContext);
|
|
return { fileName, textChanges: [createTextChange(createTextSpan(0, 0), text)], isNewFile: true };
|
|
}
|
|
changesToText2.newFileChanges = newFileChanges;
|
|
function newFileChangesWorker(oldFile, scriptKind, statements, newLineCharacter, formatContext) {
|
|
const nonFormattedText = statements.map((s) => s === 4 /* NewLineTrivia */ ? "" : getNonformattedText(s, oldFile, newLineCharacter).text).join(newLineCharacter);
|
|
const sourceFile = createSourceFile("any file name", nonFormattedText, 99 /* ESNext */, true, scriptKind);
|
|
const changes = ts_formatting_exports.formatDocument(sourceFile, formatContext);
|
|
return applyChanges(nonFormattedText, changes) + newLineCharacter;
|
|
}
|
|
changesToText2.newFileChangesWorker = newFileChangesWorker;
|
|
function computeNewText(change, sourceFile, newLineCharacter, formatContext, validate) {
|
|
var _a2;
|
|
if (change.kind === 0 /* Remove */) {
|
|
return "";
|
|
}
|
|
if (change.kind === 3 /* Text */) {
|
|
return change.text;
|
|
}
|
|
const { options = {}, range: { pos } } = change;
|
|
const format = (n) => getFormattedTextOfNode(n, sourceFile, pos, options, newLineCharacter, formatContext, validate);
|
|
const text = change.kind === 2 /* ReplaceWithMultipleNodes */ ? change.nodes.map((n) => removeSuffix(format(n), newLineCharacter)).join(((_a2 = change.options) == null ? void 0 : _a2.joiner) || newLineCharacter) : format(change.node);
|
|
const noIndent = options.indentation !== void 0 || getLineStartPositionForPosition(pos, sourceFile) === pos ? text : text.replace(/^\s+/, "");
|
|
return (options.prefix || "") + noIndent + (!options.suffix || endsWith(noIndent, options.suffix) ? "" : options.suffix);
|
|
}
|
|
function getFormattedTextOfNode(nodeIn, sourceFile, pos, { indentation, prefix, delta }, newLineCharacter, formatContext, validate) {
|
|
const { node, text } = getNonformattedText(nodeIn, sourceFile, newLineCharacter);
|
|
if (validate)
|
|
validate(node, text);
|
|
const formatOptions = getFormatCodeSettingsForWriting(formatContext, sourceFile);
|
|
const initialIndentation = indentation !== void 0 ? indentation : ts_formatting_exports.SmartIndenter.getIndentation(pos, sourceFile, formatOptions, prefix === newLineCharacter || getLineStartPositionForPosition(pos, sourceFile) === pos);
|
|
if (delta === void 0) {
|
|
delta = ts_formatting_exports.SmartIndenter.shouldIndentChildNode(formatOptions, nodeIn) ? formatOptions.indentSize || 0 : 0;
|
|
}
|
|
const file = {
|
|
text,
|
|
getLineAndCharacterOfPosition(pos2) {
|
|
return getLineAndCharacterOfPosition(this, pos2);
|
|
}
|
|
};
|
|
const changes = ts_formatting_exports.formatNodeGivenIndentation(node, file, sourceFile.languageVariant, initialIndentation, delta, { ...formatContext, options: formatOptions });
|
|
return applyChanges(text, changes);
|
|
}
|
|
function getNonformattedText(node, sourceFile, newLineCharacter) {
|
|
const writer = createWriter(newLineCharacter);
|
|
const newLine = getNewLineKind(newLineCharacter);
|
|
createPrinter({
|
|
newLine,
|
|
neverAsciiEscape: true,
|
|
preserveSourceNewlines: true,
|
|
terminateUnterminatedLiterals: true
|
|
}, writer).writeNode(4 /* Unspecified */, node, sourceFile, writer);
|
|
return { text: writer.getText(), node: assignPositionsToNode(node) };
|
|
}
|
|
changesToText2.getNonformattedText = getNonformattedText;
|
|
})(changesToText || (changesToText = {}));
|
|
function applyChanges(text, changes) {
|
|
for (let i = changes.length - 1; i >= 0; i--) {
|
|
const { span, newText } = changes[i];
|
|
text = `${text.substring(0, span.start)}${newText}${text.substring(textSpanEnd(span))}`;
|
|
}
|
|
return text;
|
|
}
|
|
function isTrivia2(s) {
|
|
return skipTrivia(s, 0) === s.length;
|
|
}
|
|
var textChangesTransformationContext = {
|
|
...nullTransformationContext,
|
|
factory: createNodeFactory(
|
|
nullTransformationContext.factory.flags | 1 /* NoParenthesizerRules */,
|
|
nullTransformationContext.factory.baseFactory
|
|
)
|
|
};
|
|
function assignPositionsToNode(node) {
|
|
const visited = visitEachChild(node, assignPositionsToNode, textChangesTransformationContext, assignPositionsToNodeArray, assignPositionsToNode);
|
|
const newNode = nodeIsSynthesized(visited) ? visited : Object.create(visited);
|
|
setTextRangePosEnd(newNode, getPos2(node), getEnd(node));
|
|
return newNode;
|
|
}
|
|
function assignPositionsToNodeArray(nodes, visitor, test, start2, count) {
|
|
const visited = visitNodes2(nodes, visitor, test, start2, count);
|
|
if (!visited) {
|
|
return visited;
|
|
}
|
|
const nodeArray = visited === nodes ? factory.createNodeArray(visited.slice(0)) : visited;
|
|
setTextRangePosEnd(nodeArray, getPos2(nodes), getEnd(nodes));
|
|
return nodeArray;
|
|
}
|
|
function createWriter(newLine) {
|
|
let lastNonTriviaPosition = 0;
|
|
const writer = createTextWriter(newLine);
|
|
const onBeforeEmitNode = (node) => {
|
|
if (node) {
|
|
setPos(node, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
const onAfterEmitNode = (node) => {
|
|
if (node) {
|
|
setEnd(node, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
const onBeforeEmitNodeArray = (nodes) => {
|
|
if (nodes) {
|
|
setPos(nodes, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
const onAfterEmitNodeArray = (nodes) => {
|
|
if (nodes) {
|
|
setEnd(nodes, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
const onBeforeEmitToken = (node) => {
|
|
if (node) {
|
|
setPos(node, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
const onAfterEmitToken = (node) => {
|
|
if (node) {
|
|
setEnd(node, lastNonTriviaPosition);
|
|
}
|
|
};
|
|
function setLastNonTriviaPosition(s, force) {
|
|
if (force || !isTrivia2(s)) {
|
|
lastNonTriviaPosition = writer.getTextPos();
|
|
let i = 0;
|
|
while (isWhiteSpaceLike(s.charCodeAt(s.length - i - 1))) {
|
|
i++;
|
|
}
|
|
lastNonTriviaPosition -= i;
|
|
}
|
|
}
|
|
function write(s) {
|
|
writer.write(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeComment(s) {
|
|
writer.writeComment(s);
|
|
}
|
|
function writeKeyword(s) {
|
|
writer.writeKeyword(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeOperator(s) {
|
|
writer.writeOperator(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writePunctuation(s) {
|
|
writer.writePunctuation(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeTrailingSemicolon(s) {
|
|
writer.writeTrailingSemicolon(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeParameter(s) {
|
|
writer.writeParameter(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeProperty(s) {
|
|
writer.writeProperty(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeSpace(s) {
|
|
writer.writeSpace(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeStringLiteral(s) {
|
|
writer.writeStringLiteral(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeSymbol(s, sym) {
|
|
writer.writeSymbol(s, sym);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeLine(force) {
|
|
writer.writeLine(force);
|
|
}
|
|
function increaseIndent() {
|
|
writer.increaseIndent();
|
|
}
|
|
function decreaseIndent() {
|
|
writer.decreaseIndent();
|
|
}
|
|
function getText() {
|
|
return writer.getText();
|
|
}
|
|
function rawWrite(s) {
|
|
writer.rawWrite(s);
|
|
setLastNonTriviaPosition(s, false);
|
|
}
|
|
function writeLiteral(s) {
|
|
writer.writeLiteral(s);
|
|
setLastNonTriviaPosition(s, true);
|
|
}
|
|
function getTextPos() {
|
|
return writer.getTextPos();
|
|
}
|
|
function getLine() {
|
|
return writer.getLine();
|
|
}
|
|
function getColumn() {
|
|
return writer.getColumn();
|
|
}
|
|
function getIndent() {
|
|
return writer.getIndent();
|
|
}
|
|
function isAtStartOfLine() {
|
|
return writer.isAtStartOfLine();
|
|
}
|
|
function clear2() {
|
|
writer.clear();
|
|
lastNonTriviaPosition = 0;
|
|
}
|
|
return {
|
|
onBeforeEmitNode,
|
|
onAfterEmitNode,
|
|
onBeforeEmitNodeArray,
|
|
onAfterEmitNodeArray,
|
|
onBeforeEmitToken,
|
|
onAfterEmitToken,
|
|
write,
|
|
writeComment,
|
|
writeKeyword,
|
|
writeOperator,
|
|
writePunctuation,
|
|
writeTrailingSemicolon,
|
|
writeParameter,
|
|
writeProperty,
|
|
writeSpace,
|
|
writeStringLiteral,
|
|
writeSymbol,
|
|
writeLine,
|
|
increaseIndent,
|
|
decreaseIndent,
|
|
getText,
|
|
rawWrite,
|
|
writeLiteral,
|
|
getTextPos,
|
|
getLine,
|
|
getColumn,
|
|
getIndent,
|
|
isAtStartOfLine,
|
|
hasTrailingComment: () => writer.hasTrailingComment(),
|
|
hasTrailingWhitespace: () => writer.hasTrailingWhitespace(),
|
|
clear: clear2
|
|
};
|
|
}
|
|
function getInsertionPositionAtSourceFileTop(sourceFile) {
|
|
let lastPrologue;
|
|
for (const node of sourceFile.statements) {
|
|
if (isPrologueDirective(node)) {
|
|
lastPrologue = node;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
let position = 0;
|
|
const text = sourceFile.text;
|
|
if (lastPrologue) {
|
|
position = lastPrologue.end;
|
|
advancePastLineBreak();
|
|
return position;
|
|
}
|
|
const shebang = getShebang(text);
|
|
if (shebang !== void 0) {
|
|
position = shebang.length;
|
|
advancePastLineBreak();
|
|
}
|
|
const ranges = getLeadingCommentRanges(text, position);
|
|
if (!ranges)
|
|
return position;
|
|
let lastComment;
|
|
let firstNodeLine;
|
|
for (const range of ranges) {
|
|
if (range.kind === 3 /* MultiLineCommentTrivia */) {
|
|
if (isPinnedComment(text, range.pos)) {
|
|
lastComment = { range, pinnedOrTripleSlash: true };
|
|
continue;
|
|
}
|
|
} else if (isRecognizedTripleSlashComment(text, range.pos, range.end)) {
|
|
lastComment = { range, pinnedOrTripleSlash: true };
|
|
continue;
|
|
}
|
|
if (lastComment) {
|
|
if (lastComment.pinnedOrTripleSlash)
|
|
break;
|
|
const commentLine = sourceFile.getLineAndCharacterOfPosition(range.pos).line;
|
|
const lastCommentEndLine = sourceFile.getLineAndCharacterOfPosition(lastComment.range.end).line;
|
|
if (commentLine >= lastCommentEndLine + 2)
|
|
break;
|
|
}
|
|
if (sourceFile.statements.length) {
|
|
if (firstNodeLine === void 0)
|
|
firstNodeLine = sourceFile.getLineAndCharacterOfPosition(sourceFile.statements[0].getStart()).line;
|
|
const commentEndLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
|
|
if (firstNodeLine < commentEndLine + 2)
|
|
break;
|
|
}
|
|
lastComment = { range, pinnedOrTripleSlash: false };
|
|
}
|
|
if (lastComment) {
|
|
position = lastComment.range.end;
|
|
advancePastLineBreak();
|
|
}
|
|
return position;
|
|
function advancePastLineBreak() {
|
|
if (position < text.length) {
|
|
const charCode = text.charCodeAt(position);
|
|
if (isLineBreak(charCode)) {
|
|
position++;
|
|
if (position < text.length && charCode === 13 /* carriageReturn */ && text.charCodeAt(position) === 10 /* lineFeed */) {
|
|
position++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function isValidLocationToAddComment(sourceFile, position) {
|
|
return !isInComment(sourceFile, position) && !isInString(sourceFile, position) && !isInTemplateString(sourceFile, position) && !isInJSXText(sourceFile, position);
|
|
}
|
|
function needSemicolonBetween(a, b) {
|
|
return (isPropertySignature(a) || isPropertyDeclaration(a)) && isClassOrTypeElement(b) && b.name.kind === 164 /* ComputedPropertyName */ || isStatementButNotDeclaration(a) && isStatementButNotDeclaration(b);
|
|
}
|
|
var deleteDeclaration;
|
|
((_deleteDeclaration) => {
|
|
function deleteDeclaration2(changes, deletedNodesInLists, sourceFile, node) {
|
|
switch (node.kind) {
|
|
case 166 /* Parameter */: {
|
|
const oldFunction = node.parent;
|
|
if (isArrowFunction(oldFunction) && oldFunction.parameters.length === 1 && !findChildOfKind(oldFunction, 20 /* OpenParenToken */, sourceFile)) {
|
|
changes.replaceNodeWithText(sourceFile, node, "()");
|
|
} else {
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
}
|
|
break;
|
|
}
|
|
case 269 /* ImportDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
const isFirstImport = sourceFile.imports.length && node === first(sourceFile.imports).parent || node === find(sourceFile.statements, isAnyImportSyntax);
|
|
deleteNode(changes, sourceFile, node, {
|
|
leadingTriviaOption: isFirstImport ? 0 /* Exclude */ : hasJSDocNodes(node) ? 2 /* JSDoc */ : 3 /* StartLine */
|
|
});
|
|
break;
|
|
case 205 /* BindingElement */:
|
|
const pattern = node.parent;
|
|
const preserveComma = pattern.kind === 204 /* ArrayBindingPattern */ && node !== last(pattern.elements);
|
|
if (preserveComma) {
|
|
deleteNode(changes, sourceFile, node);
|
|
} else {
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
}
|
|
break;
|
|
case 257 /* VariableDeclaration */:
|
|
deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node);
|
|
break;
|
|
case 165 /* TypeParameter */:
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
break;
|
|
case 273 /* ImportSpecifier */:
|
|
const namedImports = node.parent;
|
|
if (namedImports.elements.length === 1) {
|
|
deleteImportBinding(changes, sourceFile, namedImports);
|
|
} else {
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
}
|
|
break;
|
|
case 271 /* NamespaceImport */:
|
|
deleteImportBinding(changes, sourceFile, node);
|
|
break;
|
|
case 26 /* SemicolonToken */:
|
|
deleteNode(changes, sourceFile, node, { trailingTriviaOption: 0 /* Exclude */ });
|
|
break;
|
|
case 98 /* FunctionKeyword */:
|
|
deleteNode(changes, sourceFile, node, { leadingTriviaOption: 0 /* Exclude */ });
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
deleteNode(changes, sourceFile, node, { leadingTriviaOption: hasJSDocNodes(node) ? 2 /* JSDoc */ : 3 /* StartLine */ });
|
|
break;
|
|
default:
|
|
if (!node.parent) {
|
|
deleteNode(changes, sourceFile, node);
|
|
} else if (isImportClause(node.parent) && node.parent.name === node) {
|
|
deleteDefaultImport(changes, sourceFile, node.parent);
|
|
} else if (isCallExpression(node.parent) && contains(node.parent.arguments, node)) {
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
} else {
|
|
deleteNode(changes, sourceFile, node);
|
|
}
|
|
}
|
|
}
|
|
_deleteDeclaration.deleteDeclaration = deleteDeclaration2;
|
|
function deleteDefaultImport(changes, sourceFile, importClause) {
|
|
if (!importClause.namedBindings) {
|
|
deleteNode(changes, sourceFile, importClause.parent);
|
|
} else {
|
|
const start2 = importClause.name.getStart(sourceFile);
|
|
const nextToken = getTokenAtPosition(sourceFile, importClause.name.end);
|
|
if (nextToken && nextToken.kind === 27 /* CommaToken */) {
|
|
const end = skipTrivia(sourceFile.text, nextToken.end, false, true);
|
|
changes.deleteRange(sourceFile, { pos: start2, end });
|
|
} else {
|
|
deleteNode(changes, sourceFile, importClause.name);
|
|
}
|
|
}
|
|
}
|
|
function deleteImportBinding(changes, sourceFile, node) {
|
|
if (node.parent.name) {
|
|
const previousToken = Debug.checkDefined(getTokenAtPosition(sourceFile, node.pos - 1));
|
|
changes.deleteRange(sourceFile, { pos: previousToken.getStart(sourceFile), end: node.end });
|
|
} else {
|
|
const importDecl = getAncestor(node, 269 /* ImportDeclaration */);
|
|
deleteNode(changes, sourceFile, importDecl);
|
|
}
|
|
}
|
|
function deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node) {
|
|
const { parent: parent2 } = node;
|
|
if (parent2.kind === 295 /* CatchClause */) {
|
|
changes.deleteNodeRange(sourceFile, findChildOfKind(parent2, 20 /* OpenParenToken */, sourceFile), findChildOfKind(parent2, 21 /* CloseParenToken */, sourceFile));
|
|
return;
|
|
}
|
|
if (parent2.declarations.length !== 1) {
|
|
deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
|
|
return;
|
|
}
|
|
const gp = parent2.parent;
|
|
switch (gp.kind) {
|
|
case 247 /* ForOfStatement */:
|
|
case 246 /* ForInStatement */:
|
|
changes.replaceNode(sourceFile, node, factory.createObjectLiteralExpression());
|
|
break;
|
|
case 245 /* ForStatement */:
|
|
deleteNode(changes, sourceFile, parent2);
|
|
break;
|
|
case 240 /* VariableStatement */:
|
|
deleteNode(changes, sourceFile, gp, { leadingTriviaOption: hasJSDocNodes(gp) ? 2 /* JSDoc */ : 3 /* StartLine */ });
|
|
break;
|
|
default:
|
|
Debug.assertNever(gp);
|
|
}
|
|
}
|
|
})(deleteDeclaration || (deleteDeclaration = {}));
|
|
function deleteNode(changes, sourceFile, node, options = { leadingTriviaOption: 1 /* IncludeAll */ }) {
|
|
const startPosition = getAdjustedStartPosition(sourceFile, node, options);
|
|
const endPosition = getAdjustedEndPosition(sourceFile, node, options);
|
|
changes.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
|
|
}
|
|
function deleteNodeInList(changes, deletedNodesInLists, sourceFile, node) {
|
|
const containingList = Debug.checkDefined(ts_formatting_exports.SmartIndenter.getContainingList(node, sourceFile));
|
|
const index = indexOfNode(containingList, node);
|
|
Debug.assert(index !== -1);
|
|
if (containingList.length === 1) {
|
|
deleteNode(changes, sourceFile, node);
|
|
return;
|
|
}
|
|
Debug.assert(!deletedNodesInLists.has(node), "Deleting a node twice");
|
|
deletedNodesInLists.add(node);
|
|
changes.deleteRange(sourceFile, {
|
|
pos: startPositionToDeleteNodeInList(sourceFile, node),
|
|
end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1])
|
|
});
|
|
}
|
|
|
|
// src/services/_namespaces/ts.formatting.ts
|
|
var ts_formatting_exports = {};
|
|
__export(ts_formatting_exports, {
|
|
FormattingContext: () => FormattingContext,
|
|
FormattingRequestKind: () => FormattingRequestKind,
|
|
RuleAction: () => RuleAction,
|
|
RuleFlags: () => RuleFlags,
|
|
SmartIndenter: () => SmartIndenter,
|
|
anyContext: () => anyContext,
|
|
createTextRangeWithKind: () => createTextRangeWithKind,
|
|
formatDocument: () => formatDocument,
|
|
formatNodeGivenIndentation: () => formatNodeGivenIndentation,
|
|
formatOnClosingCurly: () => formatOnClosingCurly,
|
|
formatOnEnter: () => formatOnEnter,
|
|
formatOnOpeningCurly: () => formatOnOpeningCurly,
|
|
formatOnSemicolon: () => formatOnSemicolon,
|
|
formatSelection: () => formatSelection,
|
|
getAllRules: () => getAllRules,
|
|
getFormatContext: () => getFormatContext,
|
|
getFormattingScanner: () => getFormattingScanner,
|
|
getIndentationString: () => getIndentationString,
|
|
getRangeOfEnclosingComment: () => getRangeOfEnclosingComment
|
|
});
|
|
|
|
// src/services/formatting/formattingContext.ts
|
|
var FormattingRequestKind = /* @__PURE__ */ ((FormattingRequestKind2) => {
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatDocument"] = 0] = "FormatDocument";
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatSelection"] = 1] = "FormatSelection";
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatOnEnter"] = 2] = "FormatOnEnter";
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatOnSemicolon"] = 3] = "FormatOnSemicolon";
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatOnOpeningCurlyBrace"] = 4] = "FormatOnOpeningCurlyBrace";
|
|
FormattingRequestKind2[FormattingRequestKind2["FormatOnClosingCurlyBrace"] = 5] = "FormatOnClosingCurlyBrace";
|
|
return FormattingRequestKind2;
|
|
})(FormattingRequestKind || {});
|
|
var FormattingContext = class {
|
|
constructor(sourceFile, formattingRequestKind, options) {
|
|
this.sourceFile = sourceFile;
|
|
this.formattingRequestKind = formattingRequestKind;
|
|
this.options = options;
|
|
}
|
|
updateContext(currentRange, currentTokenParent, nextRange, nextTokenParent, commonParent) {
|
|
this.currentTokenSpan = Debug.checkDefined(currentRange);
|
|
this.currentTokenParent = Debug.checkDefined(currentTokenParent);
|
|
this.nextTokenSpan = Debug.checkDefined(nextRange);
|
|
this.nextTokenParent = Debug.checkDefined(nextTokenParent);
|
|
this.contextNode = Debug.checkDefined(commonParent);
|
|
this.contextNodeAllOnSameLine = void 0;
|
|
this.nextNodeAllOnSameLine = void 0;
|
|
this.tokensAreOnSameLine = void 0;
|
|
this.contextNodeBlockIsOnOneLine = void 0;
|
|
this.nextNodeBlockIsOnOneLine = void 0;
|
|
}
|
|
ContextNodeAllOnSameLine() {
|
|
if (this.contextNodeAllOnSameLine === void 0) {
|
|
this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode);
|
|
}
|
|
return this.contextNodeAllOnSameLine;
|
|
}
|
|
NextNodeAllOnSameLine() {
|
|
if (this.nextNodeAllOnSameLine === void 0) {
|
|
this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent);
|
|
}
|
|
return this.nextNodeAllOnSameLine;
|
|
}
|
|
TokensAreOnSameLine() {
|
|
if (this.tokensAreOnSameLine === void 0) {
|
|
const startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line;
|
|
const endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line;
|
|
this.tokensAreOnSameLine = startLine === endLine;
|
|
}
|
|
return this.tokensAreOnSameLine;
|
|
}
|
|
ContextNodeBlockIsOnOneLine() {
|
|
if (this.contextNodeBlockIsOnOneLine === void 0) {
|
|
this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode);
|
|
}
|
|
return this.contextNodeBlockIsOnOneLine;
|
|
}
|
|
NextNodeBlockIsOnOneLine() {
|
|
if (this.nextNodeBlockIsOnOneLine === void 0) {
|
|
this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent);
|
|
}
|
|
return this.nextNodeBlockIsOnOneLine;
|
|
}
|
|
NodeIsOnOneLine(node) {
|
|
const startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line;
|
|
const endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line;
|
|
return startLine === endLine;
|
|
}
|
|
BlockIsOnOneLine(node) {
|
|
const openBrace = findChildOfKind(node, 18 /* OpenBraceToken */, this.sourceFile);
|
|
const closeBrace = findChildOfKind(node, 19 /* CloseBraceToken */, this.sourceFile);
|
|
if (openBrace && closeBrace) {
|
|
const startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line;
|
|
const endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line;
|
|
return startLine === endLine;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// src/services/formatting/formattingScanner.ts
|
|
var standardScanner = createScanner(99 /* Latest */, false, 0 /* Standard */);
|
|
var jsxScanner = createScanner(99 /* Latest */, false, 1 /* JSX */);
|
|
function getFormattingScanner(text, languageVariant, startPos, endPos, cb) {
|
|
const scanner2 = languageVariant === 1 /* JSX */ ? jsxScanner : standardScanner;
|
|
scanner2.setText(text);
|
|
scanner2.setTextPos(startPos);
|
|
let wasNewLine = true;
|
|
let leadingTrivia;
|
|
let trailingTrivia;
|
|
let savedPos;
|
|
let lastScanAction;
|
|
let lastTokenInfo;
|
|
const res = cb({
|
|
advance,
|
|
readTokenInfo,
|
|
readEOFTokenRange,
|
|
isOnToken,
|
|
isOnEOF,
|
|
getCurrentLeadingTrivia: () => leadingTrivia,
|
|
lastTrailingTriviaWasNewLine: () => wasNewLine,
|
|
skipToEndOf,
|
|
skipToStartOf,
|
|
getStartPos: () => {
|
|
var _a2;
|
|
return (_a2 = lastTokenInfo == null ? void 0 : lastTokenInfo.token.pos) != null ? _a2 : scanner2.getTokenPos();
|
|
}
|
|
});
|
|
lastTokenInfo = void 0;
|
|
scanner2.setText(void 0);
|
|
return res;
|
|
function advance() {
|
|
lastTokenInfo = void 0;
|
|
const isStarted = scanner2.getStartPos() !== startPos;
|
|
if (isStarted) {
|
|
wasNewLine = !!trailingTrivia && last(trailingTrivia).kind === 4 /* NewLineTrivia */;
|
|
} else {
|
|
scanner2.scan();
|
|
}
|
|
leadingTrivia = void 0;
|
|
trailingTrivia = void 0;
|
|
let pos = scanner2.getStartPos();
|
|
while (pos < endPos) {
|
|
const t = scanner2.getToken();
|
|
if (!isTrivia(t)) {
|
|
break;
|
|
}
|
|
scanner2.scan();
|
|
const item = {
|
|
pos,
|
|
end: scanner2.getStartPos(),
|
|
kind: t
|
|
};
|
|
pos = scanner2.getStartPos();
|
|
leadingTrivia = append(leadingTrivia, item);
|
|
}
|
|
savedPos = scanner2.getStartPos();
|
|
}
|
|
function shouldRescanGreaterThanToken(node) {
|
|
switch (node.kind) {
|
|
case 33 /* GreaterThanEqualsToken */:
|
|
case 71 /* GreaterThanGreaterThanEqualsToken */:
|
|
case 72 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
|
|
case 49 /* GreaterThanGreaterThanGreaterThanToken */:
|
|
case 48 /* GreaterThanGreaterThanToken */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function shouldRescanJsxIdentifier(node) {
|
|
if (node.parent) {
|
|
switch (node.parent.kind) {
|
|
case 288 /* JsxAttribute */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return isKeyword(node.kind) || node.kind === 79 /* Identifier */;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function shouldRescanJsxText(node) {
|
|
return isJsxText(node) || isJsxElement(node) && (lastTokenInfo == null ? void 0 : lastTokenInfo.token.kind) === 11 /* JsxText */;
|
|
}
|
|
function shouldRescanSlashToken(container) {
|
|
return container.kind === 13 /* RegularExpressionLiteral */;
|
|
}
|
|
function shouldRescanTemplateToken(container) {
|
|
return container.kind === 16 /* TemplateMiddle */ || container.kind === 17 /* TemplateTail */;
|
|
}
|
|
function shouldRescanJsxAttributeValue(node) {
|
|
return node.parent && isJsxAttribute(node.parent) && node.parent.initializer === node;
|
|
}
|
|
function startsWithSlashToken(t) {
|
|
return t === 43 /* SlashToken */ || t === 68 /* SlashEqualsToken */;
|
|
}
|
|
function readTokenInfo(n) {
|
|
Debug.assert(isOnToken());
|
|
const expectedScanAction = shouldRescanGreaterThanToken(n) ? 1 /* RescanGreaterThanToken */ : shouldRescanSlashToken(n) ? 2 /* RescanSlashToken */ : shouldRescanTemplateToken(n) ? 3 /* RescanTemplateToken */ : shouldRescanJsxIdentifier(n) ? 4 /* RescanJsxIdentifier */ : shouldRescanJsxText(n) ? 5 /* RescanJsxText */ : shouldRescanJsxAttributeValue(n) ? 6 /* RescanJsxAttributeValue */ : 0 /* Scan */;
|
|
if (lastTokenInfo && expectedScanAction === lastScanAction) {
|
|
return fixTokenKind(lastTokenInfo, n);
|
|
}
|
|
if (scanner2.getStartPos() !== savedPos) {
|
|
Debug.assert(lastTokenInfo !== void 0);
|
|
scanner2.setTextPos(savedPos);
|
|
scanner2.scan();
|
|
}
|
|
let currentToken = getNextToken(n, expectedScanAction);
|
|
const token = createTextRangeWithKind(
|
|
scanner2.getStartPos(),
|
|
scanner2.getTextPos(),
|
|
currentToken
|
|
);
|
|
if (trailingTrivia) {
|
|
trailingTrivia = void 0;
|
|
}
|
|
while (scanner2.getStartPos() < endPos) {
|
|
currentToken = scanner2.scan();
|
|
if (!isTrivia(currentToken)) {
|
|
break;
|
|
}
|
|
const trivia = createTextRangeWithKind(
|
|
scanner2.getStartPos(),
|
|
scanner2.getTextPos(),
|
|
currentToken
|
|
);
|
|
if (!trailingTrivia) {
|
|
trailingTrivia = [];
|
|
}
|
|
trailingTrivia.push(trivia);
|
|
if (currentToken === 4 /* NewLineTrivia */) {
|
|
scanner2.scan();
|
|
break;
|
|
}
|
|
}
|
|
lastTokenInfo = { leadingTrivia, trailingTrivia, token };
|
|
return fixTokenKind(lastTokenInfo, n);
|
|
}
|
|
function getNextToken(n, expectedScanAction) {
|
|
const token = scanner2.getToken();
|
|
lastScanAction = 0 /* Scan */;
|
|
switch (expectedScanAction) {
|
|
case 1 /* RescanGreaterThanToken */:
|
|
if (token === 31 /* GreaterThanToken */) {
|
|
lastScanAction = 1 /* RescanGreaterThanToken */;
|
|
const newToken = scanner2.reScanGreaterToken();
|
|
Debug.assert(n.kind === newToken);
|
|
return newToken;
|
|
}
|
|
break;
|
|
case 2 /* RescanSlashToken */:
|
|
if (startsWithSlashToken(token)) {
|
|
lastScanAction = 2 /* RescanSlashToken */;
|
|
const newToken = scanner2.reScanSlashToken();
|
|
Debug.assert(n.kind === newToken);
|
|
return newToken;
|
|
}
|
|
break;
|
|
case 3 /* RescanTemplateToken */:
|
|
if (token === 19 /* CloseBraceToken */) {
|
|
lastScanAction = 3 /* RescanTemplateToken */;
|
|
return scanner2.reScanTemplateToken(false);
|
|
}
|
|
break;
|
|
case 4 /* RescanJsxIdentifier */:
|
|
lastScanAction = 4 /* RescanJsxIdentifier */;
|
|
return scanner2.scanJsxIdentifier();
|
|
case 5 /* RescanJsxText */:
|
|
lastScanAction = 5 /* RescanJsxText */;
|
|
return scanner2.reScanJsxToken(false);
|
|
case 6 /* RescanJsxAttributeValue */:
|
|
lastScanAction = 6 /* RescanJsxAttributeValue */;
|
|
return scanner2.reScanJsxAttributeValue();
|
|
case 0 /* Scan */:
|
|
break;
|
|
default:
|
|
Debug.assertNever(expectedScanAction);
|
|
}
|
|
return token;
|
|
}
|
|
function readEOFTokenRange() {
|
|
Debug.assert(isOnEOF());
|
|
return createTextRangeWithKind(scanner2.getStartPos(), scanner2.getTextPos(), 1 /* EndOfFileToken */);
|
|
}
|
|
function isOnToken() {
|
|
const current = lastTokenInfo ? lastTokenInfo.token.kind : scanner2.getToken();
|
|
return current !== 1 /* EndOfFileToken */ && !isTrivia(current);
|
|
}
|
|
function isOnEOF() {
|
|
const current = lastTokenInfo ? lastTokenInfo.token.kind : scanner2.getToken();
|
|
return current === 1 /* EndOfFileToken */;
|
|
}
|
|
function fixTokenKind(tokenInfo, container) {
|
|
if (isToken(container) && tokenInfo.token.kind !== container.kind) {
|
|
tokenInfo.token.kind = container.kind;
|
|
}
|
|
return tokenInfo;
|
|
}
|
|
function skipToEndOf(node) {
|
|
scanner2.setTextPos(node.end);
|
|
savedPos = scanner2.getStartPos();
|
|
lastScanAction = void 0;
|
|
lastTokenInfo = void 0;
|
|
wasNewLine = false;
|
|
leadingTrivia = void 0;
|
|
trailingTrivia = void 0;
|
|
}
|
|
function skipToStartOf(node) {
|
|
scanner2.setTextPos(node.pos);
|
|
savedPos = scanner2.getStartPos();
|
|
lastScanAction = void 0;
|
|
lastTokenInfo = void 0;
|
|
wasNewLine = false;
|
|
leadingTrivia = void 0;
|
|
trailingTrivia = void 0;
|
|
}
|
|
}
|
|
|
|
// src/services/formatting/rule.ts
|
|
var anyContext = emptyArray;
|
|
var RuleAction = /* @__PURE__ */ ((RuleAction2) => {
|
|
RuleAction2[RuleAction2["None"] = 0] = "None";
|
|
RuleAction2[RuleAction2["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions";
|
|
RuleAction2[RuleAction2["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions";
|
|
RuleAction2[RuleAction2["InsertSpace"] = 4] = "InsertSpace";
|
|
RuleAction2[RuleAction2["InsertNewLine"] = 8] = "InsertNewLine";
|
|
RuleAction2[RuleAction2["DeleteSpace"] = 16] = "DeleteSpace";
|
|
RuleAction2[RuleAction2["DeleteToken"] = 32] = "DeleteToken";
|
|
RuleAction2[RuleAction2["InsertTrailingSemicolon"] = 64] = "InsertTrailingSemicolon";
|
|
RuleAction2[RuleAction2["StopAction"] = 3] = "StopAction";
|
|
RuleAction2[RuleAction2["ModifySpaceAction"] = 28] = "ModifySpaceAction";
|
|
RuleAction2[RuleAction2["ModifyTokenAction"] = 96] = "ModifyTokenAction";
|
|
return RuleAction2;
|
|
})(RuleAction || {});
|
|
var RuleFlags = /* @__PURE__ */ ((RuleFlags2) => {
|
|
RuleFlags2[RuleFlags2["None"] = 0] = "None";
|
|
RuleFlags2[RuleFlags2["CanDeleteNewLines"] = 1] = "CanDeleteNewLines";
|
|
return RuleFlags2;
|
|
})(RuleFlags || {});
|
|
|
|
// src/services/formatting/rules.ts
|
|
function getAllRules() {
|
|
const allTokens = [];
|
|
for (let token = 0 /* FirstToken */; token <= 162 /* LastToken */; token++) {
|
|
if (token !== 1 /* EndOfFileToken */) {
|
|
allTokens.push(token);
|
|
}
|
|
}
|
|
function anyTokenExcept(...tokens) {
|
|
return { tokens: allTokens.filter((t) => !tokens.some((t2) => t2 === t)), isSpecific: false };
|
|
}
|
|
const anyToken = { tokens: allTokens, isSpecific: false };
|
|
const anyTokenIncludingMultilineComments = tokenRangeFrom([...allTokens, 3 /* MultiLineCommentTrivia */]);
|
|
const anyTokenIncludingEOF = tokenRangeFrom([...allTokens, 1 /* EndOfFileToken */]);
|
|
const keywords = tokenRangeFromRange(81 /* FirstKeyword */, 162 /* LastKeyword */);
|
|
const binaryOperators = tokenRangeFromRange(29 /* FirstBinaryOperator */, 78 /* LastBinaryOperator */);
|
|
const binaryKeywordOperators = [101 /* InKeyword */, 102 /* InstanceOfKeyword */, 162 /* OfKeyword */, 128 /* AsKeyword */, 140 /* IsKeyword */];
|
|
const unaryPrefixOperators = [45 /* PlusPlusToken */, 46 /* MinusMinusToken */, 54 /* TildeToken */, 53 /* ExclamationToken */];
|
|
const unaryPrefixExpressions = [
|
|
8 /* NumericLiteral */,
|
|
9 /* BigIntLiteral */,
|
|
79 /* Identifier */,
|
|
20 /* OpenParenToken */,
|
|
22 /* OpenBracketToken */,
|
|
18 /* OpenBraceToken */,
|
|
108 /* ThisKeyword */,
|
|
103 /* NewKeyword */
|
|
];
|
|
const unaryPreincrementExpressions = [79 /* Identifier */, 20 /* OpenParenToken */, 108 /* ThisKeyword */, 103 /* NewKeyword */];
|
|
const unaryPostincrementExpressions = [79 /* Identifier */, 21 /* CloseParenToken */, 23 /* CloseBracketToken */, 103 /* NewKeyword */];
|
|
const unaryPredecrementExpressions = [79 /* Identifier */, 20 /* OpenParenToken */, 108 /* ThisKeyword */, 103 /* NewKeyword */];
|
|
const unaryPostdecrementExpressions = [79 /* Identifier */, 21 /* CloseParenToken */, 23 /* CloseBracketToken */, 103 /* NewKeyword */];
|
|
const comments = [2 /* SingleLineCommentTrivia */, 3 /* MultiLineCommentTrivia */];
|
|
const typeNames = [79 /* Identifier */, ...typeKeywords];
|
|
const functionOpenBraceLeftTokenRange = anyTokenIncludingMultilineComments;
|
|
const typeScriptOpenBraceLeftTokenRange = tokenRangeFrom([79 /* Identifier */, 3 /* MultiLineCommentTrivia */, 84 /* ClassKeyword */, 93 /* ExportKeyword */, 100 /* ImportKeyword */]);
|
|
const controlOpenBraceLeftTokenRange = tokenRangeFrom([21 /* CloseParenToken */, 3 /* MultiLineCommentTrivia */, 90 /* DoKeyword */, 111 /* TryKeyword */, 96 /* FinallyKeyword */, 91 /* ElseKeyword */]);
|
|
const highPriorityCommonRules = [
|
|
rule("IgnoreBeforeComment", anyToken, comments, anyContext, 1 /* StopProcessingSpaceActions */),
|
|
rule("IgnoreAfterLineComment", 2 /* SingleLineCommentTrivia */, anyToken, anyContext, 1 /* StopProcessingSpaceActions */),
|
|
rule("NotSpaceBeforeColon", anyToken, 58 /* ColonToken */, [isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterColon", 58 /* ColonToken */, anyToken, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeQuestionMark", anyToken, 57 /* QuestionToken */, [isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterQuestionMarkInConditionalOperator", 57 /* QuestionToken */, anyToken, [isNonJsxSameLineTokenContext, isConditionalOperatorContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterQuestionMark", 57 /* QuestionToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeDot", anyToken, [24 /* DotToken */, 28 /* QuestionDotToken */], [isNonJsxSameLineTokenContext, isNotPropertyAccessOnIntegerLiteral], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterDot", [24 /* DotToken */, 28 /* QuestionDotToken */], anyToken, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBetweenImportParenInImportType", 100 /* ImportKeyword */, 20 /* OpenParenToken */, [isNonJsxSameLineTokenContext, isImportTypeContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterUnaryPrefixOperator", unaryPrefixOperators, unaryPrefixExpressions, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterUnaryPreincrementOperator", 45 /* PlusPlusToken */, unaryPreincrementExpressions, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterUnaryPredecrementOperator", 46 /* MinusMinusToken */, unaryPredecrementExpressions, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeUnaryPostincrementOperator", unaryPostincrementExpressions, 45 /* PlusPlusToken */, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeUnaryPostdecrementOperator", unaryPostdecrementExpressions, 46 /* MinusMinusToken */, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterPostincrementWhenFollowedByAdd", 45 /* PlusPlusToken */, 39 /* PlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterAddWhenFollowedByUnaryPlus", 39 /* PlusToken */, 39 /* PlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterAddWhenFollowedByPreincrement", 39 /* PlusToken */, 45 /* PlusPlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterPostdecrementWhenFollowedBySubtract", 46 /* MinusMinusToken */, 40 /* MinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterSubtractWhenFollowedByUnaryMinus", 40 /* MinusToken */, 40 /* MinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterSubtractWhenFollowedByPredecrement", 40 /* MinusToken */, 46 /* MinusMinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterCloseBrace", 19 /* CloseBraceToken */, [27 /* CommaToken */, 26 /* SemicolonToken */], [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NewLineBeforeCloseBraceInBlockContext", anyTokenIncludingMultilineComments, 19 /* CloseBraceToken */, [isMultilineBlockContext], 8 /* InsertNewLine */),
|
|
rule("SpaceAfterCloseBrace", 19 /* CloseBraceToken */, anyTokenExcept(21 /* CloseParenToken */), [isNonJsxSameLineTokenContext, isAfterCodeBlockContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenCloseBraceAndElse", 19 /* CloseBraceToken */, 91 /* ElseKeyword */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenCloseBraceAndWhile", 19 /* CloseBraceToken */, 115 /* WhileKeyword */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* OpenBraceToken */, 19 /* CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterConditionalClosingParen", 21 /* CloseParenToken */, 22 /* OpenBracketToken */, [isControlDeclContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenFunctionKeywordAndStar", 98 /* FunctionKeyword */, 41 /* AsteriskToken */, [isFunctionDeclarationOrFunctionExpressionContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterStarInGeneratorDeclaration", 41 /* AsteriskToken */, 79 /* Identifier */, [isFunctionDeclarationOrFunctionExpressionContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterFunctionInFuncDecl", 98 /* FunctionKeyword */, anyToken, [isFunctionDeclContext], 4 /* InsertSpace */),
|
|
rule("NewLineAfterOpenBraceInBlockContext", 18 /* OpenBraceToken */, anyToken, [isMultilineBlockContext], 8 /* InsertNewLine */),
|
|
rule("SpaceAfterGetSetInMember", [137 /* GetKeyword */, 151 /* SetKeyword */], 79 /* Identifier */, [isFunctionDeclContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenYieldKeywordAndStar", 125 /* YieldKeyword */, 41 /* AsteriskToken */, [isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand], 16 /* DeleteSpace */),
|
|
rule("SpaceBetweenYieldOrYieldStarAndOperand", [125 /* YieldKeyword */, 41 /* AsteriskToken */], anyToken, [isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenReturnAndSemicolon", 105 /* ReturnKeyword */, 26 /* SemicolonToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterCertainKeywords", [113 /* VarKeyword */, 109 /* ThrowKeyword */, 103 /* NewKeyword */, 89 /* DeleteKeyword */, 105 /* ReturnKeyword */, 112 /* TypeOfKeyword */, 133 /* AwaitKeyword */], anyToken, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterLetConstInVariableDeclaration", [119 /* LetKeyword */, 85 /* ConstKeyword */], anyToken, [isNonJsxSameLineTokenContext, isStartOfVariableDeclarationList], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeOpenParenInFuncCall", anyToken, 20 /* OpenParenToken */, [isNonJsxSameLineTokenContext, isFunctionCallOrNewContext, isPreviousTokenNotComma], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeBinaryKeywordOperator", anyToken, binaryKeywordOperators, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterBinaryKeywordOperator", binaryKeywordOperators, anyToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterVoidOperator", 114 /* VoidKeyword */, anyToken, [isNonJsxSameLineTokenContext, isVoidOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenAsyncAndOpenParen", 132 /* AsyncKeyword */, 20 /* OpenParenToken */, [isArrowFunctionContext, isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenAsyncAndFunctionKeyword", 132 /* AsyncKeyword */, [98 /* FunctionKeyword */, 79 /* Identifier */], [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenTagAndTemplateString", [79 /* Identifier */, 21 /* CloseParenToken */], [14 /* NoSubstitutionTemplateLiteral */, 15 /* TemplateHead */], [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeJsxAttribute", anyToken, 79 /* Identifier */, [isNextTokenParentJsxAttribute, isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeSlashInJsxOpeningElement", anyToken, 43 /* SlashToken */, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeGreaterThanTokenInJsxOpeningElement", 43 /* SlashToken */, 31 /* GreaterThanToken */, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeEqualInJsxAttribute", anyToken, 63 /* EqualsToken */, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterEqualInJsxAttribute", 63 /* EqualsToken */, anyToken, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterModuleImport", [142 /* ModuleKeyword */, 147 /* RequireKeyword */], 20 /* OpenParenToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule(
|
|
"SpaceAfterCertainTypeScriptKeywords",
|
|
[
|
|
126 /* AbstractKeyword */,
|
|
127 /* AccessorKeyword */,
|
|
84 /* ClassKeyword */,
|
|
136 /* DeclareKeyword */,
|
|
88 /* DefaultKeyword */,
|
|
92 /* EnumKeyword */,
|
|
93 /* ExportKeyword */,
|
|
94 /* ExtendsKeyword */,
|
|
137 /* GetKeyword */,
|
|
117 /* ImplementsKeyword */,
|
|
100 /* ImportKeyword */,
|
|
118 /* InterfaceKeyword */,
|
|
142 /* ModuleKeyword */,
|
|
143 /* NamespaceKeyword */,
|
|
121 /* PrivateKeyword */,
|
|
123 /* PublicKeyword */,
|
|
122 /* ProtectedKeyword */,
|
|
146 /* ReadonlyKeyword */,
|
|
151 /* SetKeyword */,
|
|
124 /* StaticKeyword */,
|
|
154 /* TypeKeyword */,
|
|
158 /* FromKeyword */,
|
|
141 /* KeyOfKeyword */,
|
|
138 /* InferKeyword */
|
|
],
|
|
anyToken,
|
|
[isNonJsxSameLineTokenContext],
|
|
4 /* InsertSpace */
|
|
),
|
|
rule(
|
|
"SpaceBeforeCertainTypeScriptKeywords",
|
|
anyToken,
|
|
[94 /* ExtendsKeyword */, 117 /* ImplementsKeyword */, 158 /* FromKeyword */],
|
|
[isNonJsxSameLineTokenContext],
|
|
4 /* InsertSpace */
|
|
),
|
|
rule("SpaceAfterModuleName", 10 /* StringLiteral */, 18 /* OpenBraceToken */, [isModuleDeclContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeArrow", anyToken, 38 /* EqualsGreaterThanToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterArrow", 38 /* EqualsGreaterThanToken */, anyToken, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterEllipsis", 25 /* DotDotDotToken */, 79 /* Identifier */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterOptionalParameters", 57 /* QuestionToken */, [21 /* CloseParenToken */, 27 /* CommaToken */], [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBetweenEmptyInterfaceBraceBrackets", 18 /* OpenBraceToken */, 19 /* CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectTypeContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeOpenAngularBracket", typeNames, 29 /* LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBetweenCloseParenAndAngularBracket", 21 /* CloseParenToken */, 29 /* LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterOpenAngularBracket", 29 /* LessThanToken */, anyToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeCloseAngularBracket", anyToken, 31 /* GreaterThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* DeleteSpace */),
|
|
rule(
|
|
"NoSpaceAfterCloseAngularBracket",
|
|
31 /* GreaterThanToken */,
|
|
[20 /* OpenParenToken */, 22 /* OpenBracketToken */, 31 /* GreaterThanToken */, 27 /* CommaToken */],
|
|
[isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext, isNotFunctionDeclContext],
|
|
16 /* DeleteSpace */
|
|
),
|
|
rule("SpaceBeforeAt", [21 /* CloseParenToken */, 79 /* Identifier */], 59 /* AtToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterAt", 59 /* AtToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule(
|
|
"SpaceAfterDecorator",
|
|
anyToken,
|
|
[
|
|
126 /* AbstractKeyword */,
|
|
79 /* Identifier */,
|
|
93 /* ExportKeyword */,
|
|
88 /* DefaultKeyword */,
|
|
84 /* ClassKeyword */,
|
|
124 /* StaticKeyword */,
|
|
123 /* PublicKeyword */,
|
|
121 /* PrivateKeyword */,
|
|
122 /* ProtectedKeyword */,
|
|
137 /* GetKeyword */,
|
|
151 /* SetKeyword */,
|
|
22 /* OpenBracketToken */,
|
|
41 /* AsteriskToken */
|
|
],
|
|
[isEndOfDecoratorContextOnSameLine],
|
|
4 /* InsertSpace */
|
|
),
|
|
rule("NoSpaceBeforeNonNullAssertionOperator", anyToken, 53 /* ExclamationToken */, [isNonJsxSameLineTokenContext, isNonNullAssertionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterNewKeywordOnConstructorSignature", 103 /* NewKeyword */, 20 /* OpenParenToken */, [isNonJsxSameLineTokenContext, isConstructorSignatureContext], 16 /* DeleteSpace */),
|
|
rule("SpaceLessThanAndNonJSXTypeAnnotation", 29 /* LessThanToken */, 29 /* LessThanToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */)
|
|
];
|
|
const userConfigurableRules = [
|
|
rule("SpaceAfterConstructor", 135 /* ConstructorKeyword */, 20 /* OpenParenToken */, [isOptionEnabled("insertSpaceAfterConstructor"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterConstructor", 135 /* ConstructorKeyword */, 20 /* OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterConstructor"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterComma", 27 /* CommaToken */, anyToken, [isOptionEnabled("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNextTokenNotCloseBracket, isNextTokenNotCloseParen], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterComma", 27 /* CommaToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterAnonymousFunctionKeyword", [98 /* FunctionKeyword */, 41 /* AsteriskToken */], 20 /* OpenParenToken */, [isOptionEnabled("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), isFunctionDeclContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterAnonymousFunctionKeyword", [98 /* FunctionKeyword */, 41 /* AsteriskToken */], 20 /* OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), isFunctionDeclContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterKeywordInControl", keywords, 20 /* OpenParenToken */, [isOptionEnabled("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterKeywordInControl", keywords, 20 /* OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterOpenParen", 20 /* OpenParenToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeCloseParen", anyToken, 21 /* CloseParenToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenOpenParens", 20 /* OpenParenToken */, 20 /* OpenParenToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenParens", 20 /* OpenParenToken */, 21 /* CloseParenToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterOpenParen", 20 /* OpenParenToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeCloseParen", anyToken, 21 /* CloseParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterOpenBracket", 22 /* OpenBracketToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeCloseBracket", anyToken, 23 /* CloseBracketToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenBrackets", 22 /* OpenBracketToken */, 23 /* CloseBracketToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterOpenBracket", 22 /* OpenBracketToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeCloseBracket", anyToken, 23 /* CloseBracketToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterOpenBrace", 18 /* OpenBraceToken */, anyToken, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeCloseBrace", anyToken, 19 /* CloseBraceToken */, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* OpenBraceToken */, 19 /* CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterOpenBrace", 18 /* OpenBraceToken */, anyToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeCloseBrace", anyToken, 19 /* CloseBraceToken */, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBetweenEmptyBraceBrackets", 18 /* OpenBraceToken */, 19 /* CloseBraceToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces")], 4 /* InsertSpace */),
|
|
rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* OpenBraceToken */, 19 /* CloseBraceToken */, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterTemplateHeadAndMiddle", [15 /* TemplateHead */, 16 /* TemplateMiddle */], anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], 4 /* InsertSpace */, 1 /* CanDeleteNewLines */),
|
|
rule("SpaceBeforeTemplateMiddleAndTail", anyToken, [16 /* TemplateMiddle */, 17 /* TemplateTail */], [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterTemplateHeadAndMiddle", [15 /* TemplateHead */, 16 /* TemplateMiddle */], anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], 16 /* DeleteSpace */, 1 /* CanDeleteNewLines */),
|
|
rule("NoSpaceBeforeTemplateMiddleAndTail", anyToken, [16 /* TemplateMiddle */, 17 /* TemplateTail */], [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterOpenBraceInJsxExpression", 18 /* OpenBraceToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* InsertSpace */),
|
|
rule("SpaceBeforeCloseBraceInJsxExpression", anyToken, 19 /* CloseBraceToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterOpenBraceInJsxExpression", 18 /* OpenBraceToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeCloseBraceInJsxExpression", anyToken, 19 /* CloseBraceToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterSemicolonInFor", 26 /* SemicolonToken */, anyToken, [isOptionEnabled("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterSemicolonInFor", 26 /* SemicolonToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("SpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeOpenParenInFuncDecl", anyToken, 20 /* OpenParenToken */, [isOptionEnabled("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeOpenParenInFuncDecl", anyToken, 20 /* OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 16 /* DeleteSpace */),
|
|
rule("NewLineBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isBeforeMultilineBlockContext], 8 /* InsertNewLine */, 1 /* CanDeleteNewLines */),
|
|
rule("NewLineBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeMultilineBlockContext], 8 /* InsertNewLine */, 1 /* CanDeleteNewLines */),
|
|
rule("NewLineBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isBeforeMultilineBlockContext], 8 /* InsertNewLine */, 1 /* CanDeleteNewLines */),
|
|
rule("SpaceAfterTypeAssertion", 31 /* GreaterThanToken */, anyToken, [isOptionEnabled("insertSpaceAfterTypeAssertion"), isNonJsxSameLineTokenContext, isTypeAssertionContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceAfterTypeAssertion", 31 /* GreaterThanToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterTypeAssertion"), isNonJsxSameLineTokenContext, isTypeAssertionContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeTypeAnnotation", anyToken, [57 /* QuestionToken */, 58 /* ColonToken */], [isOptionEnabled("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 4 /* InsertSpace */),
|
|
rule("NoSpaceBeforeTypeAnnotation", anyToken, [57 /* QuestionToken */, 58 /* ColonToken */], [isOptionDisabledOrUndefined("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 16 /* DeleteSpace */),
|
|
rule("NoOptionalSemicolon", 26 /* SemicolonToken */, anyTokenIncludingEOF, [optionEquals("semicolons", "remove" /* Remove */), isSemicolonDeletionContext], 32 /* DeleteToken */),
|
|
rule("OptionalSemicolon", anyToken, anyTokenIncludingEOF, [optionEquals("semicolons", "insert" /* Insert */), isSemicolonInsertionContext], 64 /* InsertTrailingSemicolon */)
|
|
];
|
|
const lowPriorityCommonRules = [
|
|
rule("NoSpaceBeforeSemicolon", anyToken, 26 /* SemicolonToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("SpaceBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* InsertSpace */, 1 /* CanDeleteNewLines */),
|
|
rule("SpaceBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* InsertSpace */, 1 /* CanDeleteNewLines */),
|
|
rule("SpaceBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, 18 /* OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* InsertSpace */, 1 /* CanDeleteNewLines */),
|
|
rule("NoSpaceBeforeComma", anyToken, 27 /* CommaToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceBeforeOpenBracket", anyTokenExcept(132 /* AsyncKeyword */, 82 /* CaseKeyword */), 22 /* OpenBracketToken */, [isNonJsxSameLineTokenContext], 16 /* DeleteSpace */),
|
|
rule("NoSpaceAfterCloseBracket", 23 /* CloseBracketToken */, anyToken, [isNonJsxSameLineTokenContext, isNotBeforeBlockInFunctionDeclarationContext], 16 /* DeleteSpace */),
|
|
rule("SpaceAfterSemicolon", 26 /* SemicolonToken */, anyToken, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule("SpaceBetweenForAndAwaitKeyword", 97 /* ForKeyword */, 133 /* AwaitKeyword */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */),
|
|
rule(
|
|
"SpaceBetweenStatements",
|
|
[21 /* CloseParenToken */, 90 /* DoKeyword */, 91 /* ElseKeyword */, 82 /* CaseKeyword */],
|
|
anyToken,
|
|
[isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNotForContext],
|
|
4 /* InsertSpace */
|
|
),
|
|
rule("SpaceAfterTryCatchFinally", [111 /* TryKeyword */, 83 /* CatchKeyword */, 96 /* FinallyKeyword */], 18 /* OpenBraceToken */, [isNonJsxSameLineTokenContext], 4 /* InsertSpace */)
|
|
];
|
|
return [
|
|
...highPriorityCommonRules,
|
|
...userConfigurableRules,
|
|
...lowPriorityCommonRules
|
|
];
|
|
}
|
|
function rule(debugName, left, right, context, action, flags = 0 /* None */) {
|
|
return { leftTokenRange: toTokenRange(left), rightTokenRange: toTokenRange(right), rule: { debugName, context, action, flags } };
|
|
}
|
|
function tokenRangeFrom(tokens) {
|
|
return { tokens, isSpecific: true };
|
|
}
|
|
function toTokenRange(arg) {
|
|
return typeof arg === "number" ? tokenRangeFrom([arg]) : isArray(arg) ? tokenRangeFrom(arg) : arg;
|
|
}
|
|
function tokenRangeFromRange(from, to, except = []) {
|
|
const tokens = [];
|
|
for (let token = from; token <= to; token++) {
|
|
if (!contains(except, token)) {
|
|
tokens.push(token);
|
|
}
|
|
}
|
|
return tokenRangeFrom(tokens);
|
|
}
|
|
function optionEquals(optionName, optionValue) {
|
|
return (context) => context.options && context.options[optionName] === optionValue;
|
|
}
|
|
function isOptionEnabled(optionName) {
|
|
return (context) => context.options && hasProperty(context.options, optionName) && !!context.options[optionName];
|
|
}
|
|
function isOptionDisabled(optionName) {
|
|
return (context) => context.options && hasProperty(context.options, optionName) && !context.options[optionName];
|
|
}
|
|
function isOptionDisabledOrUndefined(optionName) {
|
|
return (context) => !context.options || !hasProperty(context.options, optionName) || !context.options[optionName];
|
|
}
|
|
function isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName) {
|
|
return (context) => !context.options || !hasProperty(context.options, optionName) || !context.options[optionName] || context.TokensAreOnSameLine();
|
|
}
|
|
function isOptionEnabledOrUndefined(optionName) {
|
|
return (context) => !context.options || !hasProperty(context.options, optionName) || !!context.options[optionName];
|
|
}
|
|
function isForContext(context) {
|
|
return context.contextNode.kind === 245 /* ForStatement */;
|
|
}
|
|
function isNotForContext(context) {
|
|
return !isForContext(context);
|
|
}
|
|
function isBinaryOpContext(context) {
|
|
switch (context.contextNode.kind) {
|
|
case 223 /* BinaryExpression */:
|
|
return context.contextNode.operatorToken.kind !== 27 /* CommaToken */;
|
|
case 224 /* ConditionalExpression */:
|
|
case 191 /* ConditionalType */:
|
|
case 231 /* AsExpression */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 179 /* TypePredicate */:
|
|
case 189 /* UnionType */:
|
|
case 190 /* IntersectionType */:
|
|
case 235 /* SatisfiesExpression */:
|
|
return true;
|
|
case 205 /* BindingElement */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 268 /* ImportEqualsDeclaration */:
|
|
case 274 /* ExportAssignment */:
|
|
case 257 /* VariableDeclaration */:
|
|
case 166 /* Parameter */:
|
|
case 302 /* EnumMember */:
|
|
case 169 /* PropertyDeclaration */:
|
|
case 168 /* PropertySignature */:
|
|
return context.currentTokenSpan.kind === 63 /* EqualsToken */ || context.nextTokenSpan.kind === 63 /* EqualsToken */;
|
|
case 246 /* ForInStatement */:
|
|
case 165 /* TypeParameter */:
|
|
return context.currentTokenSpan.kind === 101 /* InKeyword */ || context.nextTokenSpan.kind === 101 /* InKeyword */ || context.currentTokenSpan.kind === 63 /* EqualsToken */ || context.nextTokenSpan.kind === 63 /* EqualsToken */;
|
|
case 247 /* ForOfStatement */:
|
|
return context.currentTokenSpan.kind === 162 /* OfKeyword */ || context.nextTokenSpan.kind === 162 /* OfKeyword */;
|
|
}
|
|
return false;
|
|
}
|
|
function isNotBinaryOpContext(context) {
|
|
return !isBinaryOpContext(context);
|
|
}
|
|
function isNotTypeAnnotationContext(context) {
|
|
return !isTypeAnnotationContext(context);
|
|
}
|
|
function isTypeAnnotationContext(context) {
|
|
const contextKind = context.contextNode.kind;
|
|
return contextKind === 169 /* PropertyDeclaration */ || contextKind === 168 /* PropertySignature */ || contextKind === 166 /* Parameter */ || contextKind === 257 /* VariableDeclaration */ || isFunctionLikeKind(contextKind);
|
|
}
|
|
function isConditionalOperatorContext(context) {
|
|
return context.contextNode.kind === 224 /* ConditionalExpression */ || context.contextNode.kind === 191 /* ConditionalType */;
|
|
}
|
|
function isSameLineTokenOrBeforeBlockContext(context) {
|
|
return context.TokensAreOnSameLine() || isBeforeBlockContext(context);
|
|
}
|
|
function isBraceWrappedContext(context) {
|
|
return context.contextNode.kind === 203 /* ObjectBindingPattern */ || context.contextNode.kind === 197 /* MappedType */ || isSingleLineBlockContext(context);
|
|
}
|
|
function isBeforeMultilineBlockContext(context) {
|
|
return isBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine());
|
|
}
|
|
function isMultilineBlockContext(context) {
|
|
return isBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
|
|
}
|
|
function isSingleLineBlockContext(context) {
|
|
return isBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine());
|
|
}
|
|
function isBlockContext(context) {
|
|
return nodeIsBlockContext(context.contextNode);
|
|
}
|
|
function isBeforeBlockContext(context) {
|
|
return nodeIsBlockContext(context.nextTokenParent);
|
|
}
|
|
function nodeIsBlockContext(node) {
|
|
if (nodeIsTypeScriptDeclWithBlockContext(node)) {
|
|
return true;
|
|
}
|
|
switch (node.kind) {
|
|
case 238 /* Block */:
|
|
case 266 /* CaseBlock */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 265 /* ModuleBlock */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isFunctionDeclContext(context) {
|
|
switch (context.contextNode.kind) {
|
|
case 259 /* FunctionDeclaration */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
case 176 /* CallSignature */:
|
|
case 215 /* FunctionExpression */:
|
|
case 173 /* Constructor */:
|
|
case 216 /* ArrowFunction */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isNotFunctionDeclContext(context) {
|
|
return !isFunctionDeclContext(context);
|
|
}
|
|
function isFunctionDeclarationOrFunctionExpressionContext(context) {
|
|
return context.contextNode.kind === 259 /* FunctionDeclaration */ || context.contextNode.kind === 215 /* FunctionExpression */;
|
|
}
|
|
function isTypeScriptDeclWithBlockContext(context) {
|
|
return nodeIsTypeScriptDeclWithBlockContext(context.contextNode);
|
|
}
|
|
function nodeIsTypeScriptDeclWithBlockContext(node) {
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 184 /* TypeLiteral */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 275 /* ExportDeclaration */:
|
|
case 276 /* NamedExports */:
|
|
case 269 /* ImportDeclaration */:
|
|
case 272 /* NamedImports */:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function isAfterCodeBlockContext(context) {
|
|
switch (context.currentTokenParent.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 264 /* ModuleDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 295 /* CatchClause */:
|
|
case 265 /* ModuleBlock */:
|
|
case 252 /* SwitchStatement */:
|
|
return true;
|
|
case 238 /* Block */: {
|
|
const blockParent = context.currentTokenParent.parent;
|
|
if (!blockParent || blockParent.kind !== 216 /* ArrowFunction */ && blockParent.kind !== 215 /* FunctionExpression */) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
function isControlDeclContext(context) {
|
|
switch (context.contextNode.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 252 /* SwitchStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 255 /* TryStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 251 /* WithStatement */:
|
|
case 295 /* CatchClause */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isObjectContext(context) {
|
|
return context.contextNode.kind === 207 /* ObjectLiteralExpression */;
|
|
}
|
|
function isFunctionCallContext(context) {
|
|
return context.contextNode.kind === 210 /* CallExpression */;
|
|
}
|
|
function isNewContext(context) {
|
|
return context.contextNode.kind === 211 /* NewExpression */;
|
|
}
|
|
function isFunctionCallOrNewContext(context) {
|
|
return isFunctionCallContext(context) || isNewContext(context);
|
|
}
|
|
function isPreviousTokenNotComma(context) {
|
|
return context.currentTokenSpan.kind !== 27 /* CommaToken */;
|
|
}
|
|
function isNextTokenNotCloseBracket(context) {
|
|
return context.nextTokenSpan.kind !== 23 /* CloseBracketToken */;
|
|
}
|
|
function isNextTokenNotCloseParen(context) {
|
|
return context.nextTokenSpan.kind !== 21 /* CloseParenToken */;
|
|
}
|
|
function isArrowFunctionContext(context) {
|
|
return context.contextNode.kind === 216 /* ArrowFunction */;
|
|
}
|
|
function isImportTypeContext(context) {
|
|
return context.contextNode.kind === 202 /* ImportType */;
|
|
}
|
|
function isNonJsxSameLineTokenContext(context) {
|
|
return context.TokensAreOnSameLine() && context.contextNode.kind !== 11 /* JsxText */;
|
|
}
|
|
function isNonJsxTextContext(context) {
|
|
return context.contextNode.kind !== 11 /* JsxText */;
|
|
}
|
|
function isNonJsxElementOrFragmentContext(context) {
|
|
return context.contextNode.kind !== 281 /* JsxElement */ && context.contextNode.kind !== 285 /* JsxFragment */;
|
|
}
|
|
function isJsxExpressionContext(context) {
|
|
return context.contextNode.kind === 291 /* JsxExpression */ || context.contextNode.kind === 290 /* JsxSpreadAttribute */;
|
|
}
|
|
function isNextTokenParentJsxAttribute(context) {
|
|
return context.nextTokenParent.kind === 288 /* JsxAttribute */;
|
|
}
|
|
function isJsxAttributeContext(context) {
|
|
return context.contextNode.kind === 288 /* JsxAttribute */;
|
|
}
|
|
function isJsxSelfClosingElementContext(context) {
|
|
return context.contextNode.kind === 282 /* JsxSelfClosingElement */;
|
|
}
|
|
function isNotBeforeBlockInFunctionDeclarationContext(context) {
|
|
return !isFunctionDeclContext(context) && !isBeforeBlockContext(context);
|
|
}
|
|
function isEndOfDecoratorContextOnSameLine(context) {
|
|
return context.TokensAreOnSameLine() && hasDecorators(context.contextNode) && nodeIsInDecoratorContext(context.currentTokenParent) && !nodeIsInDecoratorContext(context.nextTokenParent);
|
|
}
|
|
function nodeIsInDecoratorContext(node) {
|
|
while (node && isExpression(node)) {
|
|
node = node.parent;
|
|
}
|
|
return node && node.kind === 167 /* Decorator */;
|
|
}
|
|
function isStartOfVariableDeclarationList(context) {
|
|
return context.currentTokenParent.kind === 258 /* VariableDeclarationList */ && context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos;
|
|
}
|
|
function isNotFormatOnEnter(context) {
|
|
return context.formattingRequestKind !== 2 /* FormatOnEnter */;
|
|
}
|
|
function isModuleDeclContext(context) {
|
|
return context.contextNode.kind === 264 /* ModuleDeclaration */;
|
|
}
|
|
function isObjectTypeContext(context) {
|
|
return context.contextNode.kind === 184 /* TypeLiteral */;
|
|
}
|
|
function isConstructorSignatureContext(context) {
|
|
return context.contextNode.kind === 177 /* ConstructSignature */;
|
|
}
|
|
function isTypeArgumentOrParameterOrAssertion(token, parent2) {
|
|
if (token.kind !== 29 /* LessThanToken */ && token.kind !== 31 /* GreaterThanToken */) {
|
|
return false;
|
|
}
|
|
switch (parent2.kind) {
|
|
case 180 /* TypeReference */:
|
|
case 213 /* TypeAssertionExpression */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isTypeArgumentOrParameterOrAssertionContext(context) {
|
|
return isTypeArgumentOrParameterOrAssertion(context.currentTokenSpan, context.currentTokenParent) || isTypeArgumentOrParameterOrAssertion(context.nextTokenSpan, context.nextTokenParent);
|
|
}
|
|
function isTypeAssertionContext(context) {
|
|
return context.contextNode.kind === 213 /* TypeAssertionExpression */;
|
|
}
|
|
function isVoidOpContext(context) {
|
|
return context.currentTokenSpan.kind === 114 /* VoidKeyword */ && context.currentTokenParent.kind === 219 /* VoidExpression */;
|
|
}
|
|
function isYieldOrYieldStarWithOperand(context) {
|
|
return context.contextNode.kind === 226 /* YieldExpression */ && context.contextNode.expression !== void 0;
|
|
}
|
|
function isNonNullAssertionContext(context) {
|
|
return context.contextNode.kind === 232 /* NonNullExpression */;
|
|
}
|
|
function isNotStatementConditionContext(context) {
|
|
return !isStatementConditionContext(context);
|
|
}
|
|
function isStatementConditionContext(context) {
|
|
switch (context.contextNode.kind) {
|
|
case 242 /* IfStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function isSemicolonDeletionContext(context) {
|
|
let nextTokenKind = context.nextTokenSpan.kind;
|
|
let nextTokenStart = context.nextTokenSpan.pos;
|
|
if (isTrivia(nextTokenKind)) {
|
|
const nextRealToken = context.nextTokenParent === context.currentTokenParent ? findNextToken(
|
|
context.currentTokenParent,
|
|
findAncestor(context.currentTokenParent, (a) => !a.parent),
|
|
context.sourceFile
|
|
) : context.nextTokenParent.getFirstToken(context.sourceFile);
|
|
if (!nextRealToken) {
|
|
return true;
|
|
}
|
|
nextTokenKind = nextRealToken.kind;
|
|
nextTokenStart = nextRealToken.getStart(context.sourceFile);
|
|
}
|
|
const startLine = context.sourceFile.getLineAndCharacterOfPosition(context.currentTokenSpan.pos).line;
|
|
const endLine = context.sourceFile.getLineAndCharacterOfPosition(nextTokenStart).line;
|
|
if (startLine === endLine) {
|
|
return nextTokenKind === 19 /* CloseBraceToken */ || nextTokenKind === 1 /* EndOfFileToken */;
|
|
}
|
|
if (nextTokenKind === 237 /* SemicolonClassElement */ || nextTokenKind === 26 /* SemicolonToken */) {
|
|
return false;
|
|
}
|
|
if (context.contextNode.kind === 261 /* InterfaceDeclaration */ || context.contextNode.kind === 262 /* TypeAliasDeclaration */) {
|
|
return !isPropertySignature(context.currentTokenParent) || !!context.currentTokenParent.type || nextTokenKind !== 20 /* OpenParenToken */;
|
|
}
|
|
if (isPropertyDeclaration(context.currentTokenParent)) {
|
|
return !context.currentTokenParent.initializer;
|
|
}
|
|
return context.currentTokenParent.kind !== 245 /* ForStatement */ && context.currentTokenParent.kind !== 239 /* EmptyStatement */ && context.currentTokenParent.kind !== 237 /* SemicolonClassElement */ && nextTokenKind !== 22 /* OpenBracketToken */ && nextTokenKind !== 20 /* OpenParenToken */ && nextTokenKind !== 39 /* PlusToken */ && nextTokenKind !== 40 /* MinusToken */ && nextTokenKind !== 43 /* SlashToken */ && nextTokenKind !== 13 /* RegularExpressionLiteral */ && nextTokenKind !== 27 /* CommaToken */ && nextTokenKind !== 225 /* TemplateExpression */ && nextTokenKind !== 15 /* TemplateHead */ && nextTokenKind !== 14 /* NoSubstitutionTemplateLiteral */ && nextTokenKind !== 24 /* DotToken */;
|
|
}
|
|
function isSemicolonInsertionContext(context) {
|
|
return positionIsASICandidate(context.currentTokenSpan.end, context.currentTokenParent, context.sourceFile);
|
|
}
|
|
function isNotPropertyAccessOnIntegerLiteral(context) {
|
|
return !isPropertyAccessExpression(context.contextNode) || !isNumericLiteral(context.contextNode.expression) || context.contextNode.expression.getText().indexOf(".") !== -1;
|
|
}
|
|
|
|
// src/services/formatting/rulesMap.ts
|
|
function getFormatContext(options, host) {
|
|
return { options, getRules: getRulesMap(), host };
|
|
}
|
|
var rulesMapCache;
|
|
function getRulesMap() {
|
|
if (rulesMapCache === void 0) {
|
|
rulesMapCache = createRulesMap(getAllRules());
|
|
}
|
|
return rulesMapCache;
|
|
}
|
|
function getRuleActionExclusion(ruleAction) {
|
|
let mask2 = 0 /* None */;
|
|
if (ruleAction & 1 /* StopProcessingSpaceActions */) {
|
|
mask2 |= 28 /* ModifySpaceAction */;
|
|
}
|
|
if (ruleAction & 2 /* StopProcessingTokenActions */) {
|
|
mask2 |= 96 /* ModifyTokenAction */;
|
|
}
|
|
if (ruleAction & 28 /* ModifySpaceAction */) {
|
|
mask2 |= 28 /* ModifySpaceAction */;
|
|
}
|
|
if (ruleAction & 96 /* ModifyTokenAction */) {
|
|
mask2 |= 96 /* ModifyTokenAction */;
|
|
}
|
|
return mask2;
|
|
}
|
|
function createRulesMap(rules) {
|
|
const map2 = buildMap(rules);
|
|
return (context) => {
|
|
const bucket = map2[getRuleBucketIndex(context.currentTokenSpan.kind, context.nextTokenSpan.kind)];
|
|
if (bucket) {
|
|
const rules2 = [];
|
|
let ruleActionMask = 0;
|
|
for (const rule2 of bucket) {
|
|
const acceptRuleActions = ~getRuleActionExclusion(ruleActionMask);
|
|
if (rule2.action & acceptRuleActions && every(rule2.context, (c) => c(context))) {
|
|
rules2.push(rule2);
|
|
ruleActionMask |= rule2.action;
|
|
}
|
|
}
|
|
if (rules2.length) {
|
|
return rules2;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function buildMap(rules) {
|
|
const map2 = new Array(mapRowLength * mapRowLength);
|
|
const rulesBucketConstructionStateList = new Array(map2.length);
|
|
for (const rule2 of rules) {
|
|
const specificRule = rule2.leftTokenRange.isSpecific && rule2.rightTokenRange.isSpecific;
|
|
for (const left of rule2.leftTokenRange.tokens) {
|
|
for (const right of rule2.rightTokenRange.tokens) {
|
|
const index = getRuleBucketIndex(left, right);
|
|
let rulesBucket = map2[index];
|
|
if (rulesBucket === void 0) {
|
|
rulesBucket = map2[index] = [];
|
|
}
|
|
addRule(rulesBucket, rule2.rule, specificRule, rulesBucketConstructionStateList, index);
|
|
}
|
|
}
|
|
}
|
|
return map2;
|
|
}
|
|
function getRuleBucketIndex(row, column) {
|
|
Debug.assert(row <= 162 /* LastKeyword */ && column <= 162 /* LastKeyword */, "Must compute formatting context from tokens");
|
|
return row * mapRowLength + column;
|
|
}
|
|
var maskBitSize = 5;
|
|
var mask = 31;
|
|
var mapRowLength = 162 /* LastToken */ + 1;
|
|
var RulesPosition = ((RulesPosition2) => {
|
|
RulesPosition2[RulesPosition2["StopRulesSpecific"] = 0] = "StopRulesSpecific";
|
|
RulesPosition2[RulesPosition2["StopRulesAny"] = maskBitSize * 1] = "StopRulesAny";
|
|
RulesPosition2[RulesPosition2["ContextRulesSpecific"] = maskBitSize * 2] = "ContextRulesSpecific";
|
|
RulesPosition2[RulesPosition2["ContextRulesAny"] = maskBitSize * 3] = "ContextRulesAny";
|
|
RulesPosition2[RulesPosition2["NoContextRulesSpecific"] = maskBitSize * 4] = "NoContextRulesSpecific";
|
|
RulesPosition2[RulesPosition2["NoContextRulesAny"] = maskBitSize * 5] = "NoContextRulesAny";
|
|
return RulesPosition2;
|
|
})(RulesPosition || {});
|
|
function addRule(rules, rule2, specificTokens, constructionState, rulesBucketIndex) {
|
|
const position = rule2.action & 3 /* StopAction */ ? specificTokens ? 0 /* StopRulesSpecific */ : RulesPosition.StopRulesAny : rule2.context !== anyContext ? specificTokens ? RulesPosition.ContextRulesSpecific : RulesPosition.ContextRulesAny : specificTokens ? RulesPosition.NoContextRulesSpecific : RulesPosition.NoContextRulesAny;
|
|
const state = constructionState[rulesBucketIndex] || 0;
|
|
rules.splice(getInsertionIndex(state, position), 0, rule2);
|
|
constructionState[rulesBucketIndex] = increaseInsertionIndex(state, position);
|
|
}
|
|
function getInsertionIndex(indexBitmap, maskPosition) {
|
|
let index = 0;
|
|
for (let pos = 0; pos <= maskPosition; pos += maskBitSize) {
|
|
index += indexBitmap & mask;
|
|
indexBitmap >>= maskBitSize;
|
|
}
|
|
return index;
|
|
}
|
|
function increaseInsertionIndex(indexBitmap, maskPosition) {
|
|
const value = (indexBitmap >> maskPosition & mask) + 1;
|
|
Debug.assert((value & mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules.");
|
|
return indexBitmap & ~(mask << maskPosition) | value << maskPosition;
|
|
}
|
|
|
|
// src/services/formatting/formatting.ts
|
|
function createTextRangeWithKind(pos, end, kind) {
|
|
const textRangeWithKind = { pos, end, kind };
|
|
if (Debug.isDebugging) {
|
|
Object.defineProperty(textRangeWithKind, "__debugKind", {
|
|
get: () => Debug.formatSyntaxKind(kind)
|
|
});
|
|
}
|
|
return textRangeWithKind;
|
|
}
|
|
function formatOnEnter(position, sourceFile, formatContext) {
|
|
const line = sourceFile.getLineAndCharacterOfPosition(position).line;
|
|
if (line === 0) {
|
|
return [];
|
|
}
|
|
let endOfFormatSpan = getEndLinePosition(line, sourceFile);
|
|
while (isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(endOfFormatSpan))) {
|
|
endOfFormatSpan--;
|
|
}
|
|
if (isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) {
|
|
endOfFormatSpan--;
|
|
}
|
|
const span = {
|
|
pos: getStartPositionOfLine(line - 1, sourceFile),
|
|
end: endOfFormatSpan + 1
|
|
};
|
|
return formatSpan(span, sourceFile, formatContext, 2 /* FormatOnEnter */);
|
|
}
|
|
function formatOnSemicolon(position, sourceFile, formatContext) {
|
|
const semicolon = findImmediatelyPrecedingTokenOfKind(position, 26 /* SemicolonToken */, sourceFile);
|
|
return formatNodeLines(findOutermostNodeWithinListLevel(semicolon), sourceFile, formatContext, 3 /* FormatOnSemicolon */);
|
|
}
|
|
function formatOnOpeningCurly(position, sourceFile, formatContext) {
|
|
const openingCurly = findImmediatelyPrecedingTokenOfKind(position, 18 /* OpenBraceToken */, sourceFile);
|
|
if (!openingCurly) {
|
|
return [];
|
|
}
|
|
const curlyBraceRange = openingCurly.parent;
|
|
const outermostNode = findOutermostNodeWithinListLevel(curlyBraceRange);
|
|
const textRange = {
|
|
pos: getLineStartPositionForPosition(outermostNode.getStart(sourceFile), sourceFile),
|
|
end: position
|
|
};
|
|
return formatSpan(textRange, sourceFile, formatContext, 4 /* FormatOnOpeningCurlyBrace */);
|
|
}
|
|
function formatOnClosingCurly(position, sourceFile, formatContext) {
|
|
const precedingToken = findImmediatelyPrecedingTokenOfKind(position, 19 /* CloseBraceToken */, sourceFile);
|
|
return formatNodeLines(findOutermostNodeWithinListLevel(precedingToken), sourceFile, formatContext, 5 /* FormatOnClosingCurlyBrace */);
|
|
}
|
|
function formatDocument(sourceFile, formatContext) {
|
|
const span = {
|
|
pos: 0,
|
|
end: sourceFile.text.length
|
|
};
|
|
return formatSpan(span, sourceFile, formatContext, 0 /* FormatDocument */);
|
|
}
|
|
function formatSelection(start2, end, sourceFile, formatContext) {
|
|
const span = {
|
|
pos: getLineStartPositionForPosition(start2, sourceFile),
|
|
end
|
|
};
|
|
return formatSpan(span, sourceFile, formatContext, 1 /* FormatSelection */);
|
|
}
|
|
function findImmediatelyPrecedingTokenOfKind(end, expectedTokenKind, sourceFile) {
|
|
const precedingToken = findPrecedingToken(end, sourceFile);
|
|
return precedingToken && precedingToken.kind === expectedTokenKind && end === precedingToken.getEnd() ? precedingToken : void 0;
|
|
}
|
|
function findOutermostNodeWithinListLevel(node) {
|
|
let current = node;
|
|
while (current && current.parent && current.parent.end === node.end && !isListElement(current.parent, current)) {
|
|
current = current.parent;
|
|
}
|
|
return current;
|
|
}
|
|
function isListElement(parent2, node) {
|
|
switch (parent2.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
return rangeContainsRange(parent2.members, node);
|
|
case 264 /* ModuleDeclaration */:
|
|
const body = parent2.body;
|
|
return !!body && body.kind === 265 /* ModuleBlock */ && rangeContainsRange(body.statements, node);
|
|
case 308 /* SourceFile */:
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
return rangeContainsRange(parent2.statements, node);
|
|
case 295 /* CatchClause */:
|
|
return rangeContainsRange(parent2.block.statements, node);
|
|
}
|
|
return false;
|
|
}
|
|
function findEnclosingNode(range, sourceFile) {
|
|
return find2(sourceFile);
|
|
function find2(n) {
|
|
const candidate = forEachChild(n, (c) => startEndContainsRange(c.getStart(sourceFile), c.end, range) && c);
|
|
if (candidate) {
|
|
const result = find2(candidate);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
return n;
|
|
}
|
|
}
|
|
function prepareRangeContainsErrorFunction(errors, originalRange) {
|
|
if (!errors.length) {
|
|
return rangeHasNoErrors;
|
|
}
|
|
const sorted = errors.filter((d) => rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length)).sort((e1, e2) => e1.start - e2.start);
|
|
if (!sorted.length) {
|
|
return rangeHasNoErrors;
|
|
}
|
|
let index = 0;
|
|
return (r) => {
|
|
while (true) {
|
|
if (index >= sorted.length) {
|
|
return false;
|
|
}
|
|
const error = sorted[index];
|
|
if (r.end <= error.start) {
|
|
return false;
|
|
}
|
|
if (startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) {
|
|
return true;
|
|
}
|
|
index++;
|
|
}
|
|
};
|
|
function rangeHasNoErrors() {
|
|
return false;
|
|
}
|
|
}
|
|
function getScanStartPosition(enclosingNode, originalRange, sourceFile) {
|
|
const start2 = enclosingNode.getStart(sourceFile);
|
|
if (start2 === originalRange.pos && enclosingNode.end === originalRange.end) {
|
|
return start2;
|
|
}
|
|
const precedingToken = findPrecedingToken(originalRange.pos, sourceFile);
|
|
if (!precedingToken) {
|
|
return enclosingNode.pos;
|
|
}
|
|
if (precedingToken.end >= originalRange.pos) {
|
|
return enclosingNode.pos;
|
|
}
|
|
return precedingToken.end;
|
|
}
|
|
function getOwnOrInheritedDelta(n, options, sourceFile) {
|
|
let previousLine = -1 /* Unknown */;
|
|
let child;
|
|
while (n) {
|
|
const line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line;
|
|
if (previousLine !== -1 /* Unknown */ && line !== previousLine) {
|
|
break;
|
|
}
|
|
if (SmartIndenter.shouldIndentChildNode(options, n, child, sourceFile)) {
|
|
return options.indentSize;
|
|
}
|
|
previousLine = line;
|
|
child = n;
|
|
n = n.parent;
|
|
}
|
|
return 0;
|
|
}
|
|
function formatNodeGivenIndentation(node, sourceFileLike, languageVariant, initialIndentation, delta, formatContext) {
|
|
const range = { pos: node.pos, end: node.end };
|
|
return getFormattingScanner(sourceFileLike.text, languageVariant, range.pos, range.end, (scanner2) => formatSpanWorker(
|
|
range,
|
|
node,
|
|
initialIndentation,
|
|
delta,
|
|
scanner2,
|
|
formatContext,
|
|
1 /* FormatSelection */,
|
|
(_) => false,
|
|
sourceFileLike
|
|
));
|
|
}
|
|
function formatNodeLines(node, sourceFile, formatContext, requestKind) {
|
|
if (!node) {
|
|
return [];
|
|
}
|
|
const span = {
|
|
pos: getLineStartPositionForPosition(node.getStart(sourceFile), sourceFile),
|
|
end: node.end
|
|
};
|
|
return formatSpan(span, sourceFile, formatContext, requestKind);
|
|
}
|
|
function formatSpan(originalRange, sourceFile, formatContext, requestKind) {
|
|
const enclosingNode = findEnclosingNode(originalRange, sourceFile);
|
|
return getFormattingScanner(
|
|
sourceFile.text,
|
|
sourceFile.languageVariant,
|
|
getScanStartPosition(enclosingNode, originalRange, sourceFile),
|
|
originalRange.end,
|
|
(scanner2) => formatSpanWorker(
|
|
originalRange,
|
|
enclosingNode,
|
|
SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, formatContext.options),
|
|
getOwnOrInheritedDelta(enclosingNode, formatContext.options, sourceFile),
|
|
scanner2,
|
|
formatContext,
|
|
requestKind,
|
|
prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange),
|
|
sourceFile
|
|
)
|
|
);
|
|
}
|
|
function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delta, formattingScanner, { options, getRules, host }, requestKind, rangeContainsError, sourceFile) {
|
|
var _a2;
|
|
const formattingContext = new FormattingContext(sourceFile, requestKind, options);
|
|
let previousRangeTriviaEnd;
|
|
let previousRange;
|
|
let previousParent;
|
|
let previousRangeStartLine;
|
|
let lastIndentedLine;
|
|
let indentationOnLastIndentedLine = -1 /* Unknown */;
|
|
const edits = [];
|
|
formattingScanner.advance();
|
|
if (formattingScanner.isOnToken()) {
|
|
const startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line;
|
|
let undecoratedStartLine = startLine;
|
|
if (hasDecorators(enclosingNode)) {
|
|
undecoratedStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(enclosingNode, sourceFile)).line;
|
|
}
|
|
processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta);
|
|
}
|
|
if (!formattingScanner.isOnToken()) {
|
|
const indentation = SmartIndenter.nodeWillIndentChild(options, enclosingNode, void 0, sourceFile, false) ? initialIndentation + options.indentSize : initialIndentation;
|
|
const leadingTrivia = formattingScanner.getCurrentLeadingTrivia();
|
|
if (leadingTrivia) {
|
|
indentTriviaItems(
|
|
leadingTrivia,
|
|
indentation,
|
|
false,
|
|
(item) => processRange(item, sourceFile.getLineAndCharacterOfPosition(item.pos), enclosingNode, enclosingNode, void 0)
|
|
);
|
|
if (options.trimTrailingWhitespace !== false) {
|
|
trimTrailingWhitespacesForRemainingRange(leadingTrivia);
|
|
}
|
|
}
|
|
}
|
|
if (previousRange && formattingScanner.getStartPos() >= originalRange.end) {
|
|
const tokenInfo = formattingScanner.isOnEOF() ? formattingScanner.readEOFTokenRange() : formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(enclosingNode).token : void 0;
|
|
if (tokenInfo && tokenInfo.pos === previousRangeTriviaEnd) {
|
|
const parent2 = ((_a2 = findPrecedingToken(tokenInfo.end, sourceFile, enclosingNode)) == null ? void 0 : _a2.parent) || previousParent;
|
|
processPair(
|
|
tokenInfo,
|
|
sourceFile.getLineAndCharacterOfPosition(tokenInfo.pos).line,
|
|
parent2,
|
|
previousRange,
|
|
previousRangeStartLine,
|
|
previousParent,
|
|
parent2,
|
|
void 0
|
|
);
|
|
}
|
|
}
|
|
return edits;
|
|
function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) {
|
|
if (rangeOverlapsWithStartEnd(range, startPos, endPos) || rangeContainsStartEnd(range, startPos, endPos)) {
|
|
if (inheritedIndentation !== -1 /* Unknown */) {
|
|
return inheritedIndentation;
|
|
}
|
|
} else {
|
|
const startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line;
|
|
const startLinePosition = getLineStartPositionForPosition(startPos, sourceFile);
|
|
const column = SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, startPos, sourceFile, options);
|
|
if (startLine !== parentStartLine || startPos === column) {
|
|
const baseIndentSize = SmartIndenter.getBaseIndentation(options);
|
|
return baseIndentSize > column ? baseIndentSize : column;
|
|
}
|
|
}
|
|
return -1 /* Unknown */;
|
|
}
|
|
function computeIndentation(node, startLine, inheritedIndentation, parent2, parentDynamicIndentation, effectiveParentStartLine) {
|
|
const delta2 = SmartIndenter.shouldIndentChildNode(options, node) ? options.indentSize : 0;
|
|
if (effectiveParentStartLine === startLine) {
|
|
return {
|
|
indentation: startLine === lastIndentedLine ? indentationOnLastIndentedLine : parentDynamicIndentation.getIndentation(),
|
|
delta: Math.min(options.indentSize, parentDynamicIndentation.getDelta(node) + delta2)
|
|
};
|
|
} else if (inheritedIndentation === -1 /* Unknown */) {
|
|
if (node.kind === 20 /* OpenParenToken */ && startLine === lastIndentedLine) {
|
|
return { indentation: indentationOnLastIndentedLine, delta: parentDynamicIndentation.getDelta(node) };
|
|
} else if (SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent2, node, startLine, sourceFile) || SmartIndenter.childIsUnindentedBranchOfConditionalExpression(parent2, node, startLine, sourceFile) || SmartIndenter.argumentStartsOnSameLineAsPreviousArgument(parent2, node, startLine, sourceFile)) {
|
|
return { indentation: parentDynamicIndentation.getIndentation(), delta: delta2 };
|
|
} else {
|
|
return { indentation: parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(node), delta: delta2 };
|
|
}
|
|
} else {
|
|
return { indentation: inheritedIndentation, delta: delta2 };
|
|
}
|
|
}
|
|
function getFirstNonDecoratorTokenOfNode(node) {
|
|
if (canHaveModifiers(node)) {
|
|
const modifier = find(node.modifiers, isModifier, findIndex(node.modifiers, isDecorator));
|
|
if (modifier)
|
|
return modifier.kind;
|
|
}
|
|
switch (node.kind) {
|
|
case 260 /* ClassDeclaration */:
|
|
return 84 /* ClassKeyword */;
|
|
case 261 /* InterfaceDeclaration */:
|
|
return 118 /* InterfaceKeyword */;
|
|
case 259 /* FunctionDeclaration */:
|
|
return 98 /* FunctionKeyword */;
|
|
case 263 /* EnumDeclaration */:
|
|
return 263 /* EnumDeclaration */;
|
|
case 174 /* GetAccessor */:
|
|
return 137 /* GetKeyword */;
|
|
case 175 /* SetAccessor */:
|
|
return 151 /* SetKeyword */;
|
|
case 171 /* MethodDeclaration */:
|
|
if (node.asteriskToken) {
|
|
return 41 /* AsteriskToken */;
|
|
}
|
|
case 169 /* PropertyDeclaration */:
|
|
case 166 /* Parameter */:
|
|
const name = getNameOfDeclaration(node);
|
|
if (name) {
|
|
return name.kind;
|
|
}
|
|
}
|
|
}
|
|
function getDynamicIndentation(node, nodeStartLine, indentation, delta2) {
|
|
return {
|
|
getIndentationForComment: (kind, tokenIndentation, container) => {
|
|
switch (kind) {
|
|
case 19 /* CloseBraceToken */:
|
|
case 23 /* CloseBracketToken */:
|
|
case 21 /* CloseParenToken */:
|
|
return indentation + getDelta(container);
|
|
}
|
|
return tokenIndentation !== -1 /* Unknown */ ? tokenIndentation : indentation;
|
|
},
|
|
getIndentationForToken: (line, kind, container, suppressDelta) => !suppressDelta && shouldAddDelta(line, kind, container) ? indentation + getDelta(container) : indentation,
|
|
getIndentation: () => indentation,
|
|
getDelta,
|
|
recomputeIndentation: (lineAdded, parent2) => {
|
|
if (SmartIndenter.shouldIndentChildNode(options, parent2, node, sourceFile)) {
|
|
indentation += lineAdded ? options.indentSize : -options.indentSize;
|
|
delta2 = SmartIndenter.shouldIndentChildNode(options, node) ? options.indentSize : 0;
|
|
}
|
|
}
|
|
};
|
|
function shouldAddDelta(line, kind, container) {
|
|
switch (kind) {
|
|
case 18 /* OpenBraceToken */:
|
|
case 19 /* CloseBraceToken */:
|
|
case 21 /* CloseParenToken */:
|
|
case 91 /* ElseKeyword */:
|
|
case 115 /* WhileKeyword */:
|
|
case 59 /* AtToken */:
|
|
return false;
|
|
case 43 /* SlashToken */:
|
|
case 31 /* GreaterThanToken */:
|
|
switch (container.kind) {
|
|
case 283 /* JsxOpeningElement */:
|
|
case 284 /* JsxClosingElement */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
return false;
|
|
}
|
|
break;
|
|
case 22 /* OpenBracketToken */:
|
|
case 23 /* CloseBracketToken */:
|
|
if (container.kind !== 197 /* MappedType */) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
return nodeStartLine !== line && !(hasDecorators(node) && kind === getFirstNonDecoratorTokenOfNode(node));
|
|
}
|
|
function getDelta(child) {
|
|
return SmartIndenter.nodeWillIndentChild(options, node, child, sourceFile, true) ? delta2 : 0;
|
|
}
|
|
}
|
|
function processNode(node, contextNode, nodeStartLine, undecoratedNodeStartLine, indentation, delta2) {
|
|
if (!rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) {
|
|
return;
|
|
}
|
|
const nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta2);
|
|
let childContextNode = contextNode;
|
|
forEachChild(
|
|
node,
|
|
(child) => {
|
|
processChildNode(child, -1 /* Unknown */, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, false);
|
|
},
|
|
(nodes) => {
|
|
processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation);
|
|
}
|
|
);
|
|
while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) {
|
|
const tokenInfo = formattingScanner.readTokenInfo(node);
|
|
if (tokenInfo.token.end > Math.min(node.end, originalRange.end)) {
|
|
break;
|
|
}
|
|
consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
|
|
}
|
|
function processChildNode(child, inheritedIndentation, parent2, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
|
|
Debug.assert(!nodeIsSynthesized(child));
|
|
if (nodeIsMissing(child)) {
|
|
return inheritedIndentation;
|
|
}
|
|
const childStartPos = child.getStart(sourceFile);
|
|
const childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line;
|
|
let undecoratedChildStartLine = childStartLine;
|
|
if (hasDecorators(child)) {
|
|
undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(child, sourceFile)).line;
|
|
}
|
|
let childIndentationAmount = -1 /* Unknown */;
|
|
if (isListItem && rangeContainsRange(originalRange, parent2)) {
|
|
childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation);
|
|
if (childIndentationAmount !== -1 /* Unknown */) {
|
|
inheritedIndentation = childIndentationAmount;
|
|
}
|
|
}
|
|
if (!rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) {
|
|
if (child.end < originalRange.pos) {
|
|
formattingScanner.skipToEndOf(child);
|
|
}
|
|
return inheritedIndentation;
|
|
}
|
|
if (child.getFullWidth() === 0) {
|
|
return inheritedIndentation;
|
|
}
|
|
while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) {
|
|
const tokenInfo = formattingScanner.readTokenInfo(node);
|
|
if (tokenInfo.token.end > originalRange.end) {
|
|
return inheritedIndentation;
|
|
}
|
|
if (tokenInfo.token.end > childStartPos) {
|
|
if (tokenInfo.token.pos > childStartPos) {
|
|
formattingScanner.skipToStartOf(child);
|
|
}
|
|
break;
|
|
}
|
|
consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, node);
|
|
}
|
|
if (!formattingScanner.isOnToken() || formattingScanner.getStartPos() >= originalRange.end) {
|
|
return inheritedIndentation;
|
|
}
|
|
if (isToken(child)) {
|
|
const tokenInfo = formattingScanner.readTokenInfo(child);
|
|
if (child.kind !== 11 /* JsxText */) {
|
|
Debug.assert(tokenInfo.token.end === child.end, "Token end is child end");
|
|
consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, child);
|
|
return inheritedIndentation;
|
|
}
|
|
}
|
|
const effectiveParentStartLine = child.kind === 167 /* Decorator */ ? childStartLine : undecoratedParentStartLine;
|
|
const childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine);
|
|
processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta);
|
|
childContextNode = node;
|
|
if (isFirstListItem && parent2.kind === 206 /* ArrayLiteralExpression */ && inheritedIndentation === -1 /* Unknown */) {
|
|
inheritedIndentation = childIndentation.indentation;
|
|
}
|
|
return inheritedIndentation;
|
|
}
|
|
function processChildNodes(nodes, parent2, parentStartLine, parentDynamicIndentation) {
|
|
Debug.assert(isNodeArray(nodes));
|
|
Debug.assert(!nodeIsSynthesized(nodes));
|
|
const listStartToken = getOpenTokenForList(parent2, nodes);
|
|
let listDynamicIndentation = parentDynamicIndentation;
|
|
let startLine = parentStartLine;
|
|
if (!rangeOverlapsWithStartEnd(originalRange, nodes.pos, nodes.end)) {
|
|
if (nodes.end < originalRange.pos) {
|
|
formattingScanner.skipToEndOf(nodes);
|
|
}
|
|
return;
|
|
}
|
|
if (listStartToken !== 0 /* Unknown */) {
|
|
while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) {
|
|
const tokenInfo = formattingScanner.readTokenInfo(parent2);
|
|
if (tokenInfo.token.end > nodes.pos) {
|
|
break;
|
|
} else if (tokenInfo.token.kind === listStartToken) {
|
|
startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line;
|
|
consumeTokenAndAdvanceScanner(tokenInfo, parent2, parentDynamicIndentation, parent2);
|
|
let indentationOnListStartToken;
|
|
if (indentationOnLastIndentedLine !== -1 /* Unknown */) {
|
|
indentationOnListStartToken = indentationOnLastIndentedLine;
|
|
} else {
|
|
const startLinePosition = getLineStartPositionForPosition(tokenInfo.token.pos, sourceFile);
|
|
indentationOnListStartToken = SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, tokenInfo.token.pos, sourceFile, options);
|
|
}
|
|
listDynamicIndentation = getDynamicIndentation(parent2, parentStartLine, indentationOnListStartToken, options.indentSize);
|
|
} else {
|
|
consumeTokenAndAdvanceScanner(tokenInfo, parent2, parentDynamicIndentation, parent2);
|
|
}
|
|
}
|
|
}
|
|
let inheritedIndentation = -1 /* Unknown */;
|
|
for (let i = 0; i < nodes.length; i++) {
|
|
const child = nodes[i];
|
|
inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, true, i === 0);
|
|
}
|
|
const listEndToken = getCloseTokenForOpenToken(listStartToken);
|
|
if (listEndToken !== 0 /* Unknown */ && formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) {
|
|
let tokenInfo = formattingScanner.readTokenInfo(parent2);
|
|
if (tokenInfo.token.kind === 27 /* CommaToken */) {
|
|
consumeTokenAndAdvanceScanner(tokenInfo, parent2, listDynamicIndentation, parent2);
|
|
tokenInfo = formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(parent2) : void 0;
|
|
}
|
|
if (tokenInfo && tokenInfo.token.kind === listEndToken && rangeContainsRange(parent2, tokenInfo.token)) {
|
|
consumeTokenAndAdvanceScanner(tokenInfo, parent2, listDynamicIndentation, parent2, true);
|
|
}
|
|
}
|
|
}
|
|
function consumeTokenAndAdvanceScanner(currentTokenInfo, parent2, dynamicIndentation, container, isListEndToken) {
|
|
Debug.assert(rangeContainsRange(parent2, currentTokenInfo.token));
|
|
const lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine();
|
|
let indentToken = false;
|
|
if (currentTokenInfo.leadingTrivia) {
|
|
processTrivia(currentTokenInfo.leadingTrivia, parent2, childContextNode, dynamicIndentation);
|
|
}
|
|
let lineAction = LineAction.None;
|
|
const isTokenInRange = rangeContainsRange(originalRange, currentTokenInfo.token);
|
|
const tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos);
|
|
if (isTokenInRange) {
|
|
const rangeHasError = rangeContainsError(currentTokenInfo.token);
|
|
const savePreviousRange = previousRange;
|
|
lineAction = processRange(currentTokenInfo.token, tokenStart, parent2, childContextNode, dynamicIndentation);
|
|
if (!rangeHasError) {
|
|
if (lineAction === LineAction.None) {
|
|
const prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line;
|
|
indentToken = lastTriviaWasNewLine && tokenStart.line !== prevEndLine;
|
|
} else {
|
|
indentToken = lineAction === LineAction.LineAdded;
|
|
}
|
|
}
|
|
}
|
|
if (currentTokenInfo.trailingTrivia) {
|
|
previousRangeTriviaEnd = last(currentTokenInfo.trailingTrivia).end;
|
|
processTrivia(currentTokenInfo.trailingTrivia, parent2, childContextNode, dynamicIndentation);
|
|
}
|
|
if (indentToken) {
|
|
const tokenIndentation = isTokenInRange && !rangeContainsError(currentTokenInfo.token) ? dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind, container, !!isListEndToken) : -1 /* Unknown */;
|
|
let indentNextTokenOrTrivia = true;
|
|
if (currentTokenInfo.leadingTrivia) {
|
|
const commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind, tokenIndentation, container);
|
|
indentNextTokenOrTrivia = indentTriviaItems(
|
|
currentTokenInfo.leadingTrivia,
|
|
commentIndentation,
|
|
indentNextTokenOrTrivia,
|
|
(item) => insertIndentation(item.pos, commentIndentation, false)
|
|
);
|
|
}
|
|
if (tokenIndentation !== -1 /* Unknown */ && indentNextTokenOrTrivia) {
|
|
insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAction === LineAction.LineAdded);
|
|
lastIndentedLine = tokenStart.line;
|
|
indentationOnLastIndentedLine = tokenIndentation;
|
|
}
|
|
}
|
|
formattingScanner.advance();
|
|
childContextNode = parent2;
|
|
}
|
|
}
|
|
function indentTriviaItems(trivia, commentIndentation, indentNextTokenOrTrivia, indentSingleLine) {
|
|
for (const triviaItem of trivia) {
|
|
const triviaInRange = rangeContainsRange(originalRange, triviaItem);
|
|
switch (triviaItem.kind) {
|
|
case 3 /* MultiLineCommentTrivia */:
|
|
if (triviaInRange) {
|
|
indentMultilineComment(triviaItem, commentIndentation, !indentNextTokenOrTrivia);
|
|
}
|
|
indentNextTokenOrTrivia = false;
|
|
break;
|
|
case 2 /* SingleLineCommentTrivia */:
|
|
if (indentNextTokenOrTrivia && triviaInRange) {
|
|
indentSingleLine(triviaItem);
|
|
}
|
|
indentNextTokenOrTrivia = false;
|
|
break;
|
|
case 4 /* NewLineTrivia */:
|
|
indentNextTokenOrTrivia = true;
|
|
break;
|
|
}
|
|
}
|
|
return indentNextTokenOrTrivia;
|
|
}
|
|
function processTrivia(trivia, parent2, contextNode, dynamicIndentation) {
|
|
for (const triviaItem of trivia) {
|
|
if (isComment(triviaItem.kind) && rangeContainsRange(originalRange, triviaItem)) {
|
|
const triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);
|
|
processRange(triviaItem, triviaItemStart, parent2, contextNode, dynamicIndentation);
|
|
}
|
|
}
|
|
}
|
|
function processRange(range, rangeStart, parent2, contextNode, dynamicIndentation) {
|
|
const rangeHasError = rangeContainsError(range);
|
|
let lineAction = LineAction.None;
|
|
if (!rangeHasError) {
|
|
if (!previousRange) {
|
|
const originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos);
|
|
trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line);
|
|
} else {
|
|
lineAction = processPair(range, rangeStart.line, parent2, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation);
|
|
}
|
|
}
|
|
previousRange = range;
|
|
previousRangeTriviaEnd = range.end;
|
|
previousParent = parent2;
|
|
previousRangeStartLine = rangeStart.line;
|
|
return lineAction;
|
|
}
|
|
function processPair(currentItem, currentStartLine, currentParent, previousItem, previousStartLine, previousParent2, contextNode, dynamicIndentation) {
|
|
formattingContext.updateContext(previousItem, previousParent2, currentItem, currentParent, contextNode);
|
|
const rules = getRules(formattingContext);
|
|
let trimTrailingWhitespaces = formattingContext.options.trimTrailingWhitespace !== false;
|
|
let lineAction = LineAction.None;
|
|
if (rules) {
|
|
forEachRight(rules, (rule2) => {
|
|
lineAction = applyRuleEdits(rule2, previousItem, previousStartLine, currentItem, currentStartLine);
|
|
if (dynamicIndentation) {
|
|
switch (lineAction) {
|
|
case LineAction.LineRemoved:
|
|
if (currentParent.getStart(sourceFile) === currentItem.pos) {
|
|
dynamicIndentation.recomputeIndentation(false, contextNode);
|
|
}
|
|
break;
|
|
case LineAction.LineAdded:
|
|
if (currentParent.getStart(sourceFile) === currentItem.pos) {
|
|
dynamicIndentation.recomputeIndentation(true, contextNode);
|
|
}
|
|
break;
|
|
default:
|
|
Debug.assert(lineAction === LineAction.None);
|
|
}
|
|
}
|
|
trimTrailingWhitespaces = trimTrailingWhitespaces && !(rule2.action & 16 /* DeleteSpace */) && rule2.flags !== 1 /* CanDeleteNewLines */;
|
|
});
|
|
} else {
|
|
trimTrailingWhitespaces = trimTrailingWhitespaces && currentItem.kind !== 1 /* EndOfFileToken */;
|
|
}
|
|
if (currentStartLine !== previousStartLine && trimTrailingWhitespaces) {
|
|
trimTrailingWhitespacesForLines(previousStartLine, currentStartLine, previousItem);
|
|
}
|
|
return lineAction;
|
|
}
|
|
function insertIndentation(pos, indentation, lineAdded) {
|
|
const indentationString = getIndentationString(indentation, options);
|
|
if (lineAdded) {
|
|
recordReplace(pos, 0, indentationString);
|
|
} else {
|
|
const tokenStart = sourceFile.getLineAndCharacterOfPosition(pos);
|
|
const startLinePosition = getStartPositionOfLine(tokenStart.line, sourceFile);
|
|
if (indentation !== characterToColumn(startLinePosition, tokenStart.character) || indentationIsDifferent(indentationString, startLinePosition)) {
|
|
recordReplace(startLinePosition, tokenStart.character, indentationString);
|
|
}
|
|
}
|
|
}
|
|
function characterToColumn(startLinePosition, characterInLine) {
|
|
let column = 0;
|
|
for (let i = 0; i < characterInLine; i++) {
|
|
if (sourceFile.text.charCodeAt(startLinePosition + i) === 9 /* tab */) {
|
|
column += options.tabSize - column % options.tabSize;
|
|
} else {
|
|
column++;
|
|
}
|
|
}
|
|
return column;
|
|
}
|
|
function indentationIsDifferent(indentationString, startLinePosition) {
|
|
return indentationString !== sourceFile.text.substr(startLinePosition, indentationString.length);
|
|
}
|
|
function indentMultilineComment(commentRange, indentation, firstLineIsIndented, indentFinalLine = true) {
|
|
let startLine = sourceFile.getLineAndCharacterOfPosition(commentRange.pos).line;
|
|
const endLine = sourceFile.getLineAndCharacterOfPosition(commentRange.end).line;
|
|
if (startLine === endLine) {
|
|
if (!firstLineIsIndented) {
|
|
insertIndentation(commentRange.pos, indentation, false);
|
|
}
|
|
return;
|
|
}
|
|
const parts = [];
|
|
let startPos = commentRange.pos;
|
|
for (let line = startLine; line < endLine; line++) {
|
|
const endOfLine = getEndLinePosition(line, sourceFile);
|
|
parts.push({ pos: startPos, end: endOfLine });
|
|
startPos = getStartPositionOfLine(line + 1, sourceFile);
|
|
}
|
|
if (indentFinalLine) {
|
|
parts.push({ pos: startPos, end: commentRange.end });
|
|
}
|
|
if (parts.length === 0)
|
|
return;
|
|
const startLinePos = getStartPositionOfLine(startLine, sourceFile);
|
|
const nonWhitespaceColumnInFirstPart = SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options);
|
|
let startIndex = 0;
|
|
if (firstLineIsIndented) {
|
|
startIndex = 1;
|
|
startLine++;
|
|
}
|
|
const delta2 = indentation - nonWhitespaceColumnInFirstPart.column;
|
|
for (let i = startIndex; i < parts.length; i++, startLine++) {
|
|
const startLinePos2 = getStartPositionOfLine(startLine, sourceFile);
|
|
const nonWhitespaceCharacterAndColumn = i === 0 ? nonWhitespaceColumnInFirstPart : SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options);
|
|
const newIndentation = nonWhitespaceCharacterAndColumn.column + delta2;
|
|
if (newIndentation > 0) {
|
|
const indentationString = getIndentationString(newIndentation, options);
|
|
recordReplace(startLinePos2, nonWhitespaceCharacterAndColumn.character, indentationString);
|
|
} else {
|
|
recordDelete(startLinePos2, nonWhitespaceCharacterAndColumn.character);
|
|
}
|
|
}
|
|
}
|
|
function trimTrailingWhitespacesForLines(line1, line2, range) {
|
|
for (let line = line1; line < line2; line++) {
|
|
const lineStartPosition = getStartPositionOfLine(line, sourceFile);
|
|
const lineEndPosition = getEndLinePosition(line, sourceFile);
|
|
if (range && (isComment(range.kind) || isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) {
|
|
continue;
|
|
}
|
|
const whitespaceStart = getTrailingWhitespaceStartPosition(lineStartPosition, lineEndPosition);
|
|
if (whitespaceStart !== -1) {
|
|
Debug.assert(whitespaceStart === lineStartPosition || !isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(whitespaceStart - 1)));
|
|
recordDelete(whitespaceStart, lineEndPosition + 1 - whitespaceStart);
|
|
}
|
|
}
|
|
}
|
|
function getTrailingWhitespaceStartPosition(start2, end) {
|
|
let pos = end;
|
|
while (pos >= start2 && isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(pos))) {
|
|
pos--;
|
|
}
|
|
if (pos !== end) {
|
|
return pos + 1;
|
|
}
|
|
return -1;
|
|
}
|
|
function trimTrailingWhitespacesForRemainingRange(trivias) {
|
|
let startPos = previousRange ? previousRange.end : originalRange.pos;
|
|
for (const trivia of trivias) {
|
|
if (isComment(trivia.kind)) {
|
|
if (startPos < trivia.pos) {
|
|
trimTrailingWitespacesForPositions(startPos, trivia.pos - 1, previousRange);
|
|
}
|
|
startPos = trivia.end + 1;
|
|
}
|
|
}
|
|
if (startPos < originalRange.end) {
|
|
trimTrailingWitespacesForPositions(startPos, originalRange.end, previousRange);
|
|
}
|
|
}
|
|
function trimTrailingWitespacesForPositions(startPos, endPos, previousRange2) {
|
|
const startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line;
|
|
const endLine = sourceFile.getLineAndCharacterOfPosition(endPos).line;
|
|
trimTrailingWhitespacesForLines(startLine, endLine + 1, previousRange2);
|
|
}
|
|
function recordDelete(start2, len) {
|
|
if (len) {
|
|
edits.push(createTextChangeFromStartLength(start2, len, ""));
|
|
}
|
|
}
|
|
function recordReplace(start2, len, newText) {
|
|
if (len || newText) {
|
|
edits.push(createTextChangeFromStartLength(start2, len, newText));
|
|
}
|
|
}
|
|
function recordInsert(start2, text) {
|
|
if (text) {
|
|
edits.push(createTextChangeFromStartLength(start2, 0, text));
|
|
}
|
|
}
|
|
function applyRuleEdits(rule2, previousRange2, previousStartLine, currentRange, currentStartLine) {
|
|
const onLaterLine = currentStartLine !== previousStartLine;
|
|
switch (rule2.action) {
|
|
case 1 /* StopProcessingSpaceActions */:
|
|
return LineAction.None;
|
|
case 16 /* DeleteSpace */:
|
|
if (previousRange2.end !== currentRange.pos) {
|
|
recordDelete(previousRange2.end, currentRange.pos - previousRange2.end);
|
|
return onLaterLine ? LineAction.LineRemoved : LineAction.None;
|
|
}
|
|
break;
|
|
case 32 /* DeleteToken */:
|
|
recordDelete(previousRange2.pos, previousRange2.end - previousRange2.pos);
|
|
break;
|
|
case 8 /* InsertNewLine */:
|
|
if (rule2.flags !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
|
|
return LineAction.None;
|
|
}
|
|
const lineDelta = currentStartLine - previousStartLine;
|
|
if (lineDelta !== 1) {
|
|
recordReplace(previousRange2.end, currentRange.pos - previousRange2.end, getNewLineOrDefaultFromHost(host, options));
|
|
return onLaterLine ? LineAction.None : LineAction.LineAdded;
|
|
}
|
|
break;
|
|
case 4 /* InsertSpace */:
|
|
if (rule2.flags !== 1 /* CanDeleteNewLines */ && previousStartLine !== currentStartLine) {
|
|
return LineAction.None;
|
|
}
|
|
const posDelta = currentRange.pos - previousRange2.end;
|
|
if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange2.end) !== 32 /* space */) {
|
|
recordReplace(previousRange2.end, currentRange.pos - previousRange2.end, " ");
|
|
return onLaterLine ? LineAction.LineRemoved : LineAction.None;
|
|
}
|
|
break;
|
|
case 64 /* InsertTrailingSemicolon */:
|
|
recordInsert(previousRange2.end, ";");
|
|
}
|
|
return LineAction.None;
|
|
}
|
|
}
|
|
var LineAction = /* @__PURE__ */ ((LineAction2) => {
|
|
LineAction2[LineAction2["None"] = 0] = "None";
|
|
LineAction2[LineAction2["LineAdded"] = 1] = "LineAdded";
|
|
LineAction2[LineAction2["LineRemoved"] = 2] = "LineRemoved";
|
|
return LineAction2;
|
|
})(LineAction || {});
|
|
function getRangeOfEnclosingComment(sourceFile, position, precedingToken, tokenAtPosition = getTokenAtPosition(sourceFile, position)) {
|
|
const jsdoc = findAncestor(tokenAtPosition, isJSDoc);
|
|
if (jsdoc)
|
|
tokenAtPosition = jsdoc.parent;
|
|
const tokenStart = tokenAtPosition.getStart(sourceFile);
|
|
if (tokenStart <= position && position < tokenAtPosition.getEnd()) {
|
|
return void 0;
|
|
}
|
|
precedingToken = precedingToken === null ? void 0 : precedingToken === void 0 ? findPrecedingToken(position, sourceFile) : precedingToken;
|
|
const trailingRangesOfPreviousToken = precedingToken && getTrailingCommentRanges(sourceFile.text, precedingToken.end);
|
|
const leadingCommentRangesOfNextToken = getLeadingCommentRangesOfNode(tokenAtPosition, sourceFile);
|
|
const commentRanges = concatenate(trailingRangesOfPreviousToken, leadingCommentRangesOfNextToken);
|
|
return commentRanges && find(commentRanges, (range) => rangeContainsPositionExclusive(range, position) || position === range.end && (range.kind === 2 /* SingleLineCommentTrivia */ || position === sourceFile.getFullWidth()));
|
|
}
|
|
function getOpenTokenForList(node, list) {
|
|
switch (node.kind) {
|
|
case 173 /* Constructor */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 216 /* ArrowFunction */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
if (node.typeParameters === list) {
|
|
return 29 /* LessThanToken */;
|
|
} else if (node.parameters === list) {
|
|
return 20 /* OpenParenToken */;
|
|
}
|
|
break;
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
if (node.typeArguments === list) {
|
|
return 29 /* LessThanToken */;
|
|
} else if (node.arguments === list) {
|
|
return 20 /* OpenParenToken */;
|
|
}
|
|
break;
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
if (node.typeParameters === list) {
|
|
return 29 /* LessThanToken */;
|
|
}
|
|
break;
|
|
case 180 /* TypeReference */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 183 /* TypeQuery */:
|
|
case 230 /* ExpressionWithTypeArguments */:
|
|
case 202 /* ImportType */:
|
|
if (node.typeArguments === list) {
|
|
return 29 /* LessThanToken */;
|
|
}
|
|
break;
|
|
case 184 /* TypeLiteral */:
|
|
return 18 /* OpenBraceToken */;
|
|
}
|
|
return 0 /* Unknown */;
|
|
}
|
|
function getCloseTokenForOpenToken(kind) {
|
|
switch (kind) {
|
|
case 20 /* OpenParenToken */:
|
|
return 21 /* CloseParenToken */;
|
|
case 29 /* LessThanToken */:
|
|
return 31 /* GreaterThanToken */;
|
|
case 18 /* OpenBraceToken */:
|
|
return 19 /* CloseBraceToken */;
|
|
}
|
|
return 0 /* Unknown */;
|
|
}
|
|
var internedSizes;
|
|
var internedTabsIndentation;
|
|
var internedSpacesIndentation;
|
|
function getIndentationString(indentation, options) {
|
|
const resetInternedStrings = !internedSizes || (internedSizes.tabSize !== options.tabSize || internedSizes.indentSize !== options.indentSize);
|
|
if (resetInternedStrings) {
|
|
internedSizes = { tabSize: options.tabSize, indentSize: options.indentSize };
|
|
internedTabsIndentation = internedSpacesIndentation = void 0;
|
|
}
|
|
if (!options.convertTabsToSpaces) {
|
|
const tabs = Math.floor(indentation / options.tabSize);
|
|
const spaces = indentation - tabs * options.tabSize;
|
|
let tabString;
|
|
if (!internedTabsIndentation) {
|
|
internedTabsIndentation = [];
|
|
}
|
|
if (internedTabsIndentation[tabs] === void 0) {
|
|
internedTabsIndentation[tabs] = tabString = repeatString(" ", tabs);
|
|
} else {
|
|
tabString = internedTabsIndentation[tabs];
|
|
}
|
|
return spaces ? tabString + repeatString(" ", spaces) : tabString;
|
|
} else {
|
|
let spacesString;
|
|
const quotient = Math.floor(indentation / options.indentSize);
|
|
const remainder = indentation % options.indentSize;
|
|
if (!internedSpacesIndentation) {
|
|
internedSpacesIndentation = [];
|
|
}
|
|
if (internedSpacesIndentation[quotient] === void 0) {
|
|
spacesString = repeatString(" ", options.indentSize * quotient);
|
|
internedSpacesIndentation[quotient] = spacesString;
|
|
} else {
|
|
spacesString = internedSpacesIndentation[quotient];
|
|
}
|
|
return remainder ? spacesString + repeatString(" ", remainder) : spacesString;
|
|
}
|
|
}
|
|
|
|
// src/services/formatting/smartIndenter.ts
|
|
var SmartIndenter;
|
|
((SmartIndenter2) => {
|
|
let Value;
|
|
((Value2) => {
|
|
Value2[Value2["Unknown"] = -1] = "Unknown";
|
|
})(Value || (Value = {}));
|
|
function getIndentation(position, sourceFile, options, assumeNewLineBeforeCloseBrace = false) {
|
|
if (position > sourceFile.text.length) {
|
|
return getBaseIndentation(options);
|
|
}
|
|
if (options.indentStyle === 0 /* None */) {
|
|
return 0;
|
|
}
|
|
const precedingToken = findPrecedingToken(position, sourceFile, void 0, true);
|
|
const enclosingCommentRange = getRangeOfEnclosingComment(sourceFile, position, precedingToken || null);
|
|
if (enclosingCommentRange && enclosingCommentRange.kind === 3 /* MultiLineCommentTrivia */) {
|
|
return getCommentIndent(sourceFile, position, options, enclosingCommentRange);
|
|
}
|
|
if (!precedingToken) {
|
|
return getBaseIndentation(options);
|
|
}
|
|
const precedingTokenIsLiteral = isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind);
|
|
if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && position < precedingToken.end) {
|
|
return 0;
|
|
}
|
|
const lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
|
|
const currentToken = getTokenAtPosition(sourceFile, position);
|
|
const isObjectLiteral = currentToken.kind === 18 /* OpenBraceToken */ && currentToken.parent.kind === 207 /* ObjectLiteralExpression */;
|
|
if (options.indentStyle === 1 /* Block */ || isObjectLiteral) {
|
|
return getBlockIndent(sourceFile, position, options);
|
|
}
|
|
if (precedingToken.kind === 27 /* CommaToken */ && precedingToken.parent.kind !== 223 /* BinaryExpression */) {
|
|
const actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options);
|
|
if (actualIndentation !== -1 /* Unknown */) {
|
|
return actualIndentation;
|
|
}
|
|
}
|
|
const containerList = getListByPosition(position, precedingToken.parent, sourceFile);
|
|
if (containerList && !rangeContainsRange(containerList, precedingToken)) {
|
|
const useTheSameBaseIndentation = [215 /* FunctionExpression */, 216 /* ArrowFunction */].indexOf(currentToken.parent.kind) !== -1;
|
|
const indentSize = useTheSameBaseIndentation ? 0 : options.indentSize;
|
|
return getActualIndentationForListStartLine(containerList, sourceFile, options) + indentSize;
|
|
}
|
|
return getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options);
|
|
}
|
|
SmartIndenter2.getIndentation = getIndentation;
|
|
function getCommentIndent(sourceFile, position, options, enclosingCommentRange) {
|
|
const previousLine = getLineAndCharacterOfPosition(sourceFile, position).line - 1;
|
|
const commentStartLine = getLineAndCharacterOfPosition(sourceFile, enclosingCommentRange.pos).line;
|
|
Debug.assert(commentStartLine >= 0);
|
|
if (previousLine <= commentStartLine) {
|
|
return findFirstNonWhitespaceColumn(getStartPositionOfLine(commentStartLine, sourceFile), position, sourceFile, options);
|
|
}
|
|
const startPositionOfLine = getStartPositionOfLine(previousLine, sourceFile);
|
|
const { column, character } = findFirstNonWhitespaceCharacterAndColumn(startPositionOfLine, position, sourceFile, options);
|
|
if (column === 0) {
|
|
return column;
|
|
}
|
|
const firstNonWhitespaceCharacterCode = sourceFile.text.charCodeAt(startPositionOfLine + character);
|
|
return firstNonWhitespaceCharacterCode === 42 /* asterisk */ ? column - 1 : column;
|
|
}
|
|
function getBlockIndent(sourceFile, position, options) {
|
|
let current = position;
|
|
while (current > 0) {
|
|
const char = sourceFile.text.charCodeAt(current);
|
|
if (!isWhiteSpaceLike(char)) {
|
|
break;
|
|
}
|
|
current--;
|
|
}
|
|
const lineStart = getLineStartPositionForPosition(current, sourceFile);
|
|
return findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options);
|
|
}
|
|
function getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options) {
|
|
let previous;
|
|
let current = precedingToken;
|
|
while (current) {
|
|
if (positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(options, current, previous, sourceFile, true)) {
|
|
const currentStart = getStartLineAndCharacterForNode(current, sourceFile);
|
|
const nextTokenKind = nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile);
|
|
const indentationDelta = nextTokenKind !== NextTokenKind.Unknown ? assumeNewLineBeforeCloseBrace && nextTokenKind === NextTokenKind.CloseBrace ? options.indentSize : 0 : lineAtPosition !== currentStart.line ? options.indentSize : 0;
|
|
return getIndentationForNodeWorker(current, currentStart, void 0, indentationDelta, sourceFile, true, options);
|
|
}
|
|
const actualIndentation = getActualIndentationForListItem(current, sourceFile, options, true);
|
|
if (actualIndentation !== -1 /* Unknown */) {
|
|
return actualIndentation;
|
|
}
|
|
previous = current;
|
|
current = current.parent;
|
|
}
|
|
return getBaseIndentation(options);
|
|
}
|
|
function getIndentationForNode(n, ignoreActualIndentationRange, sourceFile, options) {
|
|
const start2 = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
|
|
return getIndentationForNodeWorker(n, start2, ignoreActualIndentationRange, 0, sourceFile, false, options);
|
|
}
|
|
SmartIndenter2.getIndentationForNode = getIndentationForNode;
|
|
function getBaseIndentation(options) {
|
|
return options.baseIndentSize || 0;
|
|
}
|
|
SmartIndenter2.getBaseIndentation = getBaseIndentation;
|
|
function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, isNextChild, options) {
|
|
var _a2;
|
|
let parent2 = current.parent;
|
|
while (parent2) {
|
|
let useActualIndentation = true;
|
|
if (ignoreActualIndentationRange) {
|
|
const start2 = current.getStart(sourceFile);
|
|
useActualIndentation = start2 < ignoreActualIndentationRange.pos || start2 > ignoreActualIndentationRange.end;
|
|
}
|
|
const containingListOrParentStart = getContainingListOrParentStart(parent2, current, sourceFile);
|
|
const parentAndChildShareLine = containingListOrParentStart.line === currentStart.line || childStartsOnTheSameLineWithElseInIfStatement(parent2, current, currentStart.line, sourceFile);
|
|
if (useActualIndentation) {
|
|
const firstListChild = (_a2 = getContainingList(current, sourceFile)) == null ? void 0 : _a2[0];
|
|
const listIndentsChild = !!firstListChild && getStartLineAndCharacterForNode(firstListChild, sourceFile).line > containingListOrParentStart.line;
|
|
let actualIndentation = getActualIndentationForListItem(current, sourceFile, options, listIndentsChild);
|
|
if (actualIndentation !== -1 /* Unknown */) {
|
|
return actualIndentation + indentationDelta;
|
|
}
|
|
actualIndentation = getActualIndentationForNode(current, parent2, currentStart, parentAndChildShareLine, sourceFile, options);
|
|
if (actualIndentation !== -1 /* Unknown */) {
|
|
return actualIndentation + indentationDelta;
|
|
}
|
|
}
|
|
if (shouldIndentChildNode(options, parent2, current, sourceFile, isNextChild) && !parentAndChildShareLine) {
|
|
indentationDelta += options.indentSize;
|
|
}
|
|
const useTrueStart = isArgumentAndStartLineOverlapsExpressionBeingCalled(parent2, current, currentStart.line, sourceFile);
|
|
current = parent2;
|
|
parent2 = current.parent;
|
|
currentStart = useTrueStart ? sourceFile.getLineAndCharacterOfPosition(current.getStart(sourceFile)) : containingListOrParentStart;
|
|
}
|
|
return indentationDelta + getBaseIndentation(options);
|
|
}
|
|
function getContainingListOrParentStart(parent2, child, sourceFile) {
|
|
const containingList = getContainingList(child, sourceFile);
|
|
const startPos = containingList ? containingList.pos : parent2.getStart(sourceFile);
|
|
return sourceFile.getLineAndCharacterOfPosition(startPos);
|
|
}
|
|
function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) {
|
|
const commaItemInfo = findListItemInfo(commaToken);
|
|
if (commaItemInfo && commaItemInfo.listItemIndex > 0) {
|
|
return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options);
|
|
} else {
|
|
return -1 /* Unknown */;
|
|
}
|
|
}
|
|
function getActualIndentationForNode(current, parent2, currentLineAndChar, parentAndChildShareLine, sourceFile, options) {
|
|
const useActualIndentation = (isDeclaration(current) || isStatementButNotDeclaration(current)) && (parent2.kind === 308 /* SourceFile */ || !parentAndChildShareLine);
|
|
if (!useActualIndentation) {
|
|
return -1 /* Unknown */;
|
|
}
|
|
return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options);
|
|
}
|
|
let NextTokenKind;
|
|
((NextTokenKind2) => {
|
|
NextTokenKind2[NextTokenKind2["Unknown"] = 0] = "Unknown";
|
|
NextTokenKind2[NextTokenKind2["OpenBrace"] = 1] = "OpenBrace";
|
|
NextTokenKind2[NextTokenKind2["CloseBrace"] = 2] = "CloseBrace";
|
|
})(NextTokenKind || (NextTokenKind = {}));
|
|
function nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile) {
|
|
const nextToken = findNextToken(precedingToken, current, sourceFile);
|
|
if (!nextToken) {
|
|
return 0 /* Unknown */;
|
|
}
|
|
if (nextToken.kind === 18 /* OpenBraceToken */) {
|
|
return 1 /* OpenBrace */;
|
|
} else if (nextToken.kind === 19 /* CloseBraceToken */) {
|
|
const nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line;
|
|
return lineAtPosition === nextTokenStartLine ? 2 /* CloseBrace */ : 0 /* Unknown */;
|
|
}
|
|
return 0 /* Unknown */;
|
|
}
|
|
function getStartLineAndCharacterForNode(n, sourceFile) {
|
|
return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile));
|
|
}
|
|
function isArgumentAndStartLineOverlapsExpressionBeingCalled(parent2, child, childStartLine, sourceFile) {
|
|
if (!(isCallExpression(parent2) && contains(parent2.arguments, child))) {
|
|
return false;
|
|
}
|
|
const expressionOfCallExpressionEnd = parent2.expression.getEnd();
|
|
const expressionOfCallExpressionEndLine = getLineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd).line;
|
|
return expressionOfCallExpressionEndLine === childStartLine;
|
|
}
|
|
SmartIndenter2.isArgumentAndStartLineOverlapsExpressionBeingCalled = isArgumentAndStartLineOverlapsExpressionBeingCalled;
|
|
function childStartsOnTheSameLineWithElseInIfStatement(parent2, child, childStartLine, sourceFile) {
|
|
if (parent2.kind === 242 /* IfStatement */ && parent2.elseStatement === child) {
|
|
const elseKeyword = findChildOfKind(parent2, 91 /* ElseKeyword */, sourceFile);
|
|
Debug.assert(elseKeyword !== void 0);
|
|
const elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line;
|
|
return elseKeywordStartLine === childStartLine;
|
|
}
|
|
return false;
|
|
}
|
|
SmartIndenter2.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement;
|
|
function childIsUnindentedBranchOfConditionalExpression(parent2, child, childStartLine, sourceFile) {
|
|
if (isConditionalExpression(parent2) && (child === parent2.whenTrue || child === parent2.whenFalse)) {
|
|
const conditionEndLine = getLineAndCharacterOfPosition(sourceFile, parent2.condition.end).line;
|
|
if (child === parent2.whenTrue) {
|
|
return childStartLine === conditionEndLine;
|
|
} else {
|
|
const trueStartLine = getStartLineAndCharacterForNode(parent2.whenTrue, sourceFile).line;
|
|
const trueEndLine = getLineAndCharacterOfPosition(sourceFile, parent2.whenTrue.end).line;
|
|
return conditionEndLine === trueStartLine && trueEndLine === childStartLine;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
SmartIndenter2.childIsUnindentedBranchOfConditionalExpression = childIsUnindentedBranchOfConditionalExpression;
|
|
function argumentStartsOnSameLineAsPreviousArgument(parent2, child, childStartLine, sourceFile) {
|
|
if (isCallOrNewExpression(parent2)) {
|
|
if (!parent2.arguments)
|
|
return false;
|
|
const currentNode = find(parent2.arguments, (arg) => arg.pos === child.pos);
|
|
if (!currentNode)
|
|
return false;
|
|
const currentIndex = parent2.arguments.indexOf(currentNode);
|
|
if (currentIndex === 0)
|
|
return false;
|
|
const previousNode = parent2.arguments[currentIndex - 1];
|
|
const lineOfPreviousNode = getLineAndCharacterOfPosition(sourceFile, previousNode.getEnd()).line;
|
|
if (childStartLine === lineOfPreviousNode) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
SmartIndenter2.argumentStartsOnSameLineAsPreviousArgument = argumentStartsOnSameLineAsPreviousArgument;
|
|
function getContainingList(node, sourceFile) {
|
|
return node.parent && getListByRange(node.getStart(sourceFile), node.getEnd(), node.parent, sourceFile);
|
|
}
|
|
SmartIndenter2.getContainingList = getContainingList;
|
|
function getListByPosition(pos, node, sourceFile) {
|
|
return node && getListByRange(pos, pos, node, sourceFile);
|
|
}
|
|
function getListByRange(start2, end, node, sourceFile) {
|
|
switch (node.kind) {
|
|
case 180 /* TypeReference */:
|
|
return getList(node.typeArguments);
|
|
case 207 /* ObjectLiteralExpression */:
|
|
return getList(node.properties);
|
|
case 206 /* ArrayLiteralExpression */:
|
|
return getList(node.elements);
|
|
case 184 /* TypeLiteral */:
|
|
return getList(node.members);
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 216 /* ArrowFunction */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 173 /* Constructor */:
|
|
case 182 /* ConstructorType */:
|
|
case 177 /* ConstructSignature */:
|
|
return getList(node.typeParameters) || getList(node.parameters);
|
|
case 174 /* GetAccessor */:
|
|
return getList(node.parameters);
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 347 /* JSDocTemplateTag */:
|
|
return getList(node.typeParameters);
|
|
case 211 /* NewExpression */:
|
|
case 210 /* CallExpression */:
|
|
return getList(node.typeArguments) || getList(node.arguments);
|
|
case 258 /* VariableDeclarationList */:
|
|
return getList(node.declarations);
|
|
case 272 /* NamedImports */:
|
|
case 276 /* NamedExports */:
|
|
return getList(node.elements);
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
return getList(node.elements);
|
|
}
|
|
function getList(list) {
|
|
return list && rangeContainsStartEnd(getVisualListRange(node, list, sourceFile), start2, end) ? list : void 0;
|
|
}
|
|
}
|
|
function getVisualListRange(node, list, sourceFile) {
|
|
const children = node.getChildren(sourceFile);
|
|
for (let i = 1; i < children.length - 1; i++) {
|
|
if (children[i].pos === list.pos && children[i].end === list.end) {
|
|
return { pos: children[i - 1].end, end: children[i + 1].getStart(sourceFile) };
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
function getActualIndentationForListStartLine(list, sourceFile, options) {
|
|
if (!list) {
|
|
return -1 /* Unknown */;
|
|
}
|
|
return findColumnForFirstNonWhitespaceCharacterInLine(sourceFile.getLineAndCharacterOfPosition(list.pos), sourceFile, options);
|
|
}
|
|
function getActualIndentationForListItem(node, sourceFile, options, listIndentsChild) {
|
|
if (node.parent && node.parent.kind === 258 /* VariableDeclarationList */) {
|
|
return -1 /* Unknown */;
|
|
}
|
|
const containingList = getContainingList(node, sourceFile);
|
|
if (containingList) {
|
|
const index = containingList.indexOf(node);
|
|
if (index !== -1) {
|
|
const result = deriveActualIndentationFromList(containingList, index, sourceFile, options);
|
|
if (result !== -1 /* Unknown */) {
|
|
return result;
|
|
}
|
|
}
|
|
return getActualIndentationForListStartLine(containingList, sourceFile, options) + (listIndentsChild ? options.indentSize : 0);
|
|
}
|
|
return -1 /* Unknown */;
|
|
}
|
|
function deriveActualIndentationFromList(list, index, sourceFile, options) {
|
|
Debug.assert(index >= 0 && index < list.length);
|
|
const node = list[index];
|
|
let lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile);
|
|
for (let i = index - 1; i >= 0; i--) {
|
|
if (list[i].kind === 27 /* CommaToken */) {
|
|
continue;
|
|
}
|
|
const prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line;
|
|
if (prevEndLine !== lineAndCharacter.line) {
|
|
return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options);
|
|
}
|
|
lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile);
|
|
}
|
|
return -1 /* Unknown */;
|
|
}
|
|
function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) {
|
|
const lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0);
|
|
return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);
|
|
}
|
|
function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) {
|
|
let character = 0;
|
|
let column = 0;
|
|
for (let pos = startPos; pos < endPos; pos++) {
|
|
const ch = sourceFile.text.charCodeAt(pos);
|
|
if (!isWhiteSpaceSingleLine(ch)) {
|
|
break;
|
|
}
|
|
if (ch === 9 /* tab */) {
|
|
column += options.tabSize + column % options.tabSize;
|
|
} else {
|
|
column++;
|
|
}
|
|
character++;
|
|
}
|
|
return { column, character };
|
|
}
|
|
SmartIndenter2.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn;
|
|
function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) {
|
|
return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column;
|
|
}
|
|
SmartIndenter2.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn;
|
|
function nodeWillIndentChild(settings, parent2, child, sourceFile, indentByDefault) {
|
|
const childKind = child ? child.kind : 0 /* Unknown */;
|
|
switch (parent2.kind) {
|
|
case 241 /* ExpressionStatement */:
|
|
case 260 /* ClassDeclaration */:
|
|
case 228 /* ClassExpression */:
|
|
case 261 /* InterfaceDeclaration */:
|
|
case 263 /* EnumDeclaration */:
|
|
case 262 /* TypeAliasDeclaration */:
|
|
case 206 /* ArrayLiteralExpression */:
|
|
case 238 /* Block */:
|
|
case 265 /* ModuleBlock */:
|
|
case 207 /* ObjectLiteralExpression */:
|
|
case 184 /* TypeLiteral */:
|
|
case 197 /* MappedType */:
|
|
case 186 /* TupleType */:
|
|
case 266 /* CaseBlock */:
|
|
case 293 /* DefaultClause */:
|
|
case 292 /* CaseClause */:
|
|
case 214 /* ParenthesizedExpression */:
|
|
case 208 /* PropertyAccessExpression */:
|
|
case 210 /* CallExpression */:
|
|
case 211 /* NewExpression */:
|
|
case 240 /* VariableStatement */:
|
|
case 274 /* ExportAssignment */:
|
|
case 250 /* ReturnStatement */:
|
|
case 224 /* ConditionalExpression */:
|
|
case 204 /* ArrayBindingPattern */:
|
|
case 203 /* ObjectBindingPattern */:
|
|
case 283 /* JsxOpeningElement */:
|
|
case 286 /* JsxOpeningFragment */:
|
|
case 282 /* JsxSelfClosingElement */:
|
|
case 291 /* JsxExpression */:
|
|
case 170 /* MethodSignature */:
|
|
case 176 /* CallSignature */:
|
|
case 177 /* ConstructSignature */:
|
|
case 166 /* Parameter */:
|
|
case 181 /* FunctionType */:
|
|
case 182 /* ConstructorType */:
|
|
case 193 /* ParenthesizedType */:
|
|
case 212 /* TaggedTemplateExpression */:
|
|
case 220 /* AwaitExpression */:
|
|
case 276 /* NamedExports */:
|
|
case 272 /* NamedImports */:
|
|
case 278 /* ExportSpecifier */:
|
|
case 273 /* ImportSpecifier */:
|
|
case 169 /* PropertyDeclaration */:
|
|
return true;
|
|
case 257 /* VariableDeclaration */:
|
|
case 299 /* PropertyAssignment */:
|
|
case 223 /* BinaryExpression */:
|
|
if (!settings.indentMultiLineObjectLiteralBeginningOnBlankLine && sourceFile && childKind === 207 /* ObjectLiteralExpression */) {
|
|
return rangeIsOnOneLine(sourceFile, child);
|
|
}
|
|
if (parent2.kind === 223 /* BinaryExpression */ && sourceFile && child && childKind === 281 /* JsxElement */) {
|
|
const parentStartLine = sourceFile.getLineAndCharacterOfPosition(skipTrivia(sourceFile.text, parent2.pos)).line;
|
|
const childStartLine = sourceFile.getLineAndCharacterOfPosition(skipTrivia(sourceFile.text, child.pos)).line;
|
|
return parentStartLine !== childStartLine;
|
|
}
|
|
if (parent2.kind !== 223 /* BinaryExpression */) {
|
|
return true;
|
|
}
|
|
break;
|
|
case 243 /* DoStatement */:
|
|
case 244 /* WhileStatement */:
|
|
case 246 /* ForInStatement */:
|
|
case 247 /* ForOfStatement */:
|
|
case 245 /* ForStatement */:
|
|
case 242 /* IfStatement */:
|
|
case 259 /* FunctionDeclaration */:
|
|
case 215 /* FunctionExpression */:
|
|
case 171 /* MethodDeclaration */:
|
|
case 173 /* Constructor */:
|
|
case 174 /* GetAccessor */:
|
|
case 175 /* SetAccessor */:
|
|
return childKind !== 238 /* Block */;
|
|
case 216 /* ArrowFunction */:
|
|
if (sourceFile && childKind === 214 /* ParenthesizedExpression */) {
|
|
return rangeIsOnOneLine(sourceFile, child);
|
|
}
|
|
return childKind !== 238 /* Block */;
|
|
case 275 /* ExportDeclaration */:
|
|
return childKind !== 276 /* NamedExports */;
|
|
case 269 /* ImportDeclaration */:
|
|
return childKind !== 270 /* ImportClause */ || !!child.namedBindings && child.namedBindings.kind !== 272 /* NamedImports */;
|
|
case 281 /* JsxElement */:
|
|
return childKind !== 284 /* JsxClosingElement */;
|
|
case 285 /* JsxFragment */:
|
|
return childKind !== 287 /* JsxClosingFragment */;
|
|
case 190 /* IntersectionType */:
|
|
case 189 /* UnionType */:
|
|
if (childKind === 184 /* TypeLiteral */ || childKind === 186 /* TupleType */) {
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
return indentByDefault;
|
|
}
|
|
SmartIndenter2.nodeWillIndentChild = nodeWillIndentChild;
|
|
function isControlFlowEndingStatement(kind, parent2) {
|
|
switch (kind) {
|
|
case 250 /* ReturnStatement */:
|
|
case 254 /* ThrowStatement */:
|
|
case 248 /* ContinueStatement */:
|
|
case 249 /* BreakStatement */:
|
|
return parent2.kind !== 238 /* Block */;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
function shouldIndentChildNode(settings, parent2, child, sourceFile, isNextChild = false) {
|
|
return nodeWillIndentChild(settings, parent2, child, sourceFile, false) && !(isNextChild && child && isControlFlowEndingStatement(child.kind, parent2));
|
|
}
|
|
SmartIndenter2.shouldIndentChildNode = shouldIndentChildNode;
|
|
function rangeIsOnOneLine(sourceFile, range) {
|
|
const rangeStart = skipTrivia(sourceFile.text, range.pos);
|
|
const startLine = sourceFile.getLineAndCharacterOfPosition(rangeStart).line;
|
|
const endLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
|
|
return startLine === endLine;
|
|
}
|
|
})(SmartIndenter || (SmartIndenter = {}));
|
|
|
|
// src/deprecatedCompat/deprecate.ts
|
|
var enableDeprecationWarnings = true;
|
|
var typeScriptVersion2;
|
|
function getTypeScriptVersion() {
|
|
return typeScriptVersion2 != null ? typeScriptVersion2 : typeScriptVersion2 = new Version(version);
|
|
}
|
|
function formatDeprecationMessage(name, error, errorAfter, since, message) {
|
|
let deprecationMessage = error ? "DeprecationError: " : "DeprecationWarning: ";
|
|
deprecationMessage += `'${name}' `;
|
|
deprecationMessage += since ? `has been deprecated since v${since}` : "is deprecated";
|
|
deprecationMessage += error ? " and can no longer be used." : errorAfter ? ` and will no longer be usable after v${errorAfter}.` : ".";
|
|
deprecationMessage += message ? ` ${formatStringFromArgs(message, [name], 0)}` : "";
|
|
return deprecationMessage;
|
|
}
|
|
function createErrorDeprecation(name, errorAfter, since, message) {
|
|
const deprecationMessage = formatDeprecationMessage(name, true, errorAfter, since, message);
|
|
return () => {
|
|
throw new TypeError(deprecationMessage);
|
|
};
|
|
}
|
|
function createWarningDeprecation(name, errorAfter, since, message) {
|
|
let hasWrittenDeprecation = false;
|
|
return () => {
|
|
if (enableDeprecationWarnings && !hasWrittenDeprecation) {
|
|
Debug.log.warn(formatDeprecationMessage(name, false, errorAfter, since, message));
|
|
hasWrittenDeprecation = true;
|
|
}
|
|
};
|
|
}
|
|
function createDeprecation(name, options = {}) {
|
|
var _a2, _b;
|
|
const version2 = typeof options.typeScriptVersion === "string" ? new Version(options.typeScriptVersion) : (_a2 = options.typeScriptVersion) != null ? _a2 : getTypeScriptVersion();
|
|
const errorAfter = typeof options.errorAfter === "string" ? new Version(options.errorAfter) : options.errorAfter;
|
|
const warnAfter = typeof options.warnAfter === "string" ? new Version(options.warnAfter) : options.warnAfter;
|
|
const since = typeof options.since === "string" ? new Version(options.since) : (_b = options.since) != null ? _b : warnAfter;
|
|
const error = options.error || errorAfter && version2.compareTo(errorAfter) <= 0;
|
|
const warn = !warnAfter || version2.compareTo(warnAfter) >= 0;
|
|
return error ? createErrorDeprecation(name, errorAfter, since, options.message) : warn ? createWarningDeprecation(name, errorAfter, since, options.message) : noop;
|
|
}
|
|
function wrapFunction(deprecation, func) {
|
|
return function() {
|
|
deprecation();
|
|
return func.apply(this, arguments);
|
|
};
|
|
}
|
|
function deprecate(func, options) {
|
|
var _a2;
|
|
const deprecation = createDeprecation((_a2 = options == null ? void 0 : options.name) != null ? _a2 : Debug.getFunctionName(func), options);
|
|
return wrapFunction(deprecation, func);
|
|
}
|
|
|
|
// src/deprecatedCompat/deprecations.ts
|
|
function createOverload(name, overloads, binder2, deprecations) {
|
|
Object.defineProperty(call, "name", { ...Object.getOwnPropertyDescriptor(call, "name"), value: name });
|
|
if (deprecations) {
|
|
for (const key of Object.keys(deprecations)) {
|
|
const index = +key;
|
|
if (!isNaN(index) && hasProperty(overloads, `${index}`)) {
|
|
overloads[index] = deprecate(overloads[index], { ...deprecations[index], name });
|
|
}
|
|
}
|
|
}
|
|
const bind = createBinder2(overloads, binder2);
|
|
return call;
|
|
function call(...args) {
|
|
const index = bind(args);
|
|
const fn = index !== void 0 ? overloads[index] : void 0;
|
|
if (typeof fn === "function") {
|
|
return fn(...args);
|
|
}
|
|
throw new TypeError("Invalid arguments");
|
|
}
|
|
}
|
|
function createBinder2(overloads, binder2) {
|
|
return (args) => {
|
|
for (let i = 0; hasProperty(overloads, `${i}`) && hasProperty(binder2, `${i}`); i++) {
|
|
const fn = binder2[i];
|
|
if (fn(args)) {
|
|
return i;
|
|
}
|
|
}
|
|
};
|
|
}
|
|
function buildOverload(name) {
|
|
return {
|
|
overload: (overloads) => ({
|
|
bind: (binder2) => ({
|
|
finish: () => createOverload(name, overloads, binder2),
|
|
deprecate: (deprecations) => ({
|
|
finish: () => createOverload(name, overloads, binder2, deprecations)
|
|
})
|
|
})
|
|
})
|
|
};
|
|
}
|
|
|
|
// src/deprecatedCompat/4.0/nodeFactoryTopLevelExports.ts
|
|
var factoryDeprecation = { since: "4.0", warnAfter: "4.1", message: "Use the appropriate method on 'ts.factory' or the 'factory' supplied by your transformation context instead." };
|
|
var createNodeArray = deprecate(factory.createNodeArray, factoryDeprecation);
|
|
var createNumericLiteral = deprecate(factory.createNumericLiteral, factoryDeprecation);
|
|
var createBigIntLiteral = deprecate(factory.createBigIntLiteral, factoryDeprecation);
|
|
var createStringLiteral = deprecate(factory.createStringLiteral, factoryDeprecation);
|
|
var createStringLiteralFromNode = deprecate(factory.createStringLiteralFromNode, factoryDeprecation);
|
|
var createRegularExpressionLiteral = deprecate(factory.createRegularExpressionLiteral, factoryDeprecation);
|
|
var createLoopVariable = deprecate(factory.createLoopVariable, factoryDeprecation);
|
|
var createUniqueName = deprecate(factory.createUniqueName, factoryDeprecation);
|
|
var createPrivateIdentifier = deprecate(factory.createPrivateIdentifier, factoryDeprecation);
|
|
var createSuper = deprecate(factory.createSuper, factoryDeprecation);
|
|
var createThis = deprecate(factory.createThis, factoryDeprecation);
|
|
var createNull = deprecate(factory.createNull, factoryDeprecation);
|
|
var createTrue = deprecate(factory.createTrue, factoryDeprecation);
|
|
var createFalse = deprecate(factory.createFalse, factoryDeprecation);
|
|
var createModifier = deprecate(factory.createModifier, factoryDeprecation);
|
|
var createModifiersFromModifierFlags = deprecate(factory.createModifiersFromModifierFlags, factoryDeprecation);
|
|
var createQualifiedName = deprecate(factory.createQualifiedName, factoryDeprecation);
|
|
var updateQualifiedName = deprecate(factory.updateQualifiedName, factoryDeprecation);
|
|
var createComputedPropertyName = deprecate(factory.createComputedPropertyName, factoryDeprecation);
|
|
var updateComputedPropertyName = deprecate(factory.updateComputedPropertyName, factoryDeprecation);
|
|
var createTypeParameterDeclaration = deprecate(factory.createTypeParameterDeclaration, factoryDeprecation);
|
|
var updateTypeParameterDeclaration = deprecate(factory.updateTypeParameterDeclaration, factoryDeprecation);
|
|
var createParameter = deprecate(factory.createParameterDeclaration, factoryDeprecation);
|
|
var updateParameter = deprecate(factory.updateParameterDeclaration, factoryDeprecation);
|
|
var createDecorator = deprecate(factory.createDecorator, factoryDeprecation);
|
|
var updateDecorator = deprecate(factory.updateDecorator, factoryDeprecation);
|
|
var createProperty = deprecate(factory.createPropertyDeclaration, factoryDeprecation);
|
|
var updateProperty = deprecate(factory.updatePropertyDeclaration, factoryDeprecation);
|
|
var createMethod = deprecate(factory.createMethodDeclaration, factoryDeprecation);
|
|
var updateMethod = deprecate(factory.updateMethodDeclaration, factoryDeprecation);
|
|
var createConstructor = deprecate(factory.createConstructorDeclaration, factoryDeprecation);
|
|
var updateConstructor = deprecate(factory.updateConstructorDeclaration, factoryDeprecation);
|
|
var createGetAccessor = deprecate(factory.createGetAccessorDeclaration, factoryDeprecation);
|
|
var updateGetAccessor = deprecate(factory.updateGetAccessorDeclaration, factoryDeprecation);
|
|
var createSetAccessor = deprecate(factory.createSetAccessorDeclaration, factoryDeprecation);
|
|
var updateSetAccessor = deprecate(factory.updateSetAccessorDeclaration, factoryDeprecation);
|
|
var createCallSignature = deprecate(factory.createCallSignature, factoryDeprecation);
|
|
var updateCallSignature = deprecate(factory.updateCallSignature, factoryDeprecation);
|
|
var createConstructSignature = deprecate(factory.createConstructSignature, factoryDeprecation);
|
|
var updateConstructSignature = deprecate(factory.updateConstructSignature, factoryDeprecation);
|
|
var updateIndexSignature = deprecate(factory.updateIndexSignature, factoryDeprecation);
|
|
var createKeywordTypeNode = deprecate(factory.createKeywordTypeNode, factoryDeprecation);
|
|
var createTypePredicateNodeWithModifier = deprecate(factory.createTypePredicateNode, factoryDeprecation);
|
|
var updateTypePredicateNodeWithModifier = deprecate(factory.updateTypePredicateNode, factoryDeprecation);
|
|
var createTypeReferenceNode = deprecate(factory.createTypeReferenceNode, factoryDeprecation);
|
|
var updateTypeReferenceNode = deprecate(factory.updateTypeReferenceNode, factoryDeprecation);
|
|
var createFunctionTypeNode = deprecate(factory.createFunctionTypeNode, factoryDeprecation);
|
|
var updateFunctionTypeNode = deprecate(factory.updateFunctionTypeNode, factoryDeprecation);
|
|
var createConstructorTypeNode = deprecate((typeParameters, parameters, type) => {
|
|
return factory.createConstructorTypeNode(void 0, typeParameters, parameters, type);
|
|
}, factoryDeprecation);
|
|
var updateConstructorTypeNode = deprecate((node, typeParameters, parameters, type) => {
|
|
return factory.updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type);
|
|
}, factoryDeprecation);
|
|
var createTypeQueryNode = deprecate(factory.createTypeQueryNode, factoryDeprecation);
|
|
var updateTypeQueryNode = deprecate(factory.updateTypeQueryNode, factoryDeprecation);
|
|
var createTypeLiteralNode = deprecate(factory.createTypeLiteralNode, factoryDeprecation);
|
|
var updateTypeLiteralNode = deprecate(factory.updateTypeLiteralNode, factoryDeprecation);
|
|
var createArrayTypeNode = deprecate(factory.createArrayTypeNode, factoryDeprecation);
|
|
var updateArrayTypeNode = deprecate(factory.updateArrayTypeNode, factoryDeprecation);
|
|
var createTupleTypeNode = deprecate(factory.createTupleTypeNode, factoryDeprecation);
|
|
var updateTupleTypeNode = deprecate(factory.updateTupleTypeNode, factoryDeprecation);
|
|
var createOptionalTypeNode = deprecate(factory.createOptionalTypeNode, factoryDeprecation);
|
|
var updateOptionalTypeNode = deprecate(factory.updateOptionalTypeNode, factoryDeprecation);
|
|
var createRestTypeNode = deprecate(factory.createRestTypeNode, factoryDeprecation);
|
|
var updateRestTypeNode = deprecate(factory.updateRestTypeNode, factoryDeprecation);
|
|
var createUnionTypeNode = deprecate(factory.createUnionTypeNode, factoryDeprecation);
|
|
var updateUnionTypeNode = deprecate(factory.updateUnionTypeNode, factoryDeprecation);
|
|
var createIntersectionTypeNode = deprecate(factory.createIntersectionTypeNode, factoryDeprecation);
|
|
var updateIntersectionTypeNode = deprecate(factory.updateIntersectionTypeNode, factoryDeprecation);
|
|
var createConditionalTypeNode = deprecate(factory.createConditionalTypeNode, factoryDeprecation);
|
|
var updateConditionalTypeNode = deprecate(factory.updateConditionalTypeNode, factoryDeprecation);
|
|
var createInferTypeNode = deprecate(factory.createInferTypeNode, factoryDeprecation);
|
|
var updateInferTypeNode = deprecate(factory.updateInferTypeNode, factoryDeprecation);
|
|
var createImportTypeNode = deprecate(factory.createImportTypeNode, factoryDeprecation);
|
|
var updateImportTypeNode = deprecate(factory.updateImportTypeNode, factoryDeprecation);
|
|
var createParenthesizedType = deprecate(factory.createParenthesizedType, factoryDeprecation);
|
|
var updateParenthesizedType = deprecate(factory.updateParenthesizedType, factoryDeprecation);
|
|
var createThisTypeNode = deprecate(factory.createThisTypeNode, factoryDeprecation);
|
|
var updateTypeOperatorNode = deprecate(factory.updateTypeOperatorNode, factoryDeprecation);
|
|
var createIndexedAccessTypeNode = deprecate(factory.createIndexedAccessTypeNode, factoryDeprecation);
|
|
var updateIndexedAccessTypeNode = deprecate(factory.updateIndexedAccessTypeNode, factoryDeprecation);
|
|
var createMappedTypeNode = deprecate(factory.createMappedTypeNode, factoryDeprecation);
|
|
var updateMappedTypeNode = deprecate(factory.updateMappedTypeNode, factoryDeprecation);
|
|
var createLiteralTypeNode = deprecate(factory.createLiteralTypeNode, factoryDeprecation);
|
|
var updateLiteralTypeNode = deprecate(factory.updateLiteralTypeNode, factoryDeprecation);
|
|
var createObjectBindingPattern = deprecate(factory.createObjectBindingPattern, factoryDeprecation);
|
|
var updateObjectBindingPattern = deprecate(factory.updateObjectBindingPattern, factoryDeprecation);
|
|
var createArrayBindingPattern = deprecate(factory.createArrayBindingPattern, factoryDeprecation);
|
|
var updateArrayBindingPattern = deprecate(factory.updateArrayBindingPattern, factoryDeprecation);
|
|
var createBindingElement = deprecate(factory.createBindingElement, factoryDeprecation);
|
|
var updateBindingElement = deprecate(factory.updateBindingElement, factoryDeprecation);
|
|
var createArrayLiteral = deprecate(factory.createArrayLiteralExpression, factoryDeprecation);
|
|
var updateArrayLiteral = deprecate(factory.updateArrayLiteralExpression, factoryDeprecation);
|
|
var createObjectLiteral = deprecate(factory.createObjectLiteralExpression, factoryDeprecation);
|
|
var updateObjectLiteral = deprecate(factory.updateObjectLiteralExpression, factoryDeprecation);
|
|
var createPropertyAccess = deprecate(factory.createPropertyAccessExpression, factoryDeprecation);
|
|
var updatePropertyAccess = deprecate(factory.updatePropertyAccessExpression, factoryDeprecation);
|
|
var createPropertyAccessChain = deprecate(factory.createPropertyAccessChain, factoryDeprecation);
|
|
var updatePropertyAccessChain = deprecate(factory.updatePropertyAccessChain, factoryDeprecation);
|
|
var createElementAccess = deprecate(factory.createElementAccessExpression, factoryDeprecation);
|
|
var updateElementAccess = deprecate(factory.updateElementAccessExpression, factoryDeprecation);
|
|
var createElementAccessChain = deprecate(factory.createElementAccessChain, factoryDeprecation);
|
|
var updateElementAccessChain = deprecate(factory.updateElementAccessChain, factoryDeprecation);
|
|
var createCall = deprecate(factory.createCallExpression, factoryDeprecation);
|
|
var updateCall = deprecate(factory.updateCallExpression, factoryDeprecation);
|
|
var createCallChain = deprecate(factory.createCallChain, factoryDeprecation);
|
|
var updateCallChain = deprecate(factory.updateCallChain, factoryDeprecation);
|
|
var createNew = deprecate(factory.createNewExpression, factoryDeprecation);
|
|
var updateNew = deprecate(factory.updateNewExpression, factoryDeprecation);
|
|
var createTypeAssertion = deprecate(factory.createTypeAssertion, factoryDeprecation);
|
|
var updateTypeAssertion = deprecate(factory.updateTypeAssertion, factoryDeprecation);
|
|
var createParen = deprecate(factory.createParenthesizedExpression, factoryDeprecation);
|
|
var updateParen = deprecate(factory.updateParenthesizedExpression, factoryDeprecation);
|
|
var createFunctionExpression = deprecate(factory.createFunctionExpression, factoryDeprecation);
|
|
var updateFunctionExpression = deprecate(factory.updateFunctionExpression, factoryDeprecation);
|
|
var createDelete = deprecate(factory.createDeleteExpression, factoryDeprecation);
|
|
var updateDelete = deprecate(factory.updateDeleteExpression, factoryDeprecation);
|
|
var createTypeOf = deprecate(factory.createTypeOfExpression, factoryDeprecation);
|
|
var updateTypeOf = deprecate(factory.updateTypeOfExpression, factoryDeprecation);
|
|
var createVoid = deprecate(factory.createVoidExpression, factoryDeprecation);
|
|
var updateVoid = deprecate(factory.updateVoidExpression, factoryDeprecation);
|
|
var createAwait = deprecate(factory.createAwaitExpression, factoryDeprecation);
|
|
var updateAwait = deprecate(factory.updateAwaitExpression, factoryDeprecation);
|
|
var createPrefix = deprecate(factory.createPrefixUnaryExpression, factoryDeprecation);
|
|
var updatePrefix = deprecate(factory.updatePrefixUnaryExpression, factoryDeprecation);
|
|
var createPostfix = deprecate(factory.createPostfixUnaryExpression, factoryDeprecation);
|
|
var updatePostfix = deprecate(factory.updatePostfixUnaryExpression, factoryDeprecation);
|
|
var createBinary = deprecate(factory.createBinaryExpression, factoryDeprecation);
|
|
var updateConditional = deprecate(factory.updateConditionalExpression, factoryDeprecation);
|
|
var createTemplateExpression = deprecate(factory.createTemplateExpression, factoryDeprecation);
|
|
var updateTemplateExpression = deprecate(factory.updateTemplateExpression, factoryDeprecation);
|
|
var createTemplateHead = deprecate(factory.createTemplateHead, factoryDeprecation);
|
|
var createTemplateMiddle = deprecate(factory.createTemplateMiddle, factoryDeprecation);
|
|
var createTemplateTail = deprecate(factory.createTemplateTail, factoryDeprecation);
|
|
var createNoSubstitutionTemplateLiteral = deprecate(factory.createNoSubstitutionTemplateLiteral, factoryDeprecation);
|
|
var updateYield = deprecate(factory.updateYieldExpression, factoryDeprecation);
|
|
var createSpread = deprecate(factory.createSpreadElement, factoryDeprecation);
|
|
var updateSpread = deprecate(factory.updateSpreadElement, factoryDeprecation);
|
|
var createOmittedExpression = deprecate(factory.createOmittedExpression, factoryDeprecation);
|
|
var createAsExpression = deprecate(factory.createAsExpression, factoryDeprecation);
|
|
var updateAsExpression = deprecate(factory.updateAsExpression, factoryDeprecation);
|
|
var createNonNullExpression = deprecate(factory.createNonNullExpression, factoryDeprecation);
|
|
var updateNonNullExpression = deprecate(factory.updateNonNullExpression, factoryDeprecation);
|
|
var createNonNullChain = deprecate(factory.createNonNullChain, factoryDeprecation);
|
|
var updateNonNullChain = deprecate(factory.updateNonNullChain, factoryDeprecation);
|
|
var createMetaProperty = deprecate(factory.createMetaProperty, factoryDeprecation);
|
|
var updateMetaProperty = deprecate(factory.updateMetaProperty, factoryDeprecation);
|
|
var createTemplateSpan = deprecate(factory.createTemplateSpan, factoryDeprecation);
|
|
var updateTemplateSpan = deprecate(factory.updateTemplateSpan, factoryDeprecation);
|
|
var createSemicolonClassElement = deprecate(factory.createSemicolonClassElement, factoryDeprecation);
|
|
var createBlock = deprecate(factory.createBlock, factoryDeprecation);
|
|
var updateBlock = deprecate(factory.updateBlock, factoryDeprecation);
|
|
var createVariableStatement = deprecate(factory.createVariableStatement, factoryDeprecation);
|
|
var updateVariableStatement = deprecate(factory.updateVariableStatement, factoryDeprecation);
|
|
var createEmptyStatement = deprecate(factory.createEmptyStatement, factoryDeprecation);
|
|
var createExpressionStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
|
|
var updateExpressionStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
|
|
var createStatement = deprecate(factory.createExpressionStatement, factoryDeprecation);
|
|
var updateStatement = deprecate(factory.updateExpressionStatement, factoryDeprecation);
|
|
var createIf = deprecate(factory.createIfStatement, factoryDeprecation);
|
|
var updateIf = deprecate(factory.updateIfStatement, factoryDeprecation);
|
|
var createDo = deprecate(factory.createDoStatement, factoryDeprecation);
|
|
var updateDo = deprecate(factory.updateDoStatement, factoryDeprecation);
|
|
var createWhile = deprecate(factory.createWhileStatement, factoryDeprecation);
|
|
var updateWhile = deprecate(factory.updateWhileStatement, factoryDeprecation);
|
|
var createFor = deprecate(factory.createForStatement, factoryDeprecation);
|
|
var updateFor = deprecate(factory.updateForStatement, factoryDeprecation);
|
|
var createForIn = deprecate(factory.createForInStatement, factoryDeprecation);
|
|
var updateForIn = deprecate(factory.updateForInStatement, factoryDeprecation);
|
|
var createForOf = deprecate(factory.createForOfStatement, factoryDeprecation);
|
|
var updateForOf = deprecate(factory.updateForOfStatement, factoryDeprecation);
|
|
var createContinue = deprecate(factory.createContinueStatement, factoryDeprecation);
|
|
var updateContinue = deprecate(factory.updateContinueStatement, factoryDeprecation);
|
|
var createBreak = deprecate(factory.createBreakStatement, factoryDeprecation);
|
|
var updateBreak = deprecate(factory.updateBreakStatement, factoryDeprecation);
|
|
var createReturn = deprecate(factory.createReturnStatement, factoryDeprecation);
|
|
var updateReturn = deprecate(factory.updateReturnStatement, factoryDeprecation);
|
|
var createWith = deprecate(factory.createWithStatement, factoryDeprecation);
|
|
var updateWith = deprecate(factory.updateWithStatement, factoryDeprecation);
|
|
var createSwitch = deprecate(factory.createSwitchStatement, factoryDeprecation);
|
|
var updateSwitch = deprecate(factory.updateSwitchStatement, factoryDeprecation);
|
|
var createLabel = deprecate(factory.createLabeledStatement, factoryDeprecation);
|
|
var updateLabel = deprecate(factory.updateLabeledStatement, factoryDeprecation);
|
|
var createThrow = deprecate(factory.createThrowStatement, factoryDeprecation);
|
|
var updateThrow = deprecate(factory.updateThrowStatement, factoryDeprecation);
|
|
var createTry = deprecate(factory.createTryStatement, factoryDeprecation);
|
|
var updateTry = deprecate(factory.updateTryStatement, factoryDeprecation);
|
|
var createDebuggerStatement = deprecate(factory.createDebuggerStatement, factoryDeprecation);
|
|
var createVariableDeclarationList = deprecate(factory.createVariableDeclarationList, factoryDeprecation);
|
|
var updateVariableDeclarationList = deprecate(factory.updateVariableDeclarationList, factoryDeprecation);
|
|
var createFunctionDeclaration = deprecate(factory.createFunctionDeclaration, factoryDeprecation);
|
|
var updateFunctionDeclaration = deprecate(factory.updateFunctionDeclaration, factoryDeprecation);
|
|
var createClassDeclaration = deprecate(factory.createClassDeclaration, factoryDeprecation);
|
|
var updateClassDeclaration = deprecate(factory.updateClassDeclaration, factoryDeprecation);
|
|
var createInterfaceDeclaration = deprecate(factory.createInterfaceDeclaration, factoryDeprecation);
|
|
var updateInterfaceDeclaration = deprecate(factory.updateInterfaceDeclaration, factoryDeprecation);
|
|
var createTypeAliasDeclaration = deprecate(factory.createTypeAliasDeclaration, factoryDeprecation);
|
|
var updateTypeAliasDeclaration = deprecate(factory.updateTypeAliasDeclaration, factoryDeprecation);
|
|
var createEnumDeclaration = deprecate(factory.createEnumDeclaration, factoryDeprecation);
|
|
var updateEnumDeclaration = deprecate(factory.updateEnumDeclaration, factoryDeprecation);
|
|
var createModuleDeclaration = deprecate(factory.createModuleDeclaration, factoryDeprecation);
|
|
var updateModuleDeclaration = deprecate(factory.updateModuleDeclaration, factoryDeprecation);
|
|
var createModuleBlock = deprecate(factory.createModuleBlock, factoryDeprecation);
|
|
var updateModuleBlock = deprecate(factory.updateModuleBlock, factoryDeprecation);
|
|
var createCaseBlock = deprecate(factory.createCaseBlock, factoryDeprecation);
|
|
var updateCaseBlock = deprecate(factory.updateCaseBlock, factoryDeprecation);
|
|
var createNamespaceExportDeclaration = deprecate(factory.createNamespaceExportDeclaration, factoryDeprecation);
|
|
var updateNamespaceExportDeclaration = deprecate(factory.updateNamespaceExportDeclaration, factoryDeprecation);
|
|
var createImportEqualsDeclaration = deprecate(factory.createImportEqualsDeclaration, factoryDeprecation);
|
|
var updateImportEqualsDeclaration = deprecate(factory.updateImportEqualsDeclaration, factoryDeprecation);
|
|
var createImportDeclaration = deprecate(factory.createImportDeclaration, factoryDeprecation);
|
|
var updateImportDeclaration = deprecate(factory.updateImportDeclaration, factoryDeprecation);
|
|
var createNamespaceImport = deprecate(factory.createNamespaceImport, factoryDeprecation);
|
|
var updateNamespaceImport = deprecate(factory.updateNamespaceImport, factoryDeprecation);
|
|
var createNamedImports = deprecate(factory.createNamedImports, factoryDeprecation);
|
|
var updateNamedImports = deprecate(factory.updateNamedImports, factoryDeprecation);
|
|
var createImportSpecifier = deprecate(factory.createImportSpecifier, factoryDeprecation);
|
|
var updateImportSpecifier = deprecate(factory.updateImportSpecifier, factoryDeprecation);
|
|
var createExportAssignment2 = deprecate(factory.createExportAssignment, factoryDeprecation);
|
|
var updateExportAssignment = deprecate(factory.updateExportAssignment, factoryDeprecation);
|
|
var createNamedExports = deprecate(factory.createNamedExports, factoryDeprecation);
|
|
var updateNamedExports = deprecate(factory.updateNamedExports, factoryDeprecation);
|
|
var createExportSpecifier = deprecate(factory.createExportSpecifier, factoryDeprecation);
|
|
var updateExportSpecifier = deprecate(factory.updateExportSpecifier, factoryDeprecation);
|
|
var createExternalModuleReference = deprecate(factory.createExternalModuleReference, factoryDeprecation);
|
|
var updateExternalModuleReference = deprecate(factory.updateExternalModuleReference, factoryDeprecation);
|
|
var createJSDocTypeExpression = deprecate(factory.createJSDocTypeExpression, factoryDeprecation);
|
|
var createJSDocTypeTag = deprecate(factory.createJSDocTypeTag, factoryDeprecation);
|
|
var createJSDocReturnTag = deprecate(factory.createJSDocReturnTag, factoryDeprecation);
|
|
var createJSDocThisTag = deprecate(factory.createJSDocThisTag, factoryDeprecation);
|
|
var createJSDocComment = deprecate(factory.createJSDocComment, factoryDeprecation);
|
|
var createJSDocParameterTag = deprecate(factory.createJSDocParameterTag, factoryDeprecation);
|
|
var createJSDocClassTag = deprecate(factory.createJSDocClassTag, factoryDeprecation);
|
|
var createJSDocAugmentsTag = deprecate(factory.createJSDocAugmentsTag, factoryDeprecation);
|
|
var createJSDocEnumTag = deprecate(factory.createJSDocEnumTag, factoryDeprecation);
|
|
var createJSDocTemplateTag = deprecate(factory.createJSDocTemplateTag, factoryDeprecation);
|
|
var createJSDocTypedefTag = deprecate(factory.createJSDocTypedefTag, factoryDeprecation);
|
|
var createJSDocCallbackTag = deprecate(factory.createJSDocCallbackTag, factoryDeprecation);
|
|
var createJSDocSignature = deprecate(factory.createJSDocSignature, factoryDeprecation);
|
|
var createJSDocPropertyTag = deprecate(factory.createJSDocPropertyTag, factoryDeprecation);
|
|
var createJSDocTypeLiteral = deprecate(factory.createJSDocTypeLiteral, factoryDeprecation);
|
|
var createJSDocImplementsTag = deprecate(factory.createJSDocImplementsTag, factoryDeprecation);
|
|
var createJSDocAuthorTag = deprecate(factory.createJSDocAuthorTag, factoryDeprecation);
|
|
var createJSDocPublicTag = deprecate(factory.createJSDocPublicTag, factoryDeprecation);
|
|
var createJSDocPrivateTag = deprecate(factory.createJSDocPrivateTag, factoryDeprecation);
|
|
var createJSDocProtectedTag = deprecate(factory.createJSDocProtectedTag, factoryDeprecation);
|
|
var createJSDocReadonlyTag = deprecate(factory.createJSDocReadonlyTag, factoryDeprecation);
|
|
var createJSDocTag = deprecate(factory.createJSDocUnknownTag, factoryDeprecation);
|
|
var createJsxElement = deprecate(factory.createJsxElement, factoryDeprecation);
|
|
var updateJsxElement = deprecate(factory.updateJsxElement, factoryDeprecation);
|
|
var createJsxSelfClosingElement = deprecate(factory.createJsxSelfClosingElement, factoryDeprecation);
|
|
var updateJsxSelfClosingElement = deprecate(factory.updateJsxSelfClosingElement, factoryDeprecation);
|
|
var createJsxOpeningElement = deprecate(factory.createJsxOpeningElement, factoryDeprecation);
|
|
var updateJsxOpeningElement = deprecate(factory.updateJsxOpeningElement, factoryDeprecation);
|
|
var createJsxClosingElement = deprecate(factory.createJsxClosingElement, factoryDeprecation);
|
|
var updateJsxClosingElement = deprecate(factory.updateJsxClosingElement, factoryDeprecation);
|
|
var createJsxFragment = deprecate(factory.createJsxFragment, factoryDeprecation);
|
|
var createJsxText = deprecate(factory.createJsxText, factoryDeprecation);
|
|
var updateJsxText = deprecate(factory.updateJsxText, factoryDeprecation);
|
|
var createJsxOpeningFragment = deprecate(factory.createJsxOpeningFragment, factoryDeprecation);
|
|
var createJsxJsxClosingFragment = deprecate(factory.createJsxJsxClosingFragment, factoryDeprecation);
|
|
var updateJsxFragment = deprecate(factory.updateJsxFragment, factoryDeprecation);
|
|
var createJsxAttribute = deprecate(factory.createJsxAttribute, factoryDeprecation);
|
|
var updateJsxAttribute = deprecate(factory.updateJsxAttribute, factoryDeprecation);
|
|
var createJsxAttributes = deprecate(factory.createJsxAttributes, factoryDeprecation);
|
|
var updateJsxAttributes = deprecate(factory.updateJsxAttributes, factoryDeprecation);
|
|
var createJsxSpreadAttribute = deprecate(factory.createJsxSpreadAttribute, factoryDeprecation);
|
|
var updateJsxSpreadAttribute = deprecate(factory.updateJsxSpreadAttribute, factoryDeprecation);
|
|
var createJsxExpression = deprecate(factory.createJsxExpression, factoryDeprecation);
|
|
var updateJsxExpression = deprecate(factory.updateJsxExpression, factoryDeprecation);
|
|
var createCaseClause = deprecate(factory.createCaseClause, factoryDeprecation);
|
|
var updateCaseClause = deprecate(factory.updateCaseClause, factoryDeprecation);
|
|
var createDefaultClause = deprecate(factory.createDefaultClause, factoryDeprecation);
|
|
var updateDefaultClause = deprecate(factory.updateDefaultClause, factoryDeprecation);
|
|
var createHeritageClause = deprecate(factory.createHeritageClause, factoryDeprecation);
|
|
var updateHeritageClause = deprecate(factory.updateHeritageClause, factoryDeprecation);
|
|
var createCatchClause = deprecate(factory.createCatchClause, factoryDeprecation);
|
|
var updateCatchClause = deprecate(factory.updateCatchClause, factoryDeprecation);
|
|
var createPropertyAssignment = deprecate(factory.createPropertyAssignment, factoryDeprecation);
|
|
var updatePropertyAssignment = deprecate(factory.updatePropertyAssignment, factoryDeprecation);
|
|
var createShorthandPropertyAssignment = deprecate(factory.createShorthandPropertyAssignment, factoryDeprecation);
|
|
var updateShorthandPropertyAssignment = deprecate(factory.updateShorthandPropertyAssignment, factoryDeprecation);
|
|
var createSpreadAssignment = deprecate(factory.createSpreadAssignment, factoryDeprecation);
|
|
var updateSpreadAssignment = deprecate(factory.updateSpreadAssignment, factoryDeprecation);
|
|
var createEnumMember = deprecate(factory.createEnumMember, factoryDeprecation);
|
|
var updateEnumMember = deprecate(factory.updateEnumMember, factoryDeprecation);
|
|
var updateSourceFileNode = deprecate(factory.updateSourceFile, factoryDeprecation);
|
|
var createNotEmittedStatement = deprecate(factory.createNotEmittedStatement, factoryDeprecation);
|
|
var createPartiallyEmittedExpression = deprecate(factory.createPartiallyEmittedExpression, factoryDeprecation);
|
|
var updatePartiallyEmittedExpression = deprecate(factory.updatePartiallyEmittedExpression, factoryDeprecation);
|
|
var createCommaList = deprecate(factory.createCommaListExpression, factoryDeprecation);
|
|
var updateCommaList = deprecate(factory.updateCommaListExpression, factoryDeprecation);
|
|
var createBundle = deprecate(factory.createBundle, factoryDeprecation);
|
|
var updateBundle = deprecate(factory.updateBundle, factoryDeprecation);
|
|
var createImmediatelyInvokedFunctionExpression = deprecate(factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation);
|
|
var createImmediatelyInvokedArrowFunction = deprecate(factory.createImmediatelyInvokedArrowFunction, factoryDeprecation);
|
|
var createVoidZero = deprecate(factory.createVoidZero, factoryDeprecation);
|
|
var createExportDefault = deprecate(factory.createExportDefault, factoryDeprecation);
|
|
var createExternalModuleExport = deprecate(factory.createExternalModuleExport, factoryDeprecation);
|
|
var createNamespaceExport = deprecate(factory.createNamespaceExport, factoryDeprecation);
|
|
var updateNamespaceExport = deprecate(factory.updateNamespaceExport, factoryDeprecation);
|
|
var createToken = deprecate(function createToken2(kind) {
|
|
return factory.createToken(kind);
|
|
}, factoryDeprecation);
|
|
var createIdentifier = deprecate(function createIdentifier2(text) {
|
|
return factory.createIdentifier(text, void 0, void 0);
|
|
}, factoryDeprecation);
|
|
var createTempVariable = deprecate(function createTempVariable2(recordTempVariable) {
|
|
return factory.createTempVariable(recordTempVariable, void 0);
|
|
}, factoryDeprecation);
|
|
var getGeneratedNameForNode = deprecate(function getGeneratedNameForNode2(node) {
|
|
return factory.getGeneratedNameForNode(node, void 0);
|
|
}, factoryDeprecation);
|
|
var createOptimisticUniqueName = deprecate(function createOptimisticUniqueName2(text) {
|
|
return factory.createUniqueName(text, 16 /* Optimistic */);
|
|
}, factoryDeprecation);
|
|
var createFileLevelUniqueName = deprecate(function createFileLevelUniqueName2(text) {
|
|
return factory.createUniqueName(text, 16 /* Optimistic */ | 32 /* FileLevel */);
|
|
}, factoryDeprecation);
|
|
var createIndexSignature = deprecate(function createIndexSignature2(decorators, modifiers, parameters, type) {
|
|
return factory.createIndexSignature(decorators, modifiers, parameters, type);
|
|
}, factoryDeprecation);
|
|
var createTypePredicateNode = deprecate(function createTypePredicateNode2(parameterName, type) {
|
|
return factory.createTypePredicateNode(void 0, parameterName, type);
|
|
}, factoryDeprecation);
|
|
var updateTypePredicateNode = deprecate(function updateTypePredicateNode2(node, parameterName, type) {
|
|
return factory.updateTypePredicateNode(node, void 0, parameterName, type);
|
|
}, factoryDeprecation);
|
|
var createLiteral = deprecate(function createLiteral2(value) {
|
|
if (typeof value === "number") {
|
|
return factory.createNumericLiteral(value);
|
|
}
|
|
if (typeof value === "object" && "base10Value" in value) {
|
|
return factory.createBigIntLiteral(value);
|
|
}
|
|
if (typeof value === "boolean") {
|
|
return value ? factory.createTrue() : factory.createFalse();
|
|
}
|
|
if (typeof value === "string") {
|
|
return factory.createStringLiteral(value, void 0);
|
|
}
|
|
return factory.createStringLiteralFromNode(value);
|
|
}, { since: "4.0", warnAfter: "4.1", message: "Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead." });
|
|
var createMethodSignature = deprecate(function createMethodSignature2(typeParameters, parameters, type, name, questionToken) {
|
|
return factory.createMethodSignature(void 0, name, questionToken, typeParameters, parameters, type);
|
|
}, factoryDeprecation);
|
|
var updateMethodSignature = deprecate(function updateMethodSignature2(node, typeParameters, parameters, type, name, questionToken) {
|
|
return factory.updateMethodSignature(node, node.modifiers, name, questionToken, typeParameters, parameters, type);
|
|
}, factoryDeprecation);
|
|
var createTypeOperatorNode = deprecate(function createTypeOperatorNode2(operatorOrType, type) {
|
|
let operator;
|
|
if (type) {
|
|
operator = operatorOrType;
|
|
} else {
|
|
type = operatorOrType;
|
|
operator = 141 /* KeyOfKeyword */;
|
|
}
|
|
return factory.createTypeOperatorNode(operator, type);
|
|
}, factoryDeprecation);
|
|
var createTaggedTemplate = deprecate(function createTaggedTemplate2(tag, typeArgumentsOrTemplate, template) {
|
|
let typeArguments;
|
|
if (template) {
|
|
typeArguments = typeArgumentsOrTemplate;
|
|
} else {
|
|
template = typeArgumentsOrTemplate;
|
|
}
|
|
return factory.createTaggedTemplateExpression(tag, typeArguments, template);
|
|
}, factoryDeprecation);
|
|
var updateTaggedTemplate = deprecate(function updateTaggedTemplate2(node, tag, typeArgumentsOrTemplate, template) {
|
|
let typeArguments;
|
|
if (template) {
|
|
typeArguments = typeArgumentsOrTemplate;
|
|
} else {
|
|
template = typeArgumentsOrTemplate;
|
|
}
|
|
return factory.updateTaggedTemplateExpression(node, tag, typeArguments, template);
|
|
}, factoryDeprecation);
|
|
var updateBinary = deprecate(function updateBinary2(node, left, right, operator = node.operatorToken) {
|
|
if (typeof operator === "number") {
|
|
operator = operator === node.operatorToken.kind ? node.operatorToken : factory.createToken(operator);
|
|
}
|
|
return factory.updateBinaryExpression(node, left, operator, right);
|
|
}, factoryDeprecation);
|
|
var createConditional = deprecate(function createConditional2(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) {
|
|
return arguments.length === 5 ? factory.createConditionalExpression(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) : arguments.length === 3 ? factory.createConditionalExpression(condition, factory.createToken(57 /* QuestionToken */), questionTokenOrWhenTrue, factory.createToken(58 /* ColonToken */), whenTrueOrWhenFalse) : Debug.fail("Argument count mismatch");
|
|
}, factoryDeprecation);
|
|
var createYield = deprecate(function createYield2(asteriskTokenOrExpression, expression) {
|
|
let asteriskToken;
|
|
if (expression) {
|
|
asteriskToken = asteriskTokenOrExpression;
|
|
} else {
|
|
expression = asteriskTokenOrExpression;
|
|
}
|
|
return factory.createYieldExpression(asteriskToken, expression);
|
|
}, factoryDeprecation);
|
|
var createClassExpression = deprecate(function createClassExpression2(modifiers, name, typeParameters, heritageClauses, members) {
|
|
return factory.createClassExpression(void 0, modifiers, name, typeParameters, heritageClauses, members);
|
|
}, factoryDeprecation);
|
|
var updateClassExpression = deprecate(function updateClassExpression2(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return factory.updateClassExpression(node, void 0, modifiers, name, typeParameters, heritageClauses, members);
|
|
}, factoryDeprecation);
|
|
var createPropertySignature = deprecate(function createPropertySignature2(modifiers, name, questionToken, type, initializer) {
|
|
const node = factory.createPropertySignature(modifiers, name, questionToken, type);
|
|
node.initializer = initializer;
|
|
return node;
|
|
}, factoryDeprecation);
|
|
var updatePropertySignature = deprecate(function updatePropertySignature2(node, modifiers, name, questionToken, type, initializer) {
|
|
let updated = factory.updatePropertySignature(node, modifiers, name, questionToken, type);
|
|
if (node.initializer !== initializer) {
|
|
if (updated === node) {
|
|
updated = factory.cloneNode(node);
|
|
}
|
|
updated.initializer = initializer;
|
|
}
|
|
return updated;
|
|
}, factoryDeprecation);
|
|
var createExpressionWithTypeArguments = deprecate(function createExpressionWithTypeArguments2(typeArguments, expression) {
|
|
return factory.createExpressionWithTypeArguments(expression, typeArguments);
|
|
}, factoryDeprecation);
|
|
var updateExpressionWithTypeArguments = deprecate(function updateExpressionWithTypeArguments2(node, typeArguments, expression) {
|
|
return factory.updateExpressionWithTypeArguments(node, expression, typeArguments);
|
|
}, factoryDeprecation);
|
|
var createArrowFunction = deprecate(function createArrowFunction2(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
|
|
return arguments.length === 6 ? factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : arguments.length === 5 ? factory.createArrowFunction(modifiers, typeParameters, parameters, type, void 0, equalsGreaterThanTokenOrBody) : Debug.fail("Argument count mismatch");
|
|
}, factoryDeprecation);
|
|
var updateArrowFunction = deprecate(function updateArrowFunction2(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) {
|
|
return arguments.length === 7 ? factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : arguments.length === 6 ? factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, node.equalsGreaterThanToken, equalsGreaterThanTokenOrBody) : Debug.fail("Argument count mismatch");
|
|
}, factoryDeprecation);
|
|
var createVariableDeclaration = deprecate(function createVariableDeclaration2(name, exclamationTokenOrType, typeOrInitializer, initializer) {
|
|
return arguments.length === 4 ? factory.createVariableDeclaration(name, exclamationTokenOrType, typeOrInitializer, initializer) : arguments.length >= 1 && arguments.length <= 3 ? factory.createVariableDeclaration(name, void 0, exclamationTokenOrType, typeOrInitializer) : Debug.fail("Argument count mismatch");
|
|
}, factoryDeprecation);
|
|
var updateVariableDeclaration = deprecate(function updateVariableDeclaration2(node, name, exclamationTokenOrType, typeOrInitializer, initializer) {
|
|
return arguments.length === 5 ? factory.updateVariableDeclaration(node, name, exclamationTokenOrType, typeOrInitializer, initializer) : arguments.length === 4 ? factory.updateVariableDeclaration(node, name, node.exclamationToken, exclamationTokenOrType, typeOrInitializer) : Debug.fail("Argument count mismatch");
|
|
}, factoryDeprecation);
|
|
var createImportClause = deprecate(function createImportClause2(name, namedBindings, isTypeOnly = false) {
|
|
return factory.createImportClause(isTypeOnly, name, namedBindings);
|
|
}, factoryDeprecation);
|
|
var updateImportClause = deprecate(function updateImportClause2(node, name, namedBindings, isTypeOnly) {
|
|
return factory.updateImportClause(node, isTypeOnly, name, namedBindings);
|
|
}, factoryDeprecation);
|
|
var createExportDeclaration = deprecate(function createExportDeclaration2(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly = false) {
|
|
return factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier);
|
|
}, factoryDeprecation);
|
|
var updateExportDeclaration = deprecate(function updateExportDeclaration2(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) {
|
|
return factory.updateExportDeclaration(node, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, node.assertClause);
|
|
}, factoryDeprecation);
|
|
var createJSDocParamTag = deprecate(function createJSDocParamTag2(name, isBracketed, typeExpression, comment) {
|
|
return factory.createJSDocParameterTag(void 0, name, isBracketed, typeExpression, false, comment ? factory.createNodeArray([factory.createJSDocText(comment)]) : void 0);
|
|
}, factoryDeprecation);
|
|
var createComma = deprecate(function createComma2(left, right) {
|
|
return factory.createComma(left, right);
|
|
}, factoryDeprecation);
|
|
var createLessThan = deprecate(function createLessThan2(left, right) {
|
|
return factory.createLessThan(left, right);
|
|
}, factoryDeprecation);
|
|
var createAssignment = deprecate(function createAssignment2(left, right) {
|
|
return factory.createAssignment(left, right);
|
|
}, factoryDeprecation);
|
|
var createStrictEquality = deprecate(function createStrictEquality2(left, right) {
|
|
return factory.createStrictEquality(left, right);
|
|
}, factoryDeprecation);
|
|
var createStrictInequality = deprecate(function createStrictInequality2(left, right) {
|
|
return factory.createStrictInequality(left, right);
|
|
}, factoryDeprecation);
|
|
var createAdd = deprecate(function createAdd2(left, right) {
|
|
return factory.createAdd(left, right);
|
|
}, factoryDeprecation);
|
|
var createSubtract = deprecate(function createSubtract2(left, right) {
|
|
return factory.createSubtract(left, right);
|
|
}, factoryDeprecation);
|
|
var createLogicalAnd = deprecate(function createLogicalAnd2(left, right) {
|
|
return factory.createLogicalAnd(left, right);
|
|
}, factoryDeprecation);
|
|
var createLogicalOr = deprecate(function createLogicalOr2(left, right) {
|
|
return factory.createLogicalOr(left, right);
|
|
}, factoryDeprecation);
|
|
var createPostfixIncrement = deprecate(function createPostfixIncrement2(operand) {
|
|
return factory.createPostfixIncrement(operand);
|
|
}, factoryDeprecation);
|
|
var createLogicalNot = deprecate(function createLogicalNot2(operand) {
|
|
return factory.createLogicalNot(operand);
|
|
}, factoryDeprecation);
|
|
var createNode2 = deprecate(function createNode3(kind, pos = 0, end = 0) {
|
|
return setTextRangePosEnd(
|
|
kind === 308 /* SourceFile */ ? parseBaseNodeFactory.createBaseSourceFileNode(kind) : kind === 79 /* Identifier */ ? parseBaseNodeFactory.createBaseIdentifierNode(kind) : kind === 80 /* PrivateIdentifier */ ? parseBaseNodeFactory.createBasePrivateIdentifierNode(kind) : !isNodeKind(kind) ? parseBaseNodeFactory.createBaseTokenNode(kind) : parseBaseNodeFactory.createBaseNode(kind),
|
|
pos,
|
|
end
|
|
);
|
|
}, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory` method instead." });
|
|
var getMutableClone = deprecate(function getMutableClone2(node) {
|
|
const clone2 = factory.cloneNode(node);
|
|
setTextRange(clone2, node);
|
|
setParent(clone2, node.parent);
|
|
return clone2;
|
|
}, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`." });
|
|
|
|
// src/deprecatedCompat/4.0/renamedNodeTests.ts
|
|
var isTypeAssertion = deprecate(function isTypeAssertion2(node) {
|
|
return node.kind === 213 /* TypeAssertionExpression */;
|
|
}, {
|
|
since: "4.0",
|
|
warnAfter: "4.1",
|
|
message: "Use `isTypeAssertionExpression` instead."
|
|
});
|
|
|
|
// src/deprecatedCompat/4.2/renamedNodeTests.ts
|
|
var isIdentifierOrPrivateIdentifier = deprecate(function isIdentifierOrPrivateIdentifier2(node) {
|
|
return isMemberName(node);
|
|
}, {
|
|
since: "4.2",
|
|
warnAfter: "4.3",
|
|
message: "Use `isMemberName` instead."
|
|
});
|
|
|
|
// src/deprecatedCompat/4.2/abstractConstructorTypes.ts
|
|
function patchNodeFactory(factory2) {
|
|
const {
|
|
createConstructorTypeNode: createConstructorTypeNode2,
|
|
updateConstructorTypeNode: updateConstructorTypeNode2
|
|
} = factory2;
|
|
factory2.createConstructorTypeNode = buildOverload("createConstructorTypeNode").overload({
|
|
0(modifiers, typeParameters, parameters, type) {
|
|
return createConstructorTypeNode2(modifiers, typeParameters, parameters, type);
|
|
},
|
|
1(typeParameters, parameters, type) {
|
|
return createConstructorTypeNode2(void 0, typeParameters, parameters, type);
|
|
}
|
|
}).bind({
|
|
0: (args) => args.length === 4,
|
|
1: (args) => args.length === 3
|
|
}).deprecate({
|
|
1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" }
|
|
}).finish();
|
|
factory2.updateConstructorTypeNode = buildOverload("updateConstructorTypeNode").overload({
|
|
0(node, modifiers, typeParameters, parameters, type) {
|
|
return updateConstructorTypeNode2(node, modifiers, typeParameters, parameters, type);
|
|
},
|
|
1(node, typeParameters, parameters, type) {
|
|
return updateConstructorTypeNode2(node, node.modifiers, typeParameters, parameters, type);
|
|
}
|
|
}).bind({
|
|
0: (args) => args.length === 5,
|
|
1: (args) => args.length === 4
|
|
}).deprecate({
|
|
1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" }
|
|
}).finish();
|
|
}
|
|
addNodeFactoryPatcher(patchNodeFactory);
|
|
patchNodeFactory(factory);
|
|
|
|
// src/deprecatedCompat/4.6/importTypeAssertions.ts
|
|
function patchNodeFactory2(factory2) {
|
|
const {
|
|
createImportTypeNode: createImportTypeNode2,
|
|
updateImportTypeNode: updateImportTypeNode2
|
|
} = factory2;
|
|
factory2.createImportTypeNode = buildOverload("createImportTypeNode").overload({
|
|
0(argument, assertions, qualifier, typeArguments, isTypeOf) {
|
|
return createImportTypeNode2(argument, assertions, qualifier, typeArguments, isTypeOf);
|
|
},
|
|
1(argument, qualifier, typeArguments, isTypeOf) {
|
|
return createImportTypeNode2(argument, void 0, qualifier, typeArguments, isTypeOf);
|
|
}
|
|
}).bind({
|
|
0: ([, assertions, qualifier, typeArguments, isTypeOf]) => (assertions === void 0 || isImportTypeAssertionContainer(assertions)) && (qualifier === void 0 || !isArray(qualifier)) && (typeArguments === void 0 || isArray(typeArguments)) && (isTypeOf === void 0 || typeof isTypeOf === "boolean"),
|
|
1: ([, qualifier, typeArguments, isTypeOf, other]) => other === void 0 && (qualifier === void 0 || isEntityName(qualifier)) && (typeArguments === void 0 || isArray(typeArguments)) && (isTypeOf === void 0 || typeof isTypeOf === "boolean")
|
|
}).deprecate({
|
|
1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" }
|
|
}).finish();
|
|
factory2.updateImportTypeNode = buildOverload("updateImportTypeNode").overload({
|
|
0(node, argument, assertions, qualifier, typeArguments, isTypeOf) {
|
|
return updateImportTypeNode2(node, argument, assertions, qualifier, typeArguments, isTypeOf);
|
|
},
|
|
1(node, argument, qualifier, typeArguments, isTypeOf) {
|
|
return updateImportTypeNode2(node, argument, node.assertions, qualifier, typeArguments, isTypeOf);
|
|
}
|
|
}).bind({
|
|
0: ([, , assertions, qualifier, typeArguments, isTypeOf]) => (assertions === void 0 || isImportTypeAssertionContainer(assertions)) && (qualifier === void 0 || !isArray(qualifier)) && (typeArguments === void 0 || isArray(typeArguments)) && (isTypeOf === void 0 || typeof isTypeOf === "boolean"),
|
|
1: ([, , qualifier, typeArguments, isTypeOf, other]) => other === void 0 && (qualifier === void 0 || isEntityName(qualifier)) && (typeArguments === void 0 || isArray(typeArguments)) && (isTypeOf === void 0 || typeof isTypeOf === "boolean")
|
|
}).deprecate({
|
|
1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" }
|
|
}).finish();
|
|
}
|
|
addNodeFactoryPatcher(patchNodeFactory2);
|
|
patchNodeFactory2(factory);
|
|
|
|
// src/deprecatedCompat/4.7/typeParameterModifiers.ts
|
|
function patchNodeFactory3(factory2) {
|
|
const {
|
|
createTypeParameterDeclaration: createTypeParameterDeclaration2,
|
|
updateTypeParameterDeclaration: updateTypeParameterDeclaration2
|
|
} = factory2;
|
|
factory2.createTypeParameterDeclaration = buildOverload("createTypeParameterDeclaration").overload({
|
|
0(modifiers, name, constraint, defaultType) {
|
|
return createTypeParameterDeclaration2(modifiers, name, constraint, defaultType);
|
|
},
|
|
1(name, constraint, defaultType) {
|
|
return createTypeParameterDeclaration2(void 0, name, constraint, defaultType);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers]) => modifiers === void 0 || isArray(modifiers),
|
|
1: ([name]) => name !== void 0 && !isArray(name)
|
|
}).deprecate({
|
|
1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" }
|
|
}).finish();
|
|
factory2.updateTypeParameterDeclaration = buildOverload("updateTypeParameterDeclaration").overload({
|
|
0(node, modifiers, name, constraint, defaultType) {
|
|
return updateTypeParameterDeclaration2(node, modifiers, name, constraint, defaultType);
|
|
},
|
|
1(node, name, constraint, defaultType) {
|
|
return updateTypeParameterDeclaration2(node, node.modifiers, name, constraint, defaultType);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers]) => modifiers === void 0 || isArray(modifiers),
|
|
1: ([, name]) => name !== void 0 && !isArray(name)
|
|
}).deprecate({
|
|
1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" }
|
|
}).finish();
|
|
}
|
|
addNodeFactoryPatcher(patchNodeFactory3);
|
|
patchNodeFactory3(factory);
|
|
|
|
// src/deprecatedCompat/4.8/mergeDecoratorsAndModifiers.ts
|
|
var MUST_MERGE = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators have been combined with modifiers. Callers should switch to an overload that does not accept a 'decorators' parameter." };
|
|
var DISALLOW_DECORATORS = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators are no longer supported for this function. Callers should switch to an overload that does not accept a 'decorators' parameter.` };
|
|
var DISALLOW_DECORATORS_AND_MODIFIERS = { since: "4.8", warnAfter: "4.9.0-0", message: `Decorators and modifiers are no longer supported for this function. Callers should switch to an overload that does not accept the 'decorators' and 'modifiers' parameters.` };
|
|
function patchNodeFactory4(factory2) {
|
|
const {
|
|
createParameterDeclaration,
|
|
updateParameterDeclaration,
|
|
createPropertyDeclaration,
|
|
updatePropertyDeclaration: updatePropertyDeclaration2,
|
|
createMethodDeclaration,
|
|
updateMethodDeclaration,
|
|
createConstructorDeclaration,
|
|
updateConstructorDeclaration,
|
|
createGetAccessorDeclaration,
|
|
updateGetAccessorDeclaration,
|
|
createSetAccessorDeclaration,
|
|
updateSetAccessorDeclaration,
|
|
createIndexSignature: createIndexSignature3,
|
|
updateIndexSignature: updateIndexSignature2,
|
|
createClassStaticBlockDeclaration,
|
|
updateClassStaticBlockDeclaration,
|
|
createClassExpression: createClassExpression3,
|
|
updateClassExpression: updateClassExpression3,
|
|
createFunctionDeclaration: createFunctionDeclaration2,
|
|
updateFunctionDeclaration: updateFunctionDeclaration2,
|
|
createClassDeclaration: createClassDeclaration2,
|
|
updateClassDeclaration: updateClassDeclaration2,
|
|
createInterfaceDeclaration: createInterfaceDeclaration2,
|
|
updateInterfaceDeclaration: updateInterfaceDeclaration2,
|
|
createTypeAliasDeclaration: createTypeAliasDeclaration2,
|
|
updateTypeAliasDeclaration: updateTypeAliasDeclaration2,
|
|
createEnumDeclaration: createEnumDeclaration2,
|
|
updateEnumDeclaration: updateEnumDeclaration2,
|
|
createModuleDeclaration: createModuleDeclaration2,
|
|
updateModuleDeclaration: updateModuleDeclaration2,
|
|
createImportEqualsDeclaration: createImportEqualsDeclaration2,
|
|
updateImportEqualsDeclaration: updateImportEqualsDeclaration2,
|
|
createImportDeclaration: createImportDeclaration2,
|
|
updateImportDeclaration: updateImportDeclaration2,
|
|
createExportAssignment: createExportAssignment3,
|
|
updateExportAssignment: updateExportAssignment2,
|
|
createExportDeclaration: createExportDeclaration3,
|
|
updateExportDeclaration: updateExportDeclaration3
|
|
} = factory2;
|
|
factory2.createParameterDeclaration = buildOverload("createParameterDeclaration").overload({
|
|
0(modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
return createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer);
|
|
},
|
|
1(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
return createParameterDeclaration(concatenate(decorators, modifiers), dotDotDotToken, name, questionToken, type, initializer);
|
|
}
|
|
}).bind({
|
|
0: ([, dotDotDotToken, name, questionToken, type, initializer, other]) => other === void 0 && (dotDotDotToken === void 0 || !isArray(dotDotDotToken)) && (name === void 0 || typeof name === "string" || isBindingName(name)) && (questionToken === void 0 || typeof questionToken === "object" && isQuestionToken(questionToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer)),
|
|
1: ([, modifiers, dotDotDotToken, name, questionToken, type, initializer]) => (modifiers === void 0 || isArray(modifiers)) && (dotDotDotToken === void 0 || typeof dotDotDotToken === "object" && isDotDotDotToken(dotDotDotToken)) && (name === void 0 || typeof name === "string" || isBindingName(name)) && (questionToken === void 0 || isQuestionToken(questionToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updateParameterDeclaration = buildOverload("updateParameterDeclaration").overload({
|
|
0(node, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
return updateParameterDeclaration(node, modifiers, dotDotDotToken, name, questionToken, type, initializer);
|
|
},
|
|
1(node, decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) {
|
|
return updateParameterDeclaration(node, concatenate(decorators, modifiers), dotDotDotToken, name, questionToken, type, initializer);
|
|
}
|
|
}).bind({
|
|
0: ([, , dotDotDotToken, name, questionToken, type, initializer, other]) => other === void 0 && (dotDotDotToken === void 0 || !isArray(dotDotDotToken)) && (name === void 0 || typeof name === "string" || isBindingName(name)) && (questionToken === void 0 || typeof questionToken === "object" && isQuestionToken(questionToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer)),
|
|
1: ([, , modifiers, dotDotDotToken, name, questionToken, type, initializer]) => (modifiers === void 0 || isArray(modifiers)) && (dotDotDotToken === void 0 || typeof dotDotDotToken === "object" && isDotDotDotToken(dotDotDotToken)) && (name === void 0 || typeof name === "string" || isBindingName(name)) && (questionToken === void 0 || isQuestionToken(questionToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createPropertyDeclaration = buildOverload("createPropertyDeclaration").overload({
|
|
0(modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer);
|
|
},
|
|
1(decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return createPropertyDeclaration(concatenate(decorators, modifiers), name, questionOrExclamationToken, type, initializer);
|
|
}
|
|
}).bind({
|
|
0: ([, name, questionOrExclamationToken, type, initializer, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (questionOrExclamationToken === void 0 || typeof questionOrExclamationToken === "object" && isQuestionOrExclamationToken(questionOrExclamationToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer)),
|
|
1: ([, modifiers, name, questionOrExclamationToken, type, initializer]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionOrExclamationToken === void 0 || isQuestionOrExclamationToken(questionOrExclamationToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updatePropertyDeclaration = buildOverload("updatePropertyDeclaration").overload({
|
|
0(node, modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return updatePropertyDeclaration2(node, modifiers, name, questionOrExclamationToken, type, initializer);
|
|
},
|
|
1(node, decorators, modifiers, name, questionOrExclamationToken, type, initializer) {
|
|
return updatePropertyDeclaration2(node, concatenate(decorators, modifiers), name, questionOrExclamationToken, type, initializer);
|
|
}
|
|
}).bind({
|
|
0: ([, , name, questionOrExclamationToken, type, initializer, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (questionOrExclamationToken === void 0 || typeof questionOrExclamationToken === "object" && isQuestionOrExclamationToken(questionOrExclamationToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer)),
|
|
1: ([, , modifiers, name, questionOrExclamationToken, type, initializer]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionOrExclamationToken === void 0 || isQuestionOrExclamationToken(questionOrExclamationToken)) && (type === void 0 || isTypeNode(type)) && (initializer === void 0 || isExpression(initializer))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createMethodDeclaration = buildOverload("createMethodDeclaration").overload({
|
|
0(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
return createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body);
|
|
},
|
|
1(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
return createMethodDeclaration(concatenate(decorators, modifiers), asteriskToken, name, questionToken, typeParameters, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, asteriskToken, name, questionToken, typeParameters, parameters, type, body, other]) => other === void 0 && (asteriskToken === void 0 || !isArray(asteriskToken)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionToken === void 0 || typeof questionToken === "object" && isQuestionToken(questionToken)) && (typeParameters === void 0 || isArray(typeParameters)) && (parameters === void 0 || !some(parameters, isTypeParameterDeclaration)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (asteriskToken === void 0 || typeof asteriskToken === "object" && isAsteriskToken(asteriskToken)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionToken === void 0 || !isArray(questionToken)) && (typeParameters === void 0 || !some(typeParameters, isParameter)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updateMethodDeclaration = buildOverload("updateMethodDeclaration").overload({
|
|
0(node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
return updateMethodDeclaration(node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body);
|
|
},
|
|
1(node, decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) {
|
|
return updateMethodDeclaration(node, concatenate(decorators, modifiers), asteriskToken, name, questionToken, typeParameters, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, , asteriskToken, name, questionToken, typeParameters, parameters, type, body, other]) => other === void 0 && (asteriskToken === void 0 || !isArray(asteriskToken)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionToken === void 0 || typeof questionToken === "object" && isQuestionToken(questionToken)) && (typeParameters === void 0 || isArray(typeParameters)) && (parameters === void 0 || !some(parameters, isTypeParameterDeclaration)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, , modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (asteriskToken === void 0 || typeof asteriskToken === "object" && isAsteriskToken(asteriskToken)) && (name === void 0 || typeof name === "string" || isPropertyName(name)) && (questionToken === void 0 || !isArray(questionToken)) && (typeParameters === void 0 || !some(typeParameters, isParameter)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createConstructorDeclaration = buildOverload("createConstructorDeclaration").overload({
|
|
0(modifiers, parameters, body) {
|
|
return createConstructorDeclaration(modifiers, parameters, body);
|
|
},
|
|
1(_decorators, modifiers, parameters, body) {
|
|
return createConstructorDeclaration(modifiers, parameters, body);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, parameters, body, other]) => other === void 0 && (modifiers === void 0 || !some(modifiers, isDecorator)) && (parameters === void 0 || !some(parameters, isModifier)) && (body === void 0 || !isArray(body)),
|
|
1: ([decorators, modifiers, parameters, body]) => (decorators === void 0 || !some(decorators, isModifier)) && (modifiers === void 0 || !some(modifiers, isParameter)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateConstructorDeclaration = buildOverload("updateConstructorDeclaration").overload({
|
|
0(node, modifiers, parameters, body) {
|
|
return updateConstructorDeclaration(node, modifiers, parameters, body);
|
|
},
|
|
1(node, _decorators, modifiers, parameters, body) {
|
|
return updateConstructorDeclaration(node, modifiers, parameters, body);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, parameters, body, other]) => other === void 0 && (modifiers === void 0 || !some(modifiers, isDecorator)) && (parameters === void 0 || !some(parameters, isModifier)) && (body === void 0 || !isArray(body)),
|
|
1: ([, decorators, modifiers, parameters, body]) => (decorators === void 0 || !some(decorators, isModifier)) && (modifiers === void 0 || !some(modifiers, isParameter)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createGetAccessorDeclaration = buildOverload("createGetAccessorDeclaration").overload({
|
|
0(modifiers, name, parameters, type, body) {
|
|
return createGetAccessorDeclaration(modifiers, name, parameters, type, body);
|
|
},
|
|
1(decorators, modifiers, name, parameters, type, body) {
|
|
return createGetAccessorDeclaration(concatenate(decorators, modifiers), name, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, name, parameters, type, body, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, modifiers, name, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updateGetAccessorDeclaration = buildOverload("updateGetAccessorDeclaration").overload({
|
|
0(node, modifiers, name, parameters, type, body) {
|
|
return updateGetAccessorDeclaration(node, modifiers, name, parameters, type, body);
|
|
},
|
|
1(node, decorators, modifiers, name, parameters, type, body) {
|
|
return updateGetAccessorDeclaration(node, concatenate(decorators, modifiers), name, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, , name, parameters, type, body, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, , modifiers, name, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createSetAccessorDeclaration = buildOverload("createSetAccessorDeclaration").overload({
|
|
0(modifiers, name, parameters, body) {
|
|
return createSetAccessorDeclaration(modifiers, name, parameters, body);
|
|
},
|
|
1(decorators, modifiers, name, parameters, body) {
|
|
return createSetAccessorDeclaration(concatenate(decorators, modifiers), name, parameters, body);
|
|
}
|
|
}).bind({
|
|
0: ([, name, parameters, body, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || !isArray(body)),
|
|
1: ([, modifiers, name, parameters, body]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updateSetAccessorDeclaration = buildOverload("updateSetAccessorDeclaration").overload({
|
|
0(node, modifiers, name, parameters, body) {
|
|
return updateSetAccessorDeclaration(node, modifiers, name, parameters, body);
|
|
},
|
|
1(node, decorators, modifiers, name, parameters, body) {
|
|
return updateSetAccessorDeclaration(node, concatenate(decorators, modifiers), name, parameters, body);
|
|
}
|
|
}).bind({
|
|
0: ([, , name, parameters, body, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || !isArray(body)),
|
|
1: ([, , modifiers, name, parameters, body]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (parameters === void 0 || isArray(parameters)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createIndexSignature = buildOverload("createIndexSignature").overload({
|
|
0(modifiers, parameters, type) {
|
|
return createIndexSignature3(modifiers, parameters, type);
|
|
},
|
|
1(_decorators, modifiers, parameters, type) {
|
|
return createIndexSignature3(modifiers, parameters, type);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, parameters, type, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (parameters === void 0 || every(parameters, isParameter)) && (type === void 0 || !isArray(type)),
|
|
1: ([decorators, modifiers, parameters, type]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || every(modifiers, isModifier)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateIndexSignature = buildOverload("updateIndexSignature").overload({
|
|
0(node, modifiers, parameters, type) {
|
|
return updateIndexSignature2(node, modifiers, parameters, type);
|
|
},
|
|
1(node, _decorators, modifiers, parameters, type) {
|
|
return updateIndexSignature2(node, modifiers, parameters, type);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, parameters, type, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (parameters === void 0 || every(parameters, isParameter)) && (type === void 0 || !isArray(type)),
|
|
1: ([, decorators, modifiers, parameters, type]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || every(modifiers, isModifier)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createClassStaticBlockDeclaration = buildOverload("createClassStaticBlockDeclaration").overload({
|
|
0(body) {
|
|
return createClassStaticBlockDeclaration(body);
|
|
},
|
|
1(_decorators, _modifiers, body) {
|
|
return createClassStaticBlockDeclaration(body);
|
|
}
|
|
}).bind({
|
|
0: ([body, other1, other2]) => other1 === void 0 && other2 === void 0 && (body === void 0 || !isArray(body)),
|
|
1: ([decorators, modifiers, body]) => (decorators === void 0 || isArray(decorators)) && (modifiers === void 0 || isArray(decorators)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS_AND_MODIFIERS
|
|
}).finish();
|
|
factory2.updateClassStaticBlockDeclaration = buildOverload("updateClassStaticBlockDeclaration").overload({
|
|
0(node, body) {
|
|
return updateClassStaticBlockDeclaration(node, body);
|
|
},
|
|
1(node, _decorators, _modifiers, body) {
|
|
return updateClassStaticBlockDeclaration(node, body);
|
|
}
|
|
}).bind({
|
|
0: ([, body, other1, other2]) => other1 === void 0 && other2 === void 0 && (body === void 0 || !isArray(body)),
|
|
1: ([, decorators, modifiers, body]) => (decorators === void 0 || isArray(decorators)) && (modifiers === void 0 || isArray(decorators)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS_AND_MODIFIERS
|
|
}).finish();
|
|
factory2.createClassExpression = buildOverload("createClassExpression").overload({
|
|
0(modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createClassExpression3(modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createClassExpression3(concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([, name, typeParameters, heritageClauses, members, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isClassElement)),
|
|
1: ([, modifiers, name, typeParameters, heritageClauses, members]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || isArray(members))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateClassExpression = buildOverload("updateClassExpression").overload({
|
|
0(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateClassExpression3(node, modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateClassExpression3(node, concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([, , name, typeParameters, heritageClauses, members, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isClassElement)),
|
|
1: ([, , modifiers, name, typeParameters, heritageClauses, members]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || isArray(members))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createFunctionDeclaration = buildOverload("createFunctionDeclaration").overload({
|
|
0(modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return createFunctionDeclaration2(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
},
|
|
1(_decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return createFunctionDeclaration2(modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, asteriskToken, name, typeParameters, parameters, type, body, other]) => other === void 0 && (asteriskToken === void 0 || !isArray(asteriskToken)) && (name === void 0 || typeof name === "string" || isIdentifier(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (parameters === void 0 || every(parameters, isParameter)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, modifiers, asteriskToken, name, typeParameters, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (asteriskToken === void 0 || typeof asteriskToken !== "string" && isAsteriskToken(asteriskToken)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateFunctionDeclaration = buildOverload("updateFunctionDeclaration").overload({
|
|
0(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return updateFunctionDeclaration2(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
},
|
|
1(node, _decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) {
|
|
return updateFunctionDeclaration2(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body);
|
|
}
|
|
}).bind({
|
|
0: ([, , asteriskToken, name, typeParameters, parameters, type, body, other]) => other === void 0 && (asteriskToken === void 0 || !isArray(asteriskToken)) && (name === void 0 || isIdentifier(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (parameters === void 0 || every(parameters, isParameter)) && (type === void 0 || !isArray(type)) && (body === void 0 || isBlock(body)),
|
|
1: ([, , modifiers, asteriskToken, name, typeParameters, parameters, type, body]) => (modifiers === void 0 || isArray(modifiers)) && (asteriskToken === void 0 || typeof asteriskToken !== "string" && isAsteriskToken(asteriskToken)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (parameters === void 0 || isArray(parameters)) && (type === void 0 || isTypeNode(type)) && (body === void 0 || isBlock(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createClassDeclaration = buildOverload("createClassDeclaration").overload({
|
|
0(modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createClassDeclaration2(modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createClassDeclaration2(concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([, name, typeParameters, heritageClauses, members, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isClassElement)),
|
|
1: () => true
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.updateClassDeclaration = buildOverload("updateClassDeclaration").overload({
|
|
0(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateClassDeclaration2(node, modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(node, decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateClassDeclaration2(node, concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([, , name, typeParameters, heritageClauses, members, other]) => other === void 0 && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isClassElement)),
|
|
1: ([, , modifiers, name, typeParameters, heritageClauses, members]) => (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || isArray(members))
|
|
}).deprecate({
|
|
1: MUST_MERGE
|
|
}).finish();
|
|
factory2.createInterfaceDeclaration = buildOverload("createInterfaceDeclaration").overload({
|
|
0(modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createInterfaceDeclaration2(modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(_decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return createInterfaceDeclaration2(modifiers, name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, name, typeParameters, heritageClauses, members, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isTypeElement)),
|
|
1: ([decorators, modifiers, name, typeParameters, heritageClauses, members]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isTypeElement))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateInterfaceDeclaration = buildOverload("updateInterfaceDeclaration").overload({
|
|
0(node, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateInterfaceDeclaration2(node, modifiers, name, typeParameters, heritageClauses, members);
|
|
},
|
|
1(node, _decorators, modifiers, name, typeParameters, heritageClauses, members) {
|
|
return updateInterfaceDeclaration2(node, modifiers, name, typeParameters, heritageClauses, members);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, name, typeParameters, heritageClauses, members, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isTypeElement)),
|
|
1: ([, decorators, modifiers, name, typeParameters, heritageClauses, members]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || every(typeParameters, isTypeParameterDeclaration)) && (heritageClauses === void 0 || every(heritageClauses, isHeritageClause)) && (members === void 0 || every(members, isTypeElement))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createTypeAliasDeclaration = buildOverload("createTypeAliasDeclaration").overload({
|
|
0(modifiers, name, typeParameters, type) {
|
|
return createTypeAliasDeclaration2(modifiers, name, typeParameters, type);
|
|
},
|
|
1(_decorators, modifiers, name, typeParameters, type) {
|
|
return createTypeAliasDeclaration2(modifiers, name, typeParameters, type);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, name, typeParameters, type, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (type === void 0 || !isArray(type)),
|
|
1: ([decorators, modifiers, name, typeParameters, type]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (type === void 0 || isTypeNode(type))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateTypeAliasDeclaration = buildOverload("updateTypeAliasDeclaration").overload({
|
|
0(node, modifiers, name, typeParameters, type) {
|
|
return updateTypeAliasDeclaration2(node, modifiers, name, typeParameters, type);
|
|
},
|
|
1(node, _decorators, modifiers, name, typeParameters, type) {
|
|
return updateTypeAliasDeclaration2(node, modifiers, name, typeParameters, type);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, name, typeParameters, type, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (type === void 0 || !isArray(type)),
|
|
1: ([, decorators, modifiers, name, typeParameters, type]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (typeParameters === void 0 || isArray(typeParameters)) && (type === void 0 || isTypeNode(type))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createEnumDeclaration = buildOverload("createEnumDeclaration").overload({
|
|
0(modifiers, name, members) {
|
|
return createEnumDeclaration2(modifiers, name, members);
|
|
},
|
|
1(_decorators, modifiers, name, members) {
|
|
return createEnumDeclaration2(modifiers, name, members);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, name, members, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (members === void 0 || isArray(members)),
|
|
1: ([decorators, modifiers, name, members]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (members === void 0 || isArray(members))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateEnumDeclaration = buildOverload("updateEnumDeclaration").overload({
|
|
0(node, modifiers, name, members) {
|
|
return updateEnumDeclaration2(node, modifiers, name, members);
|
|
},
|
|
1(node, _decorators, modifiers, name, members) {
|
|
return updateEnumDeclaration2(node, modifiers, name, members);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, name, members, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (members === void 0 || isArray(members)),
|
|
1: ([, decorators, modifiers, name, members]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name === void 0 || !isArray(name)) && (members === void 0 || isArray(members))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createModuleDeclaration = buildOverload("createModuleDeclaration").overload({
|
|
0(modifiers, name, body, flags) {
|
|
return createModuleDeclaration2(modifiers, name, body, flags);
|
|
},
|
|
1(_decorators, modifiers, name, body, flags) {
|
|
return createModuleDeclaration2(modifiers, name, body, flags);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, name, body, flags, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name !== void 0 && !isArray(name)) && (body === void 0 || isModuleBody(body)) && (flags === void 0 || typeof flags === "number"),
|
|
1: ([decorators, modifiers, name, body, flags]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name !== void 0 && isModuleName(name)) && (body === void 0 || typeof body === "object") && (flags === void 0 || typeof flags === "number")
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateModuleDeclaration = buildOverload("updateModuleDeclaration").overload({
|
|
0(node, modifiers, name, body) {
|
|
return updateModuleDeclaration2(node, modifiers, name, body);
|
|
},
|
|
1(node, _decorators, modifiers, name, body) {
|
|
return updateModuleDeclaration2(node, modifiers, name, body);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, name, body, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (name === void 0 || !isArray(name)) && (body === void 0 || isModuleBody(body)),
|
|
1: ([, decorators, modifiers, name, body]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (name !== void 0 && isModuleName(name)) && (body === void 0 || isModuleBody(body))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createImportEqualsDeclaration = buildOverload("createImportEqualsDeclaration").overload({
|
|
0(modifiers, isTypeOnly, name, moduleReference) {
|
|
return createImportEqualsDeclaration2(modifiers, isTypeOnly, name, moduleReference);
|
|
},
|
|
1(_decorators, modifiers, isTypeOnly, name, moduleReference) {
|
|
return createImportEqualsDeclaration2(modifiers, isTypeOnly, name, moduleReference);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, isTypeOnly, name, moduleReference, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (isTypeOnly === void 0 || typeof isTypeOnly === "boolean") && typeof name !== "boolean" && typeof moduleReference !== "string",
|
|
1: ([decorators, modifiers, isTypeOnly, name, moduleReference]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (isTypeOnly === void 0 || typeof isTypeOnly === "boolean") && (typeof name === "string" || isIdentifier(name)) && (moduleReference !== void 0 && isModuleReference(moduleReference))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateImportEqualsDeclaration = buildOverload("updateImportEqualsDeclaration").overload({
|
|
0(node, modifiers, isTypeOnly, name, moduleReference) {
|
|
return updateImportEqualsDeclaration2(node, modifiers, isTypeOnly, name, moduleReference);
|
|
},
|
|
1(node, _decorators, modifiers, isTypeOnly, name, moduleReference) {
|
|
return updateImportEqualsDeclaration2(node, modifiers, isTypeOnly, name, moduleReference);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, isTypeOnly, name, moduleReference, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (isTypeOnly === void 0 || typeof isTypeOnly === "boolean") && typeof name !== "boolean" && typeof moduleReference !== "string",
|
|
1: ([, decorators, modifiers, isTypeOnly, name, moduleReference]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (isTypeOnly === void 0 || typeof isTypeOnly === "boolean") && (typeof name === "string" || isIdentifier(name)) && (moduleReference !== void 0 && isModuleReference(moduleReference))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createImportDeclaration = buildOverload("createImportDeclaration").overload({
|
|
0(modifiers, importClause, moduleSpecifier, assertClause) {
|
|
return createImportDeclaration2(modifiers, importClause, moduleSpecifier, assertClause);
|
|
},
|
|
1(_decorators, modifiers, importClause, moduleSpecifier, assertClause) {
|
|
return createImportDeclaration2(modifiers, importClause, moduleSpecifier, assertClause);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, importClause, moduleSpecifier, assertClause, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (importClause === void 0 || !isArray(importClause)) && (moduleSpecifier !== void 0 && isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause)),
|
|
1: ([decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (importClause === void 0 || isImportClause(importClause)) && (moduleSpecifier !== void 0 && isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateImportDeclaration = buildOverload("updateImportDeclaration").overload({
|
|
0(node, modifiers, importClause, moduleSpecifier, assertClause) {
|
|
return updateImportDeclaration2(node, modifiers, importClause, moduleSpecifier, assertClause);
|
|
},
|
|
1(node, _decorators, modifiers, importClause, moduleSpecifier, assertClause) {
|
|
return updateImportDeclaration2(node, modifiers, importClause, moduleSpecifier, assertClause);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, importClause, moduleSpecifier, assertClause, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (importClause === void 0 || !isArray(importClause)) && (moduleSpecifier === void 0 || isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause)),
|
|
1: ([, decorators, modifiers, importClause, moduleSpecifier, assertClause]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (importClause === void 0 || isImportClause(importClause)) && (moduleSpecifier !== void 0 && isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createExportAssignment = buildOverload("createExportAssignment").overload({
|
|
0(modifiers, isExportEquals, expression) {
|
|
return createExportAssignment3(modifiers, isExportEquals, expression);
|
|
},
|
|
1(_decorators, modifiers, isExportEquals, expression) {
|
|
return createExportAssignment3(modifiers, isExportEquals, expression);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, isExportEquals, expression, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (isExportEquals === void 0 || typeof isExportEquals === "boolean") && typeof expression === "object",
|
|
1: ([decorators, modifiers, isExportEquals, expression]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (isExportEquals === void 0 || typeof isExportEquals === "boolean") && (expression !== void 0 && isExpression(expression))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateExportAssignment = buildOverload("updateExportAssignment").overload({
|
|
0(node, modifiers, expression) {
|
|
return updateExportAssignment2(node, modifiers, expression);
|
|
},
|
|
1(node, _decorators, modifiers, expression) {
|
|
return updateExportAssignment2(node, modifiers, expression);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, expression, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && (expression !== void 0 && !isArray(expression)),
|
|
1: ([, decorators, modifiers, expression]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && (expression !== void 0 && isExpression(expression))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.createExportDeclaration = buildOverload("createExportDeclaration").overload({
|
|
0(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
return createExportDeclaration3(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
},
|
|
1(_decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
return createExportDeclaration3(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
}
|
|
}).bind({
|
|
0: ([modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && typeof isTypeOnly === "boolean" && typeof exportClause !== "boolean" && (moduleSpecifier === void 0 || isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause)),
|
|
1: ([decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && typeof isTypeOnly === "boolean" && (exportClause === void 0 || isNamedExportBindings(exportClause)) && (moduleSpecifier === void 0 || isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
factory2.updateExportDeclaration = buildOverload("updateExportDeclaration").overload({
|
|
0(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
return updateExportDeclaration3(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
},
|
|
1(node, _decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) {
|
|
return updateExportDeclaration3(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
|
|
}
|
|
}).bind({
|
|
0: ([, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause, other]) => other === void 0 && (modifiers === void 0 || every(modifiers, isModifier)) && typeof isTypeOnly === "boolean" && typeof exportClause !== "boolean" && (moduleSpecifier === void 0 || isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause)),
|
|
1: ([, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause]) => (decorators === void 0 || every(decorators, isDecorator)) && (modifiers === void 0 || isArray(modifiers)) && typeof isTypeOnly === "boolean" && (exportClause === void 0 || isNamedExportBindings(exportClause)) && (moduleSpecifier === void 0 || isExpression(moduleSpecifier)) && (assertClause === void 0 || isAssertClause(assertClause))
|
|
}).deprecate({
|
|
1: DISALLOW_DECORATORS
|
|
}).finish();
|
|
}
|
|
addNodeFactoryPatcher(patchNodeFactory4);
|
|
patchNodeFactory4(factory);
|
|
|
|
// src/server/utilitiesPublic.ts
|
|
var LogLevel2 = /* @__PURE__ */ ((LogLevel3) => {
|
|
LogLevel3[LogLevel3["terse"] = 0] = "terse";
|
|
LogLevel3[LogLevel3["normal"] = 1] = "normal";
|
|
LogLevel3[LogLevel3["requestTime"] = 2] = "requestTime";
|
|
LogLevel3[LogLevel3["verbose"] = 3] = "verbose";
|
|
return LogLevel3;
|
|
})(LogLevel2 || {});
|
|
var emptyArray2 = createSortedArray2();
|
|
var Msg = /* @__PURE__ */ ((Msg2) => {
|
|
Msg2["Err"] = "Err";
|
|
Msg2["Info"] = "Info";
|
|
Msg2["Perf"] = "Perf";
|
|
return Msg2;
|
|
})(Msg || {});
|
|
function createInstallTypingsRequest(project, typeAcquisition, unresolvedImports, cachePath) {
|
|
return {
|
|
projectName: project.getProjectName(),
|
|
fileNames: project.getFileNames(true, true).concat(project.getExcludedFiles()),
|
|
compilerOptions: project.getCompilationSettings(),
|
|
watchOptions: project.projectService.getWatchOptions(project),
|
|
typeAcquisition,
|
|
unresolvedImports,
|
|
projectRootPath: project.getCurrentDirectory(),
|
|
cachePath,
|
|
kind: "discover"
|
|
};
|
|
}
|
|
var Errors;
|
|
((Errors2) => {
|
|
function ThrowNoProject() {
|
|
throw new Error("No Project.");
|
|
}
|
|
Errors2.ThrowNoProject = ThrowNoProject;
|
|
function ThrowProjectLanguageServiceDisabled() {
|
|
throw new Error("The project's language service is disabled.");
|
|
}
|
|
Errors2.ThrowProjectLanguageServiceDisabled = ThrowProjectLanguageServiceDisabled;
|
|
function ThrowProjectDoesNotContainDocument(fileName, project) {
|
|
throw new Error(`Project '${project.getProjectName()}' does not contain document '${fileName}'`);
|
|
}
|
|
Errors2.ThrowProjectDoesNotContainDocument = ThrowProjectDoesNotContainDocument;
|
|
})(Errors || (Errors = {}));
|
|
function toNormalizedPath(fileName) {
|
|
return normalizePath(fileName);
|
|
}
|
|
function normalizedPathToPath(normalizedPath, currentDirectory, getCanonicalFileName) {
|
|
const f = isRootedDiskPath(normalizedPath) ? normalizedPath : getNormalizedAbsolutePath(normalizedPath, currentDirectory);
|
|
return getCanonicalFileName(f);
|
|
}
|
|
function asNormalizedPath(fileName) {
|
|
return fileName;
|
|
}
|
|
function createNormalizedPathMap() {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
return {
|
|
get(path) {
|
|
return map2.get(path);
|
|
},
|
|
set(path, value) {
|
|
map2.set(path, value);
|
|
},
|
|
contains(path) {
|
|
return map2.has(path);
|
|
},
|
|
remove(path) {
|
|
map2.delete(path);
|
|
}
|
|
};
|
|
}
|
|
function isInferredProjectName(name) {
|
|
return /dev\/null\/inferredProject\d+\*/.test(name);
|
|
}
|
|
function makeInferredProjectName(counter) {
|
|
return `/dev/null/inferredProject${counter}*`;
|
|
}
|
|
function makeAutoImportProviderProjectName(counter) {
|
|
return `/dev/null/autoImportProviderProject${counter}*`;
|
|
}
|
|
function makeAuxiliaryProjectName(counter) {
|
|
return `/dev/null/auxiliaryProject${counter}*`;
|
|
}
|
|
function createSortedArray2() {
|
|
return [];
|
|
}
|
|
|
|
// src/server/utilities.ts
|
|
var ThrottledOperations = class {
|
|
constructor(host, logger) {
|
|
this.host = host;
|
|
this.pendingTimeouts = /* @__PURE__ */ new Map();
|
|
this.logger = logger.hasLevel(3 /* verbose */) ? logger : void 0;
|
|
}
|
|
schedule(operationId, delay, cb) {
|
|
const pendingTimeout = this.pendingTimeouts.get(operationId);
|
|
if (pendingTimeout) {
|
|
this.host.clearTimeout(pendingTimeout);
|
|
}
|
|
this.pendingTimeouts.set(operationId, this.host.setTimeout(ThrottledOperations.run, delay, this, operationId, cb));
|
|
if (this.logger) {
|
|
this.logger.info(`Scheduled: ${operationId}${pendingTimeout ? ", Cancelled earlier one" : ""}`);
|
|
}
|
|
}
|
|
cancel(operationId) {
|
|
const pendingTimeout = this.pendingTimeouts.get(operationId);
|
|
if (!pendingTimeout)
|
|
return false;
|
|
this.host.clearTimeout(pendingTimeout);
|
|
return this.pendingTimeouts.delete(operationId);
|
|
}
|
|
static run(self2, operationId, cb) {
|
|
perfLogger.logStartScheduledOperation(operationId);
|
|
self2.pendingTimeouts.delete(operationId);
|
|
if (self2.logger) {
|
|
self2.logger.info(`Running: ${operationId}`);
|
|
}
|
|
cb();
|
|
perfLogger.logStopScheduledOperation();
|
|
}
|
|
};
|
|
var GcTimer = class {
|
|
constructor(host, delay, logger) {
|
|
this.host = host;
|
|
this.delay = delay;
|
|
this.logger = logger;
|
|
}
|
|
scheduleCollect() {
|
|
if (!this.host.gc || this.timerId !== void 0) {
|
|
return;
|
|
}
|
|
this.timerId = this.host.setTimeout(GcTimer.run, this.delay, this);
|
|
}
|
|
static run(self2) {
|
|
self2.timerId = void 0;
|
|
perfLogger.logStartScheduledOperation("GC collect");
|
|
const log = self2.logger.hasLevel(2 /* requestTime */);
|
|
const before = log && self2.host.getMemoryUsage();
|
|
self2.host.gc();
|
|
if (log) {
|
|
const after = self2.host.getMemoryUsage();
|
|
self2.logger.perftrc(`GC::before ${before}, after ${after}`);
|
|
}
|
|
perfLogger.logStopScheduledOperation();
|
|
}
|
|
};
|
|
function getBaseConfigFileName(configFilePath) {
|
|
const base = getBaseFileName(configFilePath);
|
|
return base === "tsconfig.json" || base === "jsconfig.json" ? base : void 0;
|
|
}
|
|
function removeSorted(array, remove, compare) {
|
|
if (!array || array.length === 0) {
|
|
return;
|
|
}
|
|
if (array[0] === remove) {
|
|
array.splice(0, 1);
|
|
return;
|
|
}
|
|
const removeIndex = binarySearch(array, remove, identity, compare);
|
|
if (removeIndex >= 0) {
|
|
array.splice(removeIndex, 1);
|
|
}
|
|
}
|
|
var indentStr = "\n ";
|
|
function indent2(str) {
|
|
return indentStr + str.replace(/\n/g, indentStr);
|
|
}
|
|
function stringifyIndented(json) {
|
|
return indentStr + JSON.stringify(json);
|
|
}
|
|
|
|
// src/server/_namespaces/ts.server.protocol.ts
|
|
var ts_server_protocol_exports = {};
|
|
__export(ts_server_protocol_exports, {
|
|
ClassificationType: () => ClassificationType2,
|
|
CommandTypes: () => CommandTypes,
|
|
CompletionTriggerKind: () => CompletionTriggerKind2,
|
|
IndentStyle: () => IndentStyle2,
|
|
JsxEmit: () => JsxEmit2,
|
|
ModuleKind: () => ModuleKind2,
|
|
ModuleResolutionKind: () => ModuleResolutionKind2,
|
|
NewLineKind: () => NewLineKind2,
|
|
OrganizeImportsMode: () => OrganizeImportsMode2,
|
|
PollingWatchKind: () => PollingWatchKind2,
|
|
ScriptTarget: () => ScriptTarget10,
|
|
SemicolonPreference: () => SemicolonPreference2,
|
|
WatchDirectoryKind: () => WatchDirectoryKind2,
|
|
WatchFileKind: () => WatchFileKind2
|
|
});
|
|
|
|
// src/server/protocol.ts
|
|
var CommandTypes = /* @__PURE__ */ ((CommandTypes2) => {
|
|
CommandTypes2["JsxClosingTag"] = "jsxClosingTag";
|
|
CommandTypes2["Brace"] = "brace";
|
|
CommandTypes2["BraceFull"] = "brace-full";
|
|
CommandTypes2["BraceCompletion"] = "braceCompletion";
|
|
CommandTypes2["GetSpanOfEnclosingComment"] = "getSpanOfEnclosingComment";
|
|
CommandTypes2["Change"] = "change";
|
|
CommandTypes2["Close"] = "close";
|
|
CommandTypes2["Completions"] = "completions";
|
|
CommandTypes2["CompletionInfo"] = "completionInfo";
|
|
CommandTypes2["CompletionsFull"] = "completions-full";
|
|
CommandTypes2["CompletionDetails"] = "completionEntryDetails";
|
|
CommandTypes2["CompletionDetailsFull"] = "completionEntryDetails-full";
|
|
CommandTypes2["CompileOnSaveAffectedFileList"] = "compileOnSaveAffectedFileList";
|
|
CommandTypes2["CompileOnSaveEmitFile"] = "compileOnSaveEmitFile";
|
|
CommandTypes2["Configure"] = "configure";
|
|
CommandTypes2["Definition"] = "definition";
|
|
CommandTypes2["DefinitionFull"] = "definition-full";
|
|
CommandTypes2["DefinitionAndBoundSpan"] = "definitionAndBoundSpan";
|
|
CommandTypes2["DefinitionAndBoundSpanFull"] = "definitionAndBoundSpan-full";
|
|
CommandTypes2["Implementation"] = "implementation";
|
|
CommandTypes2["ImplementationFull"] = "implementation-full";
|
|
CommandTypes2["EmitOutput"] = "emit-output";
|
|
CommandTypes2["Exit"] = "exit";
|
|
CommandTypes2["FileReferences"] = "fileReferences";
|
|
CommandTypes2["FileReferencesFull"] = "fileReferences-full";
|
|
CommandTypes2["Format"] = "format";
|
|
CommandTypes2["Formatonkey"] = "formatonkey";
|
|
CommandTypes2["FormatFull"] = "format-full";
|
|
CommandTypes2["FormatonkeyFull"] = "formatonkey-full";
|
|
CommandTypes2["FormatRangeFull"] = "formatRange-full";
|
|
CommandTypes2["Geterr"] = "geterr";
|
|
CommandTypes2["GeterrForProject"] = "geterrForProject";
|
|
CommandTypes2["SemanticDiagnosticsSync"] = "semanticDiagnosticsSync";
|
|
CommandTypes2["SyntacticDiagnosticsSync"] = "syntacticDiagnosticsSync";
|
|
CommandTypes2["SuggestionDiagnosticsSync"] = "suggestionDiagnosticsSync";
|
|
CommandTypes2["NavBar"] = "navbar";
|
|
CommandTypes2["NavBarFull"] = "navbar-full";
|
|
CommandTypes2["Navto"] = "navto";
|
|
CommandTypes2["NavtoFull"] = "navto-full";
|
|
CommandTypes2["NavTree"] = "navtree";
|
|
CommandTypes2["NavTreeFull"] = "navtree-full";
|
|
CommandTypes2["Occurrences"] = "occurrences";
|
|
CommandTypes2["DocumentHighlights"] = "documentHighlights";
|
|
CommandTypes2["DocumentHighlightsFull"] = "documentHighlights-full";
|
|
CommandTypes2["Open"] = "open";
|
|
CommandTypes2["Quickinfo"] = "quickinfo";
|
|
CommandTypes2["QuickinfoFull"] = "quickinfo-full";
|
|
CommandTypes2["References"] = "references";
|
|
CommandTypes2["ReferencesFull"] = "references-full";
|
|
CommandTypes2["Reload"] = "reload";
|
|
CommandTypes2["Rename"] = "rename";
|
|
CommandTypes2["RenameInfoFull"] = "rename-full";
|
|
CommandTypes2["RenameLocationsFull"] = "renameLocations-full";
|
|
CommandTypes2["Saveto"] = "saveto";
|
|
CommandTypes2["SignatureHelp"] = "signatureHelp";
|
|
CommandTypes2["SignatureHelpFull"] = "signatureHelp-full";
|
|
CommandTypes2["FindSourceDefinition"] = "findSourceDefinition";
|
|
CommandTypes2["Status"] = "status";
|
|
CommandTypes2["TypeDefinition"] = "typeDefinition";
|
|
CommandTypes2["ProjectInfo"] = "projectInfo";
|
|
CommandTypes2["ReloadProjects"] = "reloadProjects";
|
|
CommandTypes2["Unknown"] = "unknown";
|
|
CommandTypes2["OpenExternalProject"] = "openExternalProject";
|
|
CommandTypes2["OpenExternalProjects"] = "openExternalProjects";
|
|
CommandTypes2["CloseExternalProject"] = "closeExternalProject";
|
|
CommandTypes2["SynchronizeProjectList"] = "synchronizeProjectList";
|
|
CommandTypes2["ApplyChangedToOpenFiles"] = "applyChangedToOpenFiles";
|
|
CommandTypes2["UpdateOpen"] = "updateOpen";
|
|
CommandTypes2["EncodedSyntacticClassificationsFull"] = "encodedSyntacticClassifications-full";
|
|
CommandTypes2["EncodedSemanticClassificationsFull"] = "encodedSemanticClassifications-full";
|
|
CommandTypes2["Cleanup"] = "cleanup";
|
|
CommandTypes2["GetOutliningSpans"] = "getOutliningSpans";
|
|
CommandTypes2["GetOutliningSpansFull"] = "outliningSpans";
|
|
CommandTypes2["TodoComments"] = "todoComments";
|
|
CommandTypes2["Indentation"] = "indentation";
|
|
CommandTypes2["DocCommentTemplate"] = "docCommentTemplate";
|
|
CommandTypes2["CompilerOptionsDiagnosticsFull"] = "compilerOptionsDiagnostics-full";
|
|
CommandTypes2["NameOrDottedNameSpan"] = "nameOrDottedNameSpan";
|
|
CommandTypes2["BreakpointStatement"] = "breakpointStatement";
|
|
CommandTypes2["CompilerOptionsForInferredProjects"] = "compilerOptionsForInferredProjects";
|
|
CommandTypes2["GetCodeFixes"] = "getCodeFixes";
|
|
CommandTypes2["GetCodeFixesFull"] = "getCodeFixes-full";
|
|
CommandTypes2["GetCombinedCodeFix"] = "getCombinedCodeFix";
|
|
CommandTypes2["GetCombinedCodeFixFull"] = "getCombinedCodeFix-full";
|
|
CommandTypes2["ApplyCodeActionCommand"] = "applyCodeActionCommand";
|
|
CommandTypes2["GetSupportedCodeFixes"] = "getSupportedCodeFixes";
|
|
CommandTypes2["GetApplicableRefactors"] = "getApplicableRefactors";
|
|
CommandTypes2["GetEditsForRefactor"] = "getEditsForRefactor";
|
|
CommandTypes2["GetEditsForRefactorFull"] = "getEditsForRefactor-full";
|
|
CommandTypes2["OrganizeImports"] = "organizeImports";
|
|
CommandTypes2["OrganizeImportsFull"] = "organizeImports-full";
|
|
CommandTypes2["GetEditsForFileRename"] = "getEditsForFileRename";
|
|
CommandTypes2["GetEditsForFileRenameFull"] = "getEditsForFileRename-full";
|
|
CommandTypes2["ConfigurePlugin"] = "configurePlugin";
|
|
CommandTypes2["SelectionRange"] = "selectionRange";
|
|
CommandTypes2["SelectionRangeFull"] = "selectionRange-full";
|
|
CommandTypes2["ToggleLineComment"] = "toggleLineComment";
|
|
CommandTypes2["ToggleLineCommentFull"] = "toggleLineComment-full";
|
|
CommandTypes2["ToggleMultilineComment"] = "toggleMultilineComment";
|
|
CommandTypes2["ToggleMultilineCommentFull"] = "toggleMultilineComment-full";
|
|
CommandTypes2["CommentSelection"] = "commentSelection";
|
|
CommandTypes2["CommentSelectionFull"] = "commentSelection-full";
|
|
CommandTypes2["UncommentSelection"] = "uncommentSelection";
|
|
CommandTypes2["UncommentSelectionFull"] = "uncommentSelection-full";
|
|
CommandTypes2["PrepareCallHierarchy"] = "prepareCallHierarchy";
|
|
CommandTypes2["ProvideCallHierarchyIncomingCalls"] = "provideCallHierarchyIncomingCalls";
|
|
CommandTypes2["ProvideCallHierarchyOutgoingCalls"] = "provideCallHierarchyOutgoingCalls";
|
|
CommandTypes2["ProvideInlayHints"] = "provideInlayHints";
|
|
return CommandTypes2;
|
|
})(CommandTypes || {});
|
|
var OrganizeImportsMode2 = /* @__PURE__ */ ((OrganizeImportsMode3) => {
|
|
OrganizeImportsMode3["All"] = "All";
|
|
OrganizeImportsMode3["SortAndCombine"] = "SortAndCombine";
|
|
OrganizeImportsMode3["RemoveUnused"] = "RemoveUnused";
|
|
return OrganizeImportsMode3;
|
|
})(OrganizeImportsMode2 || {});
|
|
var WatchFileKind2 = /* @__PURE__ */ ((WatchFileKind3) => {
|
|
WatchFileKind3["FixedPollingInterval"] = "FixedPollingInterval";
|
|
WatchFileKind3["PriorityPollingInterval"] = "PriorityPollingInterval";
|
|
WatchFileKind3["DynamicPriorityPolling"] = "DynamicPriorityPolling";
|
|
WatchFileKind3["FixedChunkSizePolling"] = "FixedChunkSizePolling";
|
|
WatchFileKind3["UseFsEvents"] = "UseFsEvents";
|
|
WatchFileKind3["UseFsEventsOnParentDirectory"] = "UseFsEventsOnParentDirectory";
|
|
return WatchFileKind3;
|
|
})(WatchFileKind2 || {});
|
|
var WatchDirectoryKind2 = /* @__PURE__ */ ((WatchDirectoryKind3) => {
|
|
WatchDirectoryKind3["UseFsEvents"] = "UseFsEvents";
|
|
WatchDirectoryKind3["FixedPollingInterval"] = "FixedPollingInterval";
|
|
WatchDirectoryKind3["DynamicPriorityPolling"] = "DynamicPriorityPolling";
|
|
WatchDirectoryKind3["FixedChunkSizePolling"] = "FixedChunkSizePolling";
|
|
return WatchDirectoryKind3;
|
|
})(WatchDirectoryKind2 || {});
|
|
var PollingWatchKind2 = /* @__PURE__ */ ((PollingWatchKind3) => {
|
|
PollingWatchKind3["FixedInterval"] = "FixedInterval";
|
|
PollingWatchKind3["PriorityInterval"] = "PriorityInterval";
|
|
PollingWatchKind3["DynamicPriority"] = "DynamicPriority";
|
|
PollingWatchKind3["FixedChunkSize"] = "FixedChunkSize";
|
|
return PollingWatchKind3;
|
|
})(PollingWatchKind2 || {});
|
|
var CompletionTriggerKind2 = /* @__PURE__ */ ((CompletionTriggerKind4) => {
|
|
CompletionTriggerKind4[CompletionTriggerKind4["Invoked"] = 1] = "Invoked";
|
|
CompletionTriggerKind4[CompletionTriggerKind4["TriggerCharacter"] = 2] = "TriggerCharacter";
|
|
CompletionTriggerKind4[CompletionTriggerKind4["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions";
|
|
return CompletionTriggerKind4;
|
|
})(CompletionTriggerKind2 || {});
|
|
var IndentStyle2 = /* @__PURE__ */ ((IndentStyle3) => {
|
|
IndentStyle3["None"] = "None";
|
|
IndentStyle3["Block"] = "Block";
|
|
IndentStyle3["Smart"] = "Smart";
|
|
return IndentStyle3;
|
|
})(IndentStyle2 || {});
|
|
var SemicolonPreference2 = /* @__PURE__ */ ((SemicolonPreference3) => {
|
|
SemicolonPreference3["Ignore"] = "ignore";
|
|
SemicolonPreference3["Insert"] = "insert";
|
|
SemicolonPreference3["Remove"] = "remove";
|
|
return SemicolonPreference3;
|
|
})(SemicolonPreference2 || {});
|
|
var JsxEmit2 = /* @__PURE__ */ ((JsxEmit3) => {
|
|
JsxEmit3["None"] = "None";
|
|
JsxEmit3["Preserve"] = "Preserve";
|
|
JsxEmit3["ReactNative"] = "ReactNative";
|
|
JsxEmit3["React"] = "React";
|
|
return JsxEmit3;
|
|
})(JsxEmit2 || {});
|
|
var ModuleKind2 = /* @__PURE__ */ ((ModuleKind3) => {
|
|
ModuleKind3["None"] = "None";
|
|
ModuleKind3["CommonJS"] = "CommonJS";
|
|
ModuleKind3["AMD"] = "AMD";
|
|
ModuleKind3["UMD"] = "UMD";
|
|
ModuleKind3["System"] = "System";
|
|
ModuleKind3["ES6"] = "ES6";
|
|
ModuleKind3["ES2015"] = "ES2015";
|
|
ModuleKind3["ESNext"] = "ESNext";
|
|
return ModuleKind3;
|
|
})(ModuleKind2 || {});
|
|
var ModuleResolutionKind2 = /* @__PURE__ */ ((ModuleResolutionKind3) => {
|
|
ModuleResolutionKind3["Classic"] = "Classic";
|
|
ModuleResolutionKind3["Node"] = "Node";
|
|
return ModuleResolutionKind3;
|
|
})(ModuleResolutionKind2 || {});
|
|
var NewLineKind2 = /* @__PURE__ */ ((NewLineKind3) => {
|
|
NewLineKind3["Crlf"] = "Crlf";
|
|
NewLineKind3["Lf"] = "Lf";
|
|
return NewLineKind3;
|
|
})(NewLineKind2 || {});
|
|
var ScriptTarget10 = /* @__PURE__ */ ((ScriptTarget11) => {
|
|
ScriptTarget11["ES3"] = "ES3";
|
|
ScriptTarget11["ES5"] = "ES5";
|
|
ScriptTarget11["ES6"] = "ES6";
|
|
ScriptTarget11["ES2015"] = "ES2015";
|
|
ScriptTarget11["ES2016"] = "ES2016";
|
|
ScriptTarget11["ES2017"] = "ES2017";
|
|
ScriptTarget11["ES2018"] = "ES2018";
|
|
ScriptTarget11["ES2019"] = "ES2019";
|
|
ScriptTarget11["ES2020"] = "ES2020";
|
|
ScriptTarget11["ES2021"] = "ES2021";
|
|
ScriptTarget11["ES2022"] = "ES2022";
|
|
ScriptTarget11["ESNext"] = "ESNext";
|
|
return ScriptTarget11;
|
|
})(ScriptTarget10 || {});
|
|
var ClassificationType2 = /* @__PURE__ */ ((ClassificationType3) => {
|
|
ClassificationType3[ClassificationType3["comment"] = 1] = "comment";
|
|
ClassificationType3[ClassificationType3["identifier"] = 2] = "identifier";
|
|
ClassificationType3[ClassificationType3["keyword"] = 3] = "keyword";
|
|
ClassificationType3[ClassificationType3["numericLiteral"] = 4] = "numericLiteral";
|
|
ClassificationType3[ClassificationType3["operator"] = 5] = "operator";
|
|
ClassificationType3[ClassificationType3["stringLiteral"] = 6] = "stringLiteral";
|
|
ClassificationType3[ClassificationType3["regularExpressionLiteral"] = 7] = "regularExpressionLiteral";
|
|
ClassificationType3[ClassificationType3["whiteSpace"] = 8] = "whiteSpace";
|
|
ClassificationType3[ClassificationType3["text"] = 9] = "text";
|
|
ClassificationType3[ClassificationType3["punctuation"] = 10] = "punctuation";
|
|
ClassificationType3[ClassificationType3["className"] = 11] = "className";
|
|
ClassificationType3[ClassificationType3["enumName"] = 12] = "enumName";
|
|
ClassificationType3[ClassificationType3["interfaceName"] = 13] = "interfaceName";
|
|
ClassificationType3[ClassificationType3["moduleName"] = 14] = "moduleName";
|
|
ClassificationType3[ClassificationType3["typeParameterName"] = 15] = "typeParameterName";
|
|
ClassificationType3[ClassificationType3["typeAliasName"] = 16] = "typeAliasName";
|
|
ClassificationType3[ClassificationType3["parameterName"] = 17] = "parameterName";
|
|
ClassificationType3[ClassificationType3["docCommentTagName"] = 18] = "docCommentTagName";
|
|
ClassificationType3[ClassificationType3["jsxOpenTagName"] = 19] = "jsxOpenTagName";
|
|
ClassificationType3[ClassificationType3["jsxCloseTagName"] = 20] = "jsxCloseTagName";
|
|
ClassificationType3[ClassificationType3["jsxSelfClosingTagName"] = 21] = "jsxSelfClosingTagName";
|
|
ClassificationType3[ClassificationType3["jsxAttribute"] = 22] = "jsxAttribute";
|
|
ClassificationType3[ClassificationType3["jsxText"] = 23] = "jsxText";
|
|
ClassificationType3[ClassificationType3["jsxAttributeStringLiteralValue"] = 24] = "jsxAttributeStringLiteralValue";
|
|
ClassificationType3[ClassificationType3["bigintLiteral"] = 25] = "bigintLiteral";
|
|
return ClassificationType3;
|
|
})(ClassificationType2 || {});
|
|
|
|
// src/server/scriptInfo.ts
|
|
var TextStorage = class {
|
|
constructor(host, info, initialVersion) {
|
|
this.host = host;
|
|
this.info = info;
|
|
this.isOpen = false;
|
|
this.ownFileText = false;
|
|
this.pendingReloadFromDisk = false;
|
|
this.version = initialVersion || { svc: 0, text: 0 };
|
|
}
|
|
getVersion() {
|
|
return this.svc ? `SVC-${this.version.svc}-${this.svc.getSnapshotVersion()}` : `Text-${this.version.text}`;
|
|
}
|
|
hasScriptVersionCache_TestOnly() {
|
|
return this.svc !== void 0;
|
|
}
|
|
useScriptVersionCache_TestOnly() {
|
|
this.switchToScriptVersionCache();
|
|
}
|
|
resetSourceMapInfo() {
|
|
this.info.sourceFileLike = void 0;
|
|
this.info.closeSourceMapFileWatcher();
|
|
this.info.sourceMapFilePath = void 0;
|
|
this.info.declarationInfoPath = void 0;
|
|
this.info.sourceInfos = void 0;
|
|
this.info.documentPositionMapper = void 0;
|
|
}
|
|
useText(newText) {
|
|
this.svc = void 0;
|
|
this.text = newText;
|
|
this.lineMap = void 0;
|
|
this.fileSize = void 0;
|
|
this.resetSourceMapInfo();
|
|
this.version.text++;
|
|
}
|
|
edit(start2, end, newText) {
|
|
this.switchToScriptVersionCache().edit(start2, end - start2, newText);
|
|
this.ownFileText = false;
|
|
this.text = void 0;
|
|
this.lineMap = void 0;
|
|
this.fileSize = void 0;
|
|
this.resetSourceMapInfo();
|
|
}
|
|
reload(newText) {
|
|
Debug.assert(newText !== void 0);
|
|
this.pendingReloadFromDisk = false;
|
|
if (this.text !== newText) {
|
|
this.useText(newText);
|
|
this.ownFileText = false;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
reloadWithFileText(tempFileName) {
|
|
const { text: newText, fileSize } = this.getFileTextAndSize(tempFileName);
|
|
const reloaded = this.reload(newText);
|
|
this.fileSize = fileSize;
|
|
this.ownFileText = !tempFileName || tempFileName === this.info.fileName;
|
|
return reloaded;
|
|
}
|
|
reloadFromDisk() {
|
|
if (!this.pendingReloadFromDisk && !this.ownFileText) {
|
|
return this.reloadWithFileText();
|
|
}
|
|
return false;
|
|
}
|
|
delayReloadFromFileIntoText() {
|
|
this.pendingReloadFromDisk = true;
|
|
}
|
|
getTelemetryFileSize() {
|
|
return !!this.fileSize ? this.fileSize : !!this.text ? this.text.length : !!this.svc ? this.svc.getSnapshot().getLength() : this.getSnapshot().getLength();
|
|
}
|
|
getSnapshot() {
|
|
return this.useScriptVersionCacheIfValidOrOpen() ? this.svc.getSnapshot() : ScriptSnapshot.fromString(this.getOrLoadText());
|
|
}
|
|
getAbsolutePositionAndLineText(line) {
|
|
return this.switchToScriptVersionCache().getAbsolutePositionAndLineText(line);
|
|
}
|
|
lineToTextSpan(line) {
|
|
if (!this.useScriptVersionCacheIfValidOrOpen()) {
|
|
const lineMap = this.getLineMap();
|
|
const start2 = lineMap[line];
|
|
const end = line + 1 < lineMap.length ? lineMap[line + 1] : this.text.length;
|
|
return createTextSpanFromBounds(start2, end);
|
|
}
|
|
return this.svc.lineToTextSpan(line);
|
|
}
|
|
lineOffsetToPosition(line, offset, allowEdits) {
|
|
if (!this.useScriptVersionCacheIfValidOrOpen()) {
|
|
return computePositionOfLineAndCharacter(this.getLineMap(), line - 1, offset - 1, this.text, allowEdits);
|
|
}
|
|
return this.svc.lineOffsetToPosition(line, offset);
|
|
}
|
|
positionToLineOffset(position) {
|
|
if (!this.useScriptVersionCacheIfValidOrOpen()) {
|
|
const { line, character } = computeLineAndCharacterOfPosition(this.getLineMap(), position);
|
|
return { line: line + 1, offset: character + 1 };
|
|
}
|
|
return this.svc.positionToLineOffset(position);
|
|
}
|
|
getFileTextAndSize(tempFileName) {
|
|
let text;
|
|
const fileName = tempFileName || this.info.fileName;
|
|
const getText = () => text === void 0 ? text = this.host.readFile(fileName) || "" : text;
|
|
if (!hasTSFileExtension(this.info.fileName)) {
|
|
const fileSize = this.host.getFileSize ? this.host.getFileSize(fileName) : getText().length;
|
|
if (fileSize > maxFileSize) {
|
|
Debug.assert(!!this.info.containingProjects.length);
|
|
const service = this.info.containingProjects[0].projectService;
|
|
service.logger.info(`Skipped loading contents of large file ${fileName} for info ${this.info.fileName}: fileSize: ${fileSize}`);
|
|
this.info.containingProjects[0].projectService.sendLargeFileReferencedEvent(fileName, fileSize);
|
|
return { text: "", fileSize };
|
|
}
|
|
}
|
|
return { text: getText() };
|
|
}
|
|
switchToScriptVersionCache() {
|
|
if (!this.svc || this.pendingReloadFromDisk) {
|
|
this.svc = ScriptVersionCache.fromString(this.getOrLoadText());
|
|
this.version.svc++;
|
|
}
|
|
return this.svc;
|
|
}
|
|
useScriptVersionCacheIfValidOrOpen() {
|
|
if (this.isOpen) {
|
|
return this.switchToScriptVersionCache();
|
|
}
|
|
if (this.pendingReloadFromDisk) {
|
|
this.reloadWithFileText();
|
|
}
|
|
return this.svc;
|
|
}
|
|
getOrLoadText() {
|
|
if (this.text === void 0 || this.pendingReloadFromDisk) {
|
|
Debug.assert(!this.svc || this.pendingReloadFromDisk, "ScriptVersionCache should not be set when reloading from disk");
|
|
this.reloadWithFileText();
|
|
}
|
|
return this.text;
|
|
}
|
|
getLineMap() {
|
|
Debug.assert(!this.svc, "ScriptVersionCache should not be set");
|
|
return this.lineMap || (this.lineMap = computeLineStarts(this.getOrLoadText()));
|
|
}
|
|
getLineInfo() {
|
|
if (this.svc) {
|
|
return {
|
|
getLineCount: () => this.svc.getLineCount(),
|
|
getLineText: (line) => this.svc.getAbsolutePositionAndLineText(line + 1).lineText
|
|
};
|
|
}
|
|
const lineMap = this.getLineMap();
|
|
return getLineInfo(this.text, lineMap);
|
|
}
|
|
};
|
|
function isDynamicFileName(fileName) {
|
|
return fileName[0] === "^" || (stringContains(fileName, "walkThroughSnippet:/") || stringContains(fileName, "untitled:/")) && getBaseFileName(fileName)[0] === "^" || stringContains(fileName, ":^") && !stringContains(fileName, directorySeparator);
|
|
}
|
|
var ScriptInfo = class {
|
|
constructor(host, fileName, scriptKind, hasMixedContent, path, initialVersion) {
|
|
this.host = host;
|
|
this.fileName = fileName;
|
|
this.scriptKind = scriptKind;
|
|
this.hasMixedContent = hasMixedContent;
|
|
this.path = path;
|
|
this.containingProjects = [];
|
|
this.isDynamic = isDynamicFileName(fileName);
|
|
this.textStorage = new TextStorage(host, this, initialVersion);
|
|
if (hasMixedContent || this.isDynamic) {
|
|
this.textStorage.reload("");
|
|
this.realpath = this.path;
|
|
}
|
|
this.scriptKind = scriptKind ? scriptKind : getScriptKindFromFileName(fileName);
|
|
}
|
|
getVersion() {
|
|
return this.textStorage.version;
|
|
}
|
|
getTelemetryFileSize() {
|
|
return this.textStorage.getTelemetryFileSize();
|
|
}
|
|
isDynamicOrHasMixedContent() {
|
|
return this.hasMixedContent || this.isDynamic;
|
|
}
|
|
isScriptOpen() {
|
|
return this.textStorage.isOpen;
|
|
}
|
|
open(newText) {
|
|
this.textStorage.isOpen = true;
|
|
if (newText !== void 0 && this.textStorage.reload(newText)) {
|
|
this.markContainingProjectsAsDirty();
|
|
}
|
|
}
|
|
close(fileExists = true) {
|
|
this.textStorage.isOpen = false;
|
|
if (this.isDynamicOrHasMixedContent() || !fileExists) {
|
|
if (this.textStorage.reload("")) {
|
|
this.markContainingProjectsAsDirty();
|
|
}
|
|
} else if (this.textStorage.reloadFromDisk()) {
|
|
this.markContainingProjectsAsDirty();
|
|
}
|
|
}
|
|
getSnapshot() {
|
|
return this.textStorage.getSnapshot();
|
|
}
|
|
ensureRealPath() {
|
|
if (this.realpath === void 0) {
|
|
this.realpath = this.path;
|
|
if (this.host.realpath) {
|
|
Debug.assert(!!this.containingProjects.length);
|
|
const project = this.containingProjects[0];
|
|
const realpath = this.host.realpath(this.path);
|
|
if (realpath) {
|
|
this.realpath = project.toPath(realpath);
|
|
if (this.realpath !== this.path) {
|
|
project.projectService.realpathToScriptInfos.add(this.realpath, this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
getRealpathIfDifferent() {
|
|
return this.realpath && this.realpath !== this.path ? this.realpath : void 0;
|
|
}
|
|
isSymlink() {
|
|
return this.realpath && this.realpath !== this.path;
|
|
}
|
|
getFormatCodeSettings() {
|
|
return this.formatSettings;
|
|
}
|
|
getPreferences() {
|
|
return this.preferences;
|
|
}
|
|
attachToProject(project) {
|
|
const isNew = !this.isAttached(project);
|
|
if (isNew) {
|
|
this.containingProjects.push(project);
|
|
if (!project.getCompilerOptions().preserveSymlinks) {
|
|
this.ensureRealPath();
|
|
}
|
|
project.onFileAddedOrRemoved(this.isSymlink());
|
|
}
|
|
return isNew;
|
|
}
|
|
isAttached(project) {
|
|
switch (this.containingProjects.length) {
|
|
case 0:
|
|
return false;
|
|
case 1:
|
|
return this.containingProjects[0] === project;
|
|
case 2:
|
|
return this.containingProjects[0] === project || this.containingProjects[1] === project;
|
|
default:
|
|
return contains(this.containingProjects, project);
|
|
}
|
|
}
|
|
detachFromProject(project) {
|
|
switch (this.containingProjects.length) {
|
|
case 0:
|
|
return;
|
|
case 1:
|
|
if (this.containingProjects[0] === project) {
|
|
project.onFileAddedOrRemoved(this.isSymlink());
|
|
this.containingProjects.pop();
|
|
}
|
|
break;
|
|
case 2:
|
|
if (this.containingProjects[0] === project) {
|
|
project.onFileAddedOrRemoved(this.isSymlink());
|
|
this.containingProjects[0] = this.containingProjects.pop();
|
|
} else if (this.containingProjects[1] === project) {
|
|
project.onFileAddedOrRemoved(this.isSymlink());
|
|
this.containingProjects.pop();
|
|
}
|
|
break;
|
|
default:
|
|
if (unorderedRemoveItem(this.containingProjects, project)) {
|
|
project.onFileAddedOrRemoved(this.isSymlink());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
detachAllProjects() {
|
|
for (const p of this.containingProjects) {
|
|
if (isConfiguredProject(p)) {
|
|
p.getCachedDirectoryStructureHost().addOrDeleteFile(this.fileName, this.path, 2 /* Deleted */);
|
|
}
|
|
const existingRoot = p.getRootFilesMap().get(this.path);
|
|
p.removeFile(this, false, false);
|
|
p.onFileAddedOrRemoved(this.isSymlink());
|
|
if (existingRoot && !isInferredProject(p)) {
|
|
p.addMissingFileRoot(existingRoot.fileName);
|
|
}
|
|
}
|
|
clear(this.containingProjects);
|
|
}
|
|
getDefaultProject() {
|
|
switch (this.containingProjects.length) {
|
|
case 0:
|
|
return Errors.ThrowNoProject();
|
|
case 1:
|
|
return ensurePrimaryProjectKind(this.containingProjects[0]);
|
|
default:
|
|
let firstExternalProject;
|
|
let firstConfiguredProject;
|
|
let firstInferredProject;
|
|
let firstNonSourceOfProjectReferenceRedirect;
|
|
let defaultConfiguredProject;
|
|
for (let index = 0; index < this.containingProjects.length; index++) {
|
|
const project = this.containingProjects[index];
|
|
if (isConfiguredProject(project)) {
|
|
if (!project.isSourceOfProjectReferenceRedirect(this.fileName)) {
|
|
if (defaultConfiguredProject === void 0 && index !== this.containingProjects.length - 1) {
|
|
defaultConfiguredProject = project.projectService.findDefaultConfiguredProject(this) || false;
|
|
}
|
|
if (defaultConfiguredProject === project)
|
|
return project;
|
|
if (!firstNonSourceOfProjectReferenceRedirect)
|
|
firstNonSourceOfProjectReferenceRedirect = project;
|
|
}
|
|
if (!firstConfiguredProject)
|
|
firstConfiguredProject = project;
|
|
} else if (!firstExternalProject && isExternalProject(project)) {
|
|
firstExternalProject = project;
|
|
} else if (!firstInferredProject && isInferredProject(project)) {
|
|
firstInferredProject = project;
|
|
}
|
|
}
|
|
return ensurePrimaryProjectKind(defaultConfiguredProject || firstNonSourceOfProjectReferenceRedirect || firstConfiguredProject || firstExternalProject || firstInferredProject);
|
|
}
|
|
}
|
|
registerFileUpdate() {
|
|
for (const p of this.containingProjects) {
|
|
p.registerFileUpdate(this.path);
|
|
}
|
|
}
|
|
setOptions(formatSettings, preferences) {
|
|
if (formatSettings) {
|
|
if (!this.formatSettings) {
|
|
this.formatSettings = getDefaultFormatCodeSettings(this.host.newLine);
|
|
assign(this.formatSettings, formatSettings);
|
|
} else {
|
|
this.formatSettings = { ...this.formatSettings, ...formatSettings };
|
|
}
|
|
}
|
|
if (preferences) {
|
|
if (!this.preferences) {
|
|
this.preferences = emptyOptions;
|
|
}
|
|
this.preferences = { ...this.preferences, ...preferences };
|
|
}
|
|
}
|
|
getLatestVersion() {
|
|
this.textStorage.getSnapshot();
|
|
return this.textStorage.getVersion();
|
|
}
|
|
saveTo(fileName) {
|
|
this.host.writeFile(fileName, getSnapshotText(this.textStorage.getSnapshot()));
|
|
}
|
|
delayReloadNonMixedContentFile() {
|
|
Debug.assert(!this.isDynamicOrHasMixedContent());
|
|
this.textStorage.delayReloadFromFileIntoText();
|
|
this.markContainingProjectsAsDirty();
|
|
}
|
|
reloadFromFile(tempFileName) {
|
|
if (this.isDynamicOrHasMixedContent()) {
|
|
this.textStorage.reload("");
|
|
this.markContainingProjectsAsDirty();
|
|
return true;
|
|
} else {
|
|
if (this.textStorage.reloadWithFileText(tempFileName)) {
|
|
this.markContainingProjectsAsDirty();
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
getAbsolutePositionAndLineText(line) {
|
|
return this.textStorage.getAbsolutePositionAndLineText(line);
|
|
}
|
|
editContent(start2, end, newText) {
|
|
this.textStorage.edit(start2, end, newText);
|
|
this.markContainingProjectsAsDirty();
|
|
}
|
|
markContainingProjectsAsDirty() {
|
|
for (const p of this.containingProjects) {
|
|
p.markFileAsDirty(this.path);
|
|
}
|
|
}
|
|
isOrphan() {
|
|
return !forEach(this.containingProjects, (p) => !p.isOrphan());
|
|
}
|
|
isContainedByBackgroundProject() {
|
|
return some(
|
|
this.containingProjects,
|
|
(p) => p.projectKind === 3 /* AutoImportProvider */ || p.projectKind === 4 /* Auxiliary */
|
|
);
|
|
}
|
|
lineToTextSpan(line) {
|
|
return this.textStorage.lineToTextSpan(line);
|
|
}
|
|
lineOffsetToPosition(line, offset, allowEdits) {
|
|
return this.textStorage.lineOffsetToPosition(line, offset, allowEdits);
|
|
}
|
|
positionToLineOffset(position) {
|
|
failIfInvalidPosition(position);
|
|
const location2 = this.textStorage.positionToLineOffset(position);
|
|
failIfInvalidLocation(location2);
|
|
return location2;
|
|
}
|
|
isJavaScript() {
|
|
return this.scriptKind === 1 /* JS */ || this.scriptKind === 2 /* JSX */;
|
|
}
|
|
getLineInfo() {
|
|
return this.textStorage.getLineInfo();
|
|
}
|
|
closeSourceMapFileWatcher() {
|
|
if (this.sourceMapFilePath && !isString(this.sourceMapFilePath)) {
|
|
closeFileWatcherOf(this.sourceMapFilePath);
|
|
this.sourceMapFilePath = void 0;
|
|
}
|
|
}
|
|
};
|
|
function ensurePrimaryProjectKind(project) {
|
|
if (!project || project.projectKind === 3 /* AutoImportProvider */ || project.projectKind === 4 /* Auxiliary */) {
|
|
return Errors.ThrowNoProject();
|
|
}
|
|
return project;
|
|
}
|
|
function failIfInvalidPosition(position) {
|
|
Debug.assert(typeof position === "number", `Expected position ${position} to be a number.`);
|
|
Debug.assert(position >= 0, `Expected position to be non-negative.`);
|
|
}
|
|
function failIfInvalidLocation(location2) {
|
|
Debug.assert(typeof location2.line === "number", `Expected line ${location2.line} to be a number.`);
|
|
Debug.assert(typeof location2.offset === "number", `Expected offset ${location2.offset} to be a number.`);
|
|
Debug.assert(location2.line > 0, `Expected line to be non-${location2.line === 0 ? "zero" : "negative"}`);
|
|
Debug.assert(location2.offset > 0, `Expected offset to be non-${location2.offset === 0 ? "zero" : "negative"}`);
|
|
}
|
|
|
|
// src/server/typingsCache.ts
|
|
var nullTypingsInstaller = {
|
|
isKnownTypesPackageName: returnFalse,
|
|
installPackage: notImplemented,
|
|
enqueueInstallTypingsRequest: noop,
|
|
attach: noop,
|
|
onProjectClosed: noop,
|
|
globalTypingsCacheLocation: void 0
|
|
};
|
|
function setIsEqualTo(arr1, arr2) {
|
|
if (arr1 === arr2) {
|
|
return true;
|
|
}
|
|
if ((arr1 || emptyArray2).length === 0 && (arr2 || emptyArray2).length === 0) {
|
|
return true;
|
|
}
|
|
const set = /* @__PURE__ */ new Map();
|
|
let unique = 0;
|
|
for (const v of arr1) {
|
|
if (set.get(v) !== true) {
|
|
set.set(v, true);
|
|
unique++;
|
|
}
|
|
}
|
|
for (const v of arr2) {
|
|
const isSet = set.get(v);
|
|
if (isSet === void 0) {
|
|
return false;
|
|
}
|
|
if (isSet === true) {
|
|
set.set(v, false);
|
|
unique--;
|
|
}
|
|
}
|
|
return unique === 0;
|
|
}
|
|
function typeAcquisitionChanged(opt1, opt2) {
|
|
return opt1.enable !== opt2.enable || !setIsEqualTo(opt1.include, opt2.include) || !setIsEqualTo(opt1.exclude, opt2.exclude);
|
|
}
|
|
function compilerOptionsChanged(opt1, opt2) {
|
|
return getAllowJSCompilerOption(opt1) !== getAllowJSCompilerOption(opt2);
|
|
}
|
|
function unresolvedImportsChanged(imports1, imports2) {
|
|
if (imports1 === imports2) {
|
|
return false;
|
|
}
|
|
return !arrayIsEqualTo(imports1, imports2);
|
|
}
|
|
var TypingsCache = class {
|
|
constructor(installer) {
|
|
this.installer = installer;
|
|
this.perProjectCache = /* @__PURE__ */ new Map();
|
|
}
|
|
isKnownTypesPackageName(name) {
|
|
return this.installer.isKnownTypesPackageName(name);
|
|
}
|
|
installPackage(options) {
|
|
return this.installer.installPackage(options);
|
|
}
|
|
enqueueInstallTypingsForProject(project, unresolvedImports, forceRefresh) {
|
|
const typeAcquisition = project.getTypeAcquisition();
|
|
if (!typeAcquisition || !typeAcquisition.enable) {
|
|
return;
|
|
}
|
|
const entry = this.perProjectCache.get(project.getProjectName());
|
|
if (forceRefresh || !entry || typeAcquisitionChanged(typeAcquisition, entry.typeAcquisition) || compilerOptionsChanged(project.getCompilationSettings(), entry.compilerOptions) || unresolvedImportsChanged(unresolvedImports, entry.unresolvedImports)) {
|
|
this.perProjectCache.set(project.getProjectName(), {
|
|
compilerOptions: project.getCompilationSettings(),
|
|
typeAcquisition,
|
|
typings: entry ? entry.typings : emptyArray2,
|
|
unresolvedImports,
|
|
poisoned: true
|
|
});
|
|
this.installer.enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
|
|
}
|
|
}
|
|
updateTypingsForProject(projectName, compilerOptions, typeAcquisition, unresolvedImports, newTypings) {
|
|
const typings = sort(newTypings);
|
|
this.perProjectCache.set(projectName, {
|
|
compilerOptions,
|
|
typeAcquisition,
|
|
typings,
|
|
unresolvedImports,
|
|
poisoned: false
|
|
});
|
|
return !typeAcquisition || !typeAcquisition.enable ? emptyArray2 : typings;
|
|
}
|
|
onProjectClosed(project) {
|
|
this.perProjectCache.delete(project.getProjectName());
|
|
this.installer.onProjectClosed(project);
|
|
}
|
|
};
|
|
|
|
// src/server/project.ts
|
|
var ProjectKind = /* @__PURE__ */ ((ProjectKind2) => {
|
|
ProjectKind2[ProjectKind2["Inferred"] = 0] = "Inferred";
|
|
ProjectKind2[ProjectKind2["Configured"] = 1] = "Configured";
|
|
ProjectKind2[ProjectKind2["External"] = 2] = "External";
|
|
ProjectKind2[ProjectKind2["AutoImportProvider"] = 3] = "AutoImportProvider";
|
|
ProjectKind2[ProjectKind2["Auxiliary"] = 4] = "Auxiliary";
|
|
return ProjectKind2;
|
|
})(ProjectKind || {});
|
|
function countEachFileTypes(infos, includeSizes = false) {
|
|
const result = {
|
|
js: 0,
|
|
jsSize: 0,
|
|
jsx: 0,
|
|
jsxSize: 0,
|
|
ts: 0,
|
|
tsSize: 0,
|
|
tsx: 0,
|
|
tsxSize: 0,
|
|
dts: 0,
|
|
dtsSize: 0,
|
|
deferred: 0,
|
|
deferredSize: 0
|
|
};
|
|
for (const info of infos) {
|
|
const fileSize = includeSizes ? info.getTelemetryFileSize() : 0;
|
|
switch (info.scriptKind) {
|
|
case 1 /* JS */:
|
|
result.js += 1;
|
|
result.jsSize += fileSize;
|
|
break;
|
|
case 2 /* JSX */:
|
|
result.jsx += 1;
|
|
result.jsxSize += fileSize;
|
|
break;
|
|
case 3 /* TS */:
|
|
if (isDeclarationFileName(info.fileName)) {
|
|
result.dts += 1;
|
|
result.dtsSize += fileSize;
|
|
} else {
|
|
result.ts += 1;
|
|
result.tsSize += fileSize;
|
|
}
|
|
break;
|
|
case 4 /* TSX */:
|
|
result.tsx += 1;
|
|
result.tsxSize += fileSize;
|
|
break;
|
|
case 7 /* Deferred */:
|
|
result.deferred += 1;
|
|
result.deferredSize += fileSize;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function hasOneOrMoreJsAndNoTsFiles(project) {
|
|
const counts2 = countEachFileTypes(project.getScriptInfos());
|
|
return counts2.js > 0 && counts2.ts === 0 && counts2.tsx === 0;
|
|
}
|
|
function allRootFilesAreJsOrDts(project) {
|
|
const counts2 = countEachFileTypes(project.getRootScriptInfos());
|
|
return counts2.ts === 0 && counts2.tsx === 0;
|
|
}
|
|
function allFilesAreJsOrDts(project) {
|
|
const counts2 = countEachFileTypes(project.getScriptInfos());
|
|
return counts2.ts === 0 && counts2.tsx === 0;
|
|
}
|
|
function hasNoTypeScriptSource(fileNames) {
|
|
return !fileNames.some((fileName) => fileExtensionIs(fileName, ".ts" /* Ts */) && !isDeclarationFileName(fileName) || fileExtensionIs(fileName, ".tsx" /* Tsx */));
|
|
}
|
|
function isGeneratedFileWatcher(watch) {
|
|
return watch.generatedFilePath !== void 0;
|
|
}
|
|
var Project3 = class {
|
|
constructor(projectName, projectKind, projectService, documentRegistry, hasExplicitListOfFiles, lastFileExceededProgramSize, compilerOptions, compileOnSaveEnabled, watchOptions, directoryStructureHost, currentDirectory) {
|
|
this.projectKind = projectKind;
|
|
this.projectService = projectService;
|
|
this.documentRegistry = documentRegistry;
|
|
this.compilerOptions = compilerOptions;
|
|
this.compileOnSaveEnabled = compileOnSaveEnabled;
|
|
this.watchOptions = watchOptions;
|
|
this.rootFiles = [];
|
|
this.rootFilesMap = /* @__PURE__ */ new Map();
|
|
this.plugins = [];
|
|
this.cachedUnresolvedImportsPerFile = /* @__PURE__ */ new Map();
|
|
this.hasAddedorRemovedFiles = false;
|
|
this.hasAddedOrRemovedSymlinks = false;
|
|
this.lastReportedVersion = 0;
|
|
this.projectProgramVersion = 0;
|
|
this.projectStateVersion = 0;
|
|
this.isInitialLoadPending = returnFalse;
|
|
this.dirty = false;
|
|
this.typingFiles = emptyArray2;
|
|
this.moduleSpecifierCache = createModuleSpecifierCache(this);
|
|
this.createHash = maybeBind(this.projectService.host, this.projectService.host.createHash);
|
|
this.globalCacheResolutionModuleName = ts_JsTyping_exports.nonRelativeModuleNameForTypingCache;
|
|
this.projectName = projectName;
|
|
this.directoryStructureHost = directoryStructureHost;
|
|
this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory || "");
|
|
this.getCanonicalFileName = this.projectService.toCanonicalFileName;
|
|
this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);
|
|
if (!this.compilerOptions) {
|
|
this.compilerOptions = getDefaultCompilerOptions2();
|
|
this.compilerOptions.allowNonTsExtensions = true;
|
|
this.compilerOptions.allowJs = true;
|
|
} else if (hasExplicitListOfFiles || getAllowJSCompilerOption(this.compilerOptions) || this.projectService.hasDeferredExtension()) {
|
|
this.compilerOptions.allowNonTsExtensions = true;
|
|
}
|
|
switch (projectService.serverMode) {
|
|
case 0 /* Semantic */:
|
|
this.languageServiceEnabled = true;
|
|
break;
|
|
case 1 /* PartialSemantic */:
|
|
this.languageServiceEnabled = true;
|
|
this.compilerOptions.noResolve = true;
|
|
this.compilerOptions.types = [];
|
|
break;
|
|
case 2 /* Syntactic */:
|
|
this.languageServiceEnabled = false;
|
|
this.compilerOptions.noResolve = true;
|
|
this.compilerOptions.types = [];
|
|
break;
|
|
default:
|
|
Debug.assertNever(projectService.serverMode);
|
|
}
|
|
this.setInternalCompilerOptionsForEmittingJsFiles();
|
|
const host = this.projectService.host;
|
|
if (this.projectService.logger.loggingEnabled()) {
|
|
this.trace = (s) => this.writeLog(s);
|
|
} else if (host.trace) {
|
|
this.trace = (s) => host.trace(s);
|
|
}
|
|
this.realpath = maybeBind(host, host.realpath);
|
|
this.resolutionCache = createResolutionCache(
|
|
this,
|
|
currentDirectory && this.currentDirectory,
|
|
true
|
|
);
|
|
this.languageService = createLanguageService(this, this.documentRegistry, this.projectService.serverMode);
|
|
if (lastFileExceededProgramSize) {
|
|
this.disableLanguageService(lastFileExceededProgramSize);
|
|
}
|
|
this.markAsDirty();
|
|
if (projectKind !== 3 /* AutoImportProvider */) {
|
|
this.projectService.pendingEnsureProjectForOpenFiles = true;
|
|
}
|
|
}
|
|
getResolvedProjectReferenceToRedirect(_fileName) {
|
|
return void 0;
|
|
}
|
|
isNonTsProject() {
|
|
updateProjectIfDirty(this);
|
|
return allFilesAreJsOrDts(this);
|
|
}
|
|
isJsOnlyProject() {
|
|
updateProjectIfDirty(this);
|
|
return hasOneOrMoreJsAndNoTsFiles(this);
|
|
}
|
|
static resolveModule(moduleName, initialDir, host, log, logErrors) {
|
|
const resolvedPath = normalizeSlashes(host.resolvePath(combinePaths(initialDir, "node_modules")));
|
|
log(`Loading ${moduleName} from ${initialDir} (resolved to ${resolvedPath})`);
|
|
const result = host.require(resolvedPath, moduleName);
|
|
if (result.error) {
|
|
const err = result.error.stack || result.error.message || JSON.stringify(result.error);
|
|
(logErrors || log)(`Failed to load module '${moduleName}' from ${resolvedPath}: ${err}`);
|
|
return void 0;
|
|
}
|
|
return result.module;
|
|
}
|
|
static async importServicePluginAsync(moduleName, initialDir, host, log, logErrors) {
|
|
Debug.assertIsDefined(host.importPlugin);
|
|
const resolvedPath = combinePaths(initialDir, "node_modules");
|
|
log(`Dynamically importing ${moduleName} from ${initialDir} (resolved to ${resolvedPath})`);
|
|
let result;
|
|
try {
|
|
result = await host.importPlugin(resolvedPath, moduleName);
|
|
} catch (e) {
|
|
result = { module: void 0, error: e };
|
|
}
|
|
if (result.error) {
|
|
const err = result.error.stack || result.error.message || JSON.stringify(result.error);
|
|
(logErrors || log)(`Failed to dynamically import module '${moduleName}' from ${resolvedPath}: ${err}`);
|
|
return void 0;
|
|
}
|
|
return result.module;
|
|
}
|
|
isKnownTypesPackageName(name) {
|
|
return this.typingsCache.isKnownTypesPackageName(name);
|
|
}
|
|
installPackage(options) {
|
|
return this.typingsCache.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) });
|
|
}
|
|
getGlobalTypingsCacheLocation() {
|
|
return this.getGlobalCache();
|
|
}
|
|
get typingsCache() {
|
|
return this.projectService.typingsCache;
|
|
}
|
|
getSymlinkCache() {
|
|
if (!this.symlinks) {
|
|
this.symlinks = createSymlinkCache(this.getCurrentDirectory(), this.getCanonicalFileName);
|
|
}
|
|
if (this.program && !this.symlinks.hasProcessedResolutions()) {
|
|
this.symlinks.setSymlinksFromResolutions(
|
|
this.program.getSourceFiles(),
|
|
this.program.getResolvedTypeReferenceDirectives()
|
|
);
|
|
}
|
|
return this.symlinks;
|
|
}
|
|
getCompilationSettings() {
|
|
return this.compilerOptions;
|
|
}
|
|
getCompilerOptions() {
|
|
return this.getCompilationSettings();
|
|
}
|
|
getNewLine() {
|
|
return this.projectService.host.newLine;
|
|
}
|
|
getProjectVersion() {
|
|
return this.projectStateVersion.toString();
|
|
}
|
|
getProjectReferences() {
|
|
return void 0;
|
|
}
|
|
getScriptFileNames() {
|
|
if (!this.rootFiles) {
|
|
return emptyArray;
|
|
}
|
|
let result;
|
|
this.rootFilesMap.forEach((value) => {
|
|
if (this.languageServiceEnabled || value.info && value.info.isScriptOpen()) {
|
|
(result || (result = [])).push(value.fileName);
|
|
}
|
|
});
|
|
return addRange(result, this.typingFiles) || emptyArray;
|
|
}
|
|
getOrCreateScriptInfoAndAttachToProject(fileName) {
|
|
const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(fileName, this.currentDirectory, this.directoryStructureHost);
|
|
if (scriptInfo) {
|
|
const existingValue = this.rootFilesMap.get(scriptInfo.path);
|
|
if (existingValue && existingValue.info !== scriptInfo) {
|
|
this.rootFiles.push(scriptInfo);
|
|
existingValue.info = scriptInfo;
|
|
}
|
|
scriptInfo.attachToProject(this);
|
|
}
|
|
return scriptInfo;
|
|
}
|
|
getScriptKind(fileName) {
|
|
const info = this.getOrCreateScriptInfoAndAttachToProject(fileName);
|
|
return info && info.scriptKind;
|
|
}
|
|
getScriptVersion(filename) {
|
|
const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(filename, this.currentDirectory, this.directoryStructureHost);
|
|
return info && info.getLatestVersion();
|
|
}
|
|
getScriptSnapshot(filename) {
|
|
const scriptInfo = this.getOrCreateScriptInfoAndAttachToProject(filename);
|
|
if (scriptInfo) {
|
|
return scriptInfo.getSnapshot();
|
|
}
|
|
}
|
|
getCancellationToken() {
|
|
return this.cancellationToken;
|
|
}
|
|
getCurrentDirectory() {
|
|
return this.currentDirectory;
|
|
}
|
|
getDefaultLibFileName() {
|
|
const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath()));
|
|
return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions));
|
|
}
|
|
useCaseSensitiveFileNames() {
|
|
return this.projectService.host.useCaseSensitiveFileNames;
|
|
}
|
|
readDirectory(path, extensions, exclude, include, depth) {
|
|
return this.directoryStructureHost.readDirectory(path, extensions, exclude, include, depth);
|
|
}
|
|
readFile(fileName) {
|
|
return this.projectService.host.readFile(fileName);
|
|
}
|
|
writeFile(fileName, content) {
|
|
return this.projectService.host.writeFile(fileName, content);
|
|
}
|
|
fileExists(file) {
|
|
const path = this.toPath(file);
|
|
return !this.isWatchedMissingFile(path) && this.directoryStructureHost.fileExists(file);
|
|
}
|
|
resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, _options, containingSourceFile, resolutionInfo) {
|
|
return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile, resolutionInfo);
|
|
}
|
|
getModuleResolutionCache() {
|
|
return this.resolutionCache.getModuleResolutionCache();
|
|
}
|
|
getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) {
|
|
return this.resolutionCache.getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode);
|
|
}
|
|
resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode, resolutionInfo) {
|
|
return this.resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode, resolutionInfo);
|
|
}
|
|
directoryExists(path) {
|
|
return this.directoryStructureHost.directoryExists(path);
|
|
}
|
|
getDirectories(path) {
|
|
return this.directoryStructureHost.getDirectories(path);
|
|
}
|
|
getCachedDirectoryStructureHost() {
|
|
return void 0;
|
|
}
|
|
toPath(fileName) {
|
|
return toPath(fileName, this.currentDirectory, this.projectService.toCanonicalFileName);
|
|
}
|
|
watchDirectoryOfFailedLookupLocation(directory, cb, flags) {
|
|
return this.projectService.watchFactory.watchDirectory(
|
|
directory,
|
|
cb,
|
|
flags,
|
|
this.projectService.getWatchOptions(this),
|
|
WatchType.FailedLookupLocations,
|
|
this
|
|
);
|
|
}
|
|
watchAffectingFileLocation(file, cb) {
|
|
return this.projectService.watchFactory.watchFile(
|
|
file,
|
|
cb,
|
|
2e3 /* High */,
|
|
this.projectService.getWatchOptions(this),
|
|
WatchType.AffectingFileLocation,
|
|
this
|
|
);
|
|
}
|
|
clearInvalidateResolutionOfFailedLookupTimer() {
|
|
return this.projectService.throttledOperations.cancel(`${this.getProjectName()}FailedLookupInvalidation`);
|
|
}
|
|
scheduleInvalidateResolutionsOfFailedLookupLocations() {
|
|
this.projectService.throttledOperations.schedule(`${this.getProjectName()}FailedLookupInvalidation`, 1e3, () => {
|
|
if (this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
}
|
|
});
|
|
}
|
|
invalidateResolutionsOfFailedLookupLocations() {
|
|
if (this.clearInvalidateResolutionOfFailedLookupTimer() && this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {
|
|
this.markAsDirty();
|
|
this.projectService.delayEnsureProjectForOpenFiles();
|
|
}
|
|
}
|
|
onInvalidatedResolution() {
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
}
|
|
watchTypeRootsDirectory(directory, cb, flags) {
|
|
return this.projectService.watchFactory.watchDirectory(
|
|
directory,
|
|
cb,
|
|
flags,
|
|
this.projectService.getWatchOptions(this),
|
|
WatchType.TypeRoots,
|
|
this
|
|
);
|
|
}
|
|
hasChangedAutomaticTypeDirectiveNames() {
|
|
return this.resolutionCache.hasChangedAutomaticTypeDirectiveNames();
|
|
}
|
|
onChangedAutomaticTypeDirectiveNames() {
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
}
|
|
getGlobalCache() {
|
|
return this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : void 0;
|
|
}
|
|
fileIsOpen(filePath) {
|
|
return this.projectService.openFiles.has(filePath);
|
|
}
|
|
writeLog(s) {
|
|
this.projectService.logger.info(s);
|
|
}
|
|
log(s) {
|
|
this.writeLog(s);
|
|
}
|
|
error(s) {
|
|
this.projectService.logger.msg(s, "Err" /* Err */);
|
|
}
|
|
setInternalCompilerOptionsForEmittingJsFiles() {
|
|
if (this.projectKind === 0 /* Inferred */ || this.projectKind === 2 /* External */) {
|
|
this.compilerOptions.noEmitForJsFiles = true;
|
|
}
|
|
}
|
|
getGlobalProjectErrors() {
|
|
return filter(this.projectErrors, (diagnostic) => !diagnostic.file) || emptyArray2;
|
|
}
|
|
getAllProjectErrors() {
|
|
return this.projectErrors || emptyArray2;
|
|
}
|
|
setProjectErrors(projectErrors) {
|
|
this.projectErrors = projectErrors;
|
|
}
|
|
getLanguageService(ensureSynchronized = true) {
|
|
if (ensureSynchronized) {
|
|
updateProjectIfDirty(this);
|
|
}
|
|
return this.languageService;
|
|
}
|
|
getSourceMapper() {
|
|
return this.getLanguageService().getSourceMapper();
|
|
}
|
|
clearSourceMapperCache() {
|
|
this.languageService.clearSourceMapperCache();
|
|
}
|
|
getDocumentPositionMapper(generatedFileName, sourceFileName) {
|
|
return this.projectService.getDocumentPositionMapper(this, generatedFileName, sourceFileName);
|
|
}
|
|
getSourceFileLike(fileName) {
|
|
return this.projectService.getSourceFileLike(fileName, this);
|
|
}
|
|
shouldEmitFile(scriptInfo) {
|
|
return scriptInfo && !scriptInfo.isDynamicOrHasMixedContent() && !this.program.isSourceOfProjectReferenceRedirect(scriptInfo.path);
|
|
}
|
|
getCompileOnSaveAffectedFileList(scriptInfo) {
|
|
if (!this.languageServiceEnabled) {
|
|
return [];
|
|
}
|
|
updateProjectIfDirty(this);
|
|
this.builderState = BuilderState.create(this.program, this.builderState, true);
|
|
return mapDefined(
|
|
BuilderState.getFilesAffectedBy(
|
|
this.builderState,
|
|
this.program,
|
|
scriptInfo.path,
|
|
this.cancellationToken,
|
|
this.projectService.host
|
|
),
|
|
(sourceFile) => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)) ? sourceFile.fileName : void 0
|
|
);
|
|
}
|
|
emitFile(scriptInfo, writeFile2) {
|
|
if (!this.languageServiceEnabled || !this.shouldEmitFile(scriptInfo)) {
|
|
return { emitSkipped: true, diagnostics: emptyArray2 };
|
|
}
|
|
const { emitSkipped, diagnostics, outputFiles } = this.getLanguageService().getEmitOutput(scriptInfo.fileName);
|
|
if (!emitSkipped) {
|
|
for (const outputFile of outputFiles) {
|
|
const outputFileAbsoluteFileName = getNormalizedAbsolutePath(outputFile.name, this.currentDirectory);
|
|
writeFile2(outputFileAbsoluteFileName, outputFile.text, outputFile.writeByteOrderMark);
|
|
}
|
|
if (this.builderState && getEmitDeclarations(this.compilerOptions)) {
|
|
const dtsFiles = outputFiles.filter((f) => isDeclarationFileName(f.name));
|
|
if (dtsFiles.length === 1) {
|
|
const sourceFile = this.program.getSourceFile(scriptInfo.fileName);
|
|
const signature = this.projectService.host.createHash ? this.projectService.host.createHash(dtsFiles[0].text) : generateDjb2Hash(dtsFiles[0].text);
|
|
BuilderState.updateSignatureOfFile(this.builderState, signature, sourceFile.resolvedPath);
|
|
}
|
|
}
|
|
}
|
|
return { emitSkipped, diagnostics };
|
|
}
|
|
enableLanguageService() {
|
|
if (this.languageServiceEnabled || this.projectService.serverMode === 2 /* Syntactic */) {
|
|
return;
|
|
}
|
|
this.languageServiceEnabled = true;
|
|
this.lastFileExceededProgramSize = void 0;
|
|
this.projectService.onUpdateLanguageServiceStateForProject(this, true);
|
|
}
|
|
disableLanguageService(lastFileExceededProgramSize) {
|
|
if (!this.languageServiceEnabled) {
|
|
return;
|
|
}
|
|
Debug.assert(this.projectService.serverMode !== 2 /* Syntactic */);
|
|
this.languageService.cleanupSemanticCache();
|
|
this.languageServiceEnabled = false;
|
|
this.lastFileExceededProgramSize = lastFileExceededProgramSize;
|
|
this.builderState = void 0;
|
|
if (this.autoImportProviderHost) {
|
|
this.autoImportProviderHost.close();
|
|
}
|
|
this.autoImportProviderHost = void 0;
|
|
this.resolutionCache.closeTypeRootsWatch();
|
|
this.clearGeneratedFileWatch();
|
|
this.projectService.onUpdateLanguageServiceStateForProject(this, false);
|
|
}
|
|
getProjectName() {
|
|
return this.projectName;
|
|
}
|
|
removeLocalTypingsFromTypeAcquisition(newTypeAcquisition) {
|
|
if (!newTypeAcquisition || !newTypeAcquisition.include) {
|
|
return newTypeAcquisition;
|
|
}
|
|
return { ...newTypeAcquisition, include: this.removeExistingTypings(newTypeAcquisition.include) };
|
|
}
|
|
getExternalFiles() {
|
|
return sort(flatMap(this.plugins, (plugin) => {
|
|
if (typeof plugin.module.getExternalFiles !== "function")
|
|
return;
|
|
try {
|
|
return plugin.module.getExternalFiles(this);
|
|
} catch (e) {
|
|
this.projectService.logger.info(`A plugin threw an exception in getExternalFiles: ${e}`);
|
|
if (e.stack) {
|
|
this.projectService.logger.info(e.stack);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
getSourceFile(path) {
|
|
if (!this.program) {
|
|
return void 0;
|
|
}
|
|
return this.program.getSourceFileByPath(path);
|
|
}
|
|
getSourceFileOrConfigFile(path) {
|
|
const options = this.program.getCompilerOptions();
|
|
return path === options.configFilePath ? options.configFile : this.getSourceFile(path);
|
|
}
|
|
close() {
|
|
if (this.program) {
|
|
for (const f of this.program.getSourceFiles()) {
|
|
this.detachScriptInfoIfNotRoot(f.fileName);
|
|
}
|
|
this.program.forEachResolvedProjectReference((ref) => this.detachScriptInfoFromProject(ref.sourceFile.fileName));
|
|
}
|
|
forEach(this.externalFiles, (externalFile) => this.detachScriptInfoIfNotRoot(externalFile));
|
|
for (const root of this.rootFiles) {
|
|
root.detachFromProject(this);
|
|
}
|
|
this.projectService.pendingEnsureProjectForOpenFiles = true;
|
|
this.rootFiles = void 0;
|
|
this.rootFilesMap = void 0;
|
|
this.externalFiles = void 0;
|
|
this.program = void 0;
|
|
this.builderState = void 0;
|
|
this.resolutionCache.clear();
|
|
this.resolutionCache = void 0;
|
|
this.cachedUnresolvedImportsPerFile = void 0;
|
|
this.moduleSpecifierCache = void 0;
|
|
this.directoryStructureHost = void 0;
|
|
this.exportMapCache = void 0;
|
|
this.projectErrors = void 0;
|
|
this.plugins.length = 0;
|
|
if (this.missingFilesMap) {
|
|
clearMap(this.missingFilesMap, closeFileWatcher);
|
|
this.missingFilesMap = void 0;
|
|
}
|
|
this.clearGeneratedFileWatch();
|
|
this.clearInvalidateResolutionOfFailedLookupTimer();
|
|
if (this.autoImportProviderHost) {
|
|
this.autoImportProviderHost.close();
|
|
}
|
|
this.autoImportProviderHost = void 0;
|
|
if (this.noDtsResolutionProject) {
|
|
this.noDtsResolutionProject.close();
|
|
}
|
|
this.noDtsResolutionProject = void 0;
|
|
this.languageService.dispose();
|
|
this.languageService = void 0;
|
|
}
|
|
detachScriptInfoIfNotRoot(uncheckedFilename) {
|
|
const info = this.projectService.getScriptInfo(uncheckedFilename);
|
|
if (info && !this.isRoot(info)) {
|
|
info.detachFromProject(this);
|
|
}
|
|
}
|
|
isClosed() {
|
|
return this.rootFiles === void 0;
|
|
}
|
|
hasRoots() {
|
|
return this.rootFiles && this.rootFiles.length > 0;
|
|
}
|
|
isOrphan() {
|
|
return false;
|
|
}
|
|
getRootFiles() {
|
|
return this.rootFiles && this.rootFiles.map((info) => info.fileName);
|
|
}
|
|
getRootFilesMap() {
|
|
return this.rootFilesMap;
|
|
}
|
|
getRootScriptInfos() {
|
|
return this.rootFiles;
|
|
}
|
|
getScriptInfos() {
|
|
if (!this.languageServiceEnabled) {
|
|
return this.rootFiles;
|
|
}
|
|
return map(this.program.getSourceFiles(), (sourceFile) => {
|
|
const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.resolvedPath);
|
|
Debug.assert(!!scriptInfo, "getScriptInfo", () => `scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' / '${sourceFile.resolvedPath}' is missing.`);
|
|
return scriptInfo;
|
|
});
|
|
}
|
|
getExcludedFiles() {
|
|
return emptyArray2;
|
|
}
|
|
getFileNames(excludeFilesFromExternalLibraries, excludeConfigFiles) {
|
|
if (!this.program) {
|
|
return [];
|
|
}
|
|
if (!this.languageServiceEnabled) {
|
|
let rootFiles = this.getRootFiles();
|
|
if (this.compilerOptions) {
|
|
const defaultLibrary = getDefaultLibFilePath(this.compilerOptions);
|
|
if (defaultLibrary) {
|
|
(rootFiles || (rootFiles = [])).push(asNormalizedPath(defaultLibrary));
|
|
}
|
|
}
|
|
return rootFiles;
|
|
}
|
|
const result = [];
|
|
for (const f of this.program.getSourceFiles()) {
|
|
if (excludeFilesFromExternalLibraries && this.program.isSourceFileFromExternalLibrary(f)) {
|
|
continue;
|
|
}
|
|
result.push(asNormalizedPath(f.fileName));
|
|
}
|
|
if (!excludeConfigFiles) {
|
|
const configFile = this.program.getCompilerOptions().configFile;
|
|
if (configFile) {
|
|
result.push(asNormalizedPath(configFile.fileName));
|
|
if (configFile.extendedSourceFiles) {
|
|
for (const f of configFile.extendedSourceFiles) {
|
|
result.push(asNormalizedPath(f));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
getFileNamesWithRedirectInfo(includeProjectReferenceRedirectInfo) {
|
|
return this.getFileNames().map((fileName) => ({
|
|
fileName,
|
|
isSourceOfProjectReferenceRedirect: includeProjectReferenceRedirectInfo && this.isSourceOfProjectReferenceRedirect(fileName)
|
|
}));
|
|
}
|
|
hasConfigFile(configFilePath) {
|
|
if (this.program && this.languageServiceEnabled) {
|
|
const configFile = this.program.getCompilerOptions().configFile;
|
|
if (configFile) {
|
|
if (configFilePath === asNormalizedPath(configFile.fileName)) {
|
|
return true;
|
|
}
|
|
if (configFile.extendedSourceFiles) {
|
|
for (const f of configFile.extendedSourceFiles) {
|
|
if (configFilePath === asNormalizedPath(f)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
containsScriptInfo(info) {
|
|
if (this.isRoot(info))
|
|
return true;
|
|
if (!this.program)
|
|
return false;
|
|
const file = this.program.getSourceFileByPath(info.path);
|
|
return !!file && file.resolvedPath === info.path;
|
|
}
|
|
containsFile(filename, requireOpen) {
|
|
const info = this.projectService.getScriptInfoForNormalizedPath(filename);
|
|
if (info && (info.isScriptOpen() || !requireOpen)) {
|
|
return this.containsScriptInfo(info);
|
|
}
|
|
return false;
|
|
}
|
|
isRoot(info) {
|
|
var _a2;
|
|
return this.rootFilesMap && ((_a2 = this.rootFilesMap.get(info.path)) == null ? void 0 : _a2.info) === info;
|
|
}
|
|
addRoot(info, fileName) {
|
|
Debug.assert(!this.isRoot(info));
|
|
this.rootFiles.push(info);
|
|
this.rootFilesMap.set(info.path, { fileName: fileName || info.fileName, info });
|
|
info.attachToProject(this);
|
|
this.markAsDirty();
|
|
}
|
|
addMissingFileRoot(fileName) {
|
|
const path = this.projectService.toPath(fileName);
|
|
this.rootFilesMap.set(path, { fileName });
|
|
this.markAsDirty();
|
|
}
|
|
removeFile(info, fileExists, detachFromProject) {
|
|
if (this.isRoot(info)) {
|
|
this.removeRoot(info);
|
|
}
|
|
if (fileExists) {
|
|
this.resolutionCache.removeResolutionsOfFile(info.path);
|
|
} else {
|
|
this.resolutionCache.invalidateResolutionOfFile(info.path);
|
|
}
|
|
this.cachedUnresolvedImportsPerFile.delete(info.path);
|
|
if (detachFromProject) {
|
|
info.detachFromProject(this);
|
|
}
|
|
this.markAsDirty();
|
|
}
|
|
registerFileUpdate(fileName) {
|
|
(this.updatedFileNames || (this.updatedFileNames = /* @__PURE__ */ new Set())).add(fileName);
|
|
}
|
|
markFileAsDirty(changedFile) {
|
|
this.markAsDirty();
|
|
if (this.exportMapCache && !this.exportMapCache.isEmpty()) {
|
|
(this.changedFilesForExportMapCache || (this.changedFilesForExportMapCache = /* @__PURE__ */ new Set())).add(changedFile);
|
|
}
|
|
}
|
|
markAsDirty() {
|
|
if (!this.dirty) {
|
|
this.projectStateVersion++;
|
|
this.dirty = true;
|
|
}
|
|
}
|
|
onAutoImportProviderSettingsChanged() {
|
|
var _a2;
|
|
if (this.autoImportProviderHost === false) {
|
|
this.autoImportProviderHost = void 0;
|
|
} else {
|
|
(_a2 = this.autoImportProviderHost) == null ? void 0 : _a2.markAsDirty();
|
|
}
|
|
}
|
|
onPackageJsonChange(packageJsonPath) {
|
|
var _a2;
|
|
if ((_a2 = this.packageJsonsForAutoImport) == null ? void 0 : _a2.has(packageJsonPath)) {
|
|
this.moduleSpecifierCache.clear();
|
|
if (this.autoImportProviderHost) {
|
|
this.autoImportProviderHost.markAsDirty();
|
|
}
|
|
}
|
|
}
|
|
onFileAddedOrRemoved(isSymlink) {
|
|
this.hasAddedorRemovedFiles = true;
|
|
if (isSymlink) {
|
|
this.hasAddedOrRemovedSymlinks = true;
|
|
}
|
|
}
|
|
onDiscoveredSymlink() {
|
|
this.hasAddedOrRemovedSymlinks = true;
|
|
}
|
|
updateGraph() {
|
|
var _a2, _b, _c;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "updateGraph", { name: this.projectName, kind: ProjectKind[this.projectKind] });
|
|
perfLogger.logStartUpdateGraph();
|
|
this.resolutionCache.startRecordingFilesWithChangedResolutions();
|
|
const hasNewProgram = this.updateGraphWorker();
|
|
const hasAddedorRemovedFiles = this.hasAddedorRemovedFiles;
|
|
this.hasAddedorRemovedFiles = false;
|
|
this.hasAddedOrRemovedSymlinks = false;
|
|
const changedFiles = this.resolutionCache.finishRecordingFilesWithChangedResolutions() || emptyArray2;
|
|
for (const file of changedFiles) {
|
|
this.cachedUnresolvedImportsPerFile.delete(file);
|
|
}
|
|
if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */) {
|
|
if (hasNewProgram || changedFiles.length) {
|
|
this.lastCachedUnresolvedImportsList = getUnresolvedImports(this.program, this.cachedUnresolvedImportsPerFile);
|
|
}
|
|
this.projectService.typingsCache.enqueueInstallTypingsForProject(this, this.lastCachedUnresolvedImportsList, hasAddedorRemovedFiles);
|
|
} else {
|
|
this.lastCachedUnresolvedImportsList = void 0;
|
|
}
|
|
const isFirstProgramLoad = this.projectProgramVersion === 0 && hasNewProgram;
|
|
if (hasNewProgram) {
|
|
this.projectProgramVersion++;
|
|
}
|
|
if (hasAddedorRemovedFiles) {
|
|
if (!this.autoImportProviderHost)
|
|
this.autoImportProviderHost = void 0;
|
|
(_b = this.autoImportProviderHost) == null ? void 0 : _b.markAsDirty();
|
|
}
|
|
if (isFirstProgramLoad) {
|
|
this.getPackageJsonAutoImportProvider();
|
|
}
|
|
perfLogger.logStopUpdateGraph();
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
return !hasNewProgram;
|
|
}
|
|
updateTypingFiles(typingFiles) {
|
|
if (enumerateInsertsAndDeletes(
|
|
typingFiles,
|
|
this.typingFiles,
|
|
getStringComparer(!this.useCaseSensitiveFileNames()),
|
|
noop,
|
|
(removed) => this.detachScriptInfoFromProject(removed)
|
|
)) {
|
|
this.typingFiles = typingFiles;
|
|
this.resolutionCache.setFilesWithInvalidatedNonRelativeUnresolvedImports(this.cachedUnresolvedImportsPerFile);
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
}
|
|
}
|
|
getCurrentProgram() {
|
|
return this.program;
|
|
}
|
|
removeExistingTypings(include) {
|
|
const existing = getAutomaticTypeDirectiveNames(this.getCompilerOptions(), this.directoryStructureHost);
|
|
return include.filter((i) => existing.indexOf(i) < 0);
|
|
}
|
|
updateGraphWorker() {
|
|
var _a2, _b;
|
|
const oldProgram = this.languageService.getCurrentProgram();
|
|
Debug.assert(!this.isClosed(), "Called update graph worker of closed project");
|
|
this.writeLog(`Starting updateGraphWorker: Project: ${this.getProjectName()}`);
|
|
const start2 = timestamp();
|
|
this.hasInvalidatedResolutions = this.resolutionCache.createHasInvalidatedResolutions(returnFalse);
|
|
this.resolutionCache.startCachingPerDirectoryResolution();
|
|
this.program = this.languageService.getProgram();
|
|
this.dirty = false;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "finishCachingPerDirectoryResolution");
|
|
this.resolutionCache.finishCachingPerDirectoryResolution(this.program, oldProgram);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
Debug.assert(oldProgram === void 0 || this.program !== void 0);
|
|
let hasNewProgram = false;
|
|
if (this.program && (!oldProgram || this.program !== oldProgram && this.program.structureIsReused !== 2 /* Completely */)) {
|
|
hasNewProgram = true;
|
|
if (oldProgram) {
|
|
for (const f of oldProgram.getSourceFiles()) {
|
|
const newFile = this.program.getSourceFileByPath(f.resolvedPath);
|
|
if (!newFile || f.resolvedPath === f.path && newFile.resolvedPath !== f.path) {
|
|
this.detachScriptInfoFromProject(f.fileName, !!this.program.getSourceFileByPath(f.path));
|
|
}
|
|
}
|
|
oldProgram.forEachResolvedProjectReference((resolvedProjectReference) => {
|
|
if (!this.program.getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) {
|
|
this.detachScriptInfoFromProject(resolvedProjectReference.sourceFile.fileName);
|
|
}
|
|
});
|
|
}
|
|
updateMissingFilePathsWatch(
|
|
this.program,
|
|
this.missingFilesMap || (this.missingFilesMap = /* @__PURE__ */ new Map()),
|
|
(missingFilePath) => this.addMissingFileWatcher(missingFilePath)
|
|
);
|
|
if (this.generatedFilesMap) {
|
|
const outPath = outFile(this.compilerOptions);
|
|
if (isGeneratedFileWatcher(this.generatedFilesMap)) {
|
|
if (!outPath || !this.isValidGeneratedFileWatcher(
|
|
removeFileExtension(outPath) + ".d.ts" /* Dts */,
|
|
this.generatedFilesMap
|
|
)) {
|
|
this.clearGeneratedFileWatch();
|
|
}
|
|
} else {
|
|
if (outPath) {
|
|
this.clearGeneratedFileWatch();
|
|
} else {
|
|
this.generatedFilesMap.forEach((watcher, source) => {
|
|
const sourceFile = this.program.getSourceFileByPath(source);
|
|
if (!sourceFile || sourceFile.resolvedPath !== source || !this.isValidGeneratedFileWatcher(
|
|
getDeclarationEmitOutputFilePathWorker(sourceFile.fileName, this.compilerOptions, this.currentDirectory, this.program.getCommonSourceDirectory(), this.getCanonicalFileName),
|
|
watcher
|
|
)) {
|
|
closeFileWatcherOf(watcher);
|
|
this.generatedFilesMap.delete(source);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */) {
|
|
this.resolutionCache.updateTypeRootsWatch();
|
|
}
|
|
}
|
|
if (this.exportMapCache && !this.exportMapCache.isEmpty()) {
|
|
this.exportMapCache.releaseSymbols();
|
|
if (this.hasAddedorRemovedFiles || oldProgram && !this.program.structureIsReused) {
|
|
this.exportMapCache.clear();
|
|
} else if (this.changedFilesForExportMapCache && oldProgram && this.program) {
|
|
forEachKey(this.changedFilesForExportMapCache, (fileName) => {
|
|
const oldSourceFile = oldProgram.getSourceFileByPath(fileName);
|
|
const sourceFile = this.program.getSourceFileByPath(fileName);
|
|
if (!oldSourceFile || !sourceFile) {
|
|
this.exportMapCache.clear();
|
|
return true;
|
|
}
|
|
return this.exportMapCache.onFileChanged(oldSourceFile, sourceFile, !!this.getTypeAcquisition().enable);
|
|
});
|
|
}
|
|
}
|
|
if (this.changedFilesForExportMapCache) {
|
|
this.changedFilesForExportMapCache.clear();
|
|
}
|
|
if (this.hasAddedOrRemovedSymlinks || this.program && !this.program.structureIsReused && this.getCompilerOptions().preserveSymlinks) {
|
|
this.symlinks = void 0;
|
|
this.moduleSpecifierCache.clear();
|
|
}
|
|
const oldExternalFiles = this.externalFiles || emptyArray2;
|
|
this.externalFiles = this.getExternalFiles();
|
|
enumerateInsertsAndDeletes(
|
|
this.externalFiles,
|
|
oldExternalFiles,
|
|
getStringComparer(!this.useCaseSensitiveFileNames()),
|
|
(inserted) => {
|
|
const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(inserted, this.currentDirectory, this.directoryStructureHost);
|
|
scriptInfo == null ? void 0 : scriptInfo.attachToProject(this);
|
|
},
|
|
(removed) => this.detachScriptInfoFromProject(removed)
|
|
);
|
|
const elapsed = timestamp() - start2;
|
|
this.sendPerformanceEvent("UpdateGraph", elapsed);
|
|
this.writeLog(`Finishing updateGraphWorker: Project: ${this.getProjectName()} Version: ${this.getProjectVersion()} structureChanged: ${hasNewProgram}${this.program ? ` structureIsReused:: ${StructureIsReused[this.program.structureIsReused]}` : ""} Elapsed: ${elapsed}ms`);
|
|
if (this.hasAddedorRemovedFiles) {
|
|
this.print(true);
|
|
} else if (this.program !== oldProgram) {
|
|
this.writeLog(`Different program with same set of files`);
|
|
}
|
|
return hasNewProgram;
|
|
}
|
|
sendPerformanceEvent(kind, durationMs) {
|
|
this.projectService.sendPerformanceEvent(kind, durationMs);
|
|
}
|
|
detachScriptInfoFromProject(uncheckedFileName, noRemoveResolution) {
|
|
const scriptInfoToDetach = this.projectService.getScriptInfo(uncheckedFileName);
|
|
if (scriptInfoToDetach) {
|
|
scriptInfoToDetach.detachFromProject(this);
|
|
if (!noRemoveResolution) {
|
|
this.resolutionCache.removeResolutionsOfFile(scriptInfoToDetach.path);
|
|
}
|
|
}
|
|
}
|
|
addMissingFileWatcher(missingFilePath) {
|
|
var _a2;
|
|
if (isConfiguredProject(this)) {
|
|
const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(missingFilePath);
|
|
if ((_a2 = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config) == null ? void 0 : _a2.projects.has(this.canonicalConfigFilePath))
|
|
return noopFileWatcher;
|
|
}
|
|
const fileWatcher = this.projectService.watchFactory.watchFile(
|
|
missingFilePath,
|
|
(fileName, eventKind) => {
|
|
if (isConfiguredProject(this)) {
|
|
this.getCachedDirectoryStructureHost().addOrDeleteFile(fileName, missingFilePath, eventKind);
|
|
}
|
|
if (eventKind === 0 /* Created */ && this.missingFilesMap.has(missingFilePath)) {
|
|
this.missingFilesMap.delete(missingFilePath);
|
|
fileWatcher.close();
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
}
|
|
},
|
|
500 /* Medium */,
|
|
this.projectService.getWatchOptions(this),
|
|
WatchType.MissingFile,
|
|
this
|
|
);
|
|
return fileWatcher;
|
|
}
|
|
isWatchedMissingFile(path) {
|
|
return !!this.missingFilesMap && this.missingFilesMap.has(path);
|
|
}
|
|
addGeneratedFileWatch(generatedFile, sourceFile) {
|
|
if (outFile(this.compilerOptions)) {
|
|
if (!this.generatedFilesMap) {
|
|
this.generatedFilesMap = this.createGeneratedFileWatcher(generatedFile);
|
|
}
|
|
} else {
|
|
const path = this.toPath(sourceFile);
|
|
if (this.generatedFilesMap) {
|
|
if (isGeneratedFileWatcher(this.generatedFilesMap)) {
|
|
Debug.fail(`${this.projectName} Expected to not have --out watcher for generated file with options: ${JSON.stringify(this.compilerOptions)}`);
|
|
return;
|
|
}
|
|
if (this.generatedFilesMap.has(path))
|
|
return;
|
|
} else {
|
|
this.generatedFilesMap = /* @__PURE__ */ new Map();
|
|
}
|
|
this.generatedFilesMap.set(path, this.createGeneratedFileWatcher(generatedFile));
|
|
}
|
|
}
|
|
createGeneratedFileWatcher(generatedFile) {
|
|
return {
|
|
generatedFilePath: this.toPath(generatedFile),
|
|
watcher: this.projectService.watchFactory.watchFile(
|
|
generatedFile,
|
|
() => {
|
|
this.clearSourceMapperCache();
|
|
this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);
|
|
},
|
|
2e3 /* High */,
|
|
this.projectService.getWatchOptions(this),
|
|
WatchType.MissingGeneratedFile,
|
|
this
|
|
)
|
|
};
|
|
}
|
|
isValidGeneratedFileWatcher(generateFile, watcher) {
|
|
return this.toPath(generateFile) === watcher.generatedFilePath;
|
|
}
|
|
clearGeneratedFileWatch() {
|
|
if (this.generatedFilesMap) {
|
|
if (isGeneratedFileWatcher(this.generatedFilesMap)) {
|
|
closeFileWatcherOf(this.generatedFilesMap);
|
|
} else {
|
|
clearMap(this.generatedFilesMap, closeFileWatcherOf);
|
|
}
|
|
this.generatedFilesMap = void 0;
|
|
}
|
|
}
|
|
getScriptInfoForNormalizedPath(fileName) {
|
|
const scriptInfo = this.projectService.getScriptInfoForPath(this.toPath(fileName));
|
|
if (scriptInfo && !scriptInfo.isAttached(this)) {
|
|
return Errors.ThrowProjectDoesNotContainDocument(fileName, this);
|
|
}
|
|
return scriptInfo;
|
|
}
|
|
getScriptInfo(uncheckedFileName) {
|
|
return this.projectService.getScriptInfo(uncheckedFileName);
|
|
}
|
|
filesToString(writeProjectFileNames) {
|
|
if (this.isInitialLoadPending())
|
|
return " Files (0) InitialLoadPending\n";
|
|
if (!this.program)
|
|
return " Files (0) NoProgram\n";
|
|
const sourceFiles = this.program.getSourceFiles();
|
|
let strBuilder = ` Files (${sourceFiles.length})
|
|
`;
|
|
if (writeProjectFileNames) {
|
|
for (const file of sourceFiles) {
|
|
strBuilder += ` ${file.fileName}
|
|
`;
|
|
}
|
|
strBuilder += "\n\n";
|
|
explainFiles(this.program, (s) => strBuilder += ` ${s}
|
|
`);
|
|
}
|
|
return strBuilder;
|
|
}
|
|
print(writeProjectFileNames) {
|
|
this.writeLog(`Project '${this.projectName}' (${ProjectKind[this.projectKind]})`);
|
|
this.writeLog(this.filesToString(writeProjectFileNames && this.projectService.logger.hasLevel(3 /* verbose */)));
|
|
this.writeLog("-----------------------------------------------");
|
|
if (this.autoImportProviderHost) {
|
|
this.autoImportProviderHost.print(false);
|
|
}
|
|
}
|
|
setCompilerOptions(compilerOptions) {
|
|
var _a2;
|
|
if (compilerOptions) {
|
|
compilerOptions.allowNonTsExtensions = true;
|
|
const oldOptions = this.compilerOptions;
|
|
this.compilerOptions = compilerOptions;
|
|
this.setInternalCompilerOptionsForEmittingJsFiles();
|
|
(_a2 = this.noDtsResolutionProject) == null ? void 0 : _a2.setCompilerOptions(this.getCompilerOptionsForNoDtsResolutionProject());
|
|
if (changesAffectModuleResolution(oldOptions, compilerOptions)) {
|
|
this.cachedUnresolvedImportsPerFile.clear();
|
|
this.lastCachedUnresolvedImportsList = void 0;
|
|
this.resolutionCache.clear();
|
|
this.moduleSpecifierCache.clear();
|
|
}
|
|
this.markAsDirty();
|
|
}
|
|
}
|
|
setWatchOptions(watchOptions) {
|
|
this.watchOptions = watchOptions;
|
|
}
|
|
getWatchOptions() {
|
|
return this.watchOptions;
|
|
}
|
|
setTypeAcquisition(newTypeAcquisition) {
|
|
if (newTypeAcquisition) {
|
|
this.typeAcquisition = this.removeLocalTypingsFromTypeAcquisition(newTypeAcquisition);
|
|
}
|
|
}
|
|
getTypeAcquisition() {
|
|
return this.typeAcquisition || {};
|
|
}
|
|
getChangesSinceVersion(lastKnownVersion, includeProjectReferenceRedirectInfo) {
|
|
const includeProjectReferenceRedirectInfoIfRequested = includeProjectReferenceRedirectInfo ? (files) => arrayFrom(files.entries(), ([fileName, isSourceOfProjectReferenceRedirect]) => ({
|
|
fileName,
|
|
isSourceOfProjectReferenceRedirect
|
|
})) : (files) => arrayFrom(files.keys());
|
|
if (!this.isInitialLoadPending()) {
|
|
updateProjectIfDirty(this);
|
|
}
|
|
const info = {
|
|
projectName: this.getProjectName(),
|
|
version: this.projectProgramVersion,
|
|
isInferred: isInferredProject(this),
|
|
options: this.getCompilationSettings(),
|
|
languageServiceDisabled: !this.languageServiceEnabled,
|
|
lastFileExceededProgramSize: this.lastFileExceededProgramSize
|
|
};
|
|
const updatedFileNames = this.updatedFileNames;
|
|
this.updatedFileNames = void 0;
|
|
if (this.lastReportedFileNames && lastKnownVersion === this.lastReportedVersion) {
|
|
if (this.projectProgramVersion === this.lastReportedVersion && !updatedFileNames) {
|
|
return { info, projectErrors: this.getGlobalProjectErrors() };
|
|
}
|
|
const lastReportedFileNames = this.lastReportedFileNames;
|
|
const externalFiles = this.getExternalFiles().map((f) => ({
|
|
fileName: toNormalizedPath(f),
|
|
isSourceOfProjectReferenceRedirect: false
|
|
}));
|
|
const currentFiles = arrayToMap(
|
|
this.getFileNamesWithRedirectInfo(!!includeProjectReferenceRedirectInfo).concat(externalFiles),
|
|
(info2) => info2.fileName,
|
|
(info2) => info2.isSourceOfProjectReferenceRedirect
|
|
);
|
|
const added = /* @__PURE__ */ new Map();
|
|
const removed = /* @__PURE__ */ new Map();
|
|
const updated = updatedFileNames ? arrayFrom(updatedFileNames.keys()) : [];
|
|
const updatedRedirects = [];
|
|
forEachEntry(currentFiles, (isSourceOfProjectReferenceRedirect, fileName) => {
|
|
if (!lastReportedFileNames.has(fileName)) {
|
|
added.set(fileName, isSourceOfProjectReferenceRedirect);
|
|
} else if (includeProjectReferenceRedirectInfo && isSourceOfProjectReferenceRedirect !== lastReportedFileNames.get(fileName)) {
|
|
updatedRedirects.push({
|
|
fileName,
|
|
isSourceOfProjectReferenceRedirect
|
|
});
|
|
}
|
|
});
|
|
forEachEntry(lastReportedFileNames, (isSourceOfProjectReferenceRedirect, fileName) => {
|
|
if (!currentFiles.has(fileName)) {
|
|
removed.set(fileName, isSourceOfProjectReferenceRedirect);
|
|
}
|
|
});
|
|
this.lastReportedFileNames = currentFiles;
|
|
this.lastReportedVersion = this.projectProgramVersion;
|
|
return {
|
|
info,
|
|
changes: {
|
|
added: includeProjectReferenceRedirectInfoIfRequested(added),
|
|
removed: includeProjectReferenceRedirectInfoIfRequested(removed),
|
|
updated: includeProjectReferenceRedirectInfo ? updated.map((fileName) => ({
|
|
fileName,
|
|
isSourceOfProjectReferenceRedirect: this.isSourceOfProjectReferenceRedirect(fileName)
|
|
})) : updated,
|
|
updatedRedirects: includeProjectReferenceRedirectInfo ? updatedRedirects : void 0
|
|
},
|
|
projectErrors: this.getGlobalProjectErrors()
|
|
};
|
|
} else {
|
|
const projectFileNames = this.getFileNamesWithRedirectInfo(!!includeProjectReferenceRedirectInfo);
|
|
const externalFiles = this.getExternalFiles().map((f) => ({
|
|
fileName: toNormalizedPath(f),
|
|
isSourceOfProjectReferenceRedirect: false
|
|
}));
|
|
const allFiles = projectFileNames.concat(externalFiles);
|
|
this.lastReportedFileNames = arrayToMap(
|
|
allFiles,
|
|
(info2) => info2.fileName,
|
|
(info2) => info2.isSourceOfProjectReferenceRedirect
|
|
);
|
|
this.lastReportedVersion = this.projectProgramVersion;
|
|
return {
|
|
info,
|
|
files: includeProjectReferenceRedirectInfo ? allFiles : allFiles.map((f) => f.fileName),
|
|
projectErrors: this.getGlobalProjectErrors()
|
|
};
|
|
}
|
|
}
|
|
removeRoot(info) {
|
|
orderedRemoveItem(this.rootFiles, info);
|
|
this.rootFilesMap.delete(info.path);
|
|
}
|
|
isSourceOfProjectReferenceRedirect(fileName) {
|
|
return !!this.program && this.program.isSourceOfProjectReferenceRedirect(fileName);
|
|
}
|
|
getGlobalPluginSearchPaths() {
|
|
return [
|
|
...this.projectService.pluginProbeLocations,
|
|
combinePaths(this.projectService.getExecutingFilePath(), "../../..")
|
|
];
|
|
}
|
|
enableGlobalPlugins(options, pluginConfigOverrides) {
|
|
if (!this.projectService.globalPlugins.length)
|
|
return;
|
|
const host = this.projectService.host;
|
|
if (!host.require && !host.importPlugin) {
|
|
this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
|
|
return;
|
|
}
|
|
const searchPaths = this.getGlobalPluginSearchPaths();
|
|
for (const globalPluginName of this.projectService.globalPlugins) {
|
|
if (!globalPluginName)
|
|
continue;
|
|
if (options.plugins && options.plugins.some((p) => p.name === globalPluginName))
|
|
continue;
|
|
this.projectService.logger.info(`Loading global plugin ${globalPluginName}`);
|
|
this.enablePlugin({ name: globalPluginName, global: true }, searchPaths, pluginConfigOverrides);
|
|
}
|
|
}
|
|
beginEnablePluginSync(pluginConfigEntry, searchPaths, pluginConfigOverrides) {
|
|
Debug.assertIsDefined(this.projectService.host.require);
|
|
let errorLogs;
|
|
const log = (message) => this.projectService.logger.info(message);
|
|
const logError = (message) => {
|
|
(errorLogs != null ? errorLogs : errorLogs = []).push(message);
|
|
};
|
|
const resolvedModule = firstDefined(searchPaths, (searchPath) => Project3.resolveModule(pluginConfigEntry.name, searchPath, this.projectService.host, log, logError));
|
|
return { pluginConfigEntry, pluginConfigOverrides, resolvedModule, errorLogs };
|
|
}
|
|
async beginEnablePluginAsync(pluginConfigEntry, searchPaths, pluginConfigOverrides) {
|
|
Debug.assertIsDefined(this.projectService.host.importPlugin);
|
|
let errorLogs;
|
|
const log = (message) => this.projectService.logger.info(message);
|
|
const logError = (message) => {
|
|
(errorLogs != null ? errorLogs : errorLogs = []).push(message);
|
|
};
|
|
let resolvedModule;
|
|
for (const searchPath of searchPaths) {
|
|
resolvedModule = await Project3.importServicePluginAsync(pluginConfigEntry.name, searchPath, this.projectService.host, log, logError);
|
|
if (resolvedModule !== void 0) {
|
|
break;
|
|
}
|
|
}
|
|
return { pluginConfigEntry, pluginConfigOverrides, resolvedModule, errorLogs };
|
|
}
|
|
endEnablePlugin({ pluginConfigEntry, pluginConfigOverrides, resolvedModule, errorLogs }) {
|
|
if (resolvedModule) {
|
|
const configurationOverride = pluginConfigOverrides && pluginConfigOverrides.get(pluginConfigEntry.name);
|
|
if (configurationOverride) {
|
|
const pluginName = pluginConfigEntry.name;
|
|
pluginConfigEntry = configurationOverride;
|
|
pluginConfigEntry.name = pluginName;
|
|
}
|
|
this.enableProxy(resolvedModule, pluginConfigEntry);
|
|
} else {
|
|
forEach(errorLogs, (message) => this.projectService.logger.info(message));
|
|
this.projectService.logger.info(`Couldn't find ${pluginConfigEntry.name}`);
|
|
}
|
|
}
|
|
enablePlugin(pluginConfigEntry, searchPaths, pluginConfigOverrides) {
|
|
this.projectService.requestEnablePlugin(this, pluginConfigEntry, searchPaths, pluginConfigOverrides);
|
|
}
|
|
enableProxy(pluginModuleFactory, configEntry) {
|
|
try {
|
|
if (typeof pluginModuleFactory !== "function") {
|
|
this.projectService.logger.info(`Skipped loading plugin ${configEntry.name} because it did not expose a proper factory function`);
|
|
return;
|
|
}
|
|
const info = {
|
|
config: configEntry,
|
|
project: this,
|
|
languageService: this.languageService,
|
|
languageServiceHost: this,
|
|
serverHost: this.projectService.host,
|
|
session: this.projectService.session
|
|
};
|
|
const pluginModule = pluginModuleFactory({ typescript: ts_exports3 });
|
|
const newLS = pluginModule.create(info);
|
|
for (const k of Object.keys(this.languageService)) {
|
|
if (!(k in newLS)) {
|
|
this.projectService.logger.info(`Plugin activation warning: Missing proxied method ${k} in created LS. Patching.`);
|
|
newLS[k] = this.languageService[k];
|
|
}
|
|
}
|
|
this.projectService.logger.info(`Plugin validation succeeded`);
|
|
this.languageService = newLS;
|
|
this.plugins.push({ name: configEntry.name, module: pluginModule });
|
|
} catch (e) {
|
|
this.projectService.logger.info(`Plugin activation failed: ${e}`);
|
|
}
|
|
}
|
|
onPluginConfigurationChanged(pluginName, configuration) {
|
|
this.plugins.filter((plugin) => plugin.name === pluginName).forEach((plugin) => {
|
|
if (plugin.module.onConfigurationChanged) {
|
|
plugin.module.onConfigurationChanged(configuration);
|
|
}
|
|
});
|
|
}
|
|
refreshDiagnostics() {
|
|
this.projectService.sendProjectsUpdatedInBackgroundEvent();
|
|
}
|
|
getPackageJsonsVisibleToFile(fileName, rootDir) {
|
|
if (this.projectService.serverMode !== 0 /* Semantic */)
|
|
return emptyArray2;
|
|
return this.projectService.getPackageJsonsVisibleToFile(fileName, rootDir);
|
|
}
|
|
getNearestAncestorDirectoryWithPackageJson(fileName) {
|
|
return this.projectService.getNearestAncestorDirectoryWithPackageJson(fileName);
|
|
}
|
|
getPackageJsonsForAutoImport(rootDir) {
|
|
const packageJsons = this.getPackageJsonsVisibleToFile(combinePaths(this.currentDirectory, inferredTypesContainingFile), rootDir);
|
|
this.packageJsonsForAutoImport = new Set(packageJsons.map((p) => p.fileName));
|
|
return packageJsons;
|
|
}
|
|
getPackageJsonCache() {
|
|
return this.projectService.packageJsonCache;
|
|
}
|
|
getCachedExportInfoMap() {
|
|
return this.exportMapCache || (this.exportMapCache = createCacheableExportInfoMap(this));
|
|
}
|
|
clearCachedExportInfoMap() {
|
|
var _a2;
|
|
(_a2 = this.exportMapCache) == null ? void 0 : _a2.clear();
|
|
}
|
|
getModuleSpecifierCache() {
|
|
return this.moduleSpecifierCache;
|
|
}
|
|
includePackageJsonAutoImports() {
|
|
if (this.projectService.includePackageJsonAutoImports() === 0 /* Off */ || !this.languageServiceEnabled || isInsideNodeModules(this.currentDirectory) || !this.isDefaultProjectForOpenFiles()) {
|
|
return 0 /* Off */;
|
|
}
|
|
return this.projectService.includePackageJsonAutoImports();
|
|
}
|
|
getModuleResolutionHostForAutoImportProvider() {
|
|
var _a2, _b;
|
|
if (this.program) {
|
|
return {
|
|
fileExists: this.program.fileExists,
|
|
directoryExists: this.program.directoryExists,
|
|
realpath: this.program.realpath || ((_a2 = this.projectService.host.realpath) == null ? void 0 : _a2.bind(this.projectService.host)),
|
|
getCurrentDirectory: this.getCurrentDirectory.bind(this),
|
|
readFile: this.projectService.host.readFile.bind(this.projectService.host),
|
|
getDirectories: this.projectService.host.getDirectories.bind(this.projectService.host),
|
|
trace: (_b = this.projectService.host.trace) == null ? void 0 : _b.bind(this.projectService.host),
|
|
useCaseSensitiveFileNames: this.program.useCaseSensitiveFileNames()
|
|
};
|
|
}
|
|
return this.projectService.host;
|
|
}
|
|
getPackageJsonAutoImportProvider() {
|
|
var _a2, _b, _c;
|
|
if (this.autoImportProviderHost === false) {
|
|
return void 0;
|
|
}
|
|
if (this.projectService.serverMode !== 0 /* Semantic */) {
|
|
this.autoImportProviderHost = false;
|
|
return void 0;
|
|
}
|
|
if (this.autoImportProviderHost) {
|
|
updateProjectIfDirty(this.autoImportProviderHost);
|
|
if (this.autoImportProviderHost.isEmpty()) {
|
|
this.autoImportProviderHost.close();
|
|
this.autoImportProviderHost = void 0;
|
|
return void 0;
|
|
}
|
|
return this.autoImportProviderHost.getCurrentProgram();
|
|
}
|
|
const dependencySelection = this.includePackageJsonAutoImports();
|
|
if (dependencySelection) {
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "getPackageJsonAutoImportProvider");
|
|
const start2 = timestamp();
|
|
this.autoImportProviderHost = AutoImportProviderProject.create(dependencySelection, this, this.getModuleResolutionHostForAutoImportProvider(), this.documentRegistry);
|
|
if (this.autoImportProviderHost) {
|
|
updateProjectIfDirty(this.autoImportProviderHost);
|
|
this.sendPerformanceEvent("CreatePackageJsonAutoImportProvider", timestamp() - start2);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return this.autoImportProviderHost.getCurrentProgram();
|
|
}
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
}
|
|
}
|
|
isDefaultProjectForOpenFiles() {
|
|
return !!forEachEntry(
|
|
this.projectService.openFiles,
|
|
(_, fileName) => this.projectService.tryGetDefaultProjectForFile(toNormalizedPath(fileName)) === this
|
|
);
|
|
}
|
|
watchNodeModulesForPackageJsonChanges(directoryPath) {
|
|
return this.projectService.watchPackageJsonsInNodeModules(this.toPath(directoryPath), this);
|
|
}
|
|
getIncompleteCompletionsCache() {
|
|
return this.projectService.getIncompleteCompletionsCache();
|
|
}
|
|
getNoDtsResolutionProject(rootFileNames) {
|
|
Debug.assert(this.projectService.serverMode === 0 /* Semantic */);
|
|
if (!this.noDtsResolutionProject) {
|
|
this.noDtsResolutionProject = new AuxiliaryProject(this.projectService, this.documentRegistry, this.getCompilerOptionsForNoDtsResolutionProject());
|
|
}
|
|
enumerateInsertsAndDeletes(
|
|
rootFileNames.map(toNormalizedPath),
|
|
this.noDtsResolutionProject.getRootFiles(),
|
|
getStringComparer(!this.useCaseSensitiveFileNames()),
|
|
(pathToAdd) => {
|
|
const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(
|
|
pathToAdd,
|
|
this.currentDirectory,
|
|
this.noDtsResolutionProject.directoryStructureHost
|
|
);
|
|
if (info) {
|
|
this.noDtsResolutionProject.addRoot(info, pathToAdd);
|
|
}
|
|
},
|
|
(pathToRemove) => {
|
|
const info = this.noDtsResolutionProject.getScriptInfo(pathToRemove);
|
|
if (info) {
|
|
this.noDtsResolutionProject.removeRoot(info);
|
|
}
|
|
}
|
|
);
|
|
return this.noDtsResolutionProject;
|
|
}
|
|
getCompilerOptionsForNoDtsResolutionProject() {
|
|
return {
|
|
...this.getCompilerOptions(),
|
|
noDtsResolution: true,
|
|
allowJs: true,
|
|
maxNodeModuleJsDepth: 3,
|
|
diagnostics: false,
|
|
skipLibCheck: true,
|
|
sourceMap: false,
|
|
types: emptyArray,
|
|
lib: emptyArray,
|
|
noLib: true
|
|
};
|
|
}
|
|
};
|
|
function getUnresolvedImports(program, cachedUnresolvedImportsPerFile) {
|
|
var _a2, _b;
|
|
const sourceFiles = program.getSourceFiles();
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "getUnresolvedImports", { count: sourceFiles.length });
|
|
const ambientModules = program.getTypeChecker().getAmbientModules().map((mod) => stripQuotes(mod.getName()));
|
|
const result = sortAndDeduplicate(flatMap(sourceFiles, (sourceFile) => extractUnresolvedImportsFromSourceFile(sourceFile, ambientModules, cachedUnresolvedImportsPerFile)));
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
return result;
|
|
}
|
|
function extractUnresolvedImportsFromSourceFile(file, ambientModules, cachedUnresolvedImportsPerFile) {
|
|
return getOrUpdate(cachedUnresolvedImportsPerFile, file.path, () => {
|
|
if (!file.resolvedModules)
|
|
return emptyArray2;
|
|
let unresolvedImports;
|
|
file.resolvedModules.forEach((resolvedModule, name) => {
|
|
if ((!resolvedModule || !resolutionExtensionIsTSOrJson(resolvedModule.extension)) && !isExternalModuleNameRelative(name) && !ambientModules.some((m) => m === name)) {
|
|
unresolvedImports = append(unresolvedImports, parsePackageName(name).packageName);
|
|
}
|
|
});
|
|
return unresolvedImports || emptyArray2;
|
|
});
|
|
}
|
|
var InferredProject2 = class extends Project3 {
|
|
constructor(projectService, documentRegistry, compilerOptions, watchOptions, projectRootPath, currentDirectory, pluginConfigOverrides, typeAcquisition) {
|
|
super(
|
|
projectService.newInferredProjectName(),
|
|
0 /* Inferred */,
|
|
projectService,
|
|
documentRegistry,
|
|
void 0,
|
|
void 0,
|
|
compilerOptions,
|
|
false,
|
|
watchOptions,
|
|
projectService.host,
|
|
currentDirectory
|
|
);
|
|
this._isJsInferredProject = false;
|
|
this.typeAcquisition = typeAcquisition;
|
|
this.projectRootPath = projectRootPath && projectService.toCanonicalFileName(projectRootPath);
|
|
if (!projectRootPath && !projectService.useSingleInferredProject) {
|
|
this.canonicalCurrentDirectory = projectService.toCanonicalFileName(this.currentDirectory);
|
|
}
|
|
this.enableGlobalPlugins(this.getCompilerOptions(), pluginConfigOverrides);
|
|
}
|
|
toggleJsInferredProject(isJsInferredProject) {
|
|
if (isJsInferredProject !== this._isJsInferredProject) {
|
|
this._isJsInferredProject = isJsInferredProject;
|
|
this.setCompilerOptions();
|
|
}
|
|
}
|
|
setCompilerOptions(options) {
|
|
if (!options && !this.getCompilationSettings()) {
|
|
return;
|
|
}
|
|
const newOptions = cloneCompilerOptions(options || this.getCompilationSettings());
|
|
if (this._isJsInferredProject && typeof newOptions.maxNodeModuleJsDepth !== "number") {
|
|
newOptions.maxNodeModuleJsDepth = 2;
|
|
} else if (!this._isJsInferredProject) {
|
|
newOptions.maxNodeModuleJsDepth = void 0;
|
|
}
|
|
newOptions.allowJs = true;
|
|
super.setCompilerOptions(newOptions);
|
|
}
|
|
addRoot(info) {
|
|
Debug.assert(info.isScriptOpen());
|
|
this.projectService.startWatchingConfigFilesForInferredProjectRoot(info);
|
|
if (!this._isJsInferredProject && info.isJavaScript()) {
|
|
this.toggleJsInferredProject(true);
|
|
}
|
|
super.addRoot(info);
|
|
}
|
|
removeRoot(info) {
|
|
this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info);
|
|
super.removeRoot(info);
|
|
if (this._isJsInferredProject && info.isJavaScript()) {
|
|
if (every(this.getRootScriptInfos(), (rootInfo) => !rootInfo.isJavaScript())) {
|
|
this.toggleJsInferredProject(false);
|
|
}
|
|
}
|
|
}
|
|
isOrphan() {
|
|
return !this.hasRoots();
|
|
}
|
|
isProjectWithSingleRoot() {
|
|
return !this.projectRootPath && !this.projectService.useSingleInferredProject || this.getRootScriptInfos().length === 1;
|
|
}
|
|
close() {
|
|
forEach(this.getRootScriptInfos(), (info) => this.projectService.stopWatchingConfigFilesForInferredProjectRoot(info));
|
|
super.close();
|
|
}
|
|
getTypeAcquisition() {
|
|
return this.typeAcquisition || {
|
|
enable: allRootFilesAreJsOrDts(this),
|
|
include: emptyArray,
|
|
exclude: emptyArray
|
|
};
|
|
}
|
|
};
|
|
var AuxiliaryProject = class extends Project3 {
|
|
constructor(projectService, documentRegistry, compilerOptions) {
|
|
super(
|
|
projectService.newAuxiliaryProjectName(),
|
|
4 /* Auxiliary */,
|
|
projectService,
|
|
documentRegistry,
|
|
false,
|
|
void 0,
|
|
compilerOptions,
|
|
false,
|
|
void 0,
|
|
projectService.host,
|
|
void 0
|
|
);
|
|
}
|
|
isOrphan() {
|
|
return true;
|
|
}
|
|
scheduleInvalidateResolutionsOfFailedLookupLocations() {
|
|
return;
|
|
}
|
|
};
|
|
var _AutoImportProviderProject = class extends Project3 {
|
|
constructor(hostProject, initialRootNames, documentRegistry, compilerOptions) {
|
|
super(
|
|
hostProject.projectService.newAutoImportProviderProjectName(),
|
|
3 /* AutoImportProvider */,
|
|
hostProject.projectService,
|
|
documentRegistry,
|
|
false,
|
|
void 0,
|
|
compilerOptions,
|
|
false,
|
|
hostProject.getWatchOptions(),
|
|
hostProject.projectService.host,
|
|
hostProject.currentDirectory
|
|
);
|
|
this.hostProject = hostProject;
|
|
this.rootFileNames = initialRootNames;
|
|
this.useSourceOfProjectReferenceRedirect = maybeBind(this.hostProject, this.hostProject.useSourceOfProjectReferenceRedirect);
|
|
this.getParsedCommandLine = maybeBind(this.hostProject, this.hostProject.getParsedCommandLine);
|
|
}
|
|
static getRootFileNames(dependencySelection, hostProject, moduleResolutionHost, compilerOptions) {
|
|
var _a2, _b;
|
|
if (!dependencySelection) {
|
|
return emptyArray;
|
|
}
|
|
const program = hostProject.getCurrentProgram();
|
|
if (!program) {
|
|
return emptyArray;
|
|
}
|
|
const start2 = timestamp();
|
|
let dependencyNames;
|
|
let rootNames;
|
|
const rootFileName = combinePaths(hostProject.currentDirectory, inferredTypesContainingFile);
|
|
const packageJsons = hostProject.getPackageJsonsForAutoImport(combinePaths(hostProject.currentDirectory, rootFileName));
|
|
for (const packageJson of packageJsons) {
|
|
(_a2 = packageJson.dependencies) == null ? void 0 : _a2.forEach((_, dependenyName) => addDependency(dependenyName));
|
|
(_b = packageJson.peerDependencies) == null ? void 0 : _b.forEach((_, dependencyName) => addDependency(dependencyName));
|
|
}
|
|
let dependenciesAdded = 0;
|
|
if (dependencyNames) {
|
|
const symlinkCache = hostProject.getSymlinkCache();
|
|
for (const name of arrayFrom(dependencyNames.keys())) {
|
|
if (dependencySelection === 2 /* Auto */ && dependenciesAdded > this.maxDependencies) {
|
|
hostProject.log(`AutoImportProviderProject: attempted to add more than ${this.maxDependencies} dependencies. Aborting.`);
|
|
return emptyArray;
|
|
}
|
|
const packageJson = resolvePackageNameToPackageJson(
|
|
name,
|
|
hostProject.currentDirectory,
|
|
compilerOptions,
|
|
moduleResolutionHost,
|
|
program.getModuleResolutionCache()
|
|
);
|
|
if (packageJson) {
|
|
const entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache);
|
|
if (entrypoints) {
|
|
rootNames = concatenate(rootNames, entrypoints);
|
|
dependenciesAdded += entrypoints.length ? 1 : 0;
|
|
continue;
|
|
}
|
|
}
|
|
const done = forEach([hostProject.currentDirectory, hostProject.getGlobalTypingsCacheLocation()], (directory) => {
|
|
if (directory) {
|
|
const typesPackageJson = resolvePackageNameToPackageJson(
|
|
`@types/${name}`,
|
|
directory,
|
|
compilerOptions,
|
|
moduleResolutionHost,
|
|
program.getModuleResolutionCache()
|
|
);
|
|
if (typesPackageJson) {
|
|
const entrypoints = getRootNamesFromPackageJson(typesPackageJson, program, symlinkCache);
|
|
rootNames = concatenate(rootNames, entrypoints);
|
|
dependenciesAdded += (entrypoints == null ? void 0 : entrypoints.length) ? 1 : 0;
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
if (done)
|
|
continue;
|
|
if (packageJson && compilerOptions.allowJs && compilerOptions.maxNodeModuleJsDepth) {
|
|
const entrypoints = getRootNamesFromPackageJson(packageJson, program, symlinkCache, true);
|
|
rootNames = concatenate(rootNames, entrypoints);
|
|
dependenciesAdded += (entrypoints == null ? void 0 : entrypoints.length) ? 1 : 0;
|
|
}
|
|
}
|
|
}
|
|
if (rootNames == null ? void 0 : rootNames.length) {
|
|
hostProject.log(`AutoImportProviderProject: found ${rootNames.length} root files in ${dependenciesAdded} dependencies in ${timestamp() - start2} ms`);
|
|
}
|
|
return rootNames || emptyArray;
|
|
function addDependency(dependency) {
|
|
if (!startsWith(dependency, "@types/")) {
|
|
(dependencyNames || (dependencyNames = /* @__PURE__ */ new Set())).add(dependency);
|
|
}
|
|
}
|
|
function getRootNamesFromPackageJson(packageJson, program2, symlinkCache, resolveJs) {
|
|
var _a3;
|
|
const entrypoints = getEntrypointsFromPackageJsonInfo(
|
|
packageJson,
|
|
compilerOptions,
|
|
moduleResolutionHost,
|
|
program2.getModuleResolutionCache(),
|
|
resolveJs
|
|
);
|
|
if (entrypoints) {
|
|
const real = (_a3 = moduleResolutionHost.realpath) == null ? void 0 : _a3.call(moduleResolutionHost, packageJson.packageDirectory);
|
|
const isSymlink = real && real !== packageJson.packageDirectory;
|
|
if (isSymlink) {
|
|
symlinkCache.setSymlinkedDirectory(packageJson.packageDirectory, {
|
|
real,
|
|
realPath: hostProject.toPath(real)
|
|
});
|
|
}
|
|
return mapDefined(entrypoints, (entrypoint) => {
|
|
const resolvedFileName = isSymlink ? entrypoint.replace(packageJson.packageDirectory, real) : entrypoint;
|
|
if (!program2.getSourceFile(resolvedFileName) && !(isSymlink && program2.getSourceFile(entrypoint))) {
|
|
return resolvedFileName;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
static create(dependencySelection, hostProject, moduleResolutionHost, documentRegistry) {
|
|
if (dependencySelection === 0 /* Off */) {
|
|
return void 0;
|
|
}
|
|
const compilerOptions = {
|
|
...hostProject.getCompilerOptions(),
|
|
...this.compilerOptionsOverrides
|
|
};
|
|
const rootNames = this.getRootFileNames(dependencySelection, hostProject, moduleResolutionHost, compilerOptions);
|
|
if (!rootNames.length) {
|
|
return void 0;
|
|
}
|
|
return new _AutoImportProviderProject(hostProject, rootNames, documentRegistry, compilerOptions);
|
|
}
|
|
isEmpty() {
|
|
return !some(this.rootFileNames);
|
|
}
|
|
isOrphan() {
|
|
return true;
|
|
}
|
|
updateGraph() {
|
|
let rootFileNames = this.rootFileNames;
|
|
if (!rootFileNames) {
|
|
rootFileNames = _AutoImportProviderProject.getRootFileNames(
|
|
this.hostProject.includePackageJsonAutoImports(),
|
|
this.hostProject,
|
|
this.hostProject.getModuleResolutionHostForAutoImportProvider(),
|
|
this.getCompilationSettings()
|
|
);
|
|
}
|
|
this.projectService.setFileNamesOfAutoImportProviderProject(this, rootFileNames);
|
|
this.rootFileNames = rootFileNames;
|
|
const oldProgram = this.getCurrentProgram();
|
|
const hasSameSetOfFiles = super.updateGraph();
|
|
if (oldProgram && oldProgram !== this.getCurrentProgram()) {
|
|
this.hostProject.clearCachedExportInfoMap();
|
|
}
|
|
return hasSameSetOfFiles;
|
|
}
|
|
scheduleInvalidateResolutionsOfFailedLookupLocations() {
|
|
return;
|
|
}
|
|
hasRoots() {
|
|
var _a2;
|
|
return !!((_a2 = this.rootFileNames) == null ? void 0 : _a2.length);
|
|
}
|
|
markAsDirty() {
|
|
this.rootFileNames = void 0;
|
|
super.markAsDirty();
|
|
}
|
|
getScriptFileNames() {
|
|
return this.rootFileNames || emptyArray;
|
|
}
|
|
getLanguageService() {
|
|
throw new Error("AutoImportProviderProject language service should never be used. To get the program, use `project.getCurrentProgram()`.");
|
|
}
|
|
onAutoImportProviderSettingsChanged() {
|
|
throw new Error("AutoImportProviderProject is an auto import provider; use `markAsDirty()` instead.");
|
|
}
|
|
onPackageJsonChange() {
|
|
throw new Error("package.json changes should be notified on an AutoImportProvider's host project");
|
|
}
|
|
getModuleResolutionHostForAutoImportProvider() {
|
|
throw new Error("AutoImportProviderProject cannot provide its own host; use `hostProject.getModuleResolutionHostForAutomImportProvider()` instead.");
|
|
}
|
|
getProjectReferences() {
|
|
return this.hostProject.getProjectReferences();
|
|
}
|
|
includePackageJsonAutoImports() {
|
|
return 0 /* Off */;
|
|
}
|
|
getTypeAcquisition() {
|
|
return { enable: false };
|
|
}
|
|
getSymlinkCache() {
|
|
return this.hostProject.getSymlinkCache();
|
|
}
|
|
getModuleResolutionCache() {
|
|
var _a2;
|
|
return (_a2 = this.hostProject.getCurrentProgram()) == null ? void 0 : _a2.getModuleResolutionCache();
|
|
}
|
|
};
|
|
var AutoImportProviderProject = _AutoImportProviderProject;
|
|
AutoImportProviderProject.maxDependencies = 10;
|
|
AutoImportProviderProject.compilerOptionsOverrides = {
|
|
diagnostics: false,
|
|
skipLibCheck: true,
|
|
sourceMap: false,
|
|
types: emptyArray,
|
|
lib: emptyArray,
|
|
noLib: true
|
|
};
|
|
var ConfiguredProject2 = class extends Project3 {
|
|
constructor(configFileName, canonicalConfigFilePath, projectService, documentRegistry, cachedDirectoryStructureHost) {
|
|
super(
|
|
configFileName,
|
|
1 /* Configured */,
|
|
projectService,
|
|
documentRegistry,
|
|
false,
|
|
void 0,
|
|
{},
|
|
false,
|
|
void 0,
|
|
cachedDirectoryStructureHost,
|
|
getDirectoryPath(configFileName)
|
|
);
|
|
this.canonicalConfigFilePath = canonicalConfigFilePath;
|
|
this.openFileWatchTriggered = /* @__PURE__ */ new Map();
|
|
this.canConfigFileJsonReportNoInputFiles = false;
|
|
this.externalProjectRefCount = 0;
|
|
this.isInitialLoadPending = returnTrue;
|
|
this.sendLoadingProjectFinish = false;
|
|
}
|
|
setCompilerHost(host) {
|
|
this.compilerHost = host;
|
|
}
|
|
getCompilerHost() {
|
|
return this.compilerHost;
|
|
}
|
|
useSourceOfProjectReferenceRedirect() {
|
|
return this.languageServiceEnabled;
|
|
}
|
|
getParsedCommandLine(fileName) {
|
|
const configFileName = asNormalizedPath(normalizePath(fileName));
|
|
const canonicalConfigFilePath = asNormalizedPath(this.projectService.toCanonicalFileName(configFileName));
|
|
let configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!configFileExistenceInfo) {
|
|
this.projectService.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo = { exists: this.projectService.host.fileExists(configFileName) });
|
|
}
|
|
this.projectService.ensureParsedConfigUptoDate(configFileName, canonicalConfigFilePath, configFileExistenceInfo, this);
|
|
if (this.languageServiceEnabled && this.projectService.serverMode === 0 /* Semantic */) {
|
|
this.projectService.watchWildcards(configFileName, configFileExistenceInfo, this);
|
|
}
|
|
return configFileExistenceInfo.exists ? configFileExistenceInfo.config.parsedCommandLine : void 0;
|
|
}
|
|
onReleaseParsedCommandLine(fileName) {
|
|
this.releaseParsedConfig(asNormalizedPath(this.projectService.toCanonicalFileName(asNormalizedPath(normalizePath(fileName)))));
|
|
}
|
|
releaseParsedConfig(canonicalConfigFilePath) {
|
|
this.projectService.stopWatchingWildCards(canonicalConfigFilePath, this);
|
|
this.projectService.releaseParsedConfig(canonicalConfigFilePath, this);
|
|
}
|
|
updateGraph() {
|
|
const isInitialLoad = this.isInitialLoadPending();
|
|
this.isInitialLoadPending = returnFalse;
|
|
const reloadLevel = this.pendingReload;
|
|
this.pendingReload = 0 /* None */;
|
|
let result;
|
|
switch (reloadLevel) {
|
|
case 1 /* Partial */:
|
|
this.openFileWatchTriggered.clear();
|
|
result = this.projectService.reloadFileNamesOfConfiguredProject(this);
|
|
break;
|
|
case 2 /* Full */:
|
|
this.openFileWatchTriggered.clear();
|
|
const reason = Debug.checkDefined(this.pendingReloadReason);
|
|
this.pendingReloadReason = void 0;
|
|
this.projectService.reloadConfiguredProject(this, reason, isInitialLoad, false);
|
|
result = true;
|
|
break;
|
|
default:
|
|
result = super.updateGraph();
|
|
}
|
|
this.compilerHost = void 0;
|
|
this.projectService.sendProjectLoadingFinishEvent(this);
|
|
this.projectService.sendProjectTelemetry(this);
|
|
return result;
|
|
}
|
|
getCachedDirectoryStructureHost() {
|
|
return this.directoryStructureHost;
|
|
}
|
|
getConfigFilePath() {
|
|
return asNormalizedPath(this.getProjectName());
|
|
}
|
|
getProjectReferences() {
|
|
return this.projectReferences;
|
|
}
|
|
updateReferences(refs) {
|
|
this.projectReferences = refs;
|
|
this.potentialProjectReferences = void 0;
|
|
}
|
|
setPotentialProjectReference(canonicalConfigPath) {
|
|
Debug.assert(this.isInitialLoadPending());
|
|
(this.potentialProjectReferences || (this.potentialProjectReferences = /* @__PURE__ */ new Set())).add(canonicalConfigPath);
|
|
}
|
|
getResolvedProjectReferenceToRedirect(fileName) {
|
|
const program = this.getCurrentProgram();
|
|
return program && program.getResolvedProjectReferenceToRedirect(fileName);
|
|
}
|
|
forEachResolvedProjectReference(cb) {
|
|
var _a2;
|
|
return (_a2 = this.getCurrentProgram()) == null ? void 0 : _a2.forEachResolvedProjectReference(cb);
|
|
}
|
|
enablePluginsWithOptions(options, pluginConfigOverrides) {
|
|
var _a2;
|
|
this.plugins.length = 0;
|
|
if (!((_a2 = options.plugins) == null ? void 0 : _a2.length) && !this.projectService.globalPlugins.length)
|
|
return;
|
|
const host = this.projectService.host;
|
|
if (!host.require && !host.importPlugin) {
|
|
this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
|
|
return;
|
|
}
|
|
const searchPaths = this.getGlobalPluginSearchPaths();
|
|
if (this.projectService.allowLocalPluginLoads) {
|
|
const local = getDirectoryPath(this.canonicalConfigFilePath);
|
|
this.projectService.logger.info(`Local plugin loading enabled; adding ${local} to search paths`);
|
|
searchPaths.unshift(local);
|
|
}
|
|
if (options.plugins) {
|
|
for (const pluginConfigEntry of options.plugins) {
|
|
this.enablePlugin(pluginConfigEntry, searchPaths, pluginConfigOverrides);
|
|
}
|
|
}
|
|
return this.enableGlobalPlugins(options, pluginConfigOverrides);
|
|
}
|
|
getGlobalProjectErrors() {
|
|
return filter(this.projectErrors, (diagnostic) => !diagnostic.file) || emptyArray2;
|
|
}
|
|
getAllProjectErrors() {
|
|
return this.projectErrors || emptyArray2;
|
|
}
|
|
setProjectErrors(projectErrors) {
|
|
this.projectErrors = projectErrors;
|
|
}
|
|
close() {
|
|
this.projectService.configFileExistenceInfoCache.forEach((_configFileExistenceInfo, canonicalConfigFilePath) => this.releaseParsedConfig(canonicalConfigFilePath));
|
|
this.projectErrors = void 0;
|
|
this.openFileWatchTriggered.clear();
|
|
this.compilerHost = void 0;
|
|
super.close();
|
|
}
|
|
addExternalProjectReference() {
|
|
this.externalProjectRefCount++;
|
|
}
|
|
deleteExternalProjectReference() {
|
|
this.externalProjectRefCount--;
|
|
}
|
|
isSolution() {
|
|
return this.getRootFilesMap().size === 0 && !this.canConfigFileJsonReportNoInputFiles;
|
|
}
|
|
getDefaultChildProjectFromProjectWithReferences(info) {
|
|
return forEachResolvedProjectReferenceProject(
|
|
this,
|
|
info.path,
|
|
(child) => projectContainsInfoDirectly(child, info) ? child : void 0,
|
|
0 /* Find */
|
|
);
|
|
}
|
|
hasOpenRef() {
|
|
var _a2;
|
|
if (!!this.externalProjectRefCount) {
|
|
return true;
|
|
}
|
|
if (this.isClosed()) {
|
|
return false;
|
|
}
|
|
const configFileExistenceInfo = this.projectService.configFileExistenceInfoCache.get(this.canonicalConfigFilePath);
|
|
if (this.projectService.hasPendingProjectUpdate(this)) {
|
|
return !!((_a2 = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a2.size);
|
|
}
|
|
return !!configFileExistenceInfo.openFilesImpactedByConfigFile && forEachEntry(
|
|
configFileExistenceInfo.openFilesImpactedByConfigFile,
|
|
(_value, infoPath) => {
|
|
const info = this.projectService.getScriptInfoForPath(infoPath);
|
|
return this.containsScriptInfo(info) || !!forEachResolvedProjectReferenceProject(
|
|
this,
|
|
info.path,
|
|
(child) => child.containsScriptInfo(info),
|
|
0 /* Find */
|
|
);
|
|
}
|
|
) || false;
|
|
}
|
|
hasExternalProjectRef() {
|
|
return !!this.externalProjectRefCount;
|
|
}
|
|
getEffectiveTypeRoots() {
|
|
return getEffectiveTypeRoots(this.getCompilationSettings(), this.directoryStructureHost) || [];
|
|
}
|
|
updateErrorOnNoInputFiles(fileNames) {
|
|
updateErrorForNoInputFiles(fileNames, this.getConfigFilePath(), this.getCompilerOptions().configFile.configFileSpecs, this.projectErrors, this.canConfigFileJsonReportNoInputFiles);
|
|
}
|
|
};
|
|
var ExternalProject2 = class extends Project3 {
|
|
constructor(externalProjectName, projectService, documentRegistry, compilerOptions, lastFileExceededProgramSize, compileOnSaveEnabled, projectFilePath, pluginConfigOverrides, watchOptions) {
|
|
super(
|
|
externalProjectName,
|
|
2 /* External */,
|
|
projectService,
|
|
documentRegistry,
|
|
true,
|
|
lastFileExceededProgramSize,
|
|
compilerOptions,
|
|
compileOnSaveEnabled,
|
|
watchOptions,
|
|
projectService.host,
|
|
getDirectoryPath(projectFilePath || normalizeSlashes(externalProjectName))
|
|
);
|
|
this.externalProjectName = externalProjectName;
|
|
this.compileOnSaveEnabled = compileOnSaveEnabled;
|
|
this.excludedFiles = [];
|
|
this.enableGlobalPlugins(this.getCompilerOptions(), pluginConfigOverrides);
|
|
}
|
|
updateGraph() {
|
|
const result = super.updateGraph();
|
|
this.projectService.sendProjectTelemetry(this);
|
|
return result;
|
|
}
|
|
getExcludedFiles() {
|
|
return this.excludedFiles;
|
|
}
|
|
};
|
|
function isInferredProject(project) {
|
|
return project.projectKind === 0 /* Inferred */;
|
|
}
|
|
function isConfiguredProject(project) {
|
|
return project.projectKind === 1 /* Configured */;
|
|
}
|
|
function isExternalProject(project) {
|
|
return project.projectKind === 2 /* External */;
|
|
}
|
|
|
|
// src/server/editorServices.ts
|
|
var maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;
|
|
var maxFileSize = 4 * 1024 * 1024;
|
|
var ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground";
|
|
var ProjectLoadingStartEvent = "projectLoadingStart";
|
|
var ProjectLoadingFinishEvent = "projectLoadingFinish";
|
|
var LargeFileReferencedEvent = "largeFileReferenced";
|
|
var ConfigFileDiagEvent = "configFileDiag";
|
|
var ProjectLanguageServiceStateEvent = "projectLanguageServiceState";
|
|
var ProjectInfoTelemetryEvent = "projectInfo";
|
|
var OpenFileInfoTelemetryEvent = "openFileInfo";
|
|
var ensureProjectForOpenFileSchedule = "*ensureProjectForOpenFiles*";
|
|
function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
for (const option of commandLineOptions) {
|
|
if (typeof option.type === "object") {
|
|
const optionMap = option.type;
|
|
optionMap.forEach((value) => {
|
|
Debug.assert(typeof value === "number");
|
|
});
|
|
map2.set(option.name, optionMap);
|
|
}
|
|
}
|
|
return map2;
|
|
}
|
|
var compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);
|
|
var watchOptionsConverters = prepareConvertersForEnumLikeCompilerOptions(optionsForWatch);
|
|
var indentStyle = new Map(getEntries({
|
|
none: 0 /* None */,
|
|
block: 1 /* Block */,
|
|
smart: 2 /* Smart */
|
|
}));
|
|
var defaultTypeSafeList = {
|
|
"jquery": {
|
|
match: /jquery(-[\d\.]+)?(\.intellisense)?(\.min)?\.js$/i,
|
|
types: ["jquery"]
|
|
},
|
|
"WinJS": {
|
|
match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i,
|
|
exclude: [["^", 1, "/.*"]],
|
|
types: ["winjs"]
|
|
},
|
|
"Kendo": {
|
|
match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i,
|
|
exclude: [["^", 1, "/.*"]],
|
|
types: ["kendo-ui"]
|
|
},
|
|
"Office Nuget": {
|
|
match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i,
|
|
exclude: [["^", 1, "/.*"]],
|
|
types: ["office"]
|
|
},
|
|
"References": {
|
|
match: /^(.*\/_references\.js)$/i,
|
|
exclude: [["^", 1, "$"]]
|
|
}
|
|
};
|
|
function convertFormatOptions(protocolOptions) {
|
|
if (isString(protocolOptions.indentStyle)) {
|
|
protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase());
|
|
Debug.assert(protocolOptions.indentStyle !== void 0);
|
|
}
|
|
return protocolOptions;
|
|
}
|
|
function convertCompilerOptions(protocolOptions) {
|
|
compilerOptionConverters.forEach((mappedValues, id) => {
|
|
const propertyValue = protocolOptions[id];
|
|
if (isString(propertyValue)) {
|
|
protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());
|
|
}
|
|
});
|
|
return protocolOptions;
|
|
}
|
|
function convertWatchOptions(protocolOptions, currentDirectory) {
|
|
let watchOptions;
|
|
let errors;
|
|
optionsForWatch.forEach((option) => {
|
|
const propertyValue = protocolOptions[option.name];
|
|
if (propertyValue === void 0)
|
|
return;
|
|
const mappedValues = watchOptionsConverters.get(option.name);
|
|
(watchOptions || (watchOptions = {}))[option.name] = mappedValues ? isString(propertyValue) ? mappedValues.get(propertyValue.toLowerCase()) : propertyValue : convertJsonOption(option, propertyValue, currentDirectory || "", errors || (errors = []));
|
|
});
|
|
return watchOptions && { watchOptions, errors };
|
|
}
|
|
function convertTypeAcquisition(protocolOptions) {
|
|
let result;
|
|
typeAcquisitionDeclarations.forEach((option) => {
|
|
const propertyValue = protocolOptions[option.name];
|
|
if (propertyValue === void 0)
|
|
return;
|
|
(result || (result = {}))[option.name] = propertyValue;
|
|
});
|
|
return result;
|
|
}
|
|
function tryConvertScriptKindName(scriptKindName) {
|
|
return isString(scriptKindName) ? convertScriptKindName(scriptKindName) : scriptKindName;
|
|
}
|
|
function convertScriptKindName(scriptKindName) {
|
|
switch (scriptKindName) {
|
|
case "JS":
|
|
return 1 /* JS */;
|
|
case "JSX":
|
|
return 2 /* JSX */;
|
|
case "TS":
|
|
return 3 /* TS */;
|
|
case "TSX":
|
|
return 4 /* TSX */;
|
|
default:
|
|
return 0 /* Unknown */;
|
|
}
|
|
}
|
|
function convertUserPreferences(preferences) {
|
|
const { lazyConfiguredProjectsFromExternalProject, ...userPreferences } = preferences;
|
|
return userPreferences;
|
|
}
|
|
var fileNamePropertyReader = {
|
|
getFileName: (x) => x,
|
|
getScriptKind: (fileName, extraFileExtensions) => {
|
|
let result;
|
|
if (extraFileExtensions) {
|
|
const fileExtension = getAnyExtensionFromPath(fileName);
|
|
if (fileExtension) {
|
|
some(extraFileExtensions, (info) => {
|
|
if (info.extension === fileExtension) {
|
|
result = info.scriptKind;
|
|
return true;
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, (ext) => ext.isMixedContent && fileExtensionIs(fileName, ext.extension))
|
|
};
|
|
var externalFilePropertyReader = {
|
|
getFileName: (x) => x.fileName,
|
|
getScriptKind: (x) => tryConvertScriptKindName(x.scriptKind),
|
|
hasMixedContent: (x) => !!x.hasMixedContent
|
|
};
|
|
function findProjectByName(projectName, projects) {
|
|
for (const proj of projects) {
|
|
if (proj.getProjectName() === projectName) {
|
|
return proj;
|
|
}
|
|
}
|
|
}
|
|
var noopConfigFileWatcher = { close: noop };
|
|
function isOpenScriptInfo(infoOrFileNameOrConfig) {
|
|
return !!infoOrFileNameOrConfig.containingProjects;
|
|
}
|
|
function isAncestorConfigFileInfo(infoOrFileNameOrConfig) {
|
|
return !!infoOrFileNameOrConfig.configFileInfo;
|
|
}
|
|
var ProjectReferenceProjectLoadKind = /* @__PURE__ */ ((ProjectReferenceProjectLoadKind2) => {
|
|
ProjectReferenceProjectLoadKind2[ProjectReferenceProjectLoadKind2["Find"] = 0] = "Find";
|
|
ProjectReferenceProjectLoadKind2[ProjectReferenceProjectLoadKind2["FindCreate"] = 1] = "FindCreate";
|
|
ProjectReferenceProjectLoadKind2[ProjectReferenceProjectLoadKind2["FindCreateLoad"] = 2] = "FindCreateLoad";
|
|
return ProjectReferenceProjectLoadKind2;
|
|
})(ProjectReferenceProjectLoadKind || {});
|
|
function forEachResolvedProjectReferenceProject(project, fileName, cb, projectReferenceProjectLoadKind, reason) {
|
|
var _a2;
|
|
const resolvedRefs = (_a2 = project.getCurrentProgram()) == null ? void 0 : _a2.getResolvedProjectReferences();
|
|
if (!resolvedRefs)
|
|
return void 0;
|
|
let seenResolvedRefs;
|
|
const possibleDefaultRef = fileName ? project.getResolvedProjectReferenceToRedirect(fileName) : void 0;
|
|
if (possibleDefaultRef) {
|
|
const configFileName = toNormalizedPath(possibleDefaultRef.sourceFile.fileName);
|
|
const child = project.projectService.findConfiguredProjectByProjectName(configFileName);
|
|
if (child) {
|
|
const result = cb(child);
|
|
if (result)
|
|
return result;
|
|
} else if (projectReferenceProjectLoadKind !== 0 /* Find */) {
|
|
seenResolvedRefs = /* @__PURE__ */ new Map();
|
|
const result = forEachResolvedProjectReferenceProjectWorker(
|
|
resolvedRefs,
|
|
project.getCompilerOptions(),
|
|
(ref, loadKind) => possibleDefaultRef === ref ? callback(ref, loadKind) : void 0,
|
|
projectReferenceProjectLoadKind,
|
|
project.projectService,
|
|
seenResolvedRefs
|
|
);
|
|
if (result)
|
|
return result;
|
|
seenResolvedRefs.clear();
|
|
}
|
|
}
|
|
return forEachResolvedProjectReferenceProjectWorker(
|
|
resolvedRefs,
|
|
project.getCompilerOptions(),
|
|
(ref, loadKind) => possibleDefaultRef !== ref ? callback(ref, loadKind) : void 0,
|
|
projectReferenceProjectLoadKind,
|
|
project.projectService,
|
|
seenResolvedRefs
|
|
);
|
|
function callback(ref, loadKind) {
|
|
const configFileName = toNormalizedPath(ref.sourceFile.fileName);
|
|
const child = project.projectService.findConfiguredProjectByProjectName(configFileName) || (loadKind === 0 /* Find */ ? void 0 : loadKind === 1 /* FindCreate */ ? project.projectService.createConfiguredProject(configFileName) : loadKind === 2 /* FindCreateLoad */ ? project.projectService.createAndLoadConfiguredProject(configFileName, reason) : Debug.assertNever(loadKind));
|
|
return child && cb(child);
|
|
}
|
|
}
|
|
function forEachResolvedProjectReferenceProjectWorker(resolvedProjectReferences, parentOptions, cb, projectReferenceProjectLoadKind, projectService, seenResolvedRefs) {
|
|
const loadKind = parentOptions.disableReferencedProjectLoad ? 0 /* Find */ : projectReferenceProjectLoadKind;
|
|
return forEach(resolvedProjectReferences, (ref) => {
|
|
if (!ref)
|
|
return void 0;
|
|
const configFileName = toNormalizedPath(ref.sourceFile.fileName);
|
|
const canonicalPath = projectService.toCanonicalFileName(configFileName);
|
|
const seenValue = seenResolvedRefs == null ? void 0 : seenResolvedRefs.get(canonicalPath);
|
|
if (seenValue !== void 0 && seenValue >= loadKind) {
|
|
return void 0;
|
|
}
|
|
const result = cb(ref, loadKind);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
(seenResolvedRefs || (seenResolvedRefs = /* @__PURE__ */ new Map())).set(canonicalPath, loadKind);
|
|
return ref.references && forEachResolvedProjectReferenceProjectWorker(ref.references, ref.commandLine.options, cb, loadKind, projectService, seenResolvedRefs);
|
|
});
|
|
}
|
|
function forEachPotentialProjectReference(project, cb) {
|
|
return project.potentialProjectReferences && forEachKey(project.potentialProjectReferences, cb);
|
|
}
|
|
function forEachAnyProjectReferenceKind(project, cb, cbProjectRef, cbPotentialProjectRef) {
|
|
return project.getCurrentProgram() ? project.forEachResolvedProjectReference(cb) : project.isInitialLoadPending() ? forEachPotentialProjectReference(project, cbPotentialProjectRef) : forEach(project.getProjectReferences(), cbProjectRef);
|
|
}
|
|
function callbackRefProject(project, cb, refPath) {
|
|
const refProject = refPath && project.projectService.configuredProjects.get(refPath);
|
|
return refProject && cb(refProject);
|
|
}
|
|
function forEachReferencedProject(project, cb) {
|
|
return forEachAnyProjectReferenceKind(
|
|
project,
|
|
(resolvedRef) => callbackRefProject(project, cb, resolvedRef.sourceFile.path),
|
|
(projectRef) => callbackRefProject(project, cb, project.toPath(resolveProjectReferencePath(projectRef))),
|
|
(potentialProjectRef) => callbackRefProject(project, cb, potentialProjectRef)
|
|
);
|
|
}
|
|
function getDetailWatchInfo(watchType, project) {
|
|
return `${isString(project) ? `Config: ${project} ` : project ? `Project: ${project.getProjectName()} ` : ""}WatchType: ${watchType}`;
|
|
}
|
|
function isScriptInfoWatchedFromNodeModules(info) {
|
|
return !info.isScriptOpen() && info.mTime !== void 0;
|
|
}
|
|
function projectContainsInfoDirectly(project, info) {
|
|
return project.containsScriptInfo(info) && !project.isSourceOfProjectReferenceRedirect(info.path);
|
|
}
|
|
function updateProjectIfDirty(project) {
|
|
project.invalidateResolutionsOfFailedLookupLocations();
|
|
return project.dirty && project.updateGraph();
|
|
}
|
|
function setProjectOptionsUsed(project) {
|
|
if (isConfiguredProject(project)) {
|
|
project.projectOptions = true;
|
|
}
|
|
}
|
|
function createProjectNameFactoryWithCounter(nameFactory) {
|
|
let nextId = 1;
|
|
return () => nameFactory(nextId++);
|
|
}
|
|
var _ProjectService = class {
|
|
constructor(opts) {
|
|
this.filenameToScriptInfo = /* @__PURE__ */ new Map();
|
|
this.nodeModulesWatchers = /* @__PURE__ */ new Map();
|
|
this.filenameToScriptInfoVersion = /* @__PURE__ */ new Map();
|
|
this.allJsFilesForOpenFileTelemetry = /* @__PURE__ */ new Map();
|
|
this.externalProjectToConfiguredProjectMap = /* @__PURE__ */ new Map();
|
|
this.externalProjects = [];
|
|
this.inferredProjects = [];
|
|
this.configuredProjects = /* @__PURE__ */ new Map();
|
|
this.newInferredProjectName = createProjectNameFactoryWithCounter(makeInferredProjectName);
|
|
this.newAutoImportProviderProjectName = createProjectNameFactoryWithCounter(makeAutoImportProviderProjectName);
|
|
this.newAuxiliaryProjectName = createProjectNameFactoryWithCounter(makeAuxiliaryProjectName);
|
|
this.openFiles = /* @__PURE__ */ new Map();
|
|
this.configFileForOpenFiles = /* @__PURE__ */ new Map();
|
|
this.openFilesWithNonRootedDiskPath = /* @__PURE__ */ new Map();
|
|
this.compilerOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map();
|
|
this.watchOptionsForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map();
|
|
this.typeAcquisitionForInferredProjectsPerProjectRoot = /* @__PURE__ */ new Map();
|
|
this.projectToSizeMap = /* @__PURE__ */ new Map();
|
|
this.configFileExistenceInfoCache = /* @__PURE__ */ new Map();
|
|
this.safelist = defaultTypeSafeList;
|
|
this.legacySafelist = /* @__PURE__ */ new Map();
|
|
this.pendingProjectUpdates = /* @__PURE__ */ new Map();
|
|
this.pendingEnsureProjectForOpenFiles = false;
|
|
this.seenProjects = /* @__PURE__ */ new Map();
|
|
this.sharedExtendedConfigFileWatchers = /* @__PURE__ */ new Map();
|
|
this.extendedConfigCache = /* @__PURE__ */ new Map();
|
|
this.host = opts.host;
|
|
this.logger = opts.logger;
|
|
this.cancellationToken = opts.cancellationToken;
|
|
this.useSingleInferredProject = opts.useSingleInferredProject;
|
|
this.useInferredProjectPerProjectRoot = opts.useInferredProjectPerProjectRoot;
|
|
this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller;
|
|
this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds;
|
|
this.eventHandler = opts.eventHandler;
|
|
this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents;
|
|
this.globalPlugins = opts.globalPlugins || emptyArray2;
|
|
this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray2;
|
|
this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;
|
|
this.typesMapLocation = opts.typesMapLocation === void 0 ? combinePaths(getDirectoryPath(this.getExecutingFilePath()), "typesMap.json") : opts.typesMapLocation;
|
|
this.session = opts.session;
|
|
if (opts.serverMode !== void 0) {
|
|
this.serverMode = opts.serverMode;
|
|
this.syntaxOnly = this.serverMode === 2 /* Syntactic */;
|
|
} else if (opts.syntaxOnly) {
|
|
this.serverMode = 2 /* Syntactic */;
|
|
this.syntaxOnly = true;
|
|
} else {
|
|
this.serverMode = 0 /* Semantic */;
|
|
this.syntaxOnly = false;
|
|
}
|
|
if (this.host.realpath) {
|
|
this.realpathToScriptInfos = createMultiMap();
|
|
}
|
|
this.currentDirectory = toNormalizedPath(this.host.getCurrentDirectory());
|
|
this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);
|
|
this.globalCacheLocationDirectoryPath = this.typingsInstaller.globalTypingsCacheLocation ? ensureTrailingDirectorySeparator(this.toPath(this.typingsInstaller.globalTypingsCacheLocation)) : void 0;
|
|
this.throttledOperations = new ThrottledOperations(this.host, this.logger);
|
|
if (this.typesMapLocation) {
|
|
this.loadTypesMap();
|
|
} else {
|
|
this.logger.info("No types map provided; using the default");
|
|
}
|
|
this.typingsInstaller.attach(this);
|
|
this.typingsCache = new TypingsCache(this.typingsInstaller);
|
|
this.hostConfiguration = {
|
|
formatCodeOptions: getDefaultFormatCodeSettings(this.host.newLine),
|
|
preferences: emptyOptions,
|
|
hostInfo: "Unknown host",
|
|
extraFileExtensions: []
|
|
};
|
|
this.documentRegistry = createDocumentRegistryInternal(this.host.useCaseSensitiveFileNames, this.currentDirectory, this);
|
|
const watchLogLevel = this.logger.hasLevel(3 /* verbose */) ? 2 /* Verbose */ : this.logger.loggingEnabled() ? 1 /* TriggerOnly */ : 0 /* None */;
|
|
const log = watchLogLevel !== 0 /* None */ ? (s) => this.logger.info(s) : noop;
|
|
this.packageJsonCache = createPackageJsonCache(this);
|
|
this.watchFactory = this.serverMode !== 0 /* Semantic */ ? {
|
|
watchFile: returnNoopFileWatcher,
|
|
watchDirectory: returnNoopFileWatcher
|
|
} : getWatchFactory(this.host, watchLogLevel, log, getDetailWatchInfo);
|
|
}
|
|
toPath(fileName) {
|
|
return toPath(fileName, this.currentDirectory, this.toCanonicalFileName);
|
|
}
|
|
getExecutingFilePath() {
|
|
return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath());
|
|
}
|
|
getNormalizedAbsolutePath(fileName) {
|
|
return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());
|
|
}
|
|
setDocument(key, path, sourceFile) {
|
|
const info = Debug.checkDefined(this.getScriptInfoForPath(path));
|
|
info.cacheSourceFile = { key, sourceFile };
|
|
}
|
|
getDocument(key, path) {
|
|
const info = this.getScriptInfoForPath(path);
|
|
return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : void 0;
|
|
}
|
|
ensureInferredProjectsUpToDate_TestOnly() {
|
|
this.ensureProjectStructuresUptoDate();
|
|
}
|
|
getCompilerOptionsForInferredProjects() {
|
|
return this.compilerOptionsForInferredProjects;
|
|
}
|
|
onUpdateLanguageServiceStateForProject(project, languageServiceEnabled) {
|
|
if (!this.eventHandler) {
|
|
return;
|
|
}
|
|
const event = {
|
|
eventName: ProjectLanguageServiceStateEvent,
|
|
data: { project, languageServiceEnabled }
|
|
};
|
|
this.eventHandler(event);
|
|
}
|
|
loadTypesMap() {
|
|
try {
|
|
const fileContent = this.host.readFile(this.typesMapLocation);
|
|
if (fileContent === void 0) {
|
|
this.logger.info(`Provided types map file "${this.typesMapLocation}" doesn't exist`);
|
|
return;
|
|
}
|
|
const raw = JSON.parse(fileContent);
|
|
for (const k of Object.keys(raw.typesMap)) {
|
|
raw.typesMap[k].match = new RegExp(raw.typesMap[k].match, "i");
|
|
}
|
|
this.safelist = raw.typesMap;
|
|
for (const key in raw.simpleMap) {
|
|
if (hasProperty(raw.simpleMap, key)) {
|
|
this.legacySafelist.set(key, raw.simpleMap[key].toLowerCase());
|
|
}
|
|
}
|
|
} catch (e) {
|
|
this.logger.info(`Error loading types map: ${e}`);
|
|
this.safelist = defaultTypeSafeList;
|
|
this.legacySafelist.clear();
|
|
}
|
|
}
|
|
updateTypingsForProject(response) {
|
|
const project = this.findProject(response.projectName);
|
|
if (!project) {
|
|
return;
|
|
}
|
|
switch (response.kind) {
|
|
case ActionSet:
|
|
project.updateTypingFiles(this.typingsCache.updateTypingsForProject(response.projectName, response.compilerOptions, response.typeAcquisition, response.unresolvedImports, response.typings));
|
|
return;
|
|
case ActionInvalidate:
|
|
this.typingsCache.enqueueInstallTypingsForProject(project, project.lastCachedUnresolvedImportsList, true);
|
|
return;
|
|
}
|
|
}
|
|
delayEnsureProjectForOpenFiles() {
|
|
if (!this.openFiles.size)
|
|
return;
|
|
this.pendingEnsureProjectForOpenFiles = true;
|
|
this.throttledOperations.schedule(ensureProjectForOpenFileSchedule, 2500, () => {
|
|
if (this.pendingProjectUpdates.size !== 0) {
|
|
this.delayEnsureProjectForOpenFiles();
|
|
} else {
|
|
if (this.pendingEnsureProjectForOpenFiles) {
|
|
this.ensureProjectForOpenFiles();
|
|
this.sendProjectsUpdatedInBackgroundEvent();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
delayUpdateProjectGraph(project) {
|
|
project.markAsDirty();
|
|
if (project.projectKind !== 3 /* AutoImportProvider */ && project.projectKind !== 4 /* Auxiliary */) {
|
|
const projectName = project.getProjectName();
|
|
this.pendingProjectUpdates.set(projectName, project);
|
|
this.throttledOperations.schedule(projectName, 250, () => {
|
|
if (this.pendingProjectUpdates.delete(projectName)) {
|
|
updateProjectIfDirty(project);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
hasPendingProjectUpdate(project) {
|
|
return this.pendingProjectUpdates.has(project.getProjectName());
|
|
}
|
|
sendProjectsUpdatedInBackgroundEvent() {
|
|
if (!this.eventHandler) {
|
|
return;
|
|
}
|
|
const event = {
|
|
eventName: ProjectsUpdatedInBackgroundEvent,
|
|
data: {
|
|
openFiles: arrayFrom(this.openFiles.keys(), (path) => this.getScriptInfoForPath(path).fileName)
|
|
}
|
|
};
|
|
this.eventHandler(event);
|
|
}
|
|
sendLargeFileReferencedEvent(file, fileSize) {
|
|
if (!this.eventHandler) {
|
|
return;
|
|
}
|
|
const event = {
|
|
eventName: LargeFileReferencedEvent,
|
|
data: { file, fileSize, maxFileSize }
|
|
};
|
|
this.eventHandler(event);
|
|
}
|
|
sendProjectLoadingStartEvent(project, reason) {
|
|
if (!this.eventHandler) {
|
|
return;
|
|
}
|
|
project.sendLoadingProjectFinish = true;
|
|
const event = {
|
|
eventName: ProjectLoadingStartEvent,
|
|
data: { project, reason }
|
|
};
|
|
this.eventHandler(event);
|
|
}
|
|
sendProjectLoadingFinishEvent(project) {
|
|
if (!this.eventHandler || !project.sendLoadingProjectFinish) {
|
|
return;
|
|
}
|
|
project.sendLoadingProjectFinish = false;
|
|
const event = {
|
|
eventName: ProjectLoadingFinishEvent,
|
|
data: { project }
|
|
};
|
|
this.eventHandler(event);
|
|
}
|
|
sendPerformanceEvent(kind, durationMs) {
|
|
if (this.performanceEventHandler) {
|
|
this.performanceEventHandler({ kind, durationMs });
|
|
}
|
|
}
|
|
delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project) {
|
|
this.delayUpdateProjectGraph(project);
|
|
this.delayEnsureProjectForOpenFiles();
|
|
}
|
|
delayUpdateProjectGraphs(projects, clearSourceMapperCache) {
|
|
if (projects.length) {
|
|
for (const project of projects) {
|
|
if (clearSourceMapperCache)
|
|
project.clearSourceMapperCache();
|
|
this.delayUpdateProjectGraph(project);
|
|
}
|
|
this.delayEnsureProjectForOpenFiles();
|
|
}
|
|
}
|
|
setCompilerOptionsForInferredProjects(projectCompilerOptions, projectRootPath) {
|
|
Debug.assert(projectRootPath === void 0 || this.useInferredProjectPerProjectRoot, "Setting compiler options per project root path is only supported when useInferredProjectPerProjectRoot is enabled");
|
|
const compilerOptions = convertCompilerOptions(projectCompilerOptions);
|
|
const watchOptions = convertWatchOptions(projectCompilerOptions, projectRootPath);
|
|
const typeAcquisition = convertTypeAcquisition(projectCompilerOptions);
|
|
compilerOptions.allowNonTsExtensions = true;
|
|
const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath);
|
|
if (canonicalProjectRootPath) {
|
|
this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions);
|
|
this.watchOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, watchOptions || false);
|
|
this.typeAcquisitionForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, typeAcquisition);
|
|
} else {
|
|
this.compilerOptionsForInferredProjects = compilerOptions;
|
|
this.watchOptionsForInferredProjects = watchOptions;
|
|
this.typeAcquisitionForInferredProjects = typeAcquisition;
|
|
}
|
|
for (const project of this.inferredProjects) {
|
|
if (canonicalProjectRootPath ? project.projectRootPath === canonicalProjectRootPath : !project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) {
|
|
project.setCompilerOptions(compilerOptions);
|
|
project.setTypeAcquisition(typeAcquisition);
|
|
project.setWatchOptions(watchOptions == null ? void 0 : watchOptions.watchOptions);
|
|
project.setProjectErrors(watchOptions == null ? void 0 : watchOptions.errors);
|
|
project.compileOnSaveEnabled = compilerOptions.compileOnSave;
|
|
project.markAsDirty();
|
|
this.delayUpdateProjectGraph(project);
|
|
}
|
|
}
|
|
this.delayEnsureProjectForOpenFiles();
|
|
}
|
|
findProject(projectName) {
|
|
if (projectName === void 0) {
|
|
return void 0;
|
|
}
|
|
if (isInferredProjectName(projectName)) {
|
|
return findProjectByName(projectName, this.inferredProjects);
|
|
}
|
|
return this.findExternalProjectByProjectName(projectName) || this.findConfiguredProjectByProjectName(toNormalizedPath(projectName));
|
|
}
|
|
forEachProject(cb) {
|
|
this.externalProjects.forEach(cb);
|
|
this.configuredProjects.forEach(cb);
|
|
this.inferredProjects.forEach(cb);
|
|
}
|
|
forEachEnabledProject(cb) {
|
|
this.forEachProject((project) => {
|
|
if (!project.isOrphan() && project.languageServiceEnabled) {
|
|
cb(project);
|
|
}
|
|
});
|
|
}
|
|
getDefaultProjectForFile(fileName, ensureProject) {
|
|
return ensureProject ? this.ensureDefaultProjectForFile(fileName) : this.tryGetDefaultProjectForFile(fileName);
|
|
}
|
|
tryGetDefaultProjectForFile(fileNameOrScriptInfo) {
|
|
const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
|
|
return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : void 0;
|
|
}
|
|
ensureDefaultProjectForFile(fileNameOrScriptInfo) {
|
|
return this.tryGetDefaultProjectForFile(fileNameOrScriptInfo) || this.doEnsureDefaultProjectForFile(fileNameOrScriptInfo);
|
|
}
|
|
doEnsureDefaultProjectForFile(fileNameOrScriptInfo) {
|
|
this.ensureProjectStructuresUptoDate();
|
|
const scriptInfo = isString(fileNameOrScriptInfo) ? this.getScriptInfoForNormalizedPath(fileNameOrScriptInfo) : fileNameOrScriptInfo;
|
|
return scriptInfo ? scriptInfo.getDefaultProject() : (this.logErrorForScriptInfoNotFound(isString(fileNameOrScriptInfo) ? fileNameOrScriptInfo : fileNameOrScriptInfo.fileName), Errors.ThrowNoProject());
|
|
}
|
|
getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName) {
|
|
this.ensureProjectStructuresUptoDate();
|
|
return this.getScriptInfo(uncheckedFileName);
|
|
}
|
|
ensureProjectStructuresUptoDate() {
|
|
let hasChanges = this.pendingEnsureProjectForOpenFiles;
|
|
this.pendingProjectUpdates.clear();
|
|
const updateGraph = (project) => {
|
|
hasChanges = updateProjectIfDirty(project) || hasChanges;
|
|
};
|
|
this.externalProjects.forEach(updateGraph);
|
|
this.configuredProjects.forEach(updateGraph);
|
|
this.inferredProjects.forEach(updateGraph);
|
|
if (hasChanges) {
|
|
this.ensureProjectForOpenFiles();
|
|
}
|
|
}
|
|
getFormatCodeOptions(file) {
|
|
const info = this.getScriptInfoForNormalizedPath(file);
|
|
return info && info.getFormatCodeSettings() || this.hostConfiguration.formatCodeOptions;
|
|
}
|
|
getPreferences(file) {
|
|
const info = this.getScriptInfoForNormalizedPath(file);
|
|
return { ...this.hostConfiguration.preferences, ...info && info.getPreferences() };
|
|
}
|
|
getHostFormatCodeOptions() {
|
|
return this.hostConfiguration.formatCodeOptions;
|
|
}
|
|
getHostPreferences() {
|
|
return this.hostConfiguration.preferences;
|
|
}
|
|
onSourceFileChanged(info, eventKind) {
|
|
if (eventKind === 2 /* Deleted */) {
|
|
this.handleDeletedFile(info);
|
|
} else if (!info.isScriptOpen()) {
|
|
info.delayReloadNonMixedContentFile();
|
|
this.delayUpdateProjectGraphs(info.containingProjects, false);
|
|
this.handleSourceMapProjects(info);
|
|
}
|
|
}
|
|
handleSourceMapProjects(info) {
|
|
if (info.sourceMapFilePath) {
|
|
if (isString(info.sourceMapFilePath)) {
|
|
const sourceMapFileInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
|
|
this.delayUpdateSourceInfoProjects(sourceMapFileInfo && sourceMapFileInfo.sourceInfos);
|
|
} else {
|
|
this.delayUpdateSourceInfoProjects(info.sourceMapFilePath.sourceInfos);
|
|
}
|
|
}
|
|
this.delayUpdateSourceInfoProjects(info.sourceInfos);
|
|
if (info.declarationInfoPath) {
|
|
this.delayUpdateProjectsOfScriptInfoPath(info.declarationInfoPath);
|
|
}
|
|
}
|
|
delayUpdateSourceInfoProjects(sourceInfos) {
|
|
if (sourceInfos) {
|
|
sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path));
|
|
}
|
|
}
|
|
delayUpdateProjectsOfScriptInfoPath(path) {
|
|
const info = this.getScriptInfoForPath(path);
|
|
if (info) {
|
|
this.delayUpdateProjectGraphs(info.containingProjects, true);
|
|
}
|
|
}
|
|
handleDeletedFile(info) {
|
|
this.stopWatchingScriptInfo(info);
|
|
if (!info.isScriptOpen()) {
|
|
this.deleteScriptInfo(info);
|
|
const containingProjects = info.containingProjects.slice();
|
|
info.detachAllProjects();
|
|
this.delayUpdateProjectGraphs(containingProjects, false);
|
|
this.handleSourceMapProjects(info);
|
|
info.closeSourceMapFileWatcher();
|
|
if (info.declarationInfoPath) {
|
|
const declarationInfo = this.getScriptInfoForPath(info.declarationInfoPath);
|
|
if (declarationInfo) {
|
|
declarationInfo.sourceMapFilePath = void 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
watchWildcardDirectory(directory, flags, configFileName, config) {
|
|
return this.watchFactory.watchDirectory(
|
|
directory,
|
|
(fileOrDirectory) => {
|
|
const fileOrDirectoryPath = this.toPath(fileOrDirectory);
|
|
const fsResult = config.cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath);
|
|
if (getBaseFileName(fileOrDirectoryPath) === "package.json" && !isInsideNodeModules(fileOrDirectoryPath) && (fsResult && fsResult.fileExists || !fsResult && this.host.fileExists(fileOrDirectoryPath))) {
|
|
this.logger.info(`Config: ${configFileName} Detected new package.json: ${fileOrDirectory}`);
|
|
this.onAddPackageJson(fileOrDirectoryPath);
|
|
}
|
|
const configuredProjectForConfig = this.findConfiguredProjectByProjectName(configFileName);
|
|
if (isIgnoredFileFromWildCardWatching({
|
|
watchedDirPath: directory,
|
|
fileOrDirectory,
|
|
fileOrDirectoryPath,
|
|
configFileName,
|
|
extraFileExtensions: this.hostConfiguration.extraFileExtensions,
|
|
currentDirectory: this.currentDirectory,
|
|
options: config.parsedCommandLine.options,
|
|
program: (configuredProjectForConfig == null ? void 0 : configuredProjectForConfig.getCurrentProgram()) || config.parsedCommandLine.fileNames,
|
|
useCaseSensitiveFileNames: this.host.useCaseSensitiveFileNames,
|
|
writeLog: (s) => this.logger.info(s),
|
|
toPath: (s) => this.toPath(s)
|
|
}))
|
|
return;
|
|
if (config.reloadLevel !== 2 /* Full */)
|
|
config.reloadLevel = 1 /* Partial */;
|
|
config.projects.forEach((watchWildcardDirectories, projectCanonicalPath) => {
|
|
if (!watchWildcardDirectories)
|
|
return;
|
|
const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
|
|
if (!project)
|
|
return;
|
|
const reloadLevel = configuredProjectForConfig === project ? 1 /* Partial */ : 0 /* None */;
|
|
if (project.pendingReload !== void 0 && project.pendingReload > reloadLevel)
|
|
return;
|
|
if (this.openFiles.has(fileOrDirectoryPath)) {
|
|
const info = Debug.checkDefined(this.getScriptInfoForPath(fileOrDirectoryPath));
|
|
if (info.isAttached(project)) {
|
|
const loadLevelToSet = Math.max(reloadLevel, project.openFileWatchTriggered.get(fileOrDirectoryPath) || 0 /* None */);
|
|
project.openFileWatchTriggered.set(fileOrDirectoryPath, loadLevelToSet);
|
|
} else {
|
|
project.pendingReload = reloadLevel;
|
|
this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project);
|
|
}
|
|
} else {
|
|
project.pendingReload = reloadLevel;
|
|
this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project);
|
|
}
|
|
});
|
|
},
|
|
flags,
|
|
this.getWatchOptionsFromProjectWatchOptions(config.parsedCommandLine.watchOptions),
|
|
WatchType.WildcardDirectory,
|
|
configFileName
|
|
);
|
|
}
|
|
delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, reloadReason) {
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!(configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config))
|
|
return false;
|
|
let scheduledAnyProjectUpdate = false;
|
|
configFileExistenceInfo.config.reloadLevel = 2 /* Full */;
|
|
configFileExistenceInfo.config.projects.forEach((_watchWildcardDirectories, projectCanonicalPath) => {
|
|
const project = this.getConfiguredProjectByCanonicalConfigFilePath(projectCanonicalPath);
|
|
if (!project)
|
|
return;
|
|
scheduledAnyProjectUpdate = true;
|
|
if (projectCanonicalPath === canonicalConfigFilePath) {
|
|
if (project.isInitialLoadPending())
|
|
return;
|
|
project.pendingReload = 2 /* Full */;
|
|
project.pendingReloadReason = reloadReason;
|
|
this.delayUpdateProjectGraph(project);
|
|
} else {
|
|
project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(this.toPath(canonicalConfigFilePath));
|
|
this.delayUpdateProjectGraph(project);
|
|
}
|
|
});
|
|
return scheduledAnyProjectUpdate;
|
|
}
|
|
onConfigFileChanged(canonicalConfigFilePath, eventKind) {
|
|
var _a2;
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (eventKind === 2 /* Deleted */) {
|
|
configFileExistenceInfo.exists = false;
|
|
const project = ((_a2 = configFileExistenceInfo.config) == null ? void 0 : _a2.projects.has(canonicalConfigFilePath)) ? this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) : void 0;
|
|
if (project)
|
|
this.removeProject(project);
|
|
} else {
|
|
configFileExistenceInfo.exists = true;
|
|
}
|
|
this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalConfigFilePath, "Change in config file detected");
|
|
this.reloadConfiguredProjectForFiles(
|
|
configFileExistenceInfo.openFilesImpactedByConfigFile,
|
|
false,
|
|
true,
|
|
eventKind !== 2 /* Deleted */ ? identity : returnTrue,
|
|
"Change in config file detected"
|
|
);
|
|
this.delayEnsureProjectForOpenFiles();
|
|
}
|
|
removeProject(project) {
|
|
this.logger.info("`remove Project::");
|
|
project.print(true);
|
|
project.close();
|
|
if (Debug.shouldAssert(1 /* Normal */)) {
|
|
this.filenameToScriptInfo.forEach((info) => Debug.assert(
|
|
!info.isAttached(project),
|
|
"Found script Info still attached to project",
|
|
() => `${project.projectName}: ScriptInfos still attached: ${JSON.stringify(
|
|
arrayFrom(
|
|
mapDefinedIterator(
|
|
this.filenameToScriptInfo.values(),
|
|
(info2) => info2.isAttached(project) ? {
|
|
fileName: info2.fileName,
|
|
projects: info2.containingProjects.map((p) => p.projectName),
|
|
hasMixedContent: info2.hasMixedContent
|
|
} : void 0
|
|
)
|
|
),
|
|
void 0,
|
|
" "
|
|
)}`
|
|
));
|
|
}
|
|
this.pendingProjectUpdates.delete(project.getProjectName());
|
|
switch (project.projectKind) {
|
|
case 2 /* External */:
|
|
unorderedRemoveItem(this.externalProjects, project);
|
|
this.projectToSizeMap.delete(project.getProjectName());
|
|
break;
|
|
case 1 /* Configured */:
|
|
this.configuredProjects.delete(project.canonicalConfigFilePath);
|
|
this.projectToSizeMap.delete(project.canonicalConfigFilePath);
|
|
break;
|
|
case 0 /* Inferred */:
|
|
unorderedRemoveItem(this.inferredProjects, project);
|
|
break;
|
|
}
|
|
}
|
|
assignOrphanScriptInfoToInferredProject(info, projectRootPath) {
|
|
Debug.assert(info.isOrphan());
|
|
const project = this.getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) || this.getOrCreateSingleInferredProjectIfEnabled() || this.getOrCreateSingleInferredWithoutProjectRoot(
|
|
info.isDynamic ? projectRootPath || this.currentDirectory : getDirectoryPath(
|
|
isRootedDiskPath(info.fileName) ? info.fileName : getNormalizedAbsolutePath(
|
|
info.fileName,
|
|
projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory
|
|
)
|
|
)
|
|
);
|
|
project.addRoot(info);
|
|
if (info.containingProjects[0] !== project) {
|
|
info.detachFromProject(project);
|
|
info.containingProjects.unshift(project);
|
|
}
|
|
project.updateGraph();
|
|
if (!this.useSingleInferredProject && !project.projectRootPath) {
|
|
for (const inferredProject of this.inferredProjects) {
|
|
if (inferredProject === project || inferredProject.isOrphan()) {
|
|
continue;
|
|
}
|
|
const roots = inferredProject.getRootScriptInfos();
|
|
Debug.assert(roots.length === 1 || !!inferredProject.projectRootPath);
|
|
if (roots.length === 1 && forEach(roots[0].containingProjects, (p) => p !== roots[0].containingProjects[0] && !p.isOrphan())) {
|
|
inferredProject.removeFile(roots[0], true, true);
|
|
}
|
|
}
|
|
}
|
|
return project;
|
|
}
|
|
assignOrphanScriptInfosToInferredProject() {
|
|
this.openFiles.forEach((projectRootPath, path) => {
|
|
const info = this.getScriptInfoForPath(path);
|
|
if (info.isOrphan()) {
|
|
this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
|
|
}
|
|
});
|
|
}
|
|
closeOpenFile(info, skipAssignOrphanScriptInfosToInferredProject) {
|
|
const fileExists = info.isDynamic ? false : this.host.fileExists(info.fileName);
|
|
info.close(fileExists);
|
|
this.stopWatchingConfigFilesForClosedScriptInfo(info);
|
|
const canonicalFileName = this.toCanonicalFileName(info.fileName);
|
|
if (this.openFilesWithNonRootedDiskPath.get(canonicalFileName) === info) {
|
|
this.openFilesWithNonRootedDiskPath.delete(canonicalFileName);
|
|
}
|
|
let ensureProjectsForOpenFiles = false;
|
|
for (const p of info.containingProjects) {
|
|
if (isConfiguredProject(p)) {
|
|
if (info.hasMixedContent) {
|
|
info.registerFileUpdate();
|
|
}
|
|
const reloadLevel = p.openFileWatchTriggered.get(info.path);
|
|
if (reloadLevel !== void 0) {
|
|
p.openFileWatchTriggered.delete(info.path);
|
|
if (p.pendingReload !== void 0 && p.pendingReload < reloadLevel) {
|
|
p.pendingReload = reloadLevel;
|
|
p.markFileAsDirty(info.path);
|
|
}
|
|
}
|
|
} else if (isInferredProject(p) && p.isRoot(info)) {
|
|
if (p.isProjectWithSingleRoot()) {
|
|
ensureProjectsForOpenFiles = true;
|
|
}
|
|
p.removeFile(info, fileExists, true);
|
|
}
|
|
if (!p.languageServiceEnabled) {
|
|
p.markAsDirty();
|
|
}
|
|
}
|
|
this.openFiles.delete(info.path);
|
|
this.configFileForOpenFiles.delete(info.path);
|
|
if (!skipAssignOrphanScriptInfosToInferredProject && ensureProjectsForOpenFiles) {
|
|
this.assignOrphanScriptInfosToInferredProject();
|
|
}
|
|
if (fileExists) {
|
|
this.watchClosedScriptInfo(info);
|
|
} else {
|
|
this.handleDeletedFile(info);
|
|
}
|
|
return ensureProjectsForOpenFiles;
|
|
}
|
|
deleteScriptInfo(info) {
|
|
this.filenameToScriptInfo.delete(info.path);
|
|
this.filenameToScriptInfoVersion.set(info.path, info.getVersion());
|
|
const realpath = info.getRealpathIfDifferent();
|
|
if (realpath) {
|
|
this.realpathToScriptInfos.remove(realpath, info);
|
|
}
|
|
}
|
|
configFileExists(configFileName, canonicalConfigFilePath, info) {
|
|
var _a2;
|
|
let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (configFileExistenceInfo) {
|
|
if (isOpenScriptInfo(info) && !((_a2 = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a2.has(info.path))) {
|
|
(configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, false);
|
|
}
|
|
return configFileExistenceInfo.exists;
|
|
}
|
|
const exists = this.host.fileExists(configFileName);
|
|
let openFilesImpactedByConfigFile;
|
|
if (isOpenScriptInfo(info)) {
|
|
(openFilesImpactedByConfigFile || (openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, false);
|
|
}
|
|
configFileExistenceInfo = { exists, openFilesImpactedByConfigFile };
|
|
this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
|
|
return exists;
|
|
}
|
|
createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, forProject) {
|
|
var _a2, _b;
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!configFileExistenceInfo.watcher || configFileExistenceInfo.watcher === noopConfigFileWatcher) {
|
|
configFileExistenceInfo.watcher = this.watchFactory.watchFile(
|
|
configFileName,
|
|
(_fileName, eventKind) => this.onConfigFileChanged(canonicalConfigFilePath, eventKind),
|
|
2e3 /* High */,
|
|
this.getWatchOptionsFromProjectWatchOptions((_b = (_a2 = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.config) == null ? void 0 : _a2.parsedCommandLine) == null ? void 0 : _b.watchOptions),
|
|
WatchType.ConfigFile,
|
|
forProject
|
|
);
|
|
}
|
|
const projects = configFileExistenceInfo.config.projects;
|
|
projects.set(forProject.canonicalConfigFilePath, projects.get(forProject.canonicalConfigFilePath) || false);
|
|
}
|
|
configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo) {
|
|
return configFileExistenceInfo.openFilesImpactedByConfigFile && forEachEntry(configFileExistenceInfo.openFilesImpactedByConfigFile, identity);
|
|
}
|
|
releaseParsedConfig(canonicalConfigFilePath, forProject) {
|
|
var _a2, _b, _c;
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!((_a2 = configFileExistenceInfo.config) == null ? void 0 : _a2.projects.delete(forProject.canonicalConfigFilePath)))
|
|
return;
|
|
if ((_b = configFileExistenceInfo.config) == null ? void 0 : _b.projects.size)
|
|
return;
|
|
configFileExistenceInfo.config = void 0;
|
|
clearSharedExtendedConfigFileWatcher(canonicalConfigFilePath, this.sharedExtendedConfigFileWatchers);
|
|
Debug.checkDefined(configFileExistenceInfo.watcher);
|
|
if ((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) {
|
|
if (this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
|
|
if (!canWatchDirectoryOrFile(getDirectoryPath(canonicalConfigFilePath))) {
|
|
configFileExistenceInfo.watcher.close();
|
|
configFileExistenceInfo.watcher = noopConfigFileWatcher;
|
|
}
|
|
} else {
|
|
configFileExistenceInfo.watcher.close();
|
|
configFileExistenceInfo.watcher = void 0;
|
|
}
|
|
} else {
|
|
configFileExistenceInfo.watcher.close();
|
|
this.configFileExistenceInfoCache.delete(canonicalConfigFilePath);
|
|
}
|
|
}
|
|
closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo) {
|
|
if (configFileExistenceInfo.watcher && !configFileExistenceInfo.config && !this.configFileExistenceImpactsRootOfInferredProject(configFileExistenceInfo)) {
|
|
configFileExistenceInfo.watcher.close();
|
|
configFileExistenceInfo.watcher = void 0;
|
|
}
|
|
}
|
|
stopWatchingConfigFilesForClosedScriptInfo(info) {
|
|
Debug.assert(!info.isScriptOpen());
|
|
this.forEachConfigFileLocation(info, (canonicalConfigFilePath) => {
|
|
var _a2, _b, _c;
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (configFileExistenceInfo) {
|
|
const infoIsRootOfInferredProject = (_a2 = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a2.get(info.path);
|
|
(_b = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _b.delete(info.path);
|
|
if (infoIsRootOfInferredProject) {
|
|
this.closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo);
|
|
}
|
|
if (!((_c = configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _c.size) && !configFileExistenceInfo.config) {
|
|
Debug.assert(!configFileExistenceInfo.watcher);
|
|
this.configFileExistenceInfoCache.delete(canonicalConfigFilePath);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
startWatchingConfigFilesForInferredProjectRoot(info) {
|
|
Debug.assert(info.isScriptOpen());
|
|
this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName) => {
|
|
let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!configFileExistenceInfo) {
|
|
configFileExistenceInfo = { exists: this.host.fileExists(configFileName) };
|
|
this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
|
|
}
|
|
(configFileExistenceInfo.openFilesImpactedByConfigFile || (configFileExistenceInfo.openFilesImpactedByConfigFile = /* @__PURE__ */ new Map())).set(info.path, true);
|
|
configFileExistenceInfo.watcher || (configFileExistenceInfo.watcher = canWatchDirectoryOrFile(getDirectoryPath(canonicalConfigFilePath)) ? this.watchFactory.watchFile(
|
|
configFileName,
|
|
(_filename, eventKind) => this.onConfigFileChanged(canonicalConfigFilePath, eventKind),
|
|
2e3 /* High */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.ConfigFileForInferredRoot
|
|
) : noopConfigFileWatcher);
|
|
});
|
|
}
|
|
stopWatchingConfigFilesForInferredProjectRoot(info) {
|
|
this.forEachConfigFileLocation(info, (canonicalConfigFilePath) => {
|
|
var _a2;
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if ((_a2 = configFileExistenceInfo == null ? void 0 : configFileExistenceInfo.openFilesImpactedByConfigFile) == null ? void 0 : _a2.has(info.path)) {
|
|
Debug.assert(info.isScriptOpen());
|
|
configFileExistenceInfo.openFilesImpactedByConfigFile.set(info.path, false);
|
|
this.closeConfigFileWatcherOnReleaseOfOpenFile(configFileExistenceInfo);
|
|
}
|
|
});
|
|
}
|
|
forEachConfigFileLocation(info, action) {
|
|
if (this.serverMode !== 0 /* Semantic */) {
|
|
return void 0;
|
|
}
|
|
Debug.assert(!isOpenScriptInfo(info) || this.openFiles.has(info.path));
|
|
const projectRootPath = this.openFiles.get(info.path);
|
|
const scriptInfo = Debug.checkDefined(this.getScriptInfo(info.path));
|
|
if (scriptInfo.isDynamic)
|
|
return void 0;
|
|
let searchPath = asNormalizedPath(getDirectoryPath(info.fileName));
|
|
const isSearchPathInProjectRoot = () => containsPath(projectRootPath, searchPath, this.currentDirectory, !this.host.useCaseSensitiveFileNames);
|
|
const anySearchPathOk = !projectRootPath || !isSearchPathInProjectRoot();
|
|
let searchInDirectory = !isAncestorConfigFileInfo(info);
|
|
do {
|
|
if (searchInDirectory) {
|
|
const canonicalSearchPath = normalizedPathToPath(searchPath, this.currentDirectory, this.toCanonicalFileName);
|
|
const tsconfigFileName = asNormalizedPath(combinePaths(searchPath, "tsconfig.json"));
|
|
let result = action(combinePaths(canonicalSearchPath, "tsconfig.json"), tsconfigFileName);
|
|
if (result)
|
|
return tsconfigFileName;
|
|
const jsconfigFileName = asNormalizedPath(combinePaths(searchPath, "jsconfig.json"));
|
|
result = action(combinePaths(canonicalSearchPath, "jsconfig.json"), jsconfigFileName);
|
|
if (result)
|
|
return jsconfigFileName;
|
|
if (isNodeModulesDirectory(canonicalSearchPath)) {
|
|
break;
|
|
}
|
|
}
|
|
const parentPath = asNormalizedPath(getDirectoryPath(searchPath));
|
|
if (parentPath === searchPath)
|
|
break;
|
|
searchPath = parentPath;
|
|
searchInDirectory = true;
|
|
} while (anySearchPathOk || isSearchPathInProjectRoot());
|
|
return void 0;
|
|
}
|
|
findDefaultConfiguredProject(info) {
|
|
if (!info.isScriptOpen())
|
|
return void 0;
|
|
const configFileName = this.getConfigFileNameForFile(info);
|
|
const project = configFileName && this.findConfiguredProjectByProjectName(configFileName);
|
|
return project && projectContainsInfoDirectly(project, info) ? project : project == null ? void 0 : project.getDefaultChildProjectFromProjectWithReferences(info);
|
|
}
|
|
getConfigFileNameForFile(info) {
|
|
if (isOpenScriptInfo(info)) {
|
|
Debug.assert(info.isScriptOpen());
|
|
const result = this.configFileForOpenFiles.get(info.path);
|
|
if (result !== void 0)
|
|
return result || void 0;
|
|
}
|
|
this.logger.info(`Search path: ${getDirectoryPath(info.fileName)}`);
|
|
const configFileName = this.forEachConfigFileLocation(info, (canonicalConfigFilePath, configFileName2) => this.configFileExists(configFileName2, canonicalConfigFilePath, info));
|
|
if (configFileName) {
|
|
this.logger.info(`For info: ${info.fileName} :: Config file name: ${configFileName}`);
|
|
} else {
|
|
this.logger.info(`For info: ${info.fileName} :: No config files found.`);
|
|
}
|
|
if (isOpenScriptInfo(info)) {
|
|
this.configFileForOpenFiles.set(info.path, configFileName || false);
|
|
}
|
|
return configFileName;
|
|
}
|
|
printProjects() {
|
|
if (!this.logger.hasLevel(1 /* normal */)) {
|
|
return;
|
|
}
|
|
this.logger.startGroup();
|
|
this.externalProjects.forEach(printProjectWithoutFileNames);
|
|
this.configuredProjects.forEach(printProjectWithoutFileNames);
|
|
this.inferredProjects.forEach(printProjectWithoutFileNames);
|
|
this.logger.info("Open files: ");
|
|
this.openFiles.forEach((projectRootPath, path) => {
|
|
const info = this.getScriptInfoForPath(path);
|
|
this.logger.info(` FileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
|
|
this.logger.info(` Projects: ${info.containingProjects.map((p) => p.getProjectName())}`);
|
|
});
|
|
this.logger.endGroup();
|
|
}
|
|
findConfiguredProjectByProjectName(configFileName) {
|
|
const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName));
|
|
return this.getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath);
|
|
}
|
|
getConfiguredProjectByCanonicalConfigFilePath(canonicalConfigFilePath) {
|
|
return this.configuredProjects.get(canonicalConfigFilePath);
|
|
}
|
|
findExternalProjectByProjectName(projectFileName) {
|
|
return findProjectByName(projectFileName, this.externalProjects);
|
|
}
|
|
getFilenameForExceededTotalSizeLimitForNonTsFiles(name, options, fileNames, propertyReader) {
|
|
if (options && options.disableSizeLimit || !this.host.getFileSize) {
|
|
return;
|
|
}
|
|
let availableSpace = maxProgramSizeForNonTsFiles;
|
|
this.projectToSizeMap.set(name, 0);
|
|
this.projectToSizeMap.forEach((val) => availableSpace -= val || 0);
|
|
let totalNonTsFileSize = 0;
|
|
for (const f of fileNames) {
|
|
const fileName = propertyReader.getFileName(f);
|
|
if (hasTSFileExtension(fileName)) {
|
|
continue;
|
|
}
|
|
totalNonTsFileSize += this.host.getFileSize(fileName);
|
|
if (totalNonTsFileSize > maxProgramSizeForNonTsFiles || totalNonTsFileSize > availableSpace) {
|
|
const top5LargestFiles = fileNames.map((f2) => propertyReader.getFileName(f2)).filter((name2) => !hasTSFileExtension(name2)).map((name2) => ({ name: name2, size: this.host.getFileSize(name2) })).sort((a, b) => b.size - a.size).slice(0, 5);
|
|
this.logger.info(`Non TS file size exceeded limit (${totalNonTsFileSize}). Largest files: ${top5LargestFiles.map((file) => `${file.name}:${file.size}`).join(", ")}`);
|
|
return fileName;
|
|
}
|
|
}
|
|
this.projectToSizeMap.set(name, totalNonTsFileSize);
|
|
}
|
|
createExternalProject(projectFileName, files, options, typeAcquisition, excludedFiles) {
|
|
const compilerOptions = convertCompilerOptions(options);
|
|
const watchOptionsAndErrors = convertWatchOptions(options, getDirectoryPath(normalizeSlashes(projectFileName)));
|
|
const project = new ExternalProject2(
|
|
projectFileName,
|
|
this,
|
|
this.documentRegistry,
|
|
compilerOptions,
|
|
this.getFilenameForExceededTotalSizeLimitForNonTsFiles(projectFileName, compilerOptions, files, externalFilePropertyReader),
|
|
options.compileOnSave === void 0 ? true : options.compileOnSave,
|
|
void 0,
|
|
this.currentPluginConfigOverrides,
|
|
watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions
|
|
);
|
|
project.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors);
|
|
project.excludedFiles = excludedFiles;
|
|
this.addFilesToNonInferredProject(project, files, externalFilePropertyReader, typeAcquisition);
|
|
this.externalProjects.push(project);
|
|
return project;
|
|
}
|
|
sendProjectTelemetry(project) {
|
|
if (this.seenProjects.has(project.projectName)) {
|
|
setProjectOptionsUsed(project);
|
|
return;
|
|
}
|
|
this.seenProjects.set(project.projectName, true);
|
|
if (!this.eventHandler || !this.host.createSHA256Hash) {
|
|
setProjectOptionsUsed(project);
|
|
return;
|
|
}
|
|
const projectOptions = isConfiguredProject(project) ? project.projectOptions : void 0;
|
|
setProjectOptionsUsed(project);
|
|
const data = {
|
|
projectId: this.host.createSHA256Hash(project.projectName),
|
|
fileStats: countEachFileTypes(project.getScriptInfos(), true),
|
|
compilerOptions: convertCompilerOptionsForTelemetry(project.getCompilationSettings()),
|
|
typeAcquisition: convertTypeAcquisition2(project.getTypeAcquisition()),
|
|
extends: projectOptions && projectOptions.configHasExtendsProperty,
|
|
files: projectOptions && projectOptions.configHasFilesProperty,
|
|
include: projectOptions && projectOptions.configHasIncludeProperty,
|
|
exclude: projectOptions && projectOptions.configHasExcludeProperty,
|
|
compileOnSave: project.compileOnSaveEnabled,
|
|
configFileName: configFileName(),
|
|
projectType: project instanceof ExternalProject2 ? "external" : "configured",
|
|
languageServiceEnabled: project.languageServiceEnabled,
|
|
version
|
|
};
|
|
this.eventHandler({ eventName: ProjectInfoTelemetryEvent, data });
|
|
function configFileName() {
|
|
if (!isConfiguredProject(project)) {
|
|
return "other";
|
|
}
|
|
return getBaseConfigFileName(project.getConfigFilePath()) || "other";
|
|
}
|
|
function convertTypeAcquisition2({ enable: enable2, include, exclude }) {
|
|
return {
|
|
enable: enable2,
|
|
include: include !== void 0 && include.length !== 0,
|
|
exclude: exclude !== void 0 && exclude.length !== 0
|
|
};
|
|
}
|
|
}
|
|
addFilesToNonInferredProject(project, files, propertyReader, typeAcquisition) {
|
|
this.updateNonInferredProjectFiles(project, files, propertyReader);
|
|
project.setTypeAcquisition(typeAcquisition);
|
|
}
|
|
createConfiguredProject(configFileName) {
|
|
var _a2;
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.Session, "createConfiguredProject", { configFilePath: configFileName });
|
|
this.logger.info(`Creating configuration project ${configFileName}`);
|
|
const canonicalConfigFilePath = asNormalizedPath(this.toCanonicalFileName(configFileName));
|
|
let configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!configFileExistenceInfo) {
|
|
this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo = { exists: true });
|
|
} else {
|
|
configFileExistenceInfo.exists = true;
|
|
}
|
|
if (!configFileExistenceInfo.config) {
|
|
configFileExistenceInfo.config = {
|
|
cachedDirectoryStructureHost: createCachedDirectoryStructureHost(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames),
|
|
projects: /* @__PURE__ */ new Map(),
|
|
reloadLevel: 2 /* Full */
|
|
};
|
|
}
|
|
const project = new ConfiguredProject2(
|
|
configFileName,
|
|
canonicalConfigFilePath,
|
|
this,
|
|
this.documentRegistry,
|
|
configFileExistenceInfo.config.cachedDirectoryStructureHost
|
|
);
|
|
this.configuredProjects.set(canonicalConfigFilePath, project);
|
|
this.createConfigFileWatcherForParsedConfig(configFileName, canonicalConfigFilePath, project);
|
|
return project;
|
|
}
|
|
createConfiguredProjectWithDelayLoad(configFileName, reason) {
|
|
const project = this.createConfiguredProject(configFileName);
|
|
project.pendingReload = 2 /* Full */;
|
|
project.pendingReloadReason = reason;
|
|
return project;
|
|
}
|
|
createAndLoadConfiguredProject(configFileName, reason) {
|
|
const project = this.createConfiguredProject(configFileName);
|
|
this.loadConfiguredProject(project, reason);
|
|
return project;
|
|
}
|
|
createLoadAndUpdateConfiguredProject(configFileName, reason) {
|
|
const project = this.createAndLoadConfiguredProject(configFileName, reason);
|
|
project.updateGraph();
|
|
return project;
|
|
}
|
|
loadConfiguredProject(project, reason) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "loadConfiguredProject", { configFilePath: project.canonicalConfigFilePath });
|
|
this.sendProjectLoadingStartEvent(project, reason);
|
|
const configFilename = asNormalizedPath(normalizePath(project.getConfigFilePath()));
|
|
const configFileExistenceInfo = this.ensureParsedConfigUptoDate(
|
|
configFilename,
|
|
project.canonicalConfigFilePath,
|
|
this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath),
|
|
project
|
|
);
|
|
const parsedCommandLine = configFileExistenceInfo.config.parsedCommandLine;
|
|
Debug.assert(!!parsedCommandLine.fileNames);
|
|
const compilerOptions = parsedCommandLine.options;
|
|
if (!project.projectOptions) {
|
|
project.projectOptions = {
|
|
configHasExtendsProperty: parsedCommandLine.raw.extends !== void 0,
|
|
configHasFilesProperty: parsedCommandLine.raw.files !== void 0,
|
|
configHasIncludeProperty: parsedCommandLine.raw.include !== void 0,
|
|
configHasExcludeProperty: parsedCommandLine.raw.exclude !== void 0
|
|
};
|
|
}
|
|
project.canConfigFileJsonReportNoInputFiles = canJsonReportNoInputFiles(parsedCommandLine.raw);
|
|
project.setProjectErrors(parsedCommandLine.options.configFile.parseDiagnostics);
|
|
project.updateReferences(parsedCommandLine.projectReferences);
|
|
const lastFileExceededProgramSize = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(project.canonicalConfigFilePath, compilerOptions, parsedCommandLine.fileNames, fileNamePropertyReader);
|
|
if (lastFileExceededProgramSize) {
|
|
project.disableLanguageService(lastFileExceededProgramSize);
|
|
this.configFileExistenceInfoCache.forEach((_configFileExistenceInfo, canonicalConfigFilePath) => this.stopWatchingWildCards(canonicalConfigFilePath, project));
|
|
} else {
|
|
project.setCompilerOptions(compilerOptions);
|
|
project.setWatchOptions(parsedCommandLine.watchOptions);
|
|
project.enableLanguageService();
|
|
this.watchWildcards(configFilename, configFileExistenceInfo, project);
|
|
}
|
|
project.enablePluginsWithOptions(compilerOptions, this.currentPluginConfigOverrides);
|
|
const filesToAdd = parsedCommandLine.fileNames.concat(project.getExternalFiles());
|
|
this.updateRootAndOptionsOfNonInferredProject(project, filesToAdd, fileNamePropertyReader, compilerOptions, parsedCommandLine.typeAcquisition, parsedCommandLine.compileOnSave, parsedCommandLine.watchOptions);
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
ensureParsedConfigUptoDate(configFilename, canonicalConfigFilePath, configFileExistenceInfo, forProject) {
|
|
var _a2, _b, _c;
|
|
if (configFileExistenceInfo.config) {
|
|
if (!configFileExistenceInfo.config.reloadLevel)
|
|
return configFileExistenceInfo;
|
|
if (configFileExistenceInfo.config.reloadLevel === 1 /* Partial */) {
|
|
this.reloadFileNamesOfParsedConfig(configFilename, configFileExistenceInfo.config);
|
|
return configFileExistenceInfo;
|
|
}
|
|
}
|
|
const cachedDirectoryStructureHost = ((_a2 = configFileExistenceInfo.config) == null ? void 0 : _a2.cachedDirectoryStructureHost) || createCachedDirectoryStructureHost(this.host, this.host.getCurrentDirectory(), this.host.useCaseSensitiveFileNames);
|
|
const configFileContent = tryReadFile(configFilename, (fileName) => this.host.readFile(fileName));
|
|
const configFile = parseJsonText(configFilename, isString(configFileContent) ? configFileContent : "");
|
|
const configFileErrors = configFile.parseDiagnostics;
|
|
if (!isString(configFileContent))
|
|
configFileErrors.push(configFileContent);
|
|
const parsedCommandLine = parseJsonSourceFileConfigFileContent(
|
|
configFile,
|
|
cachedDirectoryStructureHost,
|
|
getDirectoryPath(configFilename),
|
|
{},
|
|
configFilename,
|
|
[],
|
|
this.hostConfiguration.extraFileExtensions,
|
|
this.extendedConfigCache
|
|
);
|
|
if (parsedCommandLine.errors.length) {
|
|
configFileErrors.push(...parsedCommandLine.errors);
|
|
}
|
|
this.logger.info(`Config: ${configFilename} : ${JSON.stringify({
|
|
rootNames: parsedCommandLine.fileNames,
|
|
options: parsedCommandLine.options,
|
|
watchOptions: parsedCommandLine.watchOptions,
|
|
projectReferences: parsedCommandLine.projectReferences
|
|
}, void 0, " ")}`);
|
|
const oldCommandLine = (_b = configFileExistenceInfo.config) == null ? void 0 : _b.parsedCommandLine;
|
|
if (!configFileExistenceInfo.config) {
|
|
configFileExistenceInfo.config = { parsedCommandLine, cachedDirectoryStructureHost, projects: /* @__PURE__ */ new Map() };
|
|
} else {
|
|
configFileExistenceInfo.config.parsedCommandLine = parsedCommandLine;
|
|
configFileExistenceInfo.config.watchedDirectoriesStale = true;
|
|
configFileExistenceInfo.config.reloadLevel = void 0;
|
|
}
|
|
if (!oldCommandLine && !isJsonEqual(
|
|
this.getWatchOptionsFromProjectWatchOptions(void 0),
|
|
this.getWatchOptionsFromProjectWatchOptions(parsedCommandLine.watchOptions)
|
|
)) {
|
|
(_c = configFileExistenceInfo.watcher) == null ? void 0 : _c.close();
|
|
configFileExistenceInfo.watcher = void 0;
|
|
}
|
|
this.createConfigFileWatcherForParsedConfig(configFilename, canonicalConfigFilePath, forProject);
|
|
updateSharedExtendedConfigFileWatcher(
|
|
canonicalConfigFilePath,
|
|
parsedCommandLine.options,
|
|
this.sharedExtendedConfigFileWatchers,
|
|
(extendedConfigFileName, extendedConfigFilePath) => this.watchFactory.watchFile(
|
|
extendedConfigFileName,
|
|
() => {
|
|
var _a3;
|
|
cleanExtendedConfigCache(this.extendedConfigCache, extendedConfigFilePath, (fileName) => this.toPath(fileName));
|
|
let ensureProjectsForOpenFiles = false;
|
|
(_a3 = this.sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) == null ? void 0 : _a3.projects.forEach((canonicalPath) => {
|
|
ensureProjectsForOpenFiles = this.delayUpdateProjectsFromParsedConfigOnConfigFileChange(canonicalPath, `Change in extended config file ${extendedConfigFileName} detected`) || ensureProjectsForOpenFiles;
|
|
});
|
|
if (ensureProjectsForOpenFiles)
|
|
this.delayEnsureProjectForOpenFiles();
|
|
},
|
|
2e3 /* High */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.ExtendedConfigFile,
|
|
configFilename
|
|
),
|
|
(fileName) => this.toPath(fileName)
|
|
);
|
|
return configFileExistenceInfo;
|
|
}
|
|
watchWildcards(configFileName, { exists, config }, forProject) {
|
|
config.projects.set(forProject.canonicalConfigFilePath, true);
|
|
if (exists) {
|
|
if (config.watchedDirectories && !config.watchedDirectoriesStale)
|
|
return;
|
|
config.watchedDirectoriesStale = false;
|
|
updateWatchingWildcardDirectories(
|
|
config.watchedDirectories || (config.watchedDirectories = /* @__PURE__ */ new Map()),
|
|
new Map(getEntries(config.parsedCommandLine.wildcardDirectories)),
|
|
(directory, flags) => this.watchWildcardDirectory(directory, flags, configFileName, config)
|
|
);
|
|
} else {
|
|
config.watchedDirectoriesStale = false;
|
|
if (!config.watchedDirectories)
|
|
return;
|
|
clearMap(config.watchedDirectories, closeFileWatcherOf);
|
|
config.watchedDirectories = void 0;
|
|
}
|
|
}
|
|
stopWatchingWildCards(canonicalConfigFilePath, forProject) {
|
|
const configFileExistenceInfo = this.configFileExistenceInfoCache.get(canonicalConfigFilePath);
|
|
if (!configFileExistenceInfo.config || !configFileExistenceInfo.config.projects.get(forProject.canonicalConfigFilePath)) {
|
|
return;
|
|
}
|
|
configFileExistenceInfo.config.projects.set(forProject.canonicalConfigFilePath, false);
|
|
if (forEachEntry(configFileExistenceInfo.config.projects, identity))
|
|
return;
|
|
if (configFileExistenceInfo.config.watchedDirectories) {
|
|
clearMap(configFileExistenceInfo.config.watchedDirectories, closeFileWatcherOf);
|
|
configFileExistenceInfo.config.watchedDirectories = void 0;
|
|
}
|
|
configFileExistenceInfo.config.watchedDirectoriesStale = void 0;
|
|
}
|
|
updateNonInferredProjectFiles(project, files, propertyReader) {
|
|
const projectRootFilesMap = project.getRootFilesMap();
|
|
const newRootScriptInfoMap = /* @__PURE__ */ new Map();
|
|
for (const f of files) {
|
|
const newRootFile = propertyReader.getFileName(f);
|
|
const fileName = toNormalizedPath(newRootFile);
|
|
const isDynamic = isDynamicFileName(fileName);
|
|
let path;
|
|
if (!isDynamic && !project.fileExists(newRootFile)) {
|
|
path = normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName);
|
|
const existingValue = projectRootFilesMap.get(path);
|
|
if (existingValue) {
|
|
if (existingValue.info) {
|
|
project.removeFile(existingValue.info, false, true);
|
|
existingValue.info = void 0;
|
|
}
|
|
existingValue.fileName = fileName;
|
|
} else {
|
|
projectRootFilesMap.set(path, { fileName });
|
|
}
|
|
} else {
|
|
const scriptKind = propertyReader.getScriptKind(f, this.hostConfiguration.extraFileExtensions);
|
|
const hasMixedContent = propertyReader.hasMixedContent(f, this.hostConfiguration.extraFileExtensions);
|
|
const scriptInfo = Debug.checkDefined(this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(
|
|
fileName,
|
|
project.currentDirectory,
|
|
scriptKind,
|
|
hasMixedContent,
|
|
project.directoryStructureHost
|
|
));
|
|
path = scriptInfo.path;
|
|
const existingValue = projectRootFilesMap.get(path);
|
|
if (!existingValue || existingValue.info !== scriptInfo) {
|
|
project.addRoot(scriptInfo, fileName);
|
|
if (scriptInfo.isScriptOpen()) {
|
|
this.removeRootOfInferredProjectIfNowPartOfOtherProject(scriptInfo);
|
|
}
|
|
} else {
|
|
existingValue.fileName = fileName;
|
|
}
|
|
}
|
|
newRootScriptInfoMap.set(path, true);
|
|
}
|
|
if (projectRootFilesMap.size > newRootScriptInfoMap.size) {
|
|
projectRootFilesMap.forEach((value, path) => {
|
|
if (!newRootScriptInfoMap.has(path)) {
|
|
if (value.info) {
|
|
project.removeFile(value.info, project.fileExists(path), true);
|
|
} else {
|
|
projectRootFilesMap.delete(path);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
project.markAsDirty();
|
|
}
|
|
updateRootAndOptionsOfNonInferredProject(project, newUncheckedFiles, propertyReader, newOptions, newTypeAcquisition, compileOnSave, watchOptions) {
|
|
project.setCompilerOptions(newOptions);
|
|
project.setWatchOptions(watchOptions);
|
|
if (compileOnSave !== void 0) {
|
|
project.compileOnSaveEnabled = compileOnSave;
|
|
}
|
|
this.addFilesToNonInferredProject(project, newUncheckedFiles, propertyReader, newTypeAcquisition);
|
|
}
|
|
reloadFileNamesOfConfiguredProject(project) {
|
|
const fileNames = this.reloadFileNamesOfParsedConfig(project.getConfigFilePath(), this.configFileExistenceInfoCache.get(project.canonicalConfigFilePath).config);
|
|
project.updateErrorOnNoInputFiles(fileNames);
|
|
this.updateNonInferredProjectFiles(project, fileNames.concat(project.getExternalFiles()), fileNamePropertyReader);
|
|
return project.updateGraph();
|
|
}
|
|
reloadFileNamesOfParsedConfig(configFileName, config) {
|
|
if (config.reloadLevel === void 0)
|
|
return config.parsedCommandLine.fileNames;
|
|
Debug.assert(config.reloadLevel === 1 /* Partial */);
|
|
const configFileSpecs = config.parsedCommandLine.options.configFile.configFileSpecs;
|
|
const fileNames = getFileNamesFromConfigSpecs(
|
|
configFileSpecs,
|
|
getDirectoryPath(configFileName),
|
|
config.parsedCommandLine.options,
|
|
config.cachedDirectoryStructureHost,
|
|
this.hostConfiguration.extraFileExtensions
|
|
);
|
|
config.parsedCommandLine = { ...config.parsedCommandLine, fileNames };
|
|
return fileNames;
|
|
}
|
|
setFileNamesOfAutoImportProviderProject(project, fileNames) {
|
|
this.updateNonInferredProjectFiles(project, fileNames, fileNamePropertyReader);
|
|
}
|
|
reloadConfiguredProject(project, reason, isInitialLoad, clearSemanticCache) {
|
|
const host = project.getCachedDirectoryStructureHost();
|
|
if (clearSemanticCache)
|
|
this.clearSemanticCache(project);
|
|
host.clearCache();
|
|
const configFileName = project.getConfigFilePath();
|
|
this.logger.info(`${isInitialLoad ? "Loading" : "Reloading"} configured project ${configFileName}`);
|
|
this.loadConfiguredProject(project, reason);
|
|
project.updateGraph();
|
|
this.sendConfigFileDiagEvent(project, configFileName);
|
|
}
|
|
clearSemanticCache(project) {
|
|
project.resolutionCache.clear();
|
|
project.getLanguageService(false).cleanupSemanticCache();
|
|
project.markAsDirty();
|
|
}
|
|
sendConfigFileDiagEvent(project, triggerFile) {
|
|
if (!this.eventHandler || this.suppressDiagnosticEvents) {
|
|
return;
|
|
}
|
|
const diagnostics = project.getLanguageService().getCompilerOptionsDiagnostics();
|
|
diagnostics.push(...project.getAllProjectErrors());
|
|
this.eventHandler({
|
|
eventName: ConfigFileDiagEvent,
|
|
data: { configFileName: project.getConfigFilePath(), diagnostics, triggerFile }
|
|
});
|
|
}
|
|
getOrCreateInferredProjectForProjectRootPathIfEnabled(info, projectRootPath) {
|
|
if (!this.useInferredProjectPerProjectRoot || info.isDynamic && projectRootPath === void 0) {
|
|
return void 0;
|
|
}
|
|
if (projectRootPath) {
|
|
const canonicalProjectRootPath = this.toCanonicalFileName(projectRootPath);
|
|
for (const project of this.inferredProjects) {
|
|
if (project.projectRootPath === canonicalProjectRootPath) {
|
|
return project;
|
|
}
|
|
}
|
|
return this.createInferredProject(projectRootPath, false, projectRootPath);
|
|
}
|
|
let bestMatch;
|
|
for (const project of this.inferredProjects) {
|
|
if (!project.projectRootPath)
|
|
continue;
|
|
if (!containsPath(project.projectRootPath, info.path, this.host.getCurrentDirectory(), !this.host.useCaseSensitiveFileNames))
|
|
continue;
|
|
if (bestMatch && bestMatch.projectRootPath.length > project.projectRootPath.length)
|
|
continue;
|
|
bestMatch = project;
|
|
}
|
|
return bestMatch;
|
|
}
|
|
getOrCreateSingleInferredProjectIfEnabled() {
|
|
if (!this.useSingleInferredProject) {
|
|
return void 0;
|
|
}
|
|
if (this.inferredProjects.length > 0 && this.inferredProjects[0].projectRootPath === void 0) {
|
|
return this.inferredProjects[0];
|
|
}
|
|
return this.createInferredProject(void 0, true);
|
|
}
|
|
getOrCreateSingleInferredWithoutProjectRoot(currentDirectory) {
|
|
Debug.assert(!this.useSingleInferredProject);
|
|
const expectedCurrentDirectory = this.toCanonicalFileName(this.getNormalizedAbsolutePath(currentDirectory || ""));
|
|
for (const inferredProject of this.inferredProjects) {
|
|
if (!inferredProject.projectRootPath && inferredProject.isOrphan() && inferredProject.canonicalCurrentDirectory === expectedCurrentDirectory) {
|
|
return inferredProject;
|
|
}
|
|
}
|
|
return this.createInferredProject(currentDirectory);
|
|
}
|
|
createInferredProject(currentDirectory, isSingleInferredProject, projectRootPath) {
|
|
const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects;
|
|
let watchOptionsAndErrors;
|
|
let typeAcquisition;
|
|
if (projectRootPath) {
|
|
watchOptionsAndErrors = this.watchOptionsForInferredProjectsPerProjectRoot.get(projectRootPath);
|
|
typeAcquisition = this.typeAcquisitionForInferredProjectsPerProjectRoot.get(projectRootPath);
|
|
}
|
|
if (watchOptionsAndErrors === void 0) {
|
|
watchOptionsAndErrors = this.watchOptionsForInferredProjects;
|
|
}
|
|
if (typeAcquisition === void 0) {
|
|
typeAcquisition = this.typeAcquisitionForInferredProjects;
|
|
}
|
|
watchOptionsAndErrors = watchOptionsAndErrors || void 0;
|
|
const project = new InferredProject2(this, this.documentRegistry, compilerOptions, watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions, projectRootPath, currentDirectory, this.currentPluginConfigOverrides, typeAcquisition);
|
|
project.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors);
|
|
if (isSingleInferredProject) {
|
|
this.inferredProjects.unshift(project);
|
|
} else {
|
|
this.inferredProjects.push(project);
|
|
}
|
|
return project;
|
|
}
|
|
getOrCreateScriptInfoNotOpenedByClient(uncheckedFileName, currentDirectory, hostToQueryFileExistsOn) {
|
|
return this.getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(
|
|
toNormalizedPath(uncheckedFileName),
|
|
currentDirectory,
|
|
void 0,
|
|
void 0,
|
|
hostToQueryFileExistsOn
|
|
);
|
|
}
|
|
getScriptInfo(uncheckedFileName) {
|
|
return this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName));
|
|
}
|
|
getScriptInfoOrConfig(uncheckedFileName) {
|
|
const path = toNormalizedPath(uncheckedFileName);
|
|
const info = this.getScriptInfoForNormalizedPath(path);
|
|
if (info)
|
|
return info;
|
|
const configProject = this.configuredProjects.get(this.toPath(uncheckedFileName));
|
|
return configProject && configProject.getCompilerOptions().configFile;
|
|
}
|
|
logErrorForScriptInfoNotFound(fileName) {
|
|
const names = arrayFrom(this.filenameToScriptInfo.entries()).map(([path, scriptInfo]) => ({ path, fileName: scriptInfo.fileName }));
|
|
this.logger.msg(`Could not find file ${JSON.stringify(fileName)}.
|
|
All files are: ${JSON.stringify(names)}`, "Err" /* Err */);
|
|
}
|
|
getSymlinkedProjects(info) {
|
|
let projects;
|
|
if (this.realpathToScriptInfos) {
|
|
const realpath = info.getRealpathIfDifferent();
|
|
if (realpath) {
|
|
forEach(this.realpathToScriptInfos.get(realpath), combineProjects);
|
|
}
|
|
forEach(this.realpathToScriptInfos.get(info.path), combineProjects);
|
|
}
|
|
return projects;
|
|
function combineProjects(toAddInfo) {
|
|
if (toAddInfo !== info) {
|
|
for (const project of toAddInfo.containingProjects) {
|
|
if (project.languageServiceEnabled && !project.isOrphan() && !project.getCompilerOptions().preserveSymlinks && !info.isAttached(project)) {
|
|
if (!projects) {
|
|
projects = createMultiMap();
|
|
projects.add(toAddInfo.path, project);
|
|
} else if (!forEachEntry(projects, (projs, path) => path === toAddInfo.path ? false : contains(projs, project))) {
|
|
projects.add(toAddInfo.path, project);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
watchClosedScriptInfo(info) {
|
|
Debug.assert(!info.fileWatcher);
|
|
if (!info.isDynamicOrHasMixedContent() && (!this.globalCacheLocationDirectoryPath || !startsWith(info.path, this.globalCacheLocationDirectoryPath))) {
|
|
const indexOfNodeModules = info.path.indexOf("/node_modules/");
|
|
if (!this.host.getModifiedTime || indexOfNodeModules === -1) {
|
|
info.fileWatcher = this.watchFactory.watchFile(
|
|
info.fileName,
|
|
(_fileName, eventKind) => this.onSourceFileChanged(info, eventKind),
|
|
500 /* Medium */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.ClosedScriptInfo
|
|
);
|
|
} else {
|
|
info.mTime = this.getModifiedTime(info);
|
|
info.fileWatcher = this.watchClosedScriptInfoInNodeModules(info.path.substr(0, indexOfNodeModules));
|
|
}
|
|
}
|
|
}
|
|
createNodeModulesWatcher(dir) {
|
|
const watcher = this.watchFactory.watchDirectory(
|
|
dir,
|
|
(fileOrDirectory) => {
|
|
var _a2;
|
|
const fileOrDirectoryPath = removeIgnoredPath(this.toPath(fileOrDirectory));
|
|
if (!fileOrDirectoryPath)
|
|
return;
|
|
const basename = getBaseFileName(fileOrDirectoryPath);
|
|
if (((_a2 = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a2.size) && (basename === "package.json" || basename === "node_modules")) {
|
|
result.affectedModuleSpecifierCacheProjects.forEach((projectName) => {
|
|
var _a3, _b;
|
|
(_b = (_a3 = this.findProject(projectName)) == null ? void 0 : _a3.getModuleSpecifierCache()) == null ? void 0 : _b.clear();
|
|
});
|
|
}
|
|
if (result.refreshScriptInfoRefCount) {
|
|
if (dir === fileOrDirectoryPath) {
|
|
this.refreshScriptInfosInDirectory(dir);
|
|
} else {
|
|
const info = this.getScriptInfoForPath(fileOrDirectoryPath);
|
|
if (info) {
|
|
if (isScriptInfoWatchedFromNodeModules(info)) {
|
|
this.refreshScriptInfo(info);
|
|
}
|
|
} else if (!hasExtension(fileOrDirectoryPath)) {
|
|
this.refreshScriptInfosInDirectory(fileOrDirectoryPath);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
1 /* Recursive */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.NodeModules
|
|
);
|
|
const result = {
|
|
refreshScriptInfoRefCount: 0,
|
|
affectedModuleSpecifierCacheProjects: void 0,
|
|
close: () => {
|
|
var _a2;
|
|
if (!result.refreshScriptInfoRefCount && !((_a2 = result.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a2.size)) {
|
|
watcher.close();
|
|
this.nodeModulesWatchers.delete(dir);
|
|
}
|
|
}
|
|
};
|
|
this.nodeModulesWatchers.set(dir, result);
|
|
return result;
|
|
}
|
|
watchPackageJsonsInNodeModules(dir, project) {
|
|
const watcher = this.nodeModulesWatchers.get(dir) || this.createNodeModulesWatcher(dir);
|
|
(watcher.affectedModuleSpecifierCacheProjects || (watcher.affectedModuleSpecifierCacheProjects = /* @__PURE__ */ new Set())).add(project.getProjectName());
|
|
return {
|
|
close: () => {
|
|
var _a2;
|
|
(_a2 = watcher.affectedModuleSpecifierCacheProjects) == null ? void 0 : _a2.delete(project.getProjectName());
|
|
watcher.close();
|
|
}
|
|
};
|
|
}
|
|
watchClosedScriptInfoInNodeModules(dir) {
|
|
const watchDir = dir + "/node_modules";
|
|
const watcher = this.nodeModulesWatchers.get(watchDir) || this.createNodeModulesWatcher(watchDir);
|
|
watcher.refreshScriptInfoRefCount++;
|
|
return {
|
|
close: () => {
|
|
watcher.refreshScriptInfoRefCount--;
|
|
watcher.close();
|
|
}
|
|
};
|
|
}
|
|
getModifiedTime(info) {
|
|
return (this.host.getModifiedTime(info.path) || missingFileModifiedTime).getTime();
|
|
}
|
|
refreshScriptInfo(info) {
|
|
const mTime = this.getModifiedTime(info);
|
|
if (mTime !== info.mTime) {
|
|
const eventKind = getFileWatcherEventKind(info.mTime, mTime);
|
|
info.mTime = mTime;
|
|
this.onSourceFileChanged(info, eventKind);
|
|
}
|
|
}
|
|
refreshScriptInfosInDirectory(dir) {
|
|
dir = dir + directorySeparator;
|
|
this.filenameToScriptInfo.forEach((info) => {
|
|
if (isScriptInfoWatchedFromNodeModules(info) && startsWith(info.path, dir)) {
|
|
this.refreshScriptInfo(info);
|
|
}
|
|
});
|
|
}
|
|
stopWatchingScriptInfo(info) {
|
|
if (info.fileWatcher) {
|
|
info.fileWatcher.close();
|
|
info.fileWatcher = void 0;
|
|
}
|
|
}
|
|
getOrCreateScriptInfoNotOpenedByClientForNormalizedPath(fileName, currentDirectory, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
|
|
if (isRootedDiskPath(fileName) || isDynamicFileName(fileName)) {
|
|
return this.getOrCreateScriptInfoWorker(fileName, currentDirectory, false, void 0, scriptKind, hasMixedContent, hostToQueryFileExistsOn);
|
|
}
|
|
const info = this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName));
|
|
if (info) {
|
|
return info;
|
|
}
|
|
return void 0;
|
|
}
|
|
getOrCreateScriptInfoOpenedByClientForNormalizedPath(fileName, currentDirectory, fileContent, scriptKind, hasMixedContent) {
|
|
return this.getOrCreateScriptInfoWorker(fileName, currentDirectory, true, fileContent, scriptKind, hasMixedContent);
|
|
}
|
|
getOrCreateScriptInfoForNormalizedPath(fileName, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
|
|
return this.getOrCreateScriptInfoWorker(fileName, this.currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn);
|
|
}
|
|
getOrCreateScriptInfoWorker(fileName, currentDirectory, openedByClient, fileContent, scriptKind, hasMixedContent, hostToQueryFileExistsOn) {
|
|
Debug.assert(fileContent === void 0 || openedByClient, "ScriptInfo needs to be opened by client to be able to set its user defined content");
|
|
const path = normalizedPathToPath(fileName, currentDirectory, this.toCanonicalFileName);
|
|
let info = this.getScriptInfoForPath(path);
|
|
if (!info) {
|
|
const isDynamic = isDynamicFileName(fileName);
|
|
Debug.assert(isRootedDiskPath(fileName) || isDynamic || openedByClient, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
|
|
Script info with non-dynamic relative file name can only be open script info or in context of host currentDirectory`);
|
|
Debug.assert(!isRootedDiskPath(fileName) || this.currentDirectory === currentDirectory || !this.openFilesWithNonRootedDiskPath.has(this.toCanonicalFileName(fileName)), "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
|
|
Open script files with non rooted disk path opened with current directory context cannot have same canonical names`);
|
|
Debug.assert(!isDynamic || this.currentDirectory === currentDirectory || this.useInferredProjectPerProjectRoot, "", () => `${JSON.stringify({ fileName, currentDirectory, hostCurrentDirectory: this.currentDirectory, openKeys: arrayFrom(this.openFilesWithNonRootedDiskPath.keys()) })}
|
|
Dynamic files must always be opened with service's current directory or service should support inferred project per projectRootPath.`);
|
|
if (!openedByClient && !isDynamic && !(hostToQueryFileExistsOn || this.host).fileExists(fileName)) {
|
|
return;
|
|
}
|
|
info = new ScriptInfo(this.host, fileName, scriptKind, !!hasMixedContent, path, this.filenameToScriptInfoVersion.get(path));
|
|
this.filenameToScriptInfo.set(info.path, info);
|
|
this.filenameToScriptInfoVersion.delete(info.path);
|
|
if (!openedByClient) {
|
|
this.watchClosedScriptInfo(info);
|
|
} else if (!isRootedDiskPath(fileName) && (!isDynamic || this.currentDirectory !== currentDirectory)) {
|
|
this.openFilesWithNonRootedDiskPath.set(this.toCanonicalFileName(fileName), info);
|
|
}
|
|
}
|
|
if (openedByClient) {
|
|
this.stopWatchingScriptInfo(info);
|
|
info.open(fileContent);
|
|
if (hasMixedContent) {
|
|
info.registerFileUpdate();
|
|
}
|
|
}
|
|
return info;
|
|
}
|
|
getScriptInfoForNormalizedPath(fileName) {
|
|
return !isRootedDiskPath(fileName) && this.openFilesWithNonRootedDiskPath.get(this.toCanonicalFileName(fileName)) || this.getScriptInfoForPath(normalizedPathToPath(fileName, this.currentDirectory, this.toCanonicalFileName));
|
|
}
|
|
getScriptInfoForPath(fileName) {
|
|
return this.filenameToScriptInfo.get(fileName);
|
|
}
|
|
getDocumentPositionMapper(project, generatedFileName, sourceFileName) {
|
|
const declarationInfo = this.getOrCreateScriptInfoNotOpenedByClient(generatedFileName, project.currentDirectory, this.host);
|
|
if (!declarationInfo) {
|
|
if (sourceFileName) {
|
|
project.addGeneratedFileWatch(generatedFileName, sourceFileName);
|
|
}
|
|
return void 0;
|
|
}
|
|
declarationInfo.getSnapshot();
|
|
if (isString(declarationInfo.sourceMapFilePath)) {
|
|
const sourceMapFileInfo2 = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath);
|
|
if (sourceMapFileInfo2) {
|
|
sourceMapFileInfo2.getSnapshot();
|
|
if (sourceMapFileInfo2.documentPositionMapper !== void 0) {
|
|
sourceMapFileInfo2.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo2.sourceInfos);
|
|
return sourceMapFileInfo2.documentPositionMapper ? sourceMapFileInfo2.documentPositionMapper : void 0;
|
|
}
|
|
}
|
|
declarationInfo.sourceMapFilePath = void 0;
|
|
} else if (declarationInfo.sourceMapFilePath) {
|
|
declarationInfo.sourceMapFilePath.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, declarationInfo.sourceMapFilePath.sourceInfos);
|
|
return void 0;
|
|
} else if (declarationInfo.sourceMapFilePath !== void 0) {
|
|
return void 0;
|
|
}
|
|
let sourceMapFileInfo;
|
|
let mapFileNameFromDeclarationInfo;
|
|
let readMapFile = (mapFileName, mapFileNameFromDts) => {
|
|
const mapInfo = this.getOrCreateScriptInfoNotOpenedByClient(mapFileName, project.currentDirectory, this.host);
|
|
if (!mapInfo) {
|
|
mapFileNameFromDeclarationInfo = mapFileNameFromDts;
|
|
return void 0;
|
|
}
|
|
sourceMapFileInfo = mapInfo;
|
|
const snap = mapInfo.getSnapshot();
|
|
if (mapInfo.documentPositionMapper !== void 0)
|
|
return mapInfo.documentPositionMapper;
|
|
return getSnapshotText(snap);
|
|
};
|
|
const projectName = project.projectName;
|
|
const documentPositionMapper = getDocumentPositionMapper(
|
|
{ getCanonicalFileName: this.toCanonicalFileName, log: (s) => this.logger.info(s), getSourceFileLike: (f) => this.getSourceFileLike(f, projectName, declarationInfo) },
|
|
declarationInfo.fileName,
|
|
declarationInfo.getLineInfo(),
|
|
readMapFile
|
|
);
|
|
readMapFile = void 0;
|
|
if (sourceMapFileInfo) {
|
|
declarationInfo.sourceMapFilePath = sourceMapFileInfo.path;
|
|
sourceMapFileInfo.declarationInfoPath = declarationInfo.path;
|
|
sourceMapFileInfo.documentPositionMapper = documentPositionMapper || false;
|
|
sourceMapFileInfo.sourceInfos = this.addSourceInfoToSourceMap(sourceFileName, project, sourceMapFileInfo.sourceInfos);
|
|
} else if (mapFileNameFromDeclarationInfo) {
|
|
declarationInfo.sourceMapFilePath = {
|
|
watcher: this.addMissingSourceMapFile(
|
|
project.currentDirectory === this.currentDirectory ? mapFileNameFromDeclarationInfo : getNormalizedAbsolutePath(mapFileNameFromDeclarationInfo, project.currentDirectory),
|
|
declarationInfo.path
|
|
),
|
|
sourceInfos: this.addSourceInfoToSourceMap(sourceFileName, project)
|
|
};
|
|
} else {
|
|
declarationInfo.sourceMapFilePath = false;
|
|
}
|
|
return documentPositionMapper;
|
|
}
|
|
addSourceInfoToSourceMap(sourceFileName, project, sourceInfos) {
|
|
if (sourceFileName) {
|
|
const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(sourceFileName, project.currentDirectory, project.directoryStructureHost);
|
|
(sourceInfos || (sourceInfos = /* @__PURE__ */ new Set())).add(sourceInfo.path);
|
|
}
|
|
return sourceInfos;
|
|
}
|
|
addMissingSourceMapFile(mapFileName, declarationInfoPath) {
|
|
const fileWatcher = this.watchFactory.watchFile(
|
|
mapFileName,
|
|
() => {
|
|
const declarationInfo = this.getScriptInfoForPath(declarationInfoPath);
|
|
if (declarationInfo && declarationInfo.sourceMapFilePath && !isString(declarationInfo.sourceMapFilePath)) {
|
|
this.delayUpdateProjectGraphs(declarationInfo.containingProjects, true);
|
|
this.delayUpdateSourceInfoProjects(declarationInfo.sourceMapFilePath.sourceInfos);
|
|
declarationInfo.closeSourceMapFileWatcher();
|
|
}
|
|
},
|
|
2e3 /* High */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.MissingSourceMapFile
|
|
);
|
|
return fileWatcher;
|
|
}
|
|
getSourceFileLike(fileName, projectNameOrProject, declarationInfo) {
|
|
const project = projectNameOrProject.projectName ? projectNameOrProject : this.findProject(projectNameOrProject);
|
|
if (project) {
|
|
const path = project.toPath(fileName);
|
|
const sourceFile = project.getSourceFile(path);
|
|
if (sourceFile && sourceFile.resolvedPath === path)
|
|
return sourceFile;
|
|
}
|
|
const info = this.getOrCreateScriptInfoNotOpenedByClient(fileName, (project || this).currentDirectory, project ? project.directoryStructureHost : this.host);
|
|
if (!info)
|
|
return void 0;
|
|
if (declarationInfo && isString(declarationInfo.sourceMapFilePath) && info !== declarationInfo) {
|
|
const sourceMapInfo = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath);
|
|
if (sourceMapInfo) {
|
|
(sourceMapInfo.sourceInfos || (sourceMapInfo.sourceInfos = /* @__PURE__ */ new Set())).add(info.path);
|
|
}
|
|
}
|
|
if (info.cacheSourceFile)
|
|
return info.cacheSourceFile.sourceFile;
|
|
if (!info.sourceFileLike) {
|
|
info.sourceFileLike = {
|
|
get text() {
|
|
Debug.fail("shouldnt need text");
|
|
return "";
|
|
},
|
|
getLineAndCharacterOfPosition: (pos) => {
|
|
const lineOffset = info.positionToLineOffset(pos);
|
|
return { line: lineOffset.line - 1, character: lineOffset.offset - 1 };
|
|
},
|
|
getPositionOfLineAndCharacter: (line, character, allowEdits) => info.lineOffsetToPosition(line + 1, character + 1, allowEdits)
|
|
};
|
|
}
|
|
return info.sourceFileLike;
|
|
}
|
|
setPerformanceEventHandler(performanceEventHandler) {
|
|
this.performanceEventHandler = performanceEventHandler;
|
|
}
|
|
setHostConfiguration(args) {
|
|
var _a2;
|
|
if (args.file) {
|
|
const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(args.file));
|
|
if (info) {
|
|
info.setOptions(convertFormatOptions(args.formatOptions), args.preferences);
|
|
this.logger.info(`Host configuration update for file ${args.file}`);
|
|
}
|
|
} else {
|
|
if (args.hostInfo !== void 0) {
|
|
this.hostConfiguration.hostInfo = args.hostInfo;
|
|
this.logger.info(`Host information ${args.hostInfo}`);
|
|
}
|
|
if (args.formatOptions) {
|
|
this.hostConfiguration.formatCodeOptions = { ...this.hostConfiguration.formatCodeOptions, ...convertFormatOptions(args.formatOptions) };
|
|
this.logger.info("Format host information updated");
|
|
}
|
|
if (args.preferences) {
|
|
const {
|
|
lazyConfiguredProjectsFromExternalProject,
|
|
includePackageJsonAutoImports
|
|
} = this.hostConfiguration.preferences;
|
|
this.hostConfiguration.preferences = { ...this.hostConfiguration.preferences, ...args.preferences };
|
|
if (lazyConfiguredProjectsFromExternalProject && !this.hostConfiguration.preferences.lazyConfiguredProjectsFromExternalProject) {
|
|
this.configuredProjects.forEach((project) => {
|
|
if (project.hasExternalProjectRef() && project.pendingReload === 2 /* Full */ && !this.pendingProjectUpdates.has(project.getProjectName())) {
|
|
project.updateGraph();
|
|
}
|
|
});
|
|
}
|
|
if (includePackageJsonAutoImports !== args.preferences.includePackageJsonAutoImports) {
|
|
this.invalidateProjectPackageJson(void 0);
|
|
}
|
|
}
|
|
if (args.extraFileExtensions) {
|
|
this.hostConfiguration.extraFileExtensions = args.extraFileExtensions;
|
|
this.reloadProjects();
|
|
this.logger.info("Host file extension mappings updated");
|
|
}
|
|
if (args.watchOptions) {
|
|
this.hostConfiguration.watchOptions = (_a2 = convertWatchOptions(args.watchOptions)) == null ? void 0 : _a2.watchOptions;
|
|
this.logger.info(`Host watch options changed to ${JSON.stringify(this.hostConfiguration.watchOptions)}, it will be take effect for next watches.`);
|
|
}
|
|
}
|
|
}
|
|
getWatchOptions(project) {
|
|
return this.getWatchOptionsFromProjectWatchOptions(project.getWatchOptions());
|
|
}
|
|
getWatchOptionsFromProjectWatchOptions(projectOptions) {
|
|
return projectOptions && this.hostConfiguration.watchOptions ? { ...this.hostConfiguration.watchOptions, ...projectOptions } : projectOptions || this.hostConfiguration.watchOptions;
|
|
}
|
|
closeLog() {
|
|
this.logger.close();
|
|
}
|
|
reloadProjects() {
|
|
this.logger.info("reload projects.");
|
|
this.filenameToScriptInfo.forEach((info) => {
|
|
if (this.openFiles.has(info.path))
|
|
return;
|
|
if (!info.fileWatcher)
|
|
return;
|
|
this.onSourceFileChanged(info, this.host.fileExists(info.fileName) ? 1 /* Changed */ : 2 /* Deleted */);
|
|
});
|
|
this.pendingProjectUpdates.forEach((_project, projectName) => {
|
|
this.throttledOperations.cancel(projectName);
|
|
this.pendingProjectUpdates.delete(projectName);
|
|
});
|
|
this.throttledOperations.cancel(ensureProjectForOpenFileSchedule);
|
|
this.pendingEnsureProjectForOpenFiles = false;
|
|
this.configFileExistenceInfoCache.forEach((info) => {
|
|
if (info.config)
|
|
info.config.reloadLevel = 2 /* Full */;
|
|
});
|
|
this.reloadConfiguredProjectForFiles(this.openFiles, true, false, returnTrue, "User requested reload projects");
|
|
this.externalProjects.forEach((project) => {
|
|
this.clearSemanticCache(project);
|
|
project.updateGraph();
|
|
});
|
|
this.inferredProjects.forEach((project) => this.clearSemanticCache(project));
|
|
this.ensureProjectForOpenFiles();
|
|
}
|
|
reloadConfiguredProjectForFiles(openFiles, clearSemanticCache, delayReload, shouldReloadProjectFor, reason) {
|
|
const updatedProjects = /* @__PURE__ */ new Map();
|
|
const reloadChildProject = (child) => {
|
|
if (!updatedProjects.has(child.canonicalConfigFilePath)) {
|
|
updatedProjects.set(child.canonicalConfigFilePath, true);
|
|
this.reloadConfiguredProject(child, reason, false, clearSemanticCache);
|
|
}
|
|
};
|
|
openFiles == null ? void 0 : openFiles.forEach((openFileValue, path) => {
|
|
this.configFileForOpenFiles.delete(path);
|
|
if (!shouldReloadProjectFor(openFileValue)) {
|
|
return;
|
|
}
|
|
const info = this.getScriptInfoForPath(path);
|
|
Debug.assert(info.isScriptOpen());
|
|
const configFileName = this.getConfigFileNameForFile(info);
|
|
if (configFileName) {
|
|
const project = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProject(configFileName);
|
|
if (!updatedProjects.has(project.canonicalConfigFilePath)) {
|
|
updatedProjects.set(project.canonicalConfigFilePath, true);
|
|
if (delayReload) {
|
|
project.pendingReload = 2 /* Full */;
|
|
project.pendingReloadReason = reason;
|
|
if (clearSemanticCache)
|
|
this.clearSemanticCache(project);
|
|
this.delayUpdateProjectGraph(project);
|
|
} else {
|
|
this.reloadConfiguredProject(project, reason, false, clearSemanticCache);
|
|
if (!projectContainsInfoDirectly(project, info)) {
|
|
const referencedProject = forEachResolvedProjectReferenceProject(
|
|
project,
|
|
info.path,
|
|
(child) => {
|
|
reloadChildProject(child);
|
|
return projectContainsInfoDirectly(child, info);
|
|
},
|
|
1 /* FindCreate */
|
|
);
|
|
if (referencedProject) {
|
|
forEachResolvedProjectReferenceProject(
|
|
project,
|
|
void 0,
|
|
reloadChildProject,
|
|
0 /* Find */
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
removeRootOfInferredProjectIfNowPartOfOtherProject(info) {
|
|
Debug.assert(info.containingProjects.length > 0);
|
|
const firstProject = info.containingProjects[0];
|
|
if (!firstProject.isOrphan() && isInferredProject(firstProject) && firstProject.isRoot(info) && forEach(info.containingProjects, (p) => p !== firstProject && !p.isOrphan())) {
|
|
firstProject.removeFile(info, true, true);
|
|
}
|
|
}
|
|
ensureProjectForOpenFiles() {
|
|
this.logger.info("Before ensureProjectForOpenFiles:");
|
|
this.printProjects();
|
|
this.openFiles.forEach((projectRootPath, path) => {
|
|
const info = this.getScriptInfoForPath(path);
|
|
if (info.isOrphan()) {
|
|
this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
|
|
} else {
|
|
this.removeRootOfInferredProjectIfNowPartOfOtherProject(info);
|
|
}
|
|
});
|
|
this.pendingEnsureProjectForOpenFiles = false;
|
|
this.inferredProjects.forEach(updateProjectIfDirty);
|
|
this.logger.info("After ensureProjectForOpenFiles:");
|
|
this.printProjects();
|
|
}
|
|
openClientFile(fileName, fileContent, scriptKind, projectRootPath) {
|
|
return this.openClientFileWithNormalizedPath(toNormalizedPath(fileName), fileContent, scriptKind, false, projectRootPath ? toNormalizedPath(projectRootPath) : void 0);
|
|
}
|
|
getOriginalLocationEnsuringConfiguredProject(project, location2) {
|
|
const isSourceOfProjectReferenceRedirect = project.isSourceOfProjectReferenceRedirect(location2.fileName);
|
|
const originalLocation = isSourceOfProjectReferenceRedirect ? location2 : project.getSourceMapper().tryGetSourcePosition(location2);
|
|
if (!originalLocation)
|
|
return void 0;
|
|
const { fileName } = originalLocation;
|
|
const scriptInfo = this.getScriptInfo(fileName);
|
|
if (!scriptInfo && !this.host.fileExists(fileName))
|
|
return void 0;
|
|
const originalFileInfo = { fileName: toNormalizedPath(fileName), path: this.toPath(fileName) };
|
|
const configFileName = this.getConfigFileNameForFile(originalFileInfo);
|
|
if (!configFileName)
|
|
return void 0;
|
|
let configuredProject = this.findConfiguredProjectByProjectName(configFileName);
|
|
if (!configuredProject) {
|
|
if (project.getCompilerOptions().disableReferencedProjectLoad) {
|
|
if (isSourceOfProjectReferenceRedirect) {
|
|
return location2;
|
|
}
|
|
return (scriptInfo == null ? void 0 : scriptInfo.containingProjects.length) ? originalLocation : location2;
|
|
}
|
|
configuredProject = this.createAndLoadConfiguredProject(configFileName, `Creating project for original file: ${originalFileInfo.fileName}${location2 !== originalLocation ? " for location: " + location2.fileName : ""}`);
|
|
}
|
|
updateProjectIfDirty(configuredProject);
|
|
const projectContainsOriginalInfo = (project2) => {
|
|
const info = this.getScriptInfo(fileName);
|
|
return info && projectContainsInfoDirectly(project2, info);
|
|
};
|
|
if (configuredProject.isSolution() || !projectContainsOriginalInfo(configuredProject)) {
|
|
configuredProject = forEachResolvedProjectReferenceProject(
|
|
configuredProject,
|
|
fileName,
|
|
(child) => {
|
|
updateProjectIfDirty(child);
|
|
return projectContainsOriginalInfo(child) ? child : void 0;
|
|
},
|
|
2 /* FindCreateLoad */,
|
|
`Creating project referenced in solution ${configuredProject.projectName} to find possible configured project for original file: ${originalFileInfo.fileName}${location2 !== originalLocation ? " for location: " + location2.fileName : ""}`
|
|
);
|
|
if (!configuredProject)
|
|
return void 0;
|
|
if (configuredProject === project)
|
|
return originalLocation;
|
|
}
|
|
addOriginalConfiguredProject(configuredProject);
|
|
const originalScriptInfo = this.getScriptInfo(fileName);
|
|
if (!originalScriptInfo || !originalScriptInfo.containingProjects.length)
|
|
return void 0;
|
|
originalScriptInfo.containingProjects.forEach((project2) => {
|
|
if (isConfiguredProject(project2)) {
|
|
addOriginalConfiguredProject(project2);
|
|
}
|
|
});
|
|
return originalLocation;
|
|
function addOriginalConfiguredProject(originalProject) {
|
|
if (!project.originalConfiguredProjects) {
|
|
project.originalConfiguredProjects = /* @__PURE__ */ new Set();
|
|
}
|
|
project.originalConfiguredProjects.add(originalProject.canonicalConfigFilePath);
|
|
}
|
|
}
|
|
fileExists(fileName) {
|
|
return !!this.getScriptInfoForNormalizedPath(fileName) || this.host.fileExists(fileName);
|
|
}
|
|
findExternalProjectContainingOpenScriptInfo(info) {
|
|
return find(this.externalProjects, (proj) => {
|
|
updateProjectIfDirty(proj);
|
|
return proj.containsScriptInfo(info);
|
|
});
|
|
}
|
|
getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) {
|
|
const info = this.getOrCreateScriptInfoOpenedByClientForNormalizedPath(fileName, projectRootPath ? this.getNormalizedAbsolutePath(projectRootPath) : this.currentDirectory, fileContent, scriptKind, hasMixedContent);
|
|
this.openFiles.set(info.path, projectRootPath);
|
|
return info;
|
|
}
|
|
assignProjectToOpenedScriptInfo(info) {
|
|
let configFileName;
|
|
let configFileErrors;
|
|
let project = this.findExternalProjectContainingOpenScriptInfo(info);
|
|
let retainProjects;
|
|
let projectForConfigFileDiag;
|
|
let defaultConfigProjectIsCreated = false;
|
|
if (!project && this.serverMode === 0 /* Semantic */) {
|
|
configFileName = this.getConfigFileNameForFile(info);
|
|
if (configFileName) {
|
|
project = this.findConfiguredProjectByProjectName(configFileName);
|
|
if (!project) {
|
|
project = this.createLoadAndUpdateConfiguredProject(configFileName, `Creating possible configured project for ${info.fileName} to open`);
|
|
defaultConfigProjectIsCreated = true;
|
|
} else {
|
|
updateProjectIfDirty(project);
|
|
}
|
|
projectForConfigFileDiag = project.containsScriptInfo(info) ? project : void 0;
|
|
retainProjects = project;
|
|
if (!projectContainsInfoDirectly(project, info)) {
|
|
forEachResolvedProjectReferenceProject(
|
|
project,
|
|
info.path,
|
|
(child) => {
|
|
updateProjectIfDirty(child);
|
|
if (!isArray(retainProjects)) {
|
|
retainProjects = [project, child];
|
|
} else {
|
|
retainProjects.push(child);
|
|
}
|
|
if (projectContainsInfoDirectly(child, info)) {
|
|
projectForConfigFileDiag = child;
|
|
return child;
|
|
}
|
|
if (!projectForConfigFileDiag && child.containsScriptInfo(info)) {
|
|
projectForConfigFileDiag = child;
|
|
}
|
|
},
|
|
2 /* FindCreateLoad */,
|
|
`Creating project referenced in solution ${project.projectName} to find possible configured project for ${info.fileName} to open`
|
|
);
|
|
}
|
|
if (projectForConfigFileDiag) {
|
|
configFileName = projectForConfigFileDiag.getConfigFilePath();
|
|
if (projectForConfigFileDiag !== project || defaultConfigProjectIsCreated) {
|
|
configFileErrors = projectForConfigFileDiag.getAllProjectErrors();
|
|
this.sendConfigFileDiagEvent(projectForConfigFileDiag, info.fileName);
|
|
}
|
|
} else {
|
|
configFileName = void 0;
|
|
}
|
|
this.createAncestorProjects(info, project);
|
|
}
|
|
}
|
|
info.containingProjects.forEach(updateProjectIfDirty);
|
|
if (info.isOrphan()) {
|
|
if (isArray(retainProjects)) {
|
|
retainProjects.forEach((project2) => this.sendConfigFileDiagEvent(project2, info.fileName));
|
|
} else if (retainProjects) {
|
|
this.sendConfigFileDiagEvent(retainProjects, info.fileName);
|
|
}
|
|
Debug.assert(this.openFiles.has(info.path));
|
|
this.assignOrphanScriptInfoToInferredProject(info, this.openFiles.get(info.path));
|
|
}
|
|
Debug.assert(!info.isOrphan());
|
|
return { configFileName, configFileErrors, retainProjects };
|
|
}
|
|
createAncestorProjects(info, project) {
|
|
if (!info.isAttached(project))
|
|
return;
|
|
while (true) {
|
|
if (!project.isInitialLoadPending() && (!project.getCompilerOptions().composite || project.getCompilerOptions().disableSolutionSearching))
|
|
return;
|
|
const configFileName = this.getConfigFileNameForFile({
|
|
fileName: project.getConfigFilePath(),
|
|
path: info.path,
|
|
configFileInfo: true
|
|
});
|
|
if (!configFileName)
|
|
return;
|
|
const ancestor = this.findConfiguredProjectByProjectName(configFileName) || this.createConfiguredProjectWithDelayLoad(configFileName, `Creating project possibly referencing default composite project ${project.getProjectName()} of open file ${info.fileName}`);
|
|
if (ancestor.isInitialLoadPending()) {
|
|
ancestor.setPotentialProjectReference(project.canonicalConfigFilePath);
|
|
}
|
|
project = ancestor;
|
|
}
|
|
}
|
|
loadAncestorProjectTree(forProjects) {
|
|
forProjects = forProjects || mapDefinedEntries(
|
|
this.configuredProjects,
|
|
(key, project) => !project.isInitialLoadPending() ? [key, true] : void 0
|
|
);
|
|
const seenProjects = /* @__PURE__ */ new Set();
|
|
for (const project of arrayFrom(this.configuredProjects.values())) {
|
|
if (forEachPotentialProjectReference(project, (potentialRefPath) => forProjects.has(potentialRefPath))) {
|
|
updateProjectIfDirty(project);
|
|
}
|
|
this.ensureProjectChildren(project, forProjects, seenProjects);
|
|
}
|
|
}
|
|
ensureProjectChildren(project, forProjects, seenProjects) {
|
|
var _a2;
|
|
if (!tryAddToSet(seenProjects, project.canonicalConfigFilePath))
|
|
return;
|
|
if (project.getCompilerOptions().disableReferencedProjectLoad)
|
|
return;
|
|
const children = (_a2 = project.getCurrentProgram()) == null ? void 0 : _a2.getResolvedProjectReferences();
|
|
if (!children)
|
|
return;
|
|
for (const child of children) {
|
|
if (!child)
|
|
continue;
|
|
const referencedProject = forEachResolvedProjectReference(child.references, (ref) => forProjects.has(ref.sourceFile.path) ? ref : void 0);
|
|
if (!referencedProject)
|
|
continue;
|
|
const configFileName = toNormalizedPath(child.sourceFile.fileName);
|
|
const childProject = project.projectService.findConfiguredProjectByProjectName(configFileName) || project.projectService.createAndLoadConfiguredProject(configFileName, `Creating project referenced by : ${project.projectName} as it references project ${referencedProject.sourceFile.fileName}`);
|
|
updateProjectIfDirty(childProject);
|
|
this.ensureProjectChildren(childProject, forProjects, seenProjects);
|
|
}
|
|
}
|
|
cleanupAfterOpeningFile(toRetainConfigProjects) {
|
|
this.removeOrphanConfiguredProjects(toRetainConfigProjects);
|
|
for (const inferredProject of this.inferredProjects.slice()) {
|
|
if (inferredProject.isOrphan()) {
|
|
this.removeProject(inferredProject);
|
|
}
|
|
}
|
|
this.removeOrphanScriptInfos();
|
|
}
|
|
openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath) {
|
|
const info = this.getOrCreateOpenScriptInfo(fileName, fileContent, scriptKind, hasMixedContent, projectRootPath);
|
|
const { retainProjects, ...result } = this.assignProjectToOpenedScriptInfo(info);
|
|
this.cleanupAfterOpeningFile(retainProjects);
|
|
this.telemetryOnOpenFile(info);
|
|
this.printProjects();
|
|
return result;
|
|
}
|
|
removeOrphanConfiguredProjects(toRetainConfiguredProjects) {
|
|
const toRemoveConfiguredProjects = new Map(this.configuredProjects);
|
|
const markOriginalProjectsAsUsed = (project) => {
|
|
if (!project.isOrphan() && project.originalConfiguredProjects) {
|
|
project.originalConfiguredProjects.forEach(
|
|
(_value, configuredProjectPath) => {
|
|
const project2 = this.getConfiguredProjectByCanonicalConfigFilePath(configuredProjectPath);
|
|
return project2 && retainConfiguredProject(project2);
|
|
}
|
|
);
|
|
}
|
|
};
|
|
if (toRetainConfiguredProjects) {
|
|
if (isArray(toRetainConfiguredProjects)) {
|
|
toRetainConfiguredProjects.forEach(retainConfiguredProject);
|
|
} else {
|
|
retainConfiguredProject(toRetainConfiguredProjects);
|
|
}
|
|
}
|
|
this.inferredProjects.forEach(markOriginalProjectsAsUsed);
|
|
this.externalProjects.forEach(markOriginalProjectsAsUsed);
|
|
this.configuredProjects.forEach((project) => {
|
|
if (project.hasOpenRef()) {
|
|
retainConfiguredProject(project);
|
|
} else if (toRemoveConfiguredProjects.has(project.canonicalConfigFilePath)) {
|
|
forEachReferencedProject(
|
|
project,
|
|
(ref) => isRetained(ref) && retainConfiguredProject(project)
|
|
);
|
|
}
|
|
});
|
|
toRemoveConfiguredProjects.forEach((project) => this.removeProject(project));
|
|
function isRetained(project) {
|
|
return project.hasOpenRef() || !toRemoveConfiguredProjects.has(project.canonicalConfigFilePath);
|
|
}
|
|
function retainConfiguredProject(project) {
|
|
if (toRemoveConfiguredProjects.delete(project.canonicalConfigFilePath)) {
|
|
markOriginalProjectsAsUsed(project);
|
|
forEachReferencedProject(project, retainConfiguredProject);
|
|
}
|
|
}
|
|
}
|
|
removeOrphanScriptInfos() {
|
|
const toRemoveScriptInfos = new Map(this.filenameToScriptInfo);
|
|
this.filenameToScriptInfo.forEach((info) => {
|
|
if (!info.isScriptOpen() && info.isOrphan() && !info.isContainedByBackgroundProject()) {
|
|
if (!info.sourceMapFilePath)
|
|
return;
|
|
let sourceInfos;
|
|
if (isString(info.sourceMapFilePath)) {
|
|
const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
|
|
sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
|
|
} else {
|
|
sourceInfos = info.sourceMapFilePath.sourceInfos;
|
|
}
|
|
if (!sourceInfos)
|
|
return;
|
|
if (!forEachKey(sourceInfos, (path) => {
|
|
const info2 = this.getScriptInfoForPath(path);
|
|
return !!info2 && (info2.isScriptOpen() || !info2.isOrphan());
|
|
})) {
|
|
return;
|
|
}
|
|
}
|
|
toRemoveScriptInfos.delete(info.path);
|
|
if (info.sourceMapFilePath) {
|
|
let sourceInfos;
|
|
if (isString(info.sourceMapFilePath)) {
|
|
toRemoveScriptInfos.delete(info.sourceMapFilePath);
|
|
const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
|
|
sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
|
|
} else {
|
|
sourceInfos = info.sourceMapFilePath.sourceInfos;
|
|
}
|
|
if (sourceInfos) {
|
|
sourceInfos.forEach((_value, path) => toRemoveScriptInfos.delete(path));
|
|
}
|
|
}
|
|
});
|
|
toRemoveScriptInfos.forEach((info) => {
|
|
this.stopWatchingScriptInfo(info);
|
|
this.deleteScriptInfo(info);
|
|
info.closeSourceMapFileWatcher();
|
|
});
|
|
}
|
|
telemetryOnOpenFile(scriptInfo) {
|
|
if (this.serverMode !== 0 /* Semantic */ || !this.eventHandler || !scriptInfo.isJavaScript() || !addToSeen(this.allJsFilesForOpenFileTelemetry, scriptInfo.path)) {
|
|
return;
|
|
}
|
|
const project = this.ensureDefaultProjectForFile(scriptInfo);
|
|
if (!project.languageServiceEnabled) {
|
|
return;
|
|
}
|
|
const sourceFile = project.getSourceFile(scriptInfo.path);
|
|
const checkJs = !!sourceFile && !!sourceFile.checkJsDirective;
|
|
this.eventHandler({ eventName: OpenFileInfoTelemetryEvent, data: { info: { checkJs } } });
|
|
}
|
|
closeClientFile(uncheckedFileName, skipAssignOrphanScriptInfosToInferredProject) {
|
|
const info = this.getScriptInfoForNormalizedPath(toNormalizedPath(uncheckedFileName));
|
|
const result = info ? this.closeOpenFile(info, skipAssignOrphanScriptInfosToInferredProject) : false;
|
|
if (!skipAssignOrphanScriptInfosToInferredProject) {
|
|
this.printProjects();
|
|
}
|
|
return result;
|
|
}
|
|
collectChanges(lastKnownProjectVersions, currentProjects, includeProjectReferenceRedirectInfo, result) {
|
|
for (const proj of currentProjects) {
|
|
const knownProject = find(lastKnownProjectVersions, (p) => p.projectName === proj.getProjectName());
|
|
result.push(proj.getChangesSinceVersion(knownProject && knownProject.version, includeProjectReferenceRedirectInfo));
|
|
}
|
|
}
|
|
synchronizeProjectList(knownProjects, includeProjectReferenceRedirectInfo) {
|
|
const files = [];
|
|
this.collectChanges(knownProjects, this.externalProjects, includeProjectReferenceRedirectInfo, files);
|
|
this.collectChanges(knownProjects, arrayFrom(this.configuredProjects.values()), includeProjectReferenceRedirectInfo, files);
|
|
this.collectChanges(knownProjects, this.inferredProjects, includeProjectReferenceRedirectInfo, files);
|
|
return files;
|
|
}
|
|
applyChangesInOpenFiles(openFiles, changedFiles, closedFiles) {
|
|
let openScriptInfos;
|
|
let assignOrphanScriptInfosToInferredProject = false;
|
|
if (openFiles) {
|
|
while (true) {
|
|
const iterResult = openFiles.next();
|
|
if (iterResult.done)
|
|
break;
|
|
const file = iterResult.value;
|
|
const info = this.getOrCreateOpenScriptInfo(
|
|
toNormalizedPath(file.fileName),
|
|
file.content,
|
|
tryConvertScriptKindName(file.scriptKind),
|
|
file.hasMixedContent,
|
|
file.projectRootPath ? toNormalizedPath(file.projectRootPath) : void 0
|
|
);
|
|
(openScriptInfos || (openScriptInfos = [])).push(info);
|
|
}
|
|
}
|
|
if (changedFiles) {
|
|
while (true) {
|
|
const iterResult = changedFiles.next();
|
|
if (iterResult.done)
|
|
break;
|
|
const file = iterResult.value;
|
|
const scriptInfo = this.getScriptInfo(file.fileName);
|
|
Debug.assert(!!scriptInfo);
|
|
this.applyChangesToFile(scriptInfo, file.changes);
|
|
}
|
|
}
|
|
if (closedFiles) {
|
|
for (const file of closedFiles) {
|
|
assignOrphanScriptInfosToInferredProject = this.closeClientFile(file, true) || assignOrphanScriptInfosToInferredProject;
|
|
}
|
|
}
|
|
let retainProjects;
|
|
if (openScriptInfos) {
|
|
retainProjects = flatMap(openScriptInfos, (info) => this.assignProjectToOpenedScriptInfo(info).retainProjects);
|
|
}
|
|
if (assignOrphanScriptInfosToInferredProject) {
|
|
this.assignOrphanScriptInfosToInferredProject();
|
|
}
|
|
if (openScriptInfos) {
|
|
this.cleanupAfterOpeningFile(retainProjects);
|
|
openScriptInfos.forEach((info) => this.telemetryOnOpenFile(info));
|
|
this.printProjects();
|
|
} else if (length(closedFiles)) {
|
|
this.printProjects();
|
|
}
|
|
}
|
|
applyChangesToFile(scriptInfo, changes) {
|
|
while (true) {
|
|
const iterResult = changes.next();
|
|
if (iterResult.done)
|
|
break;
|
|
const change = iterResult.value;
|
|
scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText);
|
|
}
|
|
}
|
|
closeConfiguredProjectReferencedFromExternalProject(configFile) {
|
|
const configuredProject = this.findConfiguredProjectByProjectName(configFile);
|
|
if (configuredProject) {
|
|
configuredProject.deleteExternalProjectReference();
|
|
if (!configuredProject.hasOpenRef()) {
|
|
this.removeProject(configuredProject);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
closeExternalProject(uncheckedFileName) {
|
|
const fileName = toNormalizedPath(uncheckedFileName);
|
|
const configFiles = this.externalProjectToConfiguredProjectMap.get(fileName);
|
|
if (configFiles) {
|
|
for (const configFile of configFiles) {
|
|
this.closeConfiguredProjectReferencedFromExternalProject(configFile);
|
|
}
|
|
this.externalProjectToConfiguredProjectMap.delete(fileName);
|
|
} else {
|
|
const externalProject = this.findExternalProjectByProjectName(uncheckedFileName);
|
|
if (externalProject) {
|
|
this.removeProject(externalProject);
|
|
}
|
|
}
|
|
}
|
|
openExternalProjects(projects) {
|
|
const projectsToClose = arrayToMap(this.externalProjects, (p) => p.getProjectName(), (_) => true);
|
|
forEachKey(this.externalProjectToConfiguredProjectMap, (externalProjectName) => {
|
|
projectsToClose.set(externalProjectName, true);
|
|
});
|
|
for (const externalProject of projects) {
|
|
this.openExternalProject(externalProject);
|
|
projectsToClose.delete(externalProject.projectFileName);
|
|
}
|
|
forEachKey(projectsToClose, (externalProjectName) => {
|
|
this.closeExternalProject(externalProjectName);
|
|
});
|
|
}
|
|
static escapeFilenameForRegex(filename) {
|
|
return filename.replace(this.filenameEscapeRegexp, "\\$&");
|
|
}
|
|
resetSafeList() {
|
|
this.safelist = defaultTypeSafeList;
|
|
}
|
|
applySafeList(proj) {
|
|
const { rootFiles } = proj;
|
|
const typeAcquisition = proj.typeAcquisition;
|
|
Debug.assert(!!typeAcquisition, "proj.typeAcquisition should be set by now");
|
|
if (typeAcquisition.enable === false || typeAcquisition.disableFilenameBasedTypeAcquisition) {
|
|
return [];
|
|
}
|
|
const typeAcqInclude = typeAcquisition.include || (typeAcquisition.include = []);
|
|
const excludeRules = [];
|
|
const normalizedNames = rootFiles.map((f) => normalizeSlashes(f.fileName));
|
|
const excludedFiles = [];
|
|
for (const name of Object.keys(this.safelist)) {
|
|
const rule2 = this.safelist[name];
|
|
for (const root of normalizedNames) {
|
|
if (rule2.match.test(root)) {
|
|
this.logger.info(`Excluding files based on rule ${name} matching file '${root}'`);
|
|
if (rule2.types) {
|
|
for (const type of rule2.types) {
|
|
if (typeAcqInclude.indexOf(type) < 0) {
|
|
typeAcqInclude.push(type);
|
|
}
|
|
}
|
|
}
|
|
if (rule2.exclude) {
|
|
for (const exclude of rule2.exclude) {
|
|
const processedRule = root.replace(rule2.match, (...groups) => {
|
|
return exclude.map((groupNumberOrString) => {
|
|
if (typeof groupNumberOrString === "number") {
|
|
if (!isString(groups[groupNumberOrString])) {
|
|
this.logger.info(`Incorrect RegExp specification in safelist rule ${name} - not enough groups`);
|
|
return "\\*";
|
|
}
|
|
return _ProjectService.escapeFilenameForRegex(groups[groupNumberOrString]);
|
|
}
|
|
return groupNumberOrString;
|
|
}).join("");
|
|
});
|
|
if (excludeRules.indexOf(processedRule) === -1) {
|
|
excludeRules.push(processedRule);
|
|
}
|
|
}
|
|
} else {
|
|
const escaped = _ProjectService.escapeFilenameForRegex(root);
|
|
if (excludeRules.indexOf(escaped) < 0) {
|
|
excludeRules.push(escaped);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const excludeRegexes = excludeRules.map((e) => new RegExp(e, "i"));
|
|
const filesToKeep = [];
|
|
for (let i = 0; i < proj.rootFiles.length; i++) {
|
|
if (excludeRegexes.some((re) => re.test(normalizedNames[i]))) {
|
|
excludedFiles.push(normalizedNames[i]);
|
|
} else {
|
|
let exclude = false;
|
|
if (typeAcquisition.enable || typeAcquisition.enableAutoDiscovery) {
|
|
const baseName = getBaseFileName(toFileNameLowerCase(normalizedNames[i]));
|
|
if (fileExtensionIs(baseName, "js")) {
|
|
const inferredTypingName = removeFileExtension(baseName);
|
|
const cleanedTypingName = removeMinAndVersionNumbers(inferredTypingName);
|
|
const typeName = this.legacySafelist.get(cleanedTypingName);
|
|
if (typeName !== void 0) {
|
|
this.logger.info(`Excluded '${normalizedNames[i]}' because it matched ${cleanedTypingName} from the legacy safelist`);
|
|
excludedFiles.push(normalizedNames[i]);
|
|
exclude = true;
|
|
if (typeAcqInclude.indexOf(typeName) < 0) {
|
|
typeAcqInclude.push(typeName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!exclude) {
|
|
if (/^.+[\.-]min\.js$/.test(normalizedNames[i])) {
|
|
excludedFiles.push(normalizedNames[i]);
|
|
} else {
|
|
filesToKeep.push(proj.rootFiles[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
proj.rootFiles = filesToKeep;
|
|
return excludedFiles;
|
|
}
|
|
openExternalProject(proj) {
|
|
if (proj.typingOptions && !proj.typeAcquisition) {
|
|
const typeAcquisition = convertEnableAutoDiscoveryToEnable(proj.typingOptions);
|
|
proj.typeAcquisition = typeAcquisition;
|
|
}
|
|
proj.typeAcquisition = proj.typeAcquisition || {};
|
|
proj.typeAcquisition.include = proj.typeAcquisition.include || [];
|
|
proj.typeAcquisition.exclude = proj.typeAcquisition.exclude || [];
|
|
if (proj.typeAcquisition.enable === void 0) {
|
|
proj.typeAcquisition.enable = hasNoTypeScriptSource(proj.rootFiles.map((f) => f.fileName));
|
|
}
|
|
const excludedFiles = this.applySafeList(proj);
|
|
let tsConfigFiles;
|
|
const rootFiles = [];
|
|
for (const file of proj.rootFiles) {
|
|
const normalized = toNormalizedPath(file.fileName);
|
|
if (getBaseConfigFileName(normalized)) {
|
|
if (this.serverMode === 0 /* Semantic */ && this.host.fileExists(normalized)) {
|
|
(tsConfigFiles || (tsConfigFiles = [])).push(normalized);
|
|
}
|
|
} else {
|
|
rootFiles.push(file);
|
|
}
|
|
}
|
|
if (tsConfigFiles) {
|
|
tsConfigFiles.sort();
|
|
}
|
|
const externalProject = this.findExternalProjectByProjectName(proj.projectFileName);
|
|
let exisingConfigFiles;
|
|
if (externalProject) {
|
|
externalProject.excludedFiles = excludedFiles;
|
|
if (!tsConfigFiles) {
|
|
const compilerOptions = convertCompilerOptions(proj.options);
|
|
const watchOptionsAndErrors = convertWatchOptions(proj.options, externalProject.getCurrentDirectory());
|
|
const lastFileExceededProgramSize = this.getFilenameForExceededTotalSizeLimitForNonTsFiles(proj.projectFileName, compilerOptions, proj.rootFiles, externalFilePropertyReader);
|
|
if (lastFileExceededProgramSize) {
|
|
externalProject.disableLanguageService(lastFileExceededProgramSize);
|
|
} else {
|
|
externalProject.enableLanguageService();
|
|
}
|
|
externalProject.setProjectErrors(watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.errors);
|
|
this.updateRootAndOptionsOfNonInferredProject(externalProject, proj.rootFiles, externalFilePropertyReader, compilerOptions, proj.typeAcquisition, proj.options.compileOnSave, watchOptionsAndErrors == null ? void 0 : watchOptionsAndErrors.watchOptions);
|
|
externalProject.updateGraph();
|
|
return;
|
|
}
|
|
this.closeExternalProject(proj.projectFileName);
|
|
} else if (this.externalProjectToConfiguredProjectMap.get(proj.projectFileName)) {
|
|
if (!tsConfigFiles) {
|
|
this.closeExternalProject(proj.projectFileName);
|
|
} else {
|
|
const oldConfigFiles = this.externalProjectToConfiguredProjectMap.get(proj.projectFileName);
|
|
let iNew = 0;
|
|
let iOld = 0;
|
|
while (iNew < tsConfigFiles.length && iOld < oldConfigFiles.length) {
|
|
const newConfig = tsConfigFiles[iNew];
|
|
const oldConfig = oldConfigFiles[iOld];
|
|
if (oldConfig < newConfig) {
|
|
this.closeConfiguredProjectReferencedFromExternalProject(oldConfig);
|
|
iOld++;
|
|
} else if (oldConfig > newConfig) {
|
|
iNew++;
|
|
} else {
|
|
(exisingConfigFiles || (exisingConfigFiles = [])).push(oldConfig);
|
|
iOld++;
|
|
iNew++;
|
|
}
|
|
}
|
|
for (let i = iOld; i < oldConfigFiles.length; i++) {
|
|
this.closeConfiguredProjectReferencedFromExternalProject(oldConfigFiles[i]);
|
|
}
|
|
}
|
|
}
|
|
if (tsConfigFiles) {
|
|
this.externalProjectToConfiguredProjectMap.set(proj.projectFileName, tsConfigFiles);
|
|
for (const tsconfigFile of tsConfigFiles) {
|
|
let project = this.findConfiguredProjectByProjectName(tsconfigFile);
|
|
if (!project) {
|
|
project = this.getHostPreferences().lazyConfiguredProjectsFromExternalProject ? this.createConfiguredProjectWithDelayLoad(tsconfigFile, `Creating configured project in external project: ${proj.projectFileName}`) : this.createLoadAndUpdateConfiguredProject(tsconfigFile, `Creating configured project in external project: ${proj.projectFileName}`);
|
|
}
|
|
if (project && !contains(exisingConfigFiles, tsconfigFile)) {
|
|
project.addExternalProjectReference();
|
|
}
|
|
}
|
|
} else {
|
|
this.externalProjectToConfiguredProjectMap.delete(proj.projectFileName);
|
|
const project = this.createExternalProject(proj.projectFileName, rootFiles, proj.options, proj.typeAcquisition, excludedFiles);
|
|
project.updateGraph();
|
|
}
|
|
}
|
|
hasDeferredExtension() {
|
|
for (const extension of this.hostConfiguration.extraFileExtensions) {
|
|
if (extension.scriptKind === 7 /* Deferred */) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
requestEnablePlugin(project, pluginConfigEntry, searchPaths, pluginConfigOverrides) {
|
|
var _a2;
|
|
if (!this.host.importPlugin && !this.host.require) {
|
|
this.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
|
|
return;
|
|
}
|
|
this.logger.info(`Enabling plugin ${pluginConfigEntry.name} from candidate paths: ${searchPaths.join(",")}`);
|
|
if (!pluginConfigEntry.name || parsePackageName(pluginConfigEntry.name).rest) {
|
|
this.logger.info(`Skipped loading plugin ${pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)} because only package name is allowed plugin name`);
|
|
return;
|
|
}
|
|
if (this.host.importPlugin) {
|
|
const importPromise = project.beginEnablePluginAsync(pluginConfigEntry, searchPaths, pluginConfigOverrides);
|
|
(_a2 = this.pendingPluginEnablements) != null ? _a2 : this.pendingPluginEnablements = /* @__PURE__ */ new Map();
|
|
let promises = this.pendingPluginEnablements.get(project);
|
|
if (!promises)
|
|
this.pendingPluginEnablements.set(project, promises = []);
|
|
promises.push(importPromise);
|
|
return;
|
|
}
|
|
project.endEnablePlugin(project.beginEnablePluginSync(pluginConfigEntry, searchPaths, pluginConfigOverrides));
|
|
}
|
|
hasNewPluginEnablementRequests() {
|
|
return !!this.pendingPluginEnablements;
|
|
}
|
|
hasPendingPluginEnablements() {
|
|
return !!this.currentPluginEnablementPromise;
|
|
}
|
|
async waitForPendingPlugins() {
|
|
while (this.currentPluginEnablementPromise) {
|
|
await this.currentPluginEnablementPromise;
|
|
}
|
|
}
|
|
enableRequestedPlugins() {
|
|
if (this.pendingPluginEnablements) {
|
|
void this.enableRequestedPluginsAsync();
|
|
}
|
|
}
|
|
async enableRequestedPluginsAsync() {
|
|
if (this.currentPluginEnablementPromise) {
|
|
await this.waitForPendingPlugins();
|
|
}
|
|
if (!this.pendingPluginEnablements) {
|
|
return;
|
|
}
|
|
const entries = arrayFrom(this.pendingPluginEnablements.entries());
|
|
this.pendingPluginEnablements = void 0;
|
|
this.currentPluginEnablementPromise = this.enableRequestedPluginsWorker(entries);
|
|
await this.currentPluginEnablementPromise;
|
|
}
|
|
async enableRequestedPluginsWorker(pendingPlugins) {
|
|
Debug.assert(this.currentPluginEnablementPromise === void 0);
|
|
await Promise.all(map(pendingPlugins, ([project, promises]) => this.enableRequestedPluginsForProjectAsync(project, promises)));
|
|
this.currentPluginEnablementPromise = void 0;
|
|
this.sendProjectsUpdatedInBackgroundEvent();
|
|
}
|
|
async enableRequestedPluginsForProjectAsync(project, promises) {
|
|
const results = await Promise.all(promises);
|
|
if (project.isClosed()) {
|
|
return;
|
|
}
|
|
for (const result of results) {
|
|
project.endEnablePlugin(result);
|
|
}
|
|
this.delayUpdateProjectGraph(project);
|
|
}
|
|
configurePlugin(args) {
|
|
this.forEachEnabledProject((project) => project.onPluginConfigurationChanged(args.pluginName, args.configuration));
|
|
this.currentPluginConfigOverrides = this.currentPluginConfigOverrides || /* @__PURE__ */ new Map();
|
|
this.currentPluginConfigOverrides.set(args.pluginName, args.configuration);
|
|
}
|
|
getPackageJsonsVisibleToFile(fileName, rootDir) {
|
|
const packageJsonCache = this.packageJsonCache;
|
|
const rootPath = rootDir && this.toPath(rootDir);
|
|
const filePath = this.toPath(fileName);
|
|
const result = [];
|
|
const processDirectory = (directory) => {
|
|
switch (packageJsonCache.directoryHasPackageJson(directory)) {
|
|
case 3 /* Maybe */:
|
|
packageJsonCache.searchDirectoryAndAncestors(directory);
|
|
return processDirectory(directory);
|
|
case -1 /* True */:
|
|
const packageJsonFileName = combinePaths(directory, "package.json");
|
|
this.watchPackageJsonFile(packageJsonFileName);
|
|
const info = packageJsonCache.getInDirectory(directory);
|
|
if (info)
|
|
result.push(info);
|
|
}
|
|
if (rootPath && rootPath === directory) {
|
|
return true;
|
|
}
|
|
};
|
|
forEachAncestorDirectory(getDirectoryPath(filePath), processDirectory);
|
|
return result;
|
|
}
|
|
getNearestAncestorDirectoryWithPackageJson(fileName) {
|
|
return forEachAncestorDirectory(fileName, (directory) => {
|
|
switch (this.packageJsonCache.directoryHasPackageJson(this.toPath(directory))) {
|
|
case -1 /* True */:
|
|
return directory;
|
|
case 0 /* False */:
|
|
return void 0;
|
|
case 3 /* Maybe */:
|
|
return this.host.fileExists(combinePaths(directory, "package.json")) ? directory : void 0;
|
|
}
|
|
});
|
|
}
|
|
watchPackageJsonFile(path) {
|
|
const watchers = this.packageJsonFilesMap || (this.packageJsonFilesMap = /* @__PURE__ */ new Map());
|
|
if (!watchers.has(path)) {
|
|
this.invalidateProjectPackageJson(path);
|
|
watchers.set(path, this.watchFactory.watchFile(
|
|
path,
|
|
(fileName, eventKind) => {
|
|
const path2 = this.toPath(fileName);
|
|
switch (eventKind) {
|
|
case 0 /* Created */:
|
|
return Debug.fail();
|
|
case 1 /* Changed */:
|
|
this.packageJsonCache.addOrUpdate(path2);
|
|
this.invalidateProjectPackageJson(path2);
|
|
break;
|
|
case 2 /* Deleted */:
|
|
this.packageJsonCache.delete(path2);
|
|
this.invalidateProjectPackageJson(path2);
|
|
watchers.get(path2).close();
|
|
watchers.delete(path2);
|
|
}
|
|
},
|
|
250 /* Low */,
|
|
this.hostConfiguration.watchOptions,
|
|
WatchType.PackageJson
|
|
));
|
|
}
|
|
}
|
|
onAddPackageJson(path) {
|
|
this.packageJsonCache.addOrUpdate(path);
|
|
this.watchPackageJsonFile(path);
|
|
}
|
|
includePackageJsonAutoImports() {
|
|
switch (this.hostConfiguration.preferences.includePackageJsonAutoImports) {
|
|
case "on":
|
|
return 1 /* On */;
|
|
case "off":
|
|
return 0 /* Off */;
|
|
default:
|
|
return 2 /* Auto */;
|
|
}
|
|
}
|
|
invalidateProjectPackageJson(packageJsonPath) {
|
|
this.configuredProjects.forEach(invalidate);
|
|
this.inferredProjects.forEach(invalidate);
|
|
this.externalProjects.forEach(invalidate);
|
|
function invalidate(project) {
|
|
if (packageJsonPath) {
|
|
project.onPackageJsonChange(packageJsonPath);
|
|
} else {
|
|
project.onAutoImportProviderSettingsChanged();
|
|
}
|
|
}
|
|
}
|
|
getIncompleteCompletionsCache() {
|
|
return this.incompleteCompletionsCache || (this.incompleteCompletionsCache = createIncompleteCompletionsCache());
|
|
}
|
|
};
|
|
var ProjectService3 = _ProjectService;
|
|
ProjectService3.filenameEscapeRegexp = /[-\/\\^$*+?.()|[\]{}]/g;
|
|
function createIncompleteCompletionsCache() {
|
|
let info;
|
|
return {
|
|
get() {
|
|
return info;
|
|
},
|
|
set(newInfo) {
|
|
info = newInfo;
|
|
},
|
|
clear() {
|
|
info = void 0;
|
|
}
|
|
};
|
|
}
|
|
function isConfigFile(config) {
|
|
return config.kind !== void 0;
|
|
}
|
|
function printProjectWithoutFileNames(project) {
|
|
project.print(false);
|
|
}
|
|
|
|
// src/server/moduleSpecifierCache.ts
|
|
function createModuleSpecifierCache(host) {
|
|
let containedNodeModulesWatchers;
|
|
let cache;
|
|
let currentKey;
|
|
const result = {
|
|
get(fromFileName, toFileName2, preferences, options) {
|
|
if (!cache || currentKey !== key(fromFileName, preferences, options))
|
|
return void 0;
|
|
return cache.get(toFileName2);
|
|
},
|
|
set(fromFileName, toFileName2, preferences, options, modulePaths, moduleSpecifiers) {
|
|
ensureCache(fromFileName, preferences, options).set(toFileName2, createInfo(modulePaths, moduleSpecifiers, false));
|
|
if (moduleSpecifiers) {
|
|
for (const p of modulePaths) {
|
|
if (p.isInNodeModules) {
|
|
const nodeModulesPath = p.path.substring(0, p.path.indexOf(nodeModulesPathPart) + nodeModulesPathPart.length - 1);
|
|
if (!(containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.has(nodeModulesPath))) {
|
|
(containedNodeModulesWatchers || (containedNodeModulesWatchers = /* @__PURE__ */ new Map())).set(
|
|
nodeModulesPath,
|
|
host.watchNodeModulesForPackageJsonChanges(nodeModulesPath)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
setModulePaths(fromFileName, toFileName2, preferences, options, modulePaths) {
|
|
const cache2 = ensureCache(fromFileName, preferences, options);
|
|
const info = cache2.get(toFileName2);
|
|
if (info) {
|
|
info.modulePaths = modulePaths;
|
|
} else {
|
|
cache2.set(toFileName2, createInfo(modulePaths, void 0, void 0));
|
|
}
|
|
},
|
|
setBlockedByPackageJsonDependencies(fromFileName, toFileName2, preferences, options, isBlockedByPackageJsonDependencies) {
|
|
const cache2 = ensureCache(fromFileName, preferences, options);
|
|
const info = cache2.get(toFileName2);
|
|
if (info) {
|
|
info.isBlockedByPackageJsonDependencies = isBlockedByPackageJsonDependencies;
|
|
} else {
|
|
cache2.set(toFileName2, createInfo(void 0, void 0, isBlockedByPackageJsonDependencies));
|
|
}
|
|
},
|
|
clear() {
|
|
containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.forEach((watcher) => watcher.close());
|
|
cache == null ? void 0 : cache.clear();
|
|
containedNodeModulesWatchers == null ? void 0 : containedNodeModulesWatchers.clear();
|
|
currentKey = void 0;
|
|
},
|
|
count() {
|
|
return cache ? cache.size : 0;
|
|
}
|
|
};
|
|
if (Debug.isDebugging) {
|
|
Object.defineProperty(result, "__cache", { get: () => cache });
|
|
}
|
|
return result;
|
|
function ensureCache(fromFileName, preferences, options) {
|
|
const newKey = key(fromFileName, preferences, options);
|
|
if (cache && currentKey !== newKey) {
|
|
result.clear();
|
|
}
|
|
currentKey = newKey;
|
|
return cache || (cache = /* @__PURE__ */ new Map());
|
|
}
|
|
function key(fromFileName, preferences, options) {
|
|
return `${fromFileName},${preferences.importModuleSpecifierEnding},${preferences.importModuleSpecifierPreference},${options.overrideImportMode}`;
|
|
}
|
|
function createInfo(modulePaths, moduleSpecifiers, isBlockedByPackageJsonDependencies) {
|
|
return { modulePaths, moduleSpecifiers, isBlockedByPackageJsonDependencies };
|
|
}
|
|
}
|
|
|
|
// src/server/packageJsonCache.ts
|
|
function createPackageJsonCache(host) {
|
|
const packageJsons = /* @__PURE__ */ new Map();
|
|
const directoriesWithoutPackageJson = /* @__PURE__ */ new Map();
|
|
return {
|
|
addOrUpdate,
|
|
forEach: packageJsons.forEach.bind(packageJsons),
|
|
get: packageJsons.get.bind(packageJsons),
|
|
delete: (fileName) => {
|
|
packageJsons.delete(fileName);
|
|
directoriesWithoutPackageJson.set(getDirectoryPath(fileName), true);
|
|
},
|
|
getInDirectory: (directory) => {
|
|
return packageJsons.get(combinePaths(directory, "package.json")) || void 0;
|
|
},
|
|
directoryHasPackageJson,
|
|
searchDirectoryAndAncestors: (directory) => {
|
|
forEachAncestorDirectory(directory, (ancestor) => {
|
|
if (directoryHasPackageJson(ancestor) !== 3 /* Maybe */) {
|
|
return true;
|
|
}
|
|
const packageJsonFileName = host.toPath(combinePaths(ancestor, "package.json"));
|
|
if (tryFileExists(host, packageJsonFileName)) {
|
|
addOrUpdate(packageJsonFileName);
|
|
} else {
|
|
directoriesWithoutPackageJson.set(ancestor, true);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
function addOrUpdate(fileName) {
|
|
const packageJsonInfo = Debug.checkDefined(createPackageJsonInfo(fileName, host.host));
|
|
packageJsons.set(fileName, packageJsonInfo);
|
|
directoriesWithoutPackageJson.delete(getDirectoryPath(fileName));
|
|
}
|
|
function directoryHasPackageJson(directory) {
|
|
return packageJsons.has(combinePaths(directory, "package.json")) ? -1 /* True */ : directoriesWithoutPackageJson.has(directory) ? 0 /* False */ : 3 /* Maybe */;
|
|
}
|
|
}
|
|
|
|
// src/server/session.ts
|
|
var nullCancellationToken = {
|
|
isCancellationRequested: () => false,
|
|
setRequest: () => void 0,
|
|
resetRequest: () => void 0
|
|
};
|
|
function hrTimeToMilliseconds(time) {
|
|
const seconds = time[0];
|
|
const nanoseconds = time[1];
|
|
return (1e9 * seconds + nanoseconds) / 1e6;
|
|
}
|
|
function isDeclarationFileInJSOnlyNonConfiguredProject(project, file) {
|
|
if ((isInferredProject(project) || isExternalProject(project)) && project.isJsOnlyProject()) {
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
return scriptInfo && !scriptInfo.isJavaScript();
|
|
}
|
|
return false;
|
|
}
|
|
function dtsChangeCanAffectEmit(compilationSettings) {
|
|
return getEmitDeclarations(compilationSettings) || !!compilationSettings.emitDecoratorMetadata;
|
|
}
|
|
function formatDiag(fileName, project, diag2) {
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(fileName);
|
|
return {
|
|
start: scriptInfo.positionToLineOffset(diag2.start),
|
|
end: scriptInfo.positionToLineOffset(diag2.start + diag2.length),
|
|
text: flattenDiagnosticMessageText(diag2.messageText, "\n"),
|
|
code: diag2.code,
|
|
category: diagnosticCategoryName(diag2),
|
|
reportsUnnecessary: diag2.reportsUnnecessary,
|
|
reportsDeprecated: diag2.reportsDeprecated,
|
|
source: diag2.source,
|
|
relatedInformation: map(diag2.relatedInformation, formatRelatedInformation)
|
|
};
|
|
}
|
|
function formatRelatedInformation(info) {
|
|
if (!info.file) {
|
|
return {
|
|
message: flattenDiagnosticMessageText(info.messageText, "\n"),
|
|
category: diagnosticCategoryName(info),
|
|
code: info.code
|
|
};
|
|
}
|
|
return {
|
|
span: {
|
|
start: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start)),
|
|
end: convertToLocation(getLineAndCharacterOfPosition(info.file, info.start + info.length)),
|
|
file: info.file.fileName
|
|
},
|
|
message: flattenDiagnosticMessageText(info.messageText, "\n"),
|
|
category: diagnosticCategoryName(info),
|
|
code: info.code
|
|
};
|
|
}
|
|
function convertToLocation(lineAndCharacter) {
|
|
return { line: lineAndCharacter.line + 1, offset: lineAndCharacter.character + 1 };
|
|
}
|
|
function formatDiagnosticToProtocol(diag2, includeFileName) {
|
|
const start2 = diag2.file && convertToLocation(getLineAndCharacterOfPosition(diag2.file, diag2.start));
|
|
const end = diag2.file && convertToLocation(getLineAndCharacterOfPosition(diag2.file, diag2.start + diag2.length));
|
|
const text = flattenDiagnosticMessageText(diag2.messageText, "\n");
|
|
const { code, source } = diag2;
|
|
const category = diagnosticCategoryName(diag2);
|
|
const common = {
|
|
start: start2,
|
|
end,
|
|
text,
|
|
code,
|
|
category,
|
|
reportsUnnecessary: diag2.reportsUnnecessary,
|
|
reportsDeprecated: diag2.reportsDeprecated,
|
|
source,
|
|
relatedInformation: map(diag2.relatedInformation, formatRelatedInformation)
|
|
};
|
|
return includeFileName ? { ...common, fileName: diag2.file && diag2.file.fileName } : common;
|
|
}
|
|
function allEditsBeforePos(edits, pos) {
|
|
return edits.every((edit) => textSpanEnd(edit.span) < pos);
|
|
}
|
|
var CommandNames = ts_server_protocol_exports.CommandTypes;
|
|
function formatMessage2(msg, logger, byteLength, newLine) {
|
|
const verboseLogging = logger.hasLevel(3 /* verbose */);
|
|
const json = JSON.stringify(msg);
|
|
if (verboseLogging) {
|
|
logger.info(`${msg.type}:${indent2(json)}`);
|
|
}
|
|
const len = byteLength(json, "utf8");
|
|
return `Content-Length: ${1 + len}\r
|
|
\r
|
|
${json}${newLine}`;
|
|
}
|
|
var MultistepOperation = class {
|
|
constructor(operationHost) {
|
|
this.operationHost = operationHost;
|
|
}
|
|
startNew(action) {
|
|
this.complete();
|
|
this.requestId = this.operationHost.getCurrentRequestId();
|
|
this.executeAction(action);
|
|
}
|
|
complete() {
|
|
if (this.requestId !== void 0) {
|
|
this.operationHost.sendRequestCompletedEvent(this.requestId);
|
|
this.requestId = void 0;
|
|
}
|
|
this.setTimerHandle(void 0);
|
|
this.setImmediateId(void 0);
|
|
}
|
|
immediate(action) {
|
|
const requestId = this.requestId;
|
|
Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "immediate: incorrect request id");
|
|
this.setImmediateId(this.operationHost.getServerHost().setImmediate(() => {
|
|
this.immediateId = void 0;
|
|
this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action));
|
|
}));
|
|
}
|
|
delay(ms, action) {
|
|
const requestId = this.requestId;
|
|
Debug.assert(requestId === this.operationHost.getCurrentRequestId(), "delay: incorrect request id");
|
|
this.setTimerHandle(this.operationHost.getServerHost().setTimeout(() => {
|
|
this.timerHandle = void 0;
|
|
this.operationHost.executeWithRequestId(requestId, () => this.executeAction(action));
|
|
}, ms));
|
|
}
|
|
executeAction(action) {
|
|
var _a2, _b, _c, _d, _e, _f;
|
|
let stop = false;
|
|
try {
|
|
if (this.operationHost.isCancellationRequested()) {
|
|
stop = true;
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId, early: true });
|
|
} else {
|
|
(_b = tracing) == null ? void 0 : _b.push(tracing.Phase.Session, "stepAction", { seq: this.requestId });
|
|
action(this);
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
}
|
|
} catch (e) {
|
|
(_d = tracing) == null ? void 0 : _d.popAll();
|
|
stop = true;
|
|
if (e instanceof OperationCanceledException) {
|
|
(_e = tracing) == null ? void 0 : _e.instant(tracing.Phase.Session, "stepCanceled", { seq: this.requestId });
|
|
} else {
|
|
(_f = tracing) == null ? void 0 : _f.instant(tracing.Phase.Session, "stepError", { seq: this.requestId, message: e.message });
|
|
this.operationHost.logError(e, `delayed processing of request ${this.requestId}`);
|
|
}
|
|
}
|
|
if (stop || !this.hasPendingWork()) {
|
|
this.complete();
|
|
}
|
|
}
|
|
setTimerHandle(timerHandle) {
|
|
if (this.timerHandle !== void 0) {
|
|
this.operationHost.getServerHost().clearTimeout(this.timerHandle);
|
|
}
|
|
this.timerHandle = timerHandle;
|
|
}
|
|
setImmediateId(immediateId) {
|
|
if (this.immediateId !== void 0) {
|
|
this.operationHost.getServerHost().clearImmediate(this.immediateId);
|
|
}
|
|
this.immediateId = immediateId;
|
|
}
|
|
hasPendingWork() {
|
|
return !!this.timerHandle || !!this.immediateId;
|
|
}
|
|
};
|
|
function toEvent(eventName, body) {
|
|
return {
|
|
seq: 0,
|
|
type: "event",
|
|
event: eventName,
|
|
body
|
|
};
|
|
}
|
|
function combineProjectOutput(defaultValue, getValue, projects, action) {
|
|
const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, (project) => action(project, defaultValue));
|
|
if (!isArray(projects) && projects.symLinkedProjects) {
|
|
projects.symLinkedProjects.forEach((projects2, path) => {
|
|
const value = getValue(path);
|
|
outputs.push(...flatMap(projects2, (project) => action(project, value)));
|
|
});
|
|
}
|
|
return deduplicate(outputs, equateValues);
|
|
}
|
|
function createDocumentSpanSet() {
|
|
return createSet(({ textSpan }) => textSpan.start + 100003 * textSpan.length, documentSpansEqual);
|
|
}
|
|
function getRenameLocationsWorker(projects, defaultProject, initialLocation, findInStrings, findInComments, { providePrefixAndSuffixTextForRename }) {
|
|
const perProjectResults = getPerProjectReferences(
|
|
projects,
|
|
defaultProject,
|
|
initialLocation,
|
|
true,
|
|
(project, position) => project.getLanguageService().findRenameLocations(position.fileName, position.pos, findInStrings, findInComments, providePrefixAndSuffixTextForRename),
|
|
(renameLocation, cb) => cb(documentSpanLocation(renameLocation))
|
|
);
|
|
if (isArray(perProjectResults)) {
|
|
return perProjectResults;
|
|
}
|
|
const results = [];
|
|
const seen = createDocumentSpanSet();
|
|
perProjectResults.forEach((projectResults, project) => {
|
|
for (const result of projectResults) {
|
|
if (!seen.has(result) && !getMappedLocationForProject(documentSpanLocation(result), project)) {
|
|
results.push(result);
|
|
seen.add(result);
|
|
}
|
|
}
|
|
});
|
|
return results;
|
|
}
|
|
function getDefinitionLocation(defaultProject, initialLocation, isForRename) {
|
|
const infos = defaultProject.getLanguageService().getDefinitionAtPosition(initialLocation.fileName, initialLocation.pos, false, isForRename);
|
|
const info = infos && firstOrUndefined(infos);
|
|
return info && !info.isLocal ? { fileName: info.fileName, pos: info.textSpan.start } : void 0;
|
|
}
|
|
function getReferencesWorker(projects, defaultProject, initialLocation, logger) {
|
|
var _a2, _b;
|
|
const perProjectResults = getPerProjectReferences(
|
|
projects,
|
|
defaultProject,
|
|
initialLocation,
|
|
false,
|
|
(project, position) => {
|
|
logger.info(`Finding references to ${position.fileName} position ${position.pos} in project ${project.getProjectName()}`);
|
|
return project.getLanguageService().findReferences(position.fileName, position.pos);
|
|
},
|
|
(referencedSymbol, cb) => {
|
|
cb(documentSpanLocation(referencedSymbol.definition));
|
|
for (const ref of referencedSymbol.references) {
|
|
cb(documentSpanLocation(ref));
|
|
}
|
|
}
|
|
);
|
|
if (isArray(perProjectResults)) {
|
|
return perProjectResults;
|
|
}
|
|
const defaultProjectResults = perProjectResults.get(defaultProject);
|
|
if (((_b = (_a2 = defaultProjectResults == null ? void 0 : defaultProjectResults[0]) == null ? void 0 : _a2.references[0]) == null ? void 0 : _b.isDefinition) === void 0) {
|
|
perProjectResults.forEach((projectResults) => {
|
|
for (const referencedSymbol of projectResults) {
|
|
for (const ref of referencedSymbol.references) {
|
|
delete ref.isDefinition;
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
const knownSymbolSpans = createDocumentSpanSet();
|
|
for (const referencedSymbol of defaultProjectResults) {
|
|
for (const ref of referencedSymbol.references) {
|
|
if (ref.isDefinition) {
|
|
knownSymbolSpans.add(ref);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
const updatedProjects = /* @__PURE__ */ new Set();
|
|
while (true) {
|
|
let progress = false;
|
|
perProjectResults.forEach((referencedSymbols, project) => {
|
|
if (updatedProjects.has(project))
|
|
return;
|
|
const updated = project.getLanguageService().updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans);
|
|
if (updated) {
|
|
updatedProjects.add(project);
|
|
progress = true;
|
|
}
|
|
});
|
|
if (!progress)
|
|
break;
|
|
}
|
|
perProjectResults.forEach((referencedSymbols, project) => {
|
|
if (updatedProjects.has(project))
|
|
return;
|
|
for (const referencedSymbol of referencedSymbols) {
|
|
for (const ref of referencedSymbol.references) {
|
|
ref.isDefinition = false;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
const results = [];
|
|
const seenRefs = createDocumentSpanSet();
|
|
perProjectResults.forEach((projectResults, project) => {
|
|
for (const referencedSymbol of projectResults) {
|
|
const mappedDefinitionFile = getMappedLocationForProject(documentSpanLocation(referencedSymbol.definition), project);
|
|
const definition = mappedDefinitionFile === void 0 ? referencedSymbol.definition : {
|
|
...referencedSymbol.definition,
|
|
textSpan: createTextSpan(mappedDefinitionFile.pos, referencedSymbol.definition.textSpan.length),
|
|
fileName: mappedDefinitionFile.fileName,
|
|
contextSpan: getMappedContextSpanForProject(referencedSymbol.definition, project)
|
|
};
|
|
let symbolToAddTo = find(results, (o) => documentSpansEqual(o.definition, definition));
|
|
if (!symbolToAddTo) {
|
|
symbolToAddTo = { definition, references: [] };
|
|
results.push(symbolToAddTo);
|
|
}
|
|
for (const ref of referencedSymbol.references) {
|
|
if (!seenRefs.has(ref) && !getMappedLocationForProject(documentSpanLocation(ref), project)) {
|
|
seenRefs.add(ref);
|
|
symbolToAddTo.references.push(ref);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return results.filter((o) => o.references.length !== 0);
|
|
}
|
|
function forEachProjectInProjects(projects, path, cb) {
|
|
for (const project of isArray(projects) ? projects : projects.projects) {
|
|
cb(project, path);
|
|
}
|
|
if (!isArray(projects) && projects.symLinkedProjects) {
|
|
projects.symLinkedProjects.forEach((symlinkedProjects, symlinkedPath) => {
|
|
for (const project of symlinkedProjects) {
|
|
cb(project, symlinkedPath);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
function getPerProjectReferences(projects, defaultProject, initialLocation, isForRename, getResultsForPosition, forPositionInResult) {
|
|
const resultsMap = /* @__PURE__ */ new Map();
|
|
const queue = createQueue();
|
|
queue.enqueue({ project: defaultProject, location: initialLocation });
|
|
forEachProjectInProjects(projects, initialLocation.fileName, (project, path) => {
|
|
const location2 = { fileName: path, pos: initialLocation.pos };
|
|
queue.enqueue({ project, location: location2 });
|
|
});
|
|
const projectService = defaultProject.projectService;
|
|
const cancellationToken = defaultProject.getCancellationToken();
|
|
const defaultDefinition = getDefinitionLocation(defaultProject, initialLocation, isForRename);
|
|
const getGeneratedDefinition = memoize(() => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ? defaultDefinition : defaultProject.getLanguageService().getSourceMapper().tryGetGeneratedPosition(defaultDefinition));
|
|
const getSourceDefinition = memoize(() => defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ? defaultDefinition : defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition));
|
|
const searchedProjectKeys = /* @__PURE__ */ new Set();
|
|
onCancellation:
|
|
while (!queue.isEmpty()) {
|
|
while (!queue.isEmpty()) {
|
|
if (cancellationToken.isCancellationRequested())
|
|
break onCancellation;
|
|
const { project, location: location2 } = queue.dequeue();
|
|
if (resultsMap.has(project))
|
|
continue;
|
|
if (isLocationProjectReferenceRedirect(project, location2))
|
|
continue;
|
|
const projectResults = searchPosition(project, location2);
|
|
resultsMap.set(project, projectResults != null ? projectResults : emptyArray2);
|
|
searchedProjectKeys.add(getProjectKey(project));
|
|
}
|
|
if (defaultDefinition) {
|
|
projectService.loadAncestorProjectTree(searchedProjectKeys);
|
|
projectService.forEachEnabledProject((project) => {
|
|
if (cancellationToken.isCancellationRequested())
|
|
return;
|
|
if (resultsMap.has(project))
|
|
return;
|
|
const location2 = mapDefinitionInProject(defaultDefinition, project, getGeneratedDefinition, getSourceDefinition);
|
|
if (location2) {
|
|
queue.enqueue({ project, location: location2 });
|
|
}
|
|
});
|
|
}
|
|
}
|
|
if (resultsMap.size === 1) {
|
|
const it = resultsMap.values().next();
|
|
Debug.assert(!it.done);
|
|
return it.value;
|
|
}
|
|
return resultsMap;
|
|
function searchPosition(project, location2) {
|
|
const projectResults = getResultsForPosition(project, location2);
|
|
if (!projectResults)
|
|
return void 0;
|
|
for (const result of projectResults) {
|
|
forPositionInResult(result, (position) => {
|
|
const originalLocation = projectService.getOriginalLocationEnsuringConfiguredProject(project, position);
|
|
if (!originalLocation)
|
|
return;
|
|
const originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName);
|
|
for (const project2 of originalScriptInfo.containingProjects) {
|
|
if (!project2.isOrphan() && !resultsMap.has(project2)) {
|
|
queue.enqueue({ project: project2, location: originalLocation });
|
|
}
|
|
}
|
|
const symlinkedProjectsMap = projectService.getSymlinkedProjects(originalScriptInfo);
|
|
if (symlinkedProjectsMap) {
|
|
symlinkedProjectsMap.forEach((symlinkedProjects, symlinkedPath) => {
|
|
for (const symlinkedProject of symlinkedProjects) {
|
|
if (!symlinkedProject.isOrphan() && !resultsMap.has(symlinkedProject)) {
|
|
queue.enqueue({ project: symlinkedProject, location: { fileName: symlinkedPath, pos: originalLocation.pos } });
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
return projectResults;
|
|
}
|
|
}
|
|
function mapDefinitionInProject(definition, project, getGeneratedDefinition, getSourceDefinition) {
|
|
if (project.containsFile(toNormalizedPath(definition.fileName)) && !isLocationProjectReferenceRedirect(project, definition)) {
|
|
return definition;
|
|
}
|
|
const generatedDefinition = getGeneratedDefinition();
|
|
if (generatedDefinition && project.containsFile(toNormalizedPath(generatedDefinition.fileName)))
|
|
return generatedDefinition;
|
|
const sourceDefinition = getSourceDefinition();
|
|
return sourceDefinition && project.containsFile(toNormalizedPath(sourceDefinition.fileName)) ? sourceDefinition : void 0;
|
|
}
|
|
function isLocationProjectReferenceRedirect(project, location2) {
|
|
if (!location2)
|
|
return false;
|
|
const program = project.getLanguageService().getProgram();
|
|
if (!program)
|
|
return false;
|
|
const sourceFile = program.getSourceFile(location2.fileName);
|
|
return !!sourceFile && sourceFile.resolvedPath !== sourceFile.path && sourceFile.resolvedPath !== project.toPath(location2.fileName);
|
|
}
|
|
function getProjectKey(project) {
|
|
return isConfiguredProject(project) ? project.canonicalConfigFilePath : project.getProjectName();
|
|
}
|
|
function documentSpanLocation({ fileName, textSpan }) {
|
|
return { fileName, pos: textSpan.start };
|
|
}
|
|
function getMappedLocationForProject(location2, project) {
|
|
return getMappedLocation(location2, project.getSourceMapper(), (p) => project.projectService.fileExists(p));
|
|
}
|
|
function getMappedDocumentSpanForProject(documentSpan, project) {
|
|
return getMappedDocumentSpan(documentSpan, project.getSourceMapper(), (p) => project.projectService.fileExists(p));
|
|
}
|
|
function getMappedContextSpanForProject(documentSpan, project) {
|
|
return getMappedContextSpan(documentSpan, project.getSourceMapper(), (p) => project.projectService.fileExists(p));
|
|
}
|
|
var invalidPartialSemanticModeCommands = [
|
|
CommandNames.OpenExternalProject,
|
|
CommandNames.OpenExternalProjects,
|
|
CommandNames.CloseExternalProject,
|
|
CommandNames.SynchronizeProjectList,
|
|
CommandNames.EmitOutput,
|
|
CommandNames.CompileOnSaveAffectedFileList,
|
|
CommandNames.CompileOnSaveEmitFile,
|
|
CommandNames.CompilerOptionsDiagnosticsFull,
|
|
CommandNames.EncodedSemanticClassificationsFull,
|
|
CommandNames.SemanticDiagnosticsSync,
|
|
CommandNames.SuggestionDiagnosticsSync,
|
|
CommandNames.GeterrForProject,
|
|
CommandNames.Reload,
|
|
CommandNames.ReloadProjects,
|
|
CommandNames.GetCodeFixes,
|
|
CommandNames.GetCodeFixesFull,
|
|
CommandNames.GetCombinedCodeFix,
|
|
CommandNames.GetCombinedCodeFixFull,
|
|
CommandNames.ApplyCodeActionCommand,
|
|
CommandNames.GetSupportedCodeFixes,
|
|
CommandNames.GetApplicableRefactors,
|
|
CommandNames.GetEditsForRefactor,
|
|
CommandNames.GetEditsForRefactorFull,
|
|
CommandNames.OrganizeImports,
|
|
CommandNames.OrganizeImportsFull,
|
|
CommandNames.GetEditsForFileRename,
|
|
CommandNames.GetEditsForFileRenameFull,
|
|
CommandNames.PrepareCallHierarchy,
|
|
CommandNames.ProvideCallHierarchyIncomingCalls,
|
|
CommandNames.ProvideCallHierarchyOutgoingCalls
|
|
];
|
|
var invalidSyntacticModeCommands = [
|
|
...invalidPartialSemanticModeCommands,
|
|
CommandNames.Definition,
|
|
CommandNames.DefinitionFull,
|
|
CommandNames.DefinitionAndBoundSpan,
|
|
CommandNames.DefinitionAndBoundSpanFull,
|
|
CommandNames.TypeDefinition,
|
|
CommandNames.Implementation,
|
|
CommandNames.ImplementationFull,
|
|
CommandNames.References,
|
|
CommandNames.ReferencesFull,
|
|
CommandNames.Rename,
|
|
CommandNames.RenameLocationsFull,
|
|
CommandNames.RenameInfoFull,
|
|
CommandNames.Quickinfo,
|
|
CommandNames.QuickinfoFull,
|
|
CommandNames.CompletionInfo,
|
|
CommandNames.Completions,
|
|
CommandNames.CompletionsFull,
|
|
CommandNames.CompletionDetails,
|
|
CommandNames.CompletionDetailsFull,
|
|
CommandNames.SignatureHelp,
|
|
CommandNames.SignatureHelpFull,
|
|
CommandNames.Navto,
|
|
CommandNames.NavtoFull,
|
|
CommandNames.Occurrences,
|
|
CommandNames.DocumentHighlights,
|
|
CommandNames.DocumentHighlightsFull
|
|
];
|
|
var Session3 = class {
|
|
constructor(opts) {
|
|
this.changeSeq = 0;
|
|
this.handlers = new Map(getEntries({
|
|
[CommandNames.Status]: () => {
|
|
const response = { version };
|
|
return this.requiredResponse(response);
|
|
},
|
|
[CommandNames.OpenExternalProject]: (request) => {
|
|
this.projectService.openExternalProject(request.arguments);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.OpenExternalProjects]: (request) => {
|
|
this.projectService.openExternalProjects(request.arguments.projects);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.CloseExternalProject]: (request) => {
|
|
this.projectService.closeExternalProject(request.arguments.projectFileName);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.SynchronizeProjectList]: (request) => {
|
|
const result = this.projectService.synchronizeProjectList(request.arguments.knownProjects, request.arguments.includeProjectReferenceRedirectInfo);
|
|
if (!result.some((p) => p.projectErrors && p.projectErrors.length !== 0)) {
|
|
return this.requiredResponse(result);
|
|
}
|
|
const converted = map(result, (p) => {
|
|
if (!p.projectErrors || p.projectErrors.length === 0) {
|
|
return p;
|
|
}
|
|
return {
|
|
info: p.info,
|
|
changes: p.changes,
|
|
files: p.files,
|
|
projectErrors: this.convertToDiagnosticsWithLinePosition(p.projectErrors, void 0)
|
|
};
|
|
});
|
|
return this.requiredResponse(converted);
|
|
},
|
|
[CommandNames.UpdateOpen]: (request) => {
|
|
this.changeSeq++;
|
|
this.projectService.applyChangesInOpenFiles(
|
|
request.arguments.openFiles && mapIterator(arrayIterator(request.arguments.openFiles), (file) => ({
|
|
fileName: file.file,
|
|
content: file.fileContent,
|
|
scriptKind: file.scriptKindName,
|
|
projectRootPath: file.projectRootPath
|
|
})),
|
|
request.arguments.changedFiles && mapIterator(arrayIterator(request.arguments.changedFiles), (file) => ({
|
|
fileName: file.fileName,
|
|
changes: mapDefinedIterator(arrayReverseIterator(file.textChanges), (change) => {
|
|
const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(file.fileName));
|
|
const start2 = scriptInfo.lineOffsetToPosition(change.start.line, change.start.offset);
|
|
const end = scriptInfo.lineOffsetToPosition(change.end.line, change.end.offset);
|
|
return start2 >= 0 ? { span: { start: start2, length: end - start2 }, newText: change.newText } : void 0;
|
|
})
|
|
})),
|
|
request.arguments.closedFiles
|
|
);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.ApplyChangedToOpenFiles]: (request) => {
|
|
this.changeSeq++;
|
|
this.projectService.applyChangesInOpenFiles(
|
|
request.arguments.openFiles && arrayIterator(request.arguments.openFiles),
|
|
request.arguments.changedFiles && mapIterator(arrayIterator(request.arguments.changedFiles), (file) => ({
|
|
fileName: file.fileName,
|
|
changes: arrayReverseIterator(file.changes)
|
|
})),
|
|
request.arguments.closedFiles
|
|
);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.Exit]: () => {
|
|
this.exit();
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Definition]: (request) => {
|
|
return this.requiredResponse(this.getDefinition(request.arguments, true));
|
|
},
|
|
[CommandNames.DefinitionFull]: (request) => {
|
|
return this.requiredResponse(this.getDefinition(request.arguments, false));
|
|
},
|
|
[CommandNames.DefinitionAndBoundSpan]: (request) => {
|
|
return this.requiredResponse(this.getDefinitionAndBoundSpan(request.arguments, true));
|
|
},
|
|
[CommandNames.DefinitionAndBoundSpanFull]: (request) => {
|
|
return this.requiredResponse(this.getDefinitionAndBoundSpan(request.arguments, false));
|
|
},
|
|
[CommandNames.FindSourceDefinition]: (request) => {
|
|
return this.requiredResponse(this.findSourceDefinition(request.arguments));
|
|
},
|
|
[CommandNames.EmitOutput]: (request) => {
|
|
return this.requiredResponse(this.getEmitOutput(request.arguments));
|
|
},
|
|
[CommandNames.TypeDefinition]: (request) => {
|
|
return this.requiredResponse(this.getTypeDefinition(request.arguments));
|
|
},
|
|
[CommandNames.Implementation]: (request) => {
|
|
return this.requiredResponse(this.getImplementation(request.arguments, true));
|
|
},
|
|
[CommandNames.ImplementationFull]: (request) => {
|
|
return this.requiredResponse(this.getImplementation(request.arguments, false));
|
|
},
|
|
[CommandNames.References]: (request) => {
|
|
return this.requiredResponse(this.getReferences(request.arguments, true));
|
|
},
|
|
[CommandNames.ReferencesFull]: (request) => {
|
|
return this.requiredResponse(this.getReferences(request.arguments, false));
|
|
},
|
|
[CommandNames.Rename]: (request) => {
|
|
return this.requiredResponse(this.getRenameLocations(request.arguments, true));
|
|
},
|
|
[CommandNames.RenameLocationsFull]: (request) => {
|
|
return this.requiredResponse(this.getRenameLocations(request.arguments, false));
|
|
},
|
|
[CommandNames.RenameInfoFull]: (request) => {
|
|
return this.requiredResponse(this.getRenameInfo(request.arguments));
|
|
},
|
|
[CommandNames.Open]: (request) => {
|
|
this.openClientFile(
|
|
toNormalizedPath(request.arguments.file),
|
|
request.arguments.fileContent,
|
|
convertScriptKindName(request.arguments.scriptKindName),
|
|
request.arguments.projectRootPath ? toNormalizedPath(request.arguments.projectRootPath) : void 0
|
|
);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Quickinfo]: (request) => {
|
|
return this.requiredResponse(this.getQuickInfoWorker(request.arguments, true));
|
|
},
|
|
[CommandNames.QuickinfoFull]: (request) => {
|
|
return this.requiredResponse(this.getQuickInfoWorker(request.arguments, false));
|
|
},
|
|
[CommandNames.GetOutliningSpans]: (request) => {
|
|
return this.requiredResponse(this.getOutliningSpans(request.arguments, true));
|
|
},
|
|
[CommandNames.GetOutliningSpansFull]: (request) => {
|
|
return this.requiredResponse(this.getOutliningSpans(request.arguments, false));
|
|
},
|
|
[CommandNames.TodoComments]: (request) => {
|
|
return this.requiredResponse(this.getTodoComments(request.arguments));
|
|
},
|
|
[CommandNames.Indentation]: (request) => {
|
|
return this.requiredResponse(this.getIndentation(request.arguments));
|
|
},
|
|
[CommandNames.NameOrDottedNameSpan]: (request) => {
|
|
return this.requiredResponse(this.getNameOrDottedNameSpan(request.arguments));
|
|
},
|
|
[CommandNames.BreakpointStatement]: (request) => {
|
|
return this.requiredResponse(this.getBreakpointStatement(request.arguments));
|
|
},
|
|
[CommandNames.BraceCompletion]: (request) => {
|
|
return this.requiredResponse(this.isValidBraceCompletion(request.arguments));
|
|
},
|
|
[CommandNames.DocCommentTemplate]: (request) => {
|
|
return this.requiredResponse(this.getDocCommentTemplate(request.arguments));
|
|
},
|
|
[CommandNames.GetSpanOfEnclosingComment]: (request) => {
|
|
return this.requiredResponse(this.getSpanOfEnclosingComment(request.arguments));
|
|
},
|
|
[CommandNames.FileReferences]: (request) => {
|
|
return this.requiredResponse(this.getFileReferences(request.arguments, true));
|
|
},
|
|
[CommandNames.FileReferencesFull]: (request) => {
|
|
return this.requiredResponse(this.getFileReferences(request.arguments, false));
|
|
},
|
|
[CommandNames.Format]: (request) => {
|
|
return this.requiredResponse(this.getFormattingEditsForRange(request.arguments));
|
|
},
|
|
[CommandNames.Formatonkey]: (request) => {
|
|
return this.requiredResponse(this.getFormattingEditsAfterKeystroke(request.arguments));
|
|
},
|
|
[CommandNames.FormatFull]: (request) => {
|
|
return this.requiredResponse(this.getFormattingEditsForDocumentFull(request.arguments));
|
|
},
|
|
[CommandNames.FormatonkeyFull]: (request) => {
|
|
return this.requiredResponse(this.getFormattingEditsAfterKeystrokeFull(request.arguments));
|
|
},
|
|
[CommandNames.FormatRangeFull]: (request) => {
|
|
return this.requiredResponse(this.getFormattingEditsForRangeFull(request.arguments));
|
|
},
|
|
[CommandNames.CompletionInfo]: (request) => {
|
|
return this.requiredResponse(this.getCompletions(request.arguments, CommandNames.CompletionInfo));
|
|
},
|
|
[CommandNames.Completions]: (request) => {
|
|
return this.requiredResponse(this.getCompletions(request.arguments, CommandNames.Completions));
|
|
},
|
|
[CommandNames.CompletionsFull]: (request) => {
|
|
return this.requiredResponse(this.getCompletions(request.arguments, CommandNames.CompletionsFull));
|
|
},
|
|
[CommandNames.CompletionDetails]: (request) => {
|
|
return this.requiredResponse(this.getCompletionEntryDetails(request.arguments, false));
|
|
},
|
|
[CommandNames.CompletionDetailsFull]: (request) => {
|
|
return this.requiredResponse(this.getCompletionEntryDetails(request.arguments, true));
|
|
},
|
|
[CommandNames.CompileOnSaveAffectedFileList]: (request) => {
|
|
return this.requiredResponse(this.getCompileOnSaveAffectedFileList(request.arguments));
|
|
},
|
|
[CommandNames.CompileOnSaveEmitFile]: (request) => {
|
|
return this.requiredResponse(this.emitFile(request.arguments));
|
|
},
|
|
[CommandNames.SignatureHelp]: (request) => {
|
|
return this.requiredResponse(this.getSignatureHelpItems(request.arguments, true));
|
|
},
|
|
[CommandNames.SignatureHelpFull]: (request) => {
|
|
return this.requiredResponse(this.getSignatureHelpItems(request.arguments, false));
|
|
},
|
|
[CommandNames.CompilerOptionsDiagnosticsFull]: (request) => {
|
|
return this.requiredResponse(this.getCompilerOptionsDiagnostics(request.arguments));
|
|
},
|
|
[CommandNames.EncodedSyntacticClassificationsFull]: (request) => {
|
|
return this.requiredResponse(this.getEncodedSyntacticClassifications(request.arguments));
|
|
},
|
|
[CommandNames.EncodedSemanticClassificationsFull]: (request) => {
|
|
return this.requiredResponse(this.getEncodedSemanticClassifications(request.arguments));
|
|
},
|
|
[CommandNames.Cleanup]: () => {
|
|
this.cleanup();
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.SemanticDiagnosticsSync]: (request) => {
|
|
return this.requiredResponse(this.getSemanticDiagnosticsSync(request.arguments));
|
|
},
|
|
[CommandNames.SyntacticDiagnosticsSync]: (request) => {
|
|
return this.requiredResponse(this.getSyntacticDiagnosticsSync(request.arguments));
|
|
},
|
|
[CommandNames.SuggestionDiagnosticsSync]: (request) => {
|
|
return this.requiredResponse(this.getSuggestionDiagnosticsSync(request.arguments));
|
|
},
|
|
[CommandNames.Geterr]: (request) => {
|
|
this.errorCheck.startNew((next) => this.getDiagnostics(next, request.arguments.delay, request.arguments.files));
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.GeterrForProject]: (request) => {
|
|
this.errorCheck.startNew((next) => this.getDiagnosticsForProject(next, request.arguments.delay, request.arguments.file));
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Change]: (request) => {
|
|
this.change(request.arguments);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Configure]: (request) => {
|
|
this.projectService.setHostConfiguration(request.arguments);
|
|
this.doOutput(void 0, CommandNames.Configure, request.seq, true);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Reload]: (request) => {
|
|
this.reload(request.arguments, request.seq);
|
|
return this.requiredResponse({ reloadFinished: true });
|
|
},
|
|
[CommandNames.Saveto]: (request) => {
|
|
const savetoArgs = request.arguments;
|
|
this.saveToTmp(savetoArgs.file, savetoArgs.tmpfile);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Close]: (request) => {
|
|
const closeArgs = request.arguments;
|
|
this.closeClientFile(closeArgs.file);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.Navto]: (request) => {
|
|
return this.requiredResponse(this.getNavigateToItems(request.arguments, true));
|
|
},
|
|
[CommandNames.NavtoFull]: (request) => {
|
|
return this.requiredResponse(this.getNavigateToItems(request.arguments, false));
|
|
},
|
|
[CommandNames.Brace]: (request) => {
|
|
return this.requiredResponse(this.getBraceMatching(request.arguments, true));
|
|
},
|
|
[CommandNames.BraceFull]: (request) => {
|
|
return this.requiredResponse(this.getBraceMatching(request.arguments, false));
|
|
},
|
|
[CommandNames.NavBar]: (request) => {
|
|
return this.requiredResponse(this.getNavigationBarItems(request.arguments, true));
|
|
},
|
|
[CommandNames.NavBarFull]: (request) => {
|
|
return this.requiredResponse(this.getNavigationBarItems(request.arguments, false));
|
|
},
|
|
[CommandNames.NavTree]: (request) => {
|
|
return this.requiredResponse(this.getNavigationTree(request.arguments, true));
|
|
},
|
|
[CommandNames.NavTreeFull]: (request) => {
|
|
return this.requiredResponse(this.getNavigationTree(request.arguments, false));
|
|
},
|
|
[CommandNames.Occurrences]: (request) => {
|
|
return this.requiredResponse(this.getOccurrences(request.arguments));
|
|
},
|
|
[CommandNames.DocumentHighlights]: (request) => {
|
|
return this.requiredResponse(this.getDocumentHighlights(request.arguments, true));
|
|
},
|
|
[CommandNames.DocumentHighlightsFull]: (request) => {
|
|
return this.requiredResponse(this.getDocumentHighlights(request.arguments, false));
|
|
},
|
|
[CommandNames.CompilerOptionsForInferredProjects]: (request) => {
|
|
this.setCompilerOptionsForInferredProjects(request.arguments);
|
|
return this.requiredResponse(true);
|
|
},
|
|
[CommandNames.ProjectInfo]: (request) => {
|
|
return this.requiredResponse(this.getProjectInfo(request.arguments));
|
|
},
|
|
[CommandNames.ReloadProjects]: () => {
|
|
this.projectService.reloadProjects();
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.JsxClosingTag]: (request) => {
|
|
return this.requiredResponse(this.getJsxClosingTag(request.arguments));
|
|
},
|
|
[CommandNames.GetCodeFixes]: (request) => {
|
|
return this.requiredResponse(this.getCodeFixes(request.arguments, true));
|
|
},
|
|
[CommandNames.GetCodeFixesFull]: (request) => {
|
|
return this.requiredResponse(this.getCodeFixes(request.arguments, false));
|
|
},
|
|
[CommandNames.GetCombinedCodeFix]: (request) => {
|
|
return this.requiredResponse(this.getCombinedCodeFix(request.arguments, true));
|
|
},
|
|
[CommandNames.GetCombinedCodeFixFull]: (request) => {
|
|
return this.requiredResponse(this.getCombinedCodeFix(request.arguments, false));
|
|
},
|
|
[CommandNames.ApplyCodeActionCommand]: (request) => {
|
|
return this.requiredResponse(this.applyCodeActionCommand(request.arguments));
|
|
},
|
|
[CommandNames.GetSupportedCodeFixes]: () => {
|
|
return this.requiredResponse(this.getSupportedCodeFixes());
|
|
},
|
|
[CommandNames.GetApplicableRefactors]: (request) => {
|
|
return this.requiredResponse(this.getApplicableRefactors(request.arguments));
|
|
},
|
|
[CommandNames.GetEditsForRefactor]: (request) => {
|
|
return this.requiredResponse(this.getEditsForRefactor(request.arguments, true));
|
|
},
|
|
[CommandNames.GetEditsForRefactorFull]: (request) => {
|
|
return this.requiredResponse(this.getEditsForRefactor(request.arguments, false));
|
|
},
|
|
[CommandNames.OrganizeImports]: (request) => {
|
|
return this.requiredResponse(this.organizeImports(request.arguments, true));
|
|
},
|
|
[CommandNames.OrganizeImportsFull]: (request) => {
|
|
return this.requiredResponse(this.organizeImports(request.arguments, false));
|
|
},
|
|
[CommandNames.GetEditsForFileRename]: (request) => {
|
|
return this.requiredResponse(this.getEditsForFileRename(request.arguments, true));
|
|
},
|
|
[CommandNames.GetEditsForFileRenameFull]: (request) => {
|
|
return this.requiredResponse(this.getEditsForFileRename(request.arguments, false));
|
|
},
|
|
[CommandNames.ConfigurePlugin]: (request) => {
|
|
this.configurePlugin(request.arguments);
|
|
this.doOutput(void 0, CommandNames.ConfigurePlugin, request.seq, true);
|
|
return this.notRequired();
|
|
},
|
|
[CommandNames.SelectionRange]: (request) => {
|
|
return this.requiredResponse(this.getSmartSelectionRange(request.arguments, true));
|
|
},
|
|
[CommandNames.SelectionRangeFull]: (request) => {
|
|
return this.requiredResponse(this.getSmartSelectionRange(request.arguments, false));
|
|
},
|
|
[CommandNames.PrepareCallHierarchy]: (request) => {
|
|
return this.requiredResponse(this.prepareCallHierarchy(request.arguments));
|
|
},
|
|
[CommandNames.ProvideCallHierarchyIncomingCalls]: (request) => {
|
|
return this.requiredResponse(this.provideCallHierarchyIncomingCalls(request.arguments));
|
|
},
|
|
[CommandNames.ProvideCallHierarchyOutgoingCalls]: (request) => {
|
|
return this.requiredResponse(this.provideCallHierarchyOutgoingCalls(request.arguments));
|
|
},
|
|
[CommandNames.ToggleLineComment]: (request) => {
|
|
return this.requiredResponse(this.toggleLineComment(request.arguments, true));
|
|
},
|
|
[CommandNames.ToggleLineCommentFull]: (request) => {
|
|
return this.requiredResponse(this.toggleLineComment(request.arguments, false));
|
|
},
|
|
[CommandNames.ToggleMultilineComment]: (request) => {
|
|
return this.requiredResponse(this.toggleMultilineComment(request.arguments, true));
|
|
},
|
|
[CommandNames.ToggleMultilineCommentFull]: (request) => {
|
|
return this.requiredResponse(this.toggleMultilineComment(request.arguments, false));
|
|
},
|
|
[CommandNames.CommentSelection]: (request) => {
|
|
return this.requiredResponse(this.commentSelection(request.arguments, true));
|
|
},
|
|
[CommandNames.CommentSelectionFull]: (request) => {
|
|
return this.requiredResponse(this.commentSelection(request.arguments, false));
|
|
},
|
|
[CommandNames.UncommentSelection]: (request) => {
|
|
return this.requiredResponse(this.uncommentSelection(request.arguments, true));
|
|
},
|
|
[CommandNames.UncommentSelectionFull]: (request) => {
|
|
return this.requiredResponse(this.uncommentSelection(request.arguments, false));
|
|
},
|
|
[CommandNames.ProvideInlayHints]: (request) => {
|
|
return this.requiredResponse(this.provideInlayHints(request.arguments));
|
|
}
|
|
}));
|
|
this.host = opts.host;
|
|
this.cancellationToken = opts.cancellationToken;
|
|
this.typingsInstaller = opts.typingsInstaller;
|
|
this.byteLength = opts.byteLength;
|
|
this.hrtime = opts.hrtime;
|
|
this.logger = opts.logger;
|
|
this.canUseEvents = opts.canUseEvents;
|
|
this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents;
|
|
this.noGetErrOnBackgroundUpdate = opts.noGetErrOnBackgroundUpdate;
|
|
const { throttleWaitMilliseconds } = opts;
|
|
this.eventHandler = this.canUseEvents ? opts.eventHandler || ((event) => this.defaultEventHandler(event)) : void 0;
|
|
const multistepOperationHost = {
|
|
executeWithRequestId: (requestId, action) => this.executeWithRequestId(requestId, action),
|
|
getCurrentRequestId: () => this.currentRequestId,
|
|
getServerHost: () => this.host,
|
|
logError: (err, cmd) => this.logError(err, cmd),
|
|
sendRequestCompletedEvent: (requestId) => this.sendRequestCompletedEvent(requestId),
|
|
isCancellationRequested: () => this.cancellationToken.isCancellationRequested()
|
|
};
|
|
this.errorCheck = new MultistepOperation(multistepOperationHost);
|
|
const settings = {
|
|
host: this.host,
|
|
logger: this.logger,
|
|
cancellationToken: this.cancellationToken,
|
|
useSingleInferredProject: opts.useSingleInferredProject,
|
|
useInferredProjectPerProjectRoot: opts.useInferredProjectPerProjectRoot,
|
|
typingsInstaller: this.typingsInstaller,
|
|
throttleWaitMilliseconds,
|
|
eventHandler: this.eventHandler,
|
|
suppressDiagnosticEvents: this.suppressDiagnosticEvents,
|
|
globalPlugins: opts.globalPlugins,
|
|
pluginProbeLocations: opts.pluginProbeLocations,
|
|
allowLocalPluginLoads: opts.allowLocalPluginLoads,
|
|
typesMapLocation: opts.typesMapLocation,
|
|
syntaxOnly: opts.syntaxOnly,
|
|
serverMode: opts.serverMode,
|
|
session: this
|
|
};
|
|
this.projectService = new ProjectService3(settings);
|
|
this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this));
|
|
this.gcTimer = new GcTimer(this.host, 7e3, this.logger);
|
|
switch (this.projectService.serverMode) {
|
|
case 0 /* Semantic */:
|
|
break;
|
|
case 1 /* PartialSemantic */:
|
|
invalidPartialSemanticModeCommands.forEach(
|
|
(commandName) => this.handlers.set(commandName, (request) => {
|
|
throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.PartialSemantic`);
|
|
})
|
|
);
|
|
break;
|
|
case 2 /* Syntactic */:
|
|
invalidSyntacticModeCommands.forEach(
|
|
(commandName) => this.handlers.set(commandName, (request) => {
|
|
throw new Error(`Request: ${request.command} not allowed in LanguageServiceMode.Syntactic`);
|
|
})
|
|
);
|
|
break;
|
|
default:
|
|
Debug.assertNever(this.projectService.serverMode);
|
|
}
|
|
}
|
|
sendRequestCompletedEvent(requestId) {
|
|
this.event({ request_seq: requestId }, "requestCompleted");
|
|
}
|
|
addPerformanceData(key, value) {
|
|
var _a2;
|
|
if (!this.performanceData) {
|
|
this.performanceData = {};
|
|
}
|
|
this.performanceData[key] = ((_a2 = this.performanceData[key]) != null ? _a2 : 0) + value;
|
|
}
|
|
performanceEventHandler(event) {
|
|
switch (event.kind) {
|
|
case "UpdateGraph":
|
|
this.addPerformanceData("updateGraphDurationMs", event.durationMs);
|
|
break;
|
|
case "CreatePackageJsonAutoImportProvider":
|
|
this.addPerformanceData("createAutoImportProviderProgramDurationMs", event.durationMs);
|
|
break;
|
|
}
|
|
}
|
|
defaultEventHandler(event) {
|
|
switch (event.eventName) {
|
|
case ProjectsUpdatedInBackgroundEvent:
|
|
const { openFiles } = event.data;
|
|
this.projectsUpdatedInBackgroundEvent(openFiles);
|
|
break;
|
|
case ProjectLoadingStartEvent:
|
|
const { project, reason } = event.data;
|
|
this.event(
|
|
{ projectName: project.getProjectName(), reason },
|
|
ProjectLoadingStartEvent
|
|
);
|
|
break;
|
|
case ProjectLoadingFinishEvent:
|
|
const { project: finishProject } = event.data;
|
|
this.event({ projectName: finishProject.getProjectName() }, ProjectLoadingFinishEvent);
|
|
break;
|
|
case LargeFileReferencedEvent:
|
|
const { file, fileSize, maxFileSize: maxFileSize2 } = event.data;
|
|
this.event({ file, fileSize, maxFileSize: maxFileSize2 }, LargeFileReferencedEvent);
|
|
break;
|
|
case ConfigFileDiagEvent:
|
|
const { triggerFile, configFileName: configFile, diagnostics } = event.data;
|
|
const bakedDiags = map(diagnostics, (diagnostic) => formatDiagnosticToProtocol(diagnostic, true));
|
|
this.event({
|
|
triggerFile,
|
|
configFile,
|
|
diagnostics: bakedDiags
|
|
}, ConfigFileDiagEvent);
|
|
break;
|
|
case ProjectLanguageServiceStateEvent: {
|
|
const eventName = ProjectLanguageServiceStateEvent;
|
|
this.event({
|
|
projectName: event.data.project.getProjectName(),
|
|
languageServiceEnabled: event.data.languageServiceEnabled
|
|
}, eventName);
|
|
break;
|
|
}
|
|
case ProjectInfoTelemetryEvent: {
|
|
const eventName = "telemetry";
|
|
this.event({
|
|
telemetryEventName: event.eventName,
|
|
payload: event.data
|
|
}, eventName);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
projectsUpdatedInBackgroundEvent(openFiles) {
|
|
this.projectService.logger.info(`got projects updated in background, updating diagnostics for ${openFiles}`);
|
|
if (openFiles.length) {
|
|
if (!this.suppressDiagnosticEvents && !this.noGetErrOnBackgroundUpdate) {
|
|
this.errorCheck.startNew((next) => this.updateErrorCheck(next, openFiles, 100, true));
|
|
}
|
|
this.event({
|
|
openFiles
|
|
}, ProjectsUpdatedInBackgroundEvent);
|
|
}
|
|
}
|
|
logError(err, cmd) {
|
|
this.logErrorWorker(err, cmd);
|
|
}
|
|
logErrorWorker(err, cmd, fileRequest) {
|
|
let msg = "Exception on executing command " + cmd;
|
|
if (err.message) {
|
|
msg += ":\n" + indent2(err.message);
|
|
if (err.stack) {
|
|
msg += "\n" + indent2(err.stack);
|
|
}
|
|
}
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
if (fileRequest) {
|
|
try {
|
|
const { file, project } = this.getFileAndProject(fileRequest);
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
if (scriptInfo) {
|
|
const text = getSnapshotText(scriptInfo.getSnapshot());
|
|
msg += `
|
|
|
|
File text of ${fileRequest.file}:${indent2(text)}
|
|
`;
|
|
}
|
|
} catch (e) {
|
|
}
|
|
}
|
|
if (err.ProgramFiles) {
|
|
msg += `
|
|
|
|
Program files: ${JSON.stringify(err.ProgramFiles)}
|
|
`;
|
|
msg += `
|
|
|
|
Projects::
|
|
`;
|
|
let counter = 0;
|
|
const addProjectInfo = (project) => {
|
|
msg += `
|
|
Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter}
|
|
`;
|
|
msg += project.filesToString(true);
|
|
msg += "\n-----------------------------------------------\n";
|
|
counter++;
|
|
};
|
|
this.projectService.externalProjects.forEach(addProjectInfo);
|
|
this.projectService.configuredProjects.forEach(addProjectInfo);
|
|
this.projectService.inferredProjects.forEach(addProjectInfo);
|
|
}
|
|
}
|
|
this.logger.msg(msg, "Err" /* Err */);
|
|
}
|
|
send(msg) {
|
|
if (msg.type === "event" && !this.canUseEvents) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Session does not support events: ignored event: ${JSON.stringify(msg)}`);
|
|
}
|
|
return;
|
|
}
|
|
this.writeMessage(msg);
|
|
}
|
|
writeMessage(msg) {
|
|
const msgText = formatMessage2(msg, this.logger, this.byteLength, this.host.newLine);
|
|
perfLogger.logEvent(`Response message size: ${msgText.length}`);
|
|
this.host.write(msgText);
|
|
}
|
|
event(body, eventName) {
|
|
this.send(toEvent(eventName, body));
|
|
}
|
|
output(info, cmdName, reqSeq, errorMsg) {
|
|
this.doOutput(info, cmdName, reqSeq, !errorMsg, errorMsg);
|
|
}
|
|
doOutput(info, cmdName, reqSeq, success, message) {
|
|
const res = {
|
|
seq: 0,
|
|
type: "response",
|
|
command: cmdName,
|
|
request_seq: reqSeq,
|
|
success,
|
|
performanceData: this.performanceData
|
|
};
|
|
if (success) {
|
|
let metadata;
|
|
if (isArray(info)) {
|
|
res.body = info;
|
|
metadata = info.metadata;
|
|
delete info.metadata;
|
|
} else if (typeof info === "object") {
|
|
if (info.metadata) {
|
|
const { metadata: infoMetadata, ...body } = info;
|
|
res.body = body;
|
|
metadata = infoMetadata;
|
|
} else {
|
|
res.body = info;
|
|
}
|
|
} else {
|
|
res.body = info;
|
|
}
|
|
if (metadata)
|
|
res.metadata = metadata;
|
|
} else {
|
|
Debug.assert(info === void 0);
|
|
}
|
|
if (message) {
|
|
res.message = message;
|
|
}
|
|
this.send(res);
|
|
}
|
|
semanticCheck(file, project) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "semanticCheck", { file, configFilePath: project.canonicalConfigFilePath });
|
|
const diags = isDeclarationFileInJSOnlyNonConfiguredProject(project, file) ? emptyArray2 : project.getLanguageService().getSemanticDiagnostics(file).filter((d) => !!d.file);
|
|
this.sendDiagnosticsEvent(file, project, diags, "semanticDiag");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
syntacticCheck(file, project) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "syntacticCheck", { file, configFilePath: project.canonicalConfigFilePath });
|
|
this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSyntacticDiagnostics(file), "syntaxDiag");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
suggestionCheck(file, project) {
|
|
var _a2, _b;
|
|
(_a2 = tracing) == null ? void 0 : _a2.push(tracing.Phase.Session, "suggestionCheck", { file, configFilePath: project.canonicalConfigFilePath });
|
|
this.sendDiagnosticsEvent(file, project, project.getLanguageService().getSuggestionDiagnostics(file), "suggestionDiag");
|
|
(_b = tracing) == null ? void 0 : _b.pop();
|
|
}
|
|
sendDiagnosticsEvent(file, project, diagnostics, kind) {
|
|
try {
|
|
this.event({ file, diagnostics: diagnostics.map((diag2) => formatDiag(file, project, diag2)) }, kind);
|
|
} catch (err) {
|
|
this.logError(err, kind);
|
|
}
|
|
}
|
|
updateErrorCheck(next, checkList, ms, requireOpen = true) {
|
|
Debug.assert(!this.suppressDiagnosticEvents);
|
|
const seq = this.changeSeq;
|
|
const followMs = Math.min(ms, 200);
|
|
let index = 0;
|
|
const goNext = () => {
|
|
index++;
|
|
if (checkList.length > index) {
|
|
next.delay(followMs, checkOne);
|
|
}
|
|
};
|
|
const checkOne = () => {
|
|
if (this.changeSeq !== seq) {
|
|
return;
|
|
}
|
|
let item = checkList[index];
|
|
if (isString(item)) {
|
|
item = this.toPendingErrorCheck(item);
|
|
if (!item) {
|
|
goNext();
|
|
return;
|
|
}
|
|
}
|
|
const { fileName, project } = item;
|
|
updateProjectIfDirty(project);
|
|
if (!project.containsFile(fileName, requireOpen)) {
|
|
return;
|
|
}
|
|
this.syntacticCheck(fileName, project);
|
|
if (this.changeSeq !== seq) {
|
|
return;
|
|
}
|
|
if (project.projectService.serverMode !== 0 /* Semantic */) {
|
|
goNext();
|
|
return;
|
|
}
|
|
next.immediate(() => {
|
|
this.semanticCheck(fileName, project);
|
|
if (this.changeSeq !== seq) {
|
|
return;
|
|
}
|
|
if (this.getPreferences(fileName).disableSuggestions) {
|
|
goNext();
|
|
return;
|
|
}
|
|
next.immediate(() => {
|
|
this.suggestionCheck(fileName, project);
|
|
goNext();
|
|
});
|
|
});
|
|
};
|
|
if (checkList.length > index && this.changeSeq === seq) {
|
|
next.delay(ms, checkOne);
|
|
}
|
|
}
|
|
cleanProjects(caption, projects) {
|
|
if (!projects) {
|
|
return;
|
|
}
|
|
this.logger.info(`cleaning ${caption}`);
|
|
for (const p of projects) {
|
|
p.getLanguageService(false).cleanupSemanticCache();
|
|
}
|
|
}
|
|
cleanup() {
|
|
this.cleanProjects("inferred projects", this.projectService.inferredProjects);
|
|
this.cleanProjects("configured projects", arrayFrom(this.projectService.configuredProjects.values()));
|
|
this.cleanProjects("external projects", this.projectService.externalProjects);
|
|
if (this.host.gc) {
|
|
this.logger.info(`host.gc()`);
|
|
this.host.gc();
|
|
}
|
|
}
|
|
getEncodedSyntacticClassifications(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
return languageService.getEncodedSyntacticClassifications(file, args);
|
|
}
|
|
getEncodedSemanticClassifications(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const format = args.format === "2020" ? "2020" /* TwentyTwenty */ : "original" /* Original */;
|
|
return project.getLanguageService().getEncodedSemanticClassifications(file, args, format);
|
|
}
|
|
getProject(projectFileName) {
|
|
return projectFileName === void 0 ? void 0 : this.projectService.findProject(projectFileName);
|
|
}
|
|
getConfigFileAndProject(args) {
|
|
const project = this.getProject(args.projectFileName);
|
|
const file = toNormalizedPath(args.file);
|
|
return {
|
|
configFile: project && project.hasConfigFile(file) ? file : void 0,
|
|
project
|
|
};
|
|
}
|
|
getConfigFileDiagnostics(configFile, project, includeLinePosition) {
|
|
const projectErrors = project.getAllProjectErrors();
|
|
const optionsErrors = project.getLanguageService().getCompilerOptionsDiagnostics();
|
|
const diagnosticsForConfigFile = filter(
|
|
concatenate(projectErrors, optionsErrors),
|
|
(diagnostic) => !!diagnostic.file && diagnostic.file.fileName === configFile
|
|
);
|
|
return includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnosticsForConfigFile) : map(
|
|
diagnosticsForConfigFile,
|
|
(diagnostic) => formatDiagnosticToProtocol(diagnostic, false)
|
|
);
|
|
}
|
|
convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) {
|
|
return diagnostics.map((d) => ({
|
|
message: flattenDiagnosticMessageText(d.messageText, this.host.newLine),
|
|
start: d.start,
|
|
length: d.length,
|
|
category: diagnosticCategoryName(d),
|
|
code: d.code,
|
|
source: d.source,
|
|
startLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start)),
|
|
endLocation: d.file && convertToLocation(getLineAndCharacterOfPosition(d.file, d.start + d.length)),
|
|
reportsUnnecessary: d.reportsUnnecessary,
|
|
reportsDeprecated: d.reportsDeprecated,
|
|
relatedInformation: map(d.relatedInformation, formatRelatedInformation)
|
|
}));
|
|
}
|
|
getCompilerOptionsDiagnostics(args) {
|
|
const project = this.getProject(args.projectFileName);
|
|
return this.convertToDiagnosticsWithLinePosition(
|
|
filter(
|
|
project.getLanguageService().getCompilerOptionsDiagnostics(),
|
|
(diagnostic) => !diagnostic.file
|
|
),
|
|
void 0
|
|
);
|
|
}
|
|
convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo) {
|
|
return diagnostics.map((d) => ({
|
|
message: flattenDiagnosticMessageText(d.messageText, this.host.newLine),
|
|
start: d.start,
|
|
length: d.length,
|
|
category: diagnosticCategoryName(d),
|
|
code: d.code,
|
|
source: d.source,
|
|
startLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start),
|
|
endLocation: scriptInfo && scriptInfo.positionToLineOffset(d.start + d.length),
|
|
reportsUnnecessary: d.reportsUnnecessary,
|
|
reportsDeprecated: d.reportsDeprecated,
|
|
relatedInformation: map(d.relatedInformation, formatRelatedInformation)
|
|
}));
|
|
}
|
|
getDiagnosticsWorker(args, isSemantic, selector, includeLinePosition) {
|
|
const { project, file } = this.getFileAndProject(args);
|
|
if (isSemantic && isDeclarationFileInJSOnlyNonConfiguredProject(project, file)) {
|
|
return emptyArray2;
|
|
}
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
const diagnostics = selector(project, file);
|
|
return includeLinePosition ? this.convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo) : diagnostics.map((d) => formatDiag(file, project, d));
|
|
}
|
|
getDefinition(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const definitions = this.mapDefinitionInfoLocations(project.getLanguageService().getDefinitionAtPosition(file, position) || emptyArray2, project);
|
|
return simplifiedResult ? this.mapDefinitionInfo(definitions, project) : definitions.map(Session3.mapToOriginalLocation);
|
|
}
|
|
mapDefinitionInfoLocations(definitions, project) {
|
|
return definitions.map((info) => {
|
|
const newDocumentSpan = getMappedDocumentSpanForProject(info, project);
|
|
return !newDocumentSpan ? info : {
|
|
...newDocumentSpan,
|
|
containerKind: info.containerKind,
|
|
containerName: info.containerName,
|
|
kind: info.kind,
|
|
name: info.name,
|
|
failedAliasResolution: info.failedAliasResolution,
|
|
...info.unverified && { unverified: info.unverified }
|
|
};
|
|
});
|
|
}
|
|
getDefinitionAndBoundSpan(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const scriptInfo = Debug.checkDefined(project.getScriptInfo(file));
|
|
const unmappedDefinitionAndBoundSpan = project.getLanguageService().getDefinitionAndBoundSpan(file, position);
|
|
if (!unmappedDefinitionAndBoundSpan || !unmappedDefinitionAndBoundSpan.definitions) {
|
|
return {
|
|
definitions: emptyArray2,
|
|
textSpan: void 0
|
|
};
|
|
}
|
|
const definitions = this.mapDefinitionInfoLocations(unmappedDefinitionAndBoundSpan.definitions, project);
|
|
const { textSpan } = unmappedDefinitionAndBoundSpan;
|
|
if (simplifiedResult) {
|
|
return {
|
|
definitions: this.mapDefinitionInfo(definitions, project),
|
|
textSpan: toProtocolTextSpan(textSpan, scriptInfo)
|
|
};
|
|
}
|
|
return {
|
|
definitions: definitions.map(Session3.mapToOriginalLocation),
|
|
textSpan
|
|
};
|
|
}
|
|
findSourceDefinition(args) {
|
|
var _a2;
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const unmappedDefinitions = project.getLanguageService().getDefinitionAtPosition(file, position);
|
|
let definitions = this.mapDefinitionInfoLocations(unmappedDefinitions || emptyArray2, project).slice();
|
|
const needsJsResolution = this.projectService.serverMode === 0 /* Semantic */ && (!some(definitions, (d) => toNormalizedPath(d.fileName) !== file && !d.isAmbient) || some(definitions, (d) => !!d.failedAliasResolution));
|
|
if (needsJsResolution) {
|
|
const definitionSet = createSet((d) => d.textSpan.start, documentSpansEqual);
|
|
definitions == null ? void 0 : definitions.forEach((d) => definitionSet.add(d));
|
|
const noDtsProject = project.getNoDtsResolutionProject([file]);
|
|
const ls = noDtsProject.getLanguageService();
|
|
const jsDefinitions = (_a2 = ls.getDefinitionAtPosition(file, position, true, false)) == null ? void 0 : _a2.filter((d) => toNormalizedPath(d.fileName) !== file);
|
|
if (some(jsDefinitions)) {
|
|
for (const jsDefinition of jsDefinitions) {
|
|
if (jsDefinition.unverified) {
|
|
const refined = tryRefineDefinition(jsDefinition, project.getLanguageService().getProgram(), ls.getProgram());
|
|
if (some(refined)) {
|
|
for (const def of refined) {
|
|
definitionSet.add(def);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
definitionSet.add(jsDefinition);
|
|
}
|
|
} else {
|
|
const ambientCandidates = definitions.filter((d) => toNormalizedPath(d.fileName) !== file && d.isAmbient);
|
|
for (const candidate of some(ambientCandidates) ? ambientCandidates : getAmbientCandidatesByClimbingAccessChain()) {
|
|
const fileNameToSearch = findImplementationFileFromDtsFileName(candidate.fileName, file, noDtsProject);
|
|
if (!fileNameToSearch || !ensureRoot(noDtsProject, fileNameToSearch)) {
|
|
continue;
|
|
}
|
|
const noDtsProgram = ls.getProgram();
|
|
const fileToSearch = Debug.checkDefined(noDtsProgram.getSourceFile(fileNameToSearch));
|
|
for (const match of searchForDeclaration(candidate.name, fileToSearch, noDtsProgram)) {
|
|
definitionSet.add(match);
|
|
}
|
|
}
|
|
}
|
|
definitions = arrayFrom(definitionSet.values());
|
|
}
|
|
definitions = definitions.filter((d) => !d.isAmbient && !d.failedAliasResolution);
|
|
return this.mapDefinitionInfo(definitions, project);
|
|
function findImplementationFileFromDtsFileName(fileName, resolveFromFile, auxiliaryProject) {
|
|
var _a3;
|
|
const nodeModulesPathParts = getNodeModulePathParts(fileName);
|
|
if (nodeModulesPathParts && fileName.lastIndexOf(nodeModulesPathPart) === nodeModulesPathParts.topLevelNodeModulesIndex) {
|
|
const packageDirectory = fileName.substring(0, nodeModulesPathParts.packageRootIndex);
|
|
const packageJsonCache = (_a3 = project.getModuleResolutionCache()) == null ? void 0 : _a3.getPackageJsonInfoCache();
|
|
const compilerOptions = project.getCompilationSettings();
|
|
const packageJson = getPackageScopeForPath(getNormalizedAbsolutePath(packageDirectory + "/package.json", project.getCurrentDirectory()), getTemporaryModuleResolutionState(packageJsonCache, project, compilerOptions));
|
|
if (!packageJson)
|
|
return void 0;
|
|
const entrypoints = getEntrypointsFromPackageJsonInfo(
|
|
packageJson,
|
|
{ moduleResolution: 2 /* NodeJs */ },
|
|
project,
|
|
project.getModuleResolutionCache()
|
|
);
|
|
const packageNamePathPart = fileName.substring(
|
|
nodeModulesPathParts.topLevelPackageNameIndex + 1,
|
|
nodeModulesPathParts.packageRootIndex
|
|
);
|
|
const packageName = getPackageNameFromTypesPackageName(unmangleScopedPackageName(packageNamePathPart));
|
|
const path = project.toPath(fileName);
|
|
if (entrypoints && some(entrypoints, (e) => project.toPath(e) === path)) {
|
|
const [implementationResolution] = auxiliaryProject.resolveModuleNames([packageName], resolveFromFile);
|
|
return implementationResolution == null ? void 0 : implementationResolution.resolvedFileName;
|
|
} else {
|
|
const pathToFileInPackage = fileName.substring(nodeModulesPathParts.packageRootIndex + 1);
|
|
const specifier = `${packageName}/${removeFileExtension(pathToFileInPackage)}`;
|
|
const [implementationResolution] = auxiliaryProject.resolveModuleNames([specifier], resolveFromFile);
|
|
return implementationResolution == null ? void 0 : implementationResolution.resolvedFileName;
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
function getAmbientCandidatesByClimbingAccessChain() {
|
|
const ls = project.getLanguageService();
|
|
const program = ls.getProgram();
|
|
const initialNode = getTouchingPropertyName(program.getSourceFile(file), position);
|
|
if ((isStringLiteralLike(initialNode) || isIdentifier(initialNode)) && isAccessExpression(initialNode.parent)) {
|
|
return forEachNameInAccessChainWalkingLeft(initialNode, (nameInChain) => {
|
|
var _a3;
|
|
if (nameInChain === initialNode)
|
|
return void 0;
|
|
const candidates = (_a3 = ls.getDefinitionAtPosition(file, nameInChain.getStart(), true, false)) == null ? void 0 : _a3.filter((d) => toNormalizedPath(d.fileName) !== file && d.isAmbient).map((d) => ({
|
|
fileName: d.fileName,
|
|
name: getTextOfIdentifierOrLiteral(initialNode)
|
|
}));
|
|
if (some(candidates)) {
|
|
return candidates;
|
|
}
|
|
}) || emptyArray2;
|
|
}
|
|
return emptyArray2;
|
|
}
|
|
function tryRefineDefinition(definition, program, noDtsProgram) {
|
|
var _a3;
|
|
const fileToSearch = noDtsProgram.getSourceFile(definition.fileName);
|
|
if (!fileToSearch) {
|
|
return void 0;
|
|
}
|
|
const initialNode = getTouchingPropertyName(program.getSourceFile(file), position);
|
|
const symbol = program.getTypeChecker().getSymbolAtLocation(initialNode);
|
|
const importSpecifier = symbol && getDeclarationOfKind(symbol, 273 /* ImportSpecifier */);
|
|
if (!importSpecifier)
|
|
return void 0;
|
|
const nameToSearch = ((_a3 = importSpecifier.propertyName) == null ? void 0 : _a3.text) || importSpecifier.name.text;
|
|
return searchForDeclaration(nameToSearch, fileToSearch, noDtsProgram);
|
|
}
|
|
function searchForDeclaration(declarationName, fileToSearch, noDtsProgram) {
|
|
const matches = ts_FindAllReferences_exports.Core.getTopMostDeclarationNamesInFile(declarationName, fileToSearch);
|
|
return mapDefined(matches, (match) => {
|
|
const symbol = noDtsProgram.getTypeChecker().getSymbolAtLocation(match);
|
|
const decl = getDeclarationFromName(match);
|
|
if (symbol && decl) {
|
|
return ts_GoToDefinition_exports.createDefinitionInfo(decl, noDtsProgram.getTypeChecker(), symbol, decl, true);
|
|
}
|
|
});
|
|
}
|
|
function ensureRoot(project2, fileName) {
|
|
const info = project2.getScriptInfo(fileName);
|
|
if (!info)
|
|
return false;
|
|
if (!project2.containsScriptInfo(info)) {
|
|
project2.addRoot(info);
|
|
project2.updateGraph();
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
getEmitOutput(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
if (!project.shouldEmitFile(project.getScriptInfo(file))) {
|
|
return { emitSkipped: true, outputFiles: [], diagnostics: [] };
|
|
}
|
|
const result = project.getLanguageService().getEmitOutput(file);
|
|
return args.richResponse ? {
|
|
...result,
|
|
diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(result.diagnostics) : result.diagnostics.map((d) => formatDiagnosticToProtocol(d, true))
|
|
} : result;
|
|
}
|
|
mapJSDocTagInfo(tags, project, richResponse) {
|
|
return tags ? tags.map((tag) => {
|
|
var _a2;
|
|
return {
|
|
...tag,
|
|
text: richResponse ? this.mapDisplayParts(tag.text, project) : (_a2 = tag.text) == null ? void 0 : _a2.map((part) => part.text).join("")
|
|
};
|
|
}) : [];
|
|
}
|
|
mapDisplayParts(parts, project) {
|
|
if (!parts) {
|
|
return [];
|
|
}
|
|
return parts.map((part) => part.kind !== "linkName" ? part : {
|
|
...part,
|
|
target: this.toFileSpan(part.target.fileName, part.target.textSpan, project)
|
|
});
|
|
}
|
|
mapSignatureHelpItems(items, project, richResponse) {
|
|
return items.map((item) => ({
|
|
...item,
|
|
documentation: this.mapDisplayParts(item.documentation, project),
|
|
parameters: item.parameters.map((p) => ({ ...p, documentation: this.mapDisplayParts(p.documentation, project) })),
|
|
tags: this.mapJSDocTagInfo(item.tags, project, richResponse)
|
|
}));
|
|
}
|
|
mapDefinitionInfo(definitions, project) {
|
|
return definitions.map((def) => ({ ...this.toFileSpanWithContext(def.fileName, def.textSpan, def.contextSpan, project), ...def.unverified && { unverified: def.unverified } }));
|
|
}
|
|
static mapToOriginalLocation(def) {
|
|
if (def.originalFileName) {
|
|
Debug.assert(def.originalTextSpan !== void 0, "originalTextSpan should be present if originalFileName is");
|
|
return {
|
|
...def,
|
|
fileName: def.originalFileName,
|
|
textSpan: def.originalTextSpan,
|
|
targetFileName: def.fileName,
|
|
targetTextSpan: def.textSpan,
|
|
contextSpan: def.originalContextSpan,
|
|
targetContextSpan: def.contextSpan
|
|
};
|
|
}
|
|
return def;
|
|
}
|
|
toFileSpan(fileName, textSpan, project) {
|
|
const ls = project.getLanguageService();
|
|
const start2 = ls.toLineColumnOffset(fileName, textSpan.start);
|
|
const end = ls.toLineColumnOffset(fileName, textSpanEnd(textSpan));
|
|
return {
|
|
file: fileName,
|
|
start: { line: start2.line + 1, offset: start2.character + 1 },
|
|
end: { line: end.line + 1, offset: end.character + 1 }
|
|
};
|
|
}
|
|
toFileSpanWithContext(fileName, textSpan, contextSpan, project) {
|
|
const fileSpan = this.toFileSpan(fileName, textSpan, project);
|
|
const context = contextSpan && this.toFileSpan(fileName, contextSpan, project);
|
|
return context ? { ...fileSpan, contextStart: context.start, contextEnd: context.end } : fileSpan;
|
|
}
|
|
getTypeDefinition(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const definitions = this.mapDefinitionInfoLocations(project.getLanguageService().getTypeDefinitionAtPosition(file, position) || emptyArray2, project);
|
|
return this.mapDefinitionInfo(definitions, project);
|
|
}
|
|
mapImplementationLocations(implementations, project) {
|
|
return implementations.map((info) => {
|
|
const newDocumentSpan = getMappedDocumentSpanForProject(info, project);
|
|
return !newDocumentSpan ? info : {
|
|
...newDocumentSpan,
|
|
kind: info.kind,
|
|
displayParts: info.displayParts
|
|
};
|
|
});
|
|
}
|
|
getImplementation(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const implementations = this.mapImplementationLocations(project.getLanguageService().getImplementationAtPosition(file, position) || emptyArray2, project);
|
|
return simplifiedResult ? implementations.map(({ fileName, textSpan, contextSpan }) => this.toFileSpanWithContext(fileName, textSpan, contextSpan, project)) : implementations.map(Session3.mapToOriginalLocation);
|
|
}
|
|
getOccurrences(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const occurrences = project.getLanguageService().getOccurrencesAtPosition(file, position);
|
|
return occurrences ? occurrences.map((occurrence) => {
|
|
const { fileName, isWriteAccess: isWriteAccess2, textSpan, isInString: isInString2, contextSpan } = occurrence;
|
|
const scriptInfo = project.getScriptInfo(fileName);
|
|
return {
|
|
...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo),
|
|
file: fileName,
|
|
isWriteAccess: isWriteAccess2,
|
|
...isInString2 ? { isInString: isInString2 } : void 0
|
|
};
|
|
}) : emptyArray2;
|
|
}
|
|
getSyntacticDiagnosticsSync(args) {
|
|
const { configFile } = this.getConfigFileAndProject(args);
|
|
if (configFile) {
|
|
return emptyArray2;
|
|
}
|
|
return this.getDiagnosticsWorker(args, false, (project, file) => project.getLanguageService().getSyntacticDiagnostics(file), !!args.includeLinePosition);
|
|
}
|
|
getSemanticDiagnosticsSync(args) {
|
|
const { configFile, project } = this.getConfigFileAndProject(args);
|
|
if (configFile) {
|
|
return this.getConfigFileDiagnostics(configFile, project, !!args.includeLinePosition);
|
|
}
|
|
return this.getDiagnosticsWorker(args, true, (project2, file) => project2.getLanguageService().getSemanticDiagnostics(file).filter((d) => !!d.file), !!args.includeLinePosition);
|
|
}
|
|
getSuggestionDiagnosticsSync(args) {
|
|
const { configFile } = this.getConfigFileAndProject(args);
|
|
if (configFile) {
|
|
return emptyArray2;
|
|
}
|
|
return this.getDiagnosticsWorker(args, true, (project, file) => project.getLanguageService().getSuggestionDiagnostics(file), !!args.includeLinePosition);
|
|
}
|
|
getJsxClosingTag(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const tag = languageService.getJsxClosingTagAtPosition(file, position);
|
|
return tag === void 0 ? void 0 : { newText: tag.newText, caretOffset: 0 };
|
|
}
|
|
getDocumentHighlights(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const documentHighlights = project.getLanguageService().getDocumentHighlights(file, position, args.filesToSearch);
|
|
if (!documentHighlights)
|
|
return emptyArray2;
|
|
if (!simplifiedResult)
|
|
return documentHighlights;
|
|
return documentHighlights.map(({ fileName, highlightSpans }) => {
|
|
const scriptInfo = project.getScriptInfo(fileName);
|
|
return {
|
|
file: fileName,
|
|
highlightSpans: highlightSpans.map(({ textSpan, kind, contextSpan }) => ({
|
|
...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo),
|
|
kind
|
|
}))
|
|
};
|
|
});
|
|
}
|
|
provideInlayHints(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const hints = project.getLanguageService().provideInlayHints(file, args, this.getPreferences(file));
|
|
return hints.map((hint) => ({
|
|
...hint,
|
|
position: scriptInfo.positionToLineOffset(hint.position)
|
|
}));
|
|
}
|
|
setCompilerOptionsForInferredProjects(args) {
|
|
this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
|
|
}
|
|
getProjectInfo(args) {
|
|
return this.getProjectInfoWorker(args.file, args.projectFileName, args.needFileNameList, false);
|
|
}
|
|
getProjectInfoWorker(uncheckedFileName, projectFileName, needFileNameList, excludeConfigFiles) {
|
|
const { project } = this.getFileAndProjectWorker(uncheckedFileName, projectFileName);
|
|
updateProjectIfDirty(project);
|
|
const projectInfo = {
|
|
configFileName: project.getProjectName(),
|
|
languageServiceDisabled: !project.languageServiceEnabled,
|
|
fileNames: needFileNameList ? project.getFileNames(false, excludeConfigFiles) : void 0
|
|
};
|
|
return projectInfo;
|
|
}
|
|
getRenameInfo(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const preferences = this.getPreferences(file);
|
|
return project.getLanguageService().getRenameInfo(file, position, preferences);
|
|
}
|
|
getProjects(args, getScriptInfoEnsuringProjectsUptoDate, ignoreNoProjectError) {
|
|
var _a2;
|
|
let projects;
|
|
let symLinkedProjects;
|
|
if (args.projectFileName) {
|
|
const project = this.getProject(args.projectFileName);
|
|
if (project) {
|
|
projects = [project];
|
|
}
|
|
} else {
|
|
const scriptInfo = getScriptInfoEnsuringProjectsUptoDate ? this.projectService.getScriptInfoEnsuringProjectsUptoDate(args.file) : this.projectService.getScriptInfo(args.file);
|
|
if (!scriptInfo) {
|
|
if (ignoreNoProjectError)
|
|
return emptyArray2;
|
|
this.projectService.logErrorForScriptInfoNotFound(args.file);
|
|
return Errors.ThrowNoProject();
|
|
} else if (!getScriptInfoEnsuringProjectsUptoDate) {
|
|
this.projectService.ensureDefaultProjectForFile(scriptInfo);
|
|
}
|
|
projects = scriptInfo.containingProjects;
|
|
symLinkedProjects = this.projectService.getSymlinkedProjects(scriptInfo);
|
|
}
|
|
projects = filter(projects, (p) => p.languageServiceEnabled && !p.isOrphan());
|
|
if (!ignoreNoProjectError && (!projects || !projects.length) && !symLinkedProjects) {
|
|
this.projectService.logErrorForScriptInfoNotFound((_a2 = args.file) != null ? _a2 : args.projectFileName);
|
|
return Errors.ThrowNoProject();
|
|
}
|
|
return symLinkedProjects ? { projects, symLinkedProjects } : projects;
|
|
}
|
|
getDefaultProject(args) {
|
|
if (args.projectFileName) {
|
|
const project = this.getProject(args.projectFileName);
|
|
if (project) {
|
|
return project;
|
|
}
|
|
if (!args.file) {
|
|
return Errors.ThrowNoProject();
|
|
}
|
|
}
|
|
const info = this.projectService.getScriptInfo(args.file);
|
|
return info.getDefaultProject();
|
|
}
|
|
getRenameLocations(args, simplifiedResult) {
|
|
const file = toNormalizedPath(args.file);
|
|
const position = this.getPositionInFile(args, file);
|
|
const projects = this.getProjects(args);
|
|
const defaultProject = this.getDefaultProject(args);
|
|
const preferences = this.getPreferences(file);
|
|
const renameInfo = this.mapRenameInfo(
|
|
defaultProject.getLanguageService().getRenameInfo(file, position, preferences),
|
|
Debug.checkDefined(this.projectService.getScriptInfo(file))
|
|
);
|
|
if (!renameInfo.canRename)
|
|
return simplifiedResult ? { info: renameInfo, locs: [] } : [];
|
|
const locations = getRenameLocationsWorker(
|
|
projects,
|
|
defaultProject,
|
|
{ fileName: args.file, pos: position },
|
|
!!args.findInStrings,
|
|
!!args.findInComments,
|
|
preferences
|
|
);
|
|
if (!simplifiedResult)
|
|
return locations;
|
|
return { info: renameInfo, locs: this.toSpanGroups(locations) };
|
|
}
|
|
mapRenameInfo(info, scriptInfo) {
|
|
if (info.canRename) {
|
|
const { canRename, fileToRename, displayName, fullDisplayName, kind, kindModifiers, triggerSpan } = info;
|
|
return identity(
|
|
{ canRename, fileToRename, displayName, fullDisplayName, kind, kindModifiers, triggerSpan: toProtocolTextSpan(triggerSpan, scriptInfo) }
|
|
);
|
|
} else {
|
|
return info;
|
|
}
|
|
}
|
|
toSpanGroups(locations) {
|
|
const map2 = /* @__PURE__ */ new Map();
|
|
for (const { fileName, textSpan, contextSpan, originalContextSpan: _2, originalTextSpan: _, originalFileName: _1, ...prefixSuffixText } of locations) {
|
|
let group2 = map2.get(fileName);
|
|
if (!group2)
|
|
map2.set(fileName, group2 = { file: fileName, locs: [] });
|
|
const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(fileName));
|
|
group2.locs.push({ ...toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo), ...prefixSuffixText });
|
|
}
|
|
return arrayFrom(map2.values());
|
|
}
|
|
getReferences(args, simplifiedResult) {
|
|
const file = toNormalizedPath(args.file);
|
|
const projects = this.getProjects(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const references = getReferencesWorker(
|
|
projects,
|
|
this.getDefaultProject(args),
|
|
{ fileName: args.file, pos: position },
|
|
this.logger
|
|
);
|
|
if (!simplifiedResult)
|
|
return references;
|
|
const preferences = this.getPreferences(file);
|
|
const defaultProject = this.getDefaultProject(args);
|
|
const scriptInfo = defaultProject.getScriptInfoForNormalizedPath(file);
|
|
const nameInfo = defaultProject.getLanguageService().getQuickInfoAtPosition(file, position);
|
|
const symbolDisplayString = nameInfo ? displayPartsToString(nameInfo.displayParts) : "";
|
|
const nameSpan = nameInfo && nameInfo.textSpan;
|
|
const symbolStartOffset = nameSpan ? scriptInfo.positionToLineOffset(nameSpan.start).offset : 0;
|
|
const symbolName2 = nameSpan ? scriptInfo.getSnapshot().getText(nameSpan.start, textSpanEnd(nameSpan)) : "";
|
|
const refs = flatMap(references, (referencedSymbol) => {
|
|
return referencedSymbol.references.map((entry) => referenceEntryToReferencesResponseItem(this.projectService, entry, preferences));
|
|
});
|
|
return { refs, symbolName: symbolName2, symbolStartOffset, symbolDisplayString };
|
|
}
|
|
getFileReferences(args, simplifiedResult) {
|
|
const projects = this.getProjects(args);
|
|
const fileName = args.file;
|
|
const preferences = this.getPreferences(toNormalizedPath(fileName));
|
|
const references = [];
|
|
const seen = createDocumentSpanSet();
|
|
forEachProjectInProjects(projects, void 0, (project) => {
|
|
if (project.getCancellationToken().isCancellationRequested())
|
|
return;
|
|
const projectOutputs = project.getLanguageService().getFileReferences(fileName);
|
|
if (projectOutputs) {
|
|
for (const referenceEntry of projectOutputs) {
|
|
if (!seen.has(referenceEntry)) {
|
|
references.push(referenceEntry);
|
|
seen.add(referenceEntry);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (!simplifiedResult)
|
|
return references;
|
|
const refs = references.map((entry) => referenceEntryToReferencesResponseItem(this.projectService, entry, preferences));
|
|
return {
|
|
refs,
|
|
symbolName: `"${args.file}"`
|
|
};
|
|
}
|
|
openClientFile(fileName, fileContent, scriptKind, projectRootPath) {
|
|
this.projectService.openClientFileWithNormalizedPath(fileName, fileContent, scriptKind, false, projectRootPath);
|
|
}
|
|
getPosition(args, scriptInfo) {
|
|
return args.position !== void 0 ? args.position : scriptInfo.lineOffsetToPosition(args.line, args.offset);
|
|
}
|
|
getPositionInFile(args, file) {
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return this.getPosition(args, scriptInfo);
|
|
}
|
|
getFileAndProject(args) {
|
|
return this.getFileAndProjectWorker(args.file, args.projectFileName);
|
|
}
|
|
getFileAndLanguageServiceForSyntacticOperation(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
return {
|
|
file,
|
|
languageService: project.getLanguageService(false)
|
|
};
|
|
}
|
|
getFileAndProjectWorker(uncheckedFileName, projectFileName) {
|
|
const file = toNormalizedPath(uncheckedFileName);
|
|
const project = this.getProject(projectFileName) || this.projectService.ensureDefaultProjectForFile(file);
|
|
return { file, project };
|
|
}
|
|
getOutliningSpans(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const spans = languageService.getOutliningSpans(file);
|
|
if (simplifiedResult) {
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return spans.map((s) => ({
|
|
textSpan: toProtocolTextSpan(s.textSpan, scriptInfo),
|
|
hintSpan: toProtocolTextSpan(s.hintSpan, scriptInfo),
|
|
bannerText: s.bannerText,
|
|
autoCollapse: s.autoCollapse,
|
|
kind: s.kind
|
|
}));
|
|
} else {
|
|
return spans;
|
|
}
|
|
}
|
|
getTodoComments(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
return project.getLanguageService().getTodoComments(file, args.descriptors);
|
|
}
|
|
getDocCommentTemplate(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
return languageService.getDocCommentTemplateAtPosition(file, position, this.getPreferences(file));
|
|
}
|
|
getSpanOfEnclosingComment(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const onlyMultiLine = args.onlyMultiLine;
|
|
const position = this.getPositionInFile(args, file);
|
|
return languageService.getSpanOfEnclosingComment(file, position, onlyMultiLine);
|
|
}
|
|
getIndentation(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file);
|
|
const indentation = languageService.getIndentationAtPosition(file, position, options);
|
|
return { position, indentation };
|
|
}
|
|
getBreakpointStatement(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
return languageService.getBreakpointStatementAtPosition(file, position);
|
|
}
|
|
getNameOrDottedNameSpan(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
return languageService.getNameOrDottedNameSpan(file, position, position);
|
|
}
|
|
isValidBraceCompletion(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const position = this.getPositionInFile(args, file);
|
|
return languageService.isValidBraceCompletionAtPosition(file, position, args.openingBrace.charCodeAt(0));
|
|
}
|
|
getQuickInfoWorker(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const quickInfo = project.getLanguageService().getQuickInfoAtPosition(file, this.getPosition(args, scriptInfo));
|
|
if (!quickInfo) {
|
|
return void 0;
|
|
}
|
|
const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc;
|
|
if (simplifiedResult) {
|
|
const displayString = displayPartsToString(quickInfo.displayParts);
|
|
return {
|
|
kind: quickInfo.kind,
|
|
kindModifiers: quickInfo.kindModifiers,
|
|
start: scriptInfo.positionToLineOffset(quickInfo.textSpan.start),
|
|
end: scriptInfo.positionToLineOffset(textSpanEnd(quickInfo.textSpan)),
|
|
displayString,
|
|
documentation: useDisplayParts ? this.mapDisplayParts(quickInfo.documentation, project) : displayPartsToString(quickInfo.documentation),
|
|
tags: this.mapJSDocTagInfo(quickInfo.tags, project, useDisplayParts)
|
|
};
|
|
} else {
|
|
return useDisplayParts ? quickInfo : {
|
|
...quickInfo,
|
|
tags: this.mapJSDocTagInfo(quickInfo.tags, project, false)
|
|
};
|
|
}
|
|
}
|
|
getFormattingEditsForRange(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const startPosition = scriptInfo.lineOffsetToPosition(args.line, args.offset);
|
|
const endPosition = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset);
|
|
const edits = languageService.getFormattingEditsForRange(file, startPosition, endPosition, this.getFormatOptions(file));
|
|
if (!edits) {
|
|
return void 0;
|
|
}
|
|
return edits.map((edit) => this.convertTextChangeToCodeEdit(edit, scriptInfo));
|
|
}
|
|
getFormattingEditsForRangeFull(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file);
|
|
return languageService.getFormattingEditsForRange(file, args.position, args.endPosition, options);
|
|
}
|
|
getFormattingEditsForDocumentFull(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file);
|
|
return languageService.getFormattingEditsForDocument(file, options);
|
|
}
|
|
getFormattingEditsAfterKeystrokeFull(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const options = args.options ? convertFormatOptions(args.options) : this.getFormatOptions(file);
|
|
return languageService.getFormattingEditsAfterKeystroke(file, args.position, args.key, options);
|
|
}
|
|
getFormattingEditsAfterKeystroke(args) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const position = scriptInfo.lineOffsetToPosition(args.line, args.offset);
|
|
const formatOptions = this.getFormatOptions(file);
|
|
const edits = languageService.getFormattingEditsAfterKeystroke(
|
|
file,
|
|
position,
|
|
args.key,
|
|
formatOptions
|
|
);
|
|
if (args.key === "\n" && (!edits || edits.length === 0 || allEditsBeforePos(edits, position))) {
|
|
const { lineText, absolutePosition } = scriptInfo.getAbsolutePositionAndLineText(args.line);
|
|
if (lineText && lineText.search("\\S") < 0) {
|
|
const preferredIndent = languageService.getIndentationAtPosition(file, position, formatOptions);
|
|
let hasIndent = 0;
|
|
let i, len;
|
|
for (i = 0, len = lineText.length; i < len; i++) {
|
|
if (lineText.charAt(i) === " ") {
|
|
hasIndent++;
|
|
} else if (lineText.charAt(i) === " ") {
|
|
hasIndent += formatOptions.tabSize;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (preferredIndent !== hasIndent) {
|
|
const firstNoWhiteSpacePosition = absolutePosition + i;
|
|
edits.push({
|
|
span: createTextSpanFromBounds(absolutePosition, firstNoWhiteSpacePosition),
|
|
newText: ts_formatting_exports.getIndentationString(preferredIndent, formatOptions)
|
|
});
|
|
}
|
|
}
|
|
}
|
|
if (!edits) {
|
|
return void 0;
|
|
}
|
|
return edits.map((edit) => {
|
|
return {
|
|
start: scriptInfo.positionToLineOffset(edit.span.start),
|
|
end: scriptInfo.positionToLineOffset(textSpanEnd(edit.span)),
|
|
newText: edit.newText ? edit.newText : ""
|
|
};
|
|
});
|
|
}
|
|
getCompletions(args, kind) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const position = this.getPosition(args, scriptInfo);
|
|
const completions = project.getLanguageService().getCompletionsAtPosition(
|
|
file,
|
|
position,
|
|
{
|
|
...convertUserPreferences(this.getPreferences(file)),
|
|
triggerCharacter: args.triggerCharacter,
|
|
triggerKind: args.triggerKind,
|
|
includeExternalModuleExports: args.includeExternalModuleExports,
|
|
includeInsertTextCompletions: args.includeInsertTextCompletions
|
|
},
|
|
project.projectService.getFormatCodeOptions(file)
|
|
);
|
|
if (completions === void 0)
|
|
return void 0;
|
|
if (kind === ts_server_protocol_exports.CommandTypes.CompletionsFull)
|
|
return completions;
|
|
const prefix = args.prefix || "";
|
|
const entries = mapDefined(completions.entries, (entry) => {
|
|
if (completions.isMemberCompletion || startsWith(entry.name.toLowerCase(), prefix.toLowerCase())) {
|
|
const {
|
|
name,
|
|
kind: kind2,
|
|
kindModifiers,
|
|
sortText,
|
|
insertText,
|
|
replacementSpan,
|
|
hasAction,
|
|
source,
|
|
sourceDisplay,
|
|
labelDetails,
|
|
isSnippet,
|
|
isRecommended,
|
|
isPackageJsonImport,
|
|
isImportStatementCompletion,
|
|
data
|
|
} = entry;
|
|
const convertedSpan = replacementSpan ? toProtocolTextSpan(replacementSpan, scriptInfo) : void 0;
|
|
return {
|
|
name,
|
|
kind: kind2,
|
|
kindModifiers,
|
|
sortText,
|
|
insertText,
|
|
replacementSpan: convertedSpan,
|
|
isSnippet,
|
|
hasAction: hasAction || void 0,
|
|
source,
|
|
sourceDisplay,
|
|
labelDetails,
|
|
isRecommended,
|
|
isPackageJsonImport,
|
|
isImportStatementCompletion,
|
|
data
|
|
};
|
|
}
|
|
});
|
|
if (kind === ts_server_protocol_exports.CommandTypes.Completions) {
|
|
if (completions.metadata)
|
|
entries.metadata = completions.metadata;
|
|
return entries;
|
|
}
|
|
const res = {
|
|
...completions,
|
|
optionalReplacementSpan: completions.optionalReplacementSpan && toProtocolTextSpan(completions.optionalReplacementSpan, scriptInfo),
|
|
entries
|
|
};
|
|
return res;
|
|
}
|
|
getCompletionEntryDetails(args, fullResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const position = this.getPosition(args, scriptInfo);
|
|
const formattingOptions = project.projectService.getFormatCodeOptions(file);
|
|
const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc;
|
|
const result = mapDefined(args.entryNames, (entryName) => {
|
|
const { name, source, data } = typeof entryName === "string" ? { name: entryName, source: void 0, data: void 0 } : entryName;
|
|
return project.getLanguageService().getCompletionEntryDetails(file, position, name, formattingOptions, source, this.getPreferences(file), data ? cast(data, isCompletionEntryData) : void 0);
|
|
});
|
|
return fullResult ? useDisplayParts ? result : result.map((details) => ({ ...details, tags: this.mapJSDocTagInfo(details.tags, project, false) })) : result.map((details) => ({
|
|
...details,
|
|
codeActions: map(details.codeActions, (action) => this.mapCodeAction(action)),
|
|
documentation: this.mapDisplayParts(details.documentation, project),
|
|
tags: this.mapJSDocTagInfo(details.tags, project, useDisplayParts)
|
|
}));
|
|
}
|
|
getCompileOnSaveAffectedFileList(args) {
|
|
const projects = this.getProjects(args, true, true);
|
|
const info = this.projectService.getScriptInfo(args.file);
|
|
if (!info) {
|
|
return emptyArray2;
|
|
}
|
|
return combineProjectOutput(
|
|
info,
|
|
(path) => this.projectService.getScriptInfoForPath(path),
|
|
projects,
|
|
(project, info2) => {
|
|
if (!project.compileOnSaveEnabled || !project.languageServiceEnabled || project.isOrphan()) {
|
|
return void 0;
|
|
}
|
|
const compilationSettings = project.getCompilationSettings();
|
|
if (!!compilationSettings.noEmit || isDeclarationFileName(info2.fileName) && !dtsChangeCanAffectEmit(compilationSettings)) {
|
|
return void 0;
|
|
}
|
|
return {
|
|
projectFileName: project.getProjectName(),
|
|
fileNames: project.getCompileOnSaveAffectedFileList(info2),
|
|
projectUsesOutFile: !!outFile(compilationSettings)
|
|
};
|
|
}
|
|
);
|
|
}
|
|
emitFile(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
if (!project) {
|
|
Errors.ThrowNoProject();
|
|
}
|
|
if (!project.languageServiceEnabled) {
|
|
return args.richResponse ? { emitSkipped: true, diagnostics: [] } : false;
|
|
}
|
|
const scriptInfo = project.getScriptInfo(file);
|
|
const { emitSkipped, diagnostics } = project.emitFile(scriptInfo, (path, data, writeByteOrderMark) => this.host.writeFile(path, data, writeByteOrderMark));
|
|
return args.richResponse ? {
|
|
emitSkipped,
|
|
diagnostics: args.includeLinePosition ? this.convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics) : diagnostics.map((d) => formatDiagnosticToProtocol(d, true))
|
|
} : !emitSkipped;
|
|
}
|
|
getSignatureHelpItems(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const position = this.getPosition(args, scriptInfo);
|
|
const helpItems = project.getLanguageService().getSignatureHelpItems(file, position, args);
|
|
const useDisplayParts = !!this.getPreferences(file).displayPartsForJSDoc;
|
|
if (helpItems && simplifiedResult) {
|
|
const span = helpItems.applicableSpan;
|
|
return {
|
|
...helpItems,
|
|
applicableSpan: {
|
|
start: scriptInfo.positionToLineOffset(span.start),
|
|
end: scriptInfo.positionToLineOffset(span.start + span.length)
|
|
},
|
|
items: this.mapSignatureHelpItems(helpItems.items, project, useDisplayParts)
|
|
};
|
|
} else if (useDisplayParts || !helpItems) {
|
|
return helpItems;
|
|
} else {
|
|
return {
|
|
...helpItems,
|
|
items: helpItems.items.map((item) => ({ ...item, tags: this.mapJSDocTagInfo(item.tags, project, false) }))
|
|
};
|
|
}
|
|
}
|
|
toPendingErrorCheck(uncheckedFileName) {
|
|
const fileName = toNormalizedPath(uncheckedFileName);
|
|
const project = this.projectService.tryGetDefaultProjectForFile(fileName);
|
|
return project && { fileName, project };
|
|
}
|
|
getDiagnostics(next, delay, fileNames) {
|
|
if (this.suppressDiagnosticEvents) {
|
|
return;
|
|
}
|
|
if (fileNames.length > 0) {
|
|
this.updateErrorCheck(next, fileNames, delay);
|
|
}
|
|
}
|
|
change(args) {
|
|
const scriptInfo = this.projectService.getScriptInfo(args.file);
|
|
Debug.assert(!!scriptInfo);
|
|
const start2 = scriptInfo.lineOffsetToPosition(args.line, args.offset);
|
|
const end = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset);
|
|
if (start2 >= 0) {
|
|
this.changeSeq++;
|
|
this.projectService.applyChangesToFile(scriptInfo, singleIterator({
|
|
span: { start: start2, length: end - start2 },
|
|
newText: args.insertString
|
|
}));
|
|
}
|
|
}
|
|
reload(args, reqSeq) {
|
|
const file = toNormalizedPath(args.file);
|
|
const tempFileName = args.tmpfile === void 0 ? void 0 : toNormalizedPath(args.tmpfile);
|
|
const info = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
if (info) {
|
|
this.changeSeq++;
|
|
if (info.reloadFromFile(tempFileName)) {
|
|
this.doOutput(void 0, CommandNames.Reload, reqSeq, true);
|
|
}
|
|
}
|
|
}
|
|
saveToTmp(fileName, tempFileName) {
|
|
const scriptInfo = this.projectService.getScriptInfo(fileName);
|
|
if (scriptInfo) {
|
|
scriptInfo.saveTo(tempFileName);
|
|
}
|
|
}
|
|
closeClientFile(fileName) {
|
|
if (!fileName) {
|
|
return;
|
|
}
|
|
const file = normalizePath(fileName);
|
|
this.projectService.closeClientFile(file);
|
|
}
|
|
mapLocationNavigationBarItems(items, scriptInfo) {
|
|
return map(items, (item) => ({
|
|
text: item.text,
|
|
kind: item.kind,
|
|
kindModifiers: item.kindModifiers,
|
|
spans: item.spans.map((span) => toProtocolTextSpan(span, scriptInfo)),
|
|
childItems: this.mapLocationNavigationBarItems(item.childItems, scriptInfo),
|
|
indent: item.indent
|
|
}));
|
|
}
|
|
getNavigationBarItems(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const items = languageService.getNavigationBarItems(file);
|
|
return !items ? void 0 : simplifiedResult ? this.mapLocationNavigationBarItems(items, this.projectService.getScriptInfoForNormalizedPath(file)) : items;
|
|
}
|
|
toLocationNavigationTree(tree, scriptInfo) {
|
|
return {
|
|
text: tree.text,
|
|
kind: tree.kind,
|
|
kindModifiers: tree.kindModifiers,
|
|
spans: tree.spans.map((span) => toProtocolTextSpan(span, scriptInfo)),
|
|
nameSpan: tree.nameSpan && toProtocolTextSpan(tree.nameSpan, scriptInfo),
|
|
childItems: map(tree.childItems, (item) => this.toLocationNavigationTree(item, scriptInfo))
|
|
};
|
|
}
|
|
getNavigationTree(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const tree = languageService.getNavigationTree(file);
|
|
return !tree ? void 0 : simplifiedResult ? this.toLocationNavigationTree(tree, this.projectService.getScriptInfoForNormalizedPath(file)) : tree;
|
|
}
|
|
getNavigateToItems(args, simplifiedResult) {
|
|
const full = this.getFullNavigateToItems(args);
|
|
return !simplifiedResult ? flatMap(full, ({ navigateToItems }) => navigateToItems) : flatMap(
|
|
full,
|
|
({ project, navigateToItems }) => navigateToItems.map((navItem) => {
|
|
const scriptInfo = project.getScriptInfo(navItem.fileName);
|
|
const bakedItem = {
|
|
name: navItem.name,
|
|
kind: navItem.kind,
|
|
kindModifiers: navItem.kindModifiers,
|
|
isCaseSensitive: navItem.isCaseSensitive,
|
|
matchKind: navItem.matchKind,
|
|
file: navItem.fileName,
|
|
start: scriptInfo.positionToLineOffset(navItem.textSpan.start),
|
|
end: scriptInfo.positionToLineOffset(textSpanEnd(navItem.textSpan))
|
|
};
|
|
if (navItem.kindModifiers && navItem.kindModifiers !== "") {
|
|
bakedItem.kindModifiers = navItem.kindModifiers;
|
|
}
|
|
if (navItem.containerName && navItem.containerName.length > 0) {
|
|
bakedItem.containerName = navItem.containerName;
|
|
}
|
|
if (navItem.containerKind && navItem.containerKind.length > 0) {
|
|
bakedItem.containerKind = navItem.containerKind;
|
|
}
|
|
return bakedItem;
|
|
})
|
|
);
|
|
}
|
|
getFullNavigateToItems(args) {
|
|
const { currentFileOnly, searchValue, maxResultCount, projectFileName } = args;
|
|
if (currentFileOnly) {
|
|
Debug.assertIsDefined(args.file);
|
|
const { file, project } = this.getFileAndProject(args);
|
|
return [{ project, navigateToItems: project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, file) }];
|
|
}
|
|
const outputs = [];
|
|
const seenItems = /* @__PURE__ */ new Map();
|
|
if (!args.file && !projectFileName) {
|
|
this.projectService.loadAncestorProjectTree();
|
|
this.projectService.forEachEnabledProject((project) => addItemsForProject(project));
|
|
} else {
|
|
const projects = this.getProjects(args);
|
|
forEachProjectInProjects(projects, void 0, (project) => addItemsForProject(project));
|
|
}
|
|
return outputs;
|
|
function addItemsForProject(project) {
|
|
const projectItems = project.getLanguageService().getNavigateToItems(searchValue, maxResultCount, void 0, project.isNonTsProject());
|
|
const unseenItems = filter(projectItems, (item) => tryAddSeenItem(item) && !getMappedLocationForProject(documentSpanLocation(item), project));
|
|
if (unseenItems.length) {
|
|
outputs.push({ project, navigateToItems: unseenItems });
|
|
}
|
|
}
|
|
function tryAddSeenItem(item) {
|
|
const name = item.name;
|
|
if (!seenItems.has(name)) {
|
|
seenItems.set(name, [item]);
|
|
return true;
|
|
}
|
|
const seen = seenItems.get(name);
|
|
for (const seenItem of seen) {
|
|
if (navigateToItemIsEqualTo(seenItem, item)) {
|
|
return false;
|
|
}
|
|
}
|
|
seen.push(item);
|
|
return true;
|
|
}
|
|
function navigateToItemIsEqualTo(a, b) {
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (!a || !b) {
|
|
return false;
|
|
}
|
|
return a.containerKind === b.containerKind && a.containerName === b.containerName && a.fileName === b.fileName && a.isCaseSensitive === b.isCaseSensitive && a.kind === b.kind && a.kindModifiers === b.kindModifiers && a.matchKind === b.matchKind && a.name === b.name && a.textSpan.start === b.textSpan.start && a.textSpan.length === b.textSpan.length;
|
|
}
|
|
}
|
|
getSupportedCodeFixes() {
|
|
return getSupportedCodeFixes();
|
|
}
|
|
isLocation(locationOrSpan) {
|
|
return locationOrSpan.line !== void 0;
|
|
}
|
|
extractPositionOrRange(args, scriptInfo) {
|
|
let position;
|
|
let textRange;
|
|
if (this.isLocation(args)) {
|
|
position = getPosition(args);
|
|
} else {
|
|
textRange = this.getRange(args, scriptInfo);
|
|
}
|
|
return Debug.checkDefined(position === void 0 ? textRange : position);
|
|
function getPosition(loc) {
|
|
return loc.position !== void 0 ? loc.position : scriptInfo.lineOffsetToPosition(loc.line, loc.offset);
|
|
}
|
|
}
|
|
getRange(args, scriptInfo) {
|
|
const { startPosition, endPosition } = this.getStartAndEndPosition(args, scriptInfo);
|
|
return { pos: startPosition, end: endPosition };
|
|
}
|
|
getApplicableRefactors(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
return project.getLanguageService().getApplicableRefactors(file, this.extractPositionOrRange(args, scriptInfo), this.getPreferences(file), args.triggerReason, args.kind);
|
|
}
|
|
getEditsForRefactor(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
const result = project.getLanguageService().getEditsForRefactor(
|
|
file,
|
|
this.getFormatOptions(file),
|
|
this.extractPositionOrRange(args, scriptInfo),
|
|
args.refactor,
|
|
args.action,
|
|
this.getPreferences(file)
|
|
);
|
|
if (result === void 0) {
|
|
return {
|
|
edits: []
|
|
};
|
|
}
|
|
if (simplifiedResult) {
|
|
const { renameFilename, renameLocation, edits } = result;
|
|
let mappedRenameLocation;
|
|
if (renameFilename !== void 0 && renameLocation !== void 0) {
|
|
const renameScriptInfo = project.getScriptInfoForNormalizedPath(toNormalizedPath(renameFilename));
|
|
mappedRenameLocation = getLocationInNewDocument(getSnapshotText(renameScriptInfo.getSnapshot()), renameFilename, renameLocation, edits);
|
|
}
|
|
return { renameLocation: mappedRenameLocation, renameFilename, edits: this.mapTextChangesToCodeEdits(edits) };
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
organizeImports(args, simplifiedResult) {
|
|
var _a2;
|
|
Debug.assert(args.scope.type === "file");
|
|
const { file, project } = this.getFileAndProject(args.scope.args);
|
|
const changes = project.getLanguageService().organizeImports(
|
|
{
|
|
fileName: file,
|
|
mode: (_a2 = args.mode) != null ? _a2 : args.skipDestructiveCodeActions ? "SortAndCombine" /* SortAndCombine */ : void 0,
|
|
type: "file"
|
|
},
|
|
this.getFormatOptions(file),
|
|
this.getPreferences(file)
|
|
);
|
|
if (simplifiedResult) {
|
|
return this.mapTextChangesToCodeEdits(changes);
|
|
} else {
|
|
return changes;
|
|
}
|
|
}
|
|
getEditsForFileRename(args, simplifiedResult) {
|
|
const oldPath = toNormalizedPath(args.oldFilePath);
|
|
const newPath = toNormalizedPath(args.newFilePath);
|
|
const formatOptions = this.getHostFormatOptions();
|
|
const preferences = this.getHostPreferences();
|
|
const seenFiles = /* @__PURE__ */ new Set();
|
|
const textChanges2 = [];
|
|
this.projectService.loadAncestorProjectTree();
|
|
this.projectService.forEachEnabledProject((project) => {
|
|
const projectTextChanges = project.getLanguageService().getEditsForFileRename(oldPath, newPath, formatOptions, preferences);
|
|
const projectFiles = [];
|
|
for (const textChange of projectTextChanges) {
|
|
if (!seenFiles.has(textChange.fileName)) {
|
|
textChanges2.push(textChange);
|
|
projectFiles.push(textChange.fileName);
|
|
}
|
|
}
|
|
for (const file of projectFiles) {
|
|
seenFiles.add(file);
|
|
}
|
|
});
|
|
return simplifiedResult ? textChanges2.map((c) => this.mapTextChangeToCodeEdit(c)) : textChanges2;
|
|
}
|
|
getCodeFixes(args, simplifiedResult) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = project.getScriptInfoForNormalizedPath(file);
|
|
const { startPosition, endPosition } = this.getStartAndEndPosition(args, scriptInfo);
|
|
let codeActions;
|
|
try {
|
|
codeActions = project.getLanguageService().getCodeFixesAtPosition(file, startPosition, endPosition, args.errorCodes, this.getFormatOptions(file), this.getPreferences(file));
|
|
} catch (e) {
|
|
const ls = project.getLanguageService();
|
|
const existingDiagCodes = [
|
|
...ls.getSyntacticDiagnostics(file),
|
|
...ls.getSemanticDiagnostics(file),
|
|
...ls.getSuggestionDiagnostics(file)
|
|
].map((d) => decodedTextSpanIntersectsWith(startPosition, endPosition - startPosition, d.start, d.length) && d.code);
|
|
const badCode = args.errorCodes.find((c) => !existingDiagCodes.includes(c));
|
|
if (badCode !== void 0) {
|
|
e.message = `BADCLIENT: Bad error code, ${badCode} not found in range ${startPosition}..${endPosition} (found: ${existingDiagCodes.join(", ")}); could have caused this error:
|
|
${e.message}`;
|
|
}
|
|
throw e;
|
|
}
|
|
return simplifiedResult ? codeActions.map((codeAction) => this.mapCodeFixAction(codeAction)) : codeActions;
|
|
}
|
|
getCombinedCodeFix({ scope, fixId: fixId52 }, simplifiedResult) {
|
|
Debug.assert(scope.type === "file");
|
|
const { file, project } = this.getFileAndProject(scope.args);
|
|
const res = project.getLanguageService().getCombinedCodeFix({ type: "file", fileName: file }, fixId52, this.getFormatOptions(file), this.getPreferences(file));
|
|
if (simplifiedResult) {
|
|
return { changes: this.mapTextChangesToCodeEdits(res.changes), commands: res.commands };
|
|
} else {
|
|
return res;
|
|
}
|
|
}
|
|
applyCodeActionCommand(args) {
|
|
const commands = args.command;
|
|
for (const command of toArray(commands)) {
|
|
const { file, project } = this.getFileAndProject(command);
|
|
project.getLanguageService().applyCodeActionCommand(command, this.getFormatOptions(file)).then(
|
|
(_result) => {
|
|
},
|
|
(_error) => {
|
|
}
|
|
);
|
|
}
|
|
return {};
|
|
}
|
|
getStartAndEndPosition(args, scriptInfo) {
|
|
let startPosition, endPosition;
|
|
if (args.startPosition !== void 0) {
|
|
startPosition = args.startPosition;
|
|
} else {
|
|
startPosition = scriptInfo.lineOffsetToPosition(args.startLine, args.startOffset);
|
|
args.startPosition = startPosition;
|
|
}
|
|
if (args.endPosition !== void 0) {
|
|
endPosition = args.endPosition;
|
|
} else {
|
|
endPosition = scriptInfo.lineOffsetToPosition(args.endLine, args.endOffset);
|
|
args.endPosition = endPosition;
|
|
}
|
|
return { startPosition, endPosition };
|
|
}
|
|
mapCodeAction({ description: description2, changes, commands }) {
|
|
return { description: description2, changes: this.mapTextChangesToCodeEdits(changes), commands };
|
|
}
|
|
mapCodeFixAction({ fixName: fixName8, description: description2, changes, commands, fixId: fixId52, fixAllDescription }) {
|
|
return { fixName: fixName8, description: description2, changes: this.mapTextChangesToCodeEdits(changes), commands, fixId: fixId52, fixAllDescription };
|
|
}
|
|
mapTextChangesToCodeEdits(textChanges2) {
|
|
return textChanges2.map((change) => this.mapTextChangeToCodeEdit(change));
|
|
}
|
|
mapTextChangeToCodeEdit(textChanges2) {
|
|
const scriptInfo = this.projectService.getScriptInfoOrConfig(textChanges2.fileName);
|
|
if (!!textChanges2.isNewFile === !!scriptInfo) {
|
|
if (!scriptInfo) {
|
|
this.projectService.logErrorForScriptInfoNotFound(textChanges2.fileName);
|
|
}
|
|
Debug.fail("Expected isNewFile for (only) new files. " + JSON.stringify({ isNewFile: !!textChanges2.isNewFile, hasScriptInfo: !!scriptInfo }));
|
|
}
|
|
return scriptInfo ? { fileName: textChanges2.fileName, textChanges: textChanges2.textChanges.map((textChange) => convertTextChangeToCodeEdit(textChange, scriptInfo)) } : convertNewFileTextChangeToCodeEdit(textChanges2);
|
|
}
|
|
convertTextChangeToCodeEdit(change, scriptInfo) {
|
|
return {
|
|
start: scriptInfo.positionToLineOffset(change.span.start),
|
|
end: scriptInfo.positionToLineOffset(change.span.start + change.span.length),
|
|
newText: change.newText ? change.newText : ""
|
|
};
|
|
}
|
|
getBraceMatching(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const position = this.getPosition(args, scriptInfo);
|
|
const spans = languageService.getBraceMatchingAtPosition(file, position);
|
|
return !spans ? void 0 : simplifiedResult ? spans.map((span) => toProtocolTextSpan(span, scriptInfo)) : spans;
|
|
}
|
|
getDiagnosticsForProject(next, delay, fileName) {
|
|
if (this.suppressDiagnosticEvents) {
|
|
return;
|
|
}
|
|
const { fileNames, languageServiceDisabled } = this.getProjectInfoWorker(fileName, void 0, true, true);
|
|
if (languageServiceDisabled) {
|
|
return;
|
|
}
|
|
const fileNamesInProject = fileNames.filter((value) => !stringContains(value, "lib.d.ts"));
|
|
if (fileNamesInProject.length === 0) {
|
|
return;
|
|
}
|
|
const highPriorityFiles = [];
|
|
const mediumPriorityFiles = [];
|
|
const lowPriorityFiles = [];
|
|
const veryLowPriorityFiles = [];
|
|
const normalizedFileName = toNormalizedPath(fileName);
|
|
const project = this.projectService.ensureDefaultProjectForFile(normalizedFileName);
|
|
for (const fileNameInProject of fileNamesInProject) {
|
|
if (this.getCanonicalFileName(fileNameInProject) === this.getCanonicalFileName(fileName)) {
|
|
highPriorityFiles.push(fileNameInProject);
|
|
} else {
|
|
const info = this.projectService.getScriptInfo(fileNameInProject);
|
|
if (!info.isScriptOpen()) {
|
|
if (isDeclarationFileName(fileNameInProject)) {
|
|
veryLowPriorityFiles.push(fileNameInProject);
|
|
} else {
|
|
lowPriorityFiles.push(fileNameInProject);
|
|
}
|
|
} else {
|
|
mediumPriorityFiles.push(fileNameInProject);
|
|
}
|
|
}
|
|
}
|
|
const sortedFiles = [...highPriorityFiles, ...mediumPriorityFiles, ...lowPriorityFiles, ...veryLowPriorityFiles];
|
|
const checkList = sortedFiles.map((fileName2) => ({ fileName: fileName2, project }));
|
|
this.updateErrorCheck(next, checkList, delay, false);
|
|
}
|
|
configurePlugin(args) {
|
|
this.projectService.configurePlugin(args);
|
|
}
|
|
getSmartSelectionRange(args, simplifiedResult) {
|
|
const { locations } = args;
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = Debug.checkDefined(this.projectService.getScriptInfo(file));
|
|
return map(locations, (location2) => {
|
|
const pos = this.getPosition(location2, scriptInfo);
|
|
const selectionRange = languageService.getSmartSelectionRange(file, pos);
|
|
return simplifiedResult ? this.mapSelectionRange(selectionRange, scriptInfo) : selectionRange;
|
|
});
|
|
}
|
|
toggleLineComment(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfo(file);
|
|
const textRange = this.getRange(args, scriptInfo);
|
|
const textChanges2 = languageService.toggleLineComment(file, textRange);
|
|
if (simplifiedResult) {
|
|
const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2));
|
|
}
|
|
return textChanges2;
|
|
}
|
|
toggleMultilineComment(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const textRange = this.getRange(args, scriptInfo);
|
|
const textChanges2 = languageService.toggleMultilineComment(file, textRange);
|
|
if (simplifiedResult) {
|
|
const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2));
|
|
}
|
|
return textChanges2;
|
|
}
|
|
commentSelection(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const textRange = this.getRange(args, scriptInfo);
|
|
const textChanges2 = languageService.commentSelection(file, textRange);
|
|
if (simplifiedResult) {
|
|
const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2));
|
|
}
|
|
return textChanges2;
|
|
}
|
|
uncommentSelection(args, simplifiedResult) {
|
|
const { file, languageService } = this.getFileAndLanguageServiceForSyntacticOperation(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
const textRange = this.getRange(args, scriptInfo);
|
|
const textChanges2 = languageService.uncommentSelection(file, textRange);
|
|
if (simplifiedResult) {
|
|
const scriptInfo2 = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
return textChanges2.map((textChange) => this.convertTextChangeToCodeEdit(textChange, scriptInfo2));
|
|
}
|
|
return textChanges2;
|
|
}
|
|
mapSelectionRange(selectionRange, scriptInfo) {
|
|
const result = {
|
|
textSpan: toProtocolTextSpan(selectionRange.textSpan, scriptInfo)
|
|
};
|
|
if (selectionRange.parent) {
|
|
result.parent = this.mapSelectionRange(selectionRange.parent, scriptInfo);
|
|
}
|
|
return result;
|
|
}
|
|
getScriptInfoFromProjectService(file) {
|
|
const normalizedFile = toNormalizedPath(file);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(normalizedFile);
|
|
if (!scriptInfo) {
|
|
this.projectService.logErrorForScriptInfoNotFound(normalizedFile);
|
|
return Errors.ThrowNoProject();
|
|
}
|
|
return scriptInfo;
|
|
}
|
|
toProtocolCallHierarchyItem(item) {
|
|
const scriptInfo = this.getScriptInfoFromProjectService(item.file);
|
|
return {
|
|
name: item.name,
|
|
kind: item.kind,
|
|
kindModifiers: item.kindModifiers,
|
|
file: item.file,
|
|
containerName: item.containerName,
|
|
span: toProtocolTextSpan(item.span, scriptInfo),
|
|
selectionSpan: toProtocolTextSpan(item.selectionSpan, scriptInfo)
|
|
};
|
|
}
|
|
toProtocolCallHierarchyIncomingCall(incomingCall) {
|
|
const scriptInfo = this.getScriptInfoFromProjectService(incomingCall.from.file);
|
|
return {
|
|
from: this.toProtocolCallHierarchyItem(incomingCall.from),
|
|
fromSpans: incomingCall.fromSpans.map((fromSpan) => toProtocolTextSpan(fromSpan, scriptInfo))
|
|
};
|
|
}
|
|
toProtocolCallHierarchyOutgoingCall(outgoingCall, scriptInfo) {
|
|
return {
|
|
to: this.toProtocolCallHierarchyItem(outgoingCall.to),
|
|
fromSpans: outgoingCall.fromSpans.map((fromSpan) => toProtocolTextSpan(fromSpan, scriptInfo))
|
|
};
|
|
}
|
|
prepareCallHierarchy(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
|
|
if (scriptInfo) {
|
|
const position = this.getPosition(args, scriptInfo);
|
|
const result = project.getLanguageService().prepareCallHierarchy(file, position);
|
|
return result && mapOneOrMany(result, (item) => this.toProtocolCallHierarchyItem(item));
|
|
}
|
|
return void 0;
|
|
}
|
|
provideCallHierarchyIncomingCalls(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.getScriptInfoFromProjectService(file);
|
|
const incomingCalls = project.getLanguageService().provideCallHierarchyIncomingCalls(file, this.getPosition(args, scriptInfo));
|
|
return incomingCalls.map((call) => this.toProtocolCallHierarchyIncomingCall(call));
|
|
}
|
|
provideCallHierarchyOutgoingCalls(args) {
|
|
const { file, project } = this.getFileAndProject(args);
|
|
const scriptInfo = this.getScriptInfoFromProjectService(file);
|
|
const outgoingCalls = project.getLanguageService().provideCallHierarchyOutgoingCalls(file, this.getPosition(args, scriptInfo));
|
|
return outgoingCalls.map((call) => this.toProtocolCallHierarchyOutgoingCall(call, scriptInfo));
|
|
}
|
|
getCanonicalFileName(fileName) {
|
|
const name = this.host.useCaseSensitiveFileNames ? fileName : toFileNameLowerCase(fileName);
|
|
return normalizePath(name);
|
|
}
|
|
exit() {
|
|
}
|
|
notRequired() {
|
|
return { responseRequired: false };
|
|
}
|
|
requiredResponse(response) {
|
|
return { response, responseRequired: true };
|
|
}
|
|
addProtocolHandler(command, handler) {
|
|
if (this.handlers.has(command)) {
|
|
throw new Error(`Protocol handler already exists for command "${command}"`);
|
|
}
|
|
this.handlers.set(command, handler);
|
|
}
|
|
setCurrentRequest(requestId) {
|
|
Debug.assert(this.currentRequestId === void 0);
|
|
this.currentRequestId = requestId;
|
|
this.cancellationToken.setRequest(requestId);
|
|
}
|
|
resetCurrentRequest(requestId) {
|
|
Debug.assert(this.currentRequestId === requestId);
|
|
this.currentRequestId = void 0;
|
|
this.cancellationToken.resetRequest(requestId);
|
|
}
|
|
executeWithRequestId(requestId, f) {
|
|
try {
|
|
this.setCurrentRequest(requestId);
|
|
return f();
|
|
} finally {
|
|
this.resetCurrentRequest(requestId);
|
|
}
|
|
}
|
|
executeCommand(request) {
|
|
const handler = this.handlers.get(request.command);
|
|
if (handler) {
|
|
const response = this.executeWithRequestId(request.seq, () => handler(request));
|
|
this.projectService.enableRequestedPlugins();
|
|
return response;
|
|
} else {
|
|
this.logger.msg(`Unrecognized JSON command:${stringifyIndented(request)}`, "Err" /* Err */);
|
|
this.doOutput(void 0, CommandNames.Unknown, request.seq, false, `Unrecognized JSON command: ${request.command}`);
|
|
return { responseRequired: false };
|
|
}
|
|
}
|
|
onMessage(message) {
|
|
var _a2, _b, _c, _d, _e, _f, _g;
|
|
this.gcTimer.scheduleCollect();
|
|
this.performanceData = void 0;
|
|
let start2;
|
|
if (this.logger.hasLevel(2 /* requestTime */)) {
|
|
start2 = this.hrtime();
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`request:${indent2(this.toStringMessage(message))}`);
|
|
}
|
|
}
|
|
let request;
|
|
let relevantFile;
|
|
try {
|
|
request = this.parseMessage(message);
|
|
relevantFile = request.arguments && request.arguments.file ? request.arguments : void 0;
|
|
(_a2 = tracing) == null ? void 0 : _a2.instant(tracing.Phase.Session, "request", { seq: request.seq, command: request.command });
|
|
perfLogger.logStartCommand("" + request.command, this.toStringMessage(message).substring(0, 100));
|
|
(_b = tracing) == null ? void 0 : _b.push(tracing.Phase.Session, "executeCommand", { seq: request.seq, command: request.command }, true);
|
|
const { response, responseRequired } = this.executeCommand(request);
|
|
(_c = tracing) == null ? void 0 : _c.pop();
|
|
if (this.logger.hasLevel(2 /* requestTime */)) {
|
|
const elapsedTime = hrTimeToMilliseconds(this.hrtime(start2)).toFixed(4);
|
|
if (responseRequired) {
|
|
this.logger.perftrc(`${request.seq}::${request.command}: elapsed time (in milliseconds) ${elapsedTime}`);
|
|
} else {
|
|
this.logger.perftrc(`${request.seq}::${request.command}: async elapsed time (in milliseconds) ${elapsedTime}`);
|
|
}
|
|
}
|
|
perfLogger.logStopCommand("" + request.command, "Success");
|
|
(_d = tracing) == null ? void 0 : _d.instant(tracing.Phase.Session, "response", { seq: request.seq, command: request.command, success: !!response });
|
|
if (response) {
|
|
this.doOutput(response, request.command, request.seq, true);
|
|
} else if (responseRequired) {
|
|
this.doOutput(void 0, request.command, request.seq, false, "No content available.");
|
|
}
|
|
} catch (err) {
|
|
(_e = tracing) == null ? void 0 : _e.popAll();
|
|
if (err instanceof OperationCanceledException) {
|
|
perfLogger.logStopCommand("" + (request && request.command), "Canceled: " + err);
|
|
(_f = tracing) == null ? void 0 : _f.instant(tracing.Phase.Session, "commandCanceled", { seq: request == null ? void 0 : request.seq, command: request == null ? void 0 : request.command });
|
|
this.doOutput({ canceled: true }, request.command, request.seq, true);
|
|
return;
|
|
}
|
|
this.logErrorWorker(err, this.toStringMessage(message), relevantFile);
|
|
perfLogger.logStopCommand("" + (request && request.command), "Error: " + err);
|
|
(_g = tracing) == null ? void 0 : _g.instant(tracing.Phase.Session, "commandError", { seq: request == null ? void 0 : request.seq, command: request == null ? void 0 : request.command, message: err.message });
|
|
this.doOutput(
|
|
void 0,
|
|
request ? request.command : CommandNames.Unknown,
|
|
request ? request.seq : 0,
|
|
false,
|
|
"Error processing request. " + err.message + "\n" + err.stack
|
|
);
|
|
}
|
|
}
|
|
parseMessage(message) {
|
|
return JSON.parse(message);
|
|
}
|
|
toStringMessage(message) {
|
|
return message;
|
|
}
|
|
getFormatOptions(file) {
|
|
return this.projectService.getFormatCodeOptions(file);
|
|
}
|
|
getPreferences(file) {
|
|
return this.projectService.getPreferences(file);
|
|
}
|
|
getHostFormatOptions() {
|
|
return this.projectService.getHostFormatCodeOptions();
|
|
}
|
|
getHostPreferences() {
|
|
return this.projectService.getHostPreferences();
|
|
}
|
|
};
|
|
function toProtocolTextSpan(textSpan, scriptInfo) {
|
|
return {
|
|
start: scriptInfo.positionToLineOffset(textSpan.start),
|
|
end: scriptInfo.positionToLineOffset(textSpanEnd(textSpan))
|
|
};
|
|
}
|
|
function toProtocolTextSpanWithContext(span, contextSpan, scriptInfo) {
|
|
const textSpan = toProtocolTextSpan(span, scriptInfo);
|
|
const contextTextSpan = contextSpan && toProtocolTextSpan(contextSpan, scriptInfo);
|
|
return contextTextSpan ? { ...textSpan, contextStart: contextTextSpan.start, contextEnd: contextTextSpan.end } : textSpan;
|
|
}
|
|
function convertTextChangeToCodeEdit(change, scriptInfo) {
|
|
return { start: positionToLineOffset(scriptInfo, change.span.start), end: positionToLineOffset(scriptInfo, textSpanEnd(change.span)), newText: change.newText };
|
|
}
|
|
function positionToLineOffset(info, position) {
|
|
return isConfigFile(info) ? locationFromLineAndCharacter(info.getLineAndCharacterOfPosition(position)) : info.positionToLineOffset(position);
|
|
}
|
|
function locationFromLineAndCharacter(lc) {
|
|
return { line: lc.line + 1, offset: lc.character + 1 };
|
|
}
|
|
function convertNewFileTextChangeToCodeEdit(textChanges2) {
|
|
Debug.assert(textChanges2.textChanges.length === 1);
|
|
const change = first(textChanges2.textChanges);
|
|
Debug.assert(change.span.start === 0 && change.span.length === 0);
|
|
return { fileName: textChanges2.fileName, textChanges: [{ start: { line: 0, offset: 0 }, end: { line: 0, offset: 0 }, newText: change.newText }] };
|
|
}
|
|
function getLocationInNewDocument(oldText, renameFilename, renameLocation, edits) {
|
|
const newText = applyEdits(oldText, renameFilename, edits);
|
|
const { line, character } = computeLineAndCharacterOfPosition(computeLineStarts(newText), renameLocation);
|
|
return { line: line + 1, offset: character + 1 };
|
|
}
|
|
function applyEdits(text, textFilename, edits) {
|
|
for (const { fileName, textChanges: textChanges2 } of edits) {
|
|
if (fileName !== textFilename) {
|
|
continue;
|
|
}
|
|
for (let i = textChanges2.length - 1; i >= 0; i--) {
|
|
const { newText, span: { start: start2, length: length2 } } = textChanges2[i];
|
|
text = text.slice(0, start2) + newText + text.slice(start2 + length2);
|
|
}
|
|
}
|
|
return text;
|
|
}
|
|
function referenceEntryToReferencesResponseItem(projectService, { fileName, textSpan, contextSpan, isWriteAccess: isWriteAccess2, isDefinition }, { disableLineTextInReferences }) {
|
|
const scriptInfo = Debug.checkDefined(projectService.getScriptInfo(fileName));
|
|
const span = toProtocolTextSpanWithContext(textSpan, contextSpan, scriptInfo);
|
|
const lineText = disableLineTextInReferences ? void 0 : getLineText(scriptInfo, span);
|
|
return {
|
|
file: fileName,
|
|
...span,
|
|
lineText,
|
|
isWriteAccess: isWriteAccess2,
|
|
isDefinition
|
|
};
|
|
}
|
|
function getLineText(scriptInfo, span) {
|
|
const lineSpan = scriptInfo.lineToTextSpan(span.start.line - 1);
|
|
return scriptInfo.getSnapshot().getText(lineSpan.start, textSpanEnd(lineSpan)).replace(/\r|\n/g, "");
|
|
}
|
|
function isCompletionEntryData(data) {
|
|
return data === void 0 || data && typeof data === "object" && typeof data.exportName === "string" && (data.fileName === void 0 || typeof data.fileName === "string") && (data.ambientModuleName === void 0 || typeof data.ambientModuleName === "string" && (data.isPackageJsonImport === void 0 || typeof data.isPackageJsonImport === "boolean"));
|
|
}
|
|
|
|
// src/server/scriptVersionCache.ts
|
|
var lineCollectionCapacity = 4;
|
|
var CharRangeSection = /* @__PURE__ */ ((CharRangeSection2) => {
|
|
CharRangeSection2[CharRangeSection2["PreStart"] = 0] = "PreStart";
|
|
CharRangeSection2[CharRangeSection2["Start"] = 1] = "Start";
|
|
CharRangeSection2[CharRangeSection2["Entire"] = 2] = "Entire";
|
|
CharRangeSection2[CharRangeSection2["Mid"] = 3] = "Mid";
|
|
CharRangeSection2[CharRangeSection2["End"] = 4] = "End";
|
|
CharRangeSection2[CharRangeSection2["PostEnd"] = 5] = "PostEnd";
|
|
return CharRangeSection2;
|
|
})(CharRangeSection || {});
|
|
var EditWalker = class {
|
|
constructor() {
|
|
this.goSubtree = true;
|
|
this.lineIndex = new LineIndex();
|
|
this.endBranch = [];
|
|
this.state = 2 /* Entire */;
|
|
this.initialText = "";
|
|
this.trailingText = "";
|
|
this.lineIndex.root = new LineNode();
|
|
this.startPath = [this.lineIndex.root];
|
|
this.stack = [this.lineIndex.root];
|
|
}
|
|
get done() {
|
|
return false;
|
|
}
|
|
insertLines(insertedText, suppressTrailingText) {
|
|
if (suppressTrailingText) {
|
|
this.trailingText = "";
|
|
}
|
|
if (insertedText) {
|
|
insertedText = this.initialText + insertedText + this.trailingText;
|
|
} else {
|
|
insertedText = this.initialText + this.trailingText;
|
|
}
|
|
const lm = LineIndex.linesFromText(insertedText);
|
|
const lines = lm.lines;
|
|
if (lines.length > 1 && lines[lines.length - 1] === "") {
|
|
lines.pop();
|
|
}
|
|
let branchParent;
|
|
let lastZeroCount;
|
|
for (let k = this.endBranch.length - 1; k >= 0; k--) {
|
|
this.endBranch[k].updateCounts();
|
|
if (this.endBranch[k].charCount() === 0) {
|
|
lastZeroCount = this.endBranch[k];
|
|
if (k > 0) {
|
|
branchParent = this.endBranch[k - 1];
|
|
} else {
|
|
branchParent = this.branchNode;
|
|
}
|
|
}
|
|
}
|
|
if (lastZeroCount) {
|
|
branchParent.remove(lastZeroCount);
|
|
}
|
|
const leafNode = this.startPath[this.startPath.length - 1];
|
|
if (lines.length > 0) {
|
|
leafNode.text = lines[0];
|
|
if (lines.length > 1) {
|
|
let insertedNodes = new Array(lines.length - 1);
|
|
let startNode2 = leafNode;
|
|
for (let i = 1; i < lines.length; i++) {
|
|
insertedNodes[i - 1] = new LineLeaf(lines[i]);
|
|
}
|
|
let pathIndex = this.startPath.length - 2;
|
|
while (pathIndex >= 0) {
|
|
const insertionNode = this.startPath[pathIndex];
|
|
insertedNodes = insertionNode.insertAt(startNode2, insertedNodes);
|
|
pathIndex--;
|
|
startNode2 = insertionNode;
|
|
}
|
|
let insertedNodesLen = insertedNodes.length;
|
|
while (insertedNodesLen > 0) {
|
|
const newRoot = new LineNode();
|
|
newRoot.add(this.lineIndex.root);
|
|
insertedNodes = newRoot.insertAt(this.lineIndex.root, insertedNodes);
|
|
insertedNodesLen = insertedNodes.length;
|
|
this.lineIndex.root = newRoot;
|
|
}
|
|
this.lineIndex.root.updateCounts();
|
|
} else {
|
|
for (let j = this.startPath.length - 2; j >= 0; j--) {
|
|
this.startPath[j].updateCounts();
|
|
}
|
|
}
|
|
} else {
|
|
const insertionNode = this.startPath[this.startPath.length - 2];
|
|
insertionNode.remove(leafNode);
|
|
for (let j = this.startPath.length - 2; j >= 0; j--) {
|
|
this.startPath[j].updateCounts();
|
|
}
|
|
}
|
|
return this.lineIndex;
|
|
}
|
|
post(_relativeStart, _relativeLength, lineCollection) {
|
|
if (lineCollection === this.lineCollectionAtBranch) {
|
|
this.state = 4 /* End */;
|
|
}
|
|
this.stack.pop();
|
|
}
|
|
pre(_relativeStart, _relativeLength, lineCollection, _parent, nodeType) {
|
|
const currentNode = this.stack[this.stack.length - 1];
|
|
if (this.state === 2 /* Entire */ && nodeType === 1 /* Start */) {
|
|
this.state = 1 /* Start */;
|
|
this.branchNode = currentNode;
|
|
this.lineCollectionAtBranch = lineCollection;
|
|
}
|
|
let child;
|
|
function fresh(node) {
|
|
if (node.isLeaf()) {
|
|
return new LineLeaf("");
|
|
} else
|
|
return new LineNode();
|
|
}
|
|
switch (nodeType) {
|
|
case 0 /* PreStart */:
|
|
this.goSubtree = false;
|
|
if (this.state !== 4 /* End */) {
|
|
currentNode.add(lineCollection);
|
|
}
|
|
break;
|
|
case 1 /* Start */:
|
|
if (this.state === 4 /* End */) {
|
|
this.goSubtree = false;
|
|
} else {
|
|
child = fresh(lineCollection);
|
|
currentNode.add(child);
|
|
this.startPath.push(child);
|
|
}
|
|
break;
|
|
case 2 /* Entire */:
|
|
if (this.state !== 4 /* End */) {
|
|
child = fresh(lineCollection);
|
|
currentNode.add(child);
|
|
this.startPath.push(child);
|
|
} else {
|
|
if (!lineCollection.isLeaf()) {
|
|
child = fresh(lineCollection);
|
|
currentNode.add(child);
|
|
this.endBranch.push(child);
|
|
}
|
|
}
|
|
break;
|
|
case 3 /* Mid */:
|
|
this.goSubtree = false;
|
|
break;
|
|
case 4 /* End */:
|
|
if (this.state !== 4 /* End */) {
|
|
this.goSubtree = false;
|
|
} else {
|
|
if (!lineCollection.isLeaf()) {
|
|
child = fresh(lineCollection);
|
|
currentNode.add(child);
|
|
this.endBranch.push(child);
|
|
}
|
|
}
|
|
break;
|
|
case 5 /* PostEnd */:
|
|
this.goSubtree = false;
|
|
if (this.state !== 1 /* Start */) {
|
|
currentNode.add(lineCollection);
|
|
}
|
|
break;
|
|
}
|
|
if (this.goSubtree) {
|
|
this.stack.push(child);
|
|
}
|
|
}
|
|
leaf(relativeStart, relativeLength, ll) {
|
|
if (this.state === 1 /* Start */) {
|
|
this.initialText = ll.text.substring(0, relativeStart);
|
|
} else if (this.state === 2 /* Entire */) {
|
|
this.initialText = ll.text.substring(0, relativeStart);
|
|
this.trailingText = ll.text.substring(relativeStart + relativeLength);
|
|
} else {
|
|
this.trailingText = ll.text.substring(relativeStart + relativeLength);
|
|
}
|
|
}
|
|
};
|
|
var TextChange9 = class {
|
|
constructor(pos, deleteLen, insertedText) {
|
|
this.pos = pos;
|
|
this.deleteLen = deleteLen;
|
|
this.insertedText = insertedText;
|
|
}
|
|
getTextChangeRange() {
|
|
return createTextChangeRange(
|
|
createTextSpan(this.pos, this.deleteLen),
|
|
this.insertedText ? this.insertedText.length : 0
|
|
);
|
|
}
|
|
};
|
|
var _ScriptVersionCache = class {
|
|
constructor() {
|
|
this.changes = [];
|
|
this.versions = new Array(_ScriptVersionCache.maxVersions);
|
|
this.minVersion = 0;
|
|
this.currentVersion = 0;
|
|
}
|
|
versionToIndex(version2) {
|
|
if (version2 < this.minVersion || version2 > this.currentVersion) {
|
|
return void 0;
|
|
}
|
|
return version2 % _ScriptVersionCache.maxVersions;
|
|
}
|
|
currentVersionToIndex() {
|
|
return this.currentVersion % _ScriptVersionCache.maxVersions;
|
|
}
|
|
edit(pos, deleteLen, insertedText) {
|
|
this.changes.push(new TextChange9(pos, deleteLen, insertedText));
|
|
if (this.changes.length > _ScriptVersionCache.changeNumberThreshold || deleteLen > _ScriptVersionCache.changeLengthThreshold || insertedText && insertedText.length > _ScriptVersionCache.changeLengthThreshold) {
|
|
this.getSnapshot();
|
|
}
|
|
}
|
|
getSnapshot() {
|
|
return this._getSnapshot();
|
|
}
|
|
_getSnapshot() {
|
|
let snap = this.versions[this.currentVersionToIndex()];
|
|
if (this.changes.length > 0) {
|
|
let snapIndex = snap.index;
|
|
for (const change of this.changes) {
|
|
snapIndex = snapIndex.edit(change.pos, change.deleteLen, change.insertedText);
|
|
}
|
|
snap = new LineIndexSnapshot(this.currentVersion + 1, this, snapIndex, this.changes);
|
|
this.currentVersion = snap.version;
|
|
this.versions[this.currentVersionToIndex()] = snap;
|
|
this.changes = [];
|
|
if (this.currentVersion - this.minVersion >= _ScriptVersionCache.maxVersions) {
|
|
this.minVersion = this.currentVersion - _ScriptVersionCache.maxVersions + 1;
|
|
}
|
|
}
|
|
return snap;
|
|
}
|
|
getSnapshotVersion() {
|
|
return this._getSnapshot().version;
|
|
}
|
|
getAbsolutePositionAndLineText(oneBasedLine) {
|
|
return this._getSnapshot().index.lineNumberToInfo(oneBasedLine);
|
|
}
|
|
lineOffsetToPosition(line, column) {
|
|
return this._getSnapshot().index.absolutePositionOfStartOfLine(line) + (column - 1);
|
|
}
|
|
positionToLineOffset(position) {
|
|
return this._getSnapshot().index.positionToLineOffset(position);
|
|
}
|
|
lineToTextSpan(line) {
|
|
const index = this._getSnapshot().index;
|
|
const { lineText, absolutePosition } = index.lineNumberToInfo(line + 1);
|
|
const len = lineText !== void 0 ? lineText.length : index.absolutePositionOfStartOfLine(line + 2) - absolutePosition;
|
|
return createTextSpan(absolutePosition, len);
|
|
}
|
|
getTextChangesBetweenVersions(oldVersion, newVersion) {
|
|
if (oldVersion < newVersion) {
|
|
if (oldVersion >= this.minVersion) {
|
|
const textChangeRanges = [];
|
|
for (let i = oldVersion + 1; i <= newVersion; i++) {
|
|
const snap = this.versions[this.versionToIndex(i)];
|
|
for (const textChange of snap.changesSincePreviousVersion) {
|
|
textChangeRanges.push(textChange.getTextChangeRange());
|
|
}
|
|
}
|
|
return collapseTextChangeRangesAcrossMultipleVersions(textChangeRanges);
|
|
} else {
|
|
return void 0;
|
|
}
|
|
} else {
|
|
return unchangedTextChangeRange;
|
|
}
|
|
}
|
|
getLineCount() {
|
|
return this._getSnapshot().index.getLineCount();
|
|
}
|
|
static fromString(script) {
|
|
const svc = new _ScriptVersionCache();
|
|
const snap = new LineIndexSnapshot(0, svc, new LineIndex());
|
|
svc.versions[svc.currentVersion] = snap;
|
|
const lm = LineIndex.linesFromText(script);
|
|
snap.index.load(lm.lines);
|
|
return svc;
|
|
}
|
|
};
|
|
var ScriptVersionCache = _ScriptVersionCache;
|
|
ScriptVersionCache.changeNumberThreshold = 8;
|
|
ScriptVersionCache.changeLengthThreshold = 256;
|
|
ScriptVersionCache.maxVersions = 8;
|
|
var LineIndexSnapshot = class {
|
|
constructor(version2, cache, index, changesSincePreviousVersion = emptyArray2) {
|
|
this.version = version2;
|
|
this.cache = cache;
|
|
this.index = index;
|
|
this.changesSincePreviousVersion = changesSincePreviousVersion;
|
|
}
|
|
getText(rangeStart, rangeEnd) {
|
|
return this.index.getText(rangeStart, rangeEnd - rangeStart);
|
|
}
|
|
getLength() {
|
|
return this.index.getLength();
|
|
}
|
|
getChangeRange(oldSnapshot) {
|
|
if (oldSnapshot instanceof LineIndexSnapshot && this.cache === oldSnapshot.cache) {
|
|
if (this.version <= oldSnapshot.version) {
|
|
return unchangedTextChangeRange;
|
|
} else {
|
|
return this.cache.getTextChangesBetweenVersions(oldSnapshot.version, this.version);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var LineIndex = class {
|
|
constructor() {
|
|
this.checkEdits = false;
|
|
}
|
|
absolutePositionOfStartOfLine(oneBasedLine) {
|
|
return this.lineNumberToInfo(oneBasedLine).absolutePosition;
|
|
}
|
|
positionToLineOffset(position) {
|
|
const { oneBasedLine, zeroBasedColumn } = this.root.charOffsetToLineInfo(1, position);
|
|
return { line: oneBasedLine, offset: zeroBasedColumn + 1 };
|
|
}
|
|
positionToColumnAndLineText(position) {
|
|
return this.root.charOffsetToLineInfo(1, position);
|
|
}
|
|
getLineCount() {
|
|
return this.root.lineCount();
|
|
}
|
|
lineNumberToInfo(oneBasedLine) {
|
|
const lineCount = this.getLineCount();
|
|
if (oneBasedLine <= lineCount) {
|
|
const { position, leaf } = this.root.lineNumberToInfo(oneBasedLine, 0);
|
|
return { absolutePosition: position, lineText: leaf && leaf.text };
|
|
} else {
|
|
return { absolutePosition: this.root.charCount(), lineText: void 0 };
|
|
}
|
|
}
|
|
load(lines) {
|
|
if (lines.length > 0) {
|
|
const leaves = [];
|
|
for (let i = 0; i < lines.length; i++) {
|
|
leaves[i] = new LineLeaf(lines[i]);
|
|
}
|
|
this.root = LineIndex.buildTreeFromBottom(leaves);
|
|
} else {
|
|
this.root = new LineNode();
|
|
}
|
|
}
|
|
walk(rangeStart, rangeLength, walkFns) {
|
|
this.root.walk(rangeStart, rangeLength, walkFns);
|
|
}
|
|
getText(rangeStart, rangeLength) {
|
|
let accum = "";
|
|
if (rangeLength > 0 && rangeStart < this.root.charCount()) {
|
|
this.walk(rangeStart, rangeLength, {
|
|
goSubtree: true,
|
|
done: false,
|
|
leaf: (relativeStart, relativeLength, ll) => {
|
|
accum = accum.concat(ll.text.substring(relativeStart, relativeStart + relativeLength));
|
|
}
|
|
});
|
|
}
|
|
return accum;
|
|
}
|
|
getLength() {
|
|
return this.root.charCount();
|
|
}
|
|
every(f, rangeStart, rangeEnd) {
|
|
if (!rangeEnd) {
|
|
rangeEnd = this.root.charCount();
|
|
}
|
|
const walkFns = {
|
|
goSubtree: true,
|
|
done: false,
|
|
leaf(relativeStart, relativeLength, ll) {
|
|
if (!f(ll, relativeStart, relativeLength)) {
|
|
this.done = true;
|
|
}
|
|
}
|
|
};
|
|
this.walk(rangeStart, rangeEnd - rangeStart, walkFns);
|
|
return !walkFns.done;
|
|
}
|
|
edit(pos, deleteLength, newText) {
|
|
if (this.root.charCount() === 0) {
|
|
Debug.assert(deleteLength === 0);
|
|
if (newText !== void 0) {
|
|
this.load(LineIndex.linesFromText(newText).lines);
|
|
return this;
|
|
}
|
|
return void 0;
|
|
} else {
|
|
let checkText;
|
|
if (this.checkEdits) {
|
|
const source = this.getText(0, this.root.charCount());
|
|
checkText = source.slice(0, pos) + newText + source.slice(pos + deleteLength);
|
|
}
|
|
const walker = new EditWalker();
|
|
let suppressTrailingText = false;
|
|
if (pos >= this.root.charCount()) {
|
|
pos = this.root.charCount() - 1;
|
|
const endString = this.getText(pos, 1);
|
|
if (newText) {
|
|
newText = endString + newText;
|
|
} else {
|
|
newText = endString;
|
|
}
|
|
deleteLength = 0;
|
|
suppressTrailingText = true;
|
|
} else if (deleteLength > 0) {
|
|
const e = pos + deleteLength;
|
|
const { zeroBasedColumn, lineText } = this.positionToColumnAndLineText(e);
|
|
if (zeroBasedColumn === 0) {
|
|
deleteLength += lineText.length;
|
|
newText = newText ? newText + lineText : lineText;
|
|
}
|
|
}
|
|
this.root.walk(pos, deleteLength, walker);
|
|
walker.insertLines(newText, suppressTrailingText);
|
|
if (this.checkEdits) {
|
|
const updatedText = walker.lineIndex.getText(0, walker.lineIndex.getLength());
|
|
Debug.assert(checkText === updatedText, "buffer edit mismatch");
|
|
}
|
|
return walker.lineIndex;
|
|
}
|
|
}
|
|
static buildTreeFromBottom(nodes) {
|
|
if (nodes.length < lineCollectionCapacity) {
|
|
return new LineNode(nodes);
|
|
}
|
|
const interiorNodes = new Array(Math.ceil(nodes.length / lineCollectionCapacity));
|
|
let nodeIndex = 0;
|
|
for (let i = 0; i < interiorNodes.length; i++) {
|
|
const end = Math.min(nodeIndex + lineCollectionCapacity, nodes.length);
|
|
interiorNodes[i] = new LineNode(nodes.slice(nodeIndex, end));
|
|
nodeIndex = end;
|
|
}
|
|
return this.buildTreeFromBottom(interiorNodes);
|
|
}
|
|
static linesFromText(text) {
|
|
const lineMap = computeLineStarts(text);
|
|
if (lineMap.length === 0) {
|
|
return { lines: [], lineMap };
|
|
}
|
|
const lines = new Array(lineMap.length);
|
|
const lc = lineMap.length - 1;
|
|
for (let lmi = 0; lmi < lc; lmi++) {
|
|
lines[lmi] = text.substring(lineMap[lmi], lineMap[lmi + 1]);
|
|
}
|
|
const endText = text.substring(lineMap[lc]);
|
|
if (endText.length > 0) {
|
|
lines[lc] = endText;
|
|
} else {
|
|
lines.pop();
|
|
}
|
|
return { lines, lineMap };
|
|
}
|
|
};
|
|
var LineNode = class {
|
|
constructor(children = []) {
|
|
this.children = children;
|
|
this.totalChars = 0;
|
|
this.totalLines = 0;
|
|
if (children.length)
|
|
this.updateCounts();
|
|
}
|
|
isLeaf() {
|
|
return false;
|
|
}
|
|
updateCounts() {
|
|
this.totalChars = 0;
|
|
this.totalLines = 0;
|
|
for (const child of this.children) {
|
|
this.totalChars += child.charCount();
|
|
this.totalLines += child.lineCount();
|
|
}
|
|
}
|
|
execWalk(rangeStart, rangeLength, walkFns, childIndex, nodeType) {
|
|
if (walkFns.pre) {
|
|
walkFns.pre(rangeStart, rangeLength, this.children[childIndex], this, nodeType);
|
|
}
|
|
if (walkFns.goSubtree) {
|
|
this.children[childIndex].walk(rangeStart, rangeLength, walkFns);
|
|
if (walkFns.post) {
|
|
walkFns.post(rangeStart, rangeLength, this.children[childIndex], this, nodeType);
|
|
}
|
|
} else {
|
|
walkFns.goSubtree = true;
|
|
}
|
|
return walkFns.done;
|
|
}
|
|
skipChild(relativeStart, relativeLength, childIndex, walkFns, nodeType) {
|
|
if (walkFns.pre && !walkFns.done) {
|
|
walkFns.pre(relativeStart, relativeLength, this.children[childIndex], this, nodeType);
|
|
walkFns.goSubtree = true;
|
|
}
|
|
}
|
|
walk(rangeStart, rangeLength, walkFns) {
|
|
let childIndex = 0;
|
|
let childCharCount = this.children[childIndex].charCount();
|
|
let adjustedStart = rangeStart;
|
|
while (adjustedStart >= childCharCount) {
|
|
this.skipChild(adjustedStart, rangeLength, childIndex, walkFns, 0 /* PreStart */);
|
|
adjustedStart -= childCharCount;
|
|
childIndex++;
|
|
childCharCount = this.children[childIndex].charCount();
|
|
}
|
|
if (adjustedStart + rangeLength <= childCharCount) {
|
|
if (this.execWalk(adjustedStart, rangeLength, walkFns, childIndex, 2 /* Entire */)) {
|
|
return;
|
|
}
|
|
} else {
|
|
if (this.execWalk(adjustedStart, childCharCount - adjustedStart, walkFns, childIndex, 1 /* Start */)) {
|
|
return;
|
|
}
|
|
let adjustedLength = rangeLength - (childCharCount - adjustedStart);
|
|
childIndex++;
|
|
const child = this.children[childIndex];
|
|
childCharCount = child.charCount();
|
|
while (adjustedLength > childCharCount) {
|
|
if (this.execWalk(0, childCharCount, walkFns, childIndex, 3 /* Mid */)) {
|
|
return;
|
|
}
|
|
adjustedLength -= childCharCount;
|
|
childIndex++;
|
|
childCharCount = this.children[childIndex].charCount();
|
|
}
|
|
if (adjustedLength > 0) {
|
|
if (this.execWalk(0, adjustedLength, walkFns, childIndex, 4 /* End */)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (walkFns.pre) {
|
|
const clen = this.children.length;
|
|
if (childIndex < clen - 1) {
|
|
for (let ej = childIndex + 1; ej < clen; ej++) {
|
|
this.skipChild(0, 0, ej, walkFns, 5 /* PostEnd */);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
charOffsetToLineInfo(lineNumberAccumulator, relativePosition) {
|
|
if (this.children.length === 0) {
|
|
return { oneBasedLine: lineNumberAccumulator, zeroBasedColumn: relativePosition, lineText: void 0 };
|
|
}
|
|
for (const child of this.children) {
|
|
if (child.charCount() > relativePosition) {
|
|
if (child.isLeaf()) {
|
|
return { oneBasedLine: lineNumberAccumulator, zeroBasedColumn: relativePosition, lineText: child.text };
|
|
} else {
|
|
return child.charOffsetToLineInfo(lineNumberAccumulator, relativePosition);
|
|
}
|
|
} else {
|
|
relativePosition -= child.charCount();
|
|
lineNumberAccumulator += child.lineCount();
|
|
}
|
|
}
|
|
const lineCount = this.lineCount();
|
|
if (lineCount === 0) {
|
|
return { oneBasedLine: 1, zeroBasedColumn: 0, lineText: void 0 };
|
|
}
|
|
const leaf = Debug.checkDefined(this.lineNumberToInfo(lineCount, 0).leaf);
|
|
return { oneBasedLine: lineCount, zeroBasedColumn: leaf.charCount(), lineText: void 0 };
|
|
}
|
|
lineNumberToInfo(relativeOneBasedLine, positionAccumulator) {
|
|
for (const child of this.children) {
|
|
const childLineCount = child.lineCount();
|
|
if (childLineCount >= relativeOneBasedLine) {
|
|
return child.isLeaf() ? { position: positionAccumulator, leaf: child } : child.lineNumberToInfo(relativeOneBasedLine, positionAccumulator);
|
|
} else {
|
|
relativeOneBasedLine -= childLineCount;
|
|
positionAccumulator += child.charCount();
|
|
}
|
|
}
|
|
return { position: positionAccumulator, leaf: void 0 };
|
|
}
|
|
splitAfter(childIndex) {
|
|
let splitNode;
|
|
const clen = this.children.length;
|
|
childIndex++;
|
|
const endLength = childIndex;
|
|
if (childIndex < clen) {
|
|
splitNode = new LineNode();
|
|
while (childIndex < clen) {
|
|
splitNode.add(this.children[childIndex]);
|
|
childIndex++;
|
|
}
|
|
splitNode.updateCounts();
|
|
}
|
|
this.children.length = endLength;
|
|
return splitNode;
|
|
}
|
|
remove(child) {
|
|
const childIndex = this.findChildIndex(child);
|
|
const clen = this.children.length;
|
|
if (childIndex < clen - 1) {
|
|
for (let i = childIndex; i < clen - 1; i++) {
|
|
this.children[i] = this.children[i + 1];
|
|
}
|
|
}
|
|
this.children.pop();
|
|
}
|
|
findChildIndex(child) {
|
|
const childIndex = this.children.indexOf(child);
|
|
Debug.assert(childIndex !== -1);
|
|
return childIndex;
|
|
}
|
|
insertAt(child, nodes) {
|
|
let childIndex = this.findChildIndex(child);
|
|
const clen = this.children.length;
|
|
const nodeCount = nodes.length;
|
|
if (clen < lineCollectionCapacity && childIndex === clen - 1 && nodeCount === 1) {
|
|
this.add(nodes[0]);
|
|
this.updateCounts();
|
|
return [];
|
|
} else {
|
|
const shiftNode = this.splitAfter(childIndex);
|
|
let nodeIndex = 0;
|
|
childIndex++;
|
|
while (childIndex < lineCollectionCapacity && nodeIndex < nodeCount) {
|
|
this.children[childIndex] = nodes[nodeIndex];
|
|
childIndex++;
|
|
nodeIndex++;
|
|
}
|
|
let splitNodes = [];
|
|
let splitNodeCount = 0;
|
|
if (nodeIndex < nodeCount) {
|
|
splitNodeCount = Math.ceil((nodeCount - nodeIndex) / lineCollectionCapacity);
|
|
splitNodes = new Array(splitNodeCount);
|
|
let splitNodeIndex = 0;
|
|
for (let i = 0; i < splitNodeCount; i++) {
|
|
splitNodes[i] = new LineNode();
|
|
}
|
|
let splitNode = splitNodes[0];
|
|
while (nodeIndex < nodeCount) {
|
|
splitNode.add(nodes[nodeIndex]);
|
|
nodeIndex++;
|
|
if (splitNode.children.length === lineCollectionCapacity) {
|
|
splitNodeIndex++;
|
|
splitNode = splitNodes[splitNodeIndex];
|
|
}
|
|
}
|
|
for (let i = splitNodes.length - 1; i >= 0; i--) {
|
|
if (splitNodes[i].children.length === 0) {
|
|
splitNodes.pop();
|
|
}
|
|
}
|
|
}
|
|
if (shiftNode) {
|
|
splitNodes.push(shiftNode);
|
|
}
|
|
this.updateCounts();
|
|
for (let i = 0; i < splitNodeCount; i++) {
|
|
splitNodes[i].updateCounts();
|
|
}
|
|
return splitNodes;
|
|
}
|
|
}
|
|
add(collection) {
|
|
this.children.push(collection);
|
|
Debug.assert(this.children.length <= lineCollectionCapacity);
|
|
}
|
|
charCount() {
|
|
return this.totalChars;
|
|
}
|
|
lineCount() {
|
|
return this.totalLines;
|
|
}
|
|
};
|
|
var LineLeaf = class {
|
|
constructor(text) {
|
|
this.text = text;
|
|
}
|
|
isLeaf() {
|
|
return true;
|
|
}
|
|
walk(rangeStart, rangeLength, walkFns) {
|
|
walkFns.leaf(rangeStart, rangeLength, this);
|
|
}
|
|
charCount() {
|
|
return this.text.length;
|
|
}
|
|
lineCount() {
|
|
return 1;
|
|
}
|
|
};
|
|
|
|
// src/webServer/webServer.ts
|
|
var BaseLogger = class {
|
|
constructor(level) {
|
|
this.level = level;
|
|
this.seq = 0;
|
|
this.inGroup = false;
|
|
this.firstInGroup = true;
|
|
}
|
|
static padStringRight(str, padding) {
|
|
return (str + padding).slice(0, padding.length);
|
|
}
|
|
close() {
|
|
}
|
|
getLogFileName() {
|
|
return void 0;
|
|
}
|
|
perftrc(s) {
|
|
this.msg(s, "Perf" /* Perf */);
|
|
}
|
|
info(s) {
|
|
this.msg(s, "Info" /* Info */);
|
|
}
|
|
err(s) {
|
|
this.msg(s, "Err" /* Err */);
|
|
}
|
|
startGroup() {
|
|
this.inGroup = true;
|
|
this.firstInGroup = true;
|
|
}
|
|
endGroup() {
|
|
this.inGroup = false;
|
|
}
|
|
loggingEnabled() {
|
|
return true;
|
|
}
|
|
hasLevel(level) {
|
|
return this.loggingEnabled() && this.level >= level;
|
|
}
|
|
msg(s, type = "Err" /* Err */) {
|
|
switch (type) {
|
|
case "Info" /* Info */:
|
|
perfLogger.logInfoEvent(s);
|
|
break;
|
|
case "Perf" /* Perf */:
|
|
perfLogger.logPerfEvent(s);
|
|
break;
|
|
default:
|
|
perfLogger.logErrEvent(s);
|
|
break;
|
|
}
|
|
if (!this.canWrite())
|
|
return;
|
|
s = `[${nowString()}] ${s}
|
|
`;
|
|
if (!this.inGroup || this.firstInGroup) {
|
|
const prefix = BaseLogger.padStringRight(type + " " + this.seq.toString(), " ");
|
|
s = prefix + s;
|
|
}
|
|
this.write(s, type);
|
|
if (!this.inGroup) {
|
|
this.seq++;
|
|
}
|
|
}
|
|
canWrite() {
|
|
return true;
|
|
}
|
|
write(_s, _type) {
|
|
}
|
|
};
|
|
var MainProcessLogger = class extends BaseLogger {
|
|
constructor(level, host) {
|
|
super(level);
|
|
this.host = host;
|
|
}
|
|
write(body, type) {
|
|
let level;
|
|
switch (type) {
|
|
case "Info" /* Info */:
|
|
level = "info";
|
|
break;
|
|
case "Perf" /* Perf */:
|
|
level = "perf";
|
|
break;
|
|
case "Err" /* Err */:
|
|
level = "error";
|
|
break;
|
|
default:
|
|
Debug.assertNever(type);
|
|
}
|
|
this.host.writeMessage({
|
|
type: "log",
|
|
level,
|
|
body
|
|
});
|
|
}
|
|
};
|
|
function createWebSystem(host, args, getExecutingFilePath) {
|
|
const returnEmptyString = () => "";
|
|
const getExecutingDirectoryPath = memoize(() => memoize(() => ensureTrailingDirectorySeparator(getDirectoryPath(getExecutingFilePath()))));
|
|
const getWebPath = (path) => startsWith(path, directorySeparator) ? path.replace(directorySeparator, getExecutingDirectoryPath()) : void 0;
|
|
return {
|
|
args,
|
|
newLine: "\r\n",
|
|
useCaseSensitiveFileNames: false,
|
|
readFile: (path) => {
|
|
const webPath = getWebPath(path);
|
|
return webPath && host.readFile(webPath);
|
|
},
|
|
write: host.writeMessage.bind(host),
|
|
watchFile: returnNoopFileWatcher,
|
|
watchDirectory: returnNoopFileWatcher,
|
|
getExecutingFilePath: () => directorySeparator,
|
|
getCurrentDirectory: returnEmptyString,
|
|
setTimeout: (cb, ms, ...args2) => setTimeout(cb, ms, ...args2),
|
|
clearTimeout: (handle) => clearTimeout(handle),
|
|
setImmediate: (x) => setTimeout(x, 0),
|
|
clearImmediate: (handle) => clearTimeout(handle),
|
|
importPlugin: async (initialDir, moduleName) => {
|
|
const packageRoot = combinePaths(initialDir, moduleName);
|
|
let packageJson;
|
|
try {
|
|
const packageJsonResponse = await fetch(combinePaths(packageRoot, "package.json"));
|
|
packageJson = await packageJsonResponse.json();
|
|
} catch (e) {
|
|
return { module: void 0, error: new Error("Could not load plugin. Could not load 'package.json'.") };
|
|
}
|
|
const browser = packageJson.browser;
|
|
if (!browser) {
|
|
return { module: void 0, error: new Error("Could not load plugin. No 'browser' field found in package.json.") };
|
|
}
|
|
const scriptPath = combinePaths(packageRoot, browser);
|
|
try {
|
|
const { default: module2 } = await import(scriptPath);
|
|
return { module: module2, error: void 0 };
|
|
} catch (e) {
|
|
return { module: void 0, error: e };
|
|
}
|
|
},
|
|
exit: notImplemented,
|
|
getEnvironmentVariable: returnEmptyString,
|
|
fileExists: (path) => {
|
|
const webPath = getWebPath(path);
|
|
return !!webPath && host.fileExists(webPath);
|
|
},
|
|
directoryExists: returnFalse,
|
|
readDirectory: notImplemented,
|
|
getDirectories: () => [],
|
|
createDirectory: notImplemented,
|
|
writeFile: notImplemented,
|
|
resolvePath: identity
|
|
};
|
|
}
|
|
var WorkerSession = class extends Session3 {
|
|
constructor(host, webHost, options, logger, cancellationToken, hrtime2) {
|
|
super({
|
|
host,
|
|
cancellationToken,
|
|
...options,
|
|
typingsInstaller: nullTypingsInstaller,
|
|
byteLength: notImplemented,
|
|
hrtime: hrtime2,
|
|
logger,
|
|
canUseEvents: true
|
|
});
|
|
this.webHost = webHost;
|
|
}
|
|
send(msg) {
|
|
if (msg.type === "event" && !this.canUseEvents) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Session does not support events: ignored event: ${JSON.stringify(msg)}`);
|
|
}
|
|
return;
|
|
}
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`${msg.type}:${indent2(JSON.stringify(msg))}`);
|
|
}
|
|
this.webHost.writeMessage(msg);
|
|
}
|
|
parseMessage(message) {
|
|
return message;
|
|
}
|
|
toStringMessage(message) {
|
|
return JSON.stringify(message, void 0, 2);
|
|
}
|
|
};
|
|
|
|
// src/tsserver/nodeServer.ts
|
|
function parseLoggingEnvironmentString(logEnvStr) {
|
|
if (!logEnvStr) {
|
|
return {};
|
|
}
|
|
const logEnv = { logToFile: true };
|
|
const args = logEnvStr.split(" ");
|
|
const len = args.length - 1;
|
|
for (let i = 0; i < len; i += 2) {
|
|
const option = args[i];
|
|
const { value, extraPartCounter } = getEntireValue(i + 1);
|
|
i += extraPartCounter;
|
|
if (option && value) {
|
|
switch (option) {
|
|
case "-file":
|
|
logEnv.file = value;
|
|
break;
|
|
case "-level":
|
|
const level = getLogLevel(value);
|
|
logEnv.detailLevel = level !== void 0 ? level : 1 /* normal */;
|
|
break;
|
|
case "-traceToConsole":
|
|
logEnv.traceToConsole = value.toLowerCase() === "true";
|
|
break;
|
|
case "-logToFile":
|
|
logEnv.logToFile = value.toLowerCase() === "true";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return logEnv;
|
|
function getEntireValue(initialIndex) {
|
|
let pathStart = args[initialIndex];
|
|
let extraPartCounter = 0;
|
|
if (pathStart.charCodeAt(0) === 34 /* doubleQuote */ && pathStart.charCodeAt(pathStart.length - 1) !== 34 /* doubleQuote */) {
|
|
for (let i = initialIndex + 1; i < args.length; i++) {
|
|
pathStart += " ";
|
|
pathStart += args[i];
|
|
extraPartCounter++;
|
|
if (pathStart.charCodeAt(pathStart.length - 1) === 34 /* doubleQuote */)
|
|
break;
|
|
}
|
|
}
|
|
return { value: stripQuotes(pathStart), extraPartCounter };
|
|
}
|
|
}
|
|
function parseServerMode() {
|
|
const mode = findArgument("--serverMode");
|
|
if (!mode)
|
|
return void 0;
|
|
switch (mode.toLowerCase()) {
|
|
case "semantic":
|
|
return 0 /* Semantic */;
|
|
case "partialsemantic":
|
|
return 1 /* PartialSemantic */;
|
|
case "syntactic":
|
|
return 2 /* Syntactic */;
|
|
default:
|
|
return mode;
|
|
}
|
|
}
|
|
function initializeNodeSystem() {
|
|
const sys2 = Debug.checkDefined(sys);
|
|
const childProcess = require("child_process");
|
|
const fs = require("fs");
|
|
class Logger8 extends BaseLogger {
|
|
constructor(logFilename, traceToConsole, level) {
|
|
super(level);
|
|
this.logFilename = logFilename;
|
|
this.traceToConsole = traceToConsole;
|
|
this.fd = -1;
|
|
if (this.logFilename) {
|
|
try {
|
|
this.fd = fs.openSync(this.logFilename, "w");
|
|
} catch (_) {
|
|
}
|
|
}
|
|
}
|
|
close() {
|
|
if (this.fd >= 0) {
|
|
fs.close(this.fd, noop);
|
|
}
|
|
}
|
|
getLogFileName() {
|
|
return this.logFilename;
|
|
}
|
|
loggingEnabled() {
|
|
return !!this.logFilename || this.traceToConsole;
|
|
}
|
|
canWrite() {
|
|
return this.fd >= 0 || this.traceToConsole;
|
|
}
|
|
write(s, _type) {
|
|
if (this.fd >= 0) {
|
|
const buf = sys2.bufferFrom(s);
|
|
fs.writeSync(this.fd, buf, 0, buf.length, null);
|
|
}
|
|
if (this.traceToConsole) {
|
|
console.warn(s);
|
|
}
|
|
}
|
|
}
|
|
const libDirectory = getDirectoryPath(normalizePath(sys2.getExecutingFilePath()));
|
|
const nodeVersion = getNodeMajorVersion();
|
|
const useWatchGuard = process.platform === "win32" && nodeVersion >= 4;
|
|
const originalWatchDirectory = sys2.watchDirectory.bind(sys2);
|
|
const logger = createLogger2();
|
|
Debug.loggingHost = {
|
|
log(level, s) {
|
|
switch (level) {
|
|
case 1 /* Error */:
|
|
case 2 /* Warning */:
|
|
return logger.msg(s, "Err" /* Err */);
|
|
case 3 /* Info */:
|
|
case 4 /* Verbose */:
|
|
return logger.msg(s, "Info" /* Info */);
|
|
}
|
|
}
|
|
};
|
|
const pending = createQueue();
|
|
let canWrite = true;
|
|
if (useWatchGuard) {
|
|
const currentDrive = extractWatchDirectoryCacheKey(sys2.resolvePath(sys2.getCurrentDirectory()), void 0);
|
|
const statusCache = /* @__PURE__ */ new Map();
|
|
sys2.watchDirectory = (path, callback, recursive, options) => {
|
|
const cacheKey = extractWatchDirectoryCacheKey(path, currentDrive);
|
|
let status = cacheKey && statusCache.get(cacheKey);
|
|
if (status === void 0) {
|
|
if (logger.hasLevel(3 /* verbose */)) {
|
|
logger.info(`${cacheKey} for path ${path} not found in cache...`);
|
|
}
|
|
try {
|
|
const args = [combinePaths(libDirectory, "watchGuard.js"), path];
|
|
if (logger.hasLevel(3 /* verbose */)) {
|
|
logger.info(`Starting ${process.execPath} with args:${stringifyIndented(args)}`);
|
|
}
|
|
childProcess.execFileSync(process.execPath, args, { stdio: "ignore", env: { ELECTRON_RUN_AS_NODE: "1" } });
|
|
status = true;
|
|
if (logger.hasLevel(3 /* verbose */)) {
|
|
logger.info(`WatchGuard for path ${path} returned: OK`);
|
|
}
|
|
} catch (e) {
|
|
status = false;
|
|
if (logger.hasLevel(3 /* verbose */)) {
|
|
logger.info(`WatchGuard for path ${path} returned: ${e.message}`);
|
|
}
|
|
}
|
|
if (cacheKey) {
|
|
statusCache.set(cacheKey, status);
|
|
}
|
|
} else if (logger.hasLevel(3 /* verbose */)) {
|
|
logger.info(`watchDirectory for ${path} uses cached drive information.`);
|
|
}
|
|
if (status) {
|
|
return watchDirectorySwallowingException(path, callback, recursive, options);
|
|
} else {
|
|
return noopFileWatcher;
|
|
}
|
|
};
|
|
} else {
|
|
sys2.watchDirectory = watchDirectorySwallowingException;
|
|
}
|
|
sys2.write = (s) => writeMessage2(sys2.bufferFrom(s, "utf8"));
|
|
sys2.setTimeout = setTimeout;
|
|
sys2.clearTimeout = clearTimeout;
|
|
sys2.setImmediate = setImmediate;
|
|
sys2.clearImmediate = clearImmediate;
|
|
if (typeof global !== "undefined" && global.gc) {
|
|
sys2.gc = () => {
|
|
var _a2;
|
|
return (_a2 = global.gc) == null ? void 0 : _a2.call(global);
|
|
};
|
|
}
|
|
sys2.require = (initialDir, moduleName) => {
|
|
try {
|
|
return { module: require(resolveJSModule(moduleName, initialDir, sys2)), error: void 0 };
|
|
} catch (error) {
|
|
return { module: void 0, error };
|
|
}
|
|
};
|
|
let cancellationToken;
|
|
try {
|
|
const factory2 = require("./cancellationToken");
|
|
cancellationToken = factory2(sys2.args);
|
|
} catch (e) {
|
|
cancellationToken = nullCancellationToken;
|
|
}
|
|
const localeStr = findArgument("--locale");
|
|
if (localeStr) {
|
|
validateLocaleAndSetLanguage(localeStr, sys2);
|
|
}
|
|
const modeOrUnknown = parseServerMode();
|
|
let serverMode;
|
|
let unknownServerMode;
|
|
if (modeOrUnknown !== void 0) {
|
|
if (typeof modeOrUnknown === "number")
|
|
serverMode = modeOrUnknown;
|
|
else
|
|
unknownServerMode = modeOrUnknown;
|
|
}
|
|
return {
|
|
args: process.argv,
|
|
logger,
|
|
cancellationToken,
|
|
serverMode,
|
|
unknownServerMode,
|
|
startSession: startNodeSession
|
|
};
|
|
function createLogger2() {
|
|
const cmdLineLogFileName = findArgument("--logFile");
|
|
const cmdLineVerbosity = getLogLevel(findArgument("--logVerbosity"));
|
|
const envLogOptions = parseLoggingEnvironmentString(process.env.TSS_LOG);
|
|
const unsubstitutedLogFileName = cmdLineLogFileName ? stripQuotes(cmdLineLogFileName) : envLogOptions.logToFile ? envLogOptions.file || libDirectory + "/.log" + process.pid.toString() : void 0;
|
|
const substitutedLogFileName = unsubstitutedLogFileName ? unsubstitutedLogFileName.replace("PID", process.pid.toString()) : void 0;
|
|
const logVerbosity = cmdLineVerbosity || envLogOptions.detailLevel;
|
|
return new Logger8(substitutedLogFileName, envLogOptions.traceToConsole, logVerbosity);
|
|
}
|
|
function writeMessage2(buf) {
|
|
if (!canWrite) {
|
|
pending.enqueue(buf);
|
|
} else {
|
|
canWrite = false;
|
|
process.stdout.write(buf, setCanWriteFlagAndWriteMessageIfNecessary);
|
|
}
|
|
}
|
|
function setCanWriteFlagAndWriteMessageIfNecessary() {
|
|
canWrite = true;
|
|
if (!pending.isEmpty()) {
|
|
writeMessage2(pending.dequeue());
|
|
}
|
|
}
|
|
function extractWatchDirectoryCacheKey(path, currentDriveKey) {
|
|
path = normalizeSlashes(path);
|
|
if (isUNCPath(path)) {
|
|
const firstSlash = path.indexOf(directorySeparator, 2);
|
|
return firstSlash !== -1 ? toFileNameLowerCase(path.substring(0, firstSlash)) : path;
|
|
}
|
|
const rootLength = getRootLength(path);
|
|
if (rootLength === 0) {
|
|
return currentDriveKey;
|
|
}
|
|
if (path.charCodeAt(1) === 58 /* colon */ && path.charCodeAt(2) === 47 /* slash */) {
|
|
return toFileNameLowerCase(path.charAt(0));
|
|
}
|
|
if (path.charCodeAt(0) === 47 /* slash */ && path.charCodeAt(1) !== 47 /* slash */) {
|
|
return currentDriveKey;
|
|
}
|
|
return void 0;
|
|
}
|
|
function isUNCPath(s) {
|
|
return s.length > 2 && s.charCodeAt(0) === 47 /* slash */ && s.charCodeAt(1) === 47 /* slash */;
|
|
}
|
|
function watchDirectorySwallowingException(path, callback, recursive, options) {
|
|
try {
|
|
return originalWatchDirectory(path, callback, recursive, options);
|
|
} catch (e) {
|
|
logger.info(`Exception when creating directory watcher: ${e.message}`);
|
|
return noopFileWatcher;
|
|
}
|
|
}
|
|
}
|
|
function parseEventPort(eventPortStr) {
|
|
const eventPort = eventPortStr === void 0 ? void 0 : parseInt(eventPortStr);
|
|
return eventPort !== void 0 && !isNaN(eventPort) ? eventPort : void 0;
|
|
}
|
|
function startNodeSession(options, logger, cancellationToken) {
|
|
const childProcess = require("child_process");
|
|
const os = require("os");
|
|
const net = require("net");
|
|
const readline = require("readline");
|
|
const rl = readline.createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout,
|
|
terminal: false
|
|
});
|
|
const _NodeTypingsInstaller = class {
|
|
constructor(telemetryEnabled2, logger2, host, globalTypingsCacheLocation, typingSafeListLocation2, typesMapLocation2, npmLocation2, validateDefaultNpmLocation2, event) {
|
|
this.telemetryEnabled = telemetryEnabled2;
|
|
this.logger = logger2;
|
|
this.host = host;
|
|
this.globalTypingsCacheLocation = globalTypingsCacheLocation;
|
|
this.typingSafeListLocation = typingSafeListLocation2;
|
|
this.typesMapLocation = typesMapLocation2;
|
|
this.npmLocation = npmLocation2;
|
|
this.validateDefaultNpmLocation = validateDefaultNpmLocation2;
|
|
this.event = event;
|
|
this.activeRequestCount = 0;
|
|
this.requestQueue = createQueue();
|
|
this.requestMap = /* @__PURE__ */ new Map();
|
|
this.requestedRegistry = false;
|
|
}
|
|
isKnownTypesPackageName(name) {
|
|
const validationResult = ts_JsTyping_exports.validatePackageName(name);
|
|
if (validationResult !== ts_JsTyping_exports.NameValidationResult.Ok) {
|
|
return false;
|
|
}
|
|
if (this.requestedRegistry) {
|
|
return !!this.typesRegistryCache && this.typesRegistryCache.has(name);
|
|
}
|
|
this.requestedRegistry = true;
|
|
this.send({ kind: "typesRegistry" });
|
|
return false;
|
|
}
|
|
installPackage(options2) {
|
|
this.send({ kind: "installPackage", ...options2 });
|
|
Debug.assert(this.packageInstalledPromise === void 0);
|
|
return new Promise((resolve, reject) => {
|
|
this.packageInstalledPromise = { resolve, reject };
|
|
});
|
|
}
|
|
attach(projectService) {
|
|
this.projectService = projectService;
|
|
if (this.logger.hasLevel(2 /* requestTime */)) {
|
|
this.logger.info("Binding...");
|
|
}
|
|
const args = [Arguments.GlobalCacheLocation, this.globalTypingsCacheLocation];
|
|
if (this.telemetryEnabled) {
|
|
args.push(Arguments.EnableTelemetry);
|
|
}
|
|
if (this.logger.loggingEnabled() && this.logger.getLogFileName()) {
|
|
args.push(Arguments.LogFile, combinePaths(getDirectoryPath(normalizeSlashes(this.logger.getLogFileName())), `ti-${process.pid}.log`));
|
|
}
|
|
if (this.typingSafeListLocation) {
|
|
args.push(Arguments.TypingSafeListLocation, this.typingSafeListLocation);
|
|
}
|
|
if (this.typesMapLocation) {
|
|
args.push(Arguments.TypesMapLocation, this.typesMapLocation);
|
|
}
|
|
if (this.npmLocation) {
|
|
args.push(Arguments.NpmLocation, this.npmLocation);
|
|
}
|
|
if (this.validateDefaultNpmLocation) {
|
|
args.push(Arguments.ValidateDefaultNpmLocation);
|
|
}
|
|
const execArgv = [];
|
|
for (const arg of process.execArgv) {
|
|
const match = /^--((?:debug|inspect)(?:-brk)?)(?:=(\d+))?$/.exec(arg);
|
|
if (match) {
|
|
const currentPort = match[2] !== void 0 ? +match[2] : match[1].charAt(0) === "d" ? 5858 : 9229;
|
|
execArgv.push(`--${match[1]}=${currentPort + 1}`);
|
|
break;
|
|
}
|
|
}
|
|
const typingsInstaller = combinePaths(getDirectoryPath(sys.getExecutingFilePath()), "typingsInstaller.js");
|
|
this.installer = childProcess.fork(typingsInstaller, args, { execArgv });
|
|
this.installer.on("message", (m) => this.handleMessage(m));
|
|
this.host.setImmediate(() => this.event({ pid: this.installer.pid }, "typingsInstallerPid"));
|
|
process.on("exit", () => {
|
|
this.installer.kill();
|
|
});
|
|
}
|
|
onProjectClosed(p) {
|
|
this.send({ projectName: p.getProjectName(), kind: "closeProject" });
|
|
}
|
|
send(rq) {
|
|
this.installer.send(rq);
|
|
}
|
|
enqueueInstallTypingsRequest(project, typeAcquisition, unresolvedImports) {
|
|
const request = createInstallTypingsRequest(project, typeAcquisition, unresolvedImports);
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Scheduling throttled operation:${stringifyIndented(request)}`);
|
|
}
|
|
}
|
|
const operationId = project.getProjectName();
|
|
const operation = () => {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Sending request:${stringifyIndented(request)}`);
|
|
}
|
|
this.send(request);
|
|
};
|
|
const queuedRequest = { operationId, operation };
|
|
if (this.activeRequestCount < _NodeTypingsInstaller.maxActiveRequestCount) {
|
|
this.scheduleRequest(queuedRequest);
|
|
} else {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Deferring request for: ${operationId}`);
|
|
}
|
|
this.requestQueue.enqueue(queuedRequest);
|
|
this.requestMap.set(operationId, queuedRequest);
|
|
}
|
|
}
|
|
handleMessage(response) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Received response:${stringifyIndented(response)}`);
|
|
}
|
|
switch (response.kind) {
|
|
case EventTypesRegistry:
|
|
this.typesRegistryCache = new Map(getEntries(response.typesRegistry));
|
|
break;
|
|
case ActionPackageInstalled: {
|
|
const { success, message } = response;
|
|
if (success) {
|
|
this.packageInstalledPromise.resolve({ successMessage: message });
|
|
} else {
|
|
this.packageInstalledPromise.reject(message);
|
|
}
|
|
this.packageInstalledPromise = void 0;
|
|
this.projectService.updateTypingsForProject(response);
|
|
this.event(response, "setTypings");
|
|
break;
|
|
}
|
|
case EventInitializationFailed: {
|
|
const body = {
|
|
message: response.message
|
|
};
|
|
const eventName = "typesInstallerInitializationFailed";
|
|
this.event(body, eventName);
|
|
break;
|
|
}
|
|
case EventBeginInstallTypes: {
|
|
const body = {
|
|
eventId: response.eventId,
|
|
packages: response.packagesToInstall
|
|
};
|
|
const eventName = "beginInstallTypes";
|
|
this.event(body, eventName);
|
|
break;
|
|
}
|
|
case EventEndInstallTypes: {
|
|
if (this.telemetryEnabled) {
|
|
const body2 = {
|
|
telemetryEventName: "typingsInstalled",
|
|
payload: {
|
|
installedPackages: response.packagesToInstall.join(","),
|
|
installSuccess: response.installSuccess,
|
|
typingsInstallerVersion: response.typingsInstallerVersion
|
|
}
|
|
};
|
|
const eventName2 = "telemetry";
|
|
this.event(body2, eventName2);
|
|
}
|
|
const body = {
|
|
eventId: response.eventId,
|
|
packages: response.packagesToInstall,
|
|
success: response.installSuccess
|
|
};
|
|
const eventName = "endInstallTypes";
|
|
this.event(body, eventName);
|
|
break;
|
|
}
|
|
case ActionInvalidate: {
|
|
this.projectService.updateTypingsForProject(response);
|
|
break;
|
|
}
|
|
case ActionSet: {
|
|
if (this.activeRequestCount > 0) {
|
|
this.activeRequestCount--;
|
|
} else {
|
|
Debug.fail("Received too many responses");
|
|
}
|
|
while (!this.requestQueue.isEmpty()) {
|
|
const queuedRequest = this.requestQueue.dequeue();
|
|
if (this.requestMap.get(queuedRequest.operationId) === queuedRequest) {
|
|
this.requestMap.delete(queuedRequest.operationId);
|
|
this.scheduleRequest(queuedRequest);
|
|
break;
|
|
}
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Skipping defunct request for: ${queuedRequest.operationId}`);
|
|
}
|
|
}
|
|
this.projectService.updateTypingsForProject(response);
|
|
this.event(response, "setTypings");
|
|
break;
|
|
}
|
|
default:
|
|
assertType(response);
|
|
}
|
|
}
|
|
scheduleRequest(request) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`Scheduling request for: ${request.operationId}`);
|
|
}
|
|
this.activeRequestCount++;
|
|
this.host.setTimeout(request.operation, _NodeTypingsInstaller.requestDelayMillis);
|
|
}
|
|
};
|
|
let NodeTypingsInstaller = _NodeTypingsInstaller;
|
|
NodeTypingsInstaller.maxActiveRequestCount = 10;
|
|
NodeTypingsInstaller.requestDelayMillis = 100;
|
|
class IOSession extends Session3 {
|
|
constructor() {
|
|
const event = (body, eventName) => {
|
|
this.event(body, eventName);
|
|
};
|
|
const host = sys;
|
|
const typingsInstaller = disableAutomaticTypingAcquisition ? void 0 : new NodeTypingsInstaller(telemetryEnabled, logger, host, getGlobalTypingsCacheLocation(), typingSafeListLocation, typesMapLocation, npmLocation, validateDefaultNpmLocation, event);
|
|
super({
|
|
host,
|
|
cancellationToken,
|
|
...options,
|
|
typingsInstaller: typingsInstaller || nullTypingsInstaller,
|
|
byteLength: Buffer.byteLength,
|
|
hrtime: process.hrtime,
|
|
logger,
|
|
canUseEvents: true,
|
|
typesMapLocation
|
|
});
|
|
this.eventPort = eventPort;
|
|
if (this.canUseEvents && this.eventPort) {
|
|
const s = net.connect({ port: this.eventPort }, () => {
|
|
this.eventSocket = s;
|
|
if (this.socketEventQueue) {
|
|
for (const event2 of this.socketEventQueue) {
|
|
this.writeToEventSocket(event2.body, event2.eventName);
|
|
}
|
|
this.socketEventQueue = void 0;
|
|
}
|
|
});
|
|
}
|
|
this.constructed = true;
|
|
}
|
|
event(body, eventName) {
|
|
Debug.assert(!!this.constructed, "Should only call `IOSession.prototype.event` on an initialized IOSession");
|
|
if (this.canUseEvents && this.eventPort) {
|
|
if (!this.eventSocket) {
|
|
if (this.logger.hasLevel(3 /* verbose */)) {
|
|
this.logger.info(`eventPort: event "${eventName}" queued, but socket not yet initialized`);
|
|
}
|
|
(this.socketEventQueue || (this.socketEventQueue = [])).push({ body, eventName });
|
|
return;
|
|
} else {
|
|
Debug.assert(this.socketEventQueue === void 0);
|
|
this.writeToEventSocket(body, eventName);
|
|
}
|
|
} else {
|
|
super.event(body, eventName);
|
|
}
|
|
}
|
|
writeToEventSocket(body, eventName) {
|
|
this.eventSocket.write(formatMessage2(toEvent(eventName, body), this.logger, this.byteLength, this.host.newLine), "utf8");
|
|
}
|
|
exit() {
|
|
var _a2;
|
|
this.logger.info("Exiting...");
|
|
this.projectService.closeLog();
|
|
(_a2 = tracing) == null ? void 0 : _a2.stopTracing();
|
|
process.exit(0);
|
|
}
|
|
listen() {
|
|
rl.on("line", (input) => {
|
|
const message = input.trim();
|
|
this.onMessage(message);
|
|
});
|
|
rl.on("close", () => {
|
|
this.exit();
|
|
});
|
|
}
|
|
}
|
|
class IpcIOSession extends IOSession {
|
|
writeMessage(msg) {
|
|
const verboseLogging = logger.hasLevel(3 /* verbose */);
|
|
if (verboseLogging) {
|
|
const json = JSON.stringify(msg);
|
|
logger.info(`${msg.type}:${indent2(json)}`);
|
|
}
|
|
process.send(msg);
|
|
}
|
|
parseMessage(message) {
|
|
return message;
|
|
}
|
|
toStringMessage(message) {
|
|
return JSON.stringify(message, void 0, 2);
|
|
}
|
|
listen() {
|
|
process.on("message", (e) => {
|
|
this.onMessage(e);
|
|
});
|
|
process.on("disconnect", () => {
|
|
this.exit();
|
|
});
|
|
}
|
|
}
|
|
const eventPort = parseEventPort(findArgument("--eventPort"));
|
|
const typingSafeListLocation = findArgument(Arguments.TypingSafeListLocation);
|
|
const typesMapLocation = findArgument(Arguments.TypesMapLocation) || combinePaths(getDirectoryPath(sys.getExecutingFilePath()), "typesMap.json");
|
|
const npmLocation = findArgument(Arguments.NpmLocation);
|
|
const validateDefaultNpmLocation = hasArgument(Arguments.ValidateDefaultNpmLocation);
|
|
const disableAutomaticTypingAcquisition = hasArgument("--disableAutomaticTypingAcquisition");
|
|
const useNodeIpc = hasArgument("--useNodeIpc");
|
|
const telemetryEnabled = hasArgument(Arguments.EnableTelemetry);
|
|
const commandLineTraceDir = findArgument("--traceDirectory");
|
|
const traceDir = commandLineTraceDir ? stripQuotes(commandLineTraceDir) : process.env.TSS_TRACE;
|
|
if (traceDir) {
|
|
startTracing("server", traceDir);
|
|
}
|
|
const ioSession = useNodeIpc ? new IpcIOSession() : new IOSession();
|
|
process.on("uncaughtException", (err) => {
|
|
ioSession.logError(err, "unknown");
|
|
});
|
|
process.noAsar = true;
|
|
ioSession.listen();
|
|
function getGlobalTypingsCacheLocation() {
|
|
switch (process.platform) {
|
|
case "win32": {
|
|
const basePath = process.env.LOCALAPPDATA || process.env.APPDATA || os.homedir && os.homedir() || process.env.USERPROFILE || process.env.HOMEDRIVE && process.env.HOMEPATH && normalizeSlashes(process.env.HOMEDRIVE + process.env.HOMEPATH) || os.tmpdir();
|
|
return combinePaths(combinePaths(normalizeSlashes(basePath), "Microsoft/TypeScript"), versionMajorMinor);
|
|
}
|
|
case "openbsd":
|
|
case "freebsd":
|
|
case "netbsd":
|
|
case "darwin":
|
|
case "linux":
|
|
case "android": {
|
|
const cacheLocation = getNonWindowsCacheLocation(process.platform === "darwin");
|
|
return combinePaths(combinePaths(cacheLocation, "typescript"), versionMajorMinor);
|
|
}
|
|
default:
|
|
return Debug.fail(`unsupported platform '${process.platform}'`);
|
|
}
|
|
}
|
|
function getNonWindowsCacheLocation(platformIsDarwin) {
|
|
if (process.env.XDG_CACHE_HOME) {
|
|
return process.env.XDG_CACHE_HOME;
|
|
}
|
|
const usersDir = platformIsDarwin ? "Users" : "home";
|
|
const homePath = os.homedir && os.homedir() || process.env.HOME || (process.env.LOGNAME || process.env.USER) && `/${usersDir}/${process.env.LOGNAME || process.env.USER}` || os.tmpdir();
|
|
const cacheFolder = platformIsDarwin ? "Library/Caches" : ".cache";
|
|
return combinePaths(normalizeSlashes(homePath), cacheFolder);
|
|
}
|
|
}
|
|
|
|
// src/tsserver/webServer.ts
|
|
var nullLogger2 = {
|
|
close: noop,
|
|
hasLevel: returnFalse,
|
|
loggingEnabled: returnFalse,
|
|
perftrc: noop,
|
|
info: noop,
|
|
msg: noop,
|
|
startGroup: noop,
|
|
endGroup: noop,
|
|
getLogFileName: returnUndefined
|
|
};
|
|
function parseServerMode2() {
|
|
const mode = findArgument("--serverMode");
|
|
if (!mode)
|
|
return void 0;
|
|
switch (mode.toLowerCase()) {
|
|
case "partialsemantic":
|
|
return 1 /* PartialSemantic */;
|
|
case "syntactic":
|
|
return 2 /* Syntactic */;
|
|
default:
|
|
return mode;
|
|
}
|
|
}
|
|
function initializeWebSystem(args) {
|
|
createWebSystem2(args);
|
|
const modeOrUnknown = parseServerMode2();
|
|
let serverMode;
|
|
let unknownServerMode;
|
|
if (typeof modeOrUnknown === "number")
|
|
serverMode = modeOrUnknown;
|
|
else
|
|
unknownServerMode = modeOrUnknown;
|
|
const logger = createLogger();
|
|
Debug.loggingHost = {
|
|
log(level, s) {
|
|
switch (level) {
|
|
case 1 /* Error */:
|
|
case 2 /* Warning */:
|
|
return logger.msg(s, "Err" /* Err */);
|
|
case 3 /* Info */:
|
|
case 4 /* Verbose */:
|
|
return logger.msg(s, "Info" /* Info */);
|
|
}
|
|
}
|
|
};
|
|
return {
|
|
args,
|
|
logger,
|
|
cancellationToken: nullCancellationToken,
|
|
serverMode: serverMode != null ? serverMode : 1 /* PartialSemantic */,
|
|
unknownServerMode,
|
|
startSession: startWebSession
|
|
};
|
|
}
|
|
function createLogger() {
|
|
const cmdLineVerbosity = getLogLevel(findArgument("--logVerbosity"));
|
|
return cmdLineVerbosity !== void 0 ? new MainProcessLogger(cmdLineVerbosity, { writeMessage }) : nullLogger2;
|
|
}
|
|
function writeMessage(s) {
|
|
postMessage(s);
|
|
}
|
|
function createWebSystem2(args) {
|
|
Debug.assert(sys === void 0);
|
|
const webHost = {
|
|
readFile: (webPath) => {
|
|
const request = new XMLHttpRequest();
|
|
request.open("GET", webPath, false);
|
|
request.send();
|
|
return request.status === 200 ? request.responseText : void 0;
|
|
},
|
|
fileExists: (webPath) => {
|
|
const request = new XMLHttpRequest();
|
|
request.open("HEAD", webPath, false);
|
|
request.send();
|
|
return request.status === 200;
|
|
},
|
|
writeMessage
|
|
};
|
|
const sys2 = createWebSystem(webHost, args, () => findArgument("--executingFilePath") || location + "");
|
|
setSys(sys2);
|
|
const localeStr = findArgument("--locale");
|
|
if (localeStr) {
|
|
validateLocaleAndSetLanguage(localeStr, sys2);
|
|
}
|
|
}
|
|
function hrtime(previous) {
|
|
const now = self.performance.now() * 1e-3;
|
|
let seconds = Math.floor(now);
|
|
let nanoseconds = Math.floor(now % 1 * 1e9);
|
|
if (previous) {
|
|
seconds = seconds - previous[0];
|
|
nanoseconds = nanoseconds - previous[1];
|
|
if (nanoseconds < 0) {
|
|
seconds--;
|
|
nanoseconds += 1e9;
|
|
}
|
|
}
|
|
return [seconds, nanoseconds];
|
|
}
|
|
function startWebSession(options, logger, cancellationToken) {
|
|
class WorkerSession2 extends WorkerSession {
|
|
constructor() {
|
|
super(sys, { writeMessage }, options, logger, cancellationToken, hrtime);
|
|
}
|
|
exit() {
|
|
this.logger.info("Exiting...");
|
|
this.projectService.closeLog();
|
|
close();
|
|
}
|
|
listen() {
|
|
addEventListener("message", (message) => {
|
|
this.onMessage(message.data);
|
|
});
|
|
}
|
|
}
|
|
const session = new WorkerSession2();
|
|
session.listen();
|
|
}
|
|
|
|
// src/tsserver/common.ts
|
|
function getLogLevel(level) {
|
|
if (level) {
|
|
const l = level.toLowerCase();
|
|
for (const name in LogLevel2) {
|
|
if (isNaN(+name) && l === name.toLowerCase()) {
|
|
return LogLevel2[name];
|
|
}
|
|
}
|
|
}
|
|
return void 0;
|
|
}
|
|
|
|
// src/tsserver/server.ts
|
|
function findArgumentStringArray(argName) {
|
|
const arg = findArgument(argName);
|
|
if (arg === void 0) {
|
|
return emptyArray2;
|
|
}
|
|
return arg.split(",").filter((name) => name !== "");
|
|
}
|
|
function start({ args, logger, cancellationToken, serverMode, unknownServerMode, startSession: startServer }, platform) {
|
|
const syntaxOnly = hasArgument("--syntaxOnly");
|
|
logger.info(`Starting TS Server`);
|
|
logger.info(`Version: ${version}`);
|
|
logger.info(`Arguments: ${args.join(" ")}`);
|
|
logger.info(`Platform: ${platform} NodeVersion: ${getNodeMajorVersion()} CaseSensitive: ${sys.useCaseSensitiveFileNames}`);
|
|
logger.info(`ServerMode: ${serverMode} syntaxOnly: ${syntaxOnly} hasUnknownServerMode: ${unknownServerMode}`);
|
|
setStackTraceLimit();
|
|
if (Debug.isDebugging) {
|
|
Debug.enableDebugInfo();
|
|
}
|
|
if (sys.tryEnableSourceMapsForHost && /^development$/i.test(sys.getEnvironmentVariable("NODE_ENV"))) {
|
|
sys.tryEnableSourceMapsForHost();
|
|
}
|
|
console.log = (...args2) => logger.msg(args2.length === 1 ? args2[0] : args2.join(", "), "Info" /* Info */);
|
|
console.warn = (...args2) => logger.msg(args2.length === 1 ? args2[0] : args2.join(", "), "Err" /* Err */);
|
|
console.error = (...args2) => logger.msg(args2.length === 1 ? args2[0] : args2.join(", "), "Err" /* Err */);
|
|
startServer(
|
|
{
|
|
globalPlugins: findArgumentStringArray("--globalPlugins"),
|
|
pluginProbeLocations: findArgumentStringArray("--pluginProbeLocations"),
|
|
allowLocalPluginLoads: hasArgument("--allowLocalPluginLoads"),
|
|
useSingleInferredProject: hasArgument("--useSingleInferredProject"),
|
|
useInferredProjectPerProjectRoot: hasArgument("--useInferredProjectPerProjectRoot"),
|
|
suppressDiagnosticEvents: hasArgument("--suppressDiagnosticEvents"),
|
|
noGetErrOnBackgroundUpdate: hasArgument("--noGetErrOnBackgroundUpdate"),
|
|
syntaxOnly,
|
|
serverMode
|
|
},
|
|
logger,
|
|
cancellationToken
|
|
);
|
|
}
|
|
setStackTraceLimit();
|
|
if (typeof process !== "undefined") {
|
|
start(initializeNodeSystem(), require("os").platform());
|
|
} else {
|
|
const listener = (e) => {
|
|
removeEventListener("message", listener);
|
|
const args = e.data;
|
|
start(initializeWebSystem(args), "web");
|
|
};
|
|
addEventListener("message", listener);
|
|
}
|
|
return __toCommonJS(server_exports);
|
|
})();
|
|
|
|
if (typeof module !== "undefined" && module.exports) { module.exports = ts; }
|
|
//# sourceMappingURL=tsserver.js.map
|