typescript 4.6.0-dev.20220118 → 4.6.0-dev.20220119

package/lib/tsserverlibrary.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220118";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220119";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -44691,7 +44691,7 @@ var ts;
             maybeBindExpressionFlowIfCall(node.expression);
         }
         function maybeBindExpressionFlowIfCall(node) {
-            // A top level or LHS of comma expression call expression with a dotted function name and at least one argument
+            // A top level or comma expression call expression with a dotted function name and at least one argument
             // is potentially an assertion and is therefore included in the control flow.
             if (node.kind === 207 /* CallExpression */) {
                 var call = node;
@@ -44859,22 +44859,27 @@ var ts;
                 }
                 return state;
             }
-            function onLeft(left, state, _node) {
+            function onLeft(left, state, node) {
                 if (!state.skip) {
-                    return maybeBind(left);
+                    var maybeBound = maybeBind(left);
+                    if (node.operatorToken.kind === 27 /* CommaToken */) {
+                        maybeBindExpressionFlowIfCall(left);
+                    }
+                    return maybeBound;
                 }
             }
-            function onOperator(operatorToken, state, node) {
+            function onOperator(operatorToken, state, _node) {
                 if (!state.skip) {
-                    if (operatorToken.kind === 27 /* CommaToken */) {
-                        maybeBindExpressionFlowIfCall(node.left);
-                    }
                     bind(operatorToken);
                 }
             }
-            function onRight(right, state, _node) {
+            function onRight(right, state, node) {
                 if (!state.skip) {
-                    return maybeBind(right);
+                    var maybeBound = maybeBind(right);
+                    if (node.operatorToken.kind === 27 /* CommaToken */) {
+                        maybeBindExpressionFlowIfCall(right);
+                    }
+                    return maybeBound;
                 }
             }
             function onExit(node, state) {
@@ -51151,6 +51156,7 @@ var ts;
                             getCommonSourceDirectory: !!host.getCommonSourceDirectory ? function () { return host.getCommonSourceDirectory(); } : function () { return ""; },
                             getCurrentDirectory: function () { return host.getCurrentDirectory(); },
                             getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache),
+                            getPackageJsonInfoCache: function () { var _a; return (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host); },
                             useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames),
                             redirectTargetsMap: host.redirectTargetsMap,
                             getProjectReferenceRedirect: function (fileName) { return host.getProjectReferenceRedirect(fileName); },
@@ -95723,10 +95729,19 @@ var ts;
             var _a;
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             var isStaticChildren = ts.length(nonWhitespaceChildren) > 1 || !!((_a = nonWhitespaceChildren[0]) === null || _a === void 0 ? void 0 : _a.dotDotDotToken);
-            var args = [tagName, objectProperties, !keyAttr ? factory.createVoidZero() : transformJsxAttributeInitializer(keyAttr.initializer)];
+            var args = [tagName, objectProperties];
+            // function jsx(type, config, maybeKey) {}
+            // "maybeKey" is optional. It is acceptable to use "_jsx" without a third argument
+            if (keyAttr) {
+                args.push(transformJsxAttributeInitializer(keyAttr.initializer));
+            }
             if (compilerOptions.jsx === 5 /* ReactJSXDev */) {
                 var originalFile = ts.getOriginalNode(currentSourceFile);
                 if (originalFile && ts.isSourceFile(originalFile)) {
+                    // "maybeKey" has to be replaced with "void 0" to not break the jsxDEV signature
+                    if (keyAttr === undefined) {
+                        args.push(factory.createVoidZero());
+                    }
                     // isStaticChildren development flag
                     args.push(isStaticChildren ? factory.createTrue() : factory.createFalse());
                     // __source development flag
@@ -119591,11 +119606,12 @@ var ts;
             };
         }
         function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) {
+            var _a;
             if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node12
                 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) {
                 return false;
             }
-            return ts.getImpliedNodeFormatForFile(importingSourceFileName, /*packageJsonInfoCache*/ undefined, getModuleResolutionHost(host), compilerOptions) !== ts.ModuleKind.CommonJS;
+            return ts.getImpliedNodeFormatForFile(importingSourceFileName, (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host), getModuleResolutionHost(host), compilerOptions) !== ts.ModuleKind.CommonJS;
         }
         function getModuleResolutionHost(host) {
             var _a;
@@ -120155,11 +120171,13 @@ var ts;
             // For classic resolution, only allow importing from node_modules/@types, not other node_modules
             return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Classic && packageName === nodeModulesDirectoryName ? undefined : packageName;
             function tryDirectoryWithPackageJson(packageRootIndex) {
+                var _a, _b;
                 var packageRootPath = path.substring(0, packageRootIndex);
                 var packageJsonPath = ts.combinePaths(packageRootPath, "package.json");
                 var moduleFileToTry = path;
-                if (host.fileExists(packageJsonPath)) {
-                    var packageJsonContent = JSON.parse(host.readFile(packageJsonPath));
+                var cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getPackageJsonInfo(packageJsonPath);
+                if (typeof cachedPackageJson === "object" || cachedPackageJson === undefined && host.fileExists(packageJsonPath)) {
+                    var packageJsonContent = (cachedPackageJson === null || cachedPackageJson === void 0 ? void 0 : cachedPackageJson.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath));
                     if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
                         // `conditions` *could* be made to go against `importingSourceFile.impliedNodeFormat` if something wanted to generate
                         // an ImportEqualsDeclaration in an ESM-implied file or an ImportCall in a CJS-implied file. But since this function is
@@ -120998,6 +121016,7 @@ var ts;
         var sharedExtendedConfigFileWatchers; // Map of file watchers for extended files, shared between different referenced projects
         var extendedConfigCache = host.extendedConfigCache; // Cache for extended config evaluation
         var changesAffectResolution = false; // Flag for indicating non-config changes affect module resolution
+        var reportFileChangeDetectedOnCreateProgram = false; // True if synchronizeProgram should report "File change detected..." when a new program is created
         var sourceFilesCache = new ts.Map(); // Cache that stores the source file and version info
         var missingFilePathsRequestedForRelease; // These paths are held temporarily so that we can remove the entry from source file cache if the file is not tracked by missing files
         var hasChangedCompilerOptions = false; // True if the compiler options have changed between compilations
@@ -121160,14 +121179,21 @@ var ts;
             var hasInvalidatedResolution = resolutionCache.createHasInvalidatedResolution(userProvidedResolution || changesAffectResolution);
             if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, fileExists, hasInvalidatedResolution, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
                 if (hasChangedConfigFileParsingErrors) {
+                    if (reportFileChangeDetectedOnCreateProgram) {
+                        reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
+                    }
                     builderProgram = createProgram(/*rootNames*/ undefined, /*options*/ undefined, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences);
                     hasChangedConfigFileParsingErrors = false;
                 }
             }
             else {
+                if (reportFileChangeDetectedOnCreateProgram) {
+                    reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
+                }
                 createNewProgram(hasInvalidatedResolution);
             }
             changesAffectResolution = false; // reset for next sync
+            reportFileChangeDetectedOnCreateProgram = false;
             if (host.afterProgramCreate && program !== builderProgram) {
                 host.afterProgramCreate(builderProgram);
             }
@@ -121369,7 +121395,7 @@ var ts;
         }
         function updateProgramWithWatchStatus() {
             timerToUpdateProgram = undefined;
-            reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation);
+            reportFileChangeDetectedOnCreateProgram = true;
             updateProgram();
         }
         function updateProgram() {
@@ -123893,6 +123919,7 @@ var ts;
         ScriptElementKind["externalModuleName"] = "external module name";
         /**
          * <JsxTagName attribute1 attribute2={0} />
+         * @deprecated
          */
         ScriptElementKind["jsxAttribute"] = "JSX attribute";
         /** String literal */
@@ -125784,6 +125811,7 @@ var ts;
             useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames),
             getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache) || program.getSymlinkCache,
             getModuleSpecifierCache: ts.maybeBind(host, host.getModuleSpecifierCache),
