typescript 4.8.0-dev.20220617 → 4.8.0-dev.20220620

package/lib/tsserverlibrary.js

@@ -303,7 +303,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.20220617";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220620";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -10138,6 +10138,9 @@ var ts;
         For_await_loops_cannot_be_used_inside_a_class_static_block: diag(18038, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.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, ts.DiagnosticCategory.Message, "_0_is_automatically_exported_here_18044", "'{0}' is automatically exported here."),
     };
 })(ts || (ts = {}));
 var ts;
@@ -34726,10 +34729,10 @@ var ts;
                 setDecoratorContext(/*val*/ false);
             }
             var pos = getNodePos();
-            var expr = parseAssignmentExpressionOrHigher();
+            var expr = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             var operatorToken;
             while ((operatorToken = parseOptionalToken(27 /* CommaToken */))) {
-                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(), pos);
+                expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true), pos);
             }
             if (saveDecoratorContext) {
                 setDecoratorContext(/*val*/ true);
@@ -34737,9 +34740,9 @@ var ts;
             return expr;
         }
         function parseInitializer() {
-            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher() : undefined;
+            return parseOptional(63 /* EqualsToken */) ? parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true) : undefined;
         }
-        function parseAssignmentExpressionOrHigher() {
+        function parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) {
             //  AssignmentExpression[in,yield]:
             //      1) ConditionalExpression[?in,?yield]
             //      2) LeftHandSideExpression = AssignmentExpression[?in,?yield]
@@ -34765,7 +34768,7 @@ var ts;
             // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is
             // not a LeftHandSideExpression, nor does it start a ConditionalExpression.  So we are done
             // with AssignmentExpression if we see one.
-            var arrowExpression = tryParseParenthesizedArrowFunctionExpression() || tryParseAsyncSimpleArrowFunctionExpression();
+            var arrowExpression = tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction);
             if (arrowExpression) {
                 return arrowExpression;
             }
@@ -34784,7 +34787,7 @@ var ts;
             // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single
             // identifier and the current token is an arrow.
             if (expr.kind === 79 /* Identifier */ && token() === 38 /* EqualsGreaterThanToken */) {
-                return parseSimpleArrowFunctionExpression(pos, expr, /*asyncModifier*/ undefined);
+                return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, /*asyncModifier*/ undefined);
             }
             // Now see if we might be in cases '2' or '3'.
             // If the expression was a LHS expression, and we have an assignment operator, then
@@ -34793,10 +34796,10 @@ var ts;
             // Note: we call reScanGreaterToken so that we get an appropriately merged token
             // for cases like `> > =` becoming `>>=`
             if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) {
-                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(), pos);
+                return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction), pos);
             }
             // It wasn't an assignment or a lambda.  This is a conditional expression:
-            return parseConditionalExpressionRest(expr, pos);
+            return parseConditionalExpressionRest(expr, pos, allowReturnTypeInArrowFunction);
         }
         function isYieldExpression() {
             if (token() === 125 /* YieldKeyword */) {
@@ -34836,7 +34839,7 @@ var ts;
             nextToken();
             if (!scanner.hasPrecedingLineBreak() &&
                 (token() === 41 /* AsteriskToken */ || isStartOfExpression())) {
-                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher()), pos);
+                return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* AsteriskToken */), parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true)), pos);
             }
             else {
                 // if the next token is not on the same line as yield.  or we don't have an '*' or
@@ -34844,7 +34847,7 @@ var ts;
                 return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos);
             }
         }
-        function parseSimpleArrowFunctionExpression(pos, identifier, asyncModifier) {
+        function parseSimpleArrowFunctionExpression(pos, identifier, allowReturnTypeInArrowFunction, asyncModifier) {
             ts.Debug.assert(token() === 38 /* EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>");
             var parameter = factory.createParameterDeclaration(
             /*modifiers*/ undefined, 
@@ -34855,11 +34858,11 @@ var ts;
             finishNode(parameter, identifier.pos);
             var parameters = createNodeArray([parameter], parameter.pos, parameter.end);
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
-            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier);
+            var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, allowReturnTypeInArrowFunction);
             var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body);
             return addJSDocComment(finishNode(node, pos));
         }
-        function tryParseParenthesizedArrowFunctionExpression() {
+        function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             var triState = isParenthesizedArrowFunctionExpression();
             if (triState === 0 /* False */) {
                 // It's definitely not a parenthesized arrow function expression.
@@ -34870,8 +34873,8 @@ var ts;
             // it out, but don't allow any ambiguity, and return 'undefined' if this could be an
             // expression instead.
             return triState === 1 /* True */ ?
-                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true) :
-                tryParse(parsePossibleParenthesizedArrowFunctionExpression);
+                parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*allowReturnTypeInArrowFunction*/ true) :
+                tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction); });
         }
         //  True        -> We definitely expect a parenthesized arrow function here.
         //  False       -> There *cannot* be a parenthesized arrow function here.
