typescript 4.7.0-dev.20220327 → 4.7.0-dev.20220330

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.20220327";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220330";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -13401,7 +13401,9 @@ var ts;
             || kind === 174 /* CallSignature */
             || kind === 166 /* PropertySignature */
             || kind === 168 /* MethodSignature */
-            || kind === 176 /* IndexSignature */;
+            || kind === 176 /* IndexSignature */
+            || kind === 172 /* GetAccessor */
+            || kind === 173 /* SetAccessor */;
     }
     ts.isTypeElement = isTypeElement;
     function isClassOrTypeElement(node) {
@@ -47383,6 +47385,7 @@ var ts;
         TypeSystemPropertyName[TypeSystemPropertyName["EnumTagType"] = 5] = "EnumTagType";
         TypeSystemPropertyName[TypeSystemPropertyName["ResolvedTypeArguments"] = 6] = "ResolvedTypeArguments";
         TypeSystemPropertyName[TypeSystemPropertyName["ResolvedBaseTypes"] = 7] = "ResolvedBaseTypes";
+        TypeSystemPropertyName[TypeSystemPropertyName["WriteType"] = 8] = "WriteType";
     })(TypeSystemPropertyName || (TypeSystemPropertyName = {}));
     var CheckMode;
     (function (CheckMode) {
@@ -47392,7 +47395,8 @@ var ts;
         CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive";
         CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
         CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
-        CheckMode[CheckMode["RestBindingElement"] = 32] = "RestBindingElement";
+        CheckMode[CheckMode["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+        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 = {}));
@@ -47730,26 +47734,10 @@ var ts;
                 if (!node) {
                     return undefined;
                 }
-                var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
-                var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = true;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = undefined;
-                }
-                var result = getContextualType(node, contextFlags);
-                if (contextFlags & 4 /* Completions */ && containingCall) {
-                    var toMarkSkip = node;
-                    do {
-                        getNodeLinks(toMarkSkip).skipDirectInference = undefined;
-                        toMarkSkip = toMarkSkip.parent;
-                    } while (toMarkSkip && toMarkSkip !== containingCall);
-                    getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+                if (contextFlags & 4 /* Completions */) {
+                    return runWithInferenceBlockedFromSourceNode(node, function () { return getContextualType(node, contextFlags); });
                 }
-                return result;
+                return getContextualType(node, contextFlags);
             },
             getContextualTypeForObjectLiteralElement: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike);
@@ -47769,6 +47757,9 @@ var ts;
             getResolvedSignature: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */);
             },
+            getResolvedSignatureForStringLiteralCompletions: function (call, editingArgument, candidatesOutArray) {
+                return getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, 32 /* IsForStringLiteralArgumentCompletions */, editingArgument);
+            },
             getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) {
                 return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */);
             },
@@ -47921,10 +47912,34 @@ var ts;
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
             getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
-        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
+        function runWithInferenceBlockedFromSourceNode(node, fn) {
+            var containingCall = ts.findAncestor(node, ts.isCallLikeExpression);
+            var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature;
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = true;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = undefined;
+            }
+            var result = fn();
+            if (containingCall) {
+                var toMarkSkip = node;
+                do {
+                    getNodeLinks(toMarkSkip).skipDirectInference = undefined;
+                    toMarkSkip = toMarkSkip.parent;
+                } while (toMarkSkip && toMarkSkip !== containingCall);
+                getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature;
+            }
+            return result;
+        }
+        function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
             apparentArgumentCount = argumentCount;
-            var res = node ? getResolvedSignature(node, candidatesOutArray, checkMode) : undefined;
+            var res = !node ? undefined :
+                editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, function () { return getResolvedSignature(node, candidatesOutArray, checkMode); }) :
+                    getResolvedSignature(node, candidatesOutArray, checkMode);
             apparentArgumentCount = undefined;
             return res;
         }
@@ -48897,6 +48912,10 @@ var ts;
                 }
             }
         }
