typescript 4.8.0-dev.20220726 → 4.8.0-dev.20220727

package/lib/lib.es2015.proxy.d.ts

@@ -19,23 +19,112 @@ and limitations under the License.
 
 
 interface ProxyHandler<T extends object> {
+    /**
+     * A trap method for a function call.
+     * @param target The original callable object which is being proxied.
+     */
     apply?(target: T, thisArg: any, argArray: any[]): any;
+
+    /**
+     * A trap for the `new` operator.
+     * @param target The original object which is being proxied.
+     * @param newTarget The constructor that was originally called.
+     */
     construct?(target: T, argArray: any[], newTarget: Function): object;
-    defineProperty?(target: T, p: string | symbol, attributes: PropertyDescriptor): boolean;
+
+    /**
+     * A trap for `Object.defineProperty()`.
+     * @param target The original object which is being proxied.
+     * @returns A `Boolean` indicating whether or not the property has been defined.
+     */
+    defineProperty?(target: T, property: string | symbol, attributes: PropertyDescriptor): boolean;
+
+    /**
+     * A trap for the `delete` operator.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to delete.
+     * @returns A `Boolean` indicating whether or not the property was deleted.
+     */
     deleteProperty?(target: T, p: string | symbol): boolean;
+
+    /**
+     * A trap for getting a property value.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to get.
+     * @param receiver The proxy or an object that inherits from the proxy.
+     */
     get?(target: T, p: string | symbol, receiver: any): any;
+
+    /**
+     * A trap for `Object.getOwnPropertyDescriptor()`.
+     * @param target The original object which is being proxied.
+     * @param p The name of the property whose description should be retrieved.
+     */
     getOwnPropertyDescriptor?(target: T, p: string | symbol): PropertyDescriptor | undefined;
+
+    /**
+     * A trap for the `[[GetPrototypeOf]]` internal method.
+     * @param target The original object which is being proxied.
+     */
     getPrototypeOf?(target: T): object | null;
+
+    /**
+     * A trap for the `in` operator.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to check for existence.
+     */
     has?(target: T, p: string | symbol): boolean;
+
+    /**
+     * A trap for `Object.isExtensible()`.
+     * @param target The original object which is being proxied.
+     */
     isExtensible?(target: T): boolean;
+
+    /**
+     * A trap for `Reflect.ownKeys()`.
+     * @param target The original object which is being proxied.
+     */
     ownKeys?(target: T): ArrayLike<string | symbol>;
+
+    /**
+     * A trap for `Object.preventExtensions()`.
+     * @param target The original object which is being proxied.
+     */
     preventExtensions?(target: T): boolean;
-    set?(target: T, p: string | symbol, value: any, receiver: any): boolean;
+
+    /**
+     * A trap for setting a property value.
+     * @param target The original object which is being proxied.
+     * @param p The name or `Symbol` of the property to set.
+     * @param receiver The object to which the assignment was originally directed.
+     * @returns `A `Boolean` indicating whether or not the property was set.
+     */
+    set?(target: T, p: string | symbol, newValue: any, receiver: any): boolean;
+
+    /**
+     * A trap for `Object.setPrototypeOf()`.
+     * @param target The original object which is being proxied.
+     * @param newPrototype The object's new prototype or `null`.
+     */
     setPrototypeOf?(target: T, v: object | null): boolean;
 }
 
 interface ProxyConstructor {
+    /**
+     * Creates a revocable Proxy object.
+     * @param target A target object to wrap with Proxy.
+     * @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
+     */
     revocable<T extends object>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
+
+    /**
+     * Creates a Proxy object. The Proxy object allows you to create an object that can be used in place of the
+     * original object, but which may redefine fundamental Object operations like getting, setting, and defining
+     * properties. Proxy objects are commonly used to log property accesses, validate, format, or sanitize inputs.
+     * @param target A target object to wrap with Proxy.
+     * @param handler An object whose properties define the behavior of Proxy when an operation is attempted on it.
+     */
     new <T extends object>(target: T, handler: ProxyHandler<T>): T;
 }
 declare var Proxy: ProxyConstructor;

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-dev.20220726";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -5731,6 +5731,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.", undefined, true),
@@ -26880,7 +26881,9 @@ var ts;
                 case 23: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 13: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
                 case 14: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_expected);
-                default: return [undefined];
+                case 24: return parseErrorAtCurrentToken(ts.Diagnostics.Identifier_or_string_literal_expected);
+                case 25: return ts.Debug.fail("ParsingContext.Count used as a context");
+                default: ts.Debug.assertNever(context);
             }
         }
         function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
@@ -60178,7 +60181,9 @@ var ts;
                 var narrowedType = mapType(candidate, function (c) {
                     var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
                     var matching = discriminant && getConstituentTypeForKeyType(type, discriminant);
-                    var directlyRelated = mapType(matching || type, function (t) { return isRelated(t, c) ? t : isRelated(c, t) ? c : neverType; });
+                    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; });
                     return directlyRelated.flags & 131072 ?
                         mapType(type, function (t) { return maybeTypeOfKind(t, 465829888) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType; }) :
                         directlyRelated;

package/lib/tsserver.js

@@ -109,7 +109,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.20220726";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8577,6 +8577,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),
@@ -33316,7 +33317,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) {
@@ -71948,8 +71951,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 */ ?
@@ -155389,8 +155396,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);
                             }
                         }
@@ -159358,21 +159364,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);
@@ -159390,6 +159391,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)) {
@@ -159403,15 +159421,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/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.20220726";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8771,6 +8771,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),
@@ -33510,7 +33511,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) {
@@ -72142,8 +72145,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 */ ?
@@ -156002,8 +156009,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);
                             }
                         }
@@ -159971,21 +159977,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);
@@ -160003,6 +160004,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)) {
@@ -160016,15 +160034,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/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.20220726";
+    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) {
@@ -72133,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 */ ?
@@ -155993,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);
                             }
                         }
@@ -159962,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);
@@ -159994,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)) {
@@ -160007,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.20220726";
+    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) {
@@ -72133,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 */ ?
@@ -155993,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);
                             }
                         }
@@ -159962,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);
@@ -159994,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)) {
@@ -160007,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/typingsInstaller.js

@@ -89,7 +89,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.20220726";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220727";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8557,6 +8557,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),
@@ -33296,7 +33297,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) {
@@ -71928,8 +71931,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 */ ?

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.8.0-dev.20220726",
+    "version": "4.8.0-dev.20220727",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [