typescript 5.7.0-dev.20240830 → 5.7.0-dev.20240831

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-dev.20240830`;
+var version = `${versionMajorMinor}.0-dev.20240831`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -426,7 +426,10 @@ function deduplicateSorted(array, comparer) {
   for (let i = 1; i < array.length; i++) {
     const next = array[i];
     switch (comparer(next, last2)) {
+      // equality comparison
       case true:
+      // relational comparison
+      // falls through
       case 0 /* EqualTo */:
         continue;
       case -1 /* LessThan */:
@@ -3285,10 +3288,11 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind4) => {
   SyntaxKind4[SyntaxKind4["JSDocImportTag"] = 351] = "JSDocImportTag";
   SyntaxKind4[SyntaxKind4["SyntaxList"] = 352] = "SyntaxList";
   SyntaxKind4[SyntaxKind4["NotEmittedStatement"] = 353] = "NotEmittedStatement";
-  SyntaxKind4[SyntaxKind4["PartiallyEmittedExpression"] = 354] = "PartiallyEmittedExpression";
-  SyntaxKind4[SyntaxKind4["CommaListExpression"] = 355] = "CommaListExpression";
-  SyntaxKind4[SyntaxKind4["SyntheticReferenceExpression"] = 356] = "SyntheticReferenceExpression";
-  SyntaxKind4[SyntaxKind4["Count"] = 357] = "Count";
+  SyntaxKind4[SyntaxKind4["NotEmittedTypeElement"] = 354] = "NotEmittedTypeElement";
+  SyntaxKind4[SyntaxKind4["PartiallyEmittedExpression"] = 355] = "PartiallyEmittedExpression";
+  SyntaxKind4[SyntaxKind4["CommaListExpression"] = 356] = "CommaListExpression";
+  SyntaxKind4[SyntaxKind4["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression";
+  SyntaxKind4[SyntaxKind4["Count"] = 358] = "Count";
   SyntaxKind4[SyntaxKind4["FirstAssignment"] = 64 /* EqualsToken */] = "FirstAssignment";
   SyntaxKind4[SyntaxKind4["LastAssignment"] = 79 /* CaretEqualsToken */] = "LastAssignment";
   SyntaxKind4[SyntaxKind4["FirstCompoundAssignment"] = 65 /* PlusEqualsToken */] = "FirstCompoundAssignment";
@@ -4609,6 +4613,7 @@ function createSystemWatchFunctions({
         return generateWatchFileOptions(4 /* UseFsEvents */, 2 /* DynamicPriority */, options);
       case "UseFsEventsOnParentDirectory":
         useNonPollingWatchers2 = true;
+      // fall through
       default:
         return useNonPollingWatchers2 ? (
           // Use notifications from FS to watch with falling back to fs.watchFile
@@ -8135,6 +8140,7 @@ function computeLineStarts(text) {
         if (text.charCodeAt(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         result.push(lineStart);
         lineStart = pos;
@@ -8239,6 +8245,7 @@ function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) {
         if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         pos++;
         if (stopAfterLineBreak) {
@@ -8385,6 +8392,7 @@ function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) {
           if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
             pos++;
           }
+        // falls through
         case 10 /* lineFeed */:
           pos++;
           if (trailing) {
@@ -8950,12 +8958,16 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         if (pos >= end || !isDigit(charCodeUnchecked(pos))) {
           return "\0";
         }
+      // '\01', '\011'
+      // falls through
       case 49 /* _1 */:
       case 50 /* _2 */:
       case 51 /* _3 */:
         if (pos < end && isOctalDigit(charCodeUnchecked(pos))) {
           pos++;
         }
+      // '\17', '\177'
+      // falls through
       case 52 /* _4 */:
       case 53 /* _5 */:
       case 54 /* _6 */:
@@ -9053,10 +9065,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         tokenFlags |= 4096 /* HexEscape */;
         return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+      // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence),
+      // the line terminator is interpreted to be "the empty code unit sequence".
       case 13 /* carriageReturn */:
         if (pos < end && charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
       case 8232 /* lineSeparator */:
       case 8233 /* paragraphSeparator */:
@@ -9487,6 +9502,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             tokenFlags |= 256 /* OctalSpecifier */;
             return token = checkBigIntSuffix();
           }
+        // falls through
         case 49 /* _1 */:
         case 50 /* _2 */:
         case 51 /* _3 */:
@@ -10006,6 +10022,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 break;
               }
             }
+          // falls through
           case 42 /* asterisk */:
           case 43 /* plus */:
           case 63 /* question */:
@@ -10036,6 +10053,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             if (isInGroup) {
               return;
             }
+          // falls through
           case 93 /* closeBracket */:
           case 125 /* closeBrace */:
             if (anyUnicodeModeOrNonAnnexB || ch === 41 /* closeParen */) {
@@ -10098,6 +10116,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
             break;
           }
+        // falls through
         default:
           Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape(
             /*atomEscape*/
@@ -10235,6 +10254,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       let start2 = pos;
       let operand;
       switch (text.slice(pos, pos + 2)) {
+        // TODO: don't use slice
         case "--":
         case "&&":
           error(Diagnostics.Expected_a_class_set_operand);
@@ -10340,6 +10360,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         start2 = pos;
         switch (text.slice(pos, pos + 2)) {
+          // TODO: don't use slice
           case "--":
           case "&&":
             error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
@@ -10437,6 +10458,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             }
           }
           pos--;
+        // falls through
         default:
           return scanClassSetCharacter();
       }
@@ -10583,6 +10605,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return true;
         case 80 /* P */:
           isCharacterComplement = true;
+        // falls through
         case 112 /* p */:
           pos++;
           if (charCodeChecked(pos) === 123 /* openBrace */) {
@@ -10890,6 +10913,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         if (charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         tokenFlags |= 1 /* PrecedingLineBreak */;
         return token = 4 /* NewLineTrivia */;
@@ -11116,6 +11140,7 @@ function getDefaultLibFileName(options) {
       return "lib.es2016.full.d.ts";
     case 2 /* ES2015 */:
       return "lib.es6.d.ts";
+    // We don't use lib.es2015.full.d.ts due to breaking change.
     default:
       return "lib.d.ts";
   }
@@ -11915,7 +11940,7 @@ function isModifierLike(node) {
 }
 function isTypeElement(node) {
   const kind = node.kind;
-  return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */;
+  return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */ || kind === 354 /* NotEmittedTypeElement */;
 }
 function isObjectLiteralElementLike(node) {
   const kind = node.kind;
@@ -11974,7 +11999,9 @@ function isObjectBindingOrAssignmentElement(node) {
   switch (node.kind) {
     case 208 /* BindingElement */:
     case 303 /* PropertyAssignment */:
+    // AssignmentProperty
     case 304 /* ShorthandPropertyAssignment */:
+    // AssignmentProperty
     case 305 /* SpreadAssignment */:
       return true;
   }
@@ -11992,11 +12019,17 @@ function isArrayBindingOrAssignmentElement(node) {
   switch (node.kind) {
     case 208 /* BindingElement */:
     case 232 /* OmittedExpression */:
+    // Elision
     case 230 /* SpreadElement */:
+    // AssignmentRestElement
     case 209 /* ArrayLiteralExpression */:
+    // ArrayAssignmentPattern
     case 210 /* ObjectLiteralExpression */:
+    // ObjectAssignmentPattern
     case 80 /* Identifier */:
+    // DestructuringAssignmentTarget
     case 211 /* PropertyAccessExpression */:
+    // DestructuringAssignmentTarget
     case 212 /* ElementAccessExpression */:
       return true;
   }
@@ -12057,6 +12090,7 @@ function isLeftHandSideExpressionKind(kind) {
     case 218 /* FunctionExpression */:
     case 80 /* Identifier */:
     case 81 /* PrivateIdentifier */:
+    // technically this is only an Expression if it's in a `#field in expr` BinaryExpression
     case 14 /* RegularExpressionLiteral */:
     case 9 /* NumericLiteral */:
     case 10 /* BigIntLiteral */:
@@ -12072,6 +12106,7 @@ function isLeftHandSideExpressionKind(kind) {
     case 233 /* ExpressionWithTypeArguments */:
     case 236 /* MetaProperty */:
     case 102 /* ImportKeyword */:
+    // technically this is only an Expression if it's in a CallExpression
     case 282 /* MissingDeclaration */:
       return true;
     default:
@@ -12118,8 +12153,8 @@ function isExpressionKind(kind) {
     case 230 /* SpreadElement */:
     case 234 /* AsExpression */:
     case 232 /* OmittedExpression */:
-    case 355 /* CommaListExpression */:
-    case 354 /* PartiallyEmittedExpression */:
+    case 356 /* CommaListExpression */:
+    case 355 /* PartiallyEmittedExpression */:
     case 238 /* SatisfiesExpression */:
       return true;
     default:
@@ -13738,6 +13773,8 @@ function getErrorSpanForNode(sourceFile, node) {
       }
       return getSpanOfTokenAtPosition(sourceFile, pos2);
     }
+    // This list is a work in progress. Add missing node kinds to improve their error
+    // spans.
     case 260 /* VariableDeclaration */:
     case 208 /* BindingElement */:
     case 263 /* ClassDeclaration */:
@@ -13909,6 +13946,8 @@ function isPartOfTypeNode(node) {
       return isPartOfTypeExpressionWithTypeArguments(node);
     case 168 /* TypeParameter */:
       return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */;
+    // Identifiers and qualified names may be type nodes, depending on their context. Climb
+    // above them to find the lowest container
     case 80 /* Identifier */:
       if (node.parent.kind === 166 /* QualifiedName */ && node.parent.right === node) {
         node = node.parent;
@@ -13916,6 +13955,7 @@ function isPartOfTypeNode(node) {
         node = node.parent;
       }
       Debug.assert(node.kind === 80 /* Identifier */ || node.kind === 166 /* QualifiedName */ || node.kind === 211 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
+    // falls through
     case 166 /* QualifiedName */:
     case 211 /* PropertyAccessExpression */:
     case 110 /* ThisKeyword */: {
@@ -14181,6 +14221,7 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope
         if (!includeArrowFunctions) {
           continue;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 218 /* FunctionExpression */:
       case 267 /* ModuleDeclaration */:
@@ -14203,6 +14244,8 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope
 }
 function isThisContainerOrFunctionBlock(node) {
   switch (node.kind) {
+    // Arrow functions use the same scope, but may do so in a "delayed" manner
+    // For example, `const getThis = () => this` may be before a super() call in a derived constructor
     case 219 /* ArrowFunction */:
     case 262 /* FunctionDeclaration */:
     case 218 /* FunctionExpression */:
@@ -14269,6 +14312,7 @@ function getSuperContainer(node, stopOnFunctions) {
         if (!stopOnFunctions) {
           continue;
         }
+      // falls through
       case 172 /* PropertyDeclaration */:
       case 171 /* PropertySignature */:
       case 174 /* MethodDeclaration */:
@@ -14322,6 +14366,7 @@ function getEntityNameFromTypeNode(node) {
       return node.typeName;
     case 233 /* ExpressionWithTypeArguments */:
       return isEntityNameExpression(node.expression) ? node.expression : void 0;
+    // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s.
     case 80 /* Identifier */:
     case 166 /* QualifiedName */:
       return node;
@@ -14486,6 +14531,7 @@ function isExpressionNode(node) {
       if (node.parent.kind === 186 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node)) {
         return true;
       }
+    // falls through
     case 9 /* NumericLiteral */:
     case 10 /* BigIntLiteral */:
     case 11 /* StringLiteral */:
@@ -15490,6 +15536,7 @@ function getFunctionFlags(node) {
       if (node.asteriskToken) {
         flags |= 1 /* Generator */;
       }
+    // falls through
     case 219 /* ArrowFunction */:
       if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
@@ -15724,7 +15771,7 @@ function getOperator(expression) {
 }
 function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
   switch (nodeKind) {
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
       return 0 /* Comma */;
     case 230 /* SpreadElement */:
       return 1 /* Spread */;
@@ -15756,6 +15803,7 @@ function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
         default:
           return getBinaryOperatorPrecedence(operatorKind);
       }
+    // TODO: Should prefix `++` and `--` be moved to the `Update` precedence?
     case 216 /* TypeAssertionExpression */:
     case 235 /* NonNullExpression */:
     case 224 /* PrefixUnaryExpression */:
@@ -17254,11 +17302,12 @@ function getLeftmostExpression(node, stopAtCallExpressions) {
         if (stopAtCallExpressions) {
           return node;
         }
+      // falls through
       case 234 /* AsExpression */:
       case 212 /* ElementAccessExpression */:
       case 211 /* PropertyAccessExpression */:
       case 235 /* NonNullExpression */:
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
       case 238 /* SatisfiesExpression */:
         node = node.expression;
         continue;
@@ -18532,6 +18581,7 @@ function isJsonEqual(a, b) {
 function parsePseudoBigInt(stringValue) {
   let log2Base;
   switch (stringValue.charCodeAt(1)) {
+    // "x" in "0x123"
     case 98 /* b */:
     case 66 /* B */:
       log2Base = 1;
@@ -18769,7 +18819,7 @@ function getContainingNodeArray(node) {
       return parent.types;
     case 189 /* TupleType */:
     case 209 /* ArrayLiteralExpression */:
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
     case 275 /* NamedImports */:
     case 279 /* NamedExports */:
       return parent.elements;
@@ -19202,6 +19252,7 @@ function createNameResolver({
         switch (location.kind) {
           case 307 /* SourceFile */:
             if (!isExternalOrCommonJsModule(location)) break;
+          // falls through
           case 267 /* ModuleDeclaration */:
             const moduleExports = ((_a = getSymbolOfDeclaration(location)) == null ? void 0 : _a.exports) || emptySymbols;
             if (location.kind === 307 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 33554432 /* Ambient */ && !isGlobalScopeAugmentation(location)) {
@@ -19285,6 +19336,14 @@ function createNameResolver({
               }
             }
             break;
+          // It is not legal to reference a class's own type parameters from a computed property name that
+          // belongs to the class. For example:
+          //
+          //   function foo<T>() { return '' }
+          //   class C<T> { // <-- Class's own type parameter T
+          //       [foo<T>()]() { } // <-- Reference to T from class's own computed property
+          //   }
+          //
           case 167 /* ComputedPropertyName */:
             grandparent = location.parent.parent;
             if (isClassLike(grandparent) || grandparent.kind === 264 /* InterfaceDeclaration */) {
@@ -19300,6 +19359,7 @@ function createNameResolver({
             if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
               break;
             }
+          // falls through
           case 174 /* MethodDeclaration */:
           case 176 /* Constructor */:
           case 177 /* GetAccessor */:
@@ -19944,6 +20004,7 @@ function createParenthesizerRules(factory2) {
   function parenthesizeConstituentTypeOfUnionType(type) {
     switch (type.kind) {
       case 192 /* UnionType */:
+      // Not strictly necessary, but a union containing a union should have been flattened
       case 193 /* IntersectionType */:
         return factory2.createParenthesizedType(type);
     }
@@ -20714,6 +20775,7 @@ function createNodeFactory(flags, baseFactory2) {
     createSyntheticExpression,
     createSyntaxList,
     createNotEmittedStatement,
+    createNotEmittedTypeElement,
     createPartiallyEmittedExpression,
     updatePartiallyEmittedExpression,
     createCommaListExpression,
@@ -23740,7 +23802,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createPartiallyEmittedExpression(expression, original) {
-    const node = createBaseNode(354 /* PartiallyEmittedExpression */);
+    const node = createBaseNode(355 /* PartiallyEmittedExpression */);
     node.expression = expression;
     node.original = original;
     node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
@@ -23750,6 +23812,9 @@ function createNodeFactory(flags, baseFactory2) {
   function updatePartiallyEmittedExpression(node, expression) {
     return node.expression !== expression ? update(createPartiallyEmittedExpression(expression, node.original), node) : node;
   }
+  function createNotEmittedTypeElement() {
+    return createBaseNode(354 /* NotEmittedTypeElement */);
+  }
   function flattenCommaElements(node) {
     if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
       if (isCommaListExpression(node)) {
@@ -23762,7 +23827,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createCommaListExpression(elements) {
-    const node = createBaseNode(355 /* CommaListExpression */);
+    const node = createBaseNode(356 /* CommaListExpression */);
     node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements));
     node.transformFlags |= propagateChildrenFlags(node.elements);
     return node;
@@ -23771,7 +23836,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node.elements !== elements ? update(createCommaListExpression(elements), node) : node;
   }
   function createSyntheticReferenceExpression(expression, thisArg) {
-    const node = createBaseNode(356 /* SyntheticReferenceExpression */);
+    const node = createBaseNode(357 /* SyntheticReferenceExpression */);
     node.expression = expression;
     node.thisArg = thisArg;
     node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg);
@@ -24018,7 +24083,7 @@ function createNodeFactory(flags, baseFactory2) {
         return updateNonNullExpression(outerExpression, expression);
       case 233 /* ExpressionWithTypeArguments */:
         return updateExpressionWithTypeArguments(outerExpression, expression, outerExpression.typeArguments);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return updatePartiallyEmittedExpression(outerExpression, expression);
     }
   }
@@ -24563,7 +24628,7 @@ function getTransformFlagsSubtreeExclusions(kind) {
     case 216 /* TypeAssertionExpression */:
     case 238 /* SatisfiesExpression */:
     case 234 /* AsExpression */:
-    case 354 /* PartiallyEmittedExpression */:
+    case 355 /* PartiallyEmittedExpression */:
     case 217 /* ParenthesizedExpression */:
     case 108 /* SuperKeyword */:
       return -2147483648 /* OuterExpressionExcludes */;
@@ -26204,10 +26269,10 @@ function isMetaProperty(node) {
   return node.kind === 236 /* MetaProperty */;
 }
 function isPartiallyEmittedExpression(node) {
-  return node.kind === 354 /* PartiallyEmittedExpression */;
+  return node.kind === 355 /* PartiallyEmittedExpression */;
 }
 function isCommaListExpression(node) {
-  return node.kind === 355 /* CommaListExpression */;
+  return node.kind === 356 /* CommaListExpression */;
 }
 function isTemplateSpan(node) {
   return node.kind === 239 /* TemplateSpan */;
@@ -26336,7 +26401,7 @@ function isNotEmittedStatement(node) {
   return node.kind === 353 /* NotEmittedStatement */;
 }
 function isSyntheticReference(node) {
-  return node.kind === 356 /* SyntheticReferenceExpression */;
+  return node.kind === 357 /* SyntheticReferenceExpression */;
 }
 function isExternalModuleReference(node) {
   return node.kind === 283 /* ExternalModuleReference */;
@@ -26917,7 +26982,7 @@ function isOuterExpression(node, kinds = 31 /* All */) {
       return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0;
     case 235 /* NonNullExpression */:
       return (kinds & 4 /* NonNullAssertions */) !== 0;
-    case 354 /* PartiallyEmittedExpression */:
+    case 355 /* PartiallyEmittedExpression */:
       return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0;
   }
   return false;
@@ -27357,10 +27422,13 @@ var BinaryExpressionState;
     switch (currentState) {
       case enter:
         if (machine.onLeft) return left;
+      // falls through
       case left:
         if (machine.onOperator) return operator;
+      // falls through
       case operator:
         if (machine.onRight) return right;
+      // falls through
       case right:
         return exit;
       case exit:
@@ -27988,7 +28056,7 @@ var forEachChildTable = {
   [282 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.modifiers);
   },
-  [355 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
+  [356 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.elements);
   },
   [284 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) {
@@ -28084,7 +28152,7 @@ var forEachChildTable = {
   [331 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag,
   [337 /* JSDocOverrideTag */]: forEachChildInJSDocTag,
   [351 /* JSDocImportTag */]: forEachChildInJSDocImportTag,
-  [354 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
+  [355 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
 };
 function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) {
   return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
@@ -28439,6 +28507,7 @@ var Parser;
               expression2 = parseLiteralNode();
               break;
             }
+          // falls through
           default:
             expression2 = parseObjectLiteralExpression();
             break;
@@ -29360,6 +29429,7 @@ var Parser;
           case 25 /* DotToken */:
             return true;
         }
+      // falls through
       case 11 /* ArgumentExpressions */:
         return token() === 26 /* DotDotDotToken */ || isStartOfExpression();
       case 16 /* Parameters */:
@@ -29393,6 +29463,7 @@ var Parser;
         return true;
       case 26 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
+      // Not a real context, only a marker.
       default:
         Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'.");
     }
@@ -29709,6 +29780,7 @@ var Parser;
       case 3 /* SwitchClauseStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
       case 18 /* RestProperties */:
+      // fallthrough
       case 4 /* TypeMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
       case 5 /* ClassMembers */:
@@ -29756,6 +29828,7 @@ var Parser;
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
       case 26 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
+      // Not a real context, only a marker.
       default:
         Debug.assertNever(context);
     }
@@ -30680,10 +30753,12 @@ var Parser;
         return tryParse(parseKeywordAndNoDot) || parseTypeReference();
       case 67 /* AsteriskEqualsToken */:
         scanner.reScanAsteriskEqualsToken();
+      // falls through
       case 42 /* AsteriskToken */:
         return parseJSDocAllType();
       case 61 /* QuestionQuestionToken */:
         scanner.reScanQuestionToken();
+      // falls through
       case 58 /* QuestionToken */:
         return parseJSDocUnknownOrNullableType();
       case 100 /* FunctionKeyword */:
@@ -31561,6 +31636,7 @@ var Parser;
         if (isAwaitExpression2()) {
           return parseAwaitExpression();
         }
+      // falls through
       default:
         return parseUpdateExpression();
     }
@@ -31580,6 +31656,8 @@ var Parser;
         if (languageVariant !== 1 /* JSX */) {
           return false;
         }
+      // We are in JSX context and the token is part of JSXElement.
+      // falls through
       default:
         return true;
     }
@@ -32153,10 +32231,16 @@ var Parser;
   }
   function canFollowTypeArgumentsInExpression() {
     switch (token()) {
+      // These tokens can follow a type argument list in a call expression.
       case 21 /* OpenParenToken */:
+      // foo<x>(
       case 15 /* NoSubstitutionTemplateLiteral */:
+      // foo<T> `...`
       case 16 /* TemplateHead */:
         return true;
+      // A type argument list followed by `<` never makes sense, and a type argument list followed
+      // by `>` is ambiguous with a (re-scanned) `>>` operator, so we disqualify both. Also, in
+      // this context, `+` and `-` are unary operators, not binary operators.
       case 30 /* LessThanToken */:
       case 32 /* GreaterThanToken */:
       case 40 /* PlusToken */:
@@ -32174,6 +32258,7 @@ var Parser;
             false
           );
         }
+      // falls through
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 11 /* StringLiteral */:
@@ -32677,6 +32762,27 @@ var Parser;
           return isUsingDeclaration();
         case 135 /* AwaitKeyword */:
           return isAwaitUsingDeclaration();
+        // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers;
+        // however, an identifier cannot be followed by another identifier on the same line. This is what we
+        // count on to parse out the respective declarations. For instance, we exploit this to say that
+        //
+        //    namespace n
+        //
+        // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees
+        //
+        //    namespace
+        //    n
+        //
+        // as the identifier 'namespace' on one line followed by the identifier 'n' on another.
+        // We need to look one token ahead to see if it permissible to try parsing a declaration.
+        //
+        // *Note*: 'interface' is actually a strict mode reserved word. So while
+        //
+        //   "use strict"
+        //   interface
+        //   I {}
+        //
+        // could be legal, it would add complexity for very little gain.
         case 120 /* InterfaceKeyword */:
         case 156 /* TypeKeyword */:
           return nextTokenIsIdentifierOnSameLine();
@@ -32749,6 +32855,9 @@ var Parser;
       case 111 /* ThrowKeyword */:
       case 113 /* TryKeyword */:
       case 89 /* DebuggerKeyword */:
+      // 'catch' and 'finally' do not actually indicate that the code is part of a statement,
+      // however, we say they are here so that we may gracefully parse them and error later.
+      // falls through
       case 85 /* CatchKeyword */:
       case 98 /* FinallyKeyword */:
         return true;
@@ -32887,6 +32996,8 @@ var Parser;
       case 111 /* ThrowKeyword */:
         return parseThrowStatement();
       case 113 /* TryKeyword */:
+      // Include 'catch' and 'finally' for error recovery.
+      // falls through
       case 85 /* CatchKeyword */:
       case 98 /* FinallyKeyword */:
         return parseTryStatement();
@@ -33305,10 +33416,15 @@ var Parser;
       }
       switch (token()) {
         case 21 /* OpenParenToken */:
+        // Method declaration
         case 30 /* LessThanToken */:
+        // Generic Method declaration
         case 54 /* ExclamationToken */:
+        // Non-null assertion on property name
         case 59 /* ColonToken */:
+        // Type Annotation for declaration
         case 64 /* EqualsToken */:
+        // Initializer for declaration
         case 58 /* QuestionToken */:
           return true;
         default:
@@ -34215,6 +34331,7 @@ var Parser;
                   linkEnd = scanner.getTokenEnd();
                   break;
                 }
+              // fallthrough if it's not a {@link sequence
               default:
                 state = 2 /* SavingComments */;
                 pushComment(scanner.getTokenText());
@@ -34473,6 +34590,8 @@ var Parser;
                   indent2 += 1;
                   break;
                 }
+              // record the * as a comment
+              // falls through
               default:
                 if (state !== 3 /* SavingBackticks */) {
                   state = 2 /* SavingComments */;
@@ -35553,6 +35672,7 @@ function processPragmasIntoFields(context, reportDiagnostic) {
       case "jsximportsource":
       case "jsxruntime":
         return;
+      // Accessed directly
       default:
         Debug.fail("Unhandled pragma kind");
     }
@@ -37406,6 +37526,7 @@ function parseOptionValue(args, i, diagnostics, opt, options, errors) {
         case "listOrElement":
           Debug.fail("listOrElement not supported here");
           break;
+        // If not a primitive, the possible types are specified in what is effectively a map of options.
         default:
           options[opt.name] = parseCustomTypeOption(opt, args[i], errors);
           i++;
@@ -37739,6 +37860,7 @@ function convertToJson(sourceFile, rootExpression, errors, returnValue, jsonConv
         return false;
       case 106 /* NullKeyword */:
         return null;
+      // eslint-disable-line no-restricted-syntax
       case 11 /* StringLiteral */:
         if (!isDoubleQuotedString(valueExpression)) {
           errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
@@ -41370,20 +41492,24 @@ function getModuleInstanceStateCached(node, visited = /* @__PURE__ */ new Map())
 }
 function getModuleInstanceStateWorker(node, visited) {
   switch (node.kind) {
+    // 1. interface declarations, type alias declarations
     case 264 /* InterfaceDeclaration */:
     case 265 /* TypeAliasDeclaration */:
       return 0 /* NonInstantiated */;
+    // 2. const enum declarations
     case 266 /* EnumDeclaration */:
       if (isEnumConst(node)) {
         return 2 /* ConstEnumOnly */;
       }
       break;
+    // 3. non-exported import declarations
     case 272 /* ImportDeclaration */:
     case 271 /* ImportEqualsDeclaration */:
       if (!hasSyntacticModifier(node, 32 /* Export */)) {
         return 0 /* NonInstantiated */;
       }
       break;
+    // 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain
     case 278 /* ExportDeclaration */:
       const exportDeclaration = node;
       if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 279 /* NamedExports */) {
@@ -41400,6 +41526,7 @@ function getModuleInstanceStateWorker(node, visited) {
         return state;
       }
       break;
+    // 5. other uninstantiated module declarations.
     case 268 /* ModuleBlock */: {
       let state = 0 /* NonInstantiated */;
       forEachChild(node, (n) => {
@@ -41998,6 +42125,7 @@ function createBinder() {
       case 351 /* JSDocImportTag */:
         bindJSDocImportTag(node);
         break;
+      // In source files and blocks, bind functions first to match hoisting that occurs at runtime
       case 307 /* SourceFile */: {
         bindEachFunctionsFirst(node.statements);
         bind(node.endOfFileToken);
@@ -42018,6 +42146,7 @@ function createBinder() {
       case 303 /* PropertyAssignment */:
       case 230 /* SpreadElement */:
         inAssignmentPattern = saveInAssignmentPattern;
+      // falls through
       default:
         bindEachChild(node);
         break;
@@ -42039,6 +42168,7 @@ function createBinder() {
         if (isJSDocTypeAssertion(expr)) {
           return false;
         }
+      // fallthrough
       case 235 /* NonNullExpression */:
         return isNarrowingExpression(expr.expression);
       case 226 /* BinaryExpression */:
@@ -42870,6 +43000,10 @@ function createBinder() {
   }
   function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
     switch (container.kind) {
+      // Modules, source files, and classes need specialized handling for how their
+      // members are declared (for example, a member of a class will go into a specific
+      // symbol table depending on if it is static or not). We defer to specialized
+      // handlers to take care of declaring these child members.
       case 267 /* ModuleDeclaration */:
         return declareModuleMember(node, symbolFlags, symbolExcludes);
       case 307 /* SourceFile */:
@@ -43011,6 +43145,7 @@ function createBinder() {
           declareModuleMember(node, symbolFlags, symbolExcludes);
           break;
         }
+      // falls through
       default:
         Debug.assertNode(blockScopeContainer, canHaveLocals);
         if (!blockScopeContainer.locals) {
@@ -43331,6 +43466,7 @@ function createBinder() {
   }
   function bindWorker(node) {
     switch (node.kind) {
+      /* Strict mode checks */
       case 80 /* Identifier */:
         if (node.flags & 4096 /* IdentifierIsInJSDocNamespace */) {
           let parentNode = node.parent;
@@ -43340,6 +43476,7 @@ function createBinder() {
           bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
           break;
         }
+      // falls through
       case 110 /* ThisKeyword */:
         if (currentFlow && (isExpression(node) || parent.kind === 304 /* ShorthandPropertyAssignment */)) {
           node.flowNode = currentFlow;
@@ -43428,6 +43565,7 @@ function createBinder() {
         return;
       case 182 /* TypePredicate */:
         break;
+      // Binding the children will handle everything
       case 168 /* TypeParameter */:
         return bindTypeParameter(node);
       case 169 /* Parameter */:
@@ -43492,6 +43630,7 @@ function createBinder() {
             return bindObjectDefinePrototypeProperty(node);
           case 0 /* None */:
             break;
+          // Nothing to do
           default:
             return Debug.fail("Unknown call expression assignment declaration kind");
         }
@@ -43499,6 +43638,7 @@ function createBinder() {
           bindCallExpression(node);
         }
         break;
+      // Members of classes, interfaces, and modules
       case 231 /* ClassExpression */:
       case 263 /* ClassDeclaration */:
         inStrictMode = true;
@@ -43511,10 +43651,12 @@ function createBinder() {
         return bindEnumDeclaration(node);
       case 267 /* ModuleDeclaration */:
         return bindModuleDeclaration(node);
+      // Jsx-attributes
       case 292 /* JsxAttributes */:
         return bindJsxAttributes(node);
       case 291 /* JsxAttribute */:
         return bindJsxAttribute(node, 4 /* Property */, 0 /* PropertyExcludes */);
+      // Imports and exports
       case 271 /* ImportEqualsDeclaration */:
       case 274 /* NamespaceImport */:
       case 276 /* ImportSpecifier */:
@@ -43535,6 +43677,7 @@ function createBinder() {
         if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
           return;
         }
+      // falls through
       case 268 /* ModuleBlock */:
         return updateStrictModeStatementList(node.statements);
       case 341 /* JSDocParameterTag */:
@@ -43544,6 +43687,7 @@ function createBinder() {
         if (node.parent.kind !== 322 /* JSDocTypeLiteral */) {
           break;
         }
+      // falls through
       case 348 /* JSDocPropertyTag */:
         const propTag = node;
         const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 316 /* JSDocOptionalType */ ? 4 /* Property */ | 16777216 /* Optional */ : 4 /* Property */;
@@ -43756,6 +43900,7 @@ function createBinder() {
           declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
         }
         break;
+      // Namespaces are not allowed in javascript files, so do nothing here
       case 267 /* ModuleDeclaration */:
         break;
       default:
@@ -44252,6 +44397,7 @@ function getContainerFlags(node) {
       if (isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
         return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */;
       }
+    // falls through
     case 176 /* Constructor */:
     case 262 /* FunctionDeclaration */:
     case 173 /* MethodSignature */:
@@ -47305,6 +47451,7 @@ function createTypeChecker(host) {
         if (isEntityNameExpression(node.expression)) {
           return node.expression;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -49160,6 +49307,7 @@ function createTypeChecker(host) {
           if (!isExternalOrCommonJsModule(location)) {
             break;
           }
+        // falls through
         case 267 /* ModuleDeclaration */:
           const sym = getSymbolOfDeclaration(location);
           if (result = callback(
@@ -50582,6 +50730,9 @@ function createTypeChecker(host) {
       }
       function createTypeNodesFromResolvedType(resolvedType) {
         if (checkTruncationLength(context)) {
+          if (context.flags & 1 /* NoTruncation */) {
+            return [addSyntheticTrailingComment(factory.createNotEmittedTypeElement(), 3 /* MultiLineCommentTrivia */, "elided")];
+          }
           return [factory.createPropertySignature(
             /*modifiers*/
             void 0,
@@ -50619,15 +50770,20 @@ function createTypeChecker(host) {
             }
           }
           if (checkTruncationLength(context) && i + 2 < properties.length - 1) {
-            typeElements.push(factory.createPropertySignature(
-              /*modifiers*/
-              void 0,
-              `... ${properties.length - i} more ...`,
-              /*questionToken*/
-              void 0,
-              /*type*/
-              void 0
-            ));
+            if (context.flags & 1 /* NoTruncation */) {
+              const typeElement = typeElements.pop();
+              typeElements.push(addSyntheticTrailingComment(typeElement, 3 /* MultiLineCommentTrivia */, `... ${properties.length - i} more elided ...`));
+            } else {
+              typeElements.push(factory.createPropertySignature(
+                /*modifiers*/
+                void 0,
+                `... ${properties.length - i} more ...`,
+                /*questionToken*/
+                void 0,
+                /*type*/
+                void 0
+              ));
+            }
             addPropertyToElementList(properties[properties.length - 1], context, typeElements);
             break;
           }
@@ -50645,7 +50801,7 @@ function createTypeChecker(host) {
           void 0
         );
       }
-      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      return addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided");
     }
     function shouldUsePlaceholderForProperty(propertySymbol, context) {
       var _a;
@@ -50781,15 +50937,17 @@ function createTypeChecker(host) {
       if (some(types)) {
         if (checkTruncationLength(context)) {
           if (!isBareList) {
-            return [factory.createTypeReferenceNode(
-              "...",
-              /*typeArguments*/
-              void 0
-            )];
+            return [
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided") : factory.createTypeReferenceNode(
+                "...",
+                /*typeArguments*/
+                void 0
+              )
+            ];
           } else if (types.length > 2) {
             return [
               typeToTypeNodeHelper(types[0], context),
-              factory.createTypeReferenceNode(
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - 2} more elided ...`) : factory.createTypeReferenceNode(
                 `... ${types.length - 2} more ...`,
                 /*typeArguments*/
                 void 0
@@ -50805,11 +50963,13 @@ function createTypeChecker(host) {
         for (const type of types) {
           i++;
           if (checkTruncationLength(context) && i + 2 < types.length - 1) {
-            result.push(factory.createTypeReferenceNode(
-              `... ${types.length - i} more ...`,
-              /*typeArguments*/
-              void 0
-            ));
+            result.push(
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - i} more elided ...`) : factory.createTypeReferenceNode(
+                `... ${types.length - i} more ...`,
+                /*typeArguments*/
+                void 0
+              )
+            );
             const typeNode2 = typeToTypeNodeHelper(types[types.length - 1], context);
             if (typeNode2) {
               result.push(typeNode2);
@@ -53404,6 +53564,7 @@ function createTypeChecker(host) {
               );
               break;
             }
+          // else fall through and treat commonjs require just like import=
           case 271 /* ImportEqualsDeclaration */:
             if (target.escapedName === "export=" /* ExportEquals */ && some(target.declarations, (d) => isSourceFile(d) && isJsonSourceFile(d))) {
               serializeMaybeAliasAssignment(symbol);
@@ -54176,6 +54337,7 @@ function createTypeChecker(host) {
           if (isBindingPattern(node.name) && !node.name.elements.length) {
             return false;
           }
+        // falls through
         case 267 /* ModuleDeclaration */:
         case 263 /* ClassDeclaration */:
         case 264 /* InterfaceDeclaration */:
@@ -54200,6 +54362,8 @@ function createTypeChecker(host) {
           if (hasEffectiveModifier(node, 2 /* Private */ | 4 /* Protected */)) {
             return false;
           }
+        // Public properties/methods are visible if its parents are visible, so:
+        // falls through
         case 176 /* Constructor */:
         case 180 /* ConstructSignature */:
         case 179 /* CallSignature */:
@@ -54217,14 +54381,20 @@ function createTypeChecker(host) {
         case 196 /* ParenthesizedType */:
         case 202 /* NamedTupleMember */:
           return isDeclarationVisible(node.parent);
+        // Default binding, import specifier and namespace import is visible
+        // only on demand so by default it is not visible
         case 273 /* ImportClause */:
         case 274 /* NamespaceImport */:
         case 276 /* ImportSpecifier */:
           return false;
+        // Type parameters are always visible
         case 168 /* TypeParameter */:
+        // Source file and namespace export are always visible
+        // falls through
         case 307 /* SourceFile */:
         case 270 /* NamespaceExportDeclaration */:
           return true;
+        // Export assignments do not create name bindings outside the module
         case 277 /* ExportAssignment */:
           return false;
         default:
@@ -61774,6 +61944,9 @@ function createTypeChecker(host) {
         return getTypeFromTemplateTypeNode(node);
       case 205 /* ImportType */:
         return getTypeFromImportTypeNode(node);
+      // This function assumes that an identifier, qualified name, or property access expression is a type expression
+      // Callers should first ensure this by calling `isPartOfTypeNode`
+      // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s.
       case 80 /* Identifier */:
       case 166 /* QualifiedName */:
       case 211 /* PropertyAccessExpression */:
@@ -62021,6 +62194,7 @@ function createTypeChecker(host) {
           return !!tp.isThisType;
         case 80 /* Identifier */:
           return !tp.isThisType && isPartOfTypeNode(node2) && maybeTypeParameterReference(node2) && getTypeFromTypeNodeWorker(node2) === tp;
+        // use worker because we're looking for === equality
         case 186 /* TypeQuery */:
           const entityName = node2.exprName;
           const firstIdentifier = getFirstIdentifier(entityName);
@@ -62440,6 +62614,7 @@ function createTypeChecker(host) {
         if (!isConstAssertion(node)) {
           break;
         }
+      // fallthrough
       case 294 /* JsxExpression */:
       case 217 /* ParenthesizedExpression */:
         return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
@@ -67759,6 +67934,7 @@ function createTypeChecker(host) {
         if (isCallExpression(node.parent)) {
           return Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function;
         }
+      // falls through
       default:
         if (node.parent.kind === 304 /* ShorthandPropertyAssignment */) {
           return Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
@@ -67792,6 +67968,7 @@ function createTypeChecker(host) {
           const symbol = getResolvedSymbol(node);
           return symbol !== unknownSymbol ? `${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}|${getSymbolId(symbol)}` : void 0;
         }
+      // falls through
       case 110 /* ThisKeyword */:
         return `0|${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}`;
       case 235 /* NonNullExpression */:
@@ -69345,6 +69522,9 @@ function createTypeChecker(host) {
           break;
         case 28 /* CommaToken */:
           return narrowType(type, expr.right, assumeTrue);
+        // Ordinarily we won't see && and || expressions in control flow analysis because the Binder breaks those
+        // expressions down to individual conditional control flows. However, we may encounter them when analyzing
+        // aliased conditional expressions.
         case 56 /* AmpersandAmpersandToken */:
           return assumeTrue ? narrowType(
             narrowType(
@@ -69788,6 +69968,7 @@ function createTypeChecker(host) {
               }
             }
           }
+        // falls through
         case 110 /* ThisKeyword */:
         case 108 /* SuperKeyword */:
         case 211 /* PropertyAccessExpression */:
@@ -77606,6 +77787,7 @@ function createTypeChecker(host) {
                 hasError = true;
                 break;
               }
+            // fallthrough
             case 7 /* ES2022 */:
             case 99 /* ESNext */:
             case 200 /* Preserve */:
@@ -77613,6 +77795,7 @@ function createTypeChecker(host) {
               if (languageVersion >= 4 /* ES2017 */) {
                 break;
               }
+            // fallthrough
             default:
               span ?? (span = getSpanOfTokenAtPosition(sourceFile, node.pos));
               const message = isAwaitExpression(node) ? Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher;
@@ -78030,9 +78213,13 @@ function createTypeChecker(host) {
             return true;
         }
         return false;
+      // Some forms listed here for clarity
       case 222 /* VoidExpression */:
+      // Explicit opt-out
       case 216 /* TypeAssertionExpression */:
+      // Not SEF, but can produce useful type warnings
       case 234 /* AsExpression */:
+      // Not SEF, but can produce useful type warnings
       default:
         return false;
     }
@@ -79278,6 +79465,7 @@ function createTypeChecker(host) {
         if (node.expression.kind === 102 /* ImportKeyword */) {
           return checkImportCallExpression(node);
         }
+      // falls through
       case 214 /* NewExpression */:
         return checkCallExpression(node, checkMode);
       case 215 /* TaggedTemplateExpression */:
@@ -79647,6 +79835,7 @@ function createTypeChecker(host) {
             if (useDefineForClassFields) {
               break;
             }
+          // fall through
           case "prototype":
             const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
             const className = getNameOfSymbolAsWritten(getSymbolOfDeclaration(node));
@@ -80390,6 +80579,8 @@ function createTypeChecker(host) {
       switch (d.kind) {
         case 264 /* InterfaceDeclaration */:
         case 265 /* TypeAliasDeclaration */:
+        // A jsdoc typedef and callback are, by definition, type aliases.
+        // falls through
         case 346 /* JSDocTypedefTag */:
         case 338 /* JSDocCallbackTag */:
         case 340 /* JSDocEnumTag */:
@@ -80410,6 +80601,8 @@ function createTypeChecker(host) {
             return 1 /* ExportValue */;
           }
           d = expression;
+        // The below options all declare an Alias, which is allowed to merge with other values within the importing module.
+        // falls through
         case 271 /* ImportEqualsDeclaration */:
         case 274 /* NamespaceImport */:
         case 273 /* ImportClause */:
@@ -80423,6 +80616,7 @@ function createTypeChecker(host) {
         case 208 /* BindingElement */:
         case 262 /* FunctionDeclaration */:
         case 276 /* ImportSpecifier */:
+        // https://github.com/Microsoft/TypeScript/pull/7591
         case 80 /* Identifier */:
           return 1 /* ExportValue */;
         case 173 /* MethodSignature */:
@@ -80771,6 +80965,7 @@ function createTypeChecker(host) {
           headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
           break;
         }
+      // falls through
       case 169 /* Parameter */:
         headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
         break;
@@ -83992,6 +84187,7 @@ function createTypeChecker(host) {
         break;
       case 271 /* ImportEqualsDeclaration */:
         if (isInternalModuleImportEqualsDeclaration(node)) break;
+      // falls through
       case 272 /* ImportDeclaration */:
         grammarErrorOnFirstToken(node, Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
         break;
@@ -84004,6 +84200,7 @@ function createTypeChecker(host) {
           }
           break;
         }
+      // falls through
       case 263 /* ClassDeclaration */:
       case 266 /* EnumDeclaration */:
       case 262 /* FunctionDeclaration */:
@@ -84680,6 +84877,7 @@ function createTypeChecker(host) {
         return checkJSDocPropertyTag(node);
       case 317 /* JSDocFunctionType */:
         checkJSDocFunctionType(node);
+      // falls through
       case 315 /* JSDocNonNullableType */:
       case 314 /* JSDocNullableType */:
       case 312 /* JSDocAllType */:
@@ -85103,6 +85301,7 @@ function createTypeChecker(host) {
         switch (location.kind) {
           case 307 /* SourceFile */:
             if (!isExternalModule(location)) break;
+          // falls through
           case 267 /* ModuleDeclaration */:
             copyLocallyVisibleExportSymbols(getSymbolOfDeclaration(location).exports, meaning & 2623475 /* ModuleMember */);
             break;
@@ -85114,6 +85313,9 @@ function createTypeChecker(host) {
             if (className) {
               copySymbol(location.symbol, meaning);
             }
+          // this fall-through is necessary because we would like to handle
+          // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration.
+          // falls through
           case 263 /* ClassDeclaration */:
           case 264 /* InterfaceDeclaration */:
             if (!isStaticSymbol) {
@@ -85222,6 +85424,7 @@ function createTypeChecker(host) {
         if (isPropertyAccessExpression(entityName.parent) && getLeftmostAccessExpression(entityName.parent) === entityName) {
           return void 0;
         }
+      // falls through
       case 4 /* ThisProperty */:
       case 2 /* ModuleExports */:
         return getSymbolOfDeclaration(entityName.parent.parent);
@@ -85515,6 +85718,7 @@ function createTypeChecker(host) {
         if (!isThisInTypeQuery(node)) {
           return getSymbolOfNameOrPropertyAccessExpression(node);
         }
+      // falls through
       case 110 /* ThisKeyword */:
         const container = getThisContainer(
           node,
@@ -85532,6 +85736,7 @@ function createTypeChecker(host) {
         if (isInExpressionContext(node)) {
           return checkExpression(node).symbol;
         }
+      // falls through
       case 197 /* ThisType */:
         return getTypeFromThisTypeNode(node).symbol;
       case 108 /* SuperKeyword */:
@@ -85554,6 +85759,7 @@ function createTypeChecker(host) {
         if (isCallExpression(parent) && isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) {
           return getSymbolOfDeclaration(parent);
         }
+      // falls through
       case 9 /* NumericLiteral */:
         const objectType = isElementAccessExpression(parent) ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : void 0 : isLiteralTypeNode(parent) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0;
         return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text));
@@ -85583,6 +85789,7 @@ function createTypeChecker(host) {
           const symbol = getIntrinsicTagSymbol(node.parent);
           return symbol === unknownSymbol ? void 0 : symbol;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -87677,6 +87884,7 @@ function createTypeChecker(host) {
                   );
                   break;
                 }
+              // fallthrough
               case 7 /* ES2022 */:
               case 99 /* ESNext */:
               case 200 /* Preserve */:
@@ -87684,6 +87892,7 @@ function createTypeChecker(host) {
                 if (languageVersion >= 4 /* ES2017 */) {
                   break;
                 }
+              // fallthrough
               default:
                 diagnostics.add(
                   createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher)
@@ -89860,13 +90069,13 @@ var visitEachChildTable = {
     );
   },
   // Transformation nodes
-  [354 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+  [355 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
     return context.factory.updatePartiallyEmittedExpression(
       node,
       Debug.checkDefined(nodeVisitor(node.expression, visitor, isExpression))
     );
   },
-  [355 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+  [356 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
     return context.factory.updateCommaListExpression(
       node,
       nodesVisitor(node.elements, visitor, isExpression)
@@ -91790,6 +91999,8 @@ function transformTypeScript(context) {
       case 148 /* ReadonlyKeyword */:
       case 103 /* InKeyword */:
       case 147 /* OutKeyword */:
+      // TypeScript accessibility and readonly modifiers are elided
+      // falls through
       case 188 /* ArrayType */:
       case 189 /* TupleType */:
       case 190 /* OptionalType */:
@@ -91818,6 +92029,8 @@ function transformTypeScript(context) {
       case 199 /* IndexedAccessType */:
       case 200 /* MappedType */:
       case 201 /* LiteralType */:
+      // TypeScript type nodes are elided.
+      // falls through
       case 181 /* IndexSignature */:
         return void 0;
       case 265 /* TypeAliasDeclaration */:
@@ -93500,7 +93713,7 @@ function transformClassFields(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -95440,6 +95653,7 @@ function transformClassFields(context) {
         if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) {
           break;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 177 /* GetAccessor */:
@@ -95715,6 +95929,7 @@ function createRuntimeTypeSerializer(context) {
       case 197 /* ThisType */:
       case 205 /* ImportType */:
         break;
+      // handle JSDoc types from an invalid parse
       case 312 /* JSDocAllType */:
       case 313 /* JSDocUnknownType */:
       case 317 /* JSDocFunctionType */:
@@ -96560,6 +96775,7 @@ function transformESDecorators(context) {
         return Debug.fail("Not supported outside of a class. Use 'classElementVisitor' instead.");
       case 169 /* Parameter */:
         return visitParameterDeclaration(node);
+      // Support NamedEvaluation to ensure the correct class name for class expressions.
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(
           node,
@@ -96580,7 +96796,7 @@ function transformESDecorators(context) {
         return visitForStatement(node);
       case 244 /* ExpressionStatement */:
         return visitExpressionStatement(node);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -96592,7 +96808,7 @@ function transformESDecorators(context) {
           /*discarded*/
           false
         );
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(
           node,
           /*discarded*/
@@ -96616,6 +96832,7 @@ function transformESDecorators(context) {
       case 167 /* ComputedPropertyName */:
         return visitComputedPropertyName(node);
       case 174 /* MethodDeclaration */:
+      // object literal methods and accessors
       case 178 /* SetAccessor */:
       case 177 /* GetAccessor */:
       case 218 /* FunctionExpression */:
@@ -96678,7 +96895,7 @@ function transformESDecorators(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -99260,7 +99477,7 @@ function transformES2018(context) {
         return visitObjectLiteralExpression(node);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 299 /* CatchClause */:
         return visitCatchClause(node);
@@ -102400,6 +102617,7 @@ function transformES2015(context) {
     switch (node.kind) {
       case 126 /* StaticKeyword */:
         return void 0;
+      // elide static keyword
       case 263 /* ClassDeclaration */:
         return visitClassDeclaration(node);
       case 231 /* ClassExpression */:
@@ -102478,7 +102696,7 @@ function transformES2015(context) {
         return visitParenthesizedExpression(node, expressionResultIsUnused2);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 15 /* NoSubstitutionTemplateLiteral */:
       case 16 /* TemplateHead */:
@@ -102862,12 +103080,14 @@ function transformES2015(context) {
       return false;
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return false;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -103076,12 +103296,14 @@ function transformES2015(context) {
       return factory2.createPartiallyEmittedExpression(node.right, node);
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return node;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -103127,12 +103349,14 @@ function transformES2015(context) {
       );
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return node;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -105764,7 +105988,7 @@ function transformGenerators(context) {
     switch (node.kind) {
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node);
       case 227 /* ConditionalExpression */:
         return visitConditionalExpression(node);
@@ -108155,7 +108379,7 @@ function transformModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 213 /* CallExpression */:
         if (isImportCall(node) && host.shouldTransformImportCall(currentSourceFile)) {
@@ -109915,6 +110139,7 @@ function transformSystemModule(context) {
             if (!entry.importClause) {
               break;
             }
+          // falls through
           case 271 /* ImportEqualsDeclaration */:
             Debug.assert(importVariableName !== void 0);
             statements.push(
@@ -110549,7 +110774,7 @@ function transformSystemModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 226 /* BinaryExpression */:
         if (isDestructuringAssignment(node)) {
@@ -112148,6 +112373,7 @@ function transformDeclarations(context) {
       case 265 /* TypeAliasDeclaration */:
       case 266 /* EnumDeclaration */:
         return !resolver.isDeclarationVisible(node);
+      // The following should be doing their own visibility checks based on filtering their members
       case 260 /* VariableDeclaration */:
         return !getBindingNameVisible(node);
       case 271 /* ImportEqualsDeclaration */:
@@ -113429,7 +113655,7 @@ function noEmitNotification(hint, node, callback) {
 }
 function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
   var _a, _b;
-  const enabledSyntaxKindFeatures = new Array(357 /* Count */);
+  const enabledSyntaxKindFeatures = new Array(358 /* Count */);
   let lexicalEnvironmentVariableDeclarations;
   let lexicalEnvironmentFunctionDeclarations;
   let lexicalEnvironmentStatements;
@@ -114632,6 +114858,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) {
           return pipelineEmitWithNotification;
         }
+      // falls through
       case 1 /* Substitution */:
         if (substituteNode !== noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) {
           if (currentParenthesizerRule) {
@@ -114639,14 +114866,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           }
           return pipelineEmitWithSubstitution;
         }
+      // falls through
       case 2 /* Comments */:
         if (shouldEmitComments(node)) {
           return pipelineEmitWithComments;
         }
+      // falls through
       case 3 /* SourceMaps */:
         if (shouldEmitSourceMaps(node)) {
           return pipelineEmitWithSourceMaps;
         }
+      // falls through
       case 4 /* Emit */:
         return pipelineEmitWithHint;
       default:
@@ -114698,6 +114928,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 4 /* Unspecified */) {
       switch (node.kind) {
+        // Pseudo-literals
         case 16 /* TemplateHead */:
         case 17 /* TemplateMiddle */:
         case 18 /* TemplateTail */:
@@ -114706,20 +114937,26 @@ function createPrinter(printerOptions = {}, handlers = {}) {
             /*jsxAttributeEscape*/
             false
           );
+        // Identifiers
         case 80 /* Identifier */:
           return emitIdentifier(node);
+        // PrivateIdentifiers
         case 81 /* PrivateIdentifier */:
           return emitPrivateIdentifier(node);
+        // Parse tree nodes
+        // Names
         case 166 /* QualifiedName */:
           return emitQualifiedName(node);
         case 167 /* ComputedPropertyName */:
           return emitComputedPropertyName(node);
+        // Signature elements
         case 168 /* TypeParameter */:
           return emitTypeParameter(node);
         case 169 /* Parameter */:
           return emitParameter(node);
         case 170 /* Decorator */:
           return emitDecorator(node);
+        // Type members
         case 171 /* PropertySignature */:
           return emitPropertySignature(node);
         case 172 /* PropertyDeclaration */:
@@ -114741,6 +114978,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitConstructSignature(node);
         case 181 /* IndexSignature */:
           return emitIndexSignature(node);
+        // Types
         case 182 /* TypePredicate */:
           return emitTypePredicate(node);
         case 183 /* TypeReference */:
@@ -114759,6 +114997,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTupleType(node);
         case 190 /* OptionalType */:
           return emitOptionalType(node);
+        // SyntaxKind.RestType is handled below
         case 192 /* UnionType */:
           return emitUnionType(node);
         case 193 /* IntersectionType */:
@@ -114789,16 +115028,19 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTemplateTypeSpan(node);
         case 205 /* ImportType */:
           return emitImportTypeNode(node);
+        // Binding patterns
         case 206 /* ObjectBindingPattern */:
           return emitObjectBindingPattern(node);
         case 207 /* ArrayBindingPattern */:
           return emitArrayBindingPattern(node);
         case 208 /* BindingElement */:
           return emitBindingElement(node);
+        // Misc
         case 239 /* TemplateSpan */:
           return emitTemplateSpan(node);
         case 240 /* SemicolonClassElement */:
           return emitSemicolonClassElement();
+        // Statements
         case 241 /* Block */:
           return emitBlock(node);
         case 243 /* VariableStatement */:
@@ -114840,6 +115082,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTryStatement(node);
         case 259 /* DebuggerStatement */:
           return emitDebuggerStatement(node);
+        // Declarations
         case 260 /* VariableDeclaration */:
           return emitVariableDeclaration(node);
         case 261 /* VariableDeclarationList */:
@@ -114890,8 +115133,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitImportAttribute(node);
         case 282 /* MissingDeclaration */:
           return;
+        // Module references
         case 283 /* ExternalModuleReference */:
           return emitExternalModuleReference(node);
+        // JSX (non-expression)
         case 12 /* JsxText */:
           return emitJsxText(node);
         case 286 /* JsxOpeningElement */:
@@ -114910,6 +115155,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJsxExpression(node);
         case 295 /* JsxNamespacedName */:
           return emitJsxNamespacedName(node);
+        // Clauses
         case 296 /* CaseClause */:
           return emitCaseClause(node);
         case 297 /* DefaultClause */:
@@ -114918,18 +115164,22 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitHeritageClause(node);
         case 299 /* CatchClause */:
           return emitCatchClause(node);
+        // Property assignments
         case 303 /* PropertyAssignment */:
           return emitPropertyAssignment(node);
         case 304 /* ShorthandPropertyAssignment */:
           return emitShorthandPropertyAssignment(node);
         case 305 /* SpreadAssignment */:
           return emitSpreadAssignment(node);
+        // Enum
         case 306 /* EnumMember */:
           return emitEnumMember(node);
+        // Top-level nodes
         case 307 /* SourceFile */:
           return emitSourceFile(node);
         case 308 /* Bundle */:
           return Debug.fail("Bundles should be printed using printBundle");
+        // JSDoc nodes (only used in codefixes currently)
         case 309 /* JSDocTypeExpression */:
           return emitJSDocTypeExpression(node);
         case 310 /* JSDocNameReference */:
@@ -114967,6 +115217,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         case 330 /* JSDocAuthorTag */:
         case 331 /* JSDocDeprecatedTag */:
           return;
+        // SyntaxKind.JSDocClassTag (see JSDocTag, above)
         case 333 /* JSDocPublicTag */:
         case 334 /* JSDocPrivateTag */:
         case 335 /* JSDocProtectedTag */:
@@ -114976,6 +115227,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJSDocCallbackTag(node);
         case 339 /* JSDocOverloadTag */:
           return emitJSDocOverloadTag(node);
+        // SyntaxKind.JSDocEnumTag (see below)
         case 341 /* JSDocParameterTag */:
         case 348 /* JSDocPropertyTag */:
           return emitJSDocPropertyLikeTag(node);
@@ -114994,7 +115246,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJSDocSeeTag(node);
         case 351 /* JSDocImportTag */:
           return emitJSDocImportTag(node);
+        // SyntaxKind.JSDocPropertyTag (see JSDocParameterTag, above)
+        // Transformation nodes
         case 353 /* NotEmittedStatement */:
+        case 354 /* NotEmittedTypeElement */:
           return;
       }
       if (isExpression(node)) {
@@ -115012,6 +115267,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 1 /* Expression */) {
       switch (node.kind) {
+        // Literals
         case 9 /* NumericLiteral */:
         case 10 /* BigIntLiteral */:
           return emitNumericOrBigIntLiteral(node);
@@ -115023,10 +115279,12 @@ function createPrinter(printerOptions = {}, handlers = {}) {
             /*jsxAttributeEscape*/
             false
           );
+        // Identifiers
         case 80 /* Identifier */:
           return emitIdentifier(node);
         case 81 /* PrivateIdentifier */:
           return emitPrivateIdentifier(node);
+        // Expressions
         case 209 /* ArrayLiteralExpression */:
           return emitArrayLiteralExpression(node);
         case 210 /* ObjectLiteralExpression */:
@@ -115089,21 +115347,24 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return Debug.fail("SyntheticExpression should never be printed.");
         case 282 /* MissingDeclaration */:
           return;
+        // JSX
         case 284 /* JsxElement */:
           return emitJsxElement(node);
         case 285 /* JsxSelfClosingElement */:
           return emitJsxSelfClosingElement(node);
         case 288 /* JsxFragment */:
           return emitJsxFragment(node);
+        // Synthesized list
         case 352 /* SyntaxList */:
           return Debug.fail("SyntaxList should not be printed");
+        // Transformation nodes
         case 353 /* NotEmittedStatement */:
           return;
-        case 354 /* PartiallyEmittedExpression */:
+        case 355 /* PartiallyEmittedExpression */:
           return emitPartiallyEmittedExpression(node);
-        case 355 /* CommaListExpression */:
+        case 356 /* CommaListExpression */:
           return emitCommaList(node);
-        case 356 /* SyntheticReferenceExpression */:
+        case 357 /* SyntheticReferenceExpression */:
           return Debug.fail("SyntheticReferenceExpression should not be printed");
       }
     }
@@ -121240,6 +121501,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNode2(node, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
               return "skip";
             }
+          // falls through
           case 173 /* MethodSignature */:
           case 176 /* Constructor */:
           case 177 /* GetAccessor */:
@@ -121371,6 +121633,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files));
               return "skip";
             }
+          // falls through
           case 243 /* VariableStatement */:
             if (nodes === parent.modifiers) {
               checkModifiers(parent.modifiers, parent.kind === 243 /* VariableStatement */);
@@ -121413,6 +121676,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               if (isConstValid) {
                 continue;
               }
+            // to report error,
+            // falls through
             case 125 /* PublicKeyword */:
             case 123 /* PrivateKeyword */:
             case 124 /* ProtectedKeyword */:
@@ -121424,6 +121689,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
             case 147 /* OutKeyword */:
               diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
               break;
+            // These are all legal modifiers.
             case 126 /* StaticKeyword */:
             case 95 /* ExportKeyword */:
             case 90 /* DefaultKeyword */:
@@ -126829,6 +127095,7 @@ function getSourceFileVersionAsHashFromText(host, text) {
           if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) {
             pos--;
           }
+        // falls through
         case 13 /* carriageReturn */:
           break;
         default:
@@ -128315,6 +128582,7 @@ function createBuildOrUpdateInvalidedProject(state, project, projectPath, projec
           queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
           step++;
           break;
+        // Should never be done
         case 3 /* Done */:
         default:
           assertType(step);
@@ -128855,6 +129123,7 @@ function queueReferencingProjects(state, project, projectPath, projectIndex, con
               status.type = 2 /* UpToDateWithUpstreamTypes */;
               break;
             }
+          // falls through
           case 15 /* UpToDateWithInputFileText */:
           case 2 /* UpToDateWithUpstreamTypes */:
             if (!(buildResult & 2 /* DeclarationOutputUnchanged */)) {
@@ -129372,6 +129641,8 @@ function reportUpToDateStatus(state, configFileName, status) {
         relName(state, configFileName)
       );
     case 16 /* ContainerOnly */:
+    // Don't report status on "solution" projects
+    // falls through
     case 13 /* ComputingUpstream */:
       break;
     default: