tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-contextual.js

@@ -98,7 +98,7 @@ export function getInferenceContext(c, node) {
 }
 /** The node a contextual type for `node` is pushed onto: an element for its attributes, which spans its children. */
 function getContextNode(node) {
-    if (node.kind === 293 /* SyntaxKind.JsxAttributes */ && node.parent.kind !== 286 /* SyntaxKind.JsxSelfClosingElement */)
+    if (node.kind === 294 /* SyntaxKind.JsxAttributes */ && node.parent.kind !== 287 /* SyntaxKind.JsxSelfClosingElement */)
         return node.parent.parent;
     return node;
 }
@@ -175,56 +175,56 @@ export function getContextualTypeEx(c, node, contextFlags) {
     if (parent === undefined)
         return undefined;
     switch (parent.kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 209 /* SyntaxKind.BindingElement */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 210 /* SyntaxKind.BindingElement */:
             if (getInitializer(parent) !== node)
                 return undefined;
             return getContextualTypeForInitializerExpression(c, parent, contextFlags);
-        case 220 /* SyntaxKind.ArrowFunction */:
-        case 254 /* SyntaxKind.ReturnStatement */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 255 /* SyntaxKind.ReturnStatement */:
             return getContextualTypeForReturnExpression(c, node);
-        case 230 /* SyntaxKind.YieldExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
             return getContextualTypeForYieldOperand(c, parent, contextFlags);
-        case 224 /* SyntaxKind.AwaitExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
             return getContextualTypeForAwaitOperand(c, parent, contextFlags);
-        case 214 /* SyntaxKind.CallExpression */:
-        case 215 /* SyntaxKind.NewExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return getContextualTypeForArgument(c, parent, node);
-        case 171 /* SyntaxKind.Decorator */: {
+        case 172 /* SyntaxKind.Decorator */: {
             // A decorator expression is contextually typed by the call the runtime makes.
             const signature = getDecoratorCallSignature(c, parent);
             return signature !== undefined ? getOrCreateTypeFromSignature(c, signature) : undefined;
         }
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */: {
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */: {
             const typeNode = getType(parent);
             return isConstTypeReference(typeNode)
                 ? getContextualTypeEx(c, parent, contextFlags)
                 : getTypeFromTypeNode(c, typeNode);
         }
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return getTypeFromTypeNode(c, getType(parent));
-        case 278 /* SyntaxKind.ExportAssignment */: {
+        case 279 /* SyntaxKind.ExportAssignment */: {
             // A JSDoc `@type` on `export default`.
             const typeNode = getType(parent);
             return typeNode !== undefined ? getTypeFromTypeNode(c, typeNode) : undefined;
         }
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return getContextualTypeForBinaryOperand(c, parent, node, contextFlags);
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             // The property's name gets the property's contextual type too.
             return getContextualTypeForObjectLiteralElement(c, parent, contextFlags);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-            return node.kind === 175 /* SyntaxKind.MethodDeclaration */
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+            return node.kind === 176 /* SyntaxKind.MethodDeclaration */
                 ? getContextualTypeForObjectLiteralElement(c, node, contextFlags)
                 : undefined;
-        case 305 /* SyntaxKind.SpreadAssignment */:
+        case 306 /* SyntaxKind.SpreadAssignment */:
             return getContextualTypeEx(c, parent.parent, contextFlags);
-        case 210 /* SyntaxKind.ArrayLiteralExpression */: {
+        case 211 /* SyntaxKind.ArrayLiteralExpression */: {
             const elements = parent.elements.nodes;
             const index = indexOfNode(elements, node);
             if (index < 0)
@@ -232,28 +232,28 @@ export function getContextualTypeEx(c, node, contextFlags) {
             const spreads = getSpreadIndices(c, parent, elements);
             return getContextualTypeForElementExpression(c, getApparentTypeOfContextualTypeEx(c, parent, contextFlags), index, elements.length, spreads.first, spreads.last);
         }
-        case 228 /* SyntaxKind.ConditionalExpression */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = parent;
             return node === cond.whenTrue || node === cond.whenFalse
                 ? getContextualTypeEx(c, parent, contextFlags)
                 : undefined;
         }
-        case 240 /* SyntaxKind.TemplateSpan */: {
+        case 241 /* SyntaxKind.TemplateSpan */: {
             const template = parent.parent;
-            return template.parent !== undefined && template.parent.kind === 216 /* SyntaxKind.TaggedTemplateExpression */
+            return template.parent !== undefined && template.parent.kind === 217 /* SyntaxKind.TaggedTemplateExpression */
                 ? getContextualTypeForArgument(c, template.parent, node)
                 : undefined;
         }
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 236 /* SyntaxKind.NonNullExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
             return getContextualTypeEx(c, parent, contextFlags);
-        case 295 /* SyntaxKind.JsxExpression */:
+        case 296 /* SyntaxKind.JsxExpression */:
             return getContextualTypeForJsxExpression(c, parent, contextFlags);
-        case 292 /* SyntaxKind.JsxAttribute */:
-        case 294 /* SyntaxKind.JsxSpreadAttribute */:
+        case 293 /* SyntaxKind.JsxAttribute */:
+        case 295 /* SyntaxKind.JsxSpreadAttribute */:
             return getContextualTypeForJsxAttribute(c, parent, contextFlags);
-        case 287 /* SyntaxKind.JsxOpeningElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 288 /* SyntaxKind.JsxOpeningElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
             return getContextualJsxElementAttributesType(c, parent, contextFlags);
     }
     return undefined;
@@ -266,7 +266,7 @@ function getContextualTypeForInitializerExpression(c, declaration, contextFlags)
     const name = getName(declaration);
     if ((contextFlags & 8 /* ContextFlags.SkipBindingPatterns */) === 0 &&
         name !== undefined &&
-        (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */) &&
+        (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */) &&
         getElements(name).nodes.length > 0)
         return getTypeFromBindingPattern(c, name, true, false);
     return undefined;
@@ -275,17 +275,20 @@ function getContextualTypeForInitializer(c, declaration, contextFlags) {
     const typeNode = getType(declaration);
     if (typeNode !== undefined)
         return getTypeFromTypeNode(c, typeNode);
-    if (declaration.kind === 170 /* SyntaxKind.Parameter */)
+    if (declaration.kind === 171 /* SyntaxKind.Parameter */)
         return getContextuallyTypedParameterTypeOrUndefined(c, declaration);
-    if (declaration.kind === 209 /* SyntaxKind.BindingElement */)
+    if (declaration.kind === 210 /* SyntaxKind.BindingElement */)
         return getContextualTypeForBindingElement(c, declaration);
     // A static property of a class expression takes the type of the same property of the class's contextual type.
-    if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+    if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         isStatic(declaration) &&
-        declaration.parent.kind === 232 /* SyntaxKind.ClassExpression */) {
+        declaration.parent.kind === 233 /* SyntaxKind.ClassExpression */) {
         const parentType = getContextualTypeEx(c, declaration.parent, contextFlags);
         const symbol = getSymbolOfDeclaration(c, declaration);
-        if (parentType !== undefined && symbol !== undefined)
+        // The class's own type might still be in progress, so contextually typing by it would report a spurious circularity.
+        if (parentType !== undefined &&
+            symbol !== undefined &&
+            parentType.symbol !== getSymbolOfDeclaration(c, declaration.parent))
             return getTypeOfPropertyOfContextualType(c, parentType, symbol.name);
     }
     return undefined;
@@ -295,18 +298,18 @@ function getContextualTypeForBindingElement(c, declaration) {
     const element = declaration;
     const name = element.propertyName ?? element.name;
     if (name === undefined ||
-        name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
-        name.kind === 208 /* SyntaxKind.ArrayBindingPattern */ ||
-        (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputedName(name)))
+        name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ ||
+        name.kind === 209 /* SyntaxKind.ArrayBindingPattern */ ||
+        (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputedName(name)))
         return undefined;
     const parent = declaration.parent.parent;
     let parentType = getContextualTypeForInitializer(c, parent, 0 /* ContextFlags.None */);
-    if (parentType === undefined && parent.kind !== 209 /* SyntaxKind.BindingElement */ && getInitializer(parent) !== undefined)
+    if (parentType === undefined && parent.kind !== 210 /* SyntaxKind.BindingElement */ && getInitializer(parent) !== undefined)
         parentType = checkDeclarationInitializer(c, parent, element.dotDotDotToken !== undefined ? 32 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */);
     if (parentType === undefined)
         return undefined;
     const parentName = getName(parent);
-    if (parentName.kind === 208 /* SyntaxKind.ArrayBindingPattern */) {
+    if (parentName.kind === 209 /* SyntaxKind.ArrayBindingPattern */) {
         const index = getElements(parentName).nodes.indexOf(declaration);
         if (index < 0)
             return undefined;
@@ -498,7 +501,7 @@ function getSpreadIndices(c, node, elements) {
     let first = -1;
     let last = -1;
     for (let i = 0; i < elements.length; i++)
-        if (elements[i].kind === 231 /* SyntaxKind.SpreadElement */) {
+        if (elements[i].kind === 232 /* SyntaxKind.SpreadElement */) {
             if (first < 0)
                 first = i;
             last = i;
@@ -524,7 +527,7 @@ function getContextualTypeForObjectLiteralElement(c, element, contextFlags) {
             let nameType = symbol !== undefined ? c.symbolNameTypes.get(getSymbolId(symbol)) : undefined;
             // Late-bound members are named by the type of their computed name, like a unique symbol.
             const nameNode = getName(element);
-            if (nameType === undefined && nameNode.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+            if (nameType === undefined && nameNode.kind === 169 /* SyntaxKind.ComputedPropertyName */)
                 nameType = checkComputedPropertyName(c, nameNode);
             return getTypeOfPropertyOfContextualTypeEx(c, t, name, nameType);
         }
@@ -629,7 +632,7 @@ function getTypeOfConcretePropertyOfContextualType(c, t, name) {
 }
 /** Whether the type of a mapped type property is being resolved. */
 function isCircularMappedProperty(c, symbol) {
-    return ((symbol.checkFlags & 262144 /* CheckFlags.Mapped */) !== 0 &&
+    return ((symbol.checkFlags & 2097152 /* CheckFlags.Mapped */) !== 0 &&
         c.symbolTypes.get(getSymbolId(symbol)) === undefined &&
         findResolutionCycleStartIndex(c, symbol, 0 /* TypeSystemPropertyName.Type */) >= 0);
 }
@@ -697,9 +700,9 @@ export function getApparentTypeOfContextualTypeEx(c, node, contextFlags) {
         : mapTypeEx(c, t, (u) => ((u.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 ? u : getApparentType(c, u)), true);
     if (apparentType === undefined)
         return undefined;
-    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
         return discriminateContextualTypeByObjectMembers(c, node, apparentType);
-    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 293 /* SyntaxKind.JsxAttributes */)
+    if ((apparentType.flags & 134217728 /* TypeFlags.Union */) !== 0 && node.kind === 294 /* SyntaxKind.JsxAttributes */)
         return discriminateContextualTypeByJSXAttributes(c, node, apparentType);
     return apparentType;
 }
@@ -732,10 +735,10 @@ function discriminateContextualTypeByObjectMembers(c, node, contextualType) {
             const symbol = getSymbol(p);
             if (symbol === undefined)
                 continue;
-            if ((p.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+            if ((p.kind === 304 /* SyntaxKind.PropertyAssignment */ &&
                 isPossiblyDiscriminantValue(p.initializer) &&
                 isDiscriminantProperty(c, contextualType, symbol.name)) ||
-                (p.kind === 304 /* SyntaxKind.ShorthandPropertyAssignment */ && isDiscriminantProperty(c, contextualType, symbol.name)))
+                (p.kind === 305 /* SyntaxKind.ShorthandPropertyAssignment */ && isDiscriminantProperty(c, contextualType, symbol.name)))
                 props.push(p);
         }
         const nodeSymbol = getSymbol(node);
@@ -789,7 +792,7 @@ function getMatchingUnionConstituentForObjectLiteral(c, unionType, node) {
     for (const p of getProperties(node).nodes) {
         const symbol = getSymbol(p);
         if (symbol !== undefined &&
-            p.kind === 303 /* SyntaxKind.PropertyAssignment */ &&
+            p.kind === 304 /* SyntaxKind.PropertyAssignment */ &&
             symbol.name === keyPropertyName &&
             isPossiblyDiscriminantValue(p.initializer)) {
             propNode = p;
@@ -807,17 +810,17 @@ function isPossiblyDiscriminantValue(node) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
         case 111 /* SyntaxKind.TrueKeyword */:
         case 96 /* SyntaxKind.FalseKeyword */:
         case 105 /* SyntaxKind.NullKeyword */:
         case 79 /* SyntaxKind.Identifier */:
         case 157 /* SyntaxKind.UndefinedKeyword */:
             return true;
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return isPossiblyDiscriminantValue(getExpression(node));
-        case 295 /* SyntaxKind.JsxExpression */: {
+        case 296 /* SyntaxKind.JsxExpression */: {
             const expression = getExpression(node);
             return expression === undefined || isPossiblyDiscriminantValue(expression);
         }
@@ -912,7 +915,7 @@ function discriminantMatches(c, props, index, t) {
     let propType;
     if (index < props.length) {
         const prop = props[index];
-        if (prop.kind === 303 /* SyntaxKind.PropertyAssignment */)
+        if (prop.kind === 304 /* SyntaxKind.PropertyAssignment */)
             propType = getContextFreeTypeOfExpression(c, prop.initializer);
         else if (prop instanceof JsxAttribute)
             // An attribute without an initializer is `true`.
@@ -957,7 +960,7 @@ export function hasContextSensitiveParameters(func) {
     for (const p of params)
         if (getType(p) === undefined)
             return true;
-    if (func.kind !== 220 /* SyntaxKind.ArrowFunction */) {
+    if (func.kind !== 221 /* SyntaxKind.ArrowFunction */) {
         // Without an explicit `this` parameter, the implicit one is contextually typed.
         if (params.length === 0 || !isThisParameter(params[0]))
             return (func.flags & 128 /* NodeFlags.ContainsThis */) !== 0;
@@ -1084,7 +1087,7 @@ export function getContextuallyTypedParameterType(c, parameter) {
 }
 /** The contextual type of an intra-expression inference site. */
 export function getContextualTypeForInference(c, node) {
-    return node.kind === 175 /* SyntaxKind.MethodDeclaration */
+    return node.kind === 176 /* SyntaxKind.MethodDeclaration */
         ? getContextualTypeForObjectLiteralElement(c, node, 2 /* ContextFlags.NoConstraints */)
         : getContextualTypeEx(c, node, 2 /* ContextFlags.NoConstraints */);
 }
@@ -1109,7 +1112,7 @@ function getThisTypeOfObjectLiteralFromContextualType(c, containingLiteral, cont
         const thisType = getThisTypeFromContextualType(c, t);
         if (thisType !== undefined)
             return thisType;
-        if (literal.parent.kind !== 303 /* SyntaxKind.PropertyAssignment */)
+        if (literal.parent.kind !== 304 /* SyntaxKind.PropertyAssignment */)
             break;
         literal = literal.parent.parent;
         t = getApparentTypeOfContextualTypeEx(c, literal, 0 /* ContextFlags.None */);

package/dist/api/compiler/checker-declaration-order.js

@@ -25,7 +25,7 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     let declaration;
     for (let i = 0; i < declarationCount(result); i++) {
         const d = declarationAt(result, i);
-        if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 267 /* SyntaxKind.EnumDeclaration */) {
+        if (isBlockOrCatchScoped(d) || isClassLike(d) || d.kind === 268 /* SyntaxKind.EnumDeclaration */) {
             declaration = d;
             break;
         }
@@ -37,13 +37,13 @@ export function checkResolvedBlockScopedVariable(c, resolved, errorLocation) {
     const declarationName = declarationNameToString(getSourceFileOfNode(declaration), getNameOfDeclaration(declaration));
     let diagnostic = undefined;
     if ((result.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0)
-        diagnostic = c.error(errorLocation, 616 /* Diagnostics.Block_scoped_variable_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 623 /* Diagnostics.Block_scoped_variable_0_used_before_its_declaration */, declarationName);
     else if ((result.flags & 32 /* SymbolFlags.Class */) !== 0)
-        diagnostic = c.error(errorLocation, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 624 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
     else if ((result.flags & 256 /* SymbolFlags.RegularEnum */) !== 0 || c.isolatedModules)
-        diagnostic = c.error(errorLocation, 618 /* Diagnostics.Enum_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(errorLocation, 625 /* Diagnostics.Enum_0_used_before_its_declaration */, declarationName);
     if (diagnostic !== undefined)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(declaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(declaration, 867 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
 }
 /** Reports a class property read in an initializer before it's initialized. */
 export function checkPropertyNotUsedBeforeDeclaration(c, prop, node, right) {
@@ -56,33 +56,33 @@ export function checkPropertyNotUsedBeforeDeclaration(c, prop, node, right) {
         !isOptionalPropertyDeclaration(valueDeclaration) &&
         !(isAccessExpression(node) && isAccessExpression(getExpression(node))) &&
         !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right) &&
-        !(valueDeclaration.kind === 175 /* SyntaxKind.MethodDeclaration */ && isStatic(valueDeclaration)) &&
+        !(valueDeclaration.kind === 176 /* SyntaxKind.MethodDeclaration */ && isStatic(valueDeclaration)) &&
         (getUseDefineForClassFields(c) || !isPropertyDeclaredInAncestorClass(c, prop)))
-        diagnostic = c.error(right, 861 /* Diagnostics.Property_0_is_used_before_its_initialization */, declarationName);
-    else if (valueDeclaration.kind === 264 /* SyntaxKind.ClassDeclaration */ &&
-        node.parent.kind !== 184 /* SyntaxKind.TypeReference */ &&
+        diagnostic = c.error(right, 868 /* Diagnostics.Property_0_is_used_before_its_initialization */, declarationName);
+    else if (valueDeclaration.kind === 265 /* SyntaxKind.ClassDeclaration */ &&
+        node.parent.kind !== 185 /* SyntaxKind.TypeReference */ &&
         (valueDeclaration.flags & 8388608 /* NodeFlags.Ambient */) === 0 &&
         !isBlockScopedNameDeclaredBeforeUse(c, valueDeclaration, right))
-        diagnostic = c.error(right, 617 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
+        diagnostic = c.error(right, 624 /* Diagnostics.Class_0_used_before_its_declaration */, declarationName);
     if (diagnostic !== undefined)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
+        diagnostic.addRelatedInfo(createDiagnosticForNode(valueDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [declarationName]));
 }
 export function isInPropertyInitializerOrClassStaticBlock(node, ignoreArrowFunctions) {
     for (let current = node; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return true;
-            case 187 /* SyntaxKind.TypeQuery */:
-            case 288 /* SyntaxKind.JsxClosingElement */:
+            case 188 /* SyntaxKind.TypeQuery */:
+            case 289 /* SyntaxKind.JsxClosingElement */:
                 return false;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (!ignoreArrowFunctions)
                     return false;
                 break;
-            case 242 /* SyntaxKind.Block */: {
+            case 243 /* SyntaxKind.Block */: {
                 const parent = current.parent;
-                if (isFunctionLike(parent) && parent.kind !== 220 /* SyntaxKind.ArrowFunction */)
+                if (isFunctionLike(parent) && parent.kind !== 221 /* SyntaxKind.ArrowFunction */)
                     return false;
             }
         }
@@ -90,7 +90,7 @@ export function isInPropertyInitializerOrClassStaticBlock(node, ignoreArrowFunct
     return false;
 }
 function isOptionalPropertyDeclaration(node) {
-    if (node.kind !== 173 /* SyntaxKind.PropertyDeclaration */)
+    if (node.kind !== 174 /* SyntaxKind.PropertyDeclaration */)
         return false;
     const postfix = getPostfixToken(node);
     return postfix !== undefined && postfix.kind === 57 /* SyntaxKind.QuestionToken */;
@@ -120,25 +120,25 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     if ((usage.flags & 4194304 /* NodeFlags.JSDoc */) !== 0 || isPartOfTypeQuery(usage) || isInAmbientOrTypeNode(usage))
         return true;
     if (declaration.pos <= usage.pos &&
-        !(declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+        !(declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
             isThisProperty(usage.parent) &&
             getInitializer(declaration) === undefined &&
             declaration.postfixToken?.kind !== 53 /* SyntaxKind.ExclamationToken */)) {
-        if (declaration.kind === 209 /* SyntaxKind.BindingElement */) {
+        if (declaration.kind === 210 /* SyntaxKind.BindingElement */) {
             // Binding elements may use earlier siblings only (`var [a = b, b = b] = ...` is an error).
-            const errorBindingElement = findAncestorOfKind(usage, 209 /* SyntaxKind.BindingElement */);
+            const errorBindingElement = findAncestorOfKind(usage, 210 /* SyntaxKind.BindingElement */);
             if (errorBindingElement !== undefined)
-                return (findAncestorOfKind(errorBindingElement, 209 /* SyntaxKind.BindingElement */) !==
-                    findAncestorOfKind(declaration, 209 /* SyntaxKind.BindingElement */) || declaration.pos < errorBindingElement.pos);
+                return (findAncestorOfKind(errorBindingElement, 210 /* SyntaxKind.BindingElement */) !==
+                    findAncestorOfKind(declaration, 210 /* SyntaxKind.BindingElement */) || declaration.pos < errorBindingElement.pos);
             // `var [a] = a` uses the variable before its declaration.
-            return isBlockScopedNameDeclaredBeforeUse(c, findAncestorOfKind(declaration, 261 /* SyntaxKind.VariableDeclaration */), usage);
+            return isBlockScopedNameDeclaredBeforeUse(c, findAncestorOfKind(declaration, 262 /* SyntaxKind.VariableDeclaration */), usage);
         }
-        if (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */)
+        if (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */)
             // `var a = a` uses the variable in its own initializer.
             return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer);
         if (isClassLike(declaration))
             return !isUsedInClassComputedNameOrDecorator(c, declaration, usage);
-        if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+        if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */)
             // A self-referencing property initializer, as in `x = this.x`.
             return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, false);
         if (isParameterPropertyDeclaration(declaration, declaration.parent))
@@ -151,12 +151,12 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     // Uses after the declaration are legal when deferred: in export specifiers and `export =`,
     // functions, and instance property initializers referencing other members.
     const parent = usage.parent;
-    if (parent.kind === 282 /* SyntaxKind.ExportSpecifier */ || isExportEquals(parent) || isExportEquals(usage))
+    if (parent.kind === 283 /* SyntaxKind.ExportSpecifier */ || isExportEquals(parent) || isExportEquals(usage))
         return true;
     if (isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer)) {
         if (getEmitStandardClassFields(c) &&
             getContainingClass(declaration) !== undefined &&
-            (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ ||
+            (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ ||
                 isParameterPropertyDeclaration(declaration, declaration.parent)))
             return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, true);
         return true;
@@ -164,7 +164,7 @@ export function isBlockScopedNameDeclaredBeforeUse(c, declaration, usage) {
     return false;
 }
 function isExportEquals(node) {
-    return node.kind === 278 /* SyntaxKind.ExportAssignment */ && node.isExportEquals;
+    return node.kind === 279 /* SyntaxKind.ExportAssignment */ && node.isExportEquals;
 }
 /**
  * Whether a use of a class within its own declaration happens before the class exists: in a
@@ -174,24 +174,24 @@ function isUsedInClassComputedNameOrDecorator(c, declaration, usage) {
     const legacyDecorators = c.compilerOptions.experimentalDecorators === true;
     let container = usage;
     while (container !== undefined && container !== declaration) {
-        if (container.kind === 168 /* SyntaxKind.ComputedPropertyName */ && container.parent.parent === declaration)
+        if (container.kind === 169 /* SyntaxKind.ComputedPropertyName */ && container.parent.parent === declaration)
             break;
-        if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+        if (!legacyDecorators && container.kind === 172 /* SyntaxKind.Decorator */) {
             const decorated = container.parent;
             if (decorated === declaration ||
-                ((decorated.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                    decorated.kind === 178 /* SyntaxKind.GetAccessor */ ||
-                    decorated.kind === 179 /* SyntaxKind.SetAccessor */ ||
-                    decorated.kind === 173 /* SyntaxKind.PropertyDeclaration */) &&
+                ((decorated.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                    decorated.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                    decorated.kind === 180 /* SyntaxKind.SetAccessor */ ||
+                    decorated.kind === 174 /* SyntaxKind.PropertyDeclaration */) &&
                     decorated.parent === declaration) ||
-                (decorated.kind === 170 /* SyntaxKind.Parameter */ && decorated.parent.parent === declaration))
+                (decorated.kind === 171 /* SyntaxKind.Parameter */ && decorated.parent.parent === declaration))
                 break;
         }
         container = container.parent;
     }
     if (container === undefined || container === declaration)
         return false;
-    if (!legacyDecorators && container.kind === 171 /* SyntaxKind.Decorator */) {
+    if (!legacyDecorators && container.kind === 172 /* SyntaxKind.Decorator */) {
         let n = usage;
         while (n !== undefined && n !== container) {
             if (isFunctionLike(n) && getImmediatelyInvokedFunctionExpression(n) === undefined)
@@ -215,36 +215,36 @@ function isInAmbientOrTypeNode(node) {
     if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         return true;
     for (let current = node; current !== undefined; current = current.parent)
-        if (current.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
-            current.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
-            current.kind === 188 /* SyntaxKind.TypeLiteral */)
+        if (current.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
+            current.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ ||
+            current.kind === 189 /* SyntaxKind.TypeLiteral */)
             return true;
     return false;
 }
 export function getEnclosingBlockScopeContainer(node) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
-            case 270 /* SyntaxKind.CaseBlock */:
-            case 300 /* SyntaxKind.CatchClause */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 249 /* SyntaxKind.ForStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 308 /* SyntaxKind.SourceFile */:
+            case 271 /* SyntaxKind.CaseBlock */:
+            case 301 /* SyntaxKind.CatchClause */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 250 /* SyntaxKind.ForStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return current;
-            case 242 /* SyntaxKind.Block */: {
+            case 243 /* SyntaxKind.Block */: {
                 // Function bodies aren't block scope containers of their own.
                 const parent = current.parent;
-                if (!isFunctionLike(parent) && parent.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                if (!isFunctionLike(parent) && parent.kind !== 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                     return current;
             }
         }
@@ -260,25 +260,25 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
                 return true;
             continue;
         }
-        if (current.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */) {
+        if (current.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */) {
             if (declaration.pos < usage.pos)
                 return true;
             continue;
         }
         const parent = current.parent;
-        if (parent !== undefined && parent.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(parent) === current) {
+        if (parent !== undefined && parent.kind === 174 /* SyntaxKind.PropertyDeclaration */ && getInitializer(parent) === current) {
             if (isStatic(parent)) {
-                if (declaration.kind === 175 /* SyntaxKind.MethodDeclaration */)
+                if (declaration.kind === 176 /* SyntaxKind.MethodDeclaration */)
                     return true;
                 // A static property assigned in a static block before the initializer.
-                if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+                if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
                     getContainingClass(usage) === getContainingClass(declaration)) {
                     const propName = getName(declaration);
                     if (propName.kind === 79 /* SyntaxKind.Identifier */ || propName.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
                         const symbol = getSymbolOfDeclaration(c, declaration);
                         const staticBlocks = [];
                         for (const m of getMembers(declaration.parent).nodes)
-                            if (m.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+                            if (m.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
                                 staticBlocks.push(m);
                         if (symbol !== undefined &&
                             isPropertyInitializedInStaticBlocks(c, propName, getTypeOfSymbol(c, symbol), staticBlocks, declaration.parent.pos, current.pos))
@@ -287,16 +287,16 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
                 }
             }
             else {
-                const isDeclarationInstanceProperty = declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !isStatic(declaration);
+                const isDeclarationInstanceProperty = declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !isStatic(declaration);
                 if (!isDeclarationInstanceProperty || getContainingClass(usage) !== getContainingClass(declaration))
                     return true;
             }
         }
-        if (parent !== undefined && parent.kind === 171 /* SyntaxKind.Decorator */ && getExpression(parent) === current) {
+        if (parent !== undefined && parent.kind === 172 /* SyntaxKind.Decorator */ && getExpression(parent) === current) {
             const decorated = parent.parent;
-            if (decorated.kind === 170 /* SyntaxKind.Parameter */)
+            if (decorated.kind === 171 /* SyntaxKind.Parameter */)
                 return isUsedInFunctionOrInstanceProperty(c, decorated.parent.parent, declaration, declContainer);
-            if (decorated.kind === 175 /* SyntaxKind.MethodDeclaration */)
+            if (decorated.kind === 176 /* SyntaxKind.MethodDeclaration */)
                 return isUsedInFunctionOrInstanceProperty(c, decorated.parent, declaration, declContainer);
         }
     }
@@ -305,15 +305,15 @@ function isUsedInFunctionOrInstanceProperty(c, usage, declaration, declContainer
 function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage, declContainer) {
     const grandparent = declaration.parent.parent;
     switch (grandparent.kind) {
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 249 /* SyntaxKind.ForStatement */:
-        case 251 /* SyntaxKind.ForOfStatement */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             // The use is within the declaration: its initializer or a binding element.
             if (isSameScopeDescendentOf(usage, declaration, declContainer))
                 return true;
     }
     // In `for (... in/of expr)`, the use is within the expression.
-    return ((grandparent.kind === 250 /* SyntaxKind.ForInStatement */ || grandparent.kind === 251 /* SyntaxKind.ForOfStatement */) &&
+    return ((grandparent.kind === 251 /* SyntaxKind.ForInStatement */ || grandparent.kind === 252 /* SyntaxKind.ForOfStatement */) &&
         isSameScopeDescendentOf(usage, getExpression(grandparent), declContainer));
 }
 /** Whether `initial` is within `parent` without crossing `stopAt` or a function that isn't an IIFE. */
@@ -337,19 +337,19 @@ function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, st
         return false;
     for (let node = usage; node !== undefined && node !== declaration; node = node.parent) {
         switch (node.kind) {
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 return false;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 // Even when stopping at any property declaration, it must be in the same class.
                 return (stopAtAnyPropertyDeclaration &&
-                    ((declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */ && node.parent === declaration.parent) ||
+                    ((declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */ && node.parent === declaration.parent) ||
                         (isParameterPropertyDeclaration(declaration, declaration.parent) &&
                             node.parent === declaration.parent.parent)));
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 switch (node.parent.kind) {
-                    case 175 /* SyntaxKind.MethodDeclaration */:
-                    case 178 /* SyntaxKind.GetAccessor */:
-                    case 179 /* SyntaxKind.SetAccessor */:
+                    case 176 /* SyntaxKind.MethodDeclaration */:
+                    case 179 /* SyntaxKind.GetAccessor */:
+                    case 180 /* SyntaxKind.SetAccessor */:
                         return false;
                 }
         }