typescript 4.7.0-dev.20220427 → 4.7.0-dev.20220430

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.20220427";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220430";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8465,7 +8465,7 @@ var ts;
         Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext: diag(1323, ts.DiagnosticCategory.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', 'node12', or 'nodenext'."),
         Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_or_nodenext_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext' or 'nodenext'."),
         Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."),
-        Dynamic_import_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments."),
+        This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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}()'?"),
@@ -8852,7 +8852,6 @@ var ts;
         A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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}'?"),
-        Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."),
         Could_not_find_name_0_Did_you_mean_1: diag(2570, ts.DiagnosticCategory.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, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."),
         A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."),
@@ -9066,6 +9065,7 @@ var ts;
         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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.Error, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."),
@@ -38156,7 +38156,8 @@ var ts;
                     if (!comment) {
                         comment = parseTrailingTagComments(start, getNodePos(), indent, indentText);
                     }
-                    return finishNode(factory.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start);
+                    var end = comment !== undefined ? getNodePos() : typeExpression.end;
+                    return finishNode(factory.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start, end);
                 }
                 function escapedTextsEqual(a, b) {
                     while (!ts.isIdentifier(a) || !ts.isIdentifier(b)) {
@@ -75786,8 +75787,14 @@ var ts;
             var parameterRange = hasRestParameter ? min
                 : min < max ? min + "-" + max
                     : min;
-            var error = hasRestParameter ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1
-                : parameterRange === 1 && args.length === 0 && isPromiseResolveArityError(node) ? ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise
+            var isVoidPromiseError = !hasRestParameter && parameterRange === 1 && args.length === 0 && isPromiseResolveArityError(node);
+            if (isVoidPromiseError && ts.isInJSFile(node)) {
+                return getDiagnosticForCallNode(node, ts.Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments);
+            }
+            var error = hasRestParameter
+                ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1
+                : isVoidPromiseError
+                    ? ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise
                     : ts.Diagnostics.Expected_0_arguments_but_got_1;
             if (min < args.length && args.length < max) {
                 // between min and max, but with no matching overload
@@ -82839,7 +82846,7 @@ var ts;
                 }
                 var yieldType = getIterationTypeOfIterable(use, 0 /* Yield */, inputType, /*errorNode*/ undefined);
                 if (yieldType) {
-                    return [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators, false];
+                    return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false];
                 }
                 if (isES2015OrLaterIterable((_a = inputType.symbol) === null || _a === void 0 ? void 0 : _a.escapedName)) {
                     return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true];
@@ -86116,7 +86123,7 @@ var ts;
                         var symbol = getIntrinsicTagSymbol(name.parent);
                         return symbol === unknownSymbol ? undefined : symbol;
                     }
-                    var result = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ !isJSDoc_1, ts.getHostSignatureFromJSDoc(name));
+                    var result = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /* dontResolveAlias */ true, ts.getHostSignatureFromJSDoc(name));
                     if (!result && isJSDoc_1) {
                         var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration));
                         if (container) {
@@ -87973,6 +87980,9 @@ var ts;
             return ts.some(types, checkGrammarExpressionWithTypeArguments);
         }
         function checkGrammarExpressionWithTypeArguments(node) {
+            if (ts.isExpressionWithTypeArguments(node) && ts.isImportKeyword(node.expression) && node.typeArguments) {
+                return grammarErrorOnNode(node, ts.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) {
@@ -88914,7 +88924,7 @@ var ts;
                 return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node12_or_nodenext);
             }
             if (node.typeArguments) {
-                return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_import_cannot_have_type_arguments);
+                return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments);
             }
             var nodeArguments = node.arguments;
             if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext) {
@@ -108710,6 +108720,8 @@ var ts;
                         var varDecl = factory.createVariableDeclaration(newId, /*exclamationToken*/ undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), /*initializer*/ undefined);
                         errorFallbackNode = undefined;
                         var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(135 /* DeclareKeyword */)] : [], factory.createVariableDeclarationList([varDecl], 2 /* Const */));