+        function isConstAssertion(location) {
+            return (ts.isAssertionExpression(location) && ts.isConstTypeReference(location.type))
+                || (ts.isJSDocTypeTag(location) && ts.isConstTypeReference(location.typeExpression));
+        }
         /**
          * Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and
          * the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with
@@ -48922,6 +48941,11 @@ var ts;
             var grandparent;
             var isInExternalModule = false;
             loop: while (location) {
+                if (name === "const" && isConstAssertion(location)) {
+                    // `const` in an `as const` has no symbol, but issues no error because there is no *actual* lookup of the type
+                    // (it refers to the constant type of the expression instead)
+                    return undefined;
+                }
                 // Locals of a source file are not in scope (because they get merged into the global symbol table)
                 if (location.locals && !isGlobalSourceFile(location)) {
                     if (result = lookup(location.locals, name, meaning)) {
@@ -54870,6 +54894,8 @@ var ts;
                     return !!target.resolvedTypeArguments;
                 case 7 /* ResolvedBaseTypes */:
                     return !!target.baseTypesResolved;
+                case 8 /* WriteType */:
+                    return !!getSymbolLinks(target).writeType;
             }
             return ts.Debug.assertNever(propertyName);
         }
@@ -55047,7 +55073,7 @@ var ts;
         }
         /** Return the inferred type for a binding element */
         function getTypeForBindingElement(declaration) {
-            var checkMode = declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+            var checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
             var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
             return parentType && getBindingElementTypeFromParentType(declaration, parentType);
         }
@@ -55787,6 +55813,11 @@ var ts;
                 }
                 return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression)));
             }
+            if (ts.isAccessor(declaration)) {
+                // Binding of certain patterns in JS code will occasionally mark symbols as both properties
+                // and accessors. Here we dispatch to accessor resolution if needed.
+                return getTypeOfAccessors(symbol);
+            }
             // Handle variable, parameter or property
             if (!pushTypeResolution(symbol, 0 /* Type */)) {
                 // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty`
@@ -55850,9 +55881,6 @@ var ts;
             else if (ts.isEnumMember(declaration)) {
                 type = getTypeOfEnumMember(symbol);
             }
-            else if (ts.isAccessor(declaration)) {
-                type = resolveTypeOfAccessors(symbol) || ts.Debug.fail("Non-write accessor resolution must always produce a type");
-            }
             else {
                 return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol));
             }
