typescript 4.8.0-dev.20220725 → 4.8.0-dev.20220728

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.20220725";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220728";
     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) {
@@ -27226,7 +27229,7 @@ var ts;
             if (allowAmbiguity === void 0) { allowAmbiguity = true; }
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
-            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : parseDecorators();
+            var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators);
             if (token() === 108) {
                 var node_1 = factory.createParameterDeclaration(decorators, undefined, createIdentifier(true), undefined, parseTypeAnnotation(), undefined);
                 if (decorators) {
@@ -49226,7 +49229,7 @@ var ts;
                         }
                     }
                 }
-                return getIntersectionType(constraints);
+                return getNormalizedType(getIntersectionType(constraints), false);
             }
             return undefined;
         }
@@ -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;
@@ -70963,14 +70968,19 @@ var ts;
             }
             var indexInfos = getApplicableIndexInfos(type, propNameType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 ? ts.getDeclarationOfKind(type.symbol, 258) : undefined;
-            var localPropDeclaration = declaration && declaration.kind === 221 ||
-                name && name.kind === 162 || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
+            var propDeclaration = declaration && declaration.kind === 221 ||
+                name && name.kind === 162 ? declaration : undefined;
+            var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
             var _loop_30 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 var errorNode = localPropDeclaration || localIndexDeclaration ||
                     (interfaceDeclaration && !ts.some(getBaseTypes(type), function (base) { return !!getPropertyOfObjectType(base, prop.escapedName) && !!getIndexTypeOfType(base, info.keyType); }) ? interfaceDeclaration : undefined);
                 if (errorNode && !isTypeAssignableTo(propType, info.type)) {
-                    error(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
+                    var diagnostic = createError(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
+                    if (propDeclaration && errorNode !== propDeclaration) {
+                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(propDeclaration, ts.Diagnostics._0_is_declared_here, symbolToString(prop)));
+                    }
+                    diagnostics.add(diagnostic);
                 }
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
@@ -76310,7 +76320,7 @@ var ts;
                 return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
             case 197:
                 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:
                 ts.Debug.type(node);
                 return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));

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.20220725";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220728";
     /* @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) {
@@ -33757,7 +33760,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), 
@@ -59422,7 +59425,8 @@ var ts;
                         }
                     }
                 }
-                return getIntersectionType(constraints);
+                // The source types were normalized; ensure the result is normalized too.
+                return getNormalizedType(getIntersectionType(constraints), /*writing*/ false);
             }
             return undefined;
         }
@@ -71948,8 +71952,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 */ ?
@@ -84661,8 +84669,9 @@ var ts;
             }
             var indexInfos = getApplicableIndexInfos(type, propNameType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* Interface */ ? ts.getDeclarationOfKind(type.symbol, 258 /* InterfaceDeclaration */) : undefined;
-            var localPropDeclaration = declaration && declaration.kind === 221 /* BinaryExpression */ ||
-                name && name.kind === 162 /* ComputedPropertyName */ || getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
+            var propDeclaration = declaration && declaration.kind === 221 /* BinaryExpression */ ||
+                name && name.kind === 162 /* ComputedPropertyName */ ? declaration : undefined;
+            var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
             var _loop_30 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
@@ -84671,7 +84680,11 @@ var ts;
                 var errorNode = localPropDeclaration || localIndexDeclaration ||
                     (interfaceDeclaration && !ts.some(getBaseTypes(type), function (base) { return !!getPropertyOfObjectType(base, prop.escapedName) && !!getIndexTypeOfType(base, info.keyType); }) ? interfaceDeclaration : undefined);
                 if (errorNode && !isTypeAssignableTo(propType, info.type)) {
-                    error(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
+                    var diagnostic = createError(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
+                    if (propDeclaration && errorNode !== propDeclaration) {
+                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(propDeclaration, ts.Diagnostics._0_is_declared_here, symbolToString(prop)));
+                    }
+                    diagnostics.add(diagnostic);
                 }
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
@@ -90568,7 +90581,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));
@@ -118322,7 +118335,7 @@ var ts;
                     // `result[i]` is either a `ResolvedModuleFull` or a marker.
                     // If it is the former, we can leave it as is.
                     if (result[i] === predictedToResolveToAmbientModuleMarker) {
-                        result[i] = undefined; // TODO: GH#18217
+                        result[i] = undefined;
                     }
                 }
                 else {
@@ -155389,8 +155402,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 +159370,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 +159397,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 +159427,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);
             }
@@ -163543,7 +163659,7 @@ var ts;
             var usage = getUsageInfo(oldFile, toMove.all, checker);
             var currentDirectory = ts.getDirectoryPath(oldFile.fileName);
             var extension = ts.extensionFromPath(oldFile.fileName);
-            var newModuleName = makeUniqueModuleName(getNewModuleName(usage.movedSymbols), extension, currentDirectory, host);
+            var newModuleName = makeUniqueModuleName(getNewModuleName(usage.oldFileImportsFromNewFile, usage.movedSymbols), extension, currentDirectory, host);
             var newFileNameWithExtension = newModuleName + extension;
             // If previous file was global, this is easy.
             changes.createNewFile(oldFile, ts.combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences));
@@ -163907,8 +164023,8 @@ var ts;
                 newModuleName = moduleName + "." + i;
             }
         }
-        function getNewModuleName(movedSymbols) {
-            return movedSymbols.forEachEntry(ts.symbolNameNoDefault) || "newFile";
+        function getNewModuleName(importsFromNewFile, movedSymbols) {
+            return importsFromNewFile.forEachEntry(ts.symbolNameNoDefault) || movedSymbols.forEachEntry(ts.symbolNameNoDefault) || "newFile";
         }
         function getUsageInfo(oldFile, toMove, checker) {
             var movedSymbols = new SymbolSet();