+                        preserveJsDoc(statement, input);
+                        ts.removeAllComments(input);
                         return [statement, factory.updateExportAssignment(input, input.decorators, input.modifiers, newId)];
                     }
                 }
@@ -125094,7 +125106,7 @@ var ts;
         if (!state.watch || !state.lastCachedPackageJsonLookups)
             return;
         ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath), new ts.Map(state.lastCachedPackageJsonLookups.get(resolvedPath)), {
-            createNewValue: function (path, _input) { return state.watchFile(path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
+            createNewValue: function (path, _input) { return state.watchFile(path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); },
             onDeleteValue: ts.closeFileWatcher,
         });
     }
@@ -125839,6 +125851,17 @@ var ts;
         SymbolDisplayPartKind[SymbolDisplayPartKind["linkName"] = 23] = "linkName";
         SymbolDisplayPartKind[SymbolDisplayPartKind["linkText"] = 24] = "linkText";
     })(SymbolDisplayPartKind = ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {}));
+    // Do not change existing values, as they exist in telemetry.
+    var CompletionInfoFlags;
+    (function (CompletionInfoFlags) {
+        CompletionInfoFlags[CompletionInfoFlags["None"] = 0] = "None";
+        CompletionInfoFlags[CompletionInfoFlags["MayIncludeAutoImports"] = 1] = "MayIncludeAutoImports";
+        CompletionInfoFlags[CompletionInfoFlags["IsImportStatementCompletion"] = 2] = "IsImportStatementCompletion";
+        CompletionInfoFlags[CompletionInfoFlags["IsContinuation"] = 4] = "IsContinuation";
+        CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiers"] = 8] = "ResolvedModuleSpecifiers";
+        CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiersBeyondLimit"] = 16] = "ResolvedModuleSpecifiersBeyondLimit";
+        CompletionInfoFlags[CompletionInfoFlags["MayIncludeMethodSnippets"] = 32] = "MayIncludeMethodSnippets";
+    })(CompletionInfoFlags = ts.CompletionInfoFlags || (ts.CompletionInfoFlags = {}));
     var OutliningSpanKind;
     (function (OutliningSpanKind) {
         /** Single or multi-line comments */
@@ -127851,6 +127874,14 @@ var ts;
         return __assign(__assign({}, createModuleSpecifierResolutionHost(program, host)), { getCommonSourceDirectory: function () { return program.getCommonSourceDirectory(); } });
     }
     ts.getModuleSpecifierResolverHost = getModuleSpecifierResolverHost;
+    function moduleResolutionRespectsExports(moduleResolution) {
+        return moduleResolution >= ts.ModuleResolutionKind.Node12 && moduleResolution <= ts.ModuleResolutionKind.NodeNext;
+    }
+    ts.moduleResolutionRespectsExports = moduleResolutionRespectsExports;
+    function moduleResolutionUsesNodeModules(moduleResolution) {
+        return moduleResolution === ts.ModuleResolutionKind.NodeJs || moduleResolution >= ts.ModuleResolutionKind.Node12 && moduleResolution <= ts.ModuleResolutionKind.NodeNext;
+    }
+    ts.moduleResolutionUsesNodeModules = moduleResolutionUsesNodeModules;
     function makeImportIfNecessary(defaultImport, namedImports, moduleSpecifier, quotePreference) {
         return defaultImport || namedImports && namedImports.length ? makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference) : undefined;
     }
@@ -129454,8 +129485,8 @@ var ts;
         if (from === to)
             return false;
         var cachedResult = moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.get(from.path, to.path, preferences, {});
-        if ((cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.isAutoImportable) !== undefined) {
-            return cachedResult.isAutoImportable;
+        if ((cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.isBlockedByPackageJsonDependencies) !== undefined) {
+            return !cachedResult.isBlockedByPackageJsonDependencies;
         }
         var getCanonicalFileName = ts.hostGetCanonicalFileName(moduleSpecifierResolutionHost);
         var globalTypingsCache = (_a = moduleSpecifierResolutionHost.getGlobalTypingsCacheLocation) === null || _a === void 0 ? void 0 : _a.call(moduleSpecifierResolutionHost);
@@ -129469,7 +129500,7 @@ var ts;
         });
         if (packageJsonFilter) {
             var isAutoImportable = hasImportablePath && packageJsonFilter.allowsImportingSourceFile(to, moduleSpecifierResolutionHost);
-            moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.setIsAutoImportable(from.path, to.path, preferences, {}, isAutoImportable);
+            moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(from.path, to.path, preferences, {}, !isAutoImportable);
             return isAutoImportable;
         }
         return hasImportablePath;
@@ -131748,15 +131779,26 @@ var ts;
             var _a, _b, _c;
             var start = ts.timestamp();
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host);
-            var resolutionLimitExceeded = false;
+            // Under `--moduleResolution nodenext`, we have to resolve module specifiers up front, because
+            // package.json exports can mean we *can't* resolve a module specifier (that doesn't include a
+            // relative path into node_modules), and we want to filter those completions out entirely.
+            // Import statement completions always need specifier resolution because the module specifier is
+            // part of their `insertText`, not the `codeActions` creating edits away from the cursor.
+            var needsFullResolution = isForImportStatementCompletion || ts.moduleResolutionRespectsExports(ts.getEmitModuleResolutionKind(program.getCompilerOptions()));
+            var skippedAny = false;
             var ambientCount = 0;
             var resolvedCount = 0;
             var resolvedFromCacheCount = 0;
             var cacheAttemptCount = 0;
-            var result = cb({ tryResolve: tryResolve, resolutionLimitExceeded: function () { return resolutionLimitExceeded; } });
+            var result = cb({
+                tryResolve: tryResolve,
+                skippedAny: function () { return skippedAny; },
+                resolvedAny: function () { return resolvedCount > 0; },
+                resolvedBeyondLimit: function () { return resolvedCount > Completions.moduleSpecifierResolutionLimit; },
+            });
             var hitRateMessage = cacheAttemptCount ? " (" + (resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1) + "% hit rate)" : "";
             (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, logPrefix + ": resolved " + resolvedCount + " module specifiers, plus " + ambientCount + " ambient and " + resolvedFromCacheCount + " from cache" + hitRateMessage);
-            (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, logPrefix + ": response is " + (resolutionLimitExceeded ? "incomplete" : "complete"));
+            (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, logPrefix + ": response is " + (skippedAny ? "incomplete" : "complete"));
             (_c = host.log) === null || _c === void 0 ? void 0 : _c.call(host, logPrefix + ": " + (ts.timestamp() - start));
             return result;
             function tryResolve(exportInfo, symbolName, isFromAmbientModule) {
@@ -131765,22 +131807,22 @@ var ts;
                     if (result_1) {
                         ambientCount++;
                     }
-                    return result_1;
+                    return result_1 || "failed";
                 }
