@typescript-deploys/pr-build 5.5.0-pr-57480-2 → 5.5.0-pr-57465-44

package/lib/tsc.js

@@ -56016,7 +56016,15 @@ function createTypeChecker(host) {
             jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
           }
         }
-        signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+        if (type || jsdocPredicate) {
+          signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
+          const { declaration } = signature;
+          signature.resolvedTypePredicate = noTypePredicate;
+          signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+        } else {
+          signature.resolvedTypePredicate = noTypePredicate;
+        }
       }
       Debug.assert(!!signature.resolvedTypePredicate);
     }
@@ -74425,6 +74433,109 @@ function createTypeChecker(host) {
         return false;
     }
   }
+  function getTypePredicateFromBody(func) {
+    switch (func.kind) {
+      case 176 /* Constructor */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+        return void 0;
+    }
+    const functionFlags = getFunctionFlags(func);
+    if (functionFlags !== 0 /* Normal */ || func.parameters.length === 0)
+      return void 0;
+    let singleReturn;
+    if (func.body && func.body.kind !== 241 /* Block */) {
+      singleReturn = func.body;
+    } else {
+      if (functionHasImplicitReturn(func))
+        return void 0;
+      const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+        if (singleReturn || !returnStatement.expression)
+          return true;
+        singleReturn = returnStatement.expression;
+      });
+      if (bailedEarly || !singleReturn)
+        return void 0;
+    }
+    if (isTriviallyNonBoolean(singleReturn))
+      return void 0;
+    const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
+    if (predicate) {
+      const [i, type] = predicate;
+      const param = func.parameters[i];
+      if (isIdentifier(param.name)) {
+        return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
+      }
+    }
+    return void 0;
+    function checkIfExpressionRefinesAnyParameter(expr) {
+      expr = skipParentheses(
+        expr,
+        /*excludeJSDocTypeAssertions*/
+        true
+      );
+      const type = checkExpressionCached(expr, 64 /* TypeOnly */);
+      if (type !== booleanType || !func.body)
+        return void 0;
+      return forEach(func.parameters, (param, i) => {
+        const initType = getSymbolLinks(param.symbol).type;
+        if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
+          return;
+        }
+        const trueType2 = checkIfExpressionRefinesParameter(
+          expr,
+          param,
+          initType,
+          /*forceFullCheck*/
+          false
+        );
+        if (trueType2) {
+          const trueSubtype = checkIfExpressionRefinesParameter(
+            expr,
+            param,
+            trueType2,
+            /*forceFullCheck*/
+            true
+          );
+          if (trueSubtype) {
+            return [i, trueType2];
+          }
+        }
+      });
+    }
+    function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
+      const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
+      const trueCondition = {
+        flags: 32 /* TrueCondition */,
+        node: expr,
+        antecedent
+      };
+      const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
+      if (trueType2 === initType && !forceFullCheck)
+        return void 0;
+      const falseCondition = {
+        ...trueCondition,
+        flags: 64 /* FalseCondition */
+      };
+      const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
+      const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
+      if (isTypeIdenticalTo(candidateFalse, falseType2)) {
+        return trueType2;
+      }
+    }
+    function isTriviallyNonBoolean(expr) {
+      if (isLiteralExpression(expr) || isLiteralExpressionOfObject(expr)) {
+        return true;
+      }
+      if (isIdentifier(expr)) {
+        const sym = getResolvedSymbol(expr);
+        if (sym.flags & (32 /* Class */ | 4096 /* ObjectLiteral */ | 16 /* Function */ | 384 /* Enum */ | 8 /* EnumMember */)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
     addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
     return;

package/lib/tsserver.js

@@ -60761,7 +60761,15 @@ function createTypeChecker(host) {
             jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
           }
         }
-        signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+        if (type || jsdocPredicate) {
+          signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
+          const { declaration } = signature;
+          signature.resolvedTypePredicate = noTypePredicate;
+          signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+        } else {
+          signature.resolvedTypePredicate = noTypePredicate;
+        }
       }
       Debug.assert(!!signature.resolvedTypePredicate);
     }
