typescript 4.8.0-dev.20220722 → 4.8.0-dev.20220725

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.20220722";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220725";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7051,8 +7051,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -68140,37 +68142,33 @@ var ts;
             var commonBaseType;
             for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
                 var t = types_13[_i];
-                var baseType = getBaseTypeOfLiteralType(t);
-                if (!commonBaseType) {
-                    commonBaseType = baseType;
-                }
-                if (baseType === t || baseType !== commonBaseType) {
-                    return false;
+                if (!(t.flags & 131072 /* Never */)) {
+                    var baseType = getBaseTypeOfLiteralType(t);
+                    commonBaseType !== null && commonBaseType !== void 0 ? commonBaseType : (commonBaseType = baseType);
+                    if (baseType === t || baseType !== commonBaseType) {
+                        return false;
+                    }
                 }
             }
             return true;
         }
-        // When the candidate types are all literal types with the same base type, return a union
-        // of those literal types. Otherwise, return the leftmost type for which no type to the
-        // right is a supertype.
-        function getSupertypeOrUnion(types) {
-            if (types.length === 1) {
-                return types[0];
-            }
-            return literalTypesWithSameBaseType(types) ?
-                getUnionType(types) :
-                ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+        function getCombinedTypeFlags(types) {
+            return ts.reduceLeft(types, function (flags, t) { return flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags); }, 0);
         }
         function getCommonSupertype(types) {
-            if (!strictNullChecks) {
-                return getSupertypeOrUnion(types);
-            }
-            var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            if (primaryTypes.length) {
-                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
-                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            if (types.length === 1) {
+                return types[0];
             }
-            return getUnionType(types, 2 /* Subtype */);
+            // Remove nullable types from each of the candidates.
+            var primaryTypes = strictNullChecks ? ts.sameMap(types, function (t) { return filterType(t, function (u) { return !(u.flags & 98304 /* Nullable */); }); }) : types;
+            // When the candidate types are all literal types with the same base type, return a union
+            // of those literal types. Otherwise, return the leftmost type for which no type to the
+            // right is a supertype.
+            var superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ?
+                getUnionType(primaryTypes) :
+                ts.reduceLeft(primaryTypes, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+            // Add any nullable types that occurred in the candidates back to the result.
+            return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -79832,7 +79830,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90754,13 +90756,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90825,7 +90827,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -149458,6 +149460,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149524,6 +149527,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155983,54 +155987,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */

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.20220722";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220725";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -7042,8 +7042,10 @@ var ts;
             return {
                 close: function () {
                     // Close the watcher (either existing file system entry watcher or missing file system entry watcher)
-                    watcher.close();
-                    watcher = undefined;
+                    if (watcher) {
+                        watcher.close();
+                        watcher = undefined;
+                    }
                 }
             };
             function updateWatcher(createWatcher) {
@@ -68131,37 +68133,33 @@ var ts;
             var commonBaseType;
             for (var _i = 0, types_13 = types; _i < types_13.length; _i++) {
                 var t = types_13[_i];
-                var baseType = getBaseTypeOfLiteralType(t);
-                if (!commonBaseType) {
-                    commonBaseType = baseType;
-                }
-                if (baseType === t || baseType !== commonBaseType) {
-                    return false;
+                if (!(t.flags & 131072 /* Never */)) {
+                    var baseType = getBaseTypeOfLiteralType(t);
+                    commonBaseType !== null && commonBaseType !== void 0 ? commonBaseType : (commonBaseType = baseType);
+                    if (baseType === t || baseType !== commonBaseType) {
+                        return false;
+                    }
                 }
             }
             return true;
         }
-        // When the candidate types are all literal types with the same base type, return a union
-        // of those literal types. Otherwise, return the leftmost type for which no type to the
-        // right is a supertype.
-        function getSupertypeOrUnion(types) {
-            if (types.length === 1) {
-                return types[0];
-            }
-            return literalTypesWithSameBaseType(types) ?
-                getUnionType(types) :
-                ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+        function getCombinedTypeFlags(types) {
+            return ts.reduceLeft(types, function (flags, t) { return flags | (t.flags & 1048576 /* Union */ ? getCombinedTypeFlags(t.types) : t.flags); }, 0);
         }
         function getCommonSupertype(types) {
-            if (!strictNullChecks) {
-                return getSupertypeOrUnion(types);
-            }
-            var primaryTypes = ts.filter(types, function (t) { return !(t.flags & 98304 /* Nullable */); });
-            if (primaryTypes.length) {
-                var supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
-                return primaryTypes === types ? supertypeOrUnion : getUnionType(__spreadArray([supertypeOrUnion], ts.filter(types, function (t) { return !!(t.flags & 98304 /* Nullable */); }), true));
+            if (types.length === 1) {
+                return types[0];
             }
-            return getUnionType(types, 2 /* Subtype */);
+            // Remove nullable types from each of the candidates.
+            var primaryTypes = strictNullChecks ? ts.sameMap(types, function (t) { return filterType(t, function (u) { return !(u.flags & 98304 /* Nullable */); }); }) : types;
+            // When the candidate types are all literal types with the same base type, return a union
+            // of those literal types. Otherwise, return the leftmost type for which no type to the
+            // right is a supertype.
+            var superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ?
+                getUnionType(primaryTypes) :
+                ts.reduceLeft(primaryTypes, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; });
+            // Add any nullable types that occurred in the candidates back to the result.
+            return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* Nullable */);
         }
         // Return the leftmost type for which no type to the right is a subtype.
         function getCommonSubtype(types) {
@@ -79823,7 +79821,11 @@ var ts;
                     var operator = operatorToken.kind;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
-                            var parent = ts.walkUpParenthesizedExpressions(node.parent);
+                            var parent = node.parent;
+                            while (parent.kind === 212 /* ParenthesizedExpression */
+                                || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* BarBarToken */)) {
+                                parent = parent.parent;
+                            }
                             checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
@@ -90745,13 +90747,13 @@ var ts;
                 return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
             case 200 /* ImportType */:
                 ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), visitNodes(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
             case 295 /* ImportTypeAssertionContainer */:
                 ts.Debug.type(node);
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, visitNode(node.dotDotDotToken, visitor, ts.isDotDotDotToken), visitNode(node.name, visitor, ts.isIdentifier), visitNode(node.questionToken, visitor, ts.isQuestionToken), visitNode(node.type, visitor, ts.isTypeNode));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, visitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, visitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 191 /* ParenthesizedType */:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
@@ -90816,7 +90818,7 @@ var ts;
                 return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
             case 210 /* TaggedTemplateExpression */:
                 ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), visitNodes(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
             case 211 /* TypeAssertionExpression */:
                 ts.Debug.type(node);
                 return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
@@ -149449,6 +149451,7 @@ var ts;
                     consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);
                 }
                 function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) {
+                    ts.Debug.assert(!ts.nodeIsSynthesized(child));
                     if (ts.nodeIsMissing(child)) {
                         return inheritedIndentation;
                     }
@@ -149515,6 +149518,7 @@ var ts;
                 }
                 function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) {
                     ts.Debug.assert(ts.isNodeArray(nodes));
+                    ts.Debug.assert(!ts.nodeIsSynthesized(nodes));
                     var listStartToken = getOpenTokenForList(parent, nodes);
                     var listDynamicIndentation = parentDynamicIndentation;
                     var startLine = parentStartLine;
@@ -155974,54 +155978,91 @@ var ts;
         codefix.registerCodeFix({
             errorCodes: errorCodes,
             getCodeActions: function (context) {
-                var sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
-                if (!related) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host;
+                var info = getInfo(program, sourceFile, span);
+                if (info === undefined)
                     return;
-                }
-                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); });
                 return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
             },
             fixIds: [fixId],