-                var shouldResolveModuleSpecifier = isForImportStatementCompletion || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit;
+                var shouldResolveModuleSpecifier = needsFullResolution || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit;
                 var shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < Completions.moduleSpecifierResolutionCacheAttemptLimit;
                 var result = (shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache)
                     ? ts.codefix.getModuleSpecifierForBestExportInfo(exportInfo, symbolName, position, isValidTypeOnlyUseSite, sourceFile, program, host, preferences, packageJsonImportFilter, shouldGetModuleSpecifierFromCache)
                     : undefined;
                 if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result) {
-                    resolutionLimitExceeded = true;
+                    skippedAny = true;
                 }
                 resolvedCount += (result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0;
-                resolvedFromCacheCount += exportInfo.length - resolvedCount;
+                resolvedFromCacheCount += exportInfo.length - ((result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0);
                 if (shouldGetModuleSpecifierFromCache) {
                     cacheAttemptCount++;
                 }
-                return result;
+                return result || (needsFullResolution ? "failed" : "skipped");
             }
         }
         function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext) {
@@ -131878,6 +131920,7 @@ var ts;
             var newEntries = resolvingModuleSpecifiers("continuePreviousIncompleteResponse", host, program, file, location.getStart(), preferences, 
             /*isForImportStatementCompletion*/ false, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
                 var entries = ts.mapDefined(previousResponse.entries, function (entry) {
+                    var _a;
                     if (!entry.hasAction || !entry.source || !entry.data || completionEntryDataIsResolved(entry.data)) {
                         // Not an auto import or already resolved; keep as is
                         return entry;
@@ -131889,8 +131932,12 @@ var ts;
                     var origin = ts.Debug.checkDefined(getAutoImportSymbolFromCompletionEntryData(entry.name, entry.data, program, host)).origin;
                     var info = exportMap.get(file.path, entry.data.exportMapKey);
                     var result = info && context.tryResolve(info, entry.name, !ts.isExternalModuleNameRelative(ts.stripQuotes(origin.moduleSymbol.name)));
-                    if (!result)
+                    if (result === "skipped")
                         return entry;
+                    if (!result || result === "failed") {
+                        (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, "Unexpected failure resolving auto import for '" + entry.name + "' from '" + entry.source + "'");
+                        return undefined;
+                    }
                     var newOrigin = __assign(__assign({}, origin), { kind: 32 /* ResolvedExport */, moduleSpecifier: result.moduleSpecifier });
                     // Mutating for performance... feels sketchy but nobody else uses the cache,
                     // so why bother allocating a bunch of new objects?
@@ -131899,12 +131946,13 @@ var ts;
                     entry.sourceDisplay = [ts.textPart(newOrigin.moduleSpecifier)];
                     return entry;
                 });
-                if (!context.resolutionLimitExceeded()) {
+                if (!context.skippedAny()) {
                     previousResponse.isIncomplete = undefined;
                 }
                 return entries;
             });
             previousResponse.entries = newEntries;
+            previousResponse.flags = (previousResponse.flags || 0) | 4 /* IsContinuation */;
             return previousResponse;
         }
         function jsdocCompletionInfo(entries) {
@@ -131986,12 +132034,13 @@ var ts;
                 ts.insertSorted(entries, createCompletionEntryForLiteral(sourceFile, preferences, literal), compareCompletionEntries, /*allowDuplicates*/ true);
             }
             return {
+                flags: completionData.flags,
                 isGlobalCompletion: isInSnippetScope,
                 isIncomplete: preferences.allowIncompleteCompletions && hasUnresolvedAutoImports ? true : undefined,
                 isMemberCompletion: isMemberCompletionKind(completionKind),
                 isNewIdentifierLocation: isNewIdentifierLocation,
                 optionalReplacementSpan: getOptionalReplacementSpan(location),
-                entries: entries
+                entries: entries,
             };
         }
         function isUncheckedFile(sourceFile, compilerOptions) {
@@ -133048,6 +133097,7 @@ var ts;
             var location = ts.getTouchingPropertyName(sourceFile, position);
             var keywordFilters = 0 /* None */;
             var isNewIdentifierLocation = false;
+            var flags = 0 /* None */;
             if (contextToken) {
                 var importStatementCompletion = getImportStatementCompletionInfo(contextToken);
                 isNewIdentifierLocation = importStatementCompletion.isNewIdentifierLocation;
@@ -133067,6 +133117,7 @@ var ts;
                     // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients
                     // to opt in with the `includeCompletionsForImportStatements` user preference.
                     importCompletionNode = importStatementCompletion.replacementNode;
+                    flags |= 2 /* IsImportStatementCompletion */;
                 }
                 // Bail out if this is a known invalid completion location
                 if (!importCompletionNode && isCompletionListBlocker(contextToken)) {
@@ -133259,6 +133310,7 @@ var ts;
                 isRightOfOpenTag: isRightOfOpenTag,
                 importCompletionNode: importCompletionNode,
                 hasUnresolvedAutoImports: hasUnresolvedAutoImports,
+                flags: flags,
             };
             function isTagWithTypeExpression(tag) {
                 switch (tag.kind) {
@@ -133668,6 +133720,7 @@ var ts;
                     // Asking for completion details for an item that is not an auto-import
                     return;
                 }
+                flags |= 1 /* MayIncludeAutoImports */;
                 // import { type | -> token text should be blank
                 var isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken
                     && importCompletionNode
@@ -133698,16 +133751,36 @@ var ts;
                             return true;
                         return charactersFuzzyMatchInString(symbolName, lowerCaseTokenText);
                     }, function (info, symbolName, isFromAmbientModule, exportMapKey) {
+                        var _a;
                         if (detailsEntryId && !ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); })) {
                             return;
                         }
