typescript 4.8.0-dev.20220724 → 4.8.0-dev.20220727

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.20220724";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8762,6 +8762,7 @@ var ts;
         Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, ts.DiagnosticCategory.Message, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."),
         auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules."),
         An_instantiation_expression_cannot_be_followed_by_a_property_access: diag(1477, ts.DiagnosticCategory.Error, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."),
+        Identifier_or_string_literal_expected: diag(1478, ts.DiagnosticCategory.Error, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
@@ -33501,7 +33502,9 @@ var ts;
                 case 23 /* ImportOrExportSpecifiers */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 13 /* JsxAttributes */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 14 /* JsxChildren */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
-                default: return [undefined]; // TODO: GH#18217 `default: Debug.assertNever(context);`
+                case 24 /* AssertEntries */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_or_string_literal_expected); // AssertionKey.
+                case 25 /* Count */: return ts.Debug.fail("ParsingContext.Count used as a context"); // Not a real context, only a marker.
+                default: ts.Debug.assertNever(context);
             }
         }
         function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
@@ -33942,7 +33945,7 @@ var ts;
             // FormalParameter [Yield,Await]:
             //      BindingElement[?Yield,?Await]
             // Decorators are parsed in the outer [Await] context, the rest of the parameter is parsed in the function's [Await] context.
-            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : parseDecorators();
+            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators);
             if (token() === 108 /* ThisKeyword */) {
                 var node_1 = factory.createParameterDeclaration(decorators, 
                 /*dotDotDotToken*/ undefined, createIdentifier(/*isIdentifier*/ true), 
@@ -68133,37 +68136,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) {
@@ -72137,8 +72136,12 @@ var ts;
                     var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
                     var matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
                     // For each constituent t in the current type, if t and and c are directly related, pick the most
-                    // specific of the two.
-                    var directlyRelated = mapType(matching || type, function (t) { return isRelated(t, c) ? t : isRelated(c, t) ? c : neverType; });
+                    // specific of the two. When t and c are related in both directions, we prefer c for type predicates
+                    // because that is the asserted type, but t for `instanceof` because generics aren't reflected in
+                    // prototype object types.
+                    var directlyRelated = mapType(matching || type, checkDerived ?
+                        function (t) { return isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType; } :
+                        function (t) { return isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType; });
                     // If no constituents are directly related, create intersections for any generic constituents that
                     // are related by constraint.
                     return directlyRelated.flags & 131072 /* Never */ ?
@@ -90757,7 +90760,7 @@ var ts;
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                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));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, tokenVisitor, 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));
@@ -155997,8 +156000,7 @@ var ts;
                     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)) {
+                            if (ts.addToSeen(seen, ts.getNodeId(info.declaration))) {
                                 return addMissingConstraint(changes, program, preferences, host, diag.file, info);
                             }
                         }
@@ -159966,21 +159968,16 @@ var ts;
             var names = ts.map(args, function (arg) {
                 return ts.isIdentifier(arg) ? arg.text : ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.name) ? arg.name.text : undefined;
             });
-            var types = isJs ? [] : ts.map(args, function (arg) {
-                return typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker);
-            });
+            var instanceTypes = isJs ? [] : ts.map(args, function (arg) { return checker.getTypeAtLocation(arg); });
+            var _a = getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, /*flags*/ undefined, tracker), argumentTypeNodes = _a.argumentTypeNodes, argumentTypeParameters = _a.argumentTypeParameters;
             var modifiers = modifierFlags
                 ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags))
                 : undefined;
             var asteriskToken = ts.isYieldExpression(parent)
                 ? ts.factory.createToken(41 /* AsteriskToken */)
                 : undefined;
-            var typeParameters = isJs || typeArguments === undefined
-                ? undefined
-                : ts.map(typeArguments, function (_, i) {
-                    return ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, 84 /* T */ + typeArguments.length - 1 <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + i) : "T" + i);
-                });
-            var parameters = createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, isJs);
+            var typeParameters = isJs ? undefined : createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments);
+            var parameters = createDummyParameters(args.length, names, argumentTypeNodes, /*minArgumentCount*/ undefined, isJs);
             var type = isJs || contextualType === undefined
                 ? undefined
                 : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
@@ -159998,6 +159995,23 @@ var ts;
             }
         }
         codefix.createSignatureDeclarationFromCallExpression = createSignatureDeclarationFromCallExpression;
+        function createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments) {
+            var usedNames = new ts.Set(argumentTypeParameters.map(function (pair) { return pair[0]; }));
+            var constraintsByName = new ts.Map(argumentTypeParameters);
+            if (typeArguments) {
+                var typeArgumentsWithNewTypes = typeArguments.filter(function (typeArgument) { return !argumentTypeParameters.some(function (pair) { var _a; return checker.getTypeAtLocation(typeArgument) === ((_a = pair[1]) === null || _a === void 0 ? void 0 : _a.argumentType); }); });
+                var targetSize = usedNames.size + typeArgumentsWithNewTypes.length;
+                for (var i = 0; usedNames.size < targetSize; i += 1) {
+                    usedNames.add(createTypeParameterName(i));
+                }
+            }
+            return ts.map(ts.arrayFrom(usedNames.values()), function (usedName) { var _a; return ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, usedName, (_a = constraintsByName.get(usedName)) === null || _a === void 0 ? void 0 : _a.constraint); });
+        }
+        function createTypeParameterName(index) {
+            return 84 /* T */ + index <= 90 /* Z */
+                ? String.fromCharCode(84 /* T */ + index)
+                : "T" + index;
+        }
         function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
             var typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
             if (typeNode && ts.isImportTypeNode(typeNode)) {
@@ -160011,15 +160025,107 @@ var ts;
             return ts.getSynthesizedDeepClone(typeNode);
         }
         codefix.typeToAutoImportableTypeNode = typeToAutoImportableTypeNode;
+        function typeContainsTypeParameter(type) {
+            if (type.isUnionOrIntersection()) {
+                return type.types.some(typeContainsTypeParameter);
+            }
+            return type.flags & 262144 /* TypeParameter */;
+        }
+        function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) {
+            // Types to be used as the types of the parameters in the new function
+            // E.g. from this source:
+            //   added("", 0)
+            // The value will look like:
+            //   [{ typeName: { text: "string" } }, { typeName: { text: "number" }]
+            // And in the output function will generate:
+            //   function added(a: string, b: number) { ... }
+            var argumentTypeNodes = [];
+            // Names of type parameters provided as arguments to the call
+            // E.g. from this source:
+            //   added<T, U>(value);
+            // The value will look like:
+            //   [
+            //     ["T", { argumentType: { typeName: { text: "T" } } } ],
+            //     ["U", { argumentType: { typeName: { text: "U" } } } ],
+            //   ]
+            // And in the output function will generate:
+            //   function added<T, U>() { ... }
+            var argumentTypeParameters = new ts.Map();
+            for (var i = 0; i < instanceTypes.length; i += 1) {
+                var instanceType = instanceTypes[i];
+                // If the instance type contains a deep reference to an existing type parameter,
+                // instead of copying the full union or intersection, create a new type parameter
+                // E.g. from this source:
+                //   function existing<T, U>(value: T | U & string) {
+                //     added/*1*/(value);
+                // We don't want to output this:
+                //    function added<T>(value: T | U & string) { ... }
+                // We instead want to output:
+                //    function added<T>(value: T) { ... }
+                if (instanceType.isUnionOrIntersection() && instanceType.types.some(typeContainsTypeParameter)) {
+                    var synthesizedTypeParameterName = createTypeParameterName(i);
+                    argumentTypeNodes.push(ts.factory.createTypeReferenceNode(synthesizedTypeParameterName));
+                    argumentTypeParameters.set(synthesizedTypeParameterName, undefined);
+                    continue;
+                }
+                // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {"
+                var widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType);
+                var argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker);
+                if (!argumentTypeNode) {
+                    continue;
+                }
+                argumentTypeNodes.push(argumentTypeNode);
+                var argumentTypeParameter = getFirstTypeParameterName(instanceType);
+                // If the instance type is a type parameter with a constraint (other than an anonymous object),
+                // remember that constraint for when we create the new type parameter
+                // E.g. from this source:
+                //   function existing<T extends string>(value: T) {
+                //     added/*1*/(value);
+                // We don't want to output this:
+                //    function added<T>(value: T) { ... }
+                // We instead want to output:
+                //    function added<T extends string>(value: T) { ... }
+                var instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint)
+                    ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker)
+                    : undefined;
+                if (argumentTypeParameter) {
+                    argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint });
+                }
+            }
+            return { argumentTypeNodes: argumentTypeNodes, argumentTypeParameters: ts.arrayFrom(argumentTypeParameters.entries()) };
+        }
+        codefix.getArgumentTypesAndTypeParameters = getArgumentTypesAndTypeParameters;
+        function isAnonymousObjectConstraintType(type) {
+            return (type.flags & 524288 /* Object */) && type.objectFlags === 16 /* Anonymous */;
+        }
+        function getFirstTypeParameterName(type) {
+            var _a;
+            if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
+                for (var _i = 0, _b = type.types; _i < _b.length; _i++) {
+                    var subType = _b[_i];
+                    var subTypeName = getFirstTypeParameterName(subType);
+                    if (subTypeName) {
+                        return subTypeName;
+                    }
+                }
+            }
+            return type.flags & 262144 /* TypeParameter */
+                ? (_a = type.getSymbol()) === null || _a === void 0 ? void 0 : _a.getName()
+                : undefined;
+        }
         function createDummyParameters(argCount, names, types, minArgumentCount, inJs) {
             var parameters = [];
+            var parameterNameCounts = new ts.Map();
             for (var i = 0; i < argCount; i++) {
+                var parameterName = (names === null || names === void 0 ? void 0 : names[i]) || "arg" + i;
+                var parameterNameCount = parameterNameCounts.get(parameterName);
+                parameterNameCounts.set(parameterName, (parameterNameCount || 0) + 1);
                 var newParameter = ts.factory.createParameterDeclaration(
                 /*modifiers*/ undefined, 
                 /*dotDotDotToken*/ undefined, 
-                /*name*/ names && names[i] || "arg" + i, 
+                /*name*/ parameterName + (parameterNameCount || ""), 
                 /*questionToken*/ minArgumentCount !== undefined && i >= minArgumentCount ? ts.factory.createToken(57 /* QuestionToken */) : undefined, 
-                /*type*/ inJs ? undefined : types && types[i] || ts.factory.createKeywordTypeNode(155 /* UnknownKeyword */), 
+                /*type*/ inJs ? undefined : (types === null || types === void 0 ? void 0 : types[i]) || ts.factory.createKeywordTypeNode(155 /* UnknownKeyword */), 
                 /*initializer*/ undefined);
                 parameters.push(newParameter);
             }

package/lib/typescriptServices.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.20220724";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8762,6 +8762,7 @@ var ts;
         Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, ts.DiagnosticCategory.Message, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."),
         auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules."),
         An_instantiation_expression_cannot_be_followed_by_a_property_access: diag(1477, ts.DiagnosticCategory.Error, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."),
+        Identifier_or_string_literal_expected: diag(1478, ts.DiagnosticCategory.Error, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."),
         The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
         The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
         Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
@@ -33501,7 +33502,9 @@ var ts;
                 case 23 /* ImportOrExportSpecifiers */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 13 /* JsxAttributes */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 14 /* JsxChildren */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
-                default: return [undefined]; // TODO: GH#18217 `default: Debug.assertNever(context);`
+                case 24 /* AssertEntries */: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_or_string_literal_expected); // AssertionKey.
+                case 25 /* Count */: return ts.Debug.fail("ParsingContext.Count used as a context"); // Not a real context, only a marker.
+                default: ts.Debug.assertNever(context);
             }
         }
         function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
@@ -33942,7 +33945,7 @@ var ts;
             // FormalParameter [Yield,Await]:
             //      BindingElement[?Yield,?Await]
             // Decorators are parsed in the outer [Await] context, the rest of the parameter is parsed in the function's [Await] context.
-            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : parseDecorators();
+            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators);
             if (token() === 108 /* ThisKeyword */) {
                 var node_1 = factory.createParameterDeclaration(decorators, 
                 /*dotDotDotToken*/ undefined, createIdentifier(/*isIdentifier*/ true), 
@@ -68133,37 +68136,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) {
@@ -72137,8 +72136,12 @@ var ts;
                     var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
                     var matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
                     // For each constituent t in the current type, if t and and c are directly related, pick the most
-                    // specific of the two.
-                    var directlyRelated = mapType(matching || type, function (t) { return isRelated(t, c) ? t : isRelated(c, t) ? c : neverType; });
+                    // specific of the two. When t and c are related in both directions, we prefer c for type predicates
+                    // because that is the asserted type, but t for `instanceof` because generics aren't reflected in
+                    // prototype object types.
+                    var directlyRelated = mapType(matching || type, checkDerived ?
+                        function (t) { return isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType; } :
+                        function (t) { return isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType; });
                     // If no constituents are directly related, create intersections for any generic constituents that
                     // are related by constraint.
                     return directlyRelated.flags & 131072 /* Never */ ?
@@ -90757,7 +90760,7 @@ var ts;
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197 /* NamedTupleMember */:
                 ts.Debug.type(node);
-                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));
+                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, tokenVisitor, 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));
@@ -155997,8 +156000,7 @@ var ts;
                     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)) {
+                            if (ts.addToSeen(seen, ts.getNodeId(info.declaration))) {
                                 return addMissingConstraint(changes, program, preferences, host, diag.file, info);
                             }
                         }