@@ -79170,6 +79178,109 @@ function createTypeChecker(host) {
         return false;
     }
   }
+  function getTypePredicateFromBody(func) {
+    switch (func.kind) {
+      case 176 /* Constructor */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+        return void 0;
+    }
+    const functionFlags = getFunctionFlags(func);
+    if (functionFlags !== 0 /* Normal */ || func.parameters.length === 0)
+      return void 0;
+    let singleReturn;
+    if (func.body && func.body.kind !== 241 /* Block */) {
+      singleReturn = func.body;
+    } else {
+      if (functionHasImplicitReturn(func))
+        return void 0;
+      const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+        if (singleReturn || !returnStatement.expression)
+          return true;
+        singleReturn = returnStatement.expression;
+      });
+      if (bailedEarly || !singleReturn)
+        return void 0;
+    }
+    if (isTriviallyNonBoolean(singleReturn))
+      return void 0;
+    const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
+    if (predicate) {
+      const [i, type] = predicate;
+      const param = func.parameters[i];
+      if (isIdentifier(param.name)) {
+        return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
+      }
+    }
+    return void 0;
+    function checkIfExpressionRefinesAnyParameter(expr) {
+      expr = skipParentheses(
+        expr,
+        /*excludeJSDocTypeAssertions*/
+        true
+      );
+      const type = checkExpressionCached(expr, 64 /* TypeOnly */);
+      if (type !== booleanType || !func.body)
+        return void 0;
+      return forEach(func.parameters, (param, i) => {
+        const initType = getSymbolLinks(param.symbol).type;
+        if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
+          return;
+        }
+        const trueType2 = checkIfExpressionRefinesParameter(
+          expr,
+          param,
+          initType,
+          /*forceFullCheck*/
+          false
+        );
+        if (trueType2) {
+          const trueSubtype = checkIfExpressionRefinesParameter(
+            expr,
+            param,
+            trueType2,
+            /*forceFullCheck*/
+            true
+          );
+          if (trueSubtype) {
+            return [i, trueType2];
+          }
+        }
+      });
+    }
+    function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
+      const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
+      const trueCondition = {
+        flags: 32 /* TrueCondition */,
+        node: expr,
+        antecedent
+      };
+      const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
+      if (trueType2 === initType && !forceFullCheck)
+        return void 0;
+      const falseCondition = {
+        ...trueCondition,
+        flags: 64 /* FalseCondition */
+      };
+      const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
+      const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
+      if (isTypeIdenticalTo(candidateFalse, falseType2)) {
+        return trueType2;
+      }
+    }
+    function isTriviallyNonBoolean(expr) {
+      if (isLiteralExpression(expr) || isLiteralExpressionOfObject(expr)) {
+        return true;
+      }
+      if (isIdentifier(expr)) {
+        const sym = getResolvedSymbol(expr);
+        if (sym.flags & (32 /* Class */ | 4096 /* ObjectLiteral */ | 16 /* Function */ | 384 /* Enum */ | 8 /* EnumMember */)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
     addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
     return;
@@ -159781,7 +159892,7 @@ function createCompletionEntry(symbol, sortText, replacementToken, contextToken,
     let importAdder;
     const memberCompletionEntry = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, position, contextToken, formatContext);
     if (memberCompletionEntry) {
-      ({ insertText, filterText, isSnippet, importAdder, replacementSpan } = memberCompletionEntry);
+      ({ insertText, filterText, isSnippet, importAdder } = memberCompletionEntry);
       if (importAdder == null ? void 0 : importAdder.hasFixes()) {
         hasAction = true;
         source = "ClassMemberSnippet/" /* ClassMemberSnippet */;
@@ -159969,7 +160080,7 @@ function getEntryForMemberCompletion(host, program, options, preferences, name,
       );
     }
   }
-  return { insertText, filterText, isSnippet, importAdder, replacementSpan: eraseRange && createTextSpanFromBounds(eraseRange.pos, eraseRange.end) };
+  return { insertText, filterText, isSnippet, importAdder, eraseRange };
 }
 function getPresentModifiers(contextToken, sourceFile, position) {
   if (!contextToken || getLineAndCharacterOfPosition(sourceFile, position).line > getLineAndCharacterOfPosition(sourceFile, contextToken.getEnd()).line) {
@@ -160621,7 +160732,7 @@ function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextTo
     }
   }
   if (source === "ClassMemberSnippet/" /* ClassMemberSnippet */) {
-    const { importAdder, replacementSpan } = getEntryForMemberCompletion(
+    const { importAdder, eraseRange } = getEntryForMemberCompletion(
       host,
       program,
       compilerOptions,
@@ -160633,15 +160744,15 @@ function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextTo
       contextToken,
       formatContext
     );
-    if (importAdder || replacementSpan) {
+    if (importAdder || eraseRange) {
       const changes = ts_textChanges_exports.ChangeTracker.with(
         { host, formatContext, preferences },
         (tracker) => {
           if (importAdder) {
             importAdder.writeFixes(tracker);
           }
-          if (replacementSpan) {
-            tracker.deleteRange(sourceFile, { pos: replacementSpan.start, end: replacementSpan.start + replacementSpan.length });
+          if (eraseRange) {
+            tracker.deleteRange(sourceFile, eraseRange);
           }
         }
       );

package/lib/typescript.js

@@ -58515,7 +58515,15 @@ ${lanes.join("\n")}
               jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
             }
           }
-          signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+          if (type || jsdocPredicate) {
+            signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+          } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType === booleanType)) {
+            const { declaration } = signature;
+            signature.resolvedTypePredicate = noTypePredicate;
+            signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+          } else {
+            signature.resolvedTypePredicate = noTypePredicate;
+          }
         }
         Debug.assert(!!signature.resolvedTypePredicate);
       }
@@ -76924,6 +76932,109 @@ ${lanes.join("\n")}
           return false;
       }
     }
