typescript 4.8.0-dev.20220706 → 4.8.0-dev.20220709

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.20220706";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220709";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2045,7 +2045,7 @@ var ts;
      *         and 1 insertion/deletion at 3 characters)
      */
     function getSpellingSuggestion(name, candidates, getName) {
-        var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34));
+        var maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34));
         var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother.
         var bestCandidate;
         for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
@@ -2774,6 +2774,22 @@ var ts;
             return formatEnum(flags, ts.FlowFlags, /*isFlags*/ true);
         }
         Debug.formatFlowFlags = formatFlowFlags;
+        function formatRelationComparisonResult(result) {
+            return formatEnum(result, ts.RelationComparisonResult, /*isFlags*/ true);
+        }
+        Debug.formatRelationComparisonResult = formatRelationComparisonResult;
+        function formatCheckMode(mode) {
+            return formatEnum(mode, ts.CheckMode, /*isFlags*/ true);
+        }
+        Debug.formatCheckMode = formatCheckMode;
+        function formatSignatureCheckMode(mode) {
+            return formatEnum(mode, ts.SignatureCheckMode, /*isFlags*/ true);
+        }
+        Debug.formatSignatureCheckMode = formatSignatureCheckMode;
+        function formatTypeFacts(facts) {
+            return formatEnum(facts, ts.TypeFacts, /*isFlags*/ true);
+        }
+        Debug.formatTypeFacts = formatTypeFacts;
         var isDebugInfoEnabled = false;
         var extendedDebugModule;
         function extendedDebug() {
@@ -9013,6 +9029,7 @@ var ts;
         The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, ts.DiagnosticCategory.Error, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
         _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
         We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
+        Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, ts.DiagnosticCategory.Error, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -19511,7 +19528,8 @@ var ts;
     function getDeclarationModifierFlagsFromSymbol(s, isWrite) {
         if (isWrite === void 0) { isWrite = false; }
         if (s.valueDeclaration) {
-            var declaration = (isWrite && s.declarations && ts.find(s.declarations, function (d) { return d.kind === 173 /* SetAccessor */; })) || s.valueDeclaration;
+            var declaration = (isWrite && s.declarations && ts.find(s.declarations, ts.isSetAccessorDeclaration))
+                || (s.flags & 32768 /* GetAccessor */ && ts.find(s.declarations, ts.isGetAccessorDeclaration)) || s.valueDeclaration;
             var flags = ts.getCombinedModifierFlags(declaration);
             return s.parent && s.parent.flags & 32 /* Class */ ? flags : flags & ~28 /* AccessibilityModifier */;
         }
@@ -20186,7 +20204,7 @@ var ts;
         // Excludes declaration files - they still require an explicit `export {}` or the like
         // for back compat purposes. The only non-declaration files _not_ forced to be a module are `.js` files
         // that aren't esm-mode (meaning not in a `type: module` scope).
-        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */]))) && !file.isDeclarationFile ? true : undefined;
+        return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Cjs */, ".cts" /* Cts */, ".mjs" /* Mjs */, ".mts" /* Mts */]))) && !file.isDeclarationFile ? true : undefined;
     }
     function getSetExternalModuleIndicator(options) {
         // TODO: Should this callback be cached?
@@ -20209,10 +20227,7 @@ var ts;
                 if (options.jsx === 4 /* ReactJSX */ || options.jsx === 5 /* ReactJSXDev */) {
                     checks.push(isFileModuleFromUsingJSXTag);
                 }
-                var moduleKind = getEmitModuleKind(options);
-                if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) {
-                    checks.push(isFileForcedToBeModuleByFormat);
-                }
+                checks.push(isFileForcedToBeModuleByFormat);
                 var combined_1 = ts.or.apply(void 0, checks);
                 var callback = function (file) { return void (file.externalModuleIndicator = combined_1(file)); };
                 return callback;