@@ -55891,87 +55919,61 @@ var ts;
         }
         function getTypeOfAccessors(symbol) {
             var links = getSymbolLinks(symbol);
-            return links.type || (links.type = getTypeOfAccessorsWorker(symbol) || ts.Debug.fail("Read type of accessor must always produce a type"));
-        }
-        function getTypeOfSetAccessor(symbol) {
-            var links = getSymbolLinks(symbol);
-            return links.writeType || (links.writeType = getTypeOfAccessorsWorker(symbol, /*writing*/ true));
-        }
-        function getTypeOfAccessorsWorker(symbol, writing) {
-            if (writing === void 0) { writing = false; }
-            if (!pushTypeResolution(symbol, 0 /* Type */)) {
-                return errorType;
-            }
-            var type = resolveTypeOfAccessors(symbol, writing);
-            if (!popTypeResolution()) {
+            if (!links.type) {
+                if (!pushTypeResolution(symbol, 0 /* Type */)) {
+                    return errorType;
+                }
                 var getter = ts.getDeclarationOfKind(symbol, 172 /* GetAccessor */);
-                if (getter) {
-                    if (ts.getEffectiveTypeAnnotationNode(getter)) {
-                        error(getter.name, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
+                // We try to resolve a getter type annotation, a setter type annotation, or a getter function
+                // body return type inference, in that order.
+                var type = getter && ts.isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) ||
+                    getAnnotatedAccessorType(getter) ||
+                    getAnnotatedAccessorType(setter) ||
+                    getter && getter.body && getReturnTypeFromBody(getter);
+                if (!type) {
+                    if (setter && !isPrivateWithinAmbient(setter)) {
+                        errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
+                    }
+                    else if (getter && !isPrivateWithinAmbient(getter)) {
+                        errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+                    }
+                    type = anyType;
+                }
+                if (!popTypeResolution()) {
+                    if (getAnnotatedAccessorTypeNode(getter)) {
+                        error(getter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
                     }
-                    else if (noImplicitAny) {
+                    else if (getAnnotatedAccessorTypeNode(setter)) {
+                        error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    else if (getter && noImplicitAny) {
                         error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
                     }
+                    type = anyType;
                 }
-                type = anyType;
+                links.type = type;
             }
-            return type;
+            return links.type;
         }
-        function resolveTypeOfAccessors(symbol, writing) {
-            if (writing === void 0) { writing = false; }
-            var getter = ts.getDeclarationOfKind(symbol, 172 /* GetAccessor */);
-            var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
-            // For write operations, prioritize type annotations on the setter
-            if (writing) {
-                var setterType_1 = getAnnotatedAccessorType(setter);
-                if (setterType_1) {
-                    return instantiateTypeIfNeeded(setterType_1, symbol);
-                }
-            }
-            // Else defer to the getter type
-            if (getter && ts.isInJSFile(getter)) {
-                var jsDocType = getTypeForDeclarationFromJSDocComment(getter);
-                if (jsDocType) {
-                    return instantiateTypeIfNeeded(jsDocType, symbol);
-                }
-            }
-            // Try to see if the user specified a return type on the get-accessor.
-            var getterType = getAnnotatedAccessorType(getter);
-            if (getterType) {
-                return instantiateTypeIfNeeded(getterType, symbol);
-            }
-            // If the user didn't specify a return type, try to use the set-accessor's parameter type.
-            var setterType = getAnnotatedAccessorType(setter);
-            if (setterType) {
-                return setterType;
-            }
-            // If there are no specified types, try to infer it from the body of the get accessor if it exists.
-            if (getter && getter.body) {
-                var returnTypeFromBody = getReturnTypeFromBody(getter);
-                return instantiateTypeIfNeeded(returnTypeFromBody, symbol);
-            }
-            // Otherwise, fall back to 'any'.
-            if (setter) {
-                if (!isPrivateWithinAmbient(setter)) {
-                    errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
-                }
-                return anyType;
-            }
-            else if (getter) {
-                ts.Debug.assert(!!getter, "there must exist a getter as we are current checking either setter or getter in this function");
-                if (!isPrivateWithinAmbient(getter)) {
-                    errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+        function getWriteTypeOfAccessors(symbol) {
+            var links = getSymbolLinks(symbol);
+            if (!links.writeType) {
+                if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
+                    return errorType;
                 }
-                return anyType;
-            }
-            return undefined;
-            function instantiateTypeIfNeeded(type, symbol) {
-                if (ts.getCheckFlags(symbol) & 1 /* Instantiated */) {
-                    var links = getSymbolLinks(symbol);
-                    return instantiateType(type, links.mapper);
+                var setter = ts.getDeclarationOfKind(symbol, 173 /* SetAccessor */);
+                var writeType = getAnnotatedAccessorType(setter);
+                if (!popTypeResolution()) {
+                    if (getAnnotatedAccessorTypeNode(setter)) {
+                        error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol));
+                    }
+                    writeType = anyType;
                 }
-                return type;
+                // Absent an explicit setter type annotation we use the read type of the accessor.
+                links.writeType = writeType || getTypeOfAccessors(symbol);
             }
+            return links.writeType;
         }
         function getBaseTypeVariableOfClass(symbol) {
             var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol));
@@ -56053,17 +56055,11 @@ var ts;
         }
         function getTypeOfInstantiatedSymbol(symbol) {
             var links = getSymbolLinks(symbol);
-            if (!links.type) {
-                if (!pushTypeResolution(symbol, 0 /* Type */)) {
-                    return links.type = errorType;
-                }
-                var type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
-                if (!popTypeResolution()) {
-                    type = reportCircularityError(symbol);
-                }
-                links.type = type;
-            }
-            return links.type;
+            return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper));
+        }
+        function getWriteTypeOfInstantiatedSymbol(symbol) {
+            var links = getSymbolLinks(symbol);
+            return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target), links.mapper));
         }
         function reportCircularityError(symbol) {
             var declaration = symbol.valueDeclaration;
@@ -56100,35 +56096,23 @@ var ts;
             return links.writeType;
         }
         /**
-         * Distinct write types come only from set accessors, but union and intersection
-         * properties deriving from set accessors will either pre-compute or defer the
-         * union or intersection of the writeTypes of their constituents. To account for
-         * this, we will assume that any deferred type or transient symbol may have a
-         * `writeType` (or a deferred write type ready to be computed) that should be
-         * used before looking for set accessor declarations.
+         * Distinct write types come only from set accessors, but synthetic union and intersection
+         * properties deriving from set accessors will either pre-compute or defer the union or
+         * intersection of the writeTypes of their constituents.
          */
         function getWriteTypeOfSymbol(symbol) {
             var checkFlags = ts.getCheckFlags(symbol);
-            if (checkFlags & 65536 /* DeferredType */) {
-                var writeType = getWriteTypeOfSymbolWithDeferredType(symbol);
-                if (writeType) {
-                    return writeType;
-                }
+            if (symbol.flags & 4 /* Property */) {
+                return checkFlags & 2 /* SyntheticProperty */ ?
+                    checkFlags & 65536 /* DeferredType */ ?
+                        getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) :
+                        symbol.writeType || symbol.type :
+                    getTypeOfSymbol(symbol);
             }
-            if (symbol.flags & 33554432 /* Transient */) {
-                var writeType = symbol.writeType;
-                if (writeType) {
-                    return writeType;
-                }
-            }
-            return getSetAccessorTypeOfSymbol(symbol);
-        }
-        function getSetAccessorTypeOfSymbol(symbol) {
             if (symbol.flags & 98304 /* Accessor */) {
-                var type = getTypeOfSetAccessor(symbol);
-                if (type) {
-                    return type;
-                }
+                return checkFlags & 1 /* Instantiated */ ?
+                    getWriteTypeOfInstantiatedSymbol(symbol) :
+                    getWriteTypeOfAccessors(symbol);
             }
             return getTypeOfSymbol(symbol);
         }