+            getPackageJsonInfoCache: function () { var _a; return (_a = program.getModuleResolutionCache()) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfoCache(); },
             getGlobalTypingsCacheLocation: ts.maybeBind(host, host.getGlobalTypingsCacheLocation),
             redirectTargetsMap: program.redirectTargetsMap,
             getProjectReferenceRedirect: function (fileName) { return program.getProjectReferenceRedirect(fileName); },
@@ -129528,6 +129556,7 @@ var ts;
         function resolvingModuleSpecifiers(logPrefix, host, program, sourceFile, preferences, isForImportStatementCompletion, cb) {
             var _a, _b, _c;
             var start = ts.timestamp();
+            var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
             var resolutionLimitExceeded = false;
             var ambientCount = 0;
             var resolvedCount = 0;
@@ -129550,7 +129579,7 @@ var ts;
                 var shouldResolveModuleSpecifier = isForImportStatementCompletion || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit;
                 var shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < Completions.moduleSpecifierResolutionCacheAttemptLimit;
                 var result = (shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache)
-                    ? ts.codefix.getModuleSpecifierForBestExportInfo(exportInfo, sourceFile, program, host, preferences, shouldGetModuleSpecifierFromCache)
+                    ? ts.codefix.getModuleSpecifierForBestExportInfo(exportInfo, sourceFile, program, host, preferences, packageJsonImportFilter, shouldGetModuleSpecifierFromCache)
                     : undefined;
                 if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result) {
                     resolutionLimitExceeded = true;
@@ -130948,9 +130977,7 @@ var ts;
                     // GH#39946. Pulling on the type of a node inside of a function with a contextual `this` parameter can result in a circularity
                     // if the `node` is part of the exprssion of a `yield` or `return`. This circularity doesn't exist at compile time because
                     // we will check (and cache) the type of `this` *before* checking the type of the node.
-                    var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false);
-                    if (!ts.isSourceFile(container) && container.parent)
-                        typeChecker.getTypeAtLocation(container);
+                    typeChecker.tryGetThisTypeAt(node, /*includeGlobalThis*/ false);
                     var type = typeChecker.getTypeAtLocation(node).getNonOptionalType();
                     var insertQuestionDot = false;
                     if (type.isNullableType()) {
@@ -141820,18 +141847,7 @@ var ts;
                     }
                     return unionPropertyKind;
                 }