-                        var defaultExportInfo = ts.find(info, isImportableExportInfo);
-                        if (!defaultExportInfo) {
+                        // Do a relatively cheap check to bail early if all re-exports are non-importable
+                        // due to file location or package.json dependency filtering. For non-node12+
+                        // module resolution modes, getting past this point guarantees that we'll be
+                        // able to generate a suitable module specifier, so we can safely show a completion,
+                        // even if we defer computing the module specifier.
+                        var firstImportableExportInfo = ts.find(info, isImportableExportInfo);
+                        if (!firstImportableExportInfo) {
                             return;
                         }
-                        // If we don't need to resolve module specifiers, we can use any re-export that is importable at all
-                        // (We need to ensure that at least one is importable to show a completion.)
-                        var _a = context.tryResolve(info, symbolName, isFromAmbientModule) || {}, _b = _a.exportInfo, exportInfo = _b === void 0 ? defaultExportInfo : _b, moduleSpecifier = _a.moduleSpecifier;
+                        // In node12+, module specifier resolution can fail due to modules being blocked
+                        // by package.json `exports`. If that happens, don't show a completion item.
+                        // N.B. in this resolution mode we always try to resolve module specifiers here,
+                        // because we have to know now if it's going to fail so we can omit the completion
+                        // from the list.
+                        var result = context.tryResolve(info, symbolName, isFromAmbientModule) || {};
+                        if (result === "failed")
+                            return;
+                        // If we skipped resolving module specifiers, our selection of which ExportInfo
+                        // to use here is arbitrary, since the info shown in the completion list derived from
+                        // it should be identical regardless of which one is used. During the subsequent
+                        // `CompletionEntryDetails` request, we'll get all the ExportInfos again and pick
+                        // the best one based on the module specifier it produces.
+                        var exportInfo = firstImportableExportInfo, moduleSpecifier;
+                        if (result !== "skipped") {
+                            (_a = result.exportInfo, exportInfo = _a === void 0 ? firstImportableExportInfo : _a, moduleSpecifier = result.moduleSpecifier);
+                        }
                         var isDefaultExport = exportInfo.exportKind === 1 /* Default */;
                         var symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(exportInfo.symbol) || exportInfo.symbol;
                         pushAutoImportSymbol(symbol, {
@@ -133722,7 +133795,9 @@ var ts;
                             isFromPackageJson: exportInfo.isFromPackageJson,
                         });
                     });
-                    hasUnresolvedAutoImports = context.resolutionLimitExceeded();
+                    hasUnresolvedAutoImports = context.skippedAny();
+                    flags |= context.resolvedAny() ? 8 /* ResolvedModuleSpecifiers */ : 0;
+                    flags |= context.resolvedBeyondLimit() ? 16 /* ResolvedModuleSpecifiersBeyondLimit */ : 0;
                 });
                 function isImportableExportInfo(info) {
                     var moduleFile = ts.tryCast(info.moduleSymbol.valueDeclaration, ts.isSourceFile);
@@ -133770,6 +133845,7 @@ var ts;
                         return;
                     }
                     var origin = __assign({ kind: 128 /* ObjectLiteralMethod */ }, entryProps);
+                    flags |= 32 /* MayIncludeMethodSnippets */;
                     symbolToOriginInfoMap[symbols.length] = origin;
                     symbols.push(member);
                 });