-            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
-                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
-                if (!info)
-                    return;
-                return addMissingConstraint(changes, info);
-            }); },
+            getAllCodeActions: function (context) {
+                var program = context.program, preferences = context.preferences, host = context.host;
+                var seen = new ts.Map();
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length));
+                        if (info) {
+                            var id = ts.getNodeId(info.declaration) + "#" + info.token.getText();
+                            if (ts.addToSeen(seen, id)) {
+                                return addMissingConstraint(changes, program, preferences, host, diag.file, info);
+                            }
+                        }
+                        return undefined;
+                    });
+                }));
+            }
         });
-        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+        function getInfo(program, sourceFile, span) {
             var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
-            if (!diag || !diag.relatedInformation)
+            if (diag === undefined || diag.relatedInformation === undefined)
                 return;
             var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
-            if (!related)
+            if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined)
                 return;
-            return related;
-        }
-        function addMissingConstraint(changes, related) {
-            var decl = findAncestorMatchingSpan(related.file, related);
-            if (!decl)
+            var declaration = findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length));
+            if (declaration === undefined)
                 return;
-            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
-                decl = decl.parent;
+            if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) {
+                declaration = declaration.parent;
+            }
+            if (ts.isTypeParameterDeclaration(declaration)) {
+                // should only issue fix on type parameters written using `extends`
+                if (ts.isMappedTypeNode(declaration.parent))
+                    return;
+                var token = ts.getTokenAtPosition(sourceFile, span.start);
+                var checker = program.getTypeChecker();
+                var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText);
+                return { constraint: constraint, declaration: declaration, token: token };
+            }
+            return undefined;
+        }
+        function addMissingConstraint(changes, program, preferences, host, sourceFile, info) {
+            var declaration = info.declaration, constraint = info.constraint;
+            var checker = program.getTypeChecker();
+            if (ts.isString(constraint)) {
+                changes.insertText(sourceFile, declaration.name.end, " extends " + constraint);
+            }
+            else {
+                var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions());
+                var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host });
+                var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host);
+                var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker);
+                if (typeNode) {
+                    changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default));
+                    importAdder.writeFixes(changes);
+                }
             }
-            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
-                return; // should only issue fix on type parameters written using `extends`
-            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
-            if (!newConstraint)
-                return;
-            var newConstraintText = newConstraint[1];
-            changes.insertText(related.file, decl.name.end, " extends " + newConstraintText);
         }
         function findAncestorMatchingSpan(sourceFile, span) {
-            var token = ts.getTokenAtPosition(sourceFile, span.start);
             var end = ts.textSpanEnd(span);
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
             while (token.end < end) {
                 token = token.parent;
             }
             return token;
         }
+        function tryGetConstraintFromDiagnosticMessage(messageText) {
+            var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1];
+            return constraint;
+        }
+        function tryGetConstraintType(checker, node) {
+            if (ts.isTypeNode(node.parent)) {
+                return checker.getTypeArgumentConstraint(node.parent);
+            }
+            var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined;
+            return contextualType || checker.getTypeAtLocation(node);
+        }
     })(codefix = ts.codefix || (ts.codefix = {}));
 })(ts || (ts = {}));
 /* @internal */