typescript 5.6.0-dev.20240726 → 5.6.0-dev.20240728

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240726`;
+var version = `${versionMajorMinor}.0-dev.20240728`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -45471,6 +45471,7 @@ function createTypeChecker(host) {
     getNonOptionalType: removeOptionalTypeMarker,
     getTypeArguments,
     typeToTypeNode: nodeBuilder.typeToTypeNode,
+    typePredicateToTypePredicateNode: nodeBuilder.typePredicateToTypePredicateNode,
     indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration,
     signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration,
     symbolToEntityName: nodeBuilder.symbolToEntityName,
@@ -67789,6 +67790,9 @@ function createTypeChecker(host) {
     return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
   }
   function isFunctionObjectType(type) {
+    if (getObjectFlags(type) & 256 /* EvolvingArray */) {
+      return false;
+    }
     const resolved = resolveStructuredTypeMembers(type);
     return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
   }
@@ -103607,7 +103611,7 @@ function transformES2015(context) {
       statement,
       /*outermostLabeledStatement*/
       node
-    ) : factory2.restoreEnclosingLabel(Debug.checkDefined(visitNode(statement, visitor, isStatement, factory2.liftToBlock)), node, convertedLoopState && resetLabel);
+    ) : factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock) ?? setTextRange(factory2.createEmptyStatement(), statement), node, convertedLoopState && resetLabel);
   }
   function visitIterationStatement(node, outermostLabeledStatement) {
     switch (node.kind) {
@@ -107913,7 +107917,7 @@ function transformModule(context) {
     return factory2.updateLabeledStatement(
       node,
       node.label,
-      visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock) ?? factory2.createExpressionStatement(factory2.createIdentifier(""))
+      visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock) ?? setTextRange(factory2.createEmptyStatement(), node.statement)
     );
   }
   function visitWithStatement(node) {

package/lib/typescript.js

@@ -484,6 +484,7 @@ __export(typescript_exports, {
   decodeMappings: () => decodeMappings,
   decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith,
   deduplicate: () => deduplicate,
+  defaultInitCompilerOptions: () => defaultInitCompilerOptions,
   defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
   diagnosticCategoryName: () => diagnosticCategoryName,
   diagnosticToString: () => diagnosticToString,
@@ -2259,7 +2260,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240726`;
+var version = `${versionMajorMinor}.0-dev.20240728`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -50089,6 +50090,7 @@ function createTypeChecker(host) {
     getNonOptionalType: removeOptionalTypeMarker,
     getTypeArguments,
     typeToTypeNode: nodeBuilder.typeToTypeNode,
+    typePredicateToTypePredicateNode: nodeBuilder.typePredicateToTypePredicateNode,
     indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration,
     signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration,
     symbolToEntityName: nodeBuilder.symbolToEntityName,
@@ -72407,6 +72409,9 @@ function createTypeChecker(host) {
     return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType;
   }
   function isFunctionObjectType(type) {
+    if (getObjectFlags(type) & 256 /* EvolvingArray */) {
+      return false;
+    }
     const resolved = resolveStructuredTypeMembers(type);
     return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
   }
@@ -108407,7 +108412,7 @@ function transformES2015(context) {
       statement,
       /*outermostLabeledStatement*/
       node
-    ) : factory2.restoreEnclosingLabel(Debug.checkDefined(visitNode(statement, visitor, isStatement, factory2.liftToBlock)), node, convertedLoopState && resetLabel);
+    ) : factory2.restoreEnclosingLabel(visitNode(statement, visitor, isStatement, factory2.liftToBlock) ?? setTextRange(factory2.createEmptyStatement(), statement), node, convertedLoopState && resetLabel);
   }
   function visitIterationStatement(node, outermostLabeledStatement) {
     switch (node.kind) {
@@ -112713,7 +112718,7 @@ function transformModule(context) {
     return factory2.updateLabeledStatement(
       node,
       node.label,
-      visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock) ?? factory2.createExpressionStatement(factory2.createIdentifier(""))
+      visitNode(node.statement, topLevelNestedVisitor, isStatement, factory2.liftToBlock) ?? setTextRange(factory2.createEmptyStatement(), node.statement)
     );
   }
   function visitWithStatement(node) {
@@ -148186,7 +148191,27 @@ function getInfo4(context) {
     return { error: getLocaleSpecificMessage(Diagnostics.Return_type_must_be_inferred_from_a_function) };
   }
   const typeChecker = context.program.getTypeChecker();
-  const returnType = tryGetReturnType(typeChecker, declaration);
+  let returnType;
+  if (typeChecker.isImplementationOfOverload(declaration)) {
+    const signatures = typeChecker.getTypeAtLocation(declaration).getCallSignatures();
+    if (signatures.length > 1) {
+      returnType = typeChecker.getUnionType(mapDefined(signatures, (s) => s.getReturnType()));
+    }
+  }
+  if (!returnType) {
+    const signature = typeChecker.getSignatureFromDeclaration(declaration);
+    if (signature) {
+      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+      if (typePredicate && typePredicate.type) {
+        const typePredicateTypeNode = typeChecker.typePredicateToTypePredicateNode(typePredicate, declaration, 1 /* NoTruncation */);
+        if (typePredicateTypeNode) {
+          return { declaration, returnTypeNode: typePredicateTypeNode };
+        }
+      } else {
+        returnType = typeChecker.getReturnTypeOfSignature(signature);
+      }
+    }
+  }
   if (!returnType) {
     return { error: getLocaleSpecificMessage(Diagnostics.Could_not_determine_function_return_type) };
   }
@@ -148206,18 +148231,6 @@ function isConvertibleDeclaration(node) {
       return false;
   }
 }
-function tryGetReturnType(typeChecker, node) {
-  if (typeChecker.isImplementationOfOverload(node)) {
-    const signatures = typeChecker.getTypeAtLocation(node).getCallSignatures();
-    if (signatures.length > 1) {
-      return typeChecker.getUnionType(mapDefined(signatures, (s) => s.getReturnType()));
-    }
-  }
-  const signature = typeChecker.getSignatureFromDeclaration(node);
-  if (signature) {
-    return typeChecker.getReturnTypeOfSignature(signature);
-  }
-}
 
 // src/services/classifier2020.ts
 var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
@@ -151763,6 +151776,7 @@ __export(ts_codefix_exports, {
   setJsonCompilerOptionValue: () => setJsonCompilerOptionValue,
   setJsonCompilerOptionValues: () => setJsonCompilerOptionValues,
   tryGetAutoImportableReferenceFromTypeNode: () => tryGetAutoImportableReferenceFromTypeNode,
+  typePredicateToAutoImportableTypeNode: () => typePredicateToAutoImportableTypeNode,
   typeToAutoImportableTypeNode: () => typeToAutoImportableTypeNode
 });
 
@@ -159849,7 +159863,25 @@ function withContext(context, typePrintMode, cb) {
     if (typePrintMode === 1 /* Relative */) {
       return relativeType(node);
     }
-    let type = isValueSignatureDeclaration(node) ? tryGetReturnType2(node) : typeChecker.getTypeAtLocation(node);
+    let type;
+    if (isValueSignatureDeclaration(node)) {
+      const signature = typeChecker.getSignatureFromDeclaration(node);
+      if (signature) {
+        const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+        if (typePredicate) {
+          if (!typePredicate.type) {
+            return emptyInferenceResult;
+          }
+          return {
+            typeNode: typePredicateToTypeNode(typePredicate, findAncestor(node, isDeclaration) ?? sourceFile, getFlags(typePredicate.type)),
+            mutatedTarget: false
+          };
+        }
+        type = typeChecker.getReturnTypeOfSignature(signature);
+      }
+    } else {
+      type = typeChecker.getTypeAtLocation(node);
+    }
     if (!type) {
       return emptyInferenceResult;
     }
@@ -159866,11 +159898,13 @@ function withContext(context, typePrintMode, cb) {
     if (isParameter(node) && typeChecker.requiresAddingImplicitUndefined(node)) {
       type = typeChecker.getUnionType([typeChecker.getUndefinedType(), type], 0 /* None */);
     }
-    const flags = (isVariableDeclaration(node) || isPropertyDeclaration(node) && hasSyntacticModifier(node, 256 /* Static */ | 8 /* Readonly */)) && type.flags & 8192 /* UniqueESSymbol */ ? 1048576 /* AllowUniqueESSymbolType */ : 0 /* None */;
     return {
-      typeNode: typeToTypeNode2(type, findAncestor(node, isDeclaration) ?? sourceFile, flags),
+      typeNode: typeToTypeNode2(type, findAncestor(node, isDeclaration) ?? sourceFile, getFlags(type)),
       mutatedTarget: false
     };
+    function getFlags(type2) {
+      return (isVariableDeclaration(node) || isPropertyDeclaration(node) && hasSyntacticModifier(node, 256 /* Static */ | 8 /* Readonly */)) && type2.flags & 8192 /* UniqueESSymbol */ ? 1048576 /* AllowUniqueESSymbolType */ : 0 /* None */;
+    }
   }
   function createTypeOfFromEntityNameExpression(node) {
     return factory.createTypeQueryNode(getSynthesizedDeepClone(node));
@@ -160033,11 +160067,18 @@ function withContext(context, typePrintMode, cb) {
     });
     return isTruncated ? factory.createKeywordTypeNode(133 /* AnyKeyword */) : result2;
   }
-  function tryGetReturnType2(node) {
-    const signature = typeChecker.getSignatureFromDeclaration(node);
-    if (signature) {
-      return typeChecker.getReturnTypeOfSignature(signature);
-    }
+  function typePredicateToTypeNode(typePredicate, enclosingDeclaration, flags = 0 /* None */) {
+    let isTruncated = false;
+    const result2 = typePredicateToAutoImportableTypeNode(typeChecker, importAdder, typePredicate, enclosingDeclaration, scriptTarget, declarationEmitNodeBuilderFlags2 | flags, {
+      moduleResolverHost: program,
+      trackSymbol() {
+        return true;
+      },
+      reportTruncationError() {
+        isTruncated = true;
+      }
+    });
+    return isTruncated ? factory.createKeywordTypeNode(133 /* AnyKeyword */) : result2;
   }
   function addTypeToVariableLike(decl) {
     const { typeNode } = inferType(decl);
@@ -161708,6 +161749,17 @@ function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, s
   }
   return getSynthesizedDeepClone(typeNode);
 }
+function typePredicateToAutoImportableTypeNode(checker, importAdder, typePredicate, contextNode, scriptTarget, flags, tracker) {
+  let typePredicateNode = checker.typePredicateToTypePredicateNode(typePredicate, contextNode, flags, tracker);
+  if ((typePredicateNode == null ? void 0 : typePredicateNode.type) && isImportTypeNode(typePredicateNode.type)) {
+    const importableReference = tryGetAutoImportableReferenceFromTypeNode(typePredicateNode.type, scriptTarget);
+    if (importableReference) {
+      importSymbols(importAdder, importableReference.symbols);
+      typePredicateNode = factory.updateTypePredicateNode(typePredicateNode, typePredicateNode.assertsModifier, typePredicateNode.parameterName, importableReference.typeNode);
+    }
+  }
+  return getSynthesizedDeepClone(typePredicateNode);
+}
 function typeContainsTypeParameter(type) {
   if (type.isUnionOrIntersection()) {
     return type.types.some(typeContainsTypeParameter);
@@ -179430,6 +179482,7 @@ __export(ts_exports2, {
   decodeMappings: () => decodeMappings,
   decodedTextSpanIntersectsWith: () => decodedTextSpanIntersectsWith,
   deduplicate: () => deduplicate,
+  defaultInitCompilerOptions: () => defaultInitCompilerOptions,
   defaultMaximumTruncationLength: () => defaultMaximumTruncationLength,
   diagnosticCategoryName: () => diagnosticCategoryName,
   diagnosticToString: () => diagnosticToString,
@@ -193814,6 +193867,7 @@ if (typeof console !== "undefined") {
   decodeMappings,
   decodedTextSpanIntersectsWith,
   deduplicate,
+  defaultInitCompilerOptions,
   defaultMaximumTruncationLength,
   diagnosticCategoryName,
   diagnosticToString,

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.6.0-dev.20240726",
+    "version": "5.6.0-dev.20240728",
     "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": "12ae799eda74aca6a4051f1ebee4d2d0c8d817a2"
+    "gitHead": "9757109cafcb771a35ad9fe09855373cdd82005a"
 }