typescript 5.5.0-dev.20240404 → 5.5.0-dev.20240405

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-dev.20240404`;
+var version = `${versionMajorMinor}.0-dev.20240405`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1684,6 +1684,7 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`,
         attachFlowNodeDebugInfoWorker(flowNode);
       }
     }
+    return flowNode;
   }
   Debug2.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo;
   let nodeArrayProto;
@@ -1959,7 +1960,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
       return !!(f.flags & 128 /* SwitchClause */);
     }
     function hasAntecedents(f) {
-      return !!(f.flags & 12 /* Label */) && !!f.antecedents;
+      return !!(f.flags & 12 /* Label */) && !!f.antecedent;
     }
     function hasAntecedent(f) {
       return !!(f.flags & hasAntecedentFlags);
@@ -2008,7 +2009,7 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
         links[id] = graphNode = { id, flowNode: flowNode2, edges: [], text: "", lane: -1, endLane: -1, level: -1, circular: false };
         nodes.push(graphNode);
         if (hasAntecedents(flowNode2)) {
-          for (const antecedent of flowNode2.antecedents) {
+          for (const antecedent of flowNode2.antecedent) {
             buildGraphEdge(graphNode, antecedent, seen);
           }
         } else if (hasAntecedent(flowNode2)) {
@@ -2105,14 +2106,11 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
       if (circular) {
         text = `${text}#${getDebugFlowNodeId(flowNode2)}`;
       }
-      if (hasNode(flowNode2)) {
-        if (flowNode2.node) {
-          text += ` (${getNodeText(flowNode2.node)})`;
-        }
-      } else if (isFlowSwitchClause(flowNode2)) {
+      if (isFlowSwitchClause(flowNode2)) {
         const clauses = [];
-        for (let i = flowNode2.clauseStart; i < flowNode2.clauseEnd; i++) {
-          const clause = flowNode2.switchStatement.caseBlock.clauses[i];
+        const { switchStatement, clauseStart, clauseEnd } = flowNode2.node;
+        for (let i = clauseStart; i < clauseEnd; i++) {
+          const clause = switchStatement.caseBlock.clauses[i];
           if (isDefaultClause(clause)) {
             clauses.push("default");
           } else {
@@ -2120,6 +2118,10 @@ m2: ${this.mapper2.__debugToString().split("\n").join("\n    ")}`;
           }
         }
         text += ` (${clauses.join(", ")})`;
+      } else if (hasNode(flowNode2)) {
+        if (flowNode2.node) {
+          text += ` (${getNodeText(flowNode2.node)})`;
+        }
       }
       return circular === "circularity" ? `Circular(${text})` : text;
     }
@@ -11747,8 +11749,11 @@ function getTokenPosOfNode(node, sourceFile, includeJsDoc) {
   if (includeJsDoc && hasJSDocNodes(node)) {
     return getTokenPosOfNode(node.jsDoc[0], sourceFile);
   }
-  if (node.kind === 352 /* SyntaxList */ && node._children.length > 0) {
-    return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc);
+  if (node.kind === 352 /* SyntaxList */) {
+    const first2 = firstOrUndefined(getNodeChildren(node));
+    if (first2) {
+      return getTokenPosOfNode(first2, sourceFile, includeJsDoc);
+    }
   }
   return skipTrivia(
     (sourceFile || getSourceFileOfNode(node)).text,
@@ -17687,79 +17692,81 @@ function replaceFirstStar(s, replacement) {
 function getNameFromImportAttribute(node) {
   return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
 }
-function isSyntacticallyString(expr) {
-  expr = skipOuterExpressions(expr);
-  switch (expr.kind) {
-    case 226 /* BinaryExpression */:
-      const left = expr.left;
-      const right = expr.right;
-      return expr.operatorToken.kind === 40 /* PlusToken */ && (isSyntacticallyString(left) || isSyntacticallyString(right));
-    case 228 /* TemplateExpression */:
-    case 11 /* StringLiteral */:
-    case 15 /* NoSubstitutionTemplateLiteral */:
-      return true;
-  }
-  return false;
+function evaluatorResult(value, isSyntacticallyString = false, resolvedOtherFiles = false) {
+  return { value, isSyntacticallyString, resolvedOtherFiles };
 }
 function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
   function evaluate(expr, location) {
+    let isSyntacticallyString = false;
+    let resolvedOtherFiles = false;
+    expr = skipParentheses(expr);
     switch (expr.kind) {
       case 224 /* PrefixUnaryExpression */:
-        const value = evaluate(expr.operand, location);
-        if (typeof value === "number") {
+        const result = evaluate(expr.operand, location);
+        resolvedOtherFiles = result.resolvedOtherFiles;
+        if (typeof result.value === "number") {
           switch (expr.operator) {
             case 40 /* PlusToken */:
-              return value;
+              return evaluatorResult(result.value, isSyntacticallyString, resolvedOtherFiles);
             case 41 /* MinusToken */:
-              return -value;
+              return evaluatorResult(-result.value, isSyntacticallyString, resolvedOtherFiles);
             case 55 /* TildeToken */:
-              return ~value;
+              return evaluatorResult(~result.value, isSyntacticallyString, resolvedOtherFiles);
           }
         }
         break;
-      case 226 /* BinaryExpression */:
+      case 226 /* BinaryExpression */: {
         const left = evaluate(expr.left, location);
         const right = evaluate(expr.right, location);
-        if (typeof left === "number" && typeof right === "number") {
+        isSyntacticallyString = (left.isSyntacticallyString || right.isSyntacticallyString) && expr.operatorToken.kind === 40 /* PlusToken */;
+        resolvedOtherFiles = left.resolvedOtherFiles || right.resolvedOtherFiles;
+        if (typeof left.value === "number" && typeof right.value === "number") {
           switch (expr.operatorToken.kind) {
             case 52 /* BarToken */:
-              return left | right;
+              return evaluatorResult(left.value | right.value, isSyntacticallyString, resolvedOtherFiles);
             case 51 /* AmpersandToken */:
-              return left & right;
+              return evaluatorResult(left.value & right.value, isSyntacticallyString, resolvedOtherFiles);
             case 49 /* GreaterThanGreaterThanToken */:
-              return left >> right;
+              return evaluatorResult(left.value >> right.value, isSyntacticallyString, resolvedOtherFiles);
             case 50 /* GreaterThanGreaterThanGreaterThanToken */:
-              return left >>> right;
+              return evaluatorResult(left.value >>> right.value, isSyntacticallyString, resolvedOtherFiles);
             case 48 /* LessThanLessThanToken */:
-              return left << right;
+              return evaluatorResult(left.value << right.value, isSyntacticallyString, resolvedOtherFiles);
             case 53 /* CaretToken */:
-              return left ^ right;
+              return evaluatorResult(left.value ^ right.value, isSyntacticallyString, resolvedOtherFiles);
             case 42 /* AsteriskToken */:
-              return left * right;
+              return evaluatorResult(left.value * right.value, isSyntacticallyString, resolvedOtherFiles);
             case 44 /* SlashToken */:
-              return left / right;
+              return evaluatorResult(left.value / right.value, isSyntacticallyString, resolvedOtherFiles);
             case 40 /* PlusToken */:
-              return left + right;
+              return evaluatorResult(left.value + right.value, isSyntacticallyString, resolvedOtherFiles);
             case 41 /* MinusToken */:
-              return left - right;
+              return evaluatorResult(left.value - right.value, isSyntacticallyString, resolvedOtherFiles);
             case 45 /* PercentToken */:
-              return left % right;
+              return evaluatorResult(left.value % right.value, isSyntacticallyString, resolvedOtherFiles);
             case 43 /* AsteriskAsteriskToken */:
-              return left ** right;
+              return evaluatorResult(left.value ** right.value, isSyntacticallyString, resolvedOtherFiles);
           }
-        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
-          return "" + left + right;
+        } else if ((typeof left.value === "string" || typeof left.value === "number") && (typeof right.value === "string" || typeof right.value === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
+          return evaluatorResult(
+            "" + left.value + right.value,
+            isSyntacticallyString,
+            resolvedOtherFiles
+          );
         }
         break;
+      }
       case 11 /* StringLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
-        return expr.text;
+        return evaluatorResult(
+          expr.text,
+          /*isSyntacticallyString*/
+          true
+        );
       case 228 /* TemplateExpression */:
         return evaluateTemplateExpression(expr, location);
       case 9 /* NumericLiteral */:
-        return +expr.text;
-      case 217 /* ParenthesizedExpression */:
-        return evaluate(expr.expression, location);
+        return evaluatorResult(+expr.text);
       case 80 /* Identifier */:
         return evaluateEntityNameExpression(expr, location);
       case 211 /* PropertyAccessExpression */:
@@ -17770,19 +17777,36 @@ function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameEx
       case 212 /* ElementAccessExpression */:
         return evaluateElementAccessExpression(expr, location);
     }
-    return void 0;
+    return evaluatorResult(
+      /*value*/
+      void 0,
+      isSyntacticallyString,
+      resolvedOtherFiles
+    );
   }
   function evaluateTemplateExpression(expr, location) {
     let result = expr.head.text;
+    let resolvedOtherFiles = false;
     for (const span of expr.templateSpans) {
-      const value = evaluate(span.expression, location);
-      if (value === void 0) {
-        return void 0;
+      const spanResult = evaluate(span.expression, location);
+      if (spanResult.value === void 0) {
+        return evaluatorResult(
+          /*value*/
+          void 0,
+          /*isSyntacticallyString*/
+          true
+        );
       }
-      result += value;
+      result += spanResult.value;
       result += span.literal.text;
+      resolvedOtherFiles || (resolvedOtherFiles = spanResult.resolvedOtherFiles);
     }
-    return result;
+    return evaluatorResult(
+      result,
+      /*isSyntacticallyString*/
+      true,
+      resolvedOtherFiles
+    );
   }
   return evaluate;
 }
@@ -21926,7 +21950,7 @@ function createNodeFactory(flags, baseFactory2) {
   }
   function createSyntaxList(children) {
     const node = createBaseNode(352 /* SyntaxList */);
-    node._children = children;
+    setNodeChildren(node, children);
     return node;
   }
   function createNotEmittedStatement(original) {
@@ -24703,6 +24727,19 @@ function isJSDocImportTag(node) {
   return node.kind === 351 /* JSDocImportTag */;
 }
 
+// src/compiler/factory/nodeChildren.ts
+var nodeChildren = /* @__PURE__ */ new WeakMap();
+function getNodeChildren(node) {
+  return nodeChildren.get(node);
+}
+function setNodeChildren(node, children) {
+  nodeChildren.set(node, children);
+  return children;
+}
+function unsetNodeChildren(node) {
+  nodeChildren.delete(node);
+}
+
 // src/compiler/factory/utilities.ts
 function createEmptyExports(factory2) {
   return factory2.createExportDeclaration(
@@ -33334,9 +33371,7 @@ var IncrementalParser;
       if (aggressiveChecks && shouldCheckNode(node)) {
         text = oldText.substring(node.pos, node.end);
       }
-      if (node._children) {
-        node._children = void 0;
-      }
+      unsetNodeChildren(node);
       setTextRangePosEnd(node, node.pos + delta, node.end + delta);
       if (aggressiveChecks && shouldCheckNode(node)) {
         Debug.assert(text === newText.substring(node.pos, node.end));
@@ -33350,7 +33385,6 @@ var IncrementalParser;
       checkNodePositions(node, aggressiveChecks);
     }
     function visitArray2(array) {
-      array._children = void 0;
       setTextRangePosEnd(array, array.pos + delta, array.end + delta);
       for (const node of array) {
         visitNode3(node);
@@ -33422,7 +33456,7 @@ var IncrementalParser;
       const fullEnd = child.end;
       if (fullEnd >= changeStart) {
         child.intersectsChange = true;
-        child._children = void 0;
+        unsetNodeChildren(child);
         adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
         forEachChild(child, visitNode3, visitArray2);
         if (hasJSDocNodes(child)) {
@@ -33452,7 +33486,6 @@ var IncrementalParser;
       const fullEnd = array.end;
       if (fullEnd >= changeStart) {
         array.intersectsChange = true;
-        array._children = void 0;
         adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta);
         for (const node of array) {
           visitNode3(node);
@@ -39595,9 +39628,8 @@ function getModuleInstanceStateForAliasTarget(specifier, visited) {
   }
   return 1 /* Instantiated */;
 }
-function initFlowNode(node) {
-  Debug.attachFlowNodeDebugInfo(node);
-  return node;
+function createFlowNode(flags, node, antecedent) {
+  return Debug.attachFlowNodeDebugInfo({ flags, id: 0, node, antecedent });
 }
 var binder = /* @__PURE__ */ createBinder();
 function bindSourceFile(file, options) {
@@ -39631,14 +39663,27 @@ function createBinder() {
   var preSwitchCaseFlow;
   var activeLabelList;
   var hasExplicitReturn;
+  var hasFlowEffects;
   var emitFlags;
   var inStrictMode;
   var inAssignmentPattern = false;
   var symbolCount = 0;
   var Symbol12;
   var classifiableNames;
-  var unreachableFlow = { flags: 1 /* Unreachable */ };
-  var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
+  var unreachableFlow = createFlowNode(
+    1 /* Unreachable */,
+    /*node*/
+    void 0,
+    /*antecedent*/
+    void 0
+  );
+  var reportedUnreachableFlow = createFlowNode(
+    1 /* Unreachable */,
+    /*node*/
+    void 0,
+    /*antecedent*/
+    void 0
+  );
   var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
   return bindSourceFile2;
   function createDiagnosticForNode2(node, message, ...args) {
@@ -39690,6 +39735,7 @@ function createBinder() {
     currentExceptionTarget = void 0;
     activeLabelList = void 0;
     hasExplicitReturn = false;
+    hasFlowEffects = false;
     inAssignmentPattern = false;
     emitFlags = 0 /* None */;
   }
@@ -39957,7 +40003,13 @@ function createBinder() {
       const saveHasExplicitReturn = hasExplicitReturn;
       const isImmediatelyInvoked = containerFlags & 16 /* IsFunctionExpression */ && !hasSyntacticModifier(node, 1024 /* Async */) && !node.asteriskToken && !!getImmediatelyInvokedFunctionExpression(node) || node.kind === 175 /* ClassStaticBlockDeclaration */;
       if (!isImmediatelyInvoked) {
-        currentFlow = initFlowNode({ flags: 2 /* Start */ });
+        currentFlow = createFlowNode(
+          2 /* Start */,
+          /*node*/
+          void 0,
+          /*antecedent*/
+          void 0
+        );
         if (containerFlags & (16 /* IsFunctionExpression */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */)) {
           currentFlow.node = node;
         }
@@ -40147,8 +40199,8 @@ function createBinder() {
   function isNarrowingExpression(expr) {
     switch (expr.kind) {
       case 80 /* Identifier */:
-      case 81 /* PrivateIdentifier */:
       case 110 /* ThisKeyword */:
+        return true;
       case 211 /* PropertyAccessExpression */:
       case 212 /* ElementAccessExpression */:
         return containsNarrowableReference(expr);
@@ -40170,7 +40222,22 @@ function createBinder() {
     return false;
   }
   function isNarrowableReference(expr) {
-    return isDottedName(expr) || (isPropertyAccessExpression(expr) || isNonNullExpression(expr) || isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) || isBinaryExpression(expr) && expr.operatorToken.kind === 28 /* CommaToken */ && isNarrowableReference(expr.right) || isElementAccessExpression(expr) && (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression) || isAssignmentExpression(expr) && isNarrowableReference(expr.left);
+    switch (expr.kind) {
+      case 80 /* Identifier */:
+      case 110 /* ThisKeyword */:
+      case 108 /* SuperKeyword */:
+      case 236 /* MetaProperty */:
+        return true;
+      case 211 /* PropertyAccessExpression */:
+      case 217 /* ParenthesizedExpression */:
+      case 235 /* NonNullExpression */:
+        return isNarrowableReference(expr.expression);
+      case 212 /* ElementAccessExpression */:
+        return (isStringOrNumericLiteralLike(expr.argumentExpression) || isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression);
+      case 226 /* BinaryExpression */:
+        return expr.operatorToken.kind === 28 /* CommaToken */ && isNarrowableReference(expr.right) || isAssignmentOperator(expr.operatorToken.kind) && isLeftHandSideExpression(expr.left);
+    }
+    return false;
   }
   function containsNarrowableReference(expr) {
     return isNarrowableReference(expr) || isOptionalChain(expr) && containsNarrowableReference(expr.expression);
@@ -40227,20 +40294,32 @@ function createBinder() {
     return containsNarrowableReference(expr);
   }
   function createBranchLabel() {
-    return initFlowNode({ flags: 4 /* BranchLabel */, antecedents: void 0 });
+    return createFlowNode(
+      4 /* BranchLabel */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
   }
   function createLoopLabel() {
-    return initFlowNode({ flags: 8 /* LoopLabel */, antecedents: void 0 });
+    return createFlowNode(
+      8 /* LoopLabel */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
   }
   function createReduceLabel(target, antecedents, antecedent) {
-    return initFlowNode({ flags: 1024 /* ReduceLabel */, target, antecedents, antecedent });
+    return createFlowNode(1024 /* ReduceLabel */, { target, antecedents }, antecedent);
   }
   function setFlowNodeReferenced(flow) {
     flow.flags |= flow.flags & 2048 /* Referenced */ ? 4096 /* Shared */ : 2048 /* Referenced */;
   }
   function addAntecedent(label, antecedent) {
-    if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedents, antecedent)) {
-      (label.antecedents || (label.antecedents = [])).push(antecedent);
+    if (!(antecedent.flags & 1 /* Unreachable */) && !contains(label.antecedent, antecedent)) {
+      (label.antecedent || (label.antecedent = [])).push(antecedent);
       setFlowNodeReferenced(antecedent);
     }
   }
@@ -40258,15 +40337,16 @@ function createBinder() {
       return antecedent;
     }
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags, antecedent, node: expression });
+    return createFlowNode(flags, expression, antecedent);
   }
   function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) {
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags: 128 /* SwitchClause */, antecedent, switchStatement, clauseStart, clauseEnd });
+    return createFlowNode(128 /* SwitchClause */, { switchStatement, clauseStart, clauseEnd }, antecedent);
   }
   function createFlowMutation(flags, antecedent, node) {
     setFlowNodeReferenced(antecedent);
-    const result = initFlowNode({ flags, antecedent, node });
+    hasFlowEffects = true;
+    const result = createFlowNode(flags, node, antecedent);
     if (currentExceptionTarget) {
       addAntecedent(currentExceptionTarget, result);
     }
@@ -40274,10 +40354,11 @@ function createBinder() {
   }
   function createFlowCall(antecedent, node) {
     setFlowNodeReferenced(antecedent);
-    return initFlowNode({ flags: 512 /* Call */, antecedent, node });
+    hasFlowEffects = true;
+    return createFlowNode(512 /* Call */, node, antecedent);
   }
   function finishFlowLabel(flow) {
-    const antecedents = flow.antecedents;
+    const antecedents = flow.antecedent;
     if (!antecedents) {
       return unreachableFlow;
     }
@@ -40431,6 +40512,7 @@ function createBinder() {
       }
     }
     currentFlow = unreachableFlow;
+    hasFlowEffects = true;
   }
   function findActiveLabel(name) {
     for (let label = activeLabelList; label; label = label.next) {
@@ -40445,6 +40527,7 @@ function createBinder() {
     if (flowLabel) {
       addAntecedent(flowLabel, currentFlow);
       currentFlow = unreachableFlow;
+      hasFlowEffects = true;
     }
   }
   function bindBreakOrContinueStatement(node) {
@@ -40484,19 +40567,19 @@ function createBinder() {
     currentExceptionTarget = saveExceptionTarget;
     if (node.finallyBlock) {
       const finallyLabel = createBranchLabel();
-      finallyLabel.antecedents = concatenate(concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents);
+      finallyLabel.antecedent = concatenate(concatenate(normalExitLabel.antecedent, exceptionLabel.antecedent), returnLabel.antecedent);
       currentFlow = finallyLabel;
       bind(node.finallyBlock);
       if (currentFlow.flags & 1 /* Unreachable */) {
         currentFlow = unreachableFlow;
       } else {
-        if (currentReturnTarget && returnLabel.antecedents) {
-          addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow));
+        if (currentReturnTarget && returnLabel.antecedent) {
+          addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedent, currentFlow));
         }
-        if (currentExceptionTarget && exceptionLabel.antecedents) {
-          addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow));
+        if (currentExceptionTarget && exceptionLabel.antecedent) {
+          addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedent, currentFlow));
         }
-        currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow;
+        currentFlow = normalExitLabel.antecedent ? createReduceLabel(finallyLabel, normalExitLabel.antecedent, currentFlow) : unreachableFlow;
       }
     } else {
       currentFlow = finishFlowLabel(normalExitLabel);
@@ -40512,7 +40595,7 @@ function createBinder() {
     bind(node.caseBlock);
     addAntecedent(postSwitchLabel, currentFlow);
     const hasDefault = forEach(node.caseBlock.clauses, (c) => c.kind === 297 /* DefaultClause */);
-    node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents;
+    node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedent;
     if (!hasDefault) {
       addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0));
     }
@@ -40700,8 +40783,12 @@ function createBinder() {
       if (isLogicalOrCoalescingBinaryOperator(operator) || isLogicalOrCoalescingAssignmentOperator(operator)) {
         if (isTopLevelLogicalExpression(node)) {
           const postExpressionLabel = createBranchLabel();
+          const saveCurrentFlow = currentFlow;
+          const saveHasFlowEffects = hasFlowEffects;
+          hasFlowEffects = false;
           bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel);
-          currentFlow = finishFlowLabel(postExpressionLabel);
+          currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+          hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
         } else {
           bindLogicalLikeExpression(node, currentTrueTarget, currentFalseTarget);
         }
@@ -40773,6 +40860,9 @@ function createBinder() {
     const trueLabel = createBranchLabel();
     const falseLabel = createBranchLabel();
     const postExpressionLabel = createBranchLabel();
+    const saveCurrentFlow = currentFlow;
+    const saveHasFlowEffects = hasFlowEffects;
+    hasFlowEffects = false;
     bindCondition(node.condition, trueLabel, falseLabel);
     currentFlow = finishFlowLabel(trueLabel);
     bind(node.questionToken);
@@ -40782,7 +40872,8 @@ function createBinder() {
     bind(node.colonToken);
     bind(node.whenFalse);
     addAntecedent(postExpressionLabel, currentFlow);
-    currentFlow = finishFlowLabel(postExpressionLabel);
+    currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+    hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
   }
   function bindInitializedVariableFlow(node) {
     const name = !isOmittedExpression(node) ? node.name : void 0;
@@ -40894,8 +40985,11 @@ function createBinder() {
   function bindOptionalChainFlow(node) {
     if (isTopLevelLogicalExpression(node)) {
       const postExpressionLabel = createBranchLabel();
+      const saveCurrentFlow = currentFlow;
+      const saveHasFlowEffects = hasFlowEffects;
       bindOptionalChain(node, postExpressionLabel, postExpressionLabel);
-      currentFlow = finishFlowLabel(postExpressionLabel);
+      currentFlow = hasFlowEffects ? finishFlowLabel(postExpressionLabel) : saveCurrentFlow;
+      hasFlowEffects || (hasFlowEffects = saveHasFlowEffects);
     } else {
       bindOptionalChain(node, currentTrueTarget, currentFalseTarget);
     }
@@ -41116,7 +41210,13 @@ function createBinder() {
       const host = typeAlias.parent.parent;
       container = getEnclosingContainer(host) || file;
       blockScopeContainer = getEnclosingBlockScopeContainer(host) || file;
-      currentFlow = initFlowNode({ flags: 2 /* Start */ });
+      currentFlow = createFlowNode(
+        2 /* Start */,
+        /*node*/
+        void 0,
+        /*antecedent*/
+        void 0
+      );
       parent = typeAlias;
       bind(typeAlias.typeExpression);
       const declName = getNameOfDeclaration(typeAlias);
@@ -41186,7 +41286,13 @@ function createBinder() {
       const enclosingBlockScopeContainer = host ? getEnclosingBlockScopeContainer(host) : void 0;
       container = enclosingContainer || file;
       blockScopeContainer = enclosingBlockScopeContainer || file;
-      currentFlow = initFlowNode({ flags: 2 /* Start */ });
+      currentFlow = createFlowNode(
+        2 /* Start */,
+        /*node*/
+        void 0,
+        /*antecedent*/
+        void 0
+      );
       parent = jsDocImportTag;
       bind(jsDocImportTag.importClause);
     }
@@ -47851,7 +47957,7 @@ function createTypeChecker(host) {
   }
   function getMeaningOfEntityNameReference(entityName) {
     let meaning;
-    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */) {
+    if (entityName.parent.kind === 186 /* TypeQuery */ || entityName.parent.kind === 233 /* ExpressionWithTypeArguments */ && !isPartOfTypeNode(entityName.parent) || entityName.parent.kind === 167 /* ComputedPropertyName */ || entityName.parent.kind === 182 /* TypePredicate */ && entityName.parent.parameterName === entityName) {
       meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
     } else if (entityName.kind === 166 /* QualifiedName */ || entityName.kind === 211 /* PropertyAccessExpression */ || entityName.parent.kind === 271 /* ImportEqualsDeclaration */ || entityName.parent.kind === 166 /* QualifiedName */ && entityName.parent.left === entityName || entityName.parent.kind === 211 /* PropertyAccessExpression */ && entityName.parent.expression === entityName || entityName.parent.kind === 212 /* ElementAccessExpression */ && entityName.parent.expression === entityName) {
       meaning = 1920 /* Namespace */;
@@ -50027,7 +50133,28 @@ function createTypeChecker(host) {
         return { introducesError, node };
       }
       const meaning = getMeaningOfEntityNameReference(node);
-      const sym = resolveEntityName(
+      let sym;
+      if (isThisIdentifier(leftmost)) {
+        sym = getSymbolOfDeclaration(getThisContainer(
+          leftmost,
+          /*includeArrowFunctions*/
+          false,
+          /*includeClassComputedPropertyName*/
+          false
+        ));
+        if (isSymbolAccessible(
+          sym,
+          leftmost,
+          meaning,
+          /*shouldComputeAliasesToMakeVisible*/
+          false
+        ).accessibility !== 0 /* Accessible */) {
+          introducesError = true;
+          context.tracker.reportInaccessibleThisError();
+        }
+        return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+      }
+      sym = resolveEntityName(
         leftmost,
         meaning,
         /*ignoreErrors*/
@@ -50036,27 +50163,44 @@ function createTypeChecker(host) {
         true
       );
       if (sym) {
-        if (isSymbolAccessible(
+        if (sym.flags & 1 /* FunctionScopedVariable */ && sym.valueDeclaration) {
+          if (isParameterDeclaration(sym.valueDeclaration)) {
+            return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+          }
+        }
+        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the curent context if they are are resolvable
+        !isDeclarationName(node) && isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
           meaning,
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
-          if (!isDeclarationName(node)) {
-            introducesError = true;
-          }
+          introducesError = true;
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
         }
-        if (isIdentifier(node)) {
+        return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
+      }
+      return { introducesError, node };
+      function attachSymbolToLeftmostIdentifier(node2) {
+        if (node2 === leftmost) {
           const type = getDeclaredTypeOfSymbol(sym);
-          const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
+          const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node2);
           name.symbol = sym;
-          return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */), node) };
+          return setTextRange(setEmitFlags(setOriginalNode(name, node2), 16777216 /* NoAsciiEscaping */), node2);
         }
+        const updated = visitEachChild(
+          node2,
+          (c) => attachSymbolToLeftmostIdentifier(c),
+          /*context*/
+          void 0
+        );
+        if (updated !== node2) {
+          setTextRange(updated, node2);
+        }
+        return updated;
       }
-      return { introducesError, node };
     }
     function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
@@ -50217,11 +50361,12 @@ function createTypeChecker(host) {
           return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
+          if (isDeclarationName(node)) {
+            return node;
+          }
           const { introducesError, node: result } = trackExistingEntityName(node, context);
           hadError = hadError || introducesError;
-          if (result !== node) {
-            return result;
-          }
+          return result;
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -52391,6 +52536,9 @@ function createTypeChecker(host) {
       }
     }
     if (isParameter(declaration)) {
+      if (!declaration.symbol) {
+        return;
+      }
       const func = declaration.parent;
       if (func.kind === 178 /* SetAccessor */ && hasBindableName(func)) {
         const getter = getDeclarationOfKind(getSymbolOfDeclaration(declaration.parent), 177 /* GetAccessor */);
@@ -53750,7 +53898,7 @@ function createTypeChecker(host) {
             for (const member of declaration.members) {
               if (hasBindableName(member)) {
                 const memberSymbol = getSymbolOfDeclaration(member);
-                const value = getEnumMemberValue(member);
+                const value = getEnumMemberValue(member).value;
                 const memberType = getFreshTypeOfLiteralType(
                   value !== void 0 ? getEnumLiteralType(value, getSymbolId(symbol), memberSymbol) : createComputedEnumType(memberSymbol)
                 );
@@ -60886,8 +61034,8 @@ function createTypeChecker(host) {
           }
           return false;
         }
-        const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, 306 /* EnumMember */));
-        const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, 306 /* EnumMember */));
+        const sourceValue = getEnumMemberValue(getDeclarationOfKind(sourceProperty, 306 /* EnumMember */)).value;
+        const targetValue = getEnumMemberValue(getDeclarationOfKind(targetProperty, 306 /* EnumMember */)).value;
         if (sourceValue !== targetValue) {
           const sourceIsString = typeof sourceValue === "string";
           const targetIsString = typeof targetValue === "string";
@@ -65769,7 +65917,7 @@ function createTypeChecker(host) {
     return false;
   }
   function getFlowNodeId(flow) {
-    if (!flow.id || flow.id < 0) {
+    if (flow.id <= 0) {
       flow.id = nextFlowId;
       nextFlowId++;
     }
@@ -66404,33 +66552,34 @@ function createTypeChecker(host) {
         }
         flow = flow.antecedent;
       } else if (flags & 4 /* BranchLabel */) {
-        return some(flow.antecedents, (f) => isReachableFlowNodeWorker(
+        return some(flow.antecedent, (f) => isReachableFlowNodeWorker(
           f,
           /*noCacheCheck*/
           false
         ));
       } else if (flags & 8 /* LoopLabel */) {
-        const antecedents = flow.antecedents;
+        const antecedents = flow.antecedent;
         if (antecedents === void 0 || antecedents.length === 0) {
           return false;
         }
         flow = antecedents[0];
       } else if (flags & 128 /* SwitchClause */) {
-        if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) {
+        const data = flow.node;
+        if (data.clauseStart === data.clauseEnd && isExhaustiveSwitchStatement(data.switchStatement)) {
           return false;
         }
         flow = flow.antecedent;
       } else if (flags & 1024 /* ReduceLabel */) {
         lastFlowNode = void 0;
-        const target = flow.target;
-        const saveAntecedents = target.antecedents;
-        target.antecedents = flow.antecedents;
+        const target = flow.node.target;
+        const saveAntecedents = target.antecedent;
+        target.antecedent = flow.node.antecedents;
         const result = isReachableFlowNodeWorker(
           flow.antecedent,
           /*noCacheCheck*/
           false
         );
-        target.antecedents = saveAntecedents;
+        target.antecedent = saveAntecedents;
         return result;
       } else {
         return !(flags & 1 /* Unreachable */);
@@ -66460,23 +66609,23 @@ function createTypeChecker(host) {
         }
         flow = flow.antecedent;
       } else if (flags & 4 /* BranchLabel */) {
-        return every(flow.antecedents, (f) => isPostSuperFlowNode(
+        return every(flow.antecedent, (f) => isPostSuperFlowNode(
           f,
           /*noCacheCheck*/
           false
         ));
       } else if (flags & 8 /* LoopLabel */) {
-        flow = flow.antecedents[0];
+        flow = flow.antecedent[0];
       } else if (flags & 1024 /* ReduceLabel */) {
-        const target = flow.target;
-        const saveAntecedents = target.antecedents;
-        target.antecedents = flow.antecedents;
+        const target = flow.node.target;
+        const saveAntecedents = target.antecedent;
+        target.antecedent = flow.node.antecedents;
         const result = isPostSuperFlowNode(
           flow.antecedent,
           /*noCacheCheck*/
           false
         );
-        target.antecedents = saveAntecedents;
+        target.antecedent = saveAntecedents;
         return result;
       } else {
         return !!(flags & 1 /* Unreachable */);
@@ -66568,8 +66717,8 @@ function createTypeChecker(host) {
         } else if (flags & 128 /* SwitchClause */) {
           type = getTypeAtSwitchClause(flow);
         } else if (flags & 12 /* Label */) {
-          if (flow.antecedents.length === 1) {
-            flow = flow.antecedents[0];
+          if (flow.antecedent.length === 1) {
+            flow = flow.antecedent[0];
             continue;
           }
           type = flags & 4 /* BranchLabel */ ? getTypeAtFlowBranchLabel(flow) : getTypeAtFlowLoopLabel(flow);
@@ -66580,11 +66729,11 @@ function createTypeChecker(host) {
             continue;
           }
         } else if (flags & 1024 /* ReduceLabel */) {
-          const target = flow.target;
-          const saveAntecedents = target.antecedents;
-          target.antecedents = flow.antecedents;
+          const target = flow.node.target;
+          const saveAntecedents = target.antecedent;
+          target.antecedent = flow.node.antecedents;
           type = getTypeAtFlowNode(flow.antecedent);
-          target.antecedents = saveAntecedents;
+          target.antecedent = saveAntecedents;
         } else if (flags & 2 /* Start */) {
           const container = flow.node;
           if (container && container !== flowContainer && reference.kind !== 211 /* PropertyAccessExpression */ && reference.kind !== 212 /* ElementAccessExpression */ && !(reference.kind === 110 /* ThisKeyword */ && container.kind !== 219 /* ArrowFunction */)) {
@@ -66738,26 +66887,26 @@ function createTypeChecker(host) {
       return createFlowType(narrowedType, isIncomplete(flowType));
     }
     function getTypeAtSwitchClause(flow) {
-      const expr = skipParentheses(flow.switchStatement.expression);
+      const expr = skipParentheses(flow.node.switchStatement.expression);
       const flowType = getTypeAtFlowNode(flow.antecedent);
       let type = getTypeFromFlowType(flowType);
       if (isMatchingReference(reference, expr)) {
-        type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnDiscriminant(type, flow.node);
       } else if (expr.kind === 221 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
-        type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnTypeOf(type, flow.node);
       } else if (expr.kind === 112 /* TrueKeyword */) {
-        type = narrowTypeBySwitchOnTrue(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        type = narrowTypeBySwitchOnTrue(type, flow.node);
       } else {
         if (strictNullChecks) {
           if (optionalChainContainsReference(expr, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, (t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */)));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & (32768 /* Undefined */ | 131072 /* Never */)));
           } else if (expr.kind === 221 /* TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) {
-            type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, (t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined"));
+            type = narrowTypeBySwitchOptionalChainContainment(type, flow.node, (t) => !(t.flags & 131072 /* Never */ || t.flags & 128 /* StringLiteral */ && t.value === "undefined"));
           }
         }
         const access = getDiscriminantPropertyAccess(expr, type);
         if (access) {
-          type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+          type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.node);
         }
       }
       return createFlowType(type, isIncomplete(flowType));
@@ -66767,8 +66916,8 @@ function createTypeChecker(host) {
       let subtypeReduction = false;
       let seenIncomplete = false;
       let bypassFlow;
-      for (const antecedent of flow.antecedents) {
-        if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.clauseStart === antecedent.clauseEnd) {
+      for (const antecedent of flow.antecedent) {
+        if (!bypassFlow && antecedent.flags & 128 /* SwitchClause */ && antecedent.node.clauseStart === antecedent.node.clauseEnd) {
           bypassFlow = antecedent;
           continue;
         }
@@ -66788,7 +66937,7 @@ function createTypeChecker(host) {
       if (bypassFlow) {
         const flowType = getTypeAtFlowNode(bypassFlow);
         const type = getTypeFromFlowType(flowType);
-        if (!(type.flags & 131072 /* Never */) && !contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) {
+        if (!(type.flags & 131072 /* Never */) && !contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.node.switchStatement)) {
           if (type === declaredType && declaredType === initialType) {
             return type;
           }
@@ -66826,7 +66975,7 @@ function createTypeChecker(host) {
       const antecedentTypes = [];
       let subtypeReduction = false;
       let firstAntecedentType;
-      for (const antecedent of flow.antecedents) {
+      for (const antecedent of flow.antecedent) {
         let flowType;
         if (!firstAntecedentType) {
           flowType = firstAntecedentType = getTypeAtFlowNode(antecedent);
@@ -66950,15 +67099,15 @@ function createTypeChecker(host) {
       }
       return narrowTypeByDiscriminant(type, access, (t) => narrowTypeByEquality(t, operator, value, assumeTrue));
     }
-    function narrowTypeBySwitchOnDiscriminantProperty(type, access, switchStatement, clauseStart, clauseEnd) {
-      if (clauseStart < clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
-        const clauseTypes = getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd);
+    function narrowTypeBySwitchOnDiscriminantProperty(type, access, data) {
+      if (data.clauseStart < data.clauseEnd && type.flags & 1048576 /* Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) {
+        const clauseTypes = getSwitchClauseTypes(data.switchStatement).slice(data.clauseStart, data.clauseEnd);
         const candidate = getUnionType(map(clauseTypes, (t) => getConstituentTypeForKeyType(type, t) || unknownType));
         if (candidate !== unknownType) {
           return candidate;
         }
       }
-      return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, switchStatement, clauseStart, clauseEnd));
+      return narrowTypeByDiscriminant(type, access, (t) => narrowTypeBySwitchOnDiscriminant(t, data));
     }
     function narrowTypeByTruthiness(type, expr, assumeTrue) {
       if (isMatchingReference(reference, expr)) {
@@ -67203,11 +67352,11 @@ function createTypeChecker(host) {
     function narrowTypeByLiteralExpression(type, literal, assumeTrue) {
       return assumeTrue ? narrowTypeByTypeName(type, literal.text) : getAdjustedTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768 /* TypeofNEHostObject */);
     }
-    function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
+    function narrowTypeBySwitchOptionalChainContainment(type, { switchStatement, clauseStart, clauseEnd }, clauseCheck) {
       const everyClauseChecks = clauseStart !== clauseEnd && every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
       return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */) : type;
     }
-    function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnDiscriminant(type, { switchStatement, clauseStart, clauseEnd }) {
       const switchTypes = getSwitchClauseTypes(switchStatement);
       if (!switchTypes.length) {
         return type;
@@ -67280,7 +67429,7 @@ function createTypeChecker(host) {
         )
       ));
     }
-    function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnTypeOf(type, { switchStatement, clauseStart, clauseEnd }) {
       const witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
       if (!witnesses) {
         return type;
@@ -67294,7 +67443,7 @@ function createTypeChecker(host) {
       const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
       return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
     }
-    function narrowTypeBySwitchOnTrue(type, switchStatement, clauseStart, clauseEnd) {
+    function narrowTypeBySwitchOnTrue(type, { switchStatement, clauseStart, clauseEnd }) {
       const defaultIndex = findIndex(switchStatement.caseBlock.clauses, (clause) => clause.kind === 297 /* DefaultClause */);
       const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
       for (let i = 0; i < clauseStart; i++) {
@@ -74588,20 +74737,18 @@ function createTypeChecker(host) {
     });
   }
   function checkIfExpressionRefinesParameter(func, expr, param, initType) {
-    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
-    const trueCondition = {
-      flags: 32 /* TrueCondition */,
-      antecedent,
-      node: expr
-    };
+    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || createFlowNode(
+      2 /* Start */,
+      /*node*/
+      void 0,
+      /*antecedent*/
+      void 0
+    );
+    const trueCondition = createFlowNode(32 /* TrueCondition */, expr, antecedent);
     const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
     if (trueType2 === initType)
       return void 0;
-    const falseCondition = {
-      flags: 64 /* FalseCondition */,
-      antecedent,
-      node: expr
-    };
+    const falseCondition = createFlowNode(64 /* FalseCondition */, expr, antecedent);
     const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
@@ -75995,7 +76142,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node);
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
     return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
@@ -80900,14 +81047,14 @@ function createTypeChecker(host) {
       let autoValue = 0;
       let previous;
       for (const member of node.members) {
-        const value = computeMemberValue(member, autoValue, previous);
-        getNodeLinks(member).enumMemberValue = value;
-        autoValue = typeof value === "number" ? value + 1 : void 0;
+        const result = computeEnumMemberValue(member, autoValue, previous);
+        getNodeLinks(member).enumMemberValue = result;
+        autoValue = typeof result.value === "number" ? result.value + 1 : void 0;
         previous = member;
       }
     }
   }
-  function computeMemberValue(member, autoValue, previous) {
+  function computeEnumMemberValue(member, autoValue, previous) {
     if (isComputedNonLiteralName(member.name)) {
       error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
     } else {
@@ -80917,34 +81064,43 @@ function createTypeChecker(host) {
       }
     }
     if (member.initializer) {
-      return computeConstantValue(member);
+      return computeConstantEnumMemberValue(member);
     }
     if (member.parent.flags & 33554432 /* Ambient */ && !isEnumConst(member.parent)) {
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     }
     if (autoValue === void 0) {
       error(member.name, Diagnostics.Enum_member_must_have_initializer);
-      return void 0;
-    }
-    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer) && !isSyntacticallyNumericConstant(previous.initializer)) {
-      error(
-        member.name,
-        Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+      return evaluatorResult(
+        /*value*/
+        void 0
       );
     }
-    return autoValue;
+    if (getIsolatedModules(compilerOptions) && (previous == null ? void 0 : previous.initializer)) {
+      const prevValue = getEnumMemberValue(previous);
+      if (!(typeof prevValue.value === "number" && !prevValue.resolvedOtherFiles)) {
+        error(
+          member.name,
+          Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled
+        );
+      }
+    }
+    return evaluatorResult(autoValue);
   }
-  function computeConstantValue(member) {
+  function computeConstantEnumMemberValue(member) {
     const isConstEnum = isEnumConst(member.parent);
     const initializer = member.initializer;
-    const value = evaluate(initializer, member);
-    if (value !== void 0) {
-      if (isConstEnum && typeof value === "number" && !isFinite(value)) {
+    const result = evaluate(initializer, member);
+    if (result.value !== void 0) {
+      if (isConstEnum && typeof result.value === "number" && !isFinite(result.value)) {
         error(
           initializer,
-          isNaN(value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
+          isNaN(result.value) ? Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value
         );
-      } else if (getIsolatedModules(compilerOptions) && typeof value === "string" && !isSyntacticallyString(initializer)) {
+      } else if (getIsolatedModules(compilerOptions) && typeof result.value === "string" && !result.isSyntacticallyString) {
         error(
           initializer,
           Diagnostics._0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled,
@@ -80958,19 +81114,7 @@ function createTypeChecker(host) {
     } else {
       checkTypeAssignableTo(checkExpression(initializer), numberType, initializer, Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values);
     }
-    return value;
-  }
-  function isSyntacticallyNumericConstant(expr) {
-    expr = skipOuterExpressions(expr);
-    switch (expr.kind) {
-      case 224 /* PrefixUnaryExpression */:
-        return isSyntacticallyNumericConstant(expr.operand);
-      case 226 /* BinaryExpression */:
-        return isSyntacticallyNumericConstant(expr.left) && isSyntacticallyNumericConstant(expr.right);
-      case 9 /* NumericLiteral */:
-        return true;
-    }
-    return false;
+    return result;
   }
   function evaluateEntityNameExpression(expr, location) {
     const symbol = resolveEntityName(
@@ -80980,7 +81124,10 @@ function createTypeChecker(host) {
       true
     );
     if (!symbol)
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     if (expr.kind === 80 /* Identifier */) {
       const identifier = expr;
       if (isInfinityOrNaNString(identifier.escapedText) && symbol === getGlobalSymbol(
@@ -80989,7 +81136,11 @@ function createTypeChecker(host) {
         /*diagnostic*/
         void 0
       )) {
-        return +identifier.escapedText;
+        return evaluatorResult(
+          +identifier.escapedText,
+          /*isSyntacticallyString*/
+          false
+        );
       }
     }
     if (symbol.flags & 8 /* EnumMember */) {
@@ -80998,9 +81149,23 @@ function createTypeChecker(host) {
     if (isConstantVariable(symbol)) {
       const declaration = symbol.valueDeclaration;
       if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-        return evaluate(declaration.initializer, declaration);
+        const result = evaluate(declaration.initializer, declaration);
+        if (location && getSourceFileOfNode(location) !== getSourceFileOfNode(declaration)) {
+          return evaluatorResult(
+            result.value,
+            /*isSyntacticallyString*/
+            false,
+            /*resolvedOtherFiles*/
+            true
+          );
+        }
+        return result;
       }
     }
+    return evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function evaluateElementAccessExpression(expr, location) {
     const root = expr.expression;
@@ -81015,20 +81180,31 @@ function createTypeChecker(host) {
         const name = escapeLeadingUnderscores(expr.argumentExpression.text);
         const member = rootSymbol.exports.get(name);
         if (member) {
+          Debug.assert(getSourceFileOfNode(member.valueDeclaration) === getSourceFileOfNode(rootSymbol.valueDeclaration));
           return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
         }
       }
     }
+    return evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function evaluateEnumMember(expr, symbol, location) {
     const declaration = symbol.valueDeclaration;
     if (!declaration || declaration === location) {
       error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(symbol));
-      return void 0;
+      return evaluatorResult(
+        /*value*/
+        void 0
+      );
     }
     if (!isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
       error(expr, Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums);
-      return 0;
+      return evaluatorResult(
+        /*value*/
+        0
+      );
     }
     return getEnumMemberValue(declaration);
   }
@@ -83169,7 +83345,10 @@ function createTypeChecker(host) {
   }
   function getEnumMemberValue(node) {
     computeEnumMemberValues(node.parent);
-    return getNodeLinks(node).enumMemberValue;
+    return getNodeLinks(node).enumMemberValue ?? evaluatorResult(
+      /*value*/
+      void 0
+    );
   }
   function canHaveConstantValue(node) {
     switch (node.kind) {
@@ -83182,13 +83361,13 @@ function createTypeChecker(host) {
   }
   function getConstantValue2(node) {
     if (node.kind === 306 /* EnumMember */) {
-      return getEnumMemberValue(node);
+      return getEnumMemberValue(node).value;
     }
     const symbol = getNodeLinks(node).resolvedSymbol;
     if (symbol && symbol.flags & 8 /* EnumMember */) {
       const member = symbol.valueDeclaration;
       if (isEnumConst(member.parent)) {
-        return getEnumMemberValue(member);
+        return getEnumMemberValue(member).value;
       }
     }
     return void 0;
@@ -83563,6 +83742,10 @@ function createTypeChecker(host) {
         const node = getParseTreeNode(nodeIn, canHaveConstantValue);
         return node ? getConstantValue2(node) : void 0;
       },
+      getEnumMemberValue: (nodeIn) => {
+        const node = getParseTreeNode(nodeIn, isEnumMember);
+        return node ? getEnumMemberValue(node) : void 0;
+      },
       collectLinkedAliases,
       getReferencedValueDeclaration,
       getReferencedValueDeclarations,
@@ -89781,7 +89964,8 @@ function transformTypeScript(context) {
       /*generateNameForComputedPropertyName*/
       false
     );
-    const valueExpression = transformEnumMemberDeclarationValue(member);
+    const evaluated = resolver.getEnumMemberValue(member);
+    const valueExpression = transformEnumMemberDeclarationValue(member, evaluated == null ? void 0 : evaluated.value);
     const innerAssignment = factory2.createAssignment(
       factory2.createElementAccessExpression(
         currentNamespaceContainerName,
@@ -89789,7 +89973,7 @@ function transformTypeScript(context) {
       ),
       valueExpression
     );
-    const outerAssignment = isSyntacticallyString(valueExpression) ? innerAssignment : factory2.createAssignment(
+    const outerAssignment = typeof (evaluated == null ? void 0 : evaluated.value) === "string" || (evaluated == null ? void 0 : evaluated.isSyntacticallyString) ? innerAssignment : factory2.createAssignment(
       factory2.createElementAccessExpression(
         currentNamespaceContainerName,
         innerAssignment
@@ -89806,10 +89990,9 @@ function transformTypeScript(context) {
       member
     );
   }
-  function transformEnumMemberDeclarationValue(member) {
-    const value = resolver.getConstantValue(member);
-    if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-value)) : factory2.createNumericLiteral(value);
+  function transformEnumMemberDeclarationValue(member, constantValue) {
+    if (constantValue !== void 0) {
+      return typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constantValue)) : factory2.createNumericLiteral(constantValue);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -111149,6 +111332,7 @@ var notImplementedResolver = {
   isEntityNameVisible: notImplemented,
   // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant
   getConstantValue: notImplemented,
+  getEnumMemberValue: notImplemented,
   getReferencedValueDeclaration: notImplemented,
   getReferencedValueDeclarations: notImplemented,
   getTypeReferenceSerializationKind: notImplemented,
@@ -126034,7 +126218,7 @@ function verboseReportProjectStatus(state, configFileName, status) {
   }
 }
 
-// src/executeCommandLine/executeCommandLine.ts
+// src/compiler/executeCommandLine.ts
 function countLines(program) {
   const counts2 = getCountsMap();
   forEach(program.getSourceFiles(), (file) => {