@typescript-deploys/pr-build 6.0.0-pr-62673-3 → 6.0.0-pr-62789-2

package/lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "6.0";
-var version = `${versionMajorMinor}.0-insiders.20251028`;
+var version = `${versionMajorMinor}.0-insiders.20251124`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -368,20 +368,6 @@ function some(array, predicate) {
   }
   return false;
 }
-function getRangesWhere(arr, pred, cb) {
-  let start;
-  for (let i = 0; i < arr.length; i++) {
-    if (pred(arr[i])) {
-      start = start === void 0 ? i : start;
-    } else {
-      if (start !== void 0) {
-        cb(start, i);
-        start = void 0;
-      }
-    }
-  }
-  if (start !== void 0) cb(start, arr.length);
-}
 function concatenate(array1, array2) {
   if (array2 === void 0 || array2.length === 0) return array1;
   if (array1 === void 0 || array1.length === 0) return array2;
@@ -3362,6 +3348,7 @@ var NodeFlags = /* @__PURE__ */ ((NodeFlags3) => {
   NodeFlags3[NodeFlags3["JsonFile"] = 134217728] = "JsonFile";
   NodeFlags3[NodeFlags3["TypeCached"] = 268435456] = "TypeCached";
   NodeFlags3[NodeFlags3["Deprecated"] = 536870912] = "Deprecated";
+  NodeFlags3[NodeFlags3["Unreachable"] = 1073741824] = "Unreachable";
   NodeFlags3[NodeFlags3["BlockScoped"] = 7] = "BlockScoped";
   NodeFlags3[NodeFlags3["Constant"] = 6] = "Constant";
   NodeFlags3[NodeFlags3["ReachabilityCheckFlags"] = 1536] = "ReachabilityCheckFlags";
@@ -6252,6 +6239,9 @@ var Diagnostics = {
   Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0: diag(1544, 1 /* Error */, "Named_imports_from_a_JSON_file_into_an_ECMAScript_module_are_not_allowed_when_module_is_set_to_0_1544", "Named imports from a JSON file into an ECMAScript module are not allowed when 'module' is set to '{0}'."),
   using_declarations_are_not_allowed_in_ambient_contexts: diag(1545, 1 /* Error */, "using_declarations_are_not_allowed_in_ambient_contexts_1545", "'using' declarations are not allowed in ambient contexts."),
   await_using_declarations_are_not_allowed_in_ambient_contexts: diag(1546, 1 /* Error */, "await_using_declarations_are_not_allowed_in_ambient_contexts_1546", "'await using' declarations are not allowed in ambient contexts."),
+  using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block: diag(1547, 1 /* Error */, "using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block_1547", "'using' declarations are not allowed in 'case' or 'default' clauses unless contained within a block."),
+  await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block: diag(1548, 1 /* Error */, "await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block_1548", "'await using' declarations are not allowed in 'case' or 'default' clauses unless contained within a block."),
+  Ignore_the_tsconfig_found_and_build_with_commandline_options_and_files: diag(1549, 3 /* Message */, "Ignore_the_tsconfig_found_and_build_with_commandline_options_and_files_1549", "Ignore the tsconfig found and build with commandline options and files."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -6997,7 +6987,7 @@ var Diagnostics = {
   Compiler_option_0_may_only_be_used_with_build: diag(5093, 1 /* Error */, "Compiler_option_0_may_only_be_used_with_build_5093", "Compiler option '--{0}' may only be used with '--build'."),
   Compiler_option_0_may_not_be_used_with_build: diag(5094, 1 /* Error */, "Compiler_option_0_may_not_be_used_with_build_5094", "Compiler option '--{0}' may not be used with '--build'."),
   Option_0_can_only_be_used_when_module_is_set_to_preserve_commonjs_or_es2015_or_later: diag(5095, 1 /* Error */, "Option_0_can_only_be_used_when_module_is_set_to_preserve_commonjs_or_es2015_or_later_5095", "Option '{0}' can only be used when 'module' is set to 'preserve', 'commonjs', or 'es2015' or later."),
-  Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set: diag(5096, 1 /* Error */, "Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set_5096", "Option 'allowImportingTsExtensions' can only be used when either 'noEmit' or 'emitDeclarationOnly' is set."),
+  Option_allowImportingTsExtensions_can_only_be_used_when_one_of_noEmit_emitDeclarationOnly_or_rewriteRelativeImportExtensions_is_set: diag(5096, 1 /* Error */, "Option_allowImportingTsExtensions_can_only_be_used_when_one_of_noEmit_emitDeclarationOnly_or_rewrite_5096", "Option 'allowImportingTsExtensions' can only be used when one of 'noEmit', 'emitDeclarationOnly', or 'rewriteRelativeImportExtensions' is set."),
   An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled: diag(5097, 1 /* Error */, "An_import_path_can_only_end_with_a_0_extension_when_allowImportingTsExtensions_is_enabled_5097", "An import path can only end with a '{0}' extension when 'allowImportingTsExtensions' is enabled."),
   Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler: diag(5098, 1 /* Error */, "Option_0_can_only_be_used_when_moduleResolution_is_set_to_node16_nodenext_or_bundler_5098", "Option '{0}' can only be used when 'moduleResolution' is set to 'node16', 'nodenext', or 'bundler'."),
   Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprecations_Colon_2_to_silence_this_error: diag(5101, 1 /* Error */, "Option_0_is_deprecated_and_will_stop_functioning_in_TypeScript_1_Specify_compilerOption_ignoreDeprec_5101", `Option '{0}' is deprecated and will stop functioning in TypeScript {1}. Specify compilerOption '"ignoreDeprecations": "{2}"' to silence this error.`),
@@ -7011,6 +7001,7 @@ var Diagnostics = {
   Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1: diag(5109, 1 /* Error */, "Option_moduleResolution_must_be_set_to_0_or_left_unspecified_when_option_module_is_set_to_1_5109", "Option 'moduleResolution' must be set to '{0}' (or left unspecified) when option 'module' is set to '{1}'."),
   Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1: diag(5110, 1 /* Error */, "Option_module_must_be_set_to_0_when_option_moduleResolution_is_set_to_1_5110", "Option 'module' must be set to '{0}' when option 'moduleResolution' is set to '{1}'."),
   Visit_https_Colon_Slash_Slashaka_ms_Slashts6_for_migration_information: diag(5111, 3 /* Message */, "Visit_https_Colon_Slash_Slashaka_ms_Slashts6_for_migration_information_5111", "Visit https://aka.ms/ts6 for migration information."),
+  tsconfig_json_is_present_but_will_not_be_loaded_if_files_are_specified_on_commandline_Use_ignoreConfig_to_skip_this_error: diag(5112, 1 /* Error */, "tsconfig_json_is_present_but_will_not_be_loaded_if_files_are_specified_on_commandline_Use_ignoreConf_5112", "tsconfig.json is present but will not be loaded if files are specified on commandline. Use '--ignoreConfig' to skip this error."),
   Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6e3, 3 /* Message */, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."),
   Concatenate_and_emit_output_to_single_file: diag(6001, 3 /* Message */, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."),
   Generates_corresponding_d_ts_file: diag(6002, 3 /* Message */, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."),
@@ -12484,9 +12475,6 @@ function isDeclaration(node) {
 function isDeclarationStatement(node) {
   return isDeclarationStatementKind(node.kind);
 }
-function isStatementButNotDeclaration(node) {
-  return isStatementKindButNotDeclarationKind(node.kind);
-}
 function isStatement(node) {
   const kind = node.kind;
   return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || isBlockStatement(node);
@@ -18225,12 +18213,6 @@ function hasJsonModuleEmitEnabled(options) {
   }
   return true;
 }
-function unreachableCodeIsError(options) {
-  return options.allowUnreachableCode === false;
-}
-function unusedLabelIsError(options) {
-  return options.allowUnusedLabels === false;
-}
 function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
   return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */ || moduleResolution === 100 /* Bundler */;
 }
@@ -18801,11 +18783,6 @@ function matchPatternOrExact(parsedPatterns, candidate) {
   }
   return findBestPatternMatch(patterns, (_) => _, candidate);
 }
-function sliceAfter(arr, value) {
-  const index = arr.indexOf(value);
-  Debug.assert(index !== -1);
-  return arr.slice(index);
-}
 function addRelatedInfo(diagnostic, ...relatedInformation) {
   if (!relatedInformation.length) {
     return diagnostic;
@@ -20155,6 +20132,21 @@ function addEmitFlagsRecursively(node, flag, getChild) {
 function getFirstChild(node) {
   return forEachChild(node, (child) => child);
 }
+function canHaveStatements(node) {
+  return isBlock(node) || isModuleBlock(node) || isSourceFile(node) || isCaseClause(node) || isDefaultClause(node);
+}
+function isPotentiallyExecutableNode(node) {
+  if (244 /* FirstStatement */ <= node.kind && node.kind <= 260 /* LastStatement */) {
+    if (isVariableStatement(node)) {
+      if (getCombinedNodeFlags(node.declarationList) & 7 /* BlockScoped */) {
+        return true;
+      }
+      return some(node.declarationList.declarations, (d) => d.initializer !== void 0);
+    }
+    return true;
+  }
+  return isClassDeclaration(node) || isEnumDeclaration(node) || isModuleDeclaration(node);
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -36872,6 +36864,15 @@ var commandOptionsWithoutBuild = [
     description: Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing,
     defaultValueDescription: false
   },
+  {
+    name: "ignoreConfig",
+    type: "boolean",
+    showInSimplifiedHelpView: true,
+    category: Diagnostics.Command_line_Options,
+    isCommandLineOnly: true,
+    description: Diagnostics.Ignore_the_tsconfig_found_and_build_with_commandline_options_and_files,
+    defaultValueDescription: false
+  },
   // Basic
   targetOptionDeclaration,
   moduleOptionDeclaration,
@@ -42370,13 +42371,6 @@ function createBinder() {
     /*antecedent*/
     void 0
   );
-  var reportedUnreachableFlow = createFlowNode(
-    1 /* Unreachable */,
-    /*node*/
-    void 0,
-    /*antecedent*/
-    void 0
-  );
   var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
   return bindSourceFile2;
   function createDiagnosticForNode2(node, message, ...args) {
@@ -42392,7 +42386,6 @@ function createBinder() {
     symbolCount = 0;
     Symbol13 = objectAllocator.getSymbolConstructor();
     Debug.attachFlowNodeDebugInfo(unreachableFlow);
-    Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow);
     if (!file.locals) {
       (_a = tracing) == null ? void 0 : _a.push(
         tracing.Phase.Bind,
@@ -42765,16 +42758,22 @@ function createBinder() {
   function bindChildren(node) {
     const saveInAssignmentPattern = inAssignmentPattern;
     inAssignmentPattern = false;
-    if (checkUnreachable(node)) {
-      if (canHaveFlowNode(node) && node.flowNode) {
+    if (isPotentiallyExecutableNode(node)) {
+      node.flags &= ~1073741824 /* Unreachable */;
+    }
+    if (currentFlow === unreachableFlow) {
+      if (canHaveFlowNode(node)) {
         node.flowNode = void 0;
       }
+      if (isPotentiallyExecutableNode(node)) {
+        node.flags |= 1073741824 /* Unreachable */;
+      }
       bindEachChild(node);
       bindJSDoc(node);
       inAssignmentPattern = saveInAssignmentPattern;
       return;
     }
-    if (node.kind >= 244 /* FirstStatement */ && node.kind <= 260 /* LastStatement */ && (!options.allowUnreachableCode || node.kind === 254 /* ReturnStatement */)) {
+    if (244 /* FirstStatement */ <= node.kind && node.kind <= 260 /* LastStatement */ && canHaveFlowNode(node)) {
       node.flowNode = currentFlow;
     }
     switch (node.kind) {
@@ -43361,8 +43360,8 @@ function createBinder() {
     };
     bind(node.label);
     bind(node.statement);
-    if (!activeLabelList.referenced && !options.allowUnusedLabels) {
-      errorOrSuggestionOnNode(unusedLabelIsError(options), node.label, Diagnostics.Unused_label);
+    if (!activeLabelList.referenced) {
+      node.label.flags |= 1073741824 /* Unreachable */;
     }
     activeLabelList = activeLabelList.next;
     addAntecedent(postStatementLabel, currentFlow);
@@ -44139,20 +44138,6 @@ function createBinder() {
     const span = getSpanOfTokenAtPosition(file, node.pos);
     file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, ...args));
   }
-  function errorOrSuggestionOnNode(isError, node, message) {
-    errorOrSuggestionOnRange(isError, node, node, message);
-  }
-  function errorOrSuggestionOnRange(isError, startNode, endNode, message) {
-    addErrorOrSuggestionDiagnostic(isError, { pos: getTokenPosOfNode(startNode, file), end: endNode.end }, message);
-  }
-  function addErrorOrSuggestionDiagnostic(isError, range, message) {
-    const diag2 = createFileDiagnostic(file, range.pos, range.end - range.pos, message);
-    if (isError) {
-      file.bindDiagnostics.push(diag2);
-    } else {
-      file.bindSuggestionDiagnostics = append(file.bindSuggestionDiagnostics, { ...diag2, category: 2 /* Suggestion */ });
-    }
-  }
   function bind(node) {
     if (!node) {
       return;
@@ -45039,61 +45024,6 @@ function createBinder() {
       declareSymbolAndAddToSymbolTable(node, 262144 /* TypeParameter */, 526824 /* TypeParameterExcludes */);
     }
   }
-  function shouldReportErrorOnModuleDeclaration(node) {
-    const instanceState = getModuleInstanceState(node);
-    return instanceState === 1 /* Instantiated */ || instanceState === 2 /* ConstEnumOnly */ && shouldPreserveConstEnums(options);
-  }
-  function checkUnreachable(node) {
-    if (!(currentFlow.flags & 1 /* Unreachable */)) {
-      return false;
-    }
-    if (currentFlow === unreachableFlow) {
-      const reportError = (
-        // report error on all statements except empty ones
-        isStatementButNotDeclaration(node) && node.kind !== 243 /* EmptyStatement */ || // report error on class declarations
-        node.kind === 264 /* ClassDeclaration */ || // report errors on enums with preserved emit
-        isEnumDeclarationWithPreservedEmit(node, options) || // report error on instantiated modules
-        node.kind === 268 /* ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)
-      );
-      if (reportError) {
-        currentFlow = reportedUnreachableFlow;
-        if (!options.allowUnreachableCode) {
-          const isError = unreachableCodeIsError(options) && !(node.flags & 33554432 /* Ambient */) && (!isVariableStatement(node) || !!(getCombinedNodeFlags(node.declarationList) & 7 /* BlockScoped */) || node.declarationList.declarations.some((d) => !!d.initializer));
-          eachUnreachableRange(node, options, (start, end) => errorOrSuggestionOnRange(isError, start, end, Diagnostics.Unreachable_code_detected));
-        }
-      }
-    }
-    return true;
-  }
-}
-function isEnumDeclarationWithPreservedEmit(node, options) {
-  return node.kind === 267 /* EnumDeclaration */ && (!isEnumConst(node) || shouldPreserveConstEnums(options));
-}
-function eachUnreachableRange(node, options, cb) {
-  if (isStatement(node) && isExecutableStatement(node) && isBlock(node.parent)) {
-    const { statements } = node.parent;
-    const slice = sliceAfter(statements, node);
-    getRangesWhere(slice, isExecutableStatement, (start, afterEnd) => cb(slice[start], slice[afterEnd - 1]));
-  } else {
-    cb(node, node);
-  }
-  function isExecutableStatement(s) {
-    return !isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && // `var x;` may declare a variable used above
-    !(isVariableStatement(s) && !(getCombinedNodeFlags(s) & 7 /* BlockScoped */) && s.declarationList.declarations.some((d) => !d.initializer));
-  }
-  function isPurelyTypeDeclaration(s) {
-    switch (s.kind) {
-      case 265 /* InterfaceDeclaration */:
-      case 266 /* TypeAliasDeclaration */:
-        return true;
-      case 268 /* ModuleDeclaration */:
-        return getModuleInstanceState(s) !== 1 /* Instantiated */;
-      case 267 /* EnumDeclaration */:
-        return !isEnumDeclarationWithPreservedEmit(s, options);
-      default:
-        return false;
-    }
-  }
 }
 function isExportsOrModuleExportsOrAlias(sourceFile, node) {
   let i = 0;
@@ -46434,6 +46364,8 @@ function createTypeChecker(host) {
   var currentNode;
   var varianceTypeParameter;
   var isInferencePartiallyBlocked = false;
+  var withinUnreachableCode = false;
+  var reportedUnreachableNodes;
   var emptySymbols = createSymbolTable();
   var arrayVariances = [1 /* Covariant */];
   var compilerOptions = host.getCompilerOptions();
@@ -65566,35 +65498,11 @@ function createTypeChecker(host) {
               /*reportErrors*/
               false
             ) : compareTypesIdentical(s, t);
-          } else if (variance === 1 /* Covariant */) {
-            related = isRelatedTo(
-              s,
-              t,
-              3 /* Both */,
-              reportErrors2,
-              /*headMessage*/
-              void 0,
-              intersectionState
-            );
-          } else if (variance === 2 /* Contravariant */) {
-            related = isRelatedTo(
-              t,
-              s,
-              3 /* Both */,
-              reportErrors2,
-              /*headMessage*/
-              void 0,
-              intersectionState
-            );
-          } else if (variance === 3 /* Bivariant */) {
-            related = isRelatedTo(
-              t,
-              s,
-              3 /* Both */,
-              /*reportErrors*/
-              false
-            );
-            if (!related) {
+          } else {
+            if (inVarianceComputation && varianceFlags & 16 /* Unreliable */) {
+              instantiateType(s, reportUnreliableMapper);
+            }
+            if (variance === 1 /* Covariant */) {
               related = isRelatedTo(
                 s,
                 t,
@@ -65604,19 +65512,8 @@ function createTypeChecker(host) {
                 void 0,
                 intersectionState
               );
-            }
-          } else {
-            related = isRelatedTo(
-              s,
-              t,
-              3 /* Both */,
-              reportErrors2,
-              /*headMessage*/
-              void 0,
-              intersectionState
-            );
-            if (related) {
-              related &= isRelatedTo(
+            } else if (variance === 2 /* Contravariant */) {
+              related = isRelatedTo(
                 t,
                 s,
                 3 /* Both */,
@@ -65625,6 +65522,46 @@ function createTypeChecker(host) {
                 void 0,
                 intersectionState
               );
+            } else if (variance === 3 /* Bivariant */) {
+              related = isRelatedTo(
+                t,
+                s,
+                3 /* Both */,
+                /*reportErrors*/
+                false
+              );
+              if (!related) {
+                related = isRelatedTo(
+                  s,
+                  t,
+                  3 /* Both */,
+                  reportErrors2,
+                  /*headMessage*/
+                  void 0,
+                  intersectionState
+                );
+              }
+            } else {
+              related = isRelatedTo(
+                s,
+                t,
+                3 /* Both */,
+                reportErrors2,
+                /*headMessage*/
+                void 0,
+                intersectionState
+              );
+              if (related) {
+                related &= isRelatedTo(
+                  t,
+                  s,
+                  3 /* Both */,
+                  reportErrors2,
+                  /*headMessage*/
+                  void 0,
+                  intersectionState
+                );
+              }
             }
           }
           if (!related) {
@@ -70668,18 +70605,22 @@ function createTypeChecker(host) {
         const symbol = getResolvedSymbol(expr);
         if (isConstantVariable(symbol)) {
           const declaration = symbol.valueDeclaration;
-          if (isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isAccessExpression(declaration.initializer) && isMatchingReference(reference, declaration.initializer.expression)) {
-            return declaration.initializer;
+          let initializer = getCandidateVariableDeclarationInitializer(declaration);
+          if (initializer && isAccessExpression(initializer) && isMatchingReference(reference, initializer.expression)) {
+            return initializer;
           }
           if (isBindingElement(declaration) && !declaration.initializer) {
-            const parent = declaration.parent.parent;
-            if (isVariableDeclaration(parent) && !parent.type && parent.initializer && (isIdentifier(parent.initializer) || isAccessExpression(parent.initializer)) && isMatchingReference(reference, parent.initializer)) {
+            initializer = getCandidateVariableDeclarationInitializer(declaration.parent.parent);
+            if (initializer && (isIdentifier(initializer) || isAccessExpression(initializer)) && isMatchingReference(reference, initializer)) {
               return declaration;
             }
           }
         }
       }
       return void 0;
+      function getCandidateVariableDeclarationInitializer(node) {
+        return isVariableDeclaration(node) && !node.type && node.initializer ? skipParentheses(node.initializer) : void 0;
+      }
     }
     function getDiscriminantPropertyAccess(expr, computedType) {
       if (declaredType.flags & 1048576 /* Union */ || computedType.flags & 1048576 /* Union */) {
@@ -71017,7 +70958,7 @@ function createTypeChecker(host) {
       if (!hasDefaultClause) {
         return caseType;
       }
-      const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, t.flags & 32768 /* Undefined */ ? undefinedType : getRegularTypeOfLiteralType(extractUnitType(t)))));
+      const defaultType = filterType(type, (t) => !(isUnitLikeType(t) && contains(switchTypes, t.flags & 32768 /* Undefined */ ? undefinedType : getRegularTypeOfLiteralType(extractUnitType(t)), (t1, t2) => isUnitType(t1) && areTypesComparable(t1, t2))));
       return caseType.flags & 131072 /* Never */ ? defaultType : getUnionType([caseType, defaultType]);
     }
     function narrowTypeByTypeName(type, typeName) {
@@ -71617,26 +71558,9 @@ function createTypeChecker(host) {
   function markIdentifierAliasReferenced(location) {
     const symbol = getResolvedSymbol(location);
     if (symbol && symbol !== argumentsSymbol && symbol !== unknownSymbol && !isThisInTypeQuery(location)) {
-      if (isIdentifierInAbstractMemberComputedPropertyName(location)) {
-        return;
-      }
       markAliasReferenced(symbol, location);
     }
   }
-  function isIdentifierInAbstractMemberComputedPropertyName(node) {
-    let parent = node.parent;
-    while (parent) {
-      if (isComputedPropertyName(parent)) {
-        const memberParent = parent.parent;
-        if ((isMethodDeclaration(memberParent) || isMethodSignature(memberParent) || isPropertyDeclaration(memberParent) || isPropertySignature(memberParent)) && hasSyntacticModifier(memberParent, 64 /* Abstract */)) {
-          return true;
-        }
-        return false;
-      }
-      parent = parent.parent;
-    }
-    return false;
-  }
   function markPropertyAliasReferenced(location, propSymbol, parentType) {
     const left = isPropertyAccessExpression(location) ? location.expression : location.left;
     if (isThisIdentifier(left) || !isIdentifier(left)) {
@@ -78664,6 +78588,9 @@ function createTypeChecker(host) {
     let fallbackReturnType = voidType;
     if (func.body.kind !== 242 /* Block */) {
       returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8 /* SkipGenericFunctions */);
+      if (isConstContext(func.body)) {
+        returnType = getRegularTypeOfLiteralType(returnType);
+      }
       if (isAsync) {
         returnType = unwrapAwaitedType(checkAwaitedType(
           returnType,
@@ -78695,7 +78622,7 @@ function createTypeChecker(host) {
           /*contextFlags*/
           void 0
         );
-        const returnType2 = contextualReturnType && (unwrapReturnType(contextualReturnType, functionFlags) || voidType).flags & 32768 /* Undefined */ ? undefinedType : voidType;
+        const returnType2 = contextualReturnType && someType(unwrapReturnType(contextualReturnType, functionFlags) || voidType, (t) => !!(t.flags & 32768 /* Undefined */)) ? undefinedType : voidType;
         return functionFlags & 2 /* Async */ ? createPromiseReturnType(func, returnType2) : (
           // Async function
           returnType2
@@ -78775,7 +78702,10 @@ function createTypeChecker(host) {
     const nextTypes = [];
     const isAsync = (getFunctionFlags(func) & 2 /* Async */) !== 0;
     forEachYieldExpression(func.body, (yieldExpression) => {
-      const yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
+      let yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
+      if (yieldExpression.expression && isConstContext(yieldExpression.expression)) {
+        yieldExpressionType = getRegularTypeOfLiteralType(yieldExpressionType);
+      }
       pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
       let nextType;
       if (yieldExpression.asteriskToken) {
@@ -78892,7 +78822,7 @@ function createTypeChecker(host) {
         if (type.flags & 131072 /* Never */) {
           hasReturnOfTypeNever = true;
         }
-        pushIfUnique(aggregatedTypes, type);
+        pushIfUnique(aggregatedTypes, isConstContext(expr) ? getRegularTypeOfLiteralType(type) : type);
       } else {
         hasReturnWithNoExpression = true;
       }
@@ -79879,7 +79809,8 @@ function createTypeChecker(host) {
     }
   }
   function isNotWithinNullishCoalesceExpression(node) {
-    return !isBinaryExpression(node.parent) || node.parent.operatorToken.kind !== 61 /* QuestionQuestionToken */;
+    const parent = walkUpOuterExpressions(node);
+    return !isBinaryExpression(parent) || parent.operatorToken.kind !== 61 /* QuestionQuestionToken */;
   }
   function getSyntacticNullishnessSemantics(node) {
     node = skipOuterExpressions(node);
@@ -83969,6 +83900,7 @@ function createTypeChecker(host) {
   }
   function getIterationTypesOfIterable(type, use, errorNode) {
     var _a, _b;
+    type = getReducedType(type);
     if (type === silentNeverType) {
       return silentNeverIterationTypes;
     }
@@ -84042,7 +83974,7 @@ function createTypeChecker(host) {
     }
     let noCache = false;
     if (use & 2 /* AllowsAsyncIterablesFlag */) {
-      const iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
+      let iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
       if (iterationTypes) {
         if (iterationTypes === noIterationTypes && errorNode) {
           noCache = true;
@@ -84050,6 +83982,10 @@ function createTypeChecker(host) {
           return use & 8 /* ForOfFlag */ ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode) : iterationTypes;
         }
       }
+      iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
+      if (iterationTypes !== noIterationTypes) {
+        return iterationTypes;
+      }
     }
     if (use & 1 /* AllowsSyncIterablesFlag */) {
       let iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) || getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
@@ -84067,15 +84003,7 @@ function createTypeChecker(host) {
           }
         }
       }
-    }
-    if (use & 2 /* AllowsAsyncIterablesFlag */) {
-      const iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
-      if (iterationTypes !== noIterationTypes) {
-        return iterationTypes;
-      }
-    }
-    if (use & 1 /* AllowsSyncIterablesFlag */) {
-      let iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
+      iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache);
       if (iterationTypes !== noIterationTypes) {
         if (use & 2 /* AllowsAsyncIterablesFlag */) {
           iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
@@ -84567,6 +84495,9 @@ function createTypeChecker(host) {
         return false;
       });
     }
+    if (node.label.flags & 1073741824 /* Unreachable */ && compilerOptions.allowUnusedLabels !== true) {
+      errorOrSuggestion(compilerOptions.allowUnusedLabels === false, node.label, Diagnostics.Unused_label);
+    }
     checkSourceElement(node.statement);
   }
   function checkThrowStatement(node) {
@@ -86459,10 +86390,12 @@ function createTypeChecker(host) {
   function checkSourceElement(node) {
     if (node) {
       const saveCurrentNode = currentNode;
+      const saveWithinUnreachableCode = withinUnreachableCode;
       currentNode = node;
       instantiationCount = 0;
       checkSourceElementWorker(node);
       currentNode = saveCurrentNode;
+      withinUnreachableCode = saveWithinUnreachableCode;
     }
   }
   function checkSourceElementWorker(node) {
@@ -86490,8 +86423,10 @@ function createTypeChecker(host) {
           cancellationToken.throwIfCancellationRequested();
       }
     }
-    if (kind >= 244 /* FirstStatement */ && kind <= 260 /* LastStatement */ && canHaveFlowNode(node) && node.flowNode && !isReachableFlowNode(node.flowNode)) {
-      errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, Diagnostics.Unreachable_code_detected);
+    if (compilerOptions.allowUnreachableCode !== true && !withinUnreachableCode) {
+      if (checkSourceElementUnreachable(node)) {
+        withinUnreachableCode = true;
+      }
     }
     switch (kind) {
       case 169 /* TypeParameter */:
@@ -86669,6 +86604,66 @@ function createTypeChecker(host) {
         return checkMissingDeclaration(node);
     }
   }
+  function checkSourceElementUnreachable(node) {
+    if (!isPotentiallyExecutableNode(node)) {
+      return false;
+    }
+    if (reportedUnreachableNodes == null ? void 0 : reportedUnreachableNodes.has(node)) {
+      return true;
+    }
+    if (!isSourceElementUnreachable(node)) {
+      return false;
+    }
+    (reportedUnreachableNodes ?? (reportedUnreachableNodes = /* @__PURE__ */ new Set())).add(node);
+    const sourceFile = getSourceFileOfNode(node);
+    let start = node.pos;
+    let end = node.end;
+    const parent = node.parent;
+    if (canHaveStatements(parent)) {
+      const statements = parent.statements;
+      const offset = statements.indexOf(node);
+      if (offset >= 0) {
+        let first2 = offset;
+        for (let i = offset - 1; i >= 0; i--) {
+          const prevNode = statements[i];
+          if (!isPotentiallyExecutableNode(prevNode) || reportedUnreachableNodes.has(prevNode) || !isSourceElementUnreachable(prevNode)) {
+            break;
+          }
+          first2 = i;
+          reportedUnreachableNodes.add(prevNode);
+        }
+        let last2 = offset;
+        for (let i = offset + 1; i < statements.length; i++) {
+          const nextNode = statements[i];
+          if (!isPotentiallyExecutableNode(nextNode) || !isSourceElementUnreachable(nextNode)) {
+            break;
+          }
+          last2 = i;
+          reportedUnreachableNodes.add(nextNode);
+        }
+        start = statements[first2].pos;
+        end = statements[last2].end;
+      }
+    }
+    start = skipTrivia(sourceFile.text, start);
+    addErrorOrSuggestion(compilerOptions.allowUnreachableCode === false, createFileDiagnostic(sourceFile, start, end - start, Diagnostics.Unreachable_code_detected));
+    return true;
+  }
+  function isSourceElementUnreachable(node) {
+    if (node.flags & 1073741824 /* Unreachable */) {
+      switch (node.kind) {
+        case 267 /* EnumDeclaration */:
+          return !isEnumConst(node) || shouldPreserveConstEnums(compilerOptions);
+        case 268 /* ModuleDeclaration */:
+          return isInstantiatedModule(node, shouldPreserveConstEnums(compilerOptions));
+        default:
+          return true;
+      }
+    } else if (canHaveFlowNode(node) && node.flowNode) {
+      return !isReachableFlowNode(node.flowNode);
+    }
+    return false;
+  }
   function checkJSDocCommentWorker(node) {
     if (isArray(node)) {
       forEach(node, (tag) => {
@@ -86831,6 +86826,7 @@ function createTypeChecker(host) {
     mark(afterMark);
     measure("Check", beforeMark, afterMark);
     (_b = tracing) == null ? void 0 : _b.pop();
+    reportedUnreachableNodes = void 0;
   }
   function unusedIsError(kind, isAmbient) {
     if (isAmbient) {
@@ -89986,6 +89982,11 @@ function createTypeChecker(host) {
           declarationList,
           blockScopeFlags === 4 /* Using */ ? Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_using_declaration : Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration
         );
+      } else if (isVariableStatement(declarationList.parent) && isCaseOrDefaultClause(declarationList.parent.parent)) {
+        return grammarErrorOnNode(
+          declarationList,
+          blockScopeFlags === 4 /* Using */ ? Diagnostics.using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block : Diagnostics.await_using_declarations_are_not_allowed_in_case_or_default_clauses_unless_contained_within_a_block
+        );
       }
       if (declarationList.flags & 33554432 /* Ambient */) {
         return grammarErrorOnNode(
@@ -102824,8 +102825,6 @@ function transformESNext(context) {
         return visitForStatement(node);
       case 251 /* ForOfStatement */:
         return visitForOfStatement(node);
-      case 256 /* SwitchStatement */:
-        return visitSwitchStatement(node);
       default:
         return visitEachChild(node, visitor, context);
     }
@@ -102989,60 +102988,6 @@ function transformESNext(context) {
     }
     return visitEachChild(node, visitor, context);
   }
-  function visitCaseOrDefaultClause(node, envBinding) {
-    if (getUsingKindOfStatements(node.statements) !== 0 /* None */) {
-      if (isCaseClause(node)) {
-        return factory2.updateCaseClause(
-          node,
-          visitNode(node.expression, visitor, isExpression),
-          transformUsingDeclarations(
-            node.statements,
-            /*start*/
-            0,
-            node.statements.length,
-            envBinding,
-            /*topLevelStatements*/
-            void 0
-          )
-        );
-      } else {
-        return factory2.updateDefaultClause(
-          node,
-          transformUsingDeclarations(
-            node.statements,
-            /*start*/
-            0,
-            node.statements.length,
-            envBinding,
-            /*topLevelStatements*/
-            void 0
-          )
-        );
-      }
-    }
-    return visitEachChild(node, visitor, context);
-  }
-  function visitSwitchStatement(node) {
-    const usingKind = getUsingKindOfCaseOrDefaultClauses(node.caseBlock.clauses);
-    if (usingKind) {
-      const envBinding = createEnvBinding();
-      return createDownlevelUsingStatements(
-        [
-          factory2.updateSwitchStatement(
-            node,
-            visitNode(node.expression, visitor, isExpression),
-            factory2.updateCaseBlock(
-              node.caseBlock,
-              node.caseBlock.clauses.map((clause) => visitCaseOrDefaultClause(clause, envBinding))
-            )
-          )
-        ],
-        envBinding,
-        usingKind === 2 /* Async */
-      );
-    }
-    return visitEachChild(node, visitor, context);
-  }
   function transformUsingDeclarations(statementsIn, start, end, envBinding, topLevelStatements) {
     const statements = [];
     for (let i = start; i < end; i++) {
@@ -103408,15 +103353,6 @@ function getUsingKindOfStatements(statements) {
   }
   return result;
 }
-function getUsingKindOfCaseOrDefaultClauses(clauses) {
-  let result = 0 /* None */;
-  for (const clause of clauses) {
-    const usingKind = getUsingKindOfStatements(clause.statements);
-    if (usingKind === 2 /* Async */) return 2 /* Async */;
-    if (usingKind > result) result = usingKind;
-  }
-  return result;
-}
 
 // src/compiler/transformers/jsx.ts
 function transformJsx(context) {
@@ -124529,7 +124465,7 @@ function createProgram(_rootNamesOrOptions, _options, _host, _oldProgram, _confi
       }
     }
     if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly || options.rewriteRelativeImportExtensions)) {
-      createOptionValueDiagnostic("allowImportingTsExtensions", Diagnostics.Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set);
+      createOptionValueDiagnostic("allowImportingTsExtensions", Diagnostics.Option_allowImportingTsExtensions_can_only_be_used_when_one_of_noEmit_emitDeclarationOnly_or_rewriteRelativeImportExtensions_is_set);
     }
     const moduleResolution = getEmitModuleResolutionKind(options);
     if (options.resolvePackageJsonExports && !moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
@@ -132131,18 +132067,23 @@ function executeCommandLineWorker(sys2, cb, commandLine) {
         return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
       }
     }
-  } else if (commandLine.fileNames.length === 0) {
+  } else if (!commandLine.options.ignoreConfig || commandLine.fileNames.length === 0) {
     const searchPath = normalizePath(sys2.getCurrentDirectory());
     configFileName = findConfigFile(searchPath, (fileName) => sys2.fileExists(fileName));
-  }
-  if (commandLine.fileNames.length === 0 && !configFileName) {
-    if (commandLine.options.showConfig) {
-      reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, normalizePath(sys2.getCurrentDirectory())));
-    } else {
-      printVersion(sys2);
-      printHelp(sys2, commandLine);
+    if (commandLine.fileNames.length !== 0) {
+      if (configFileName) {
+        reportDiagnostic(createCompilerDiagnostic(Diagnostics.tsconfig_json_is_present_but_will_not_be_loaded_if_files_are_specified_on_commandline_Use_ignoreConfig_to_skip_this_error));
+        return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
+      }
+    } else if (!configFileName) {
+      if (commandLine.options.showConfig) {
+        reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, normalizePath(sys2.getCurrentDirectory())));
+      } else {
+        printVersion(sys2);
+        printHelp(sys2, commandLine);
+      }
+      return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
     }
-    return sys2.exit(1 /* DiagnosticsPresent_OutputsSkipped */);
   }
   const currentDirectory = sys2.getCurrentDirectory();
   const commandLineOptions = convertToOptionsWithAbsolutePaths(