@@ -35005,25 +35008,25 @@ var ts;
                 return 2 /* Unknown */;
             }
         }
-        function parsePossibleParenthesizedArrowFunctionExpression() {
+        function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             var tokenPos = scanner.getTokenPos();
             if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) {
                 return undefined;
             }
-            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
+            var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, allowReturnTypeInArrowFunction);
             if (!result) {
                 (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos);
             }
             return result;
         }
-        function tryParseAsyncSimpleArrowFunctionExpression() {
+        function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) {
             // We do a check here so that we won't be doing unnecessarily call to "lookAhead"
             if (token() === 131 /* AsyncKeyword */) {
                 if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* True */) {
                     var pos = getNodePos();
                     var asyncModifier = parseModifiersForArrowFunction();
                     var expr = parseBinaryExpressionOrHigher(0 /* Lowest */);
-                    return parseSimpleArrowFunctionExpression(pos, expr, asyncModifier);
+                    return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, asyncModifier);
                 }
             }
             return undefined;
@@ -35047,7 +35050,7 @@ var ts;
             }
             return 0 /* False */;
         }
-        function parseParenthesizedArrowFunctionExpression(allowAmbiguity) {
+        function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) {
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiersForArrowFunction();
@@ -35082,6 +35085,7 @@ var ts;
                     return undefined;
                 }
             }
+            var hasReturnColon = token() === 58 /* ColonToken */;
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
             if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) {
                 return undefined;
@@ -35110,12 +35114,37 @@ var ts;
             var lastToken = token();
             var equalsGreaterThanToken = parseExpectedToken(38 /* EqualsGreaterThanToken */);
             var body = (lastToken === 38 /* EqualsGreaterThanToken */ || lastToken === 18 /* OpenBraceToken */)
-                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier))
+                ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), allowReturnTypeInArrowFunction)
                 : parseIdentifier();
+            // Given:
+            //     x ? y => ({ y }) : z => ({ z })
+            // We try to parse the body of the first arrow function by looking at:
+            //     ({ y }) : z => ({ z })
+            // This is a valid arrow function with "z" as the return type.
+            //
+            // But, if we're in the true side of a conditional expression, this colon
+            // terminates the expression, so we cannot allow a return type if we aren't
+            // certain whether or not the preceding text was parsed as a parameter list.
+            //
+            // For example,
+            //     a() ? (b: number, c?: string): void => d() : e
+            // is determined by isParenthesizedArrowFunctionExpression to unambiguously
+            // be an arrow expression, so we allow a return type.
+            if (!allowReturnTypeInArrowFunction && hasReturnColon) {
+                // However, if the arrow function we were able to parse is followed by another colon
+                // as in:
+                //     a ? (x): string => x : null
+                // Then allow the arrow function, and treat the second colon as terminating
+                // the conditional expression. It's okay to do this because this code would
+                // be a syntax error in JavaScript (as the second colon shouldn't be there).
+                if (token() !== 58 /* ColonToken */) {
+                    return undefined;
+                }
+            }
             var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body);
             return withJSDoc(finishNode(node, pos), hasJSDoc);
         }
-        function parseArrowFunctionExpressionBody(isAsync) {
+        function parseArrowFunctionExpressionBody(isAsync, allowReturnTypeInArrowFunction) {
             if (token() === 18 /* OpenBraceToken */) {
                 return parseFunctionBlock(isAsync ? 2 /* Await */ : 0 /* None */);
             }
@@ -35143,12 +35172,12 @@ var ts;
             var savedTopLevel = topLevel;
             topLevel = false;
             var node = isAsync
-                ? doInAwaitContext(parseAssignmentExpressionOrHigher)
-                : doOutsideOfAwaitContext(parseAssignmentExpressionOrHigher);
+                ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); })
+                : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); });
             topLevel = savedTopLevel;
             return node;
         }
-        function parseConditionalExpressionRest(leftOperand, pos) {
+        function parseConditionalExpressionRest(leftOperand, pos, allowReturnTypeInArrowFunction) {
             // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher.
             var questionToken = parseOptionalToken(57 /* QuestionToken */);
             if (!questionToken) {
@@ -35157,8 +35186,8 @@ var ts;
             // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and
             // we do not that for the 'whenFalse' part.
             var colonToken;
-            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, parseAssignmentExpressionOrHigher), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
-                ? parseAssignmentExpressionOrHigher()
+            return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ false); }), colonToken = parseExpectedToken(58 /* ColonToken */), ts.nodeIsPresent(colonToken)
+                ? parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction)
                 : createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* ColonToken */))), pos);
         }
         function parseBinaryExpressionOrHigher(precedence) {
@@ -36073,13 +36102,13 @@ var ts;
         function parseSpreadElement() {
             var pos = getNodePos();
             parseExpected(25 /* DotDotDotToken */);
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             return finishNode(factory.createSpreadElement(expression), pos);
         }
         function parseArgumentOrArrayLiteralElement() {
             return token() === 25 /* DotDotDotToken */ ? parseSpreadElement() :
                 token() === 27 /* CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) :
-                    parseAssignmentExpressionOrHigher();
+                    parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
         }
         function parseArgumentExpression() {
             return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement);
@@ -36097,7 +36126,7 @@ var ts;
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             if (parseOptionalToken(25 /* DotDotDotToken */)) {
-                var expression = parseAssignmentExpressionOrHigher();
+                var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
                 return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc);
             }
             var decorators = parseDecorators();
@@ -36126,7 +36155,7 @@ var ts;
             var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* ColonToken */);
             if (isShorthandPropertyAssignment) {
                 var equalsToken = parseOptionalToken(63 /* EqualsToken */);
-                var objectAssignmentInitializer = equalsToken ? allowInAnd(parseAssignmentExpressionOrHigher) : undefined;
+                var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); }) : undefined;
                 node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer);
                 // Save equals token for error reporting.
                 // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful.
@@ -36134,7 +36163,7 @@ var ts;
             }
             else {
                 parseExpected(58 /* ColonToken */);
-                var initializer = allowInAnd(parseAssignmentExpressionOrHigher);
+                var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); });
                 node = factory.createPropertyAssignment(name, initializer);
             }
             // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker
@@ -36311,7 +36340,7 @@ var ts;
             }
             var node;
             if (awaitToken ? parseExpected(160 /* OfKeyword */) : parseOptional(160 /* OfKeyword */)) {
-                var expression = allowInAnd(parseAssignmentExpressionOrHigher);
+                var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); });
                 parseExpected(21 /* CloseParenToken */);
                 node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement());
             }
@@ -37499,7 +37528,7 @@ var ts;
             var pos = getNodePos();
             var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* StringLiteral */);
             parseExpected(58 /* ColonToken */);
-            var value = parseAssignmentExpressionOrHigher();
+            var value = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             return finishNode(factory.createAssertEntry(name, value), pos);
         }
         function parseAssertClause(skipAssertKeyword) {
@@ -37740,7 +37769,7 @@ var ts;
             else {
                 parseExpected(88 /* DefaultKeyword */);
             }
-            var expression = parseAssignmentExpressionOrHigher();
+            var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true);
             parseSemicolon();
             setAwaitContext(savedAwaitContext);
             var node = factory.createExportAssignment(modifiers, isExportEquals, expression);