+    function getTypePredicateFromBody(func) {
+      switch (func.kind) {
+        case 176 /* Constructor */:
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+          return void 0;
+      }
+      const functionFlags = getFunctionFlags(func);
+      if (functionFlags !== 0 /* Normal */ || func.parameters.length === 0)
+        return void 0;
+      let singleReturn;
+      if (func.body && func.body.kind !== 241 /* Block */) {
+        singleReturn = func.body;
+      } else {
+        if (functionHasImplicitReturn(func))
+          return void 0;
+        const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+          if (singleReturn || !returnStatement.expression)
+            return true;
+          singleReturn = returnStatement.expression;
+        });
+        if (bailedEarly || !singleReturn)
+          return void 0;
+      }
+      if (isTriviallyNonBoolean(singleReturn))
+        return void 0;
+      const predicate = checkIfExpressionRefinesAnyParameter(singleReturn);
+      if (predicate) {
+        const [i, type] = predicate;
+        const param = func.parameters[i];
+        if (isIdentifier(param.name)) {
+          return createTypePredicate(1 /* Identifier */, param.name.escapedText, i, type);
+        }
+      }
+      return void 0;
+      function checkIfExpressionRefinesAnyParameter(expr) {
+        expr = skipParentheses(
+          expr,
+          /*excludeJSDocTypeAssertions*/
+          true
+        );
+        const type = checkExpressionCached(expr, 64 /* TypeOnly */);
+        if (type !== booleanType || !func.body)
+          return void 0;
+        return forEach(func.parameters, (param, i) => {
+          const initType = getSymbolLinks(param.symbol).type;
+          if (!initType || initType === booleanType || isSymbolAssigned(param.symbol)) {
+            return;
+          }
+          const trueType2 = checkIfExpressionRefinesParameter(
+            expr,
+            param,
+            initType,
+            /*forceFullCheck*/
+            false
+          );
+          if (trueType2) {
+            const trueSubtype = checkIfExpressionRefinesParameter(
+              expr,
+              param,
+              trueType2,
+              /*forceFullCheck*/
+              true
+            );
+            if (trueSubtype) {
+              return [i, trueType2];
+            }
+          }
+        });
+      }
+      function checkIfExpressionRefinesParameter(expr, param, initType, forceFullCheck) {
+        const antecedent = expr.flowNode ?? { flags: 2 /* Start */ };
+        const trueCondition = {
+          flags: 32 /* TrueCondition */,
+          node: expr,
+          antecedent
+        };
+        const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
+        if (trueType2 === initType && !forceFullCheck)
+          return void 0;
+        const falseCondition = {
+          ...trueCondition,
+          flags: 64 /* FalseCondition */
+        };
+        const falseType2 = getFlowTypeOfReference(param.name, initType, initType, func, falseCondition);
+        const candidateFalse = filterType(initType, (t) => !isTypeSubtypeOf(t, trueType2));
+        if (isTypeIdenticalTo(candidateFalse, falseType2)) {
+          return trueType2;
+        }
+      }
+      function isTriviallyNonBoolean(expr) {
+        if (isLiteralExpression(expr) || isLiteralExpressionOfObject(expr)) {
+          return true;
+        }
+        if (isIdentifier(expr)) {
+          const sym = getResolvedSymbol(expr);
+          if (sym.flags & (32 /* Class */ | 4096 /* ObjectLiteral */ | 16 /* Function */ | 384 /* Enum */ | 8 /* EnumMember */)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }
     function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
       addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
       return;
@@ -159003,7 +159114,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       let importAdder;
       const memberCompletionEntry = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, position, contextToken, formatContext);
       if (memberCompletionEntry) {
-        ({ insertText, filterText, isSnippet, importAdder, replacementSpan } = memberCompletionEntry);
+        ({ insertText, filterText, isSnippet, importAdder } = memberCompletionEntry);
         if (importAdder == null ? void 0 : importAdder.hasFixes()) {
           hasAction = true;
           source = "ClassMemberSnippet/" /* ClassMemberSnippet */;
@@ -159191,7 +159302,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         );
       }
     }
