typescript 4.6.0-dev.20220115 → 4.6.0-dev.20220119

package/lib/typescript.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.20220115";
+    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 */;
         }
@@ -145849,7 +145865,11 @@ var ts;
                         oldTags[i] = merged;
                     return !!merged;
                 }); });
-                var tag = ts.factory.createJSDocComment(ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n"))), ts.factory.createNodeArray(__spreadArray(__spreadArray([], oldTags, true), unmergedNewTags, true)));
+                var tags = __spreadArray(__spreadArray([], oldTags, true), unmergedNewTags, true);
+                var jsDoc = ts.singleOrUndefined(parent.jsDoc);
+                var comment = jsDoc && ts.positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && !ts.length(comments) ? undefined :
+                    ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n")));
+                var tag = ts.factory.createJSDocComment(comment, ts.factory.createNodeArray(tags));
                 var host = updateJSDocHost(parent);
                 this.insertJsdocCommentBefore(sourceFile, host, tag);
             };
@@ -146279,6 +146299,8 @@ var ts;
                 }
                 case 339 /* JSDocReturnTag */:
                     return ts.factory.createJSDocReturnTag(/*tagName*/ undefined, newTag.typeExpression, oldTag.comment);
+                case 341 /* JSDocTypeTag */:
+                    return ts.factory.createJSDocTypeTag(/*tagName*/ undefined, newTag.typeExpression, oldTag.comment);
             }
         }
         // find first non-whitespace position in the leading trivia of the node
@@ -149817,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;
@@ -149872,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;
@@ -150097,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`. */
@@ -152965,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) {
@@ -153043,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;
                     }
@@ -154742,35 +154764,34 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) {
-                var propertyDeclaration = getPropertyDeclaration(context.sourceFile, context.span.start);
-                if (!propertyDeclaration)
+                var info = getInfo(context.sourceFile, context.span.start);
+                if (!info)
                     return;
-                var result = [
-                    getActionForAddMissingUndefinedType(context, propertyDeclaration),
-                    getActionForAddMissingDefiniteAssignmentAssertion(context, propertyDeclaration)
-                ];
-                ts.append(result, getActionForAddMissingInitializer(context, propertyDeclaration));
+                var result = [];
+                ts.append(result, getActionForAddMissingUndefinedType(context, info));
+                ts.append(result, getActionForAddMissingDefiniteAssignmentAssertion(context, info));
+                ts.append(result, getActionForAddMissingInitializer(context, info));
                 return result;
             },
             fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer],
             getAllCodeActions: function (context) {
                 return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                    var propertyDeclaration = getPropertyDeclaration(diag.file, diag.start);
-                    if (!propertyDeclaration)
+                    var info = getInfo(diag.file, diag.start);
+                    if (!info)
                         return;
                     switch (context.fixId) {
                         case fixIdAddDefiniteAssignmentAssertions:
-                            addDefiniteAssignmentAssertion(changes, diag.file, propertyDeclaration);
+                            addDefiniteAssignmentAssertion(changes, diag.file, info.prop);
                             break;
                         case fixIdAddUndefinedType:
-                            addUndefinedType(changes, diag.file, propertyDeclaration);
+                            addUndefinedType(changes, diag.file, info);
                             break;
                         case fixIdAddInitializer:
                             var checker = context.program.getTypeChecker();
-                            var initializer = getInitializer(checker, propertyDeclaration);
+                            var initializer = getInitializer(checker, info.prop);
                             if (!initializer)
                                 return;
-                            addInitializer(changes, diag.file, propertyDeclaration, initializer);
+                            addInitializer(changes, diag.file, info.prop, initializer);
                             break;
                         default:
                             ts.Debug.fail(JSON.stringify(context.fixId));
@@ -154778,35 +154799,50 @@ var ts;
                 });
             },
         });
-        function getPropertyDeclaration(sourceFile, pos) {
+        function getInfo(sourceFile, pos) {
             var token = ts.getTokenAtPosition(sourceFile, pos);
-            return ts.isIdentifier(token) ? ts.cast(token.parent, ts.isPropertyDeclaration) : undefined;
+            if (ts.isIdentifier(token) && ts.isPropertyDeclaration(token.parent)) {
+                var type = ts.getEffectiveTypeAnnotationNode(token.parent);
+                if (type) {
+                    return { type: type, prop: token.parent, isJs: ts.isInJSFile(token.parent) };
+                }
+            }
+            return undefined;
         }
-        function getActionForAddMissingDefiniteAssignmentAssertion(context, propertyDeclaration) {
-            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addDefiniteAssignmentAssertion(t, context.sourceFile, propertyDeclaration); });
-            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_definite_assignment_assertion_to_property_0, propertyDeclaration.getText()], fixIdAddDefiniteAssignmentAssertions, ts.Diagnostics.Add_definite_assignment_assertions_to_all_uninitialized_properties);
+        function getActionForAddMissingDefiniteAssignmentAssertion(context, info) {
+            if (info.isJs)
+                return undefined;
+            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addDefiniteAssignmentAssertion(t, context.sourceFile, info.prop); });
+            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_definite_assignment_assertion_to_property_0, info.prop.getText()], fixIdAddDefiniteAssignmentAssertions, ts.Diagnostics.Add_definite_assignment_assertions_to_all_uninitialized_properties);
         }
         function addDefiniteAssignmentAssertion(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) {
             var property = ts.factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.decorators, propertyDeclaration.modifiers, propertyDeclaration.name, ts.factory.createToken(53 /* ExclamationToken */), propertyDeclaration.type, propertyDeclaration.initializer);
             changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property);
         }
-        function getActionForAddMissingUndefinedType(context, propertyDeclaration) {
-            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addUndefinedType(t, context.sourceFile, propertyDeclaration); });
-            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_undefined_type_to_property_0, propertyDeclaration.name.getText()], fixIdAddUndefinedType, ts.Diagnostics.Add_undefined_type_to_all_uninitialized_properties);
+        function getActionForAddMissingUndefinedType(context, info) {
+            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addUndefinedType(t, context.sourceFile, info); });
+            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_undefined_type_to_property_0, info.prop.name.getText()], fixIdAddUndefinedType, ts.Diagnostics.Add_undefined_type_to_all_uninitialized_properties);
         }
-        function addUndefinedType(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) {
+        function addUndefinedType(changeTracker, sourceFile, info) {
             var undefinedTypeNode = ts.factory.createKeywordTypeNode(152 /* UndefinedKeyword */);
-            var type = propertyDeclaration.type; // TODO: GH#18217
-            var types = ts.isUnionTypeNode(type) ? type.types.concat(undefinedTypeNode) : [type, undefinedTypeNode];
-            changeTracker.replaceNode(propertyDeclarationSourceFile, type, ts.factory.createUnionTypeNode(types));
+            var types = ts.isUnionTypeNode(info.type) ? info.type.types.concat(undefinedTypeNode) : [info.type, undefinedTypeNode];
+            var unionTypeNode = ts.factory.createUnionTypeNode(types);
+            if (info.isJs) {
+                changeTracker.addJSDocTags(sourceFile, info.prop, [ts.factory.createJSDocTypeTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(unionTypeNode))]);
+            }
+            else {
+                changeTracker.replaceNode(sourceFile, info.type, unionTypeNode);
+            }
         }
-        function getActionForAddMissingInitializer(context, propertyDeclaration) {
+        function getActionForAddMissingInitializer(context, info) {
+            if (info.isJs)
+                return undefined;
             var checker = context.program.getTypeChecker();
-            var initializer = getInitializer(checker, propertyDeclaration);
+            var initializer = getInitializer(checker, info.prop);
             if (!initializer)
                 return undefined;
-            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addInitializer(t, context.sourceFile, propertyDeclaration, initializer); });
-            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_initializer_to_property_0, propertyDeclaration.name.getText()], fixIdAddInitializer, ts.Diagnostics.Add_initializers_to_all_uninitialized_properties);
+            var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addInitializer(t, context.sourceFile, info.prop, initializer); });
+            return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_initializer_to_property_0, info.prop.name.getText()], fixIdAddInitializer, ts.Diagnostics.Add_initializers_to_all_uninitialized_properties);
         }
         function addInitializer(changeTracker, propertyDeclarationSourceFile, propertyDeclaration, initializer) {
             var property = ts.factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.decorators, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer);
@@ -161308,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,

package/lib/typescriptServices.d.ts

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