@@ -68217,7 +68201,7 @@ var ts;
                 for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
                     var targetProp = properties_3[_i];
                     var sourceProp = getPropertyOfType(source, targetProp.escapedName);
-                    if (sourceProp) {
+                    if (sourceProp && !ts.some(sourceProp.declarations, hasSkipDirectInferenceFlag)) {
                         inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));
                     }
                 }
@@ -70599,7 +70583,7 @@ var ts;
                 }
             }
             if (ts.isDeclarationName(location) && ts.isSetAccessor(location.parent) && getAnnotatedAccessorTypeNode(location.parent)) {
-                return resolveTypeOfAccessors(location.parent.symbol, /*writing*/ true);
+                return getWriteTypeOfAccessors(location.parent.symbol);
             }
             // The location isn't a reference to the given symbol, meaning we're being asked
             // a hypothetical question of what type the symbol would have if there was a reference
@@ -70691,7 +70675,7 @@ var ts;
             // as we want the type of a rest element to be generic when possible.
             var contextualType = (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
                 !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) &&
-                (checkMode && checkMode & 32 /* RestBindingElement */ ?
+                (checkMode && checkMode & 64 /* RestBindingElement */ ?
                     getContextualType(node, 8 /* SkipBindingPatterns */)
                     : getContextualType(node));
             return contextualType && !isGenericType(contextualType);
@@ -71630,7 +71614,7 @@ var ts;
             var parent = declaration.parent.parent;
             var name = declaration.propertyName || declaration.name;
             var parentType = getContextualTypeForVariableLikeDeclaration(parent) ||
-                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */);
+                parent.kind !== 203 /* BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
             if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name))
                 return undefined;
             if (parent.name.kind === 202 /* ArrayBindingPattern */) {
@@ -74684,7 +74668,7 @@ var ts;
             }
             for (var i = 0; i < argCount; i++) {
                 var arg = args[i];
-                if (arg.kind !== 227 /* OmittedExpression */) {
+                if (arg.kind !== 227 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
                     var paramType = getTypeAtPosition(signature, i);
                     var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
                     inferTypes(context.inferences, argType, paramType);
@@ -75369,7 +75353,7 @@ var ts;
                     }
                 }
             }
-            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
+            return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode);
             function addImplementationSuccessElaboration(failed, diagnostic) {
                 var _a, _b;
                 var oldCandidatesForArgumentError = candidatesForArgumentError;
@@ -75470,14 +75454,14 @@ var ts;
             }
         }
         // No signature was applicable. We have already reported the errors for the invalid signature.
-        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray) {
+        function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) {
             ts.Debug.assert(candidates.length > 0); // Else should not have called this.
             checkNodeDeferred(node);
             // Normally we will combine overloads. Skip this if they have type parameters since that's hard to combine.
             // Don't do this if there is a `candidatesOutArray`,
             // because then we want the chosen best candidate to be one of the overloads, not a combination.
             return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; })
-                ? pickLongestCandidateSignature(node, candidates, args)
+                ? pickLongestCandidateSignature(node, candidates, args, checkMode)
                 : createUnionOfSignaturesForOverloadFailure(candidates);
         }
         function createUnionOfSignaturesForOverloadFailure(candidates) {
@@ -75525,7 +75509,7 @@ var ts;
             // This function is currently only used for erroneous overloads, so it's good enough to just use the first source.
             return createSymbolWithType(ts.first(sources), type);
         }
-        function pickLongestCandidateSignature(node, candidates, args) {
+        function pickLongestCandidateSignature(node, candidates, args, checkMode) {
             // Pick the longest signature. This way we can get a contextual type for cases like:
             //     declare function f(a: { xa: number; xb: number; }, b: number);
             //     f({ |
@@ -75541,7 +75525,7 @@ var ts;
             var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
             var instantiated = typeArgumentNodes
                 ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node)))
-                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args);
+                : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
             candidates[bestIndex] = instantiated;
             return instantiated;
         }
@@ -75555,9 +75539,9 @@ var ts;
             }
             return typeArguments;
         }
-        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args) {
+        function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode) {
             var inferenceContext = createInferenceContext(typeParameters, candidate, /*flags*/ ts.isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */);
-            var typeArgumentTypes = inferTypeArguments(node, candidate, args, 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
+            var typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* SkipContextSensitive */ | 8 /* SkipGenericFunctions */, inferenceContext);
             return createSignatureInstantiation(candidate, typeArgumentTypes);
         }
         function getLongestCandidateIndex(candidates, argsCount) {
@@ -81623,7 +81607,7 @@ var ts;
                 }
                 // check private/protected variable access
                 var parent = node.parent.parent;
-                var parentCheckMode = node.dotDotDotToken ? 32 /* RestBindingElement */ : 0 /* Normal */;
+                var parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
                 var parentType = getTypeForBindingElementParent(parent, parentCheckMode);
                 var name = node.propertyName || node.name;
                 if (parentType && !ts.isBindingPattern(name)) {
@@ -81802,6 +81786,8 @@ var ts;
                     (condExpr.operatorToken.kind === 56 /* BarBarToken */ || condExpr.operatorToken.kind === 55 /* AmpersandAmpersandToken */)
                     ? condExpr.right
                     : condExpr;
+                if (ts.isModuleExportsAccessExpression(location))
+                    return;
                 var type = checkTruthinessExpression(location);
                 var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
                 if (getFalsyFlags(type) || isPropertyExpressionCast)
@@ -116719,6 +116705,13 @@ var ts;
                                 return "skip";
                             }
                             break;
+                        case 270 /* ImportSpecifier */:
+                        case 275 /* ExportSpecifier */:
+                            if (node.isTypeOnly) {
+                                diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, ts.isImportSpecifier(node) ? "import...type" : "export...type"));
+                                return "skip";
+                            }
+                            break;
                         case 265 /* ImportEqualsDeclaration */:
                             diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files));
                             return "skip";

package/package.json

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