Discover parent types through mapped types

Resolves #2978

Author: Gerrit0

.vscode/settings.json

@@ -5,6 +5,7 @@
     },
 
     "typescript.tsdk": "./node_modules/typescript/lib",
+    "dprint.path": "./node_modules/dprint/dprint",
 
     // Automatically run the formatter when certain files are saved.
     "[javascript]": {

CHANGELOG.md

@@ -14,6 +14,7 @@ title: Changelog
 
 - Relative links in `<img srcset>` will now be discovered by TypeDoc, #2975.
 - Relative links in `<source src>` and `<source srcset>` elements will now be discovered by TypeDoc, #2975.
+- Improved inherited from/overwrites link discovery to point to parent properties in more cases, #2978
 
 ### Thanks!
 

scripts/testcase.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 // @ts-check
 import md from "markdown-it";
 import cp from "child_process";

src/lib/converter/plugins/ImplementsPlugin.ts

@@ -110,8 +110,10 @@ export class ImplementsPlugin extends ConverterComponent {
         project: ProjectReflection,
         reflection: DeclarationReflection,
     ) {
+        if (!reflection.extendedTypes) return;
+
         const extendedTypes = filterMap(
-            reflection.extendedTypes ?? [],
+            reflection.extendedTypes,
             (type) => {
                 return type instanceof ReferenceType &&
                         type.reflection instanceof DeclarationReflection
@@ -139,23 +141,54 @@ export class ImplementsPlugin extends ConverterComponent {
                             parentMember.signatures ?? [],
                         )
                     ) {
-                        childSig[key] = ReferenceType.createResolvedReference(
+                        // If we're already pointing at something because TS said we should reference
+                        // it, then don't overwrite the reference.
+                        if (!childSig[key]?.reflection) {
+                            childSig[key] = ReferenceType.createResolvedReference(
+                                `${parent.name}.${parentMember.name}`,
+                                parentSig,
+                                project,
+                            );
+                        }
+                    }
+
+                    if (!child[key]?.reflection) {
+                        child[key] = ReferenceType.createResolvedReference(
                             `${parent.name}.${parentMember.name}`,
-                            parentSig,
+                            parentMember,
                             project,
                         );
                     }
 
-                    child[key] = ReferenceType.createResolvedReference(
-                        `${parent.name}.${parentMember.name}`,
-                        parentMember,
-                        project,
-                    );
-
                     this.handleInheritedComments(child, parentMember);
                 }
             }
         }
+
+        // #2978, this is very unfortunate. If a child's parent links are broken at this point,
+        // we replace them with an intentionally broken link so that they won't ever be resolved.
+        // This is done because if we don't do it then we run into issues where we have a link which
+        // points to some ReflectionSymbolId which might not exist now, but once we've gone through
+        // serialization/deserialization, might point to an unexpected location. (See the mixin
+        // converter tests, I suspect this might actually be an indication of something else slightly
+        // broken there, but don't want to spend more time with this right now.)
+        for (const child of reflection.children || []) {
+            if (child.inheritedFrom && !child.inheritedFrom.reflection) {
+                child.inheritedFrom = ReferenceType.createBrokenReference(child.inheritedFrom.name, project);
+            }
+            if (child.overwrites && !child.overwrites.reflection) {
+                child.overwrites = ReferenceType.createBrokenReference(child.overwrites.name, project);
+            }
+
+            for (const childSig of child.getAllSignatures()) {
+                if (childSig.inheritedFrom && !childSig.inheritedFrom.reflection) {
+                    childSig.inheritedFrom = ReferenceType.createBrokenReference(childSig.inheritedFrom.name, project);
+                }
+                if (childSig.overwrites && !childSig.overwrites.reflection) {
+                    childSig.overwrites = ReferenceType.createBrokenReference(childSig.overwrites.name, project);
+                }
+            }
+        }
     }
 
     private onResolveEnd(context: Context) {
@@ -522,9 +555,21 @@ function createLink(
     symbol: ts.Symbol,
     isInherit: boolean,
 ) {
-    const project = context.project;
     const name = `${expr.expression.getText()}.${getHumanName(symbol.name)}`;
 
+    // We should always have rootSymbols, but check just in case. We use the first
+    // symbol here as TypeDoc's models don't have multiple symbols for the parent
+    // reference. This is technically wrong because symbols might be declared in
+    // multiple locations (interface declaration merging), but that's an uncommon
+    // enough use case that it doesn't seem worthwhile to complicate the rest of the
+    // world to deal with it.
+    // Note that we also need to check that the root symbol isn't this symbol.
+    // This seems to happen sometimes when dealing with interface inheritance.
+    const rootSymbols = context.checker.getRootSymbols(symbol);
+    const ref = rootSymbols.length && rootSymbols[0] != symbol
+        ? context.createSymbolReference(rootSymbols[0], context, name)
+        : ReferenceType.createBrokenReference(name, context.project);
+
     link(reflection);
     link(reflection.getSignature);
     link(reflection.setSignature);
@@ -535,34 +580,21 @@ function createLink(
         link(sig);
     }
 
-    // Intentionally create broken links here. These will be replaced with real links during
-    // resolution if we can do so. We create broken links rather than real links because in the
-    // case of an inherited symbol, we'll end up referencing a single symbol ID rather than one
-    // for each class.
     function link(
         target: DeclarationReflection | SignatureReflection | undefined,
     ) {
         if (!target) return;
 
         if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-            target.implementationOf ??= ReferenceType.createBrokenReference(
-                name,
-                project,
-            );
+            target.implementationOf ??= ref;
             return;
         }
 
         if (isInherit) {
             target.setFlag(ReflectionFlag.Inherited);
-            target.inheritedFrom ??= ReferenceType.createBrokenReference(
-                name,
-                project,
-            );
+            target.inheritedFrom ??= ref;
         } else {
-            target.overwrites ??= ReferenceType.createBrokenReference(
-                name,
-                project,
-            );
+            target.overwrites ??= ref;
         }
     }
 }

src/lib/serialization/schema.ts

@@ -58,6 +58,7 @@ type _ModelToObject<T> =
         T extends M.CommentDisplayPart ? CommentDisplayPart :
         T extends M.SourceReference ? SourceReference :
         T extends M.FileRegistry ? FileRegistry :
+        T extends M.ReflectionSymbolId ? ReflectionSymbolId :
         never;
 
 type Primitive = string | number | undefined | null | boolean;

src/test/converter/interface/specs.json

@@ -2546,8 +2546,8 @@
                             },
                             "inheritedFrom": {
                                 "type": "reference",
-                                "target": 106,
-                                "name": "Base.base"
+                                "target": 112,
+                                "name": "Child.base"
                             }
                         },
                         {

src/test/converter2/issues/gh2978.ts

@@ -0,0 +1,15 @@
+export interface Parent {
+    prop: string;
+}
+
+export interface Child extends Partial<Parent> {}
+
+export type Tricky<T> = Omit<T, "x"> & { x: number };
+
+export interface HasX {
+    x: string;
+}
+
+export interface InheritsX extends Tricky<HasX> {
+    // InheritsX.x should *not* be linked to HasX.x
+}

src/test/issues.c2.test.ts

@@ -2135,4 +2135,13 @@ describe("Issue Tests", () => {
             ["Var", "Comment"],
         ]);
     });
+
+    it("#2978 handles parent properties through mapped types", () => {
+        const project = convert();
+        const prop = query(project, "Child.prop");
+        equal(prop.inheritedFrom?.reflection?.getFullName(), "Parent.prop");
+        const x = query(project, "InheritsX.x");
+        equal(x.inheritedFrom?.reflection?.getFullName(), undefined);
+        equal(x.inheritedFrom?.name, "Tricky.x");
+    });
 });