Correctly set kind for class/interface children

Closes #2150

Author: Gerrit0

CHANGELOG.md

@@ -50,6 +50,7 @@
 
 -   TypeDoc will now ignore package.json files not containing a `name` field, #2190.
 -   Fixed `@inheritDoc` on signatures (functions, methods, constructors, getters, setters) being unable to inherit from a non-signature.
+-   Interfaces/classes created via extending a module will no longer contain variables/functions where the member should have been converted as properties/methods, #2150.
 
 ### Thanks!
 

src/lib/converter/comments/discovery.ts

@@ -30,6 +30,7 @@ const wantedKinds: Record<ReflectionKind, ts.SyntaxKind[]> = {
         ts.SyntaxKind.PropertySignature,
     ],
     [ReflectionKind.Variable]: [
+        // everything here should also be in ReflectionKind.Property
         ts.SyntaxKind.VariableDeclaration,
         ts.SyntaxKind.BindingElement,
         ts.SyntaxKind.ExportAssignment,
@@ -55,6 +56,11 @@ const wantedKinds: Record<ReflectionKind, ts.SyntaxKind[]> = {
         ts.SyntaxKind.PropertyAssignment,
         // class X { constructor(/** Comment */ readonly z: string) }
         ts.SyntaxKind.Parameter,
+        // Variable values
+        ts.SyntaxKind.VariableDeclaration,
+        ts.SyntaxKind.BindingElement,
+        ts.SyntaxKind.ExportAssignment,
+        ts.SyntaxKind.PropertyAccessExpression,
     ],
     [ReflectionKind.Method]: [
         ts.SyntaxKind.FunctionDeclaration,

src/lib/converter/context.ts

@@ -61,20 +61,9 @@ export class Context {
      */
     readonly scope: Reflection;
 
-    /** @internal */
-    isConvertingTypeNode(): boolean {
-        return this.convertingTypeNode;
-    }
-
-    /** @internal */
-    setConvertingTypeNode() {
-        this.convertingTypeNode = true;
-    }
-
-    /** @internal */
-    shouldBeStatic = false;
-
-    private convertingTypeNode = false;
+    convertingTypeNode = false; // Inherited by withScope
+    convertingClassOrInterface = false; // Not inherited
+    shouldBeStatic = false; // Not inherited
 
     /**
      * Create a new Context instance.
@@ -100,13 +89,6 @@ export class Context {
         return this.converter.application.logger;
     }
 
-    /**
-     * Return the compiler options.
-     */
-    getCompilerOptions(): ts.CompilerOptions {
-        return this.converter.application.options.getCompilerOptions();
-    }
-
     /**
      * Return the type declaration of the given node.
      *
@@ -175,6 +157,15 @@ export class Context {
             nameOverride ?? exportSymbol?.name ?? symbol?.name ?? "unknown"
         );
 
+        if (this.convertingClassOrInterface) {
+            if (kind === ReflectionKind.Function) {
+                kind = ReflectionKind.Method;
+            }
+            if (kind === ReflectionKind.Variable) {
+                kind = ReflectionKind.Property;
+            }
+        }
+
         const reflection = new DeclarationReflection(name, kind, this.scope);
         this.postReflectionCreation(reflection, symbol, exportSymbol);
 

src/lib/converter/symbols.ts

@@ -447,6 +447,7 @@ function convertClassOrInterface(
     if (classDeclaration) setModifiers(symbol, classDeclaration, reflection);
 
     const reflectionContext = context.withScope(reflection);
+    reflectionContext.convertingClassOrInterface = true;
 
     const instanceType = context.checker.getDeclaredTypeOfSymbol(symbol);
     assert(instanceType.isClassOrInterface());
@@ -643,7 +644,7 @@ function convertProperty(
 
     reflection.type = context.converter.convertType(
         context.withScope(reflection),
-        (context.isConvertingTypeNode() ? parameterType : void 0) ??
+        (context.convertingTypeNode ? parameterType : void 0) ??
             context.checker.getTypeOfSymbol(symbol)
     );
 

src/lib/converter/types.ts

@@ -225,7 +225,7 @@ const constructorConverter: TypeConverter<ts.ConstructorTypeNode, ts.Type> = {
             context.scope
         );
         const rc = context.withScope(reflection);
-        rc.setConvertingTypeNode();
+        rc.convertingTypeNode = true;
 
         context.registerReflection(reflection, symbol);
         context.trigger(ConverterEvents.CREATE_DECLARATION, reflection);
@@ -557,7 +557,7 @@ const typeLiteralConverter: TypeConverter<ts.TypeLiteralNode> = {
             context.scope
         );
         const rc = context.withScope(reflection);
-        rc.setConvertingTypeNode();
+        rc.convertingTypeNode = true;
 
         context.registerReflection(reflection, symbol);
         context.trigger(ConverterEvents.CREATE_DECLARATION, reflection);

src/test/converter2/issues/gh2150/index.ts

@@ -0,0 +1,8 @@
+import * as Int from "./int";
+
+type Int = typeof Int;
+
+export interface FileInt extends Int {}
+
+export class FileClass {}
+export interface FileClass extends Int {}

src/test/converter2/issues/gh2150/int.ts

@@ -0,0 +1,8 @@
+/** intFn doc */
+export function intFn() {}
+
+/** intVar doc */
+export const intVar = 123;
+
+/** constFn doc */
+export const constFn = () => {};

src/test/issueTests.ts

@@ -832,6 +832,46 @@ export const issueTests: {
         );
     },
 
+    gh2150(project) {
+        const intFn = query(project, "FileInt.intFn");
+        equal(intFn.kind, ReflectionKind.Method, "intFn interface method");
+        equal(
+            Comment.combineDisplayParts(intFn.signatures?.[0].comment?.summary),
+            "intFn doc"
+        );
+
+        const intProp = query(project, "FileInt.intVar");
+        equal(intProp.kind, ReflectionKind.Property, "intVar interface prop");
+        equal(
+            Comment.combineDisplayParts(intProp.comment?.summary),
+            "intVar doc"
+        );
+
+        const constFn = query(project, "FileInt.constFn");
+        equal(constFn.kind, ReflectionKind.Method, "constFn interface method");
+        equal(
+            Comment.combineDisplayParts(
+                constFn.signatures?.[0].comment?.summary
+            ),
+            "constFn doc"
+        );
+
+        const intFn2 = query(project, "FileClass.intFn");
+        equal(intFn2.kind, ReflectionKind.Method, "intFn class method");
+
+        const intProp2 = query(project, "FileClass.intVar");
+        equal(intProp2.kind, ReflectionKind.Property, "intVar class prop");
+
+        const constFn2 = query(project, "FileClass.constFn");
+        equal(constFn2.kind, ReflectionKind.Method, "constFn class method");
+        equal(
+            Comment.combineDisplayParts(
+                constFn2.signatures?.[0].comment?.summary
+            ),
+            "constFn doc"
+        );
+    },
+
     pre2156(app) {
         app.options.setValue("excludeNotDocumented", true);
     },