@@ -133966,7 +134042,7 @@ var ts;
                     // through type declaration or inference.
                     // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed -
                     // type of parameter will flow in from the contextual type of the function
-                    var canGetType = ts.hasInitializer(rootDeclaration) || ts.hasType(rootDeclaration) || rootDeclaration.parent.parent.kind === 244 /* ForOfStatement */;
+                    var canGetType = ts.hasInitializer(rootDeclaration) || !!ts.getEffectiveTypeAnnotationNode(rootDeclaration) || rootDeclaration.parent.parent.kind === 244 /* ForOfStatement */;
                     if (!canGetType && rootDeclaration.kind === 164 /* Parameter */) {
                         if (ts.isExpression(rootDeclaration.parent)) {
                             canGetType = !!typeChecker.getContextualType(rootDeclaration.parent);
@@ -135241,6 +135317,8 @@ var ts;
                     return highlightSpans(getAsyncAndAwaitOccurrences(node));
                 case 125 /* YieldKeyword */:
                     return highlightSpans(getYieldOccurrences(node));
+                case 101 /* InKeyword */:
+                    return undefined;
                 default:
                     return ts.isModifierKind(node.kind) && (ts.isDeclaration(node.parent) || ts.isVariableStatement(node.parent))
                         ? highlightSpans(getModifierOccurrences(node.kind, node.parent))
@@ -150009,7 +150087,7 @@ var ts;
             ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined.code,
             ts.Diagnostics.Type_0_is_not_an_array_type.code,
             ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type.code,
-            ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators.code,
+            ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher.code,
             ts.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,
             ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
             ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator.code,
@@ -152963,6 +153041,7 @@ var ts;
             var compilerOptions = program.getCompilerOptions();
             var moduleSpecifierResolutionHost = ts.createModuleSpecifierResolutionHost(program, host);
             var getChecker = ts.memoizeOne(function (isFromPackageJson) { return isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker(); });
+            var rejectNodeModulesRelativePaths = ts.moduleResolutionUsesNodeModules(ts.getEmitModuleResolutionKind(compilerOptions));
             var getModuleSpecifiers = fromCacheOnly
                 ? function (moduleSymbol) { return ({ moduleSpecifiers: ts.moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }); }
                 : function (moduleSymbol, checker) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); };
@@ -152973,19 +153052,19 @@ var ts;
                 var importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & 111551 /* Value */);
                 var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, exportInfo.symbol, exportInfo.targetFlags, checker, compilerOptions);
                 computedWithoutCacheCount += computedWithoutCache ? 1 : 0;
-                return moduleSpecifiers === null || moduleSpecifiers === void 0 ? void 0 : moduleSpecifiers.map(function (moduleSpecifier) {
-                    // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
-                    return !importedSymbolHasValueMeaning && isJs && position !== undefined
-                        ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 }
-                        : {
-                            kind: 3 /* AddNew */,
-                            moduleSpecifier: moduleSpecifier,
-                            importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
-                            useRequire: useRequire,
-                            addAsTypeOnly: addAsTypeOnly,
-                            exportInfo: exportInfo,
-                            isReExport: i > 0,
-                        };
+                return ts.mapDefined(moduleSpecifiers, function (moduleSpecifier) {
+                    return rejectNodeModulesRelativePaths && ts.pathContainsNodeModules(moduleSpecifier) ? undefined :
+                        // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types.
+                        !importedSymbolHasValueMeaning && isJs && position !== undefined ? { kind: 1 /* JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 } :
+                            {
+                                kind: 3 /* AddNew */,
+                                moduleSpecifier: moduleSpecifier,
+                                importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions),
+                                useRequire: useRequire,
+                                addAsTypeOnly: addAsTypeOnly,
+                                exportInfo: exportInfo,
+                                isReExport: i > 0,
+                            };
                 });
             });
             return { computedWithoutCacheCount: computedWithoutCacheCount, fixes: fixes };
