tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/checker-declared-types.js

@@ -3,11 +3,12 @@
 import { sideOf } from './side-state.js';
 import { getInferredTypeParameterConstraint } from './checker-inference.js';
 import { getExpression, getInitializer, getLocals, getName, getText, getType, getTypeArguments as getTypeArgumentNodes, getTypeParameters as getTypeParameterNodes, getHeritageClauses, } from './ast.js';
-import { getSourceFileOfNode, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
+import { getSourceFileOfNode, hasDynamicName, isEnumConst, isObjectLiteralMethod } from './binder-utilities.js';
+import { getHeritageClauseElementName } from './ast-utilities.js';
 import { createDiagnosticForNode } from './checker.js';
 import { elaborateNeverIntersection } from './checker-property-access.js';
 import { TypeAlias, emptyTypes, newTypeMapper, ReferenceCache, } from './checker-types.js';
-import { createArrayTypeEx, getFreshTypeOfLiteralType, getNumberEnumLiteralType, getStringEnumLiteralType, getTargetType, getTypeArguments, getUnionType, getUnionTypeEx, isErrorType, newObjectType, typeListKey, typesOf, typeListHash, } from './checker-type-factory.js';
+import { createArrayTypeEx, getFreshTypeOfLiteralType, getNumberEnumLiteralType, getStringEnumLiteralType, getTargetType, getTypeArguments, getUnionType, getUnionTypeEx, isErrorType, newObjectType, typeListKey, typesOf, typeListHash, compareTypes, } from './checker-type-factory.js';
 import { getFirstIdentifier, getMergedSymbol, getParentOfSymbol, getSymbolOfDeclaration, popTypeResolution, pushTypeResolution, resolveEntityName, } from './checker-symbols.js';
 import { getTypeFromTypeNode, getTypeFromClassOrInterfaceReference, isTypeAlias } from './checker-type-nodes.js';
 import { instantiateType } from './instantiation.js';
@@ -84,14 +85,14 @@ export function getDeclaredTypeOfClassOrInterface(c, symbol) {
 }
 function isThislessInterface(c, symbol) {
     for (const declaration of getDeclarations(symbol)) {
-        if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+        if (declaration.kind !== 266 /* SyntaxKind.InterfaceDeclaration */)
             continue;
         if ((declaration.flags & 128 /* NodeFlags.ContainsThis */) !== 0)
             return false;
         for (const node of getExtendsHeritageClauseElements(declaration)) {
-            const expression = getExpression(node);
-            if (isEntityNameExpression(expression)) {
-                const baseSymbol = resolveEntityName(c, expression, 788968 /* SymbolFlags.Type */, true, false, undefined);
+            const name = getHeritageClauseElementName(node);
+            if (name.kind === 168 /* SyntaxKind.QualifiedName */ || isEntityNameExpression(name)) {
+                const baseSymbol = resolveEntityName(c, name, 788968 /* SymbolFlags.Type */, true, false, undefined);
                 if (baseSymbol === undefined ||
                     (baseSymbol.flags & 64 /* SymbolFlags.Interface */) === 0 ||
                     getDeclaredTypeOfClassOrInterface(c, baseSymbol).thisType !== undefined)
@@ -104,7 +105,7 @@ function isThislessInterface(c, symbol) {
 export function isEntityNameExpression(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = getName(node);
         return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(getExpression(node));
     }
@@ -129,7 +130,7 @@ export function getExtendsHeritageClauseElement(node) {
 }
 export function getClassLikeDeclarationOfSymbol(symbol) {
     for (const d of getDeclarations(symbol))
-        if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 232 /* SyntaxKind.ClassExpression */)
+        if (d.kind === 265 /* SyntaxKind.ClassDeclaration */ || d.kind === 233 /* SyntaxKind.ClassExpression */)
             return d;
     return undefined;
 }
@@ -138,14 +139,14 @@ function getOuterTypeParametersOfClassOrInterface(c, symbol) {
     if ((symbol.flags & (32 /* SymbolFlags.Class */ | 16 /* SymbolFlags.Function */)) === 0) {
         declaration = undefined;
         for (const d of getDeclarations(symbol)) {
-            if (d.kind === 265 /* SyntaxKind.InterfaceDeclaration */) {
+            if (d.kind === 266 /* SyntaxKind.InterfaceDeclaration */) {
                 declaration = d;
                 break;
             }
-            if (d.kind === 261 /* SyntaxKind.VariableDeclaration */) {
+            if (d.kind === 262 /* SyntaxKind.VariableDeclaration */) {
                 const initializer = getInitializer(d);
                 if (initializer !== undefined &&
-                    (initializer.kind === 219 /* SyntaxKind.FunctionExpression */ || initializer.kind === 220 /* SyntaxKind.ArrowFunction */)) {
+                    (initializer.kind === 220 /* SyntaxKind.FunctionExpression */ || initializer.kind === 221 /* SyntaxKind.ArrowFunction */)) {
                     declaration = d;
                     break;
                 }
@@ -161,26 +162,26 @@ export function getOuterTypeParameters(c, node, includeThisTypes) {
     for (let current = node.parent; current !== undefined; current = current.parent) {
         const kind = current.kind;
         switch (kind) {
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 180 /* SyntaxKind.CallSignature */:
-            case 181 /* SyntaxKind.ConstructSignature */:
-            case 174 /* SyntaxKind.MethodSignature */:
-            case 185 /* SyntaxKind.FunctionType */:
-            case 186 /* SyntaxKind.ConstructorType */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 220 /* SyntaxKind.ArrowFunction */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-            case 201 /* SyntaxKind.MappedType */:
-            case 195 /* SyntaxKind.ConditionalType */: {
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 175 /* SyntaxKind.MethodSignature */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 221 /* SyntaxKind.ArrowFunction */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 202 /* SyntaxKind.MappedType */:
+            case 196 /* SyntaxKind.ConditionalType */: {
                 const outer = getOuterTypeParameters(c, current, includeThisTypes);
                 // A contextually typed function has the type parameters of its contextual signature.
-                if ((kind === 219 /* SyntaxKind.FunctionExpression */ ||
-                    kind === 220 /* SyntaxKind.ArrowFunction */ ||
+                if ((kind === 220 /* SyntaxKind.FunctionExpression */ ||
+                    kind === 221 /* SyntaxKind.ArrowFunction */ ||
                     isObjectLiteralMethod(current)) &&
                     isContextSensitive(c, current)) {
                     const signatures = getSignaturesOfType(c, getTypeOfSymbol(c, getSymbolOfDeclaration(c, current)), 0 /* SignatureKind.Call */);
@@ -190,21 +191,21 @@ export function getOuterTypeParameters(c, node, includeThisTypes) {
                         return outer;
                     }
                 }
-                if (kind === 201 /* SyntaxKind.MappedType */) {
+                if (kind === 202 /* SyntaxKind.MappedType */) {
                     const typeParameter = current.typeParameter;
                     outer.push(getDeclaredTypeOfTypeParameter(c, getSymbolOfDeclaration(c, typeParameter)));
                     return outer;
                 }
-                if (kind === 195 /* SyntaxKind.ConditionalType */) {
+                if (kind === 196 /* SyntaxKind.ConditionalType */) {
                     for (const t of getInferTypeParameters(c, current))
                         outer.push(t);
                     return outer;
                 }
                 appendTypeParameters(c, outer, getTypeParameterNodes(current)?.nodes);
                 if (includeThisTypes &&
-                    (kind === 264 /* SyntaxKind.ClassDeclaration */ ||
-                        kind === 232 /* SyntaxKind.ClassExpression */ ||
-                        kind === 265 /* SyntaxKind.InterfaceDeclaration */)) {
+                    (kind === 265 /* SyntaxKind.ClassDeclaration */ ||
+                        kind === 233 /* SyntaxKind.ClassExpression */ ||
+                        kind === 266 /* SyntaxKind.InterfaceDeclaration */)) {
                     const thisType = getDeclaredTypeOfClassOrInterface(c, getSymbolOfDeclaration(c, current)).thisType;
                     if (thisType !== undefined)
                         outer.push(thisType);
@@ -222,6 +223,7 @@ export function getInferTypeParameters(c, node) {
         for (const symbol of locals.values())
             if ((symbol.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0)
                 result.push(getDeclaredTypeOfSymbol(c, symbol));
+    result.sort((t1, t2) => compareTypes(c, t1, t2));
     return result;
 }
 export function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol) {
@@ -229,9 +231,9 @@ export function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, symbol) {
 }
 function appendLocalTypeParameters(c, types, symbol) {
     for (const node of getDeclarations(symbol)) {
-        if (node.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
-            node.kind === 264 /* SyntaxKind.ClassDeclaration */ ||
-            node.kind === 232 /* SyntaxKind.ClassExpression */ ||
+        if (node.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
+            node.kind === 265 /* SyntaxKind.ClassDeclaration */ ||
+            node.kind === 233 /* SyntaxKind.ClassExpression */ ||
             isTypeAlias(node))
             appendTypeParameters(c, types, getTypeParameterNodes(node)?.nodes);
     }
@@ -261,7 +263,7 @@ export function getDeclaredTypeOfTypeAlias(c, symbol) {
         return c.errorType;
     let declaration;
     for (const d of getDeclarations(symbol))
-        if (d.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */) {
+        if (d.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ || d.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */) {
             declaration = d;
             break;
         }
@@ -281,7 +283,7 @@ export function getDeclaredTypeOfTypeAlias(c, symbol) {
     }
     else {
         const errorNode = declaration !== undefined ? (getName(declaration) ?? declaration) : undefined;
-        c.error(errorNode, 622 /* Diagnostics.Type_alias_0_circularly_references_itself */, symbolToString(c, symbol));
+        c.error(errorNode, 629 /* Diagnostics.Type_alias_0_circularly_references_itself */, symbolToString(c, symbol));
         type = c.errorType;
     }
     if (links.declaredType === undefined)
@@ -294,10 +296,10 @@ export function getDeclaredTypeOfEnum(c, symbol) {
         return links.declaredType;
     const memberTypes = [];
     for (const declaration of getDeclarations(symbol)) {
-        if (declaration.kind !== 267 /* SyntaxKind.EnumDeclaration */)
+        if (declaration.kind !== 268 /* SyntaxKind.EnumDeclaration */)
             continue;
         for (const member of declaration.members.nodes) {
-            if (!hasBindableName(member))
+            if (hasDynamicName(member))
                 continue;
             const memberSymbol = getSymbolOfDeclaration(c, member);
             computeEnumMemberValues(c, declaration);
@@ -325,7 +327,7 @@ export function getDeclaredTypeOfEnum(c, symbol) {
 }
 export function hasBindableName(node) {
     const name = getName(node);
-    return name === undefined || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */ || isLiteralComputed(name);
+    return name === undefined || name.kind !== 169 /* SyntaxKind.ComputedPropertyName */ || isLiteralComputed(name);
 }
 function isLiteralComputed(name) {
     const e = getExpression(name);
@@ -374,14 +376,14 @@ export function computeEnumMemberValues(c, node) {
 function computeEnumMemberValue(c, member, hasAuto, autoValue, previous) {
     const links = c.nodeLinks(member);
     const name = getName(member);
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputed(name))
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */ && !isLiteralComputed(name))
         c.error(name, 121 /* Diagnostics.Computed_property_names_are_not_allowed_in_enums */);
     else if (name.kind === 9 /* SyntaxKind.BigIntLiteral */)
-        c.error(name, 620 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
+        c.error(name, 627 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
     else {
-        const text = name.kind === 168 /* SyntaxKind.ComputedPropertyName */ ? getText(getExpression(name)) : getText(name);
+        const text = name.kind === 169 /* SyntaxKind.ComputedPropertyName */ ? getText(getExpression(name)) : getText(name);
         if (isNumericLiteralName(text) && text !== 'Infinity' && text !== '-Infinity' && text !== 'NaN')
-            c.error(name, 620 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
+            c.error(name, 627 /* Diagnostics.An_enum_member_cannot_have_a_numeric_name */);
     }
     const initializer = getInitializer(member);
     if (initializer !== undefined) {
@@ -403,7 +405,7 @@ function computeEnumMemberValue(c, member, hasAuto, autoValue, previous) {
         const previousLinks = c.nodeLinks(previous);
         if (previousLinks.enumValueKind !== 1 /* EvaluatedKind.Number */ ||
             (previousLinks.enumValueFlags & 2 /* EvaluatedFlags.ResolvedOtherFiles */) !== 0)
-            c.error(name, 1871 /* Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled */);
+            c.error(name, 1891 /* Diagnostics.Enum_member_following_a_non_literal_numeric_member_must_have_an_initializer_when_isolatedModules_is_enabled */);
     }
     links.enumValueKind = 1 /* EvaluatedKind.Number */;
     links.enumNumberValue = autoValue;
@@ -419,20 +421,20 @@ function computeConstantEnumMemberValue(c, member, initializer) {
     if (result.kind !== 0 /* EvaluatedKind.None */) {
         if (isConstEnum && result.kind === 1 /* EvaluatedKind.Number */ && !Number.isFinite(result.numberValue))
             c.error(initializer, result.numberValue !== result.numberValue
-                ? 642 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN */
-                : 641 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_a_non_finite_value */);
+                ? 649 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN */
+                : 648 /* Diagnostics.X_const_enum_member_initializer_was_evaluated_to_a_non_finite_value */);
         // A transpiler emits a string member without a reverse mapping only when it sees a string.
         if (c.isolatedModules &&
             result.kind === 2 /* EvaluatedKind.String */ &&
             (result.flags & 1 /* EvaluatedFlags.SyntacticallyString */) === 0)
-            c.error(initializer, 1870 /* Diagnostics.X_0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled */, getText(getName(member.parent)) + '.' + getText(getName(member)));
+            c.error(initializer, 1890 /* Diagnostics.X_0_has_a_string_type_but_must_have_syntactically_recognizable_string_syntax_when_isolatedModules_is_enabled */, getText(getName(member.parent)) + '.' + getText(getName(member)));
     }
     else if (isConstEnum)
-        c.error(initializer, 638 /* Diagnostics.X_const_enum_member_initializers_must_be_constant_expressions */);
+        c.error(initializer, 645 /* Diagnostics.X_const_enum_member_initializers_must_be_constant_expressions */);
     else if ((member.parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         c.error(initializer, 51 /* Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression */);
     else
-        checkTypeAssignableTo(c, checkExpression(c, initializer), c.numberType, initializer, 1850 /* Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values */);
+        checkTypeAssignableTo(c, checkExpression(c, initializer), c.numberType, initializer, 1870 /* Diagnostics.Type_0_is_not_assignable_to_type_1_as_required_for_computed_enum_member_values */);
 }
 export function isNumericLiteralName(name) {
     // A name is numeric when it round-trips through Number.
@@ -456,7 +458,7 @@ export function getBaseTypes(c, t) {
         }
         if (!popTypeResolution(c))
             for (const declaration of getDeclarations(t.symbol))
-                if (declaration.kind === 264 /* SyntaxKind.ClassDeclaration */ || declaration.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
+                if (declaration.kind === 265 /* SyntaxKind.ClassDeclaration */ || declaration.kind === 266 /* SyntaxKind.InterfaceDeclaration */)
                     reportCircularBaseType(c, declaration, t);
         // Circular defaults may leave members partially resolved; reset them.
         membersHolder(c, t).objectFlags &= ~2097152 /* ObjectFlags.MembersResolved */;
@@ -492,7 +494,7 @@ function resolveBaseTypesOfClass(c, t) {
     else {
         const constructors = getInstantiatedConstructorsForTypeArguments(c, baseConstructorType, getTypeArgumentNodes(baseTypeNode)?.nodes, baseTypeNode);
         if (constructors.length === 0) {
-            c.error(getExpression(baseTypeNode), 668 /* Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments */);
+            c.error(getExpression(baseTypeNode), 675 /* Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments */);
             return;
         }
         baseType = getReturnTypeOfSignature(c, constructors[0]);
@@ -502,12 +504,12 @@ function resolveBaseTypesOfClass(c, t) {
     const reducedBaseType = getReducedType(c, baseType);
     if (!isValidBaseType(c, reducedBaseType)) {
         const errorNode = getExpression(baseTypeNode);
-        const diagnostic = createDiagnosticForNode(errorNode, 669 /* Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members */, [typeToString(c, reducedBaseType)]);
+        const diagnostic = createDiagnosticForNode(errorNode, 676 /* Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members */, [typeToString(c, reducedBaseType)]);
         c.addDiagnostic(diagnostic.addMessageChain(elaborateNeverIntersection(c, undefined, errorNode, baseType)));
         return;
     }
     if (t.id === reducedBaseType.id || hasBaseType(c, reducedBaseType, t)) {
-        c.error(t.symbol.valueDeclaration, 488 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t));
+        c.error(t.symbol.valueDeclaration, 495 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t));
         return;
     }
     sideOf(c, t).resolvedBaseTypes = [reducedBaseType];
@@ -530,7 +532,7 @@ function isInJS(node) {
 }
 function resolveBaseTypesOfInterface(c, t) {
     for (const declaration of getDeclarations(t.symbol)) {
-        if (declaration.kind !== 265 /* SyntaxKind.InterfaceDeclaration */)
+        if (declaration.kind !== 266 /* SyntaxKind.InterfaceDeclaration */)
             continue;
         for (const node of getExtendsHeritageClauseElements(declaration)) {
             const baseType = getReducedType(c, getTypeFromTypeNode(c, node));
@@ -548,7 +550,7 @@ function resolveBaseTypesOfInterface(c, t) {
                     reportCircularBaseType(c, declaration, t);
             }
             else
-                c.error(node, 490 /* Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members */);
+                c.error(node, 497 /* Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members */);
         }
     }
 }
@@ -561,7 +563,7 @@ function areAllOuterTypeParametersApplied(c, t) {
     return outer[last].symbol !== getTypeArguments(c, t)[last].symbol;
 }
 function reportCircularBaseType(c, node, t) {
-    c.error(node, 488 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t, undefined, 1 << 1));
+    c.error(node, 495 /* Diagnostics.Type_0_recursively_references_itself_as_a_base_type */, typeToString(c, t, undefined, 1 << 1));
 }
 export function isValidBaseType(c, t) {
     if ((t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0) {
@@ -613,7 +615,7 @@ export function getBaseConstructorTypeOfClass(c, t) {
     if ((baseConstructorType.flags & (1048576 /* TypeFlags.Object */ | 268435456 /* TypeFlags.Intersection */)) !== 0)
         resolveStructuredTypeMembers(c, baseConstructorType);
     if (!popTypeResolution(c)) {
-        c.error(t.symbol.valueDeclaration, 666 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_base_expression */, symbolToString(c, t.symbol));
+        c.error(t.symbol.valueDeclaration, 673 /* Diagnostics.X_0_is_referenced_directly_or_indirectly_in_its_own_base_expression */, symbolToString(c, t.symbol));
         if (side.resolvedBaseConstructorType === undefined)
             side.resolvedBaseConstructorType = c.errorType;
         return side.resolvedBaseConstructorType;
@@ -621,7 +623,7 @@ export function getBaseConstructorTypeOfClass(c, t) {
     if ((baseConstructorType.flags & 1 /* TypeFlags.Any */) === 0 &&
         baseConstructorType !== c.nullWideningType &&
         !isConstructorType(c, baseConstructorType)) {
-        c.error(getExpression(baseTypeNode), 667 /* Diagnostics.Type_0_is_not_a_constructor_function_type */, typeToString(c, baseConstructorType));
+        c.error(getExpression(baseTypeNode), 674 /* Diagnostics.Type_0_is_not_a_constructor_function_type */, typeToString(c, baseConstructorType));
         if (side.resolvedBaseConstructorType === undefined)
             side.resolvedBaseConstructorType = c.errorType;
         return side.resolvedBaseConstructorType;
@@ -668,7 +670,7 @@ export function hasNonCircularBaseConstraint(c, t) {
 export function getConstraintDeclaration(t) {
     if (t.symbol !== undefined)
         for (const d of getDeclarations(t.symbol))
-            if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
+            if (d.kind === 170 /* SyntaxKind.TypeParameter */) {
                 const constraint = d.constraint;
                 if (constraint !== undefined)
                     return constraint;
@@ -697,7 +699,7 @@ export function getConstraintFromTypeParameter(c, t) {
                 if ((constraint.flags & 1 /* TypeFlags.Any */) !== 0 && !isErrorType(c, constraint))
                     // Mapped type keys use string | number | symbol; others unknown.
                     constraint =
-                        declaration.parent.parent.kind === 201 /* SyntaxKind.MappedType */ ? c.stringNumberSymbolType : c.unknownType;
+                        declaration.parent.parent.kind === 202 /* SyntaxKind.MappedType */ ? c.stringNumberSymbolType : c.unknownType;
             }
             else
                 constraint = getInferredTypeParameterConstraint(c, t);
@@ -725,7 +727,7 @@ export function getResolvedTypeParameterDefault(c, t) {
             let defaultType = c.noConstraintType;
             if (t.symbol !== undefined)
                 for (const d of getDeclarations(t.symbol))
-                    if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
+                    if (d.kind === 170 /* SyntaxKind.TypeParameter */) {
                         const node = d.defaultType;
                         if (node !== undefined) {
                             defaultType = getTypeFromTypeNode(c, node);
@@ -757,7 +759,7 @@ function hasTypeParameterDefault(t) {
         return false;
     for (let i = 0; i < declarationCount(symbol); i++) {
         const d = declarationAt(symbol, i);
-        if (d.kind === 169 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
+        if (d.kind === 170 /* SyntaxKind.TypeParameter */ && d.defaultType !== undefined)
             return true;
     }
     return false;