Fixed crash when getting a definition for a class member with a computed name and an override modifier

src/compiler/checker.ts

@@ -47336,7 +47336,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         const errorMessage = overriddenInstanceProperty ?
                             Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property :
                             Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor;
-                        error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, symbolToString(base), typeToString(baseType), typeToString(type));
+                        error(getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, symbolToString(base), typeToString(getDeclaredTypeOfSymbol(base.parent!)), typeToString(type));
                     }
                     else if (useDefineForClassFields) {
                         const uninitialized = derived.declarations?.find(d => d.kind === SyntaxKind.PropertyDeclaration && !(d as PropertyDeclaration).initializer);

src/services/codefixes/fixAddMissingMember.ts

@@ -7,7 +7,6 @@ import {
     createSignatureDeclarationFromSignature,
     createStubbedBody,
     eachDiagnostic,
-    getAllSupers,
     ImportAdder,
     registerCodeFix,
 } from "../_namespaces/ts.codefix.js";
@@ -40,6 +39,7 @@ import {
     firstOrUndefinedIterator,
     FunctionExpression,
     getCheckFlags,
+    getClassExtendsHeritageElement,
     getClassLikeDeclarationOfSymbol,
     getEmitScriptTarget,
     getEscapedTextOfJsxAttributeName,
@@ -797,3 +797,18 @@ function findScope(node: Node) {
     }
     return getSourceFileOfNode(node);
 }
+
+function getAllSupers(decl: ClassLikeDeclaration | InterfaceDeclaration | undefined, checker: TypeChecker): readonly ClassLikeDeclaration[] {
+    const res: ClassLikeDeclaration[] = [];
+    while (decl) {
+        const superElement = getClassExtendsHeritageElement(decl);
+        const superSymbol = superElement && checker.getSymbolAtLocation(superElement.expression);
+        if (!superSymbol) break;
+        const symbol = superSymbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(superSymbol) : superSymbol;
+        const superDecl = symbol.declarations && find(symbol.declarations, isClassLike);
+        if (!superDecl) break;
+        res.push(superDecl);
+        decl = superDecl;
+    }
+    return res;
+}

src/services/codefixes/fixPropertyOverrideAccessor.ts

@@ -2,20 +2,22 @@ import {
     codeFixAll,
     createCodeFixAction,
     generateAccessorFromProperty,
-    getAllSupers,
     registerCodeFix,
 } from "../_namespaces/ts.codefix.js";
 import {
     CodeFixAllContext,
     CodeFixContext,
     Debug,
     Diagnostics,
+    getEffectiveBaseTypeNode,
     getSourceFileOfNode,
     getTextOfPropertyName,
     getTokenAtPosition,
     isAccessor,
+    isClassExpression,
     isClassLike,
-    singleOrUndefined,
+    isComputedPropertyName,
+    skipParentheses,
     SourceFile,
     unescapeLeadingUnderscores,
 } from "../_namespaces/ts.js";
@@ -56,15 +58,20 @@ function doChange(file: SourceFile, start: number, length: number, code: number,
     else if (code === Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code) {
         const checker = context.program.getTypeChecker();
         const node = getTokenAtPosition(file, start).parent;
+        if (isComputedPropertyName(node)) {
+            return;
+        }
         Debug.assert(isAccessor(node), "error span of fixPropertyOverrideAccessor should only be on an accessor");
         const containingClass = node.parent;
         Debug.assert(isClassLike(containingClass), "erroneous accessors should only be inside classes");
-        const base = singleOrUndefined(getAllSupers(containingClass, checker));
-        if (!base) return [];
-
-        const name = unescapeLeadingUnderscores(getTextOfPropertyName(node.name));
-        const baseProp = checker.getPropertyOfType(checker.getTypeAtLocation(base), name);
-        if (!baseProp || !baseProp.valueDeclaration) return [];
+        const baseTypeNode = getEffectiveBaseTypeNode(containingClass);
+        if (!baseTypeNode) return;
+        const expression = skipParentheses(baseTypeNode.expression);
+        const base = isClassExpression(expression) ? expression.symbol : checker.getSymbolAtLocation(expression);
+        if (!base) return;
+        const baseType = checker.getDeclaredTypeOfSymbol(base);
+        const baseProp = checker.getPropertyOfType(baseType, unescapeLeadingUnderscores(getTextOfPropertyName(node.name)));
+        if (!baseProp || !baseProp.valueDeclaration) return;
 
         startPosition = baseProp.valueDeclaration.pos;
         endPosition = baseProp.valueDeclaration.end;

src/services/codefixes/generateAccessors.ts

@@ -9,9 +9,7 @@ import {
     Diagnostics,
     factory,
     FileTextChanges,
-    find,
     findAncestor,
-    getClassExtendsHeritageElement,
     getDecorators,
     getEffectiveModifierFlags,
     getFirstConstructorWithBody,
@@ -22,7 +20,6 @@ import {
     hasEffectiveReadonlyModifier,
     hasStaticModifier,
     Identifier,
-    InterfaceDeclaration,
     isClassLike,
     isElementAccessExpression,
     isFunctionLike,
@@ -50,10 +47,8 @@ import {
     startsWithUnderscore,
     StringLiteral,
     suppressLeadingAndTrailingTrivia,
-    SymbolFlags,
     SyntaxKind,
     textChanges,
-    TypeChecker,
     TypeNode,
 } from "../_namespaces/ts.js";
 
@@ -321,22 +316,3 @@ function getDeclarationType(declaration: AcceptedDeclaration, program: Program):
     }
     return typeNode;
 }
-
-/** @internal */
-export function getAllSupers(decl: ClassOrInterface | undefined, checker: TypeChecker): readonly ClassOrInterface[] {
-    const res: ClassLikeDeclaration[] = [];
-    while (decl) {
-        const superElement = getClassExtendsHeritageElement(decl);
-        const superSymbol = superElement && checker.getSymbolAtLocation(superElement.expression);
-        if (!superSymbol) break;
-        const symbol = superSymbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(superSymbol) : superSymbol;
-        const superDecl = symbol.declarations && find(symbol.declarations, isClassLike);
-        if (!superDecl) break;
-        res.push(superDecl);
-        decl = superDecl;
-    }
-    return res;
-}
-
-/** @internal */
-export type ClassOrInterface = ClassLikeDeclaration | InterfaceDeclaration;

src/services/goToDefinition.ts

@@ -51,6 +51,7 @@ import {
     isClassExpression,
     isClassLike,
     isClassStaticBlockDeclaration,
+    isComputedPropertyName,
     isConstructorDeclaration,
     isDeclarationFileName,
     isDefaultClause,
@@ -64,6 +65,7 @@ import {
     isJSDocOverrideTag,
     isJsxOpeningLikeElement,
     isJumpStatementTarget,
+    isKnownSymbol,
     isModifier,
     isModuleSpecifierLike,
     isNamedDeclaration,
@@ -328,14 +330,29 @@ function getDefinitionFromOverriddenMember(typeChecker: TypeChecker, node: Node)
     const expression = skipParentheses(baseTypeNode.expression);
     const base = isClassExpression(expression) ? expression.symbol : typeChecker.getSymbolAtLocation(expression);
     if (!base) return;
+    const baseType = hasStaticModifier(classElement) ? typeChecker.getTypeOfSymbol(base) : typeChecker.getDeclaredTypeOfSymbol(base);
+    let baseProp: Symbol | undefined;
 
-    const name = unescapeLeadingUnderscores(getTextOfPropertyName(classElement.name));
-    const symbol = hasStaticModifier(classElement)
-        ? typeChecker.getPropertyOfType(typeChecker.getTypeOfSymbol(base), name)
-        : typeChecker.getPropertyOfType(typeChecker.getDeclaredTypeOfSymbol(base), name);
-    if (!symbol) return;
+    if (isComputedPropertyName(classElement.name)) {
+        const prop = typeChecker.getSymbolAtLocation(classElement.name);
 
-    return getDefinitionFromSymbol(typeChecker, symbol, node);
+        if (!prop) {
+            return;
+        }
+
+        if (isKnownSymbol(prop)) {
+            baseProp = find(typeChecker.getPropertiesOfType(baseType), s => s.escapedName === prop.escapedName);
+        }
+        else {
+            baseProp = typeChecker.getPropertyOfType(baseType, unescapeLeadingUnderscores(prop.escapedName));
+        }
+    }
+    else {
+        baseProp = typeChecker.getPropertyOfType(baseType, unescapeLeadingUnderscores(getTextOfPropertyName(classElement.name)));
+    }
+    if (!baseProp) return;
+
+    return getDefinitionFromSymbol(typeChecker, baseProp, node);
 }
 
 /** @internal */

tests/baselines/reference/accessorsOverrideProperty10.errors.txt

@@ -0,0 +1,16 @@
+accessorsOverrideProperty10.ts(6,7): error TS2611: 'x' is defined as a property in class 'A', but is overridden here in 'C' as an accessor.
+
+
+==== accessorsOverrideProperty10.ts (1 errors) ====
+    class A {
+      x = 1;
+    }
+    class B extends A {}
+    class C extends B {
+      get x() {
+          ~
+!!! error TS2611: 'x' is defined as a property in class 'A', but is overridden here in 'C' as an accessor.
+        return 2;
+      }
+    }
+

tests/baselines/reference/accessorsOverrideProperty10.symbols

@@ -0,0 +1,24 @@
+//// [tests/cases/conformance/classes/propertyMemberDeclarations/accessorsOverrideProperty10.ts] ////
+
+=== accessorsOverrideProperty10.ts ===
+class A {
+>A : Symbol(A, Decl(accessorsOverrideProperty10.ts, 0, 0))
+
+  x = 1;
+>x : Symbol(A.x, Decl(accessorsOverrideProperty10.ts, 0, 9))
+}
+class B extends A {}
+>B : Symbol(B, Decl(accessorsOverrideProperty10.ts, 2, 1))
+>A : Symbol(A, Decl(accessorsOverrideProperty10.ts, 0, 0))
+
+class C extends B {
+>C : Symbol(C, Decl(accessorsOverrideProperty10.ts, 3, 20))
+>B : Symbol(B, Decl(accessorsOverrideProperty10.ts, 2, 1))
+
+  get x() {
+>x : Symbol(C.x, Decl(accessorsOverrideProperty10.ts, 4, 19))
+
+    return 2;
+  }
+}
+

tests/baselines/reference/accessorsOverrideProperty10.types

@@ -0,0 +1,35 @@
+//// [tests/cases/conformance/classes/propertyMemberDeclarations/accessorsOverrideProperty10.ts] ////
+
+=== accessorsOverrideProperty10.ts ===
+class A {
+>A : A
+>  : ^
+
+  x = 1;
+>x : number
+>  : ^^^^^^
+>1 : 1
+>  : ^
+}
+class B extends A {}
+>B : B
+>  : ^
+>A : A
+>  : ^
+
+class C extends B {
+>C : C
+>  : ^
+>B : B
+>  : ^
+
+  get x() {
+>x : number
+>  : ^^^^^^
+
+    return 2;
+>2 : 2
+>  : ^
+  }
+}
+

tests/baselines/reference/goToDefinitionOverriddenMember17.baseline.jsonc

@@ -0,0 +1,23 @@
+// === goToDefinition ===
+// === /tests/cases/fourslash/goToDefinitionOverriddenMember17.ts ===
+// const entityKind = Symbol.for("drizzle:entityKind");
+// 
+// abstract class MySqlColumn {
+//   <|static readonly [|[entityKind]|]: string = "MySqlColumn";|>
+// }
+// 
+// export class MySqlVarBinary extends MySqlColumn {
+//   static /*GOTO DEF*/override readonly [entityKind]: string = "MySqlVarBinary";
+// }
+
+  // === Details ===
+  [
+   {
+    "kind": "property",
+    "name": "[entityKind]",
+    "containerName": "MySqlColumn",
+    "isLocal": true,
+    "isAmbient": false,
+    "unverified": false
+   }
+  ]

tests/baselines/reference/goToDefinitionOverriddenMember18.baseline.jsonc

@@ -0,0 +1,23 @@
+// === goToDefinition ===
+// === /tests/cases/fourslash/goToDefinitionOverriddenMember18.ts ===
+// const entityKind = Symbol.for("drizzle:entityKind");
+// 
+// abstract class MySqlColumn {
+//   <|readonly [|[entityKind]|]: string = "MySqlColumn";|>
+// }
+// 
+// export class MySqlVarBinary extends MySqlColumn {
+//   /*GOTO DEF*/override readonly [entityKind]: string = "MySqlVarBinary";
+// }
+
+  // === Details ===
+  [
+   {
+    "kind": "property",
+    "name": "[entityKind]",
+    "containerName": "MySqlColumn",
+    "isLocal": true,
+    "isAmbient": false,
+    "unverified": false
+   }
+  ]

tests/baselines/reference/goToDefinitionOverriddenMember19.baseline.jsonc

@@ -0,0 +1,23 @@
+// === goToDefinition ===
+// === /tests/cases/fourslash/goToDefinitionOverriddenMember19.ts ===
+// const prop = "foo" as const;
+// 
+// abstract class A {
+//   <|static readonly [|[prop]|] = "A";|>
+// }
+// 
+// export class B extends A {
+//   static /*GOTO DEF*/override readonly [prop] = "B";
+// }
+
+  // === Details ===
+  [
+   {
+    "kind": "property",
+    "name": "[prop]",
+    "containerName": "A",
+    "isLocal": true,
+    "isAmbient": false,
+    "unverified": false
+   }
+  ]

tests/baselines/reference/goToDefinitionOverriddenMember20.baseline.jsonc

@@ -0,0 +1,23 @@
+// === goToDefinition ===
+// === /tests/cases/fourslash/goToDefinitionOverriddenMember20.ts ===
+// const prop = "foo" as const;
+// 
+// abstract class A {
+//   <|readonly [|[prop]|] = "A";|>
+// }
+// 
+// export class B extends A {
+//   /*GOTO DEF*/override readonly [prop] = "B";
+// }
+
+  // === Details ===
+  [
+   {
+    "kind": "property",
+    "name": "[prop]",
+    "containerName": "A",
+    "isLocal": true,
+    "isAmbient": false,
+    "unverified": false
+   }
+  ]