@typescript-deploys/pr-build 5.2.0-pr-54581-2 → 5.2.0-pr-54282-26

package/lib/tsserver.js

@@ -2305,7 +2305,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230609`;
+var version = `${versionMajorMinor}.0-insiders.20230612`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -47322,11 +47322,10 @@ var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
   CheckMode3[CheckMode3["Inferential"] = 2] = "Inferential";
   CheckMode3[CheckMode3["SkipContextSensitive"] = 4] = "SkipContextSensitive";
   CheckMode3[CheckMode3["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
-  CheckMode3[CheckMode3["SkipAddingIntraExpressionSites"] = 16] = "SkipAddingIntraExpressionSites";
-  CheckMode3[CheckMode3["IsForSignatureHelp"] = 32] = "IsForSignatureHelp";
-  CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 64] = "IsForStringLiteralArgumentCompletions";
-  CheckMode3[CheckMode3["RestBindingElement"] = 128] = "RestBindingElement";
-  CheckMode3[CheckMode3["TypeOnly"] = 256] = "TypeOnly";
+  CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
+  CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+  CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
+  CheckMode3[CheckMode3["TypeOnly"] = 128] = "TypeOnly";
   return CheckMode3;
 })(CheckMode || {});
 var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
@@ -47606,9 +47605,9 @@ function createTypeChecker(host) {
       candidatesOutArray,
       /*argumentCount*/
       void 0,
-      64 /* IsForStringLiteralArgumentCompletions */
+      32 /* IsForStringLiteralArgumentCompletions */
     )),
-    getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 32 /* IsForSignatureHelp */)),
+    getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */)),
     getExpandedParameters,
     hasEffectiveRestParameter,
     containsArgumentsReference,
@@ -55563,7 +55562,7 @@ function createTypeChecker(host) {
     return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
   }
   function getTypeForBindingElement(declaration) {
-    const checkMode = declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+    const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
     const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
     return parentType && getBindingElementTypeFromParentType(declaration, parentType);
   }
@@ -62087,6 +62086,114 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
+  function getNarrowConditionalType(root, narrowMapper, mapper, aliasSymbol, aliasTypeArguments) {
+    let result;
+    let extraTypes;
+    let tailCount = 0;
+    while (true) {
+      if (tailCount === 1e3) {
+        error2(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+        return errorType;
+      }
+      const checkType = instantiateNarrowType(getActualTypeVariable(root.checkType), narrowMapper, mapper);
+      const extendsType = instantiateType(root.extendsType, mapper);
+      if (checkType === errorType || extendsType === errorType) {
+        return errorType;
+      }
+      if (checkType === wildcardType || extendsType === wildcardType) {
+        return wildcardType;
+      }
+      const checkTypeDeferred = false;
+      let combinedMapper;
+      if (root.inferTypeParameters) {
+        const freshParams = sameMap(root.inferTypeParameters, maybeCloneTypeParameter);
+        const freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : void 0;
+        const context = createInferenceContext(
+          freshParams,
+          /*signature*/
+          void 0,
+          0 /* None */
+        );
+        if (freshMapper) {
+          const freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
+          for (const p of freshParams) {
+            if (root.inferTypeParameters.indexOf(p) === -1) {
+              p.mapper = freshCombinedMapper;
+            }
+          }
+        }
+        if (!checkTypeDeferred) {
+          inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* NoConstraints */ | 1024 /* AlwaysStrict */);
+        }
+        const innerMapper = combineTypeMappers(freshMapper, context.mapper);
+        combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper;
+      }
+      const inferredExtendsType = combinedMapper ? instantiateType(root.extendsType, combinedMapper) : extendsType;
+      if (true) {
+        if (!(inferredExtendsType.flags & 3 /* AnyOrUnknown */) && (checkType.flags & 1 /* Any */ || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) {
+          if (checkType.flags & 1 /* Any */) {
+            (extraTypes || (extraTypes = [])).push(
+              instantiateNarrowType(getTypeFromTypeNode(root.node.trueType), narrowMapper, combinedMapper || mapper)
+            );
+          }
+          const falseType2 = getTypeFromTypeNode(root.node.falseType);
+          if (falseType2.flags & 16777216 /* Conditional */) {
+            const newRoot = falseType2.root;
+            if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
+              root = newRoot;
+              continue;
+            }
+            if (canTailRecurse(falseType2, mapper)) {
+              continue;
+            }
+          }
+          result = instantiateNarrowType(falseType2, narrowMapper, mapper);
+          break;
+        }
+        if (inferredExtendsType.flags & 3 /* AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) {
+          const trueType2 = getTypeFromTypeNode(root.node.trueType);
+          const trueMapper = combinedMapper || mapper;
+          if (canTailRecurse(trueType2, trueMapper)) {
+            continue;
+          }
+          result = instantiateNarrowType(trueType2, narrowMapper, trueMapper);
+          break;
+        }
+      }
+      result = createType(16777216 /* Conditional */);
+      result.root = root;
+      result.checkType = instantiateType(root.checkType, mapper);
+      result.extendsType = instantiateType(root.extendsType, mapper);
+      result.mapper = mapper;
+      result.combinedMapper = combinedMapper;
+      result.aliasSymbol = aliasSymbol || root.aliasSymbol;
+      result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper);
+      break;
+    }
+    return extraTypes ? getIntersectionType(append(extraTypes, result)) : result;
+    function canTailRecurse(newType, newMapper) {
+      if (newType.flags & 16777216 /* Conditional */ && newMapper) {
+        const newRoot = newType.root;
+        if (newRoot.outerTypeParameters) {
+          const typeParamMapper = combineTypeMappers(newType.mapper, newMapper);
+          const typeArguments = map(newRoot.outerTypeParameters, (t) => getMappedType(t, typeParamMapper));
+          const newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments);
+          const newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : void 0;
+          if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 /* Union */ | 131072 /* Never */))) {
+            root = newRoot;
+            mapper = newRootMapper;
+            aliasSymbol = void 0;
+            aliasTypeArguments = void 0;
+            if (newRoot.aliasSymbol) {
+              tailCount++;
+            }
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  }
   function getTypeFromInferTypeNode(node) {
     const links = getNodeLinks(node);
     if (!links.resolvedType) {
@@ -63035,6 +63142,93 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function instantiateNarrowType(type, narrowMapper, mapper, noTopLevel = false) {
+    return type ? instantiateNarrowTypeWithAlias(
+      type,
+      narrowMapper,
+      mapper,
+      /*aliasSymbol*/
+      void 0,
+      /*aliasTypeArguments*/
+      void 0,
+      noTopLevel
+    ) : type;
+  }
+  function instantiateNarrowTypeWithAlias(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel) {
+    var _a;
+    if (!couldContainTypeVariables(type)) {
+      return type;
+    }
+    if (instantiationDepth === 100 || instantiationCount >= 5e6) {
+      (_a = tracing) == null ? void 0 : _a.instant(tracing.Phase.CheckTypes, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth, instantiationCount });
+      error2(currentNode, Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
+      return errorType;
+    }
+    totalInstantiationCount++;
+    instantiationCount++;
+    instantiationDepth++;
+    const result = instantiateNarrowTypeWorker(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel);
+    instantiationDepth--;
+    return result;
+  }
+  function instantiateNarrowTypeWorker(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments, noTopLevel) {
+    const flags = type.flags;
+    if (flags & 262144 /* TypeParameter */) {
+      if (noTopLevel) {
+        return type;
+      }
+      return getMappedType(type, combineTypeMappers(mapper, narrowMapper));
+    }
+    if (flags & 8388608 /* IndexedAccess */) {
+      const newAliasSymbol = aliasSymbol || type.aliasSymbol;
+      const newAliasTypeArguments = aliasSymbol || !mapper ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
+      const objectType = instantiateType(type.objectType, mapper);
+      let indexType = instantiateType(type.indexType, mapper);
+      if (indexType.flags & 262144 /* TypeParameter */) {
+        indexType = getMappedType(indexType, narrowMapper);
+      }
+      return getIndexedAccessType(
+        objectType,
+        indexType,
+        type.accessFlags | 4 /* Writing */,
+        // Get the writing type
+        /*accessNode*/
+        void 0,
+        newAliasSymbol,
+        newAliasTypeArguments
+      );
+    }
+    if (flags & 16777216 /* Conditional */) {
+      return getNarrowConditionalTypeInstantiation(
+        type,
+        narrowMapper,
+        mapper ? combineTypeMappers(type.mapper, mapper) : type.mapper,
+        aliasSymbol,
+        aliasTypeArguments
+      );
+    }
+    return type;
+  }
+  function getNarrowConditionalTypeInstantiation(type, narrowMapper, mapper, aliasSymbol, aliasTypeArguments) {
+    const root = type.root;
+    if (root.outerTypeParameters) {
+      const typeArguments = mapper ? map(root.outerTypeParameters, (t) => getMappedType(t, mapper)) : root.outerTypeParameters;
+      let result;
+      const newMapper = createTypeMapper(root.outerTypeParameters, typeArguments);
+      const checkType = root.checkType;
+      const distributionType = root.isDistributive ? getMappedType(checkType, combineTypeMappers(newMapper, narrowMapper)) : void 0;
+      if (distributionType && checkType !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */)) {
+        result = mapTypeWithAlias(getReducedType(distributionType), (t) => getNarrowConditionalType(root, narrowMapper, prependTypeMapping(checkType, t, newMapper)), aliasSymbol, aliasTypeArguments);
+        if (result.flags & 1048576 /* Union */) {
+          result = getIntersectionType(result.types, aliasSymbol, aliasTypeArguments);
+        }
+      } else {
+        result = getNarrowConditionalType(root, narrowMapper, newMapper, aliasSymbol, aliasTypeArguments);
+      }
+      return result;
+    }
+    return type;
+  }
   function instantiateReverseMappedType(type, mapper) {
     const innerMappedType = instantiateType(type.mappedType, mapper);
     if (!(getObjectFlags(innerMappedType) & 32 /* Mapped */)) {
@@ -70468,7 +70662,7 @@ function createTypeChecker(host) {
     return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
   }
   function hasContextualTypeWithNoGenericTypes(node, checkMode) {
-    const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 128 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
+    const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 64 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
       node,
       /*contextFlags*/
       void 0
@@ -70476,7 +70670,7 @@ function createTypeChecker(host) {
     return contextualType && !isGenericType(contextualType);
   }
   function getNarrowableTypeForReference(type, reference, checkMode) {
-    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
+    const substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) && someType(type, isGenericTypeWithUnionConstraint) && (reference.flags & 8 /* Synthesized */ || isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
     return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type;
   }
   function isExportOrExportExpression(location) {
@@ -71225,7 +71419,7 @@ function createTypeChecker(host) {
   function getContextualTypeForBindingElement(declaration, contextFlags) {
     const parent2 = declaration.parent.parent;
     const name = declaration.propertyName || declaration.name;
-    const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */);
+    const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
     if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name))
       return void 0;
     if (parent2.name.kind === 206 /* ArrayBindingPattern */) {
@@ -71268,9 +71462,16 @@ function createTypeChecker(host) {
   function getContextualTypeForReturnExpression(node, contextFlags) {
     const func = getContainingFunction(node);
     if (func) {
+      const functionFlags = getFunctionFlags(func);
+      const links = getNodeLinks(node);
+      if (links.contextualReturnType) {
+        if (functionFlags & 2 /* Async */) {
+          return getUnionType([links.contextualReturnType, createPromiseLikeType(links.contextualReturnType)]);
+        }
+        return links.contextualReturnType;
+      }
       let contextualReturnType = getContextualReturnType(func, contextFlags);
       if (contextualReturnType) {
-        const functionFlags = getFunctionFlags(func);
         if (functionFlags & 1 /* Generator */) {
           const isAsyncGenerator = (functionFlags & 2 /* Async */) !== 0;
           if (contextualReturnType.flags & 1048576 /* Union */) {
@@ -71283,7 +71484,7 @@ function createTypeChecker(host) {
           contextualReturnType = iterationReturnType;
         }
         if (functionFlags & 2 /* Async */) {
-          const contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeNoAlias);
+          const contextualAwaitedType = getAwaitedTypeNoAlias(contextualReturnType);
           return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]);
         }
         return contextualReturnType;
@@ -72274,9 +72475,7 @@ function createTypeChecker(host) {
         elementTypes.push(undefinedOrMissingType);
         elementFlags.push(2 /* Optional */);
       } else {
-        const shouldAddAsIntraExpressionInferenceSite = inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(e);
-        const elementCheckMode = (checkMode || 0 /* Normal */) | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        const type = checkExpressionForMutableLocation(e, elementCheckMode, forceTuple);
+        const type = checkExpressionForMutableLocation(e, checkMode, forceTuple);
         elementTypes.push(addOptionality(
           type,
           /*isProperty*/
@@ -72284,7 +72483,7 @@ function createTypeChecker(host) {
           hasOmittedExpression
         ));
         elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
           const inferenceContext = getInferenceContext(node);
           Debug.assert(inferenceContext);
           addIntraExpressionInferenceSite(inferenceContext, e, type);
@@ -72425,13 +72624,11 @@ function createTypeChecker(host) {
       let member = getSymbolOfDeclaration(memberDecl);
       const computedNameType = memberDecl.name && memberDecl.name.kind === 166 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
       if (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 303 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
-        const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl);
-        const propCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, propCheckMode) : (
+        let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : (
           // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring
           // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`.
           // we don't want to say "could not find 'a'".