@@ -85866,6 +85895,7 @@ var ts;
             return true;
         }
         function checkAliasSymbol(node) {
+            var _a, _b, _c, _d, _e;
             var symbol = getSymbolOfNode(node);
             var target = resolveAlias(symbol);
             if (target !== unknownSymbol) {
@@ -85876,6 +85906,31 @@ var ts;
                 // otherwise it will conflict with some local declaration). Note that in addition to normal flags we include matching SymbolFlags.Export*
                 // in order to prevent collisions with declarations that were exported from the current module (they still contribute to local names).
                 symbol = getMergedSymbol(symbol.exportSymbol || symbol);
+                // A type-only import/export will already have a grammar error in a JS file, so no need to issue more errors within
+                if (ts.isInJSFile(node) && !(target.flags & 111551 /* Value */) && !ts.isTypeOnlyImportOrExportDeclaration(node)) {
+                    var errorNode = ts.isImportOrExportSpecifier(node) ? node.propertyName || node.name :
+                        ts.isNamedDeclaration(node) ? node.name :
+                            node;
+                    ts.Debug.assert(node.kind !== 274 /* NamespaceExport */);
+                    if (node.kind === 275 /* ExportSpecifier */) {
+                        var diag = error(errorNode, ts.Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files);
+                        var alreadyExportedSymbol = (_b = (_a = ts.getSourceFileOfNode(node).symbol) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.get((node.propertyName || node.name).escapedText);
+                        if (alreadyExportedSymbol === target) {
+                            var exportingDeclaration = (_c = alreadyExportedSymbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isJSDocNode);
+                            if (exportingDeclaration) {
+                                ts.addRelatedInfo(diag, ts.createDiagnosticForNode(exportingDeclaration, ts.Diagnostics._0_is_automatically_exported_here, ts.unescapeLeadingUnderscores(alreadyExportedSymbol.escapedName)));
+                            }
+                        }
+                    }
+                    else {
+                        ts.Debug.assert(node.kind !== 254 /* VariableDeclaration */);
+                        var importDeclaration = ts.findAncestor(node, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration));
+                        var moduleSpecifier = (_e = (importDeclaration && ((_d = ts.tryGetModuleSpecifierFromDeclaration(importDeclaration)) === null || _d === void 0 ? void 0 : _d.text))) !== null && _e !== void 0 ? _e : "...";
+                        var importedIdentifier = ts.unescapeLeadingUnderscores(ts.isIdentifier(errorNode) ? errorNode.escapedText : symbol.escapedName);
+                        error(errorNode, ts.Diagnostics._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation, importedIdentifier, "import(\"" + moduleSpecifier + "\")." + importedIdentifier);
+                    }
+                    return;
+                }
                 var excludedMeanings = (symbol.flags & (111551 /* Value */ | 1048576 /* ExportValue */) ? 111551 /* Value */ : 0) |
                     (symbol.flags & 788968 /* Type */ ? 788968 /* Type */ : 0) |
                     (symbol.flags & 1920 /* Namespace */ ? 1920 /* Namespace */ : 0);
@@ -131295,32 +131350,41 @@ var ts;
             || ts.startsWith(getCanonicalFileName(fromPath), toNodeModulesParent)
             || (!!globalCachePath && ts.startsWith(getCanonicalFileName(globalCachePath), toNodeModulesParent));
     }
-    function forEachExternalModuleToImportFrom(program, host, useAutoImportProvider, cb) {
+    function forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, cb) {
         var _a, _b;
-        forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), function (module, file) { return cb(module, file, program, /*isFromPackageJson*/ false); });
+        var useCaseSensitiveFileNames = ts.hostUsesCaseSensitiveFileNames(host);
+        var excludePatterns = preferences.autoImportFileExcludePatterns && ts.mapDefined(preferences.autoImportFileExcludePatterns, function (spec) {
+            // The client is expected to send rooted path specs since we don't know
+            // what directory a relative path is relative to.
+            var pattern = ts.getPatternFromSpec(spec, "", "exclude");
+            return pattern ? ts.getRegexFromPattern(pattern, useCaseSensitiveFileNames) : undefined;
+        });
+        forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), excludePatterns, function (module, file) { return cb(module, file, program, /*isFromPackageJson*/ false); });
         var autoImportProvider = useAutoImportProvider && ((_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host));
         if (autoImportProvider) {
             var start = ts.timestamp();
-            forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), function (module, file) { return cb(module, file, autoImportProvider, /*isFromPackageJson*/ true); });
+            forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, function (module, file) { return cb(module, file, autoImportProvider, /*isFromPackageJson*/ true); });
             (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, "forEachExternalModuleToImportFrom autoImportProvider: " + (ts.timestamp() - start));
         }
     }
     ts.forEachExternalModuleToImportFrom = forEachExternalModuleToImportFrom;
