refactor(compiler-cli): Extract type predicates from type guards. (angular#60934)

Previously they were extracted as `boolean`.

PR Close angular#60934

Author: JeanMeche

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

@@ -32,14 +32,7 @@ export class FunctionExtractor {
     // TODO: is there any real situation in which the signature would not be available here?
     //     Is void a better type?
     const signature = this.typeChecker.getSignatureFromDeclaration(this.exportDeclaration);
-    const returnType = signature
-      ? this.typeChecker.typeToString(
-          this.typeChecker.getReturnTypeOfSignature(signature),
-          undefined,
-          // This ensures that e.g. `T | undefined` is not reduced to `T`.
-          ts.TypeFormatFlags.NoTypeReduction | ts.TypeFormatFlags.NoTruncation,
-        )
-      : 'unknown';
+    const returnType = signature ? extractReturnType(signature, this.typeChecker) : 'unknown';
 
     const implementation =
       findImplementationOfFunction(this.exportDeclaration, this.typeChecker) ??
@@ -149,15 +142,24 @@ export function extractCallSignatures(name: string, typeChecker: ts.TypeChecker,
     jsdocTags: extractJsDocTags(decl),
     params: extractAllParams(decl.parameters, typeChecker),
     rawComment: extractRawJsDoc(decl),
-    returnType: typeChecker.typeToString(
-      typeChecker.getReturnTypeOfSignature(signature),
-      undefined,
-      // This ensures that e.g. `T | undefined` is not reduced to `T`.
-      ts.TypeFormatFlags.NoTypeReduction | ts.TypeFormatFlags.NoTruncation,
-    ),
+    returnType: extractReturnType(signature, typeChecker),
   }));
 }
 
+function extractReturnType(signature: ts.Signature, typeChecker: ts.TypeChecker): string {
+  // Handling Type Predicates
+  if (signature?.declaration?.type && ts.isTypePredicateNode(signature.declaration.type)) {
+    return signature.declaration.type.getText();
+  }
+
+  return typeChecker.typeToString(
+    typeChecker.getReturnTypeOfSignature(signature),
+    undefined,
+    // This ensures that e.g. `T | undefined` is not reduced to `T`.
+    ts.TypeFormatFlags.NoTypeReduction | ts.TypeFormatFlags.NoTruncation,
+  );
+}
+
 /** Finds the implementation of the given function declaration overload signature. */
 export function findImplementationOfFunction(
   node: FunctionLike,

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

@@ -145,5 +145,19 @@ runInEachFileSystem(() => {
       expect(genericEntry.constraint).toBeUndefined();
       expect(genericEntry.default).toBeUndefined();
     });
+
+    it('should extract type predicates as return type of type guards', () => {
+      env.write(
+        'index.ts',
+        `export function isSignal(value: unknown): value is Signal<unknown> {}`,
+      );
+
+      const docs: DocEntry[] = env.driveDocsExtraction('index.ts');
+      expect(docs.length).toBe(1);
+
+      const [functionEntry] = docs as FunctionEntry[];
+      expect(functionEntry.implementation.returnType).toBe('value is Signal<unknown>');
+      expect(functionEntry.signatures[0].returnType).toBe('value is Signal<unknown>');
+    });
   });
 });