@@ -158558,6 +158637,7 @@ var ts;
         var fixName = "addVoidToPromise";
         var fixId = "addVoidToPromise";
         var errorCodes = [
+            ts.Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code,
             ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code
         ];
         codefix.registerCodeFix({
@@ -174124,7 +174204,7 @@ var ts;
                     return cache.get(toFileName);
                 },
                 set: function (fromFileName, toFileName, preferences, options, modulePaths, moduleSpecifiers) {
-                    ensureCache(fromFileName, preferences, options).set(toFileName, createInfo(modulePaths, moduleSpecifiers, /*isAutoImportable*/ true));
+                    ensureCache(fromFileName, preferences, options).set(toFileName, createInfo(modulePaths, moduleSpecifiers, /*isBlockedByPackageJsonDependencies*/ false));
                     // If any module specifiers were generated based off paths in node_modules,
                     // a package.json file in that package was read and is an input to the cached.
                     // Instead of watching each individual package.json file, set up a wildcard
@@ -174150,17 +174230,17 @@ var ts;
                         info.modulePaths = modulePaths;
                     }
                     else {
-                        cache.set(toFileName, createInfo(modulePaths, /*moduleSpecifiers*/ undefined, /*isAutoImportable*/ undefined));
+                        cache.set(toFileName, createInfo(modulePaths, /*moduleSpecifiers*/ undefined, /*isBlockedByPackageJsonDependencies*/ undefined));
                     }
                 },
-                setIsAutoImportable: function (fromFileName, toFileName, preferences, options, isAutoImportable) {
+                setBlockedByPackageJsonDependencies: function (fromFileName, toFileName, preferences, options, isBlockedByPackageJsonDependencies) {
                     var cache = ensureCache(fromFileName, preferences, options);
                     var info = cache.get(toFileName);
                     if (info) {
-                        info.isAutoImportable = isAutoImportable;
+                        info.isBlockedByPackageJsonDependencies = isBlockedByPackageJsonDependencies;
                     }
                     else {
-                        cache.set(toFileName, createInfo(/*modulePaths*/ undefined, /*moduleSpecifiers*/ undefined, isAutoImportable));
+                        cache.set(toFileName, createInfo(/*modulePaths*/ undefined, /*moduleSpecifiers*/ undefined, isBlockedByPackageJsonDependencies));
                     }
                 },
                 clear: function () {
@@ -174188,8 +174268,8 @@ var ts;
             function key(fromFileName, preferences, options) {
                 return fromFileName + "," + preferences.importModuleSpecifierEnding + "," + preferences.importModuleSpecifierPreference + "," + options.overrideImportMode;
             }
-            function createInfo(modulePaths, moduleSpecifiers, isAutoImportable) {
-                return { modulePaths: modulePaths, moduleSpecifiers: moduleSpecifiers, isAutoImportable: isAutoImportable };
+            function createInfo(modulePaths, moduleSpecifiers, isBlockedByPackageJsonDependencies) {
+                return { modulePaths: modulePaths, moduleSpecifiers: moduleSpecifiers, isBlockedByPackageJsonDependencies: isBlockedByPackageJsonDependencies };
             }
         }
         server.createModuleSpecifierCache = createModuleSpecifierCache;

package/lib/typescript.d.ts

@@ -6435,7 +6435,18 @@ declare namespace ts {
         argumentIndex: number;
         argumentCount: number;
     }
+    enum CompletionInfoFlags {
+        None = 0,
+        MayIncludeAutoImports = 1,
+        IsImportStatementCompletion = 2,
+        IsContinuation = 4,
+        ResolvedModuleSpecifiers = 8,
+        ResolvedModuleSpecifiersBeyondLimit = 16,
+        MayIncludeMethodSnippets = 32
+    }
     interface CompletionInfo {
+        /** For performance telemetry. */
+        flags?: CompletionInfoFlags;
         /** Not true for all global completions. This will be true if the enclosing scope matches a few syntax kinds. See `isSnippetScope`. */
         isGlobalCompletion: boolean;
         isMemberCompletion: boolean;