refactor(compiler-cli): Improved filterMethodOverloads to Include Members without body (angular#58445)

Previously, `filterMethodOverloads` excluded all members without a body, causing issues with the extraction of functions and members in TypeScript types.

PR Close angular#58445

Author: alan-agius4

packages/compiler-cli/src/ngtsc/docs/src/class_extractor.ts

@@ -271,26 +271,21 @@ class ClassExtractor {
   /** The result only contains properties, method implementations and abstracts */
   private filterMethodOverloads(declarations: ts.Declaration[]): ts.Declaration[] {
     return declarations.filter((declaration, index) => {
+      // Check if the declaration is a function or method
       if (ts.isFunctionDeclaration(declaration) || ts.isMethodDeclaration(declaration)) {
-        if (ts.getCombinedModifierFlags(declaration) & ts.ModifierFlags.Abstract) {
-          // TS enforces that all declarations of an abstract method are consecutive
-          const previousDeclaration = declarations[index - 1];
-
-          const samePreviousAbstractMethod =
-            previousDeclaration &&
-            ts.isMethodDeclaration(previousDeclaration) &&
-            ts.getCombinedModifierFlags(previousDeclaration) & ts.ModifierFlags.Abstract &&
-            previousDeclaration.name.getText() === declaration.name?.getText();
-
-          // We just need a reference to one member
-          // In the case of Abstract Methods we only want to return the first abstract.
-          // Others with the same name are considered as overloads
-          // Later on, the function extractor will handle overloads and implementation detection
-          return !samePreviousAbstractMethod;
-        }
-
-        return !!declaration.body;
+        // TypeScript ensures that all declarations for a given abstract method appear consecutively.
+        const nextDeclaration = declarations[index + 1];
+        const isNextAbstractMethodWithSameName =
+          nextDeclaration &&
+          ts.isMethodDeclaration(nextDeclaration) &&
+          nextDeclaration.name.getText() === declaration.name?.getText();
+
+        // Return only the last occurrence of an abstract method to avoid overload duplication.
+        // Subsequent overloads or implementations are handled separately by the function extractor.
+        return !isNextAbstractMethodWithSameName;
       }
+
+      // Include non-method declarations, such as properties, without filtering.
       return true;
     });
   }

packages/compiler-cli/test/ngtsc/doc_extraction/class_doc_extraction_spec.ts

@@ -276,15 +276,15 @@ runInEachFileSystem(() => {
             eyeColor = 'brown';
 
             /** @internal */
-            uuid: string;     
-            
+            uuid: string;
+
             // @internal
             foreignId: string;
 
             /** @internal */
             _doSomething() {}
 
-            // @internal 
+            // @internal
             _doSomethingElse() {}
         }
       `,
@@ -662,5 +662,27 @@ runInEachFileSystem(() => {
       expect(fooEntry.memberType).toBe(MemberType.Property);
       expect((fooEntry as PropertyEntry).type).toBe('string');
     });
+
+    it('should extract members of a class from .d.ts', () => {
+      env.write(
+        'index.d.ts',
+        `
+        export declare class UserProfile {
+          firstName: string;
+          save(): void;
+        }`,
+      );
+
+      const docs: DocEntry[] = env.driveDocsExtraction('index.d.ts');
+      expect(docs.length).toBe(1);
+
+      const classEntry = docs[0] as ClassEntry;
+      expect(classEntry.members.length).toBe(2);
+
+      const [firstNameEntry, saveEntry] = classEntry.members;
+
+      expect(firstNameEntry.name).toBe('firstName');
+      expect(saveEntry.name).toBe('save');
+    });
   });
 });