-                // If we requested completions after `x.` at the top-level, we may be at a source file location.
-                switch (location.parent && location.parent.kind) {
-                    // If we've typed a character of the attribute name, will be 'JsxAttribute', else will be 'JsxOpeningElement'.
-                    case 279 /* JsxOpeningElement */:
-                    case 277 /* JsxElement */:
-                    case 278 /* JsxSelfClosingElement */:
-                        return location.kind === 79 /* Identifier */ ? "property" /* memberVariableElement */ : "JSX attribute" /* jsxAttribute */;
-                    case 284 /* JsxAttribute */:
-                        return "JSX attribute" /* jsxAttribute */;
-                    default:
-                        return "property" /* memberVariableElement */;
-                }
+                return "property" /* memberVariableElement */;
             }
             return "" /* unknown */;
         }
@@ -149823,7 +149839,8 @@ var ts;
         codefix.getImportCompletionAction = getImportCompletionAction;
         function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, symbolName, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
             ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol");
-            return getBestFix(getImportFixes(exportInfos, symbolName, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences), sourceFile, program, host, preferences);
+            var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
+            return getBestFix(getImportFixes(exportInfos, symbolName, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences), sourceFile, program, packageJsonImportFilter);
         }
         function codeFixActionToCodeAction(_a) {
             var description = _a.description, changes = _a.changes, commands = _a.commands;
@@ -149878,12 +149895,12 @@ var ts;
                 return !moduleFile || ts.isImportableFile(program, importingFile, moduleFile, preferences, /*packageJsonFilter*/ undefined, getModuleSpecifierResolutionHost(isFromPackageJson), (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host));
             }
         }
-        function getModuleSpecifierForBestExportInfo(exportInfo, importingFile, program, host, preferences, fromCacheOnly) {
+        function getModuleSpecifierForBestExportInfo(exportInfo, importingFile, program, host, preferences, packageJsonImportFilter, fromCacheOnly) {
             var _a = getNewImportFixes(program, importingFile, 
             /*position*/ undefined, 
             /*isValidTypeOnlyUseSite*/ false, 
             /*useRequire*/ false, exportInfo, host, preferences, fromCacheOnly), fixes = _a.fixes, computedWithoutCacheCount = _a.computedWithoutCacheCount;
-            var result = getBestFix(fixes, importingFile, program, host, preferences);
+            var result = getBestFix(fixes, importingFile, program, packageJsonImportFilter || ts.createPackageJsonImportFilter(importingFile, preferences, host));
             return result && __assign(__assign({}, result), { computedWithoutCacheCount: computedWithoutCacheCount });
         }
         codefix.getModuleSpecifierForBestExportInfo = getModuleSpecifierForBestExportInfo;
@@ -150103,23 +150120,22 @@ var ts;
             var info = errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code
                 ? getFixesInfoForUMDImport(context, symbolToken)
                 : ts.isIdentifier(symbolToken) ? getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider) : undefined;
-            return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, context.host, context.preferences) });
+            var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
+            return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter) });
         }
-        function sortFixes(fixes, sourceFile, program, host, preferences) {
-            var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
-            return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, sourceFile, program, allowsImportingSpecifier); });
+        function sortFixes(fixes, sourceFile, program, packageJsonImportFilter) {
+            return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier); });
         }
-        function getBestFix(fixes, sourceFile, program, host, preferences) {
+        function getBestFix(fixes, sourceFile, program, packageJsonImportFilter) {
             if (!ts.some(fixes))
                 return;
             // These will always be placed first if available, and are better than other kinds
             if (fixes[0].kind === 0 /* UseNamespace */ || fixes[0].kind === 2 /* AddToExisting */) {
                 return fixes[0];
             }
-            var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
                 // Takes true branch of conditional if `fix` is better than `best`
-                return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
+                return compareModuleSpecifiers(fix, best, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
         /** @returns `Comparison.LessThan` if `a` is better than `b`. */
@@ -152971,7 +152987,7 @@ var ts;
                 });
                 var name = declaration && ts.getNameOfDeclaration(declaration);
                 return !name || changes.length === 0 ? undefined
-                    : [codefix.createCodeFixAction(fixId, changes, [getDiagnostic(errorCode, token), name.getText(sourceFile)], fixId, ts.Diagnostics.Infer_all_types_from_usage)];
+                    : [codefix.createCodeFixAction(fixId, changes, [getDiagnostic(errorCode, token), ts.getTextOfNode(name)], fixId, ts.Diagnostics.Infer_all_types_from_usage)];
             },
             fixIds: [fixId],
             getAllCodeActions: function (context) {
@@ -153049,7 +153065,7 @@ var ts;
                 case ts.Diagnostics.Variable_0_implicitly_has_an_1_type.code: {
                     var symbol = program.getTypeChecker().getSymbolAtLocation(token);
                     if (symbol && symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && markSeen(symbol.valueDeclaration)) {
-                        annotateVariableDeclaration(changes, importAdder, sourceFile, symbol.valueDeclaration, program, host, cancellationToken);
+                        annotateVariableDeclaration(changes, importAdder, ts.getSourceFileOfNode(symbol.valueDeclaration), symbol.valueDeclaration, program, host, cancellationToken);
                         importAdder.writeFixes(changes);
                         return symbol.valueDeclaration;
                     }
@@ -161328,6 +161344,7 @@ var ts;
                 hasChangedAutomaticTypeDirectiveNames: hasChangedAutomaticTypeDirectiveNames,
                 trace: parseConfigHost.trace,
                 resolveModuleNames: ts.maybeBind(host, host.resolveModuleNames),
+                getModuleResolutionCache: ts.maybeBind(host, host.getModuleResolutionCache),
                 resolveTypeReferenceDirectives: ts.maybeBind(host, host.resolveTypeReferenceDirectives),
                 useSourceOfProjectReferenceRedirect: ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect),
                 getParsedCommandLine: getParsedCommandLine,
@@ -165541,6 +165558,9 @@ var ts;
             Project.prototype.resolveModuleNames = function (moduleNames, containingFile, reusedNames, redirectedReference, _options, containingSourceFile) {
                 return this.resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile);
             };
