@typescript-deploys/pr-build 5.3.0-pr-55459-3 → 5.3.0-pr-55476-8

package/lib/tsserver.js

@@ -2333,7 +2333,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-insiders.20230822`;
+var version = `${versionMajorMinor}.0-insiders.20230823`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -15541,8 +15541,8 @@ function getInternalEmitFlags(node) {
   const emitNode = node.emitNode;
   return emitNode && emitNode.internalFlags || 0;
 }
-function getScriptTargetFeatures() {
-  return new Map(Object.entries({
+var getScriptTargetFeatures = /* @__PURE__ */ memoize(
+  () => new Map(Object.entries({
     Array: new Map(Object.entries({
       es2015: [
         "find",
@@ -15935,8 +15935,8 @@ function getScriptTargetFeatures() {
         "cause"
       ]
     }))
-  }));
-}
+  }))
+);
 var GetLiteralTextFlags = /* @__PURE__ */ ((GetLiteralTextFlags2) => {
   GetLiteralTextFlags2[GetLiteralTextFlags2["None"] = 0] = "None";
   GetLiteralTextFlags2[GetLiteralTextFlags2["NeverAsciiEscape"] = 1] = "NeverAsciiEscape";
@@ -53338,11 +53338,17 @@ function createTypeChecker(host) {
       const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
       return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
     }
-    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
-      let parameterDeclaration = getDeclarationOfKind(parameterSymbol, 169 /* Parameter */);
-      if (!parameterDeclaration && !isTransientSymbol(parameterSymbol)) {
-        parameterDeclaration = getDeclarationOfKind(parameterSymbol, 348 /* JSDocParameterTag */);
+    function getEffectiveParameterDeclaration(parameterSymbol) {
+      const parameterDeclaration = getDeclarationOfKind(parameterSymbol, 169 /* Parameter */);
+      if (parameterDeclaration) {
+        return parameterDeclaration;
       }
+      if (!isTransientSymbol(parameterSymbol)) {
+        return getDeclarationOfKind(parameterSymbol, 348 /* JSDocParameterTag */);
+      }
+    }
+    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+      const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       let parameterType = getTypeOfSymbol(parameterSymbol);
       if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
         parameterType = getOptionalType(parameterType);
@@ -53351,7 +53357,7 @@ function createTypeChecker(host) {
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
-      const name = parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 80 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 16777216 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 166 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 16777216 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
+      const name = parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context);
       const isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 16384 /* OptionalParameter */;
       const questionToken = isOptional ? factory.createToken(58 /* QuestionToken */) : void 0;
       const parameterNode = factory.createParameterDeclaration(
@@ -53365,6 +53371,9 @@ function createTypeChecker(host) {
       );
       context.approximateLength += symbolName(parameterSymbol).length + 3;
       return parameterNode;
+    }
+    function parameterToParameterDeclarationName(parameterSymbol, parameterDeclaration, context) {
+      return parameterDeclaration ? parameterDeclaration.name ? parameterDeclaration.name.kind === 80 /* Identifier */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name), 16777216 /* NoAsciiEscaping */) : parameterDeclaration.name.kind === 166 /* QualifiedName */ ? setEmitFlags(factory.cloneNode(parameterDeclaration.name.right), 16777216 /* NoAsciiEscaping */) : cloneBindingName(parameterDeclaration.name) : symbolName(parameterSymbol) : symbolName(parameterSymbol);
       function cloneBindingName(node) {
         return elideInitializerAndSetEmitFlags(node);
         function elideInitializerAndSetEmitFlags(node2) {
@@ -55345,6 +55354,21 @@ function createTypeChecker(host) {
           if (p.flags & 98304 /* Accessor */ && useAccessors) {
             const result = [];
             if (p.flags & 65536 /* SetAccessor */) {
+              const setter = p.declarations && forEach(p.declarations, (d) => {
+                if (d.kind === 178 /* SetAccessor */) {
+                  return d;
+                }
+                if (isCallExpression(d) && isBindableObjectDefinePropertyCall(d)) {
+                  return forEach(d.arguments[2].properties, (propDecl) => {
+                    const id = getNameOfDeclaration(propDecl);
+                    if (!!id && isIdentifier(id) && idText(id) === "set") {
+                      return propDecl;
+                    }
+                  });
+                }
+              });
+              Debug.assert(setter && isFunctionLikeDeclaration(setter));
+              const paramSymbol = getSignatureFromDeclaration(setter).parameters[0];
               result.push(setTextRange(
                 factory.createSetAccessorDeclaration(
                   factory.createModifiersFromModifierFlags(flag),
@@ -55354,7 +55378,7 @@ function createTypeChecker(host) {
                     void 0,
                     /*dotDotDotToken*/
                     void 0,
-                    "arg",
+                    paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
                     isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
@@ -56120,7 +56144,7 @@ function createTypeChecker(host) {
     const pattern = declaration.parent;
     if (strictNullChecks && declaration.flags & 33554432 /* Ambient */ && isParameterDeclaration(declaration)) {
       parentType = getNonNullableType(parentType);
-    } else if (strictNullChecks && pattern.parent.initializer && !hasTypeFacts(getTypeOfInitializer(pattern.parent.initializer), 65536 /* EQUndefined */)) {
+    } else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* EQUndefined */)) {
       parentType = getTypeWithFacts(parentType, 524288 /* NEUndefined */);
     }
     let type;
@@ -56163,7 +56187,7 @@ function createTypeChecker(host) {
       return type;
     }
     if (getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration))) {
-      return strictNullChecks && !hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
+      return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
     }
     return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
   }
@@ -64271,7 +64295,7 @@ function createTypeChecker(host) {
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
-        const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && getOnlyTypeFacts(sourceType, 50331648 /* IsUndefinedOrNull */) === getOnlyTypeFacts(targetType, 50331648 /* IsUndefinedOrNull */);
+        const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
         let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(
           sourceType,
           targetType,
@@ -67428,7 +67452,7 @@ function createTypeChecker(host) {
     return value.base10Value === "0";
   }
   function removeDefinitelyFalsyTypes(type) {
-    return filterType(type, (t) => hasTypeFacts(t, 4194304 /* Truthy */));
+    return filterType(type, (t) => !!(getTypeFacts(t) & 4194304 /* Truthy */));
   }
   function extractDefinitelyFalsyTypes(type) {
     return mapType(type, getDefinitelyFalsyPartOfType);
@@ -68704,12 +68728,14 @@ function createTypeChecker(host) {
     }
     function inferFromSignatures(source, target, kind) {
       const sourceSignatures = getSignaturesOfType(source, kind);
-      const targetSignatures = getSignaturesOfType(target, kind);
       const sourceLen = sourceSignatures.length;
-      const targetLen = targetSignatures.length;
-      const len = sourceLen < targetLen ? sourceLen : targetLen;
-      for (let i = 0; i < len; i++) {
-        inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+      if (sourceLen > 0) {
+        const targetSignatures = getSignaturesOfType(target, kind);
+        const targetLen = targetSignatures.length;
+        for (let i = 0; i < targetLen; i++) {
+          const sourceIndex = Math.max(sourceLen - targetLen + i, 0);
+          inferFromSignature(getBaseSignature(sourceSignatures[sourceIndex]), getErasedSignature(targetSignatures[i]));
+        }
       }
     }
     function inferFromSignature(source, target) {
@@ -69171,13 +69197,7 @@ function createTypeChecker(host) {
     const resolved = resolveStructuredTypeMembers(type);
     return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
   }
-  function getOnlyTypeFacts(type, mask2) {
-    return getTypeFactsWorker(type, mask2) & mask2;
-  }
-  function hasTypeFacts(type, mask2) {
-    return getOnlyTypeFacts(type, mask2) !== 0;
-  }
-  function getTypeFactsWorker(type, callerOnlyNeeds) {
+  function getTypeFacts(type) {
     if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
       type = getBaseConstraintOfType(type) || unknownType;
     }
@@ -69210,10 +69230,6 @@ function createTypeChecker(host) {
       return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
     }
     if (flags & 524288 /* Object */) {
-      const possibleFacts = strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ | 7880640 /* FunctionStrictFacts */ | 7888800 /* ObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ | 16728e3 /* FunctionFacts */ | 16736160 /* ObjectFacts */;
-      if ((callerOnlyNeeds & possibleFacts) === 0) {
-        return 0;
-      }
       return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
     }
     if (flags & 16384 /* Void */) {
@@ -69235,20 +69251,20 @@ function createTypeChecker(host) {
       return 0 /* None */;
     }
     if (flags & 1048576 /* Union */) {
-      return reduceLeft(type.types, (facts, t) => facts | getTypeFactsWorker(t, callerOnlyNeeds), 0 /* None */);
+      return reduceLeft(type.types, (facts, t) => facts | getTypeFacts(t), 0 /* None */);
     }
     if (flags & 2097152 /* Intersection */) {
-      return getIntersectionTypeFacts(type, callerOnlyNeeds);
+      return getIntersectionTypeFacts(type);
     }
     return 83886079 /* UnknownFacts */;
   }
-  function getIntersectionTypeFacts(type, callerOnlyNeeds) {
+  function getIntersectionTypeFacts(type) {
     const ignoreObjects = maybeTypeOfKind(type, 402784252 /* Primitive */);
     let oredFacts = 0 /* None */;
     let andedFacts = 134217727 /* All */;
     for (const t of type.types) {
       if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
-        const f = getTypeFactsWorker(t, callerOnlyNeeds);
+        const f = getTypeFacts(t);
         oredFacts |= f;
         andedFacts &= f;
       }
@@ -69256,19 +69272,19 @@ function createTypeChecker(host) {
     return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
   }
   function getTypeWithFacts(type, include) {
-    return filterType(type, (t) => hasTypeFacts(t, include));
+    return filterType(type, (t) => (getTypeFacts(t) & include) !== 0);
   }
   function getAdjustedTypeWithFacts(type, facts) {
     const reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
     if (strictNullChecks) {
       switch (facts) {
         case 524288 /* NEUndefined */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 65536 /* EQUndefined */) ? getIntersectionType([t, hasTypeFacts(t, 131072 /* EQNull */) && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
+          return mapType(reduced, (t) => getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
         case 1048576 /* NENull */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 131072 /* EQNull */) ? getIntersectionType([t, hasTypeFacts(t, 65536 /* EQUndefined */) && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
+          return mapType(reduced, (t) => getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
         case 2097152 /* NEUndefinedOrNull */:
         case 4194304 /* Truthy */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 262144 /* EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(t) : t);
+          return mapType(reduced, (t) => getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t);
       }
     }
     return reduced;
@@ -70255,7 +70271,7 @@ function createTypeChecker(host) {
       return void 0;
     }
     function getDiscriminantPropertyAccess(expr, computedType) {
-      const type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
+      const type = !(computedType.flags & 1048576 /* Union */) && declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
       if (type.flags & 1048576 /* Union */) {
         const access = getCandidateDiscriminantPropertyAccess(expr);
         if (access) {
@@ -70605,14 +70621,14 @@ function createTypeChecker(host) {
         // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
         // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
         // but are classified as "function" according to `typeof`.
-        isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? hasTypeFacts(t, facts) ? t : neverType : (
+        isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
           // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
           // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
           isTypeSubtypeOf(impliedType, t) ? impliedType : (
             // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
             // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
             // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-            hasTypeFacts(t, facts) ? getIntersectionType([t, impliedType]) : neverType
+            getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
           )
         )
       ));
@@ -70626,7 +70642,7 @@ function createTypeChecker(host) {
       const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
       if (hasDefaultClause) {
         const notEqualFacts = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
-        return filterType(type, (t) => getOnlyTypeFacts(t, notEqualFacts) === notEqualFacts);
+        return filterType(type, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
       }
       const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
       return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
@@ -70764,7 +70780,7 @@ function createTypeChecker(host) {
               false
             );
           }
-          if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !hasTypeFacts(predicate.type, 65536 /* EQUndefined */)) {
+          if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
             type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
           }
           const access = getDiscriminantPropertyAccess(predicateArgument, type);
@@ -70898,7 +70914,7 @@ function createTypeChecker(host) {
         reportCircularityError(declaration.symbol);
         return true;
       }
-      const containsUndefined = !!hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */);
+      const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
       if (!popTypeResolution()) {
         reportCircularityError(declaration.symbol);
         return true;
@@ -70908,7 +70924,7 @@ function createTypeChecker(host) {
     return links.parameterInitializerContainsUndefined;
   }
   function removeOptionalityFromDeclaredType(declaredType, declaration) {
-    const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && hasTypeFacts(declaredType, 16777216 /* IsUndefined */) && !parameterInitializerContainsUndefined(declaration);
+    const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
     return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
   }
   function isConstraintPosition(type, node) {
@@ -73738,7 +73754,7 @@ function createTypeChecker(host) {
     return checkNonNullType(checkExpression(node), node);
   }
   function isNullableType(type) {
-    return hasTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
+    return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
   }
   function getNonNullableTypeIfNeeded(type) {
     return isNullableType(type) ? getNonNullableType(type) : type;
@@ -73784,7 +73800,7 @@ function createTypeChecker(host) {
       error2(node, Diagnostics.Object_is_of_type_unknown);
       return errorType;
     }
-    const facts = getOnlyTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
+    const facts = getTypeFacts(type);
     if (facts & 50331648 /* IsUndefinedOrNull */) {
       reportError(node, facts);
       const t = getNonNullableType(type);
@@ -77564,7 +77580,7 @@ function createTypeChecker(host) {
       if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
         return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
       }
-      return !someType(operandConstraint, (t) => getOnlyTypeFacts(t, notEqualFacts) === notEqualFacts);
+      return !someType(operandConstraint, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
     }
     const type = checkExpressionCached(node.expression);
     if (!isLiteralType(type)) {
@@ -77889,7 +77905,7 @@ function createTypeChecker(host) {
   }
   function checkDeleteExpressionMustBeOptional(expr, symbol) {
     const type = getTypeOfSymbol(symbol);
-    if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : hasTypeFacts(type, 16777216 /* IsUndefined */))) {
+    if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
       error2(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
     }
   }
@@ -78024,7 +78040,7 @@ function createTypeChecker(host) {
         return getUnaryResultType(operandType);
       case 54 /* ExclamationToken */:
         checkTruthinessOfType(operandType, node.operand);
-        const facts = getOnlyTypeFacts(operandType, 4194304 /* Truthy */ | 8388608 /* Falsy */);
+        const facts = getTypeFacts(operandType) & (4194304 /* Truthy */ | 8388608 /* Falsy */);
         return facts === 4194304 /* Truthy */ ? falseType : facts === 8388608 /* Falsy */ ? trueType : booleanType;
       case 46 /* PlusPlusToken */:
       case 47 /* MinusMinusToken */:
@@ -78255,7 +78271,7 @@ function createTypeChecker(host) {
     if (exprOrAssignment.kind === 304 /* ShorthandPropertyAssignment */) {
       const prop = exprOrAssignment;
       if (prop.objectAssignmentInitializer) {
-        if (strictNullChecks && !hasTypeFacts(checkExpression(prop.objectAssignmentInitializer), 16777216 /* IsUndefined */)) {
+        if (strictNullChecks && !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
           sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
         }
         checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
@@ -78667,7 +78683,7 @@ function createTypeChecker(host) {
         return checkInExpression(left, right, leftType, rightType);
       case 56 /* AmpersandAmpersandToken */:
       case 77 /* AmpersandAmpersandEqualsToken */: {
-        const resultType2 = hasTypeFacts(leftType, 4194304 /* Truthy */) ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
+        const resultType2 = getTypeFacts(leftType) & 4194304 /* Truthy */ ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
         if (operator === 77 /* AmpersandAmpersandEqualsToken */) {
           checkAssignmentOperator(rightType);
         }
@@ -78675,7 +78691,7 @@ function createTypeChecker(host) {
       }
       case 57 /* BarBarToken */:
       case 76 /* BarBarEqualsToken */: {
-        const resultType2 = hasTypeFacts(leftType, 8388608 /* Falsy */) ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
+        const resultType2 = getTypeFacts(leftType) & 8388608 /* Falsy */ ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
         if (operator === 76 /* BarBarEqualsToken */) {
           checkAssignmentOperator(rightType);
         }
@@ -78683,7 +78699,7 @@ function createTypeChecker(host) {
       }
       case 61 /* QuestionQuestionToken */:
       case 78 /* QuestionQuestionEqualsToken */: {
-        const resultType2 = hasTypeFacts(leftType, 262144 /* EQUndefinedOrNull */) ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
+        const resultType2 = getTypeFacts(leftType) & 262144 /* EQUndefinedOrNull */ ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
         if (operator === 78 /* QuestionQuestionEqualsToken */) {
           checkAssignmentOperator(rightType);
         }
@@ -82000,7 +82016,7 @@ function createTypeChecker(host) {
       }
       const type = location === condExpr2 ? condType : checkTruthinessExpression(location);
       const isPropertyExpressionCast = isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
-      if (!hasTypeFacts(type, 4194304 /* Truthy */) || isPropertyExpressionCast)
+      if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
         return;
       const callSignatures = getSignaturesOfType(type, 0 /* Call */);
       const isPromise = !!getAwaitedTypeOfPromise(type);
@@ -164652,11 +164668,11 @@ function provideInlayHints(context) {
   function isSignatureSupportingReturnAnnotation(node) {
     return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
   }
-  function addParameterHints(text, parameter, position, isFirstVariadicArgument, sourceFile) {
+  function addParameterHints(text, parameter, position, isFirstVariadicArgument) {
     let hintText = `${isFirstVariadicArgument ? "..." : ""}${text}`;
     let displayParts;
     if (shouldUseInteractiveInlayHints(preferences)) {
-      displayParts = [getNodeDisplayPart(hintText, parameter, sourceFile), { text: ":" }];
+      displayParts = [getNodeDisplayPart(hintText, parameter), { text: ":" }];
       hintText = "";
     } else {
       hintText += ":";
@@ -164728,7 +164744,6 @@ function provideInlayHints(context) {
     if (!signature || !candidates.length) {
       return;
     }
-    const sourceFile = shouldUseInteractiveInlayHints(preferences) ? expr.getSourceFile() : void 0;
     let signatureParamPos = 0;
     for (const originalArg of args) {
       const arg = skipParentheses(originalArg);
@@ -164763,7 +164778,7 @@ function provideInlayHints(context) {
         if (leadingCommentsContainsParameterName(arg, name)) {
           continue;
         }
-        addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
+        addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument);
       }
     }
   }
@@ -164899,7 +164914,8 @@ function provideInlayHints(context) {
     }
     return true;
   }
-  function getNodeDisplayPart(text, node, sourceFile) {
+  function getNodeDisplayPart(text, node) {
+    const sourceFile = node.getSourceFile();
     return {
       text,
       span: createTextSpanFromNode(node, sourceFile),
@@ -183585,14 +183601,22 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
       return {
         ...hint,
         position: scriptInfo.positionToLineOffset(position),
-        displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => ({
-          text,
-          span: span && {
-            start: scriptInfo.positionToLineOffset(span.start),
-            end: scriptInfo.positionToLineOffset(span.start + span.length),
-            file: file2
+        displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => {
+          if (span) {
+            Debug.assertIsDefined(file2, "Target file should be defined together with its span.");
+            const scriptInfo2 = this.projectService.getScriptInfo(file2);
+            return {
+              text,
+              span: {
+                start: scriptInfo2.positionToLineOffset(span.start),
+                end: scriptInfo2.positionToLineOffset(span.start + span.length),
+                file: file2
+              }
+            };
+          } else {
+            return { text };
           }
-        }))
+        })
       };
     });
   }