@@ -159966,21 +159968,16 @@ var ts;
             var names = ts.map(args, function (arg) {
                 return ts.isIdentifier(arg) ? arg.text : ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.name) ? arg.name.text : undefined;
             });
-            var types = isJs ? [] : ts.map(args, function (arg) {
-                return typeToAutoImportableTypeNode(checker, importAdder, checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(arg)), contextNode, scriptTarget, /*flags*/ undefined, tracker);
-            });
+            var instanceTypes = isJs ? [] : ts.map(args, function (arg) { return checker.getTypeAtLocation(arg); });
+            var _a = getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, /*flags*/ undefined, tracker), argumentTypeNodes = _a.argumentTypeNodes, argumentTypeParameters = _a.argumentTypeParameters;
             var modifiers = modifierFlags
                 ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags))
                 : undefined;
             var asteriskToken = ts.isYieldExpression(parent)
                 ? ts.factory.createToken(41 /* AsteriskToken */)
                 : undefined;
-            var typeParameters = isJs || typeArguments === undefined
-                ? undefined
-                : ts.map(typeArguments, function (_, i) {
-                    return ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, 84 /* T */ + typeArguments.length - 1 <= 90 /* Z */ ? String.fromCharCode(84 /* T */ + i) : "T" + i);
-                });
-            var parameters = createDummyParameters(args.length, names, types, /*minArgumentCount*/ undefined, isJs);
+            var typeParameters = isJs ? undefined : createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments);
+            var parameters = createDummyParameters(args.length, names, argumentTypeNodes, /*minArgumentCount*/ undefined, isJs);
             var type = isJs || contextualType === undefined
                 ? undefined
                 : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker);
@@ -159998,6 +159995,23 @@ var ts;
             }
         }
         codefix.createSignatureDeclarationFromCallExpression = createSignatureDeclarationFromCallExpression;
+        function createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments) {
+            var usedNames = new ts.Set(argumentTypeParameters.map(function (pair) { return pair[0]; }));
+            var constraintsByName = new ts.Map(argumentTypeParameters);
+            if (typeArguments) {
+                var typeArgumentsWithNewTypes = typeArguments.filter(function (typeArgument) { return !argumentTypeParameters.some(function (pair) { var _a; return checker.getTypeAtLocation(typeArgument) === ((_a = pair[1]) === null || _a === void 0 ? void 0 : _a.argumentType); }); });
+                var targetSize = usedNames.size + typeArgumentsWithNewTypes.length;
+                for (var i = 0; usedNames.size < targetSize; i += 1) {
+                    usedNames.add(createTypeParameterName(i));
+                }
+            }
+            return ts.map(ts.arrayFrom(usedNames.values()), function (usedName) { var _a; return ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, usedName, (_a = constraintsByName.get(usedName)) === null || _a === void 0 ? void 0 : _a.constraint); });
+        }
+        function createTypeParameterName(index) {
+            return 84 /* T */ + index <= 90 /* Z */
+                ? String.fromCharCode(84 /* T */ + index)
+                : "T" + index;
+        }
         function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) {
             var typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker);
             if (typeNode && ts.isImportTypeNode(typeNode)) {
@@ -160011,15 +160025,107 @@ var ts;
             return ts.getSynthesizedDeepClone(typeNode);
         }
         codefix.typeToAutoImportableTypeNode = typeToAutoImportableTypeNode;
+        function typeContainsTypeParameter(type) {
+            if (type.isUnionOrIntersection()) {
+                return type.types.some(typeContainsTypeParameter);
+            }
+            return type.flags & 262144 /* TypeParameter */;
+        }
+        function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) {
+            // Types to be used as the types of the parameters in the new function
+            // E.g. from this source:
+            //   added("", 0)
+            // The value will look like:
+            //   [{ typeName: { text: "string" } }, { typeName: { text: "number" }]
+            // And in the output function will generate:
+            //   function added(a: string, b: number) { ... }
+            var argumentTypeNodes = [];
+            // Names of type parameters provided as arguments to the call
+            // E.g. from this source:
+            //   added<T, U>(value);
+            // The value will look like:
+            //   [
+            //     ["T", { argumentType: { typeName: { text: "T" } } } ],
+            //     ["U", { argumentType: { typeName: { text: "U" } } } ],
+            //   ]
+            // And in the output function will generate:
+            //   function added<T, U>() { ... }
+            var argumentTypeParameters = new ts.Map();
+            for (var i = 0; i < instanceTypes.length; i += 1) {
+                var instanceType = instanceTypes[i];
+                // If the instance type contains a deep reference to an existing type parameter,
+                // instead of copying the full union or intersection, create a new type parameter
+                // E.g. from this source:
+                //   function existing<T, U>(value: T | U & string) {
+                //     added/*1*/(value);
+                // We don't want to output this:
+                //    function added<T>(value: T | U & string) { ... }
+                // We instead want to output:
+                //    function added<T>(value: T) { ... }
+                if (instanceType.isUnionOrIntersection() && instanceType.types.some(typeContainsTypeParameter)) {
+                    var synthesizedTypeParameterName = createTypeParameterName(i);
+                    argumentTypeNodes.push(ts.factory.createTypeReferenceNode(synthesizedTypeParameterName));
+                    argumentTypeParameters.set(synthesizedTypeParameterName, undefined);
+                    continue;
+                }
+                // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {"
+                var widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType);
+                var argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker);
+                if (!argumentTypeNode) {
+                    continue;
+                }
+                argumentTypeNodes.push(argumentTypeNode);
+                var argumentTypeParameter = getFirstTypeParameterName(instanceType);
+                // If the instance type is a type parameter with a constraint (other than an anonymous object),
+                // remember that constraint for when we create the new type parameter
+                // E.g. from this source:
+                //   function existing<T extends string>(value: T) {
+                //     added/*1*/(value);
+                // We don't want to output this:
+                //    function added<T>(value: T) { ... }
+                // We instead want to output:
+                //    function added<T extends string>(value: T) { ... }
+                var instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint)
+                    ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker)
+                    : undefined;
+                if (argumentTypeParameter) {
+                    argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint });
+                }
+            }
+            return { argumentTypeNodes: argumentTypeNodes, argumentTypeParameters: ts.arrayFrom(argumentTypeParameters.entries()) };
+        }
+        codefix.getArgumentTypesAndTypeParameters = getArgumentTypesAndTypeParameters;
+        function isAnonymousObjectConstraintType(type) {
+            return (type.flags & 524288 /* Object */) && type.objectFlags === 16 /* Anonymous */;
+        }
+        function getFirstTypeParameterName(type) {
+            var _a;
+            if (type.flags & (1048576 /* Union */ | 2097152 /* Intersection */)) {
+                for (var _i = 0, _b = type.types; _i < _b.length; _i++) {
+                    var subType = _b[_i];
+                    var subTypeName = getFirstTypeParameterName(subType);
+                    if (subTypeName) {
+                        return subTypeName;
+                    }
+                }
+            }
+            return type.flags & 262144 /* TypeParameter */
+                ? (_a = type.getSymbol()) === null || _a === void 0 ? void 0 : _a.getName()
+                : undefined;
+        }
         function createDummyParameters(argCount, names, types, minArgumentCount, inJs) {
             var parameters = [];
+            var parameterNameCounts = new ts.Map();
             for (var i = 0; i < argCount; i++) {
+                var parameterName = (names === null || names === void 0 ? void 0 : names[i]) || "arg" + i;
+                var parameterNameCount = parameterNameCounts.get(parameterName);
+                parameterNameCounts.set(parameterName, (parameterNameCount || 0) + 1);
                 var newParameter = ts.factory.createParameterDeclaration(
                 /*modifiers*/ undefined, 
                 /*dotDotDotToken*/ undefined, 
-                /*name*/ names && names[i] || "arg" + i, 
+                /*name*/ parameterName + (parameterNameCount || ""), 
                 /*questionToken*/ minArgumentCount !== undefined && i >= minArgumentCount ? ts.factory.createToken(57 /* QuestionToken */) : undefined, 
-                /*type*/ inJs ? undefined : types && types[i] || ts.factory.createKeywordTypeNode(155 /* UnknownKeyword */), 
+                /*type*/ inJs ? undefined : (types === null || types === void 0 ? void 0 : types[i]) || ts.factory.createKeywordTypeNode(155 /* UnknownKeyword */), 
                 /*initializer*/ undefined);
                 parameters.push(newParameter);
             }