tsc-ts 0.0.10 → 0.1.0

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

@@ -32,7 +32,7 @@ export function checkIfStatement(c, node) {
     const t = checkTruthinessExpression(c, s.expression, 0 /* CheckMode.Normal */);
     checkTestingKnownTruthyType(c, s.expression, t, s.thenStatement);
     checkSourceElement(c, s.thenStatement);
-    if (s.thenStatement.kind === 243 /* SyntaxKind.EmptyStatement */)
+    if (s.thenStatement.kind === 244 /* SyntaxKind.EmptyStatement */)
         c.error(s.thenStatement, 249 /* Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement */);
     checkSourceElement(c, s.elseStatement);
 }
@@ -50,7 +50,7 @@ export function checkForStatement(c, node) {
     const s = node;
     const initializer = s.initializer;
     if (initializer !== undefined) {
-        if (initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+        if (initializer.kind === 263 /* SyntaxKind.VariableDeclarationList */)
             checkVariableDeclarationList(c, initializer);
         else
             checkExpression(c, initializer);
@@ -67,10 +67,10 @@ export function checkForInStatement(c, node) {
     const rightType = hasTypeFacts(c, expressionType, 50331648 /* TypeFacts.IsUndefinedOrNull */)
         ? getNonNullableType(c, expressionType)
         : expressionType;
-    if (s.initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+    if (s.initializer.kind === 263 /* SyntaxKind.VariableDeclarationList */) {
         const declarations = s.initializer.declarations.nodes;
         if (declarations.length !== 0 && isBindingPattern(getName(declarations[0])))
-            c.error(getName(declarations[0]), 651 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
+            c.error(getName(declarations[0]), 658 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
         for (const d of declarations)
             checkVariableLikeDeclaration(c, d);
     }
@@ -78,16 +78,16 @@ export function checkForInStatement(c, node) {
         // The variable must be a reference that the keys of the object, as strings, are assignable to.
         const varExpr = s.initializer;
         const leftType = checkExpression(c, varExpr);
-        if (varExpr.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
-            c.error(varExpr, 651 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
+        if (varExpr.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
+            c.error(varExpr, 658 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern */);
         else if (!isTypeAssignableTo(c, getIndexTypeOrString(c, rightType), leftType))
-            c.error(varExpr, 576 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any */);
+            c.error(varExpr, 583 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any */);
         else
-            checkReferenceExpression(c, varExpr, 577 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access */, 912 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access */);
+            checkReferenceExpression(c, varExpr, 584 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access */, 919 /* Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access */);
     }
     if ((rightType.flags & 262144 /* TypeFlags.Never */) !== 0 ||
         !isTypeAssignableToKind(c, rightType, 131072 /* TypeFlags.NonPrimitive */ | 117964800 /* TypeFlags.InstantiableNonPrimitive */, false))
-        c.error(s.expression, 578 /* Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0 */, typeToString(c, rightType));
+        c.error(s.expression, 585 /* Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0 */, typeToString(c, rightType));
     checkSourceElement(c, s.statement);
 }
 function getIndexTypeOrString(c, t) {
@@ -99,25 +99,25 @@ export function checkForOfStatement(c, node) {
     // for await..of in an async function before ES2018 uses __asyncValues.
     if (s.awaitModifier !== undefined) {
         const container = getContainingFunctionOrClassStaticBlock(node);
-        if ((container === undefined || container.kind !== 176 /* SyntaxKind.ClassStaticBlockDeclaration */) &&
+        if ((container === undefined || container.kind !== 177 /* SyntaxKind.ClassStaticBlockDeclaration */) &&
             (getFunctionFlags(container) & (4 /* FunctionFlags.Invalid */ | 2 /* FunctionFlags.Async */)) === 2 /* FunctionFlags.Async */ &&
             c.languageVersion < ScriptTarget.ES2018)
             checkExternalEmitHelpers(c, node, 256 /* ExternalEmitHelpers.ForAwaitOfIncludes */);
     }
     // A declaration checks the right side through its type; an expression is checked as a
     // destructuring assignment or a reference the iterated type must be assignable to.
-    if (s.initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+    if (s.initializer.kind === 263 /* SyntaxKind.VariableDeclarationList */) {
         for (const d of s.initializer.declarations.nodes)
             checkVariableLikeDeclaration(c, d);
     }
     else {
         const varExpr = s.initializer;
         const iteratedType = checkRightHandSideOfForOf(c, s);
-        if (varExpr.kind === 210 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+        if (varExpr.kind === 211 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
             checkDestructuringAssignment(c, varExpr, iteratedType, 0 /* CheckMode.Normal */, false);
         else {
             const leftType = checkExpression(c, varExpr);
-            checkReferenceExpression(c, varExpr, 647 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access */, 913 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access */);
+            checkReferenceExpression(c, varExpr, 654 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access */, 920 /* Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access */);
             checkTypeAssignableToAndOptionallyElaborate(c, iteratedType, leftType, varExpr, s.expression);
         }
     }
@@ -131,6 +131,9 @@ export function checkRightHandSideOfForOf(c, statement) {
 }
 export function checkReturnStatement(c, node) {
     const s = node;
+    // The expression is checked also where a return statement is a grammar error.
+    const exprNode = s.expression;
+    const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
     const container = getContainingFunction(node);
     // Returns outside functions and in static blocks are grammar errors.
     if (container === undefined)
@@ -138,43 +141,41 @@ export function checkReturnStatement(c, node) {
     const signature = getSignatureFromDeclaration(c, container);
     const returnType = getReturnTypeOfSignature(c, signature);
     const functionFlags = getFunctionFlags(container);
-    const exprNode = s.expression;
     if (c.strictNullChecks || exprNode !== undefined || (returnType.flags & 262144 /* TypeFlags.Never */) !== 0) {
-        const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
-        if (container.kind === 179 /* SyntaxKind.SetAccessor */) {
+        if (container.kind === 180 /* SyntaxKind.SetAccessor */) {
             if (exprNode !== undefined)
-                c.error(node, 579 /* Diagnostics.Setters_cannot_return_a_value */);
+                c.error(node, 586 /* Diagnostics.Setters_cannot_return_a_value */);
         }
-        else if (container.kind === 177 /* SyntaxKind.Constructor */) {
+        else if (container.kind === 178 /* SyntaxKind.Constructor */) {
             if (exprNode !== undefined &&
                 !checkTypeAssignableToAndOptionallyElaborate(c, exprType, returnType, node, exprNode))
-                c.error(node, 580 /* Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class */);
+                c.error(node, 587 /* Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class */);
         }
         else if (getReturnTypeFromAnnotation(c, container) !== undefined) {
             const unwrappedReturnType = unwrapReturnType(c, returnType, functionFlags);
             checkReturnExpression(c, container, unwrappedReturnType, node, exprNode, exprType, false);
         }
     }
-    else if (container.kind !== 177 /* SyntaxKind.Constructor */ &&
+    else if (container.kind !== 178 /* SyntaxKind.Constructor */ &&
         c.compilerOptions.noImplicitReturns === true &&
         !isUnwrappedReturnTypeUndefinedVoidOrAny(c, container, returnType))
         // The function has a return type, but this return statement has no expression.
-        c.error(node, 1701 /* Diagnostics.Not_all_code_paths_return_a_value */);
+        c.error(node, 1720 /* Diagnostics.Not_all_code_paths_return_a_value */);
 }
 function getContainingFunction(node) {
     let current = node.parent;
     while (current !== undefined) {
         switch (current.kind) {
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
                 return current;
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-            case 307 /* SyntaxKind.SourceFile */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return undefined;
         }
         current = current.parent;
@@ -197,14 +198,14 @@ export function checkSwitchStatement(c, node) {
         if (c.compilerOptions.noFallthroughCasesInSwitch === true &&
             caseClause.fallthroughFlowNode !== undefined &&
             isReachableFlowNode(c, caseClause.fallthroughFlowNode))
-            c.error(clause, 1700 /* Diagnostics.Fallthrough_case_in_switch */);
+            c.error(clause, 1719 /* Diagnostics.Fallthrough_case_in_switch */);
     }
 }
 export function checkLabeledStatement(c, node) {
     const { label, statement } = node;
     // The binder marks the labels that no break or continue statement references.
     if ((label.flags & 134217728 /* NodeFlags.Unreachable */) !== 0 && c.compilerOptions.allowUnusedLabels !== true)
-        c.addErrorOrSuggestion(c.compilerOptions.allowUnusedLabels === false, createDiagnosticForNode(label, 1699 /* Diagnostics.Unused_label */, []));
+        c.addErrorOrSuggestion(c.compilerOptions.allowUnusedLabels === false, createDiagnosticForNode(label, 1718 /* Diagnostics.Unused_label */, []));
     checkSourceElement(c, statement);
 }
 export function checkThrowStatement(c, node) {

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

@@ -10,34 +10,34 @@ import { getSymbolOfDeclaration } from './checker-symbols.js';
 /** The type of `super` in `super(...)`, `super.x` or `super[x]`, reporting where it can't be used. */
 export function checkSuperExpression(c, node) {
     const parent = node.parent;
-    const isCallExpression = parent.kind === 214 /* SyntaxKind.CallExpression */ && getExpression(parent) === node;
+    const isCallExpression = parent.kind === 215 /* SyntaxKind.CallExpression */ && getExpression(parent) === node;
     const immediateContainer = getSuperContainer(node, true);
     let container = immediateContainer;
     // `super` property accesses in arrow functions belong to the enclosing container.
     if (!isCallExpression)
-        while (container !== undefined && container.kind === 220 /* SyntaxKind.ArrowFunction */)
+        while (container !== undefined && container.kind === 221 /* SyntaxKind.ArrowFunction */)
             container = getSuperContainer(container, true);
     if (container === undefined || !isLegalUsageOfSuperExpression(container, isCallExpression)) {
         if (isInComputedPropertyNameBefore(node, container))
-            c.error(node, 632 /* Diagnostics.X_super_cannot_be_referenced_in_a_computed_property_name */);
+            c.error(node, 639 /* Diagnostics.X_super_cannot_be_referenced_in_a_computed_property_name */);
         else if (isCallExpression)
-            c.error(node, 514 /* Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors */);
+            c.error(node, 521 /* Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors */);
         else if (container === undefined ||
             container.parent === undefined ||
-            !(isClassLike(container.parent) || container.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */))
-            c.error(node, 794 /* Diagnostics.X_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions */);
+            !(isClassLike(container.parent) || container.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */))
+            c.error(node, 801 /* Diagnostics.X_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions */);
         else
-            c.error(node, 515 /* Diagnostics.X_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class */);
+            c.error(node, 522 /* Diagnostics.X_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class */);
         return c.errorType;
     }
-    if (!isCallExpression && immediateContainer.kind === 177 /* SyntaxKind.Constructor */)
-        checkThisBeforeSuper(c, node, container, 1814 /* Diagnostics.X_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class */);
+    if (!isCallExpression && immediateContainer.kind === 178 /* SyntaxKind.Constructor */)
+        checkThisBeforeSuper(c, node, container, 1834 /* Diagnostics.X_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class */);
     // `super` in an object literal is `any`.
-    if (container.parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if (container.parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
         return c.anyType;
     const classLikeDeclaration = container.parent;
     if (getExtendsHeritageClauseElement(classLikeDeclaration) === undefined) {
-        c.error(node, 512 /* Diagnostics.X_super_can_only_be_referenced_in_a_derived_class */);
+        c.error(node, 519 /* Diagnostics.X_super_can_only_be_referenced_in_a_derived_class */);
         return c.errorType;
     }
     if (classDeclarationExtendsNull(c, classLikeDeclaration))
@@ -49,14 +49,14 @@ export function checkSuperExpression(c, node) {
     const baseTypes = getBaseTypes(c, classType);
     if (baseTypes.length === 0)
         return c.errorType;
-    if (container.kind === 177 /* SyntaxKind.Constructor */ && isInConstructorArgumentInitializer(node, container)) {
-        c.error(node, 513 /* Diagnostics.X_super_cannot_be_referenced_in_constructor_arguments */);
+    if (container.kind === 178 /* SyntaxKind.Constructor */ && isInConstructorArgumentInitializer(node, container)) {
+        c.error(node, 520 /* Diagnostics.X_super_cannot_be_referenced_in_constructor_arguments */);
         return c.errorType;
     }
     if (isStatic(container) || isCallExpression) {
         if (!isCallExpression &&
             c.languageVersion <= ScriptTarget.ES2021 &&
-            (container.kind === 173 /* SyntaxKind.PropertyDeclaration */ || container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */))
+            (container.kind === 174 /* SyntaxKind.PropertyDeclaration */ || container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */))
             markSuperPropertyInStaticInitializer(c, node);
         return getBaseConstructorTypeOfClass(c, classType);
     }
@@ -65,22 +65,22 @@ export function checkSuperExpression(c, node) {
 function isLegalUsageOfSuperExpression(container, isCallExpression) {
     // Super calls are only permitted in constructors of derived classes.
     if (isCallExpression)
-        return container.kind === 177 /* SyntaxKind.Constructor */;
+        return container.kind === 178 /* SyntaxKind.Constructor */;
     // Super property accesses are permitted in members directly within a class or object literal.
     const parent = container.parent;
-    if (parent === undefined || !(isClassLike(parent) || parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */))
+    if (parent === undefined || !(isClassLike(parent) || parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */))
         return false;
     switch (container.kind) {
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 174 /* SyntaxKind.MethodSignature */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
             return true;
-        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
             return isStatic(container);
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 177 /* SyntaxKind.Constructor */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 178 /* SyntaxKind.Constructor */:
             return !isStatic(container);
     }
     return false;
@@ -88,7 +88,7 @@ function isLegalUsageOfSuperExpression(container, isCallExpression) {
 /** Whether `node` is in a computed property name below `container`. */
 function isInComputedPropertyNameBefore(node, container) {
     for (let current = node.parent; current !== undefined && current !== container; current = current.parent)
-        if (current.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+        if (current.kind === 169 /* SyntaxKind.ComputedPropertyName */)
             return true;
     return false;
 }
@@ -96,20 +96,20 @@ function isInConstructorArgumentInitializer(node, constructorDeclaration) {
     for (let current = node; current !== undefined; current = current.parent) {
         if (isFunctionLikeDeclarationKind(current.kind))
             return false;
-        if (current.kind === 170 /* SyntaxKind.Parameter */ && current.parent === constructorDeclaration)
+        if (current.kind === 171 /* SyntaxKind.Parameter */ && current.parent === constructorDeclaration)
             return true;
     }
     return false;
 }
 function isFunctionLikeDeclarationKind(kind) {
     switch (kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
-        case 177 /* SyntaxKind.Constructor */:
-        case 178 /* SyntaxKind.GetAccessor */:
-        case 179 /* SyntaxKind.SetAccessor */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
     }
     return false;
@@ -118,28 +118,28 @@ function isFunctionLikeDeclarationKind(kind) {
 export function getSuperContainer(node, stopOnFunctions) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         switch (current.kind) {
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 current = current.parent;
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (stopOnFunctions)
                     return current;
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 177 /* SyntaxKind.Constructor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 return current;
-            case 171 /* SyntaxKind.Decorator */: {
+            case 172 /* SyntaxKind.Decorator */: {
                 // Decorators are applied outside the body of their class or method.
                 const decorated = current.parent;
-                if (decorated.kind === 170 /* SyntaxKind.Parameter */ && isClassElement(decorated.parent))
+                if (decorated.kind === 171 /* SyntaxKind.Parameter */ && isClassElement(decorated.parent))
                     current = decorated.parent;
                 else if (isClassElement(decorated))
                     current = decorated;
@@ -217,21 +217,21 @@ function isPostSuperFlowNode(c, start, noCacheCheckIn) {
 }
 /** Reports `this` in a static property initializer of a class with legacy decorators. */
 export function checkThisInStaticClassFieldInitializerInDecoratedClass(c, thisExpression, container) {
-    if (container.kind !== 173 /* SyntaxKind.PropertyDeclaration */ || !isStatic(container) || !c.legacyDecorators)
+    if (container.kind !== 174 /* SyntaxKind.PropertyDeclaration */ || !isStatic(container) || !c.legacyDecorators)
         return;
     const initializer = getInitializer(container);
     if (initializer !== undefined &&
         initializer.pos <= thisExpression.pos &&
         thisExpression.pos <= initializer.end &&
         hasDecoratorModifier(container.parent))
-        c.error(thisExpression, 947 /* Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class */);
+        c.error(thisExpression, 954 /* Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class */);
 }
 function hasDecoratorModifier(node) {
     const modifiers = getModifiersOf(node);
     if (modifiers === undefined)
         return false;
     for (const modifier of modifiers)
-        if (modifier.kind === 171 /* SyntaxKind.Decorator */)
+        if (modifier.kind === 172 /* SyntaxKind.Decorator */)
             return true;
     return false;
 }