tsc-ts 0.0.9 → 0.1.0

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

@@ -5,6 +5,7 @@ import { findConstructorDeclaration, getNameOfDeclaration, getDeclarationOfKind,
 import { chainDiagnostic } from './diagnostics.js';
 import { getUseDefineForClassFields } from './options.js';
 import { createDiagnosticForNode } from './checker.js';
+import { checkJSDocAugmentsTagMatchesExtends } from './checker-jsdoc.js';
 import { emptyIndexInfos, emptySignatures, newTypeMapper, } from './checker-types.js';
 import { createAnonymousType, getIntersectionType, isErrorType, typesOf } from './checker-type-factory.js';
 import { getBaseConstructorTypeOfClass, getBaseTypes, getClassLikeDeclarationOfSymbol, getConstraintOfTypeParameter, getDeclaredTypeOfSymbol, getDefaultFromTypeParameter, getExtendsHeritageClauseElement, getExtendsHeritageClauseElements, getMinTypeArgumentCount, isEntityNameExpression, isMixinConstructorType, isValidBaseType, getDeclaredTypeOfTypeParameter, fillMissingTypeArguments, getInstantiatedConstructorsForTypeArguments, } from './checker-declared-types.js';
@@ -23,7 +24,7 @@ import { hasDynamicName, hasLateBindableName, isBindingPattern } from './checker
 import { checkTypeAssignableTo, checkTypeRelatedTo, compareProperties, isTypeAssignableTo, isTypeIdenticalTo, } from './relations.js';
 import { symbolToString, typeToString } from './type-printer.js';
 import { checkFunctionOrConstructorSymbol } from './checker-overloads.js';
-import { isPropertyInitializedInConstructor } from './checker-classes.js';
+import { getConstructorAccessibilityError, isPropertyInitializedInConstructor } from './checker-classes.js';
 import { declarationCount, getDeclarations, } from './symbol.js';
 // ---- Classes
 /** Checks a class's merged declarations, members, base class, implemented types and index signatures. */
@@ -49,19 +50,22 @@ export function checkClassHeritage(c, node) {
     }
     checkMembersForOverrideModifier(c, node, classType, typeWithThis, staticType);
     for (const typeRefNode of getImplementsHeritageClauseElements(node)) {
-        const expr = getExpression(typeRefNode);
-        if (!isEntityNameExpression(expr) || isOptionalChain(expr))
-            c.error(expr, 660 /* Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments */);
+        // The parser makes an entity name element a type reference; anything else stays an expression.
+        if (typeRefNode.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */) {
+            const expr = getExpression(typeRefNode);
+            if (!isEntityNameExpression(expr) || isOptionalChain(expr))
+                c.error(expr, 667 /* Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments */);
+        }
         const t = getReducedType(c, getTypeFromTypeNode(c, typeRefNode));
         if (isErrorType(c, t))
             continue;
         if (!isValidBaseType(c, t)) {
-            c.error(typeRefNode, 592 /* Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members */);
+            c.error(typeRefNode, 599 /* Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members */);
             continue;
         }
         const message = t.symbol !== undefined && (t.symbol.flags & 32 /* SymbolFlags.Class */) !== 0
-            ? 852 /* Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass */
-            : 591 /* Diagnostics.Class_0_incorrectly_implements_interface_1 */;
+            ? 859 /* Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass */
+            : 598 /* Diagnostics.Class_0_incorrectly_implements_interface_1 */;
         const baseWithThis = getTypeWithThisArgument(c, t, classType.thisType, false);
         if (!checkTypeAssignableTo(c, typeWithThis, baseWithThis, undefined, undefined))
             issueMemberSpecificError(c, node, typeWithThis, baseWithThis, message);
@@ -72,8 +76,9 @@ export function checkClassHeritage(c, node) {
 }
 function checkBaseClass(c, node, classType, typeWithThis, staticType, baseType) {
     const baseConstructorType = getBaseConstructorTypeOfClass(c, classType);
-    const staticBaseType = getApparentType(c, baseConstructorType);
     const baseTypeNode = getExtendsHeritageClauseElement(node);
+    checkJSDocAugmentsTagMatchesExtends(c, node, baseTypeNode, baseType);
+    const staticBaseType = getApparentType(c, baseConstructorType);
     checkBaseTypeAccessibility(c, staticBaseType, baseTypeNode);
     const typeArgumentNodes = getTypeArguments(baseTypeNode);
     if (typeArgumentNodes !== undefined && typeArgumentNodes.nodes.length !== 0) {
@@ -86,16 +91,16 @@ function checkBaseClass(c, node, classType, typeWithThis, staticType, baseType)
     const baseWithThis = getTypeWithThisArgument(c, baseType, classType.thisType, false);
     const errorNode = getName(node) ?? node;
     if (!checkTypeAssignableTo(c, typeWithThis, baseWithThis, undefined, undefined))
-        issueMemberSpecificError(c, node, typeWithThis, baseWithThis, 586 /* Diagnostics.Class_0_incorrectly_extends_base_class_1 */);
+        issueMemberSpecificError(c, node, typeWithThis, baseWithThis, 593 /* Diagnostics.Class_0_incorrectly_extends_base_class_1 */);
     // The static side is checked only when the instance side is assignable.
     else
-        checkTypeAssignableTo(c, staticType, getTypeWithoutSignatures(c, staticBaseType), errorNode, 588 /* Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1 */);
+        checkTypeAssignableTo(c, staticType, getTypeWithoutSignatures(c, staticBaseType), errorNode, 595 /* Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1 */);
     if ((baseConstructorType.flags & 34078720 /* TypeFlags.TypeVariable */) !== 0) {
         if (!isMixinConstructorType(c, staticType))
-            c.error(errorNode, 701 /* Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any */);
+            c.error(errorNode, 708 /* Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any */);
         else if (hasAbstractSignature(getSignaturesOfType(c, baseConstructorType, 1 /* SignatureKind.Construct */)) &&
             !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
-            c.error(errorNode, 929 /* Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract */);
+            c.error(errorNode, 936 /* Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract */);
     }
     // A class-like constructor function that isn't a class must return the same type from every
     // instantiated construct signature.
@@ -104,7 +109,7 @@ function checkBaseClass(c, node, classType, typeWithThis, staticType, baseType)
         const constructors = getInstantiatedConstructorsForTypeArguments(c, staticBaseType, getTypeArguments(baseTypeNode)?.nodes, baseTypeNode);
         for (const sig of constructors) {
             if (!isTypeIdenticalTo(c, getReturnTypeOfSignature(c, sig), baseType)) {
-                c.error(getExpression(baseTypeNode), 670 /* Diagnostics.Base_constructors_must_all_have_the_same_return_type */);
+                c.error(getExpression(baseTypeNode), 677 /* Diagnostics.Base_constructors_must_all_have_the_same_return_type */);
                 break;
             }
         }
@@ -147,7 +152,7 @@ export function checkTypeArgumentConstraints(c, node, typeParameters) {
         }
         result =
             result &&
-                checkTypeAssignableTo(c, typeArguments[i], instantiateType(c, constraint, mapper), i < typeArgumentNodes.length ? typeArgumentNodes[i] : undefined, 520 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */);
+                checkTypeAssignableTo(c, typeArguments[i], instantiateType(c, constraint, mapper), i < typeArgumentNodes.length ? typeArgumentNodes[i] : undefined, 527 /* Diagnostics.Type_0_does_not_satisfy_the_constraint_1 */);
     }
     return result;
 }
@@ -169,20 +174,9 @@ function getImplementsHeritageClauseElements(node) {
 }
 function checkBaseTypeAccessibility(c, t, node) {
     const signatures = getSignaturesOfType(c, t, 1 /* SignatureKind.Construct */);
-    if (signatures.length === 0)
-        return;
-    const declaration = signatures[0].declaration;
-    if (declaration === undefined || !hasSyntacticModifier(declaration, 2 /* ModifierFlags.Private */))
-        return;
-    const typeClassDeclaration = t.symbol !== undefined ? getClassLikeDeclarationOfSymbol(t.symbol) : undefined;
-    if (!isNodeWithinClass(node, typeClassDeclaration))
-        c.error(node, 809 /* Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private */, getFullyQualifiedName(c, t.symbol));
-}
-function isNodeWithinClass(node, classDeclaration) {
-    for (let n = node; n !== undefined; n = n.parent)
-        if (n === classDeclaration)
-            return true;
-    return false;
+    const error = getConstructorAccessibilityError(c, node, signatures, 2 /* ModifierFlags.Private */);
+    if (error !== undefined)
+        c.error(node, 816 /* Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private */, getFullyQualifiedName(c, error.declaringClass.symbol));
 }
 /** Reports each incompatible member, or the class as a whole when no member is to blame. */
 function issueMemberSpecificError(c, node, typeWithThis, baseWithThis, broadMessage) {
@@ -199,7 +193,7 @@ function issueMemberSpecificError(c, node, typeWithThis, baseWithThis, broadMess
             continue;
         const diagnostics = [];
         if (!checkTypeRelatedTo(c, getTypeOfSymbol(c, prop), getTypeOfSymbol(c, baseProp), c.assignableRelation, getName(member) ?? member, undefined, diagnostics)) {
-            c.addDiagnostic(chainDiagnostic(diagnostics[0], 587 /* Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2 */, symbolToString(c, declaredProp), typeToString(c, typeWithThis), typeToString(c, baseWithThis)));
+            c.addDiagnostic(chainDiagnostic(diagnostics[0], 594 /* Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2 */, symbolToString(c, declaredProp), typeToString(c, typeWithThis), typeToString(c, baseWithThis)));
             issuedMemberError = true;
         }
     }
@@ -229,7 +223,7 @@ function checkClassForStaticPropertyNameConflicts(c, node) {
             continue;
         const memberName = getEffectivePropertyName(c, name);
         if (memberName === 'name' || memberName === 'length' || memberName === 'caller' || memberName === 'arguments')
-            c.error(name, 831 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, memberName, symbolToString(c, getSymbolOfDeclaration(c, node)));
+            c.error(name, 838 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, memberName, symbolToString(c, getSymbolOfDeclaration(c, node)));
     }
 }
 /** The property name a name denotes: a literal name, or the literal type of a computed name's expression. */
@@ -240,7 +234,7 @@ function getEffectivePropertyName(c, name) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
             return getText(name);
-        case 168 /* SyntaxKind.ComputedPropertyName */: {
+        case 169 /* SyntaxKind.ComputedPropertyName */: {
             const e = getExpression(name);
             if (e.kind === 10 /* SyntaxKind.StringLiteral */ ||
                 e.kind === 8 /* SyntaxKind.NumericLiteral */ ||
@@ -304,16 +298,16 @@ function checkKindsOfPropertyMemberOverrides(c, t, baseType) {
         const derivedName = getNameOfDeclaration(derived.valueDeclaration) ?? derived.valueDeclaration;
         if (basePropertyFlags !== 0 && derivedPropertyFlags !== 0) {
             // Abstract and interface members, and assignment-declared overrides, may change kind.
-            if ((base.checkFlags & 262144 /* CheckFlags.Mapped */) !== 0 ||
-                (derived.valueDeclaration !== undefined && derived.valueDeclaration.kind === 227 /* SyntaxKind.BinaryExpression */) ||
+            if ((base.checkFlags & 2097152 /* CheckFlags.Mapped */) !== 0 ||
+                (derived.valueDeclaration !== undefined && derived.valueDeclaration.kind === 228 /* SyntaxKind.BinaryExpression */) ||
                 arePropertiesAbstractOrInterface(base, baseDeclarationFlags))
                 continue;
             const overriddenInstanceProperty = basePropertyFlags !== 4 /* SymbolFlags.Property */ && derivedPropertyFlags === 4 /* SymbolFlags.Property */;
             const overriddenInstanceAccessor = basePropertyFlags === 4 /* SymbolFlags.Property */ && derivedPropertyFlags !== 4 /* SymbolFlags.Property */;
             if (overriddenInstanceProperty || overriddenInstanceAccessor)
                 c.error(derivedName, overriddenInstanceProperty
-                    ? 754 /* Diagnostics.X_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property */
-                    : 755 /* Diagnostics.X_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor */, symbolToString(c, base), typeToString(c, baseType), typeToString(c, t));
+                    ? 761 /* Diagnostics.X_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property */
+                    : 762 /* Diagnostics.X_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor */, symbolToString(c, base), typeToString(c, baseType), typeToString(c, t));
             else if (getUseDefineForClassFields(c.compilerOptions))
                 checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarationFlags, derivedDeclarationFlags);
             continue;
@@ -324,14 +318,14 @@ function checkKindsOfPropertyMemberOverrides(c, t, baseType) {
             if (isPrototypeProperty(derived) || (derived.flags & 4 /* SymbolFlags.Property */) !== 0)
                 continue;
             message =
-                593 /* Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor */;
+                600 /* Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor */;
         }
         else if ((base.flags & 98304 /* SymbolFlags.Accessor */) !== 0)
             message =
-                595 /* Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function */;
+                602 /* Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function */;
         else
             message =
-                594 /* Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function */;
+                601 /* Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function */;
         c.error(derivedName, message, typeToString(c, baseType), symbolToString(c, base), typeToString(c, t));
     }
     if (missing !== undefined)
@@ -351,7 +345,7 @@ function isImplementedByOtherBaseType(c, t, baseType, base) {
 function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarationFlags, derivedDeclarationFlags) {
     let uninitialized;
     for (const d of getDeclarations(derived)) {
-        if (d.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getInitializer(d) === undefined) {
+        if (d.kind === 174 /* SyntaxKind.PropertyDeclaration */ && getInitializer(d) === undefined) {
             uninitialized = d;
             break;
         }
@@ -372,16 +366,16 @@ function checkPropertyOverwritesBase(c, t, baseType, base, derived, baseDeclarat
         propName.kind !== 79 /* SyntaxKind.Identifier */ ||
         !c.strictNullChecks ||
         !isPropertyInitializedInConstructor(c, propName, t, constructor))
-        c.error(getNameOfDeclaration(derived.valueDeclaration) ?? derived.valueDeclaration, 756 /* Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration */, symbolToString(c, base), typeToString(c, baseType));
+        c.error(getNameOfDeclaration(derived.valueDeclaration) ?? derived.valueDeclaration, 763 /* Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration */, symbolToString(c, base), typeToString(c, baseType));
 }
 function reportMissingAbstractMembers(c, node, missing) {
-    const isExpression = node !== undefined && node.kind === 232 /* SyntaxKind.ClassExpression */;
+    const isExpression = node !== undefined && node.kind === 233 /* SyntaxKind.ClassExpression */;
     const properties = missing.properties;
     if (properties.length === 1) {
         if (isExpression)
-            c.error(node, 787 /* Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1 */, properties[0], missing.baseTypeName);
+            c.error(node, 794 /* Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1 */, properties[0], missing.baseTypeName);
         else
-            c.error(node, 675 /* Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2 */, missing.typeName, properties[0], missing.baseTypeName);
+            c.error(node, 682 /* Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2 */, missing.typeName, properties[0], missing.baseTypeName);
         return;
     }
     if (properties.length > 5) {
@@ -391,16 +385,16 @@ function reportMissingAbstractMembers(c, node, missing) {
             .join(', ');
         const remaining = String(properties.length - 4);
         if (isExpression)
-            c.error(node, 784 /* Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more */, missing.baseTypeName, listed, remaining);
+            c.error(node, 791 /* Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1_and_2_more */, missing.baseTypeName, listed, remaining);
         else
-            c.error(node, 789 /* Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more */, missing.typeName, missing.baseTypeName, listed, remaining);
+            c.error(node, 796 /* Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2_and_3_more */, missing.typeName, missing.baseTypeName, listed, remaining);
         return;
     }
     const listed = properties.map((p) => "'" + p + "'").join(', ');
     if (isExpression)
-        c.error(node, 790 /* Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1 */, missing.baseTypeName, listed);
+        c.error(node, 797 /* Diagnostics.Non_abstract_class_expression_is_missing_implementations_for_the_following_members_of_0_Colon_1 */, missing.baseTypeName, listed);
     else
-        c.error(node, 788 /* Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2 */, missing.typeName, missing.baseTypeName, listed);
+        c.error(node, 795 /* Diagnostics.Non_abstract_class_0_is_missing_implementations_for_the_following_members_of_1_Colon_2 */, missing.typeName, missing.baseTypeName, listed);
 }
 function arePropertiesAbstractOrInterface(base, baseDeclarationFlags) {
     // Synthetic (intersection) properties need any declaration to qualify; others need all.
@@ -416,9 +410,9 @@ function arePropertiesAbstractOrInterface(base, baseDeclarationFlags) {
     return true;
 }
 function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) {
-    return (declaration.parent.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
+    return (declaration.parent.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
         ((baseDeclarationFlags & 64 /* ModifierFlags.Abstract */) !== 0 &&
-            (declaration.kind !== 173 /* SyntaxKind.PropertyDeclaration */ || getInitializer(declaration) === undefined)));
+            (declaration.kind !== 174 /* SyntaxKind.PropertyDeclaration */ || getInitializer(declaration) === undefined)));
 }
 // ---- `override`
 function checkMembersForOverrideModifier(c, node, t, typeWithThis, staticType) {
@@ -432,7 +426,7 @@ function checkMembersForOverrideModifier(c, node, t, typeWithThis, staticType) {
     for (const member of getMembers(node).nodes) {
         if (hasSyntacticModifier(member, 128 /* ModifierFlags.Ambient */))
             continue;
-        if (member.kind === 177 /* SyntaxKind.Constructor */) {
+        if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes)
                 if (isParameterPropertyDeclaration(param, member))
                     checkMemberForOverrideModifier(c, node, staticType, baseStaticType, baseWithThis, t, typeWithThis, param);
@@ -447,20 +441,20 @@ function checkMemberForOverrideModifier(c, node, staticType, baseStaticType, bas
     if (baseWithThis === undefined) {
         if (memberHasOverrideModifier)
             c.error(member, isJs
-                ? 1107 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class */
-                : 1098 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class */, typeToString(c, t));
+                ? 1114 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class */
+                : 1105 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class */, typeToString(c, t));
         return;
     }
     const memberSymbol = getSymbolOfDeclaration(c, member);
     if (memberHasOverrideModifier &&
         memberSymbol !== undefined &&
         memberSymbol.valueDeclaration !== undefined &&
-        member.kind !== 170 /* SyntaxKind.Parameter */ &&
+        member.kind !== 171 /* SyntaxKind.Parameter */ &&
         hasDynamicName(member) &&
         !hasLateBindableName(c, member)) {
         c.error(member, isJs
-            ? 1114 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic */
-            : 1113 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic */);
+            ? 1121 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_name_is_dynamic */
+            : 1120 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_its_name_is_dynamic */);
         return;
     }
     if (!memberHasOverrideModifier && c.compilerOptions.noImplicitOverride !== true)
@@ -477,12 +471,12 @@ function checkMemberForOverrideModifier(c, node, staticType, baseStaticType, bas
         const suggestion = getSpellingSuggestionForName(c, memberSymbol.name, getPropertiesOfType(c, baseType), 106500 /* SymbolFlags.ClassMember */);
         if (suggestion !== undefined)
             c.error(member, isJs
-                ? 1109 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 */
-                : 1103 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 */, typeToString(c, baseWithThis), symbolToString(c, suggestion));
+                ? 1116 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 */
+                : 1110 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 */, typeToString(c, baseWithThis), symbolToString(c, suggestion));
         else
             c.error(member, isJs
-                ? 1108 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 */
-                : 1099 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0 */, typeToString(c, baseWithThis));
+                ? 1115 /* Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 */
+                : 1106 /* Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0 */, typeToString(c, baseWithThis));
         return;
     }
     if (baseProp === undefined ||
@@ -500,19 +494,19 @@ function checkMemberForOverrideModifier(c, node, staticType, baseStaticType, bas
     }
     if (!baseHasAbstract) {
         let message;
-        if (member.kind === 170 /* SyntaxKind.Parameter */)
+        if (member.kind === 171 /* SyntaxKind.Parameter */)
             message = isJs
-                ? 1106 /* Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 */
-                : 1101 /* Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 */;
+                ? 1113 /* Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 */
+                : 1108 /* Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 */;
         else
             message = isJs
-                ? 1105 /* Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 */
-                : 1100 /* Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0 */;
+                ? 1112 /* Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 */
+                : 1107 /* Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0 */;
         c.error(member, message, typeToString(c, baseWithThis));
         return;
     }
     if (hasSyntacticModifier(member, 64 /* ModifierFlags.Abstract */))
-        c.error(member, 1102 /* Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0 */, typeToString(c, baseWithThis));
+        c.error(member, 1109 /* Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0 */, typeToString(c, baseWithThis));
 }
 // ---- Interfaces
 /** Checks an interface's merged declarations, base interfaces and index signatures, once per symbol. */
@@ -524,22 +518,26 @@ export function checkInterfaceHeritage(c, node) {
     const links = c.symbolLinks(symbol);
     if (!links.interfaceChecked) {
         links.interfaceChecked = true;
+        // Reported on the first interface declaration, whichever declaration is checked first.
+        const firstName = getName(getDeclarationOfKind(symbol, 266 /* SyntaxKind.InterfaceDeclaration */));
         const t = getDeclaredTypeOfSymbol(c, symbol);
         if ((t.flags & 1048576 /* TypeFlags.Object */) !== 0) {
             const typeWithThis = getTypeWithThisArgument(c, t, undefined, false);
             // Later checks run only when inherited properties agree.
-            if (checkInheritedPropertiesAreIdentical(c, t, getName(node))) {
+            if (checkInheritedPropertiesAreIdentical(c, t, firstName)) {
                 for (const baseType of getBaseTypes(c, t))
-                    checkTypeAssignableTo(c, typeWithThis, getTypeWithThisArgument(c, baseType, t.thisType, false), getName(node), 598 /* Diagnostics.Interface_0_incorrectly_extends_interface_1 */);
+                    checkTypeAssignableTo(c, typeWithThis, getTypeWithThisArgument(c, baseType, t.thisType, false), firstName, 605 /* Diagnostics.Interface_0_incorrectly_extends_interface_1 */);
                 checkIndexConstraints(c, t, symbol, false);
             }
         }
     }
     checkObjectTypeForDuplicateDeclarations(c, node, false);
     for (const element of getExtendsHeritageClauseElements(node)) {
+        if (element.kind !== 235 /* SyntaxKind.ExpressionWithTypeArguments */)
+            continue;
         const expr = getExpression(element);
         if (!isEntityNameExpression(expr) || isOptionalChain(expr))
-            c.error(expr, 659 /* Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments */);
+            c.error(expr, 666 /* Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments */);
     }
 }
 /** Checks a type literal's index signatures and members after its members are checked. */
@@ -581,8 +579,8 @@ function checkInheritedPropertiesAreIdentical(c, t, typeNode) {
                 identical = false;
                 const typeName1 = typeToString(c, existing.containingType);
                 const typeName2 = typeToString(c, base);
-                const errorInfo = createDiagnosticForNode(typeNode, 497 /* Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical */, [symbolToString(c, prop), typeName1, typeName2]);
-                c.addDiagnostic(chainDiagnostic(errorInfo, 498 /* Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2 */, typeToString(c, t), typeName1, typeName2));
+                const errorInfo = createDiagnosticForNode(typeNode, 504 /* Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical */, [symbolToString(c, prop), typeName1, typeName2]);
+                c.addDiagnostic(chainDiagnostic(errorInfo, 505 /* Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2 */, typeToString(c, t), typeName1, typeName2));
             }
         }
     }
@@ -599,7 +597,7 @@ export function checkTypeParameterListsIdentical(c, symbol) {
     links.typeParametersChecked = true;
     const declarations = [];
     for (const d of getDeclarations(symbol))
-        if (d.kind === 264 /* SyntaxKind.ClassDeclaration */ || d.kind === 265 /* SyntaxKind.InterfaceDeclaration */)
+        if (d.kind === 265 /* SyntaxKind.ClassDeclaration */ || d.kind === 266 /* SyntaxKind.InterfaceDeclaration */)
             declarations.push(d);
     if (declarations.length <= 1)
         return;
@@ -615,7 +613,7 @@ export function checkTypeParameterListsIdentical(c, symbol) {
         return;
     const name = symbolToString(c, symbol);
     for (const d of declarations)
-        c.error(getName(d), 597 /* Diagnostics.All_declarations_of_0_must_have_identical_type_parameters */, name);
+        c.error(getName(d), 604 /* Diagnostics.All_declarations_of_0_must_have_identical_type_parameters */, name);
 }
 /** Reports the declarations of an `infer` type parameter declared more than once with different constraints. */
 export function checkInferTypeParameterDeclarations(c, symbol) {
@@ -628,7 +626,7 @@ export function checkInferTypeParameterDeclarations(c, symbol) {
     const declarations = [];
     const typeParameterLists = [];
     for (const d of getDeclarations(symbol)) {
-        if (d.kind === 169 /* SyntaxKind.TypeParameter */) {
+        if (d.kind === 170 /* SyntaxKind.TypeParameter */) {
             declarations.push(d);
             typeParameterLists.push([d]);
         }
@@ -637,7 +635,7 @@ export function checkInferTypeParameterDeclarations(c, symbol) {
         return;
     const name = symbolToString(c, symbol);
     for (const d of declarations)
-        c.error(getName(d), 960 /* Diagnostics.All_declarations_of_0_must_have_identical_constraints */, name);
+        c.error(getName(d), 967 /* Diagnostics.All_declarations_of_0_must_have_identical_constraints */, name);
 }
 function areTypeParametersIdentical(c, lists, targetParameters) {
     const maxTypeArgumentCount = targetParameters.length;
@@ -675,7 +673,7 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
     const privateNames = new Map();
     const nodeInAmbientContext = (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     for (const member of getMembers(node).nodes) {
-        if (member.kind === 177 /* SyntaxKind.Constructor */) {
+        if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes)
                 if (isParameterPropertyDeclaration(param, member) && !isBindingPattern(getName(param))) {
                     const symbol = getSymbolOfDeclaration(c, param);
@@ -689,15 +687,15 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
             continue;
         const memberIsStatic = hasStaticModifier(member);
         if (!nodeInAmbientContext && memberIsStatic && symbol.name === 'prototype')
-            c.error(getName(member), 831 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, symbol.name, symbolToString(c, getSymbolOfDeclaration(c, node)));
+            c.error(getName(member), 838 /* Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1 */, symbol.name, symbolToString(c, getSymbolOfDeclaration(c, node)));
         const names = memberIsStatic ? staticNames : instanceNames;
         const hasAccessorModifier = hasSyntacticModifier(member, 512 /* ModifierFlags.Accessor */);
-        if ((member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
-            member.kind === 172 /* SyntaxKind.PropertySignature */)
+        if ((member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && !hasAccessorModifier) ||
+            member.kind === 173 /* SyntaxKind.PropertySignature */)
             checkPropertyOrAccessor(c, node, names, symbol, 1 /* MemberKind.Property */, memberIsStatic);
-        else if (member.kind === 178 /* SyntaxKind.GetAccessor */ ||
-            member.kind === 179 /* SyntaxKind.SetAccessor */ ||
-            (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
+        else if (member.kind === 179 /* SyntaxKind.GetAccessor */ ||
+            member.kind === 180 /* SyntaxKind.SetAccessor */ ||
+            (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasAccessorModifier))
             checkPropertyOrAccessor(c, node, names, symbol, 2 /* MemberKind.Accessor */, memberIsStatic);
         const name = getName(member);
         if (checkPrivateNames && name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
@@ -707,7 +705,7 @@ export function checkObjectTypeForDuplicateDeclarations(c, node, checkPrivateNam
             flags |= isStatic(member) ? 2 : 1;
             privateNames.set(symbol.name, flags);
             if (flags === 3)
-                reportDuplicateMemberErrors(c, node, symbol.name, false, false, 936 /* Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name */);
+                reportDuplicateMemberErrors(c, node, symbol.name, false, false, 943 /* Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name */);
         }
     }
 }
@@ -719,13 +717,13 @@ function checkPropertyOrAccessor(c, node, names, symbol, kind, isStaticMember) {
         names.set(symbol.name, kind);
     // A second property, or a property combined with an accessor.
     else if (state === 1 /* MemberKind.Property */ || (state === 2 /* MemberKind.Accessor */ && kind !== 2 /* MemberKind.Accessor */)) {
-        reportDuplicateMemberErrors(c, node, symbol.name, true, isStaticMember, 478 /* Diagnostics.Duplicate_identifier_0 */);
+        reportDuplicateMemberErrors(c, node, symbol.name, true, isStaticMember, 485 /* Diagnostics.Duplicate_identifier_0 */);
         names.set(symbol.name, 3 /* MemberKind.Reported */);
     }
 }
 function reportDuplicateMemberErrors(c, node, name, checkStatic, isStaticMember, message) {
     for (const member of getMembers(node).nodes) {
-        if (member.kind === 177 /* SyntaxKind.Constructor */) {
+        if (member.kind === 178 /* SyntaxKind.Constructor */) {
             for (const param of getParameters(member).nodes) {
                 if (!isParameterPropertyDeclaration(param, member) || isBindingPattern(getName(param)))
                     continue;
@@ -790,10 +788,10 @@ function checkIndexConstraintForProperty(c, t, prop, propNameType, propType) {
     if (indexInfos.length === 0)
         return;
     const interfaceDeclaration = (t.objectFlags & 2 /* ObjectFlags.Interface */) !== 0
-        ? getDeclarationOfKind(t.symbol, 265 /* SyntaxKind.InterfaceDeclaration */)
+        ? getDeclarationOfKind(t.symbol, 266 /* SyntaxKind.InterfaceDeclaration */)
         : undefined;
-    const propDeclaration = (declaration !== undefined && declaration.kind === 227 /* SyntaxKind.BinaryExpression */) ||
-        (name !== undefined && name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    const propDeclaration = (declaration !== undefined && declaration.kind === 228 /* SyntaxKind.BinaryExpression */) ||
+        (name !== undefined && name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         ? declaration
         : undefined;
     const localPropDeclaration = getParentOfSymbol(c, prop) === t.symbol ? declaration : undefined;
@@ -807,14 +805,14 @@ function checkIndexConstraintForProperty(c, t, prop, propNameType, propType) {
             errorNode = interfaceDeclaration;
         if (errorNode === undefined || isTypeAssignableTo(c, propType, info.valueType))
             continue;
-        const diagnostic = createDiagnosticForNode(errorNode, 582 /* Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3 */, [
+        const diagnostic = createDiagnosticForNode(errorNode, 589 /* Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3 */, [
             symbolToString(c, prop),
             typeToString(c, propType),
             typeToString(c, info.keyType),
             typeToString(c, info.valueType),
         ]);
         if (propDeclaration !== undefined && errorNode !== propDeclaration)
-            diagnostic.addRelatedInfo(createDiagnosticForNode(propDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [symbolToString(c, prop)]));
+            diagnostic.addRelatedInfo(createDiagnosticForNode(propDeclaration, 867 /* Diagnostics.X_0_is_declared_here */, [symbolToString(c, prop)]));
         c.addDiagnostic(diagnostic);
     }
 }
@@ -835,7 +833,7 @@ function checkIndexConstraintForIndexSignature(c, t, checkInfo) {
     if (indexInfos.length === 0)
         return;
     const interfaceDeclaration = (t.objectFlags & 2 /* ObjectFlags.Interface */) !== 0
-        ? getDeclarationOfKind(t.symbol, 265 /* SyntaxKind.InterfaceDeclaration */)
+        ? getDeclarationOfKind(t.symbol, 266 /* SyntaxKind.InterfaceDeclaration */)
         : undefined;
     const localCheckDeclaration = getLocalIndexDeclaration(c, t, checkInfo);
     for (const info of indexInfos) {
@@ -847,7 +845,7 @@ function checkIndexConstraintForIndexSignature(c, t, checkInfo) {
             !someBaseHasIndexTypes(c, t, checkInfo.keyType, info.keyType))
             errorNode = interfaceDeclaration;
         if (errorNode !== undefined && !isTypeAssignableTo(c, checkInfo.valueType, info.valueType))
-            c.error(errorNode, 584 /* Diagnostics.X_0_index_type_1_is_not_assignable_to_2_index_type_3 */, typeToString(c, checkInfo.keyType), typeToString(c, checkInfo.valueType), typeToString(c, info.keyType), typeToString(c, info.valueType));
+            c.error(errorNode, 591 /* Diagnostics.X_0_index_type_1_is_not_assignable_to_2_index_type_3 */, typeToString(c, checkInfo.keyType), typeToString(c, checkInfo.valueType), typeToString(c, info.keyType), typeToString(c, info.valueType));
     }
 }
 /** Reports duplicate index signatures of a class or interface, once per symbol. */
@@ -872,7 +870,7 @@ function checkTypeForDuplicateIndexSignatures(c, node) {
     const keyTypes = [];
     const declarationsByKey = [];
     for (const declaration of getDeclarations(indexSymbol)) {
-        if (declaration.kind !== 182 /* SyntaxKind.IndexSignature */)
+        if (declaration.kind !== 183 /* SyntaxKind.IndexSignature */)
             continue;
         const parameters = getParameters(declaration).nodes;
         if (parameters.length !== 1)
@@ -896,6 +894,6 @@ function checkTypeForDuplicateIndexSignatures(c, node) {
         if (declarationsByKey[i].length <= 1)
             continue;
         for (const declaration of declarationsByKey[i])
-            c.error(declaration, 548 /* Diagnostics.Duplicate_index_signature_for_type_0 */, typeToString(c, keyTypes[i]));
+            c.error(declaration, 555 /* Diagnostics.Duplicate_index_signature_for_type_0 */, typeToString(c, keyTypes[i]));
     }
 }