-    function forEachExternalModule(checker, allSourceFiles, cb) {
-        for (var _i = 0, _a = checker.getAmbientModules(); _i < _a.length; _i++) {
-            var ambient = _a[_i];
-            if (!ts.stringContains(ambient.name, "*")) {
+    function forEachExternalModule(checker, allSourceFiles, excludePatterns, cb) {
+        var _a;
+        var isExcluded = function (fileName) { return excludePatterns === null || excludePatterns === void 0 ? void 0 : excludePatterns.some(function (p) { return p.test(fileName); }); };
+        for (var _i = 0, _b = checker.getAmbientModules(); _i < _b.length; _i++) {
+            var ambient = _b[_i];
+            if (!ts.stringContains(ambient.name, "*") && !(excludePatterns && ((_a = ambient.declarations) === null || _a === void 0 ? void 0 : _a.every(function (d) { return isExcluded(d.getSourceFile().fileName); })))) {
                 cb(ambient, /*sourceFile*/ undefined);
             }
         }
-        for (var _b = 0, allSourceFiles_1 = allSourceFiles; _b < allSourceFiles_1.length; _b++) {
-            var sourceFile = allSourceFiles_1[_b];
-            if (ts.isExternalOrCommonJsModule(sourceFile)) {
+        for (var _c = 0, allSourceFiles_1 = allSourceFiles; _c < allSourceFiles_1.length; _c++) {
+            var sourceFile = allSourceFiles_1[_c];
+            if (ts.isExternalOrCommonJsModule(sourceFile) && !isExcluded(sourceFile.fileName)) {
                 cb(checker.getMergedSymbol(sourceFile.symbol), sourceFile);
             }
         }
     }
-    function getExportInfoMap(importingFile, host, program, cancellationToken) {
+    function getExportInfoMap(importingFile, host, program, preferences, cancellationToken) {
         var _a, _b, _c, _d, _e;
         var start = ts.timestamp();
         // Pulling the AutoImportProvider project will trigger its updateGraph if pending,
@@ -131340,7 +131404,7 @@ var ts;
         var compilerOptions = program.getCompilerOptions();
         var moduleCount = 0;
         try {
-            forEachExternalModuleToImportFrom(program, host, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
+            forEachExternalModuleToImportFrom(program, host, preferences, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
                 if (++moduleCount % 100 === 0)
                     cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancellationRequested();
                 var seenExports = new ts.Map();
@@ -133736,7 +133800,7 @@ var ts;
             if (!previousResponse)
                 return undefined;
             var lowerCaseTokenText = location.text.toLowerCase();
-            var exportMap = ts.getExportInfoMap(file, host, program, cancellationToken);
+            var exportMap = ts.getExportInfoMap(file, host, program, preferences, cancellationToken);
             var newEntries = resolvingModuleSpecifiers("continuePreviousIncompleteResponse", host, ts.codefix.createImportSpecifierResolver(file, program, host, preferences), program, location.getStart(), preferences, 
             /*isForImportStatementCompletion*/ false, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
                 var entries = ts.mapDefined(previousResponse.entries, function (entry) {
@@ -135548,7 +135612,7 @@ var ts;
                     previousToken && ts.isIdentifier(previousToken) ? previousToken.text.toLowerCase() :
                         "";
                 var moduleSpecifierCache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host);
-                var exportInfo = ts.getExportInfoMap(sourceFile, host, program, cancellationToken);
+                var exportInfo = ts.getExportInfoMap(sourceFile, host, program, preferences, cancellationToken);
                 var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host);
                 var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host);
                 resolvingModuleSpecifiers("collectAutoImports", host, importSpecifierResolver || (importSpecifierResolver = ts.codefix.createImportSpecifierResolver(sourceFile, program, host, preferences)), program, position, preferences, !!importCompletionNode, ts.isValidTypeOnlyAliasUseSite(location), function (context) {
@@ -154745,7 +154809,7 @@ var ts;
             var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) {
                 return ts.createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host);
             });
-            ts.forEachExternalModuleToImportFrom(program, host, useAutoImportProvider, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
+            ts.forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, function (moduleSymbol, moduleFile, program, isFromPackageJson) {
                 var checker = program.getTypeChecker();
                 // Don't import from a re-export when looking "up" like to `./index` or `../index`.
                 if (moduleFile && moduleSymbol !== exportingModuleSymbol && ts.startsWith(importingFile.fileName, ts.getDirectoryPath(moduleFile.fileName))) {
@@ -155214,7 +155278,7 @@ var ts;
                     originalSymbolToExportInfos.add(ts.getUniqueSymbolId(exportedSymbol, checker).toString(), { symbol: exportedSymbol, moduleSymbol: moduleSymbol, moduleFileName: toFile === null || toFile === void 0 ? void 0 : toFile.fileName, exportKind: exportKind, targetFlags: ts.skipAlias(exportedSymbol, checker).flags, isFromPackageJson: isFromPackageJson });
                 }
             }
-            ts.forEachExternalModuleToImportFrom(program, host, useAutoImportProvider, function (moduleSymbol, sourceFile, program, isFromPackageJson) {
+            ts.forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, function (moduleSymbol, sourceFile, program, isFromPackageJson) {
                 var checker = program.getTypeChecker();
                 cancellationToken.throwIfCancellationRequested();
                 var compilerOptions = program.getCompilerOptions();

package/lib/typescript.d.ts

@@ -4138,6 +4138,7 @@ declare namespace ts {
         readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
         readonly includeInlayEnumMemberValueHints?: boolean;
         readonly allowRenameOfImportPath?: boolean;
+        readonly autoImportFileExcludePatterns?: string[];
     }
     /** Represents a bigint literal value without requiring bigint support */
     export interface PseudoBigInt {