+            Project.prototype.getModuleResolutionCache = function () {
+                return this.resolutionCache.getModuleResolutionCache();
+            };
             Project.prototype.getResolvedModuleWithFailedLookupLocationsFromCache = function (moduleName, containingFile, resolutionMode) {
                 return this.resolutionCache.getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode);
             };
@@ -166803,6 +166823,7 @@ var ts;
                 if (!program) {
                     return ts.emptyArray;
                 }
+                var start = ts.timestamp();
                 var dependencyNames;
                 var rootNames;
                 var rootFileName = ts.combinePaths(hostProject.currentDirectory, ts.inferredTypesContainingFile);
@@ -166812,14 +166833,14 @@ var ts;
                     (_a = packageJson.dependencies) === null || _a === void 0 ? void 0 : _a.forEach(function (_, dependenyName) { return addDependency(dependenyName); });
                     (_b = packageJson.peerDependencies) === null || _b === void 0 ? void 0 : _b.forEach(function (_, dependencyName) { return addDependency(dependencyName); });
                 }
+                var dependenciesAdded = 0;
                 if (dependencyNames) {
-                    var dependenciesAdded = 0;
                     var symlinkCache = hostProject.getSymlinkCache();
                     for (var _c = 0, _d = ts.arrayFrom(dependencyNames.keys()); _c < _d.length; _c++) {
                         var name = _d[_c];
                         // Avoid creating a large project that would significantly slow down time to editor interactivity
                         if (dependencySelection === 2 /* Auto */ && dependenciesAdded > this.maxDependencies) {
-                            hostProject.log("Auto-import provider attempted to add more than " + this.maxDependencies + " dependencies.");
+                            hostProject.log("AutoImportProviderProject: attempted to add more than " + this.maxDependencies + " dependencies. Aborting.");
                             return ts.emptyArray;
                         }
                         // 1. Try to load from the implementation package. For many dependencies, the
@@ -166853,6 +166874,9 @@ var ts;
                         }
                     }
                 }
+                if (rootNames === null || rootNames === void 0 ? void 0 : rootNames.length) {
+                    hostProject.log("AutoImportProviderProject: found " + rootNames.length + " root files in " + dependenciesAdded + " dependencies in " + (ts.timestamp() - start) + " ms");
+                }
                 return rootNames || ts.emptyArray;
                 function addDependency(dependency) {
                     if (!ts.startsWith(dependency, "@types/")) {
@@ -166953,6 +166977,11 @@ var ts;
                 return this.hostProject.getSymlinkCache();
             };
             /*@internal*/
+            AutoImportProviderProject.prototype.getModuleResolutionCache = function () {
+                var _a;
+                return (_a = this.hostProject.getCurrentProgram()) === null || _a === void 0 ? void 0 : _a.getModuleResolutionCache();
+            };
+            /*@internal*/
             AutoImportProviderProject.maxDependencies = 10;
             /*@internal*/
             AutoImportProviderProject.compilerOptionsOverrides = {

package/lib/typescript.d.ts

@@ -6594,6 +6594,7 @@ declare namespace ts {
         externalModuleName = "external module name",
         /**
          * <JsxTagName attribute1 attribute2={0} />
+         * @deprecated
          */
         jsxAttribute = "JSX attribute",
         /** String literal */