@@ -33932,10 +33947,10 @@ var ts;
             var hasJSDoc = hasPrecedingJSDocComment();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 172 /* GetAccessor */, 4 /* Type */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 173 /* SetAccessor */, 4 /* Type */);
             }
             if (isIndexSignature()) {
                 return parseIndexSignatureDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers);
@@ -35981,10 +35996,10 @@ var ts;
             var decorators = parseDecorators();
             var modifiers = parseModifiers();
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             var asteriskToken = parseOptionalToken(41 /* AsteriskToken */);
             var tokenIsIdentifier = isIdentifier();
@@ -36676,9 +36691,15 @@ var ts;
             return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10 /* StringLiteral */);
         }
         function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) {
-            if (token() !== 18 /* OpenBraceToken */ && canParseSemicolon()) {
-                parseSemicolon();
-                return;
+            if (token() !== 18 /* OpenBraceToken */) {
+                if (flags & 4 /* Type */) {
+                    parseTypeMemberSemicolon();
+                    return;
+                }
+                if (canParseSemicolon()) {
+                    parseSemicolon();
+                    return;
+                }
             }
             return parseFunctionBlock(flags, diagnosticMessage);
         }
@@ -36882,12 +36903,12 @@ var ts;
             }
             return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken);
         }
-        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind) {
+        function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) {
             var name = parsePropertyName();
             var typeParameters = parseTypeParameters();
             var parameters = parseParameters(0 /* None */);
             var type = parseReturnType(58 /* ColonToken */, /*isType*/ false);
-            var body = parseFunctionBlockOrSemicolon(0 /* None */);
+            var body = parseFunctionBlockOrSemicolon(flags);
             var node = kind === 172 /* GetAccessor */
                 ? factory.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body)
                 : factory.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body);
@@ -37074,10 +37095,10 @@ var ts;
                 return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers);
             }
             if (parseContextualModifier(136 /* GetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 172 /* GetAccessor */, 0 /* None */);
             }
             if (parseContextualModifier(149 /* SetKeyword */)) {
-                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */);
+                return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 173 /* SetAccessor */, 0 /* None */);
             }
             if (token() === 134 /* ConstructorKeyword */ || token() === 10 /* StringLiteral */) {
                 var constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers);
@@ -44388,6 +44409,7 @@ var ts;
         return toSearchResult(/*value*/ undefined);
     }
     /**
+     * @internal
      * From https://github.com/nodejs/node/blob/8f39f51cbbd3b2de14b9ee896e26421cc5b20121/lib/internal/modules/esm/resolve.js#L722 -
      * "longest" has some nuance as to what "longest" means in the presence of pattern trailers
      */
@@ -44410,6 +44432,7 @@ var ts;
             return 1;
         return 0;
     }
+    ts.comparePatternKeys = comparePatternKeys;
     function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) {
         var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports);
         if (!ts.endsWith(moduleName, ts.directorySeparator) && moduleName.indexOf("*") === -1 && ts.hasProperty(lookupTable, moduleName)) {
@@ -48481,7 +48504,7 @@ var ts;
         // Masks
         TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask";
         TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask";
-    })(TypeFacts || (TypeFacts = {}));
+    })(TypeFacts = ts.TypeFacts || (ts.TypeFacts = {}));
     var typeofNEFacts = new ts.Map(ts.getEntries({
         string: 256 /* TypeofNEString */,
         number: 512 /* TypeofNENumber */,
@@ -48516,7 +48539,7 @@ var ts;
         CheckMode[CheckMode["RestBindingElement"] = 64] = "RestBindingElement";
         //   e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`,
         //   we need to preserve generic types instead of substituting them for constraints
-    })(CheckMode || (CheckMode = {}));
+    })(CheckMode = ts.CheckMode || (ts.CheckMode = {}));
     var SignatureCheckMode;
     (function (SignatureCheckMode) {
         SignatureCheckMode[SignatureCheckMode["BivariantCallback"] = 1] = "BivariantCallback";
@@ -48524,7 +48547,7 @@ var ts;
         SignatureCheckMode[SignatureCheckMode["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes";
         SignatureCheckMode[SignatureCheckMode["StrictArity"] = 8] = "StrictArity";
         SignatureCheckMode[SignatureCheckMode["Callback"] = 3] = "Callback";
-    })(SignatureCheckMode || (SignatureCheckMode = {}));
+    })(SignatureCheckMode = ts.SignatureCheckMode || (ts.SignatureCheckMode = {}));
     var IntersectionState;
     (function (IntersectionState) {
         IntersectionState[IntersectionState["None"] = 0] = "None";
@@ -48876,7 +48899,7 @@ var ts;
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
-                return node ? getContextualTypeForObjectLiteralElement(node) : undefined;
+                return node ? getContextualTypeForObjectLiteralElement(node, /*contextFlags*/ undefined) : undefined;
             },
             getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -48884,7 +48907,7 @@ var ts;
             },
             getContextualTypeForJsxAttribute: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike);
-                return node && getContextualTypeForJsxAttribute(node);
+                return node && getContextualTypeForJsxAttribute(node, /*contextFlags*/ undefined);
             },
             isContextSensitive: isContextSensitive,
             getTypeOfPropertyOfContextualType: getTypeOfPropertyOfContextualType,
@@ -50216,6 +50239,7 @@ var ts;
                             if (ctor && ctor.locals) {
                                 if (lookup(ctor.locals, name, meaning & 111551 /* Value */)) {
                                     // Remember the property node, it will be used later to report appropriate error
+                                    ts.Debug.assertNode(location, ts.isPropertyDeclaration);
                                     propertyWithInvalidInitializer = location;
                                 }
                             }
@@ -50405,11 +50429,27 @@ var ts;
                     }
                 }
             }
+            // The invalid initializer error is needed in two situation:
+            // 1. When result is undefined, after checking for a missing "this."
+            // 2. When result is defined
+            function checkAndReportErrorForInvalidInitializer() {
+                if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
+                    // We have a match, but the reference occurred within a property initializer and the identifier also binds
+                    // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
+                    // with ESNext+useDefineForClassFields because the scope semantics are different.
+                    error(errorLocation, errorLocation && propertyWithInvalidInitializer.type && ts.textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos)
+                        ? ts.Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor
+                        : ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyWithInvalidInitializer.name), diagnosticName(nameArg));
+                    return true;
+                }
+                return false;
+            }
             if (!result) {
                 if (nameNotFoundMessage) {
                     addLazyDiagnostic(function () {
                         if (!errorLocation ||
                             !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217
+                                !checkAndReportErrorForInvalidInitializer() &&
                                 !checkAndReportErrorForExtendingInterface(errorLocation) &&
                                 !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) &&
@@ -50417,7 +50457,16 @@ var ts;
                                 !checkAndReportErrorForUsingNamespaceModuleAsValue(errorLocation, name, meaning) &&
                                 !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) {
                             var suggestion = void 0;
-                            if (getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
+                            var suggestedLib = void 0;
+                            // Report missing lib first
+                            if (nameArg) {
+                                suggestedLib = getSuggestedLibForNonExistentName(nameArg);
+                                if (suggestedLib) {
+                                    error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib);
+                                }
+                            }
+                            // then spelling suggestions
+                            if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) {
                                 suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning);
                                 var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration);
                                 if (isGlobalScopeAugmentationDeclaration) {
@@ -50436,16 +50485,9 @@ var ts;
                                     }
                                 }
                             }
-                            if (!suggestion) {
-                                if (nameArg) {
-                                    var lib = getSuggestedLibForNonExistentName(nameArg);
-                                    if (lib) {
-                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), lib);
-                                    }
-                                    else {
-                                        error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
-                                    }
-                                }
+                            // And then fall back to unspecified "not found"
+                            if (!suggestion && !suggestedLib && nameArg) {
+                                error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg));
                             }
                             suggestionCount++;
                         }
@@ -50453,12 +50495,7 @@ var ts;
                 }
                 return undefined;
             }