-    return { insertText, filterText, isSnippet, importAdder, replacementSpan: eraseRange && createTextSpanFromBounds(eraseRange.pos, eraseRange.end) };
+    return { insertText, filterText, isSnippet, importAdder, eraseRange };
   }
   function getPresentModifiers(contextToken, sourceFile, position) {
     if (!contextToken || getLineAndCharacterOfPosition(sourceFile, position).line > getLineAndCharacterOfPosition(sourceFile, contextToken.getEnd()).line) {
@@ -159843,7 +159954,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
     }
     if (source === "ClassMemberSnippet/" /* ClassMemberSnippet */) {
-      const { importAdder, replacementSpan } = getEntryForMemberCompletion(
+      const { importAdder, eraseRange } = getEntryForMemberCompletion(
         host,
         program,
         compilerOptions,
@@ -159855,15 +159966,15 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         contextToken,
         formatContext
       );
-      if (importAdder || replacementSpan) {
+      if (importAdder || eraseRange) {
         const changes = ts_textChanges_exports.ChangeTracker.with(
           { host, formatContext, preferences },
           (tracker) => {
             if (importAdder) {
               importAdder.writeFixes(tracker);
             }
-            if (replacementSpan) {
-              tracker.deleteRange(sourceFile, { pos: replacementSpan.start, end: replacementSpan.start + replacementSpan.length });
+            if (eraseRange) {
+              tracker.deleteRange(sourceFile, eraseRange);
             }
           }
         );

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.5.0-pr-57480-2",
+  "version": "5.5.0-pr-57465-44",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -114,5 +114,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "f882d281482b734527fece6d31cfff99a8813730"
+  "gitHead": "38a3acfa5adb621582815eb125e8f5d5ebb602cf"
 }