@typescript-deploys/pr-build 5.5.0-pr-58025-3 → 5.5.0-pr-58065-2

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240401`;
+var version = `${versionMajorMinor}.0-insiders.20240403`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3924,7 +3924,6 @@ var commentPragmas = {
     kind: 4 /* MultiLine */
   }
 };
-var _optionsType = [void 0][0];
 
 // src/compiler/sys.ts
 function generateDjb2Hash(data) {
@@ -33838,16 +33837,13 @@ var compileOnSaveCommandLineOption = {
   type: "boolean",
   defaultValueDescription: false
 };
-function strongMap(input) {
-  return new Map(Object.entries(input));
-}
-var jsxOptionMap = strongMap({
+var jsxOptionMap = new Map(Object.entries({
   "preserve": 1 /* Preserve */,
   "react-native": 3 /* ReactNative */,
   "react": 2 /* React */,
   "react-jsx": 4 /* ReactJSX */,
   "react-jsxdev": 5 /* ReactJSXDev */
-});
+}));
 var inverseJsxOptionMap = new Map(mapIterator(jsxOptionMap.entries(), ([key, value]) => ["" + value, key]));
 var libEntries = [
   // JavaScript only
@@ -33945,38 +33941,38 @@ var libMap = new Map(libEntries);
 var optionsForWatch = [
   {
     name: "watchFile",
-    type: strongMap({
+    type: new Map(Object.entries({
       fixedpollinginterval: 0 /* FixedPollingInterval */,
       prioritypollinginterval: 1 /* PriorityPollingInterval */,
       dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
       fixedchunksizepolling: 3 /* FixedChunkSizePolling */,
       usefsevents: 4 /* UseFsEvents */,
       usefseventsonparentdirectory: 5 /* UseFsEventsOnParentDirectory */
-    }),
+    })),
     category: Diagnostics.Watch_and_Build_Modes,
     description: Diagnostics.Specify_how_the_TypeScript_watch_mode_works,
     defaultValueDescription: 4 /* UseFsEvents */
   },
   {
     name: "watchDirectory",
-    type: strongMap({
+    type: new Map(Object.entries({
       usefsevents: 0 /* UseFsEvents */,
       fixedpollinginterval: 1 /* FixedPollingInterval */,
       dynamicprioritypolling: 2 /* DynamicPriorityPolling */,
       fixedchunksizepolling: 3 /* FixedChunkSizePolling */
-    }),
+    })),
     category: Diagnostics.Watch_and_Build_Modes,
     description: Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality,
     defaultValueDescription: 0 /* UseFsEvents */
   },
   {
     name: "fallbackPolling",
-    type: strongMap({
+    type: new Map(Object.entries({
       fixedinterval: 0 /* FixedInterval */,
       priorityinterval: 1 /* PriorityInterval */,
       dynamicpriority: 2 /* DynamicPriority */,
       fixedchunksize: 3 /* FixedChunkSize */
-    }),
+    })),
     category: Diagnostics.Watch_and_Build_Modes,
     description: Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers,
     defaultValueDescription: 1 /* PriorityInterval */
@@ -34202,7 +34198,7 @@ var commonOptionsWithBuild = [
 var targetOptionDeclaration = {
   name: "target",
   shortName: "t",
-  type: strongMap({
+  type: new Map(Object.entries({
     es3: 0 /* ES3 */,
     es5: 1 /* ES5 */,
     es6: 2 /* ES2015 */,
@@ -34215,7 +34211,7 @@ var targetOptionDeclaration = {
     es2021: 8 /* ES2021 */,
     es2022: 9 /* ES2022 */,
     esnext: 99 /* ESNext */
-  }),
+  })),
   affectsSourceFile: true,
   affectsModuleResolution: true,
   affectsEmit: true,
@@ -34230,7 +34226,7 @@ var targetOptionDeclaration = {
 var moduleOptionDeclaration = {
   name: "module",
   shortName: "m",
-  type: strongMap({
+  type: new Map(Object.entries({
     none: 0 /* None */,
     commonjs: 1 /* CommonJS */,
     amd: 2 /* AMD */,
@@ -34244,7 +34240,7 @@ var moduleOptionDeclaration = {
     node16: 100 /* Node16 */,
     nodenext: 199 /* NodeNext */,
     preserve: 200 /* Preserve */
-  }),
+  })),
   affectsSourceFile: true,
   affectsModuleResolution: true,
   affectsEmit: true,
@@ -34463,11 +34459,11 @@ var commandOptionsWithoutBuild = [
   },
   {
     name: "importsNotUsedAsValues",
-    type: strongMap({
+    type: new Map(Object.entries({
       remove: 0 /* Remove */,
       preserve: 1 /* Preserve */,
       error: 2 /* Error */
-    }),
+    })),
     affectsEmit: true,
     affectsSemanticDiagnostics: true,
     affectsBuildInfo: true,
@@ -34675,7 +34671,7 @@ var commandOptionsWithoutBuild = [
   // Module Resolution
   {
     name: "moduleResolution",
-    type: strongMap({
+    type: new Map(Object.entries({
       // N.B. The first entry specifies the value shown in `tsc --init`
       node10: 2 /* Node10 */,
       node: 2 /* Node10 */,
@@ -34683,7 +34679,7 @@ var commandOptionsWithoutBuild = [
       node16: 3 /* Node16 */,
       nodenext: 99 /* NodeNext */,
       bundler: 100 /* Bundler */
-    }),
+    })),
     deprecatedKeys: /* @__PURE__ */ new Set(["node"]),
     affectsSourceFile: true,
     affectsModuleResolution: true,
@@ -34979,10 +34975,10 @@ var commandOptionsWithoutBuild = [
   },
   {
     name: "newLine",
-    type: strongMap({
+    type: new Map(Object.entries({
       crlf: 0 /* CarriageReturnLineFeed */,
       lf: 1 /* LineFeed */
-    }),
+    })),
     affectsEmit: true,
     affectsBuildInfo: true,
     paramType: Diagnostics.NEWLINE,
@@ -35223,11 +35219,11 @@ var commandOptionsWithoutBuild = [
   },
   {
     name: "moduleDetection",
-    type: strongMap({
+    type: new Map(Object.entries({
       auto: 2 /* Auto */,
       legacy: 1 /* Legacy */,
       force: 3 /* Force */
-    }),
+    })),
     affectsSourceFile: true,
     affectsModuleResolution: true,
     description: Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files,
@@ -35599,10 +35595,7 @@ function getDiagnosticText(message, ...args) {
   return cast(createCompilerDiagnostic(message, ...args).messageText, isString);
 }
 function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) {
-  const typeConfig = hasTSFileExtension(configFileName) || hasJSFileExtension(configFileName) ? loadConfigFromDefaultType(
-    configFileName
-  ) : void 0;
-  const configFileText = typeConfig ? typeConfig.configText : tryReadFile(configFileName, (fileName) => host.readFile(fileName));
+  const configFileText = tryReadFile(configFileName, (fileName) => host.readFile(fileName));
   if (!isString(configFileText)) {
     host.onUnRecoverableConfigFileDiagnostic(configFileText);
     return void 0;
@@ -35612,7 +35605,7 @@ function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host,
   result.path = toPath(configFileName, cwd, createGetCanonicalFileName(host.useCaseSensitiveFileNames));
   result.resolvedPath = result.path;
   result.originalFileName = result.fileName;
-  const parsedResult = parseJsonSourceFileConfigFileContent(
+  return parseJsonSourceFileConfigFileContent(
     result,
     host,
     getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd),
@@ -35624,64 +35617,6 @@ function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host,
     extendedConfigCache,
     watchOptionsToExtend
   );
-  parsedResult.errors = concatenate(parsedResult.errors, typeConfig == null ? void 0 : typeConfig.errors);
-  return parsedResult;
-}
-function loadConfigFromDefaultType(configFileName) {
-  const program = createProgram({
-    rootNames: [configFileName],
-    options: {
-      strict: true,
-      exactOptionalPropertyTypes: true,
-      noEmit: true,
-      module: 199 /* NodeNext */,
-      target: 99 /* Latest */,
-      allowJs: true,
-      resolveJsonModule: true,
-      allowArbitraryExtensions: true,
-      lib: ["esnext"],
-      types: [],
-      moduleDetection: 3 /* Force */
-    }
-    // TODO: Use passed-in host object instead of sys
-  });
-  const file = Debug.checkDefined(program.getSourceFile(configFileName));
-  const checker = program.getTypeChecker();
-  const defaultMember = checker.tryGetMemberInModuleExports("default" /* Default */, file.symbol);
-  if (!defaultMember) {
-    return void 0;
-  }
-  const type = checker.getTypeOfSymbol(defaultMember);
-  const raw = convertTypeIntoRawConfig(checker, type);
-  return {
-    errors: program.getSemanticDiagnostics(file).slice(),
-    configText: JSON.stringify(raw)
-  };
-}
-function convertTypeIntoRawConfig(checker, type) {
-  return convertType(type);
-  function convertType(type2) {
-    if (type2.flags & 512 /* BooleanLiteral */) {
-      return type2.intrinsicName === "true" ? true : false;
-    }
-    if (type2.flags & 256 /* NumberLiteral */ || type2.flags & 128 /* StringLiteral */) {
-      return type2.value;
-    }
-    if (checker.isTupleType(type2)) {
-      const args = checker.getTypeArguments(type2);
-      return map(args, convertType);
-    }
-    if (type2.flags & 524288 /* Object */) {
-      const result = {};
-      const members = checker.getPropertiesOfType(type2);
-      for (const member of members) {
-        const name = symbolName(member);
-        result[name] = convertType(checker.getTypeOfSymbol(member));
-      }
-      return result;
-    }
-    return void 0;
-  }
 }
 function parseConfigFileTextToJson(fileName, jsonText) {
   const jsonSourceFile = parseJsonText(fileName, jsonText);
@@ -43540,7 +43475,7 @@ function createTypeChecker(host) {
   var requestedExternalEmitHelpers;
   var externalHelpersModule;
   var Symbol12 = objectAllocator.getSymbolConstructor();
-  var Type8 = objectAllocator.getTypeConstructor();
+  var Type7 = objectAllocator.getTypeConstructor();
   var Signature5 = objectAllocator.getSignatureConstructor();
   var typeCount = 0;
   var symbolCount = 0;
@@ -47454,7 +47389,7 @@ function createTypeChecker(host) {
   }
   function createType(flags) {
     var _a;
-    const result = new Type8(checker, flags);
+    const result = new Type7(checker, flags);
     typeCount++;
     result.id = typeCount;
     (_a = tracing) == null ? void 0 : _a.recordType(result);
@@ -47466,7 +47401,7 @@ function createTypeChecker(host) {
     return result;
   }
   function createOriginType(flags) {
-    return new Type8(checker, flags);
+    return new Type7(checker, flags);
   }
   function createIntrinsicType(kind, intrinsicName, objectFlags = 0 /* None */, debugIntrinsicName) {
     checkIntrinsicName(intrinsicName, debugIntrinsicName);
@@ -49175,68 +49110,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      let cleanup;
-      if (context.enclosingDeclaration && signature.declaration && signature.declaration !== context.enclosingDeclaration && !isInJSFile(signature.declaration) && (some(expandedParams) || some(signature.typeParameters))) {
-        let pushFakeScope2 = function(kind2, addAll) {
-          Debug.assert(context.enclosingDeclaration);
-          let existingFakeScope;
-          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration;
-          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind2) {
-            existingFakeScope = context.enclosingDeclaration.parent;
-          }
-          Debug.assertOptionalNode(existingFakeScope, isBlock);
-          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
-          let newLocals;
-          addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
-            }
-          });
-          if (!newLocals)
-            return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
-            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind2;
-            fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
-            context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
-            };
-          }
-        };
-        var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
-          "params",
-          (add) => {
-            for (const param of expandedParams) {
-              add(param.escapedName, param);
-            }
-          }
-        );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
-            "typeParams",
-            (add) => {
-              for (const typeParam of signature.typeParameters ?? emptyArray) {
-                const typeParamName = typeParameterToName(typeParam, context).escapedText;
-                add(typeParamName, typeParam.symbol);
-              }
-            }
-          );
-        }
-      }
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
       const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
@@ -49327,6 +49201,111 @@ function createTypeChecker(host) {
       cleanup == null ? void 0 : cleanup();
       return node;
     }
+    function isNewScopeNode(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) || isMappedTypeNode(node);
+    }
+    function getTypeParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
+    }
+    function getParametersInScope(node) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
+        getSignatureFromDeclaration(node),
+        /*skipUnionExpanding*/
+        true
+      )[0] : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters) {
+      let cleanup;
+      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+        let pushFakeScope2 = function(kind, addAll) {
+          Debug.assert(context.enclosingDeclaration);
+          let existingFakeScope;
+          if (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration;
+          } else if (context.enclosingDeclaration.parent && getNodeLinks(context.enclosingDeclaration.parent).fakeScopeForSignatureDeclaration === kind) {
+            existingFakeScope = context.enclosingDeclaration.parent;
+          }
+          Debug.assertOptionalNode(existingFakeScope, isBlock);
+          const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
+          let newLocals;
+          addAll((name, symbol) => {
+            if (!locals.has(name)) {
+              newLocals = append(newLocals, name);
+              locals.set(name, symbol);
+            }
+          });
+          if (!newLocals)
+            return;
+          const oldCleanup = cleanup;
+          function undo() {
+            forEach(newLocals, (s) => locals.delete(s));
+            oldCleanup == null ? void 0 : oldCleanup();
+          }
+          if (existingFakeScope) {
+            cleanup = undo;
+          } else {
+            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+            getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
+            fakeScope.locals = locals;
+            const saveEnclosingDeclaration = context.enclosingDeclaration;
+            setParent(fakeScope, saveEnclosingDeclaration);
+            context.enclosingDeclaration = fakeScope;
+            cleanup = () => {
+              context.enclosingDeclaration = saveEnclosingDeclaration;
+              undo();
+            };
+          }
+        };
+        var pushFakeScope = pushFakeScope2;
+        pushFakeScope2(
+          "params",
+          (add) => {
+            for (const param of expandedParams ?? emptyArray) {
+              if (!forEach(param.declarations, (d) => {
+                if (isParameter(d) && isBindingPattern(d.name)) {
+                  bindPattern(d.name);
+                  return true;
+                }
+                return void 0;
+                function bindPattern(p) {
+                  forEach(p.elements, (e) => {
+                    switch (e.kind) {
+                      case 232 /* OmittedExpression */:
+                        return;
+                      case 208 /* BindingElement */:
+                        return bindElement(e);
+                      default:
+                        return Debug.assertNever(e);
+                    }
+                  });
+                }
+                function bindElement(e) {
+                  if (isBindingPattern(e.name)) {
+                    return bindPattern(e.name);
+                  }
+                  const symbol = getSymbolOfDeclaration(e);
+                  add(symbol.escapedName, symbol);
+                }
+              })) {
+                add(param.escapedName, param);
+              }
+            }
+          }
+        );
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
+          pushFakeScope2(
+            "typeParams",
+            (add) => {
+              for (const typeParam of typeParameters ?? emptyArray) {
+                const typeParamName = typeParameterToName(typeParam, context).escapedText;
+                add(typeParamName, typeParam.symbol);
+              }
+            }
+          );
+        }
+        return cleanup;
+      }
+    }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
         return symbolToParameterDeclaration(signature.thisParameter, context);
@@ -49945,6 +49924,9 @@ function createTypeChecker(host) {
       if (initial.typeParameterSymbolList) {
         initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
       }
+      if (initial.typeParameterNamesByTextNextNameCount) {
+        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
+      }
       initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
       return initial;
     }
@@ -50077,6 +50059,22 @@ function createTypeChecker(host) {
       }
       return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
       function visitExistingNodeTreeSymbols(node) {
+        const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
+        const result = visitExistingNodeTreeSymbolsWorker(node);
+        onExitNewScope == null ? void 0 : onExitNewScope();
+        return result;
+      }
+      function onEnterNewScope(node) {
+        const oldContex = context;
+        context = cloneNodeBuilderContext(context);
+        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
+        return onExitNewScope;
+        function onExitNewScope() {
+          cleanup == null ? void 0 : cleanup();
+          context = oldContex;
+        }
+      }
+      function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
           return factory.createKeywordTypeNode(133 /* AnyKeyword */);
         }
@@ -50227,6 +50225,21 @@ function createTypeChecker(host) {
           setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
           return clone;
         }
+        if (isConditionalTypeNode(node)) {
+          const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode);
+          const disposeScope = onEnterNewScope(node);
+          const extendType = visitNode(node.extendsType, visitExistingNodeTreeSymbols, isTypeNode);
+          const trueType2 = visitNode(node.trueType, visitExistingNodeTreeSymbols, isTypeNode);
+          disposeScope();
+          const falseType2 = visitNode(node.falseType, visitExistingNodeTreeSymbols, isTypeNode);
+          return factory.updateConditionalTypeNode(
+            node,
+            checkType,
+            extendType,
+            trueType2,
+            falseType2
+          );
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -63442,6 +63455,9 @@ function createTypeChecker(host) {
       const resolved = resolveStructuredTypeMembers(type);
       return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && resolved.properties.length > 0 && every(resolved.properties, (p) => !!(p.flags & 16777216 /* Optional */));
     }
+    if (type.flags & 33554432 /* Substitution */) {
+      return isWeakType(type.baseType);
+    }
     if (type.flags & 2097152 /* Intersection */) {
       return every(type.types, isWeakType);
     }
@@ -70410,7 +70426,11 @@ function createTypeChecker(host) {
       if (getPropertyOfObjectType(targetType, name) || getApplicableIndexInfoForName(targetType, name) || isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || isComparingJsxAttributes && isHyphenatedJsxName(name)) {
         return true;
       }
-    } else if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
+    }
+    if (targetType.flags & 33554432 /* Substitution */) {
+      return isKnownProperty(targetType.baseType, name, isComparingJsxAttributes);
+    }
+    if (targetType.flags & 3145728 /* UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) {
       for (const t of targetType.types) {
         if (isKnownProperty(t, name, isComparingJsxAttributes)) {
           return true;
@@ -70420,7 +70440,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isExcessPropertyCheckTarget(type) {
-    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
+    return !!(type.flags & 524288 /* Object */ && !(getObjectFlags(type) & 512 /* ObjectLiteralPatternWithComputedProperties */) || type.flags & 67108864 /* NonPrimitive */ || type.flags & 33554432 /* Substitution */ && isExcessPropertyCheckTarget(type.baseType) || type.flags & 1048576 /* Union */ && some(type.types, isExcessPropertyCheckTarget) || type.flags & 2097152 /* Intersection */ && every(type.types, isExcessPropertyCheckTarget));
   }
   function checkJsxExpression(node, checkMode) {
     checkGrammarJsxExpression(node);
@@ -74561,17 +74581,18 @@ function createTypeChecker(host) {
     const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
     const trueCondition = {
       flags: 32 /* TrueCondition */,
-      node: expr,
-      antecedent
+      antecedent,
+      node: expr
     };
     const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
     if (trueType2 === initType)
       return void 0;
     const falseCondition = {
-      ...trueCondition,
-      flags: 64 /* FalseCondition */
+      flags: 64 /* FalseCondition */,
+      antecedent,
+      node: expr
     };
-    const falseSubtype = getFlowTypeOfReference(param.name, trueType2, trueType2, func, falseCondition);
+    const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
@@ -117193,6 +117214,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
     getRedirectReferenceForResolutionFromSourceOfProject,
+    getRedirectReferenceForResolution,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -122108,7 +122130,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     getResolutionWithResolvedFileName,
     deferWatchingNonRelativeResolution,
     shouldRetryResolution,
-    logChanges
+    logChanges,
+    canWatchFailedLookups
   }) {
     const path = resolutionHost.toPath(containingFile);
     const resolutionsInFile = perFileCache.get(path) || perFileCache.set(path, createModeAwareCache()).get(path);
@@ -122131,7 +122154,14 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         }
         resolutionsInFile.set(name, mode, resolution);
         if (resolution !== existingResolution) {
-          watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution);
+          watchFailedLookupLocationsOfExternalModuleResolutions(
+            name,
+            resolution,
+            path,
+            getResolutionWithResolvedFileName,
+            deferWatchingNonRelativeResolution,
+            (resolution2) => canWatchFailedLookups(resolution2, (redirectedReference == null ? void 0 : redirectedReference.commandLine.options) || options, containingSourceFile)
+          );
           if (existingResolution) {
             stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName);
           }
@@ -122210,7 +122240,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       ),
       getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective,
       shouldRetryResolution: (resolution) => resolution.resolvedTypeReferenceDirective === void 0,
-      deferWatchingNonRelativeResolution: false
+      deferWatchingNonRelativeResolution: false,
+      canWatchFailedLookups: canWatchFailedLookupsOfTypeReferencedDirective
     });
   }
   function resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames) {
@@ -122232,8 +122263,9 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       getResolutionWithResolvedFileName: getResolvedModule,
       shouldRetryResolution: (resolution) => !resolution.resolvedModule || !resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension),
       logChanges: logChangesWhenResolvingModule,
-      deferWatchingNonRelativeResolution: true
+      deferWatchingNonRelativeResolution: true,
       // Defer non relative resolution watch because we could be using ambient modules
+      canWatchFailedLookups: canWatchFailedLookupsOfResolvedModule
     });
   }
   function resolveLibrary2(libraryName, resolveFrom, options, libFileName) {
@@ -122249,7 +122281,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         path,
         getResolvedModule,
         /*deferWatchingNonRelativeResolution*/
-        false
+        false,
+        canWatchFailedLookupsOfResolvedLibrary
       );
       resolvedLibraries.set(libFileName, resolution);
       if (existingResolution) {
@@ -122296,16 +122329,18 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function isNodeModulesAtTypesDirectory(dirPath) {
     return endsWith(dirPath, "/node_modules/@types");
   }
-  function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution) {
-    var _a;
+  function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName, deferWatchingNonRelativeResolution, canWatchFailedLookups) {
+    var _a, _b;
     if (resolution.refCount) {
       resolution.refCount++;
       Debug.assertIsDefined(resolution.files);
     } else {
       resolution.refCount = 1;
       Debug.assert(!((_a = resolution.files) == null ? void 0 : _a.size));
+      if (((_b = resolution.failedLookupLocations) == null ? void 0 : _b.length) && canWatchFailedLookups(resolution))
+        resolution.canWatchFailedLookups = true;
       if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
-        watchFailedLookupLocationOfResolution(resolution);
+        watchFailedLookupLocationAndAffectedLocationsOfResolution(resolution);
       } else {
         nonRelativeExternalModuleResolutions.add(name, resolution);
       }
@@ -122341,15 +122376,16 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
     }
     return setAtRoot;
   }
-  function watchFailedLookupLocationOfResolution(resolution) {
+  function watchFailedLookupLocationAndAffectedLocationsOfResolution(resolution) {
     Debug.assert(!!resolution.refCount);
     const { failedLookupLocations, affectingLocations, alternateResult } = resolution;
     if (!(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !(affectingLocations == null ? void 0 : affectingLocations.length) && !alternateResult)
       return;
-    if ((failedLookupLocations == null ? void 0 : failedLookupLocations.length) || alternateResult)
+    const addToFailedLookup = resolution.canWatchFailedLookups || alternateResult;
+    if (addToFailedLookup)
       resolutionsWithFailedLookups.add(resolution);
     let setAtRoot = false;
-    if (failedLookupLocations) {
+    if (resolution.canWatchFailedLookups) {
       for (const failedLookupLocation of failedLookupLocations) {
         setAtRoot = watchFailedLookupLocation(failedLookupLocation, setAtRoot);
       }
@@ -122364,7 +122400,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
         true
       );
     }
-    watchAffectingLocationsOfResolution(resolution, !(failedLookupLocations == null ? void 0 : failedLookupLocations.length) && !alternateResult);
+    watchAffectingLocationsOfResolution(resolution, !addToFailedLookup);
   }
   function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) {
     Debug.assert(!!resolution.refCount);
@@ -122451,7 +122487,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
   function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
     const program = resolutionHost.getCurrentProgram();
     if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
-      resolutions.forEach(watchFailedLookupLocationOfResolution);
+      resolutions.forEach(watchFailedLookupLocationAndAffectedLocationsOfResolution);
     } else {
       resolutions.forEach((resolution) => watchAffectingLocationsOfResolution(
         resolution,
@@ -122502,10 +122538,10 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       if ((resolutions == null ? void 0 : resolutions.delete(resolution)) && !resolutions.size)
         resolvedFileToResolution.delete(key);
     }
-    const { failedLookupLocations, affectingLocations, alternateResult } = resolution;
+    const { canWatchFailedLookups, failedLookupLocations, affectingLocations, alternateResult } = resolution;
     if (resolutionsWithFailedLookups.delete(resolution)) {
       let removeAtRoot = false;
-      if (failedLookupLocations) {
+      if (canWatchFailedLookups) {
         for (const failedLookupLocation of failedLookupLocations) {
           removeAtRoot = stopWatchFailedLookupLocation(failedLookupLocation, removeAtRoot, syncDirWatcherRemove);
         }
@@ -122678,7 +122714,7 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
       return true;
     if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks)
       return false;
-    return ((_a = resolution.failedLookupLocations) == null ? void 0 : _a.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)))) || !!resolution.alternateResult && isInvalidatedFailedLookup(resolutionHost.toPath(resolution.alternateResult));
+    return resolution.canWatchFailedLookups && ((_a = resolution.failedLookupLocations) == null ? void 0 : _a.some((location) => isInvalidatedFailedLookup(resolutionHost.toPath(location)))) || !!resolution.alternateResult && isInvalidatedFailedLookup(resolutionHost.toPath(resolution.alternateResult));
   }
   function isInvalidatedFailedLookup(locationPath) {
     return (failedLookupChecks == null ? void 0 : failedLookupChecks.has(locationPath)) || firstDefinedIterator((startsWithPathChecks == null ? void 0 : startsWithPathChecks.keys()) || [], (fileOrDirectoryPath) => startsWith(locationPath, fileOrDirectoryPath) ? true : void 0) || firstDefinedIterator((isInDirectoryChecks == null ? void 0 : isInDirectoryChecks.keys()) || [], (dirPath) => locationPath.length > dirPath.length && startsWith(locationPath, dirPath) && (isDiskPathRoot(dirPath) || locationPath[dirPath.length] === directorySeparator) ? true : void 0);
@@ -122741,6 +122777,16 @@ function resolutionIsSymlink(resolution) {
   var _a, _b;
   return !!(((_a = resolution.resolvedModule) == null ? void 0 : _a.originalPath) || ((_b = resolution.resolvedTypeReferenceDirective) == null ? void 0 : _b.originalPath));
 }
+function canWatchFailedLookupsOfResolvedModule(resolution, optionsForFile, file) {
+  var _a;
+  return !resolution.resolvedModule || !!resolution.alternateResult || !!((_a = resolution.resolutionDiagnostics) == null ? void 0 : _a.length) || !!getResolutionDiagnostic(optionsForFile, resolution.resolvedModule, file);
+}
+function canWatchFailedLookupsOfTypeReferencedDirective(resolution) {
+  return !resolution.resolvedTypeReferenceDirective;
+}
+function canWatchFailedLookupsOfResolvedLibrary(resolution) {
+  return !resolution.resolvedModule;
+}
 
 // src/compiler/watch.ts
 var sysFormatDiagnosticsHost = sys ? {