-            if (propertyWithInvalidInitializer && !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ESNext */ && useDefineForClassFields)) {
-                // We have a match, but the reference occurred within a property initializer and the identifier also binds
-                // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed
-                // with ESNext+useDefineForClassFields because the scope semantics are different.
-                var propertyName = propertyWithInvalidInitializer.name;
-                error(errorLocation, ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyName), diagnosticName(nameArg));
+            else if (checkAndReportErrorForInvalidInitializer()) {
                 return undefined;
             }
             // Perform extra checks only if error reporting was requested
@@ -52607,13 +52644,25 @@ var ts;
                         && isDeclarationVisible(declaration.parent)) {
                         return addVisibleAlias(declaration, declaration);
                     }
-                    else if (symbol.flags & 2097152 /* Alias */ && ts.isBindingElement(declaration) && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
-                        && ts.isVariableDeclaration(declaration.parent.parent)
-                        && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
-                        && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
-                        && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
-                        && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
-                        return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                    else if (ts.isBindingElement(declaration)) {
+                        if (symbol.flags & 2097152 /* Alias */ && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement
+                            && ts.isVariableDeclaration(declaration.parent.parent)
+                            && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent)
+                            && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* Export */)
+                            && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file)
+                            && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) {
+                            return addVisibleAlias(declaration, declaration.parent.parent.parent.parent);
+                        }
+                        else if (symbol.flags & 2 /* BlockScopedVariable */) {
+                            var variableStatement = ts.findAncestor(declaration, ts.isVariableStatement);
+                            if (ts.hasSyntacticModifier(variableStatement, 1 /* Export */)) {
+                                return true;
+                            }
+                            if (!isDeclarationVisible(variableStatement.parent)) {
+                                return false;
+                            }
+                            return addVisibleAlias(declaration, variableStatement);
+                        }
                     }
                     // Declaration is not visible
                     return false;
@@ -53134,6 +53183,10 @@ var ts;
                     }
                     return typeToTypeNodeHelper(type, context);
                 }
+                function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) {
+                    return isMappedTypeWithKeyofConstraintDeclaration(type)
+                        && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */);
+                }
                 function createMappedTypeNodeFromType(type) {
                     ts.Debug.assert(!!(type.flags & 524288 /* Object */));
                     var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined;
@@ -53143,7 +53196,7 @@ var ts;
                     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
                         // We have a { [P in keyof T]: X }
                         // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType`
-                        if (!(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                        if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                             var newParam = createTypeParameter(createSymbol(262144 /* TypeParameter */, "T"));
                             var name = typeParameterToName(newParam, context);
                             newTypeVariable = ts.factory.createTypeReferenceNode(name);
@@ -53159,11 +53212,12 @@ var ts;
                     var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined);
                     context.approximateLength += 10;
                     var result = ts.setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
-                    if (isMappedTypeWithKeyofConstraintDeclaration(type) && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeParameter */) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+                    if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
                         // homomorphic mapped type with a non-homomorphic naive inlining
                         // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting
                         // type stays homomorphic
-                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
+                        var originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type.declaration.typeParameter.constraint.type)) || unknownType, type.mapper);
+                        return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* Unknown */ ? undefined : typeToTypeNodeHelper(originalConstraint, context))), result, ts.factory.createKeywordTypeNode(143 /* NeverKeyword */));
                     }
                     return result;
                 }
@@ -62308,19 +62362,22 @@ var ts;
          * to reduce the resulting type if possible (since only intersections with conflicting literal-typed properties are reducible).
          */
         function isPossiblyReducibleByInstantiation(type) {
-            return ts.some(type.types, function (t) {
-                var uniqueFilled = getUniqueLiteralFilledInstantiation(t);
-                return getReducedType(uniqueFilled) !== uniqueFilled;
-            });
+            var uniqueFilled = getUniqueLiteralFilledInstantiation(type);
+            return getReducedType(uniqueFilled) !== uniqueFilled;
+        }
+        function shouldDeferIndexType(type) {
+            return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ ||
+                isGenericTupleType(type) ||
+                isGenericMappedType(type) && !hasDistributiveNameType(type) ||
+                type.flags & 1048576 /* Union */ && ts.some(type.types, isPossiblyReducibleByInstantiation) ||
+                type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && ts.some(type.types, isEmptyAnonymousObjectType));
         }
         function getIndexType(type, stringsOnly, noIndexSignatures) {
             if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; }
             type = getReducedType(type);
-            return type.flags & 1048576 /* Union */ ? isPossiblyReducibleByInstantiation(type)
-                ? getIndexTypeForGenericType(type, stringsOnly)
-                : getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
-                type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
-                    type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
+            return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) :
+                type.flags & 1048576 /* Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
+                    type.flags & 2097152 /* Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) :
                         ts.getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) :
                             type === wildcardType ? wildcardType :
                                 type.flags & 2 /* Unknown */ ? neverType :
@@ -66113,13 +66170,20 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
+                var saveErrorInfo = captureErrorCalculationState();
+                var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
+                if (result) {
+                    resetErrorInfo(saveErrorInfo);
+                }
+                return result;
+            }
+            function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
                 }
                 var result;
                 var originalErrorInfo;
                 var varianceCheckFailed = false;
-                var saveErrorInfo = captureErrorCalculationState();
                 var sourceFlags = source.flags;
                 var targetFlags = target.flags;
                 if (relation === identityRelation) {
@@ -66183,7 +66247,6 @@ var ts;
                         if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
                             // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
                             if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66308,7 +66371,6 @@ var ts;
                             result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, reportErrors);
                         }
                         if (result) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (reportErrors) {
@@ -66411,7 +66473,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     var c = target;
@@ -66426,7 +66487,6 @@ var ts;
                         if (result = skipTrue ? -1 /* True */ : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false)) {
                             result &= skipFalse ? -1 /* True */ : isRelatedTo(source, getFalseTypeFromConditionalType(c), 2 /* Target */, /*reportErrors*/ false);
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66458,12 +66518,10 @@ var ts;
                         var constraint = getConstraintOfType(source) || unknownType;
                         // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed
                         if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
                         else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                         if (isMappedTypeGenericIndexedAccess(source)) {
@@ -66472,7 +66530,6 @@ var ts;
                             var indexConstraint = getConstraintOfType(source.indexType);
                             if (indexConstraint) {
                                 if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* Source */, reportErrors)) {
-                                    resetErrorInfo(saveErrorInfo);
                                     return result;
                                 }
                             }
@@ -66481,7 +66538,6 @@ var ts;
                 }
                 else if (sourceFlags & 4194304 /* Index */) {
                     if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
-                        resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
@@ -66489,7 +66545,6 @@ var ts;
                     if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66500,14 +66555,12 @@ var ts;
                             return 0 /* False */;
                         }
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
                     else {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66516,7 +66569,6 @@ var ts;
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) {
-                        resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
                     if (targetFlags & 16777216 /* Conditional */) {
@@ -66539,7 +66591,6 @@ var ts;
                                 result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, reportErrors);
                             }
                             if (result) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66550,7 +66601,6 @@ var ts;
                         var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined;
                         if (distributiveConstraint) {
                             if (result = isRelatedTo(distributiveConstraint, target, 1 /* Source */, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -66560,7 +66610,6 @@ var ts;
                     var defaultConstraint = getDefaultConstraintOfConditionalType(source);
                     if (defaultConstraint) {
                         if (result = isRelatedTo(defaultConstraint, target, 1 /* Source */, reportErrors)) {
-                            resetErrorInfo(saveErrorInfo);
                             return result;
                         }
                     }
@@ -66573,7 +66622,6 @@ var ts;
                     if (isGenericMappedType(target)) {
                         if (isGenericMappedType(source)) {
                             if (result = mappedTypeRelatedTo(source, target, reportErrors)) {
-                                resetErrorInfo(saveErrorInfo);
                                 return result;
                             }
                         }
@@ -69919,6 +69967,15 @@ var ts;
                         var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer);
                         return key && key + "." + propName;
                     }
+                    break;
+                case 201 /* ObjectBindingPattern */:
+                case 202 /* ArrayBindingPattern */:
+                case 256 /* FunctionDeclaration */:
+                case 213 /* FunctionExpression */:
+                case 214 /* ArrowFunction */:
+                case 169 /* MethodDeclaration */:
+                    // Handle pseudo-references originating in getNarrowedTypeOfSymbol.
+                    return getNodeId(node) + "#" + getTypeId(declaredType);
             }
             return undefined;
         }
@@ -72094,7 +72151,7 @@ var ts;
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
                 (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
-                    : getContextualType(node));
+                    : getContextualType(node, /*contextFlags*/ undefined));
             return contextualType && !isGenericType(contextualType);
         }
         function getNarrowableTypeForReference(type, reference, checkMode) {
@@ -72958,7 +73015,7 @@ var ts;
                     // We have an object literal method. Check if the containing object literal has a contextual type
                     // that includes a ThisType<T>. If so, T is the contextual type for 'this'. We continue looking in
                     // any directly enclosing object literals.
-                    var contextualType = getApparentTypeOfContextualType(containingLiteral);
+                    var contextualType = getApparentTypeOfContextualType(containingLiteral, /*contextFlags*/ undefined);
                     var literal = containingLiteral;
                     var type = contextualType;
                     while (type) {
@@ -72970,7 +73027,7 @@ var ts;
                             break;
                         }
                         literal = literal.parent.parent;
-                        type = getApparentTypeOfContextualType(literal);
+                        type = getApparentTypeOfContextualType(literal, /*contextFlags*/ undefined);
                     }
                     // There was no contextual ThisType<T> for the containing object literal, so the contextual type
                     // for 'this' is the non-null form of the contextual type for the containing object literal or
@@ -73027,7 +73084,7 @@ var ts;
                     tryGetTypeAtPosition(contextualSignature, index);
             }
         }
-        function getContextualTypeForVariableLikeDeclaration(declaration) {
+        function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) {
             var typeNode = ts.getEffectiveTypeAnnotationNode(declaration);
             if (typeNode) {
                 return getTypeFromTypeNode(typeNode);
@@ -73036,18 +73093,18 @@ var ts;
                 case 164 /* Parameter */:
                     return getContextuallyTypedParameterType(declaration);
                 case 203 /* BindingElement */:
-                    return getContextualTypeForBindingElement(declaration);
+                    return getContextualTypeForBindingElement(declaration, contextFlags);
                 case 167 /* PropertyDeclaration */:
                     if (ts.isStatic(declaration)) {
-                        return getContextualTypeForStaticPropertyDeclaration(declaration);
+                        return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags);
                     }
                 // By default, do nothing and return undefined - only the above cases have context implied by a parent
             }
         }
-        function getContextualTypeForBindingElement(declaration) {
+        function getContextualTypeForBindingElement(declaration, contextFlags) {
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
-            var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
+            var parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) ||
                 parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
@@ -73063,8 +73120,8 @@ var ts;
                 return getTypeOfPropertyOfType(parentType, text);
             }
         }
-        function getContextualTypeForStaticPropertyDeclaration(declaration) {
-            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent);
+        function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) {
+            var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent, contextFlags);
             if (!parentType)
                 return undefined;
             return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName);