-          memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, propCheckMode) : checkObjectLiteralMethod(memberDecl, propCheckMode)
+          memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode)
         );
         if (isInJavascript) {
           const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
@@ -72475,7 +72672,7 @@ function createTypeChecker(host) {
         prop.links.target = member;
         member = prop;
         allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
           const inferenceContext = getInferenceContext(node);
           Debug.assert(inferenceContext);
           const inferenceNode = memberDecl.kind === 302 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
@@ -72648,9 +72845,7 @@ function createTypeChecker(host) {
     for (const attributeDecl of attributes.properties) {
       const member = attributeDecl.symbol;
       if (isJsxAttribute(attributeDecl)) {
-        const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(attributeDecl);
-        const attributeCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        const exprType = checkJsxAttribute(attributeDecl, attributeCheckMode);
+        const exprType = checkJsxAttribute(attributeDecl, checkMode);
         objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
         const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
         attributeSymbol.declarations = member.declarations;
@@ -72671,7 +72866,7 @@ function createTypeChecker(host) {
             addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
           }
         }
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) {
           const inferenceContext = getInferenceContext(attributes);
           Debug.assert(inferenceContext);
           const inferenceNode = attributeDecl.initializer.expression;
@@ -74289,7 +74484,7 @@ function createTypeChecker(host) {
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
-      if (arg.kind !== 231 /* OmittedExpression */ && !(checkMode & 64 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
+      if (arg.kind !== 231 /* OmittedExpression */ && !(checkMode & 32 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
@@ -74902,12 +75097,12 @@ function createTypeChecker(host) {
     const args = getEffectiveCallArguments(node);
     const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
     let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
-    argCheckMode |= checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
+    argCheckMode |= checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
     let candidatesForArgumentError;
     let candidateForArgumentArityError;
     let candidateForTypeArgumentError;
     let result;
-    const signatureHelpTrailingComma = !!(checkMode & 32 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
+    const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
     if (candidates.length > 1) {
       result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
     }
@@ -75126,7 +75321,7 @@ function createTypeChecker(host) {
           continue;
         }
         if (argCheckMode) {
-          argCheckMode = checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
+          argCheckMode = checkMode & 32 /* IsForStringLiteralArgumentCompletions */;
           if (inferenceContext) {
             const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
@@ -78204,7 +78399,7 @@ function createTypeChecker(host) {
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
       case 38 /* ExclamationEqualsEqualsToken */:
-        if (!(checkMode && checkMode & 256 /* TypeOnly */)) {
+        if (!(checkMode && checkMode & 128 /* TypeOnly */)) {
           if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
             const eqType = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
             error2(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
@@ -78863,7 +79058,7 @@ function createTypeChecker(host) {
       }
     }
     const startInvocationCount = flowInvocationCount;
-    const type = checkExpression(node, 256 /* TypeOnly */);
+    const type = checkExpression(node, 128 /* TypeOnly */);
     if (flowInvocationCount !== startInvocationCount) {
       const cache = flowTypeCache || (flowTypeCache = []);
       cache[getNodeId(node)] = type;
@@ -81334,7 +81529,7 @@ function createTypeChecker(host) {
         checkComputedPropertyName(node.propertyName);
       }
       const parent2 = node.parent.parent;
-      const parentCheckMode = node.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+      const parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
       const parentType = getTypeForBindingElementParent(parent2, parentCheckMode);
       const name = node.propertyName || node.name;
       if (parentType && !isBindingPattern(name)) {
@@ -82383,17 +82578,55 @@ function createTypeChecker(host) {
     const returnType = getReturnTypeOfSignature(signature);
     const functionFlags = getFunctionFlags(container);
     if (strictNullChecks || node.expression || returnType.flags & 131072 /* Never */) {
-      const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
       if (container.kind === 177 /* SetAccessor */) {
         if (node.expression) {
           error2(node, Diagnostics.Setters_cannot_return_a_value);
         }
       } else if (container.kind === 175 /* Constructor */) {
+        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
           error2(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
         }
       } else if (getReturnTypeFromAnnotation(container)) {
         const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
+        let actualReturnType = unwrappedReturnType;
+        const links = node.expression && getNodeLinks(node.expression);
+        if (links && !links.contextualReturnType) {
+          const outerTypeParameters = getOuterTypeParameters(
+            container,
+            /*includeThisTypes*/
+            false
+          );
+          const typeParameters = appendTypeParameters(outerTypeParameters, getEffectiveTypeParameterDeclarations(container));
+          const queryTypeParameters = typeParameters == null ? void 0 : typeParameters.filter(isQueryTypeParameter);
+          if (queryTypeParameters) {
+            const narrowMapper = createTypeMapper(queryTypeParameters, queryTypeParameters.map((tp) => {
+              const originalName = tp.exprName;
+              const fakeName = factory.cloneNode(originalName);
+              setParent(fakeName, node.parent);
+              setNodeFlags(fakeName, fakeName.flags | 8 /* Synthesized */);
+              fakeName.flowNode = node.flowNode;
+              const exprType2 = checkExpression(fakeName);
+              if (getConstraintOfTypeParameter(tp)) {
+                const narrowableConstraintType = mapType(tp.constraint, getBaseConstraintOrType);
+                if (narrowableConstraintType === exprType2) {
+                  return tp;
+                }
+              }
+              return exprType2;
+            }));
+            actualReturnType = instantiateNarrowType(
+              unwrappedReturnType,
+              narrowMapper,
+              /*mapper*/
+              void 0,
+              /*noTopLevel*/
+              true
+            );
+          }
+          links.contextualReturnType = actualReturnType;
+        }
+        const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
         const unwrappedExprType = functionFlags & 2 /* Async */ ? checkAwaitedType(
           exprType,
           /*withAlias*/
@@ -82401,14 +82634,57 @@ function createTypeChecker(host) {
           node,
           Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
         ) : exprType;
-        if (unwrappedReturnType) {
-          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
+        if (actualReturnType) {
+          checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, actualReturnType, node, node.expression);
         }
       }
     } else if (container.kind !== 175 /* Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
       error2(node, Diagnostics.Not_all_code_paths_return_a_value);
     }
   }
+  function isQueryTypeParameter(typeParameter) {
+    if (typeParameter.exprName) {
+      return true;
+    }
+    if (isThisTypeParameter(typeParameter)) {
+      return false;
+    }
+    if (!typeParameter.symbol) {
+      return false;
+    }
+    const declaration = getDeclarationOfKind(typeParameter.symbol, 167 /* TypeParameter */);
+    const owner = getTypeParameterOwner(declaration);
+    if (!owner || !isFunctionLikeDeclaration(owner)) {
+      return false;
+    }
+    const references = [];
+    owner.parameters.forEach((parameter) => forEachChild(parameter, collectReferences));
+    if (references.length === 1) {
+      const reference = references[0];
+      let exprName;
+      if (isParameter(reference.parent) && reference.parent.parent === owner && (exprName = getNameOfDeclaration(reference.parent))) {
+        typeParameter.exprName = exprName;
+        return true;
+      }
+    }
+    return false;
+    function collectReferences(node) {
+      if (isFunctionLikeDeclaration(node.parent) && node === node.parent.body) {
+        return;
+      }
+      if (isNodeDescendantOf(node, owner.type)) {
+        return;
+      }
+      if (isTypeReferenceNode(node)) {
+        const type = getTypeFromTypeNode(node);
+        if (type.flags & 262144 /* TypeParameter */ && isTypeIdenticalTo(type, typeParameter)) {
+          references.push(node);
+        }
+        return;
+      }
+      forEachChild(node, collectReferences);
+    }
+  }
   function checkWithStatement(node) {
     if (!checkGrammarStatementInAmbientContext(node)) {
       if (node.flags & 32768 /* AwaitContext */) {