@@ -73080,7 +73137,7 @@ var ts;
         function getContextualTypeForInitializerExpression(node, contextFlags) {
             var declaration = node.parent;
             if (ts.hasInitializer(declaration) && node === declaration.initializer) {
-                var result = getContextualTypeForVariableLikeDeclaration(declaration);
+                var result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags);
                 if (result) {
                     return result;
                 }
@@ -73090,10 +73147,10 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForReturnExpression(node) {
+        function getContextualTypeForReturnExpression(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     var functionFlags = ts.getFunctionFlags(func);
                     if (functionFlags & 1 /* Generator */) { // Generator or AsyncGenerator function
@@ -73123,11 +73180,11 @@ var ts;
             }
             return undefined;
         }
-        function getContextualTypeForYieldOperand(node) {
+        function getContextualTypeForYieldOperand(node, contextFlags) {
             var func = ts.getContainingFunction(node);
             if (func) {
                 var functionFlags = ts.getFunctionFlags(func);
-                var contextualReturnType = getContextualReturnType(func);
+                var contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     return node.asteriskToken
                         ? contextualReturnType
@@ -73151,14 +73208,14 @@ var ts;
         }
         function getContextualIterationType(kind, functionDecl) {
             var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2 /* Async */);
-            var contextualReturnType = getContextualReturnType(functionDecl);
+            var contextualReturnType = getContextualReturnType(functionDecl, /*contextFlags*/ undefined);
             if (contextualReturnType) {
                 return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync)
                     || undefined;
             }
             return undefined;
         }
-        function getContextualReturnType(functionDecl) {
+        function getContextualReturnType(functionDecl, contextFlags) {
             // If the containing function has a return type annotation, is a constructor, or is a get accessor whose
             // corresponding set accessor has a type annotation, return statements in the function are contextually typed
             var returnType = getReturnTypeFromAnnotation(functionDecl);
@@ -73173,7 +73230,7 @@ var ts;
             }
             var iife = ts.getImmediatelyInvokedFunctionExpression(functionDecl);
             if (iife) {
-                return getContextualType(iife);
+                return getContextualType(iife, contextFlags);
             }
             return undefined;
         }
@@ -73426,7 +73483,7 @@ var ts;
         }
         function getContextualTypeForObjectLiteralElement(element, contextFlags) {
             var objectLiteral = element.parent;
-            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element);
+            var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags);
             if (propertyAssignmentType) {
                 return propertyAssignmentType;
             }
@@ -73621,9 +73678,9 @@ var ts;
                     return getContextualTypeForInitializerExpression(node, contextFlags);
                 case 214 /* ArrowFunction */:
                 case 247 /* ReturnStatement */:
-                    return getContextualTypeForReturnExpression(node);
+                    return getContextualTypeForReturnExpression(node, contextFlags);
                 case 224 /* YieldExpression */:
-                    return getContextualTypeForYieldOperand(parent);
+                    return getContextualTypeForYieldOperand(parent, contextFlags);
                 case 218 /* AwaitExpression */:
                     return getContextualTypeForAwaitOperand(parent, contextFlags);
                 case 208 /* CallExpression */:
@@ -73671,7 +73728,7 @@ var ts;
             }
             return undefined;
             function tryFindWhenConstTypeReference(node) {
-                return getContextualType(node);
+                return getContextualType(node, contextFlags);
             }
         }
         function getInferenceContext(node) {
@@ -73973,7 +74030,7 @@ var ts;
             var elementCount = elements.length;
             var elementTypes = [];
             var elementFlags = [];
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var inDestructuringPattern = ts.isAssignmentTarget(node);
             var inConstContext = isConstContext(node);
             var hasOmittedExpression = false;
@@ -74144,7 +74201,7 @@ var ts;
             var propertiesTable = ts.createSymbolTable();
             var propertiesArray = [];
             var spread = emptyObjectType;
-            var contextualType = getApparentTypeOfContextualType(node);
+            var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined);
             var contextualTypeHasPattern = contextualType && contextualType.pattern &&
                 (contextualType.pattern.kind === 201 /* ObjectBindingPattern */ || contextualType.pattern.kind === 205 /* ObjectLiteralExpression */);
             var inConstContext = isConstContext(node);
@@ -74483,7 +74540,7 @@ var ts;
                     if (explicitlySpecifyChildrenAttribute) {
                         error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName));
                     }
-                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes);
+                    var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, /*contextFlags*/ undefined);
                     var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName);
                     // If there are children in the body of JSX element, create dummy attribute "children" with the union of children types so that it will pass the attribute checking process
                     var childrenPropSymbol = createSymbol(4 /* Property */, jsxChildrenPropertyName);
@@ -78323,17 +78380,6 @@ var ts;
                     }
                 }
             }
-            var restType = getEffectiveRestType(context);
-            if (restType && restType.flags & 262144 /* TypeParameter */) {
-                // The contextual signature has a generic rest parameter. We first instantiate the contextual
-                // signature (without fixing type parameters) and assign types to contextually typed parameters.
-                var instantiatedContext = instantiateSignature(context, inferenceContext.nonFixingMapper);
-                assignContextualParameterTypes(signature, instantiatedContext);
-                // We then infer from a tuple type representing the parameters that correspond to the contextual
-                // rest parameter.
-                var restPos = getParameterCount(context) - 1;
-                inferTypes(inferenceContext.inferences, getRestTypeAtPosition(signature, restPos), restType);
-            }
         }
         function assignContextualParameterTypes(signature, context) {
             if (context.typeParameters) {
@@ -78526,7 +78572,7 @@ var ts;
                     var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
                     var contextualType = !contextualSignature ? undefined :
                         contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
-                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func);
+                            instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, /*contextFlags*/ undefined);
                     if (isGenerator) {
                         yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* Yield */, isAsync);
                         returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* Return */, isAsync);
@@ -78597,7 +78643,7 @@ var ts;
                     nextType = iterationTypes && iterationTypes.nextType;
                 }
                 else {
-                    nextType = getContextualType(yieldExpression);
+                    nextType = getContextualType(yieldExpression, /*contextFlags*/ undefined);
                 }
                 if (nextType)
                     ts.pushIfUnique(nextTypes, nextType);
@@ -78806,11 +78852,16 @@ var ts;
                     if (isContextSensitive(node)) {
                         if (contextualSignature) {
                             var inferenceContext = getInferenceContext(node);
+                            var instantiatedContextualSignature = void 0;
                             if (checkMode && checkMode & 2 /* Inferential */) {
                                 inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext);
+                                var restType = getEffectiveRestType(contextualSignature);
+                                if (restType && restType.flags & 262144 /* TypeParameter */) {
+                                    instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper);
+                                }
                             }
-                            var instantiatedContextualSignature = inferenceContext ?
-                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature;
+                            instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ?
+                                instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature);
                             assignContextualParameterTypes(signature, instantiatedContextualSignature);
                         }
                         else {
@@ -80052,7 +80103,7 @@ var ts;
                 type = anyType;
                 addLazyDiagnostic(function () {
                     if (noImplicitAny && !ts.expressionResultIsUnused(node)) {
-                        var contextualType = getContextualType(node);
+                        var contextualType = getContextualType(node, /*contextFlags*/ undefined);
                         if (!contextualType || isTypeAny(contextualType)) {
                             error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation);
                         }
@@ -80093,7 +80144,7 @@ var ts;
                 texts.push(span.literal.text);
                 types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
             }
-            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+            return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node, /*contextFlags*/ undefined) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
         }
         function isTemplateLiteralContextualType(type) {
             return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) ||
@@ -80121,7 +80172,7 @@ var ts;
                 // We strip literal freshness when an appropriate contextual type is present such that contextually typed
                 // literals always preserve their literal types (otherwise they might widen during type inference). An alternative
                 // here would be to not mark contextually typed literals as fresh in the first place.
-                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node)) ?
+                var result = maybeTypeOfKind(type, 2944 /* Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ?
                     getRegularTypeOfLiteralType(type) : type;
                 return result;
             }
@@ -80236,7 +80287,7 @@ var ts;
             var type = checkExpression(node, checkMode, forceTuple);
             return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) :
                 isTypeAssertion(node) ? type :
-                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node) : contextualType, node));
+                    getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, /*contextFlags*/ undefined) : contextualType, node, /*contextFlags*/ undefined));
         }
         function checkPropertyAssignment(node, checkMode) {
             // Do not use hasDynamicName here, because that returns false for well known symbols.