fix(typescript): handle property accessors correctly

typescript/mocks/readTypeScriptModules/gettersAndSetters.ts

@@ -0,0 +1,20 @@
+export class Test {
+  get foo1(): string { return null; }
+  /** foo1 setter */
+  set foo1(value: string) { /* do nothing */}
+
+  set foo2(value: string) { /* do nothing */}
+  /** foo2 getter */
+  get foo2(): string { return null; }
+
+  /** bar getter */
+  get bar(): number { return null; }
+
+  /** qux setter */
+  set qux(value: object) { /* do nothing */ }
+
+  /** This has no explicit getter return type */
+  get noType() { return 'x'; }
+  /** So we get it from the setter instead */
+  set noType(value: string) { /**/ }
+}

typescript/src/api-doc-types/AccessorInfoDoc.ts

@@ -0,0 +1,22 @@
+import { Declaration, SignatureDeclaration, TypeChecker } from 'typescript';
+import { getDeclarationTypeText } from '../services/TsParser/getDeclarationTypeText';
+import { getParameters } from '../services/TsParser/getParameters';
+import { encodeAnchor } from '../utils/encodeAnchor';
+import { MethodMemberDoc } from './MethodMemberDoc';
+import { PropertyMemberDoc } from './PropertyMemberDoc';
+
+/**
+ * This represents a getter or setter overload of an accessor property.
+ * There will be a PropertyMemberDoc that contains these docs.
+ */
+export class AccessorInfoDoc extends MethodMemberDoc {
+  docType = `${this.accessorType}-accessor-info`;
+  name = `${this.propertyDoc.name}:${this.accessorType}`;
+  id = `${this.propertyDoc.id}:${this.accessorType}`;
+  aliases = this.propertyDoc.aliases.map(alias => `${alias}:${this.accessorType}`);
+  anchor = encodeAnchor(this.name);
+
+  constructor(public accessorType: 'get'|'set', public propertyDoc: PropertyMemberDoc, declaration: Declaration, basePath: string, namespacesToInclude: string[]) {
+    super(propertyDoc.containerDoc, propertyDoc.symbol, declaration, basePath, namespacesToInclude, false);
+  }
+}

typescript/src/api-doc-types/ContainerExportDoc.ts

@@ -1,7 +1,8 @@
 /* tslint:disable:no-bitwise */
-import { FunctionLikeDeclaration, Map, Symbol, SymbolFlags } from 'typescript';
+import { FunctionLikeDeclaration, GetAccessorDeclaration, Map, SetAccessorDeclaration, Symbol, SymbolFlags, SyntaxKind } from 'typescript';
 import { FileInfo } from "../services/TsParser/FileInfo";
 import { getAccessibility } from "../services/TsParser/getAccessibility";
+import { AccessorInfoDoc } from './AccessorInfoDoc';
 import { ExportDoc } from './ExportDoc' ;
 import { MemberDoc } from './MemberDoc' ;
 import { MethodMemberDoc } from './MethodMemberDoc';
@@ -38,22 +39,34 @@ export abstract class ContainerExportDoc extends ExportDoc {
 
       const overloads: MethodMemberDoc[] = [];
       let memberDoc: MemberDoc|null = null;
+      let getAccessorDeclaration: GetAccessorDeclaration | null = null;
+      let setAccessorDeclaration: SetAccessorDeclaration | null = null;
 
       for (const declaration of member.getDeclarations()!) {
         if (flags & MethodMemberFlags) {
-          if ((declaration as FunctionLikeDeclaration).body) {
+          if (declaration.kind === SyntaxKind.GetAccessor) {
+            getAccessorDeclaration = declaration as GetAccessorDeclaration;
+          } else if (declaration.kind === SyntaxKind.SetAccessor) {
+            setAccessorDeclaration = declaration as SetAccessorDeclaration;
+          } else if ((declaration as FunctionLikeDeclaration).body) {
             // This is the "real" declaration of the method
             memberDoc = new MethodMemberDoc(this, member, declaration, this.basePath, this.namespacesToInclude, isStatic, overloads);
           } else {
             // This is an overload signature of the method
             overloads.push(new MethodMemberDoc(this, member, declaration, this.basePath, this.namespacesToInclude, isStatic, overloads));
           }
         } else if (flags & PropertyMemberFlags) {
-          memberDoc = new PropertyMemberDoc(this, member, declaration, this.basePath, this.namespacesToInclude, isStatic);
+          memberDoc = new PropertyMemberDoc(this, member, declaration, null, null, this.basePath, this.namespacesToInclude, isStatic);
         } else {
           throw new Error(`Unknown member type for member ${member.name}`);
         }
       }
+
+      // If at least one of the declarations was an accessor then the whole member is a property.
+      if (getAccessorDeclaration || setAccessorDeclaration) {
+        memberDoc = new PropertyMemberDoc(this, member, null, getAccessorDeclaration, setAccessorDeclaration, this.basePath, this.namespacesToInclude, false);
+      }
+
       // If there is no member doc then we are in an interface or abstract class and we just take the first overload
       // as the primary one.
       memberDocs.push(memberDoc || overloads.shift()!);

typescript/src/api-doc-types/PropertyMemberDoc.ts

@@ -1,9 +1,35 @@
+import { Declaration, GetAccessorDeclaration, SetAccessorDeclaration, SignatureDeclaration, Symbol, SyntaxKind } from 'typescript';
+import { getDeclarationTypeText } from "../services/TsParser/getDeclarationTypeText";
+import { getParameters } from '../services/TsParser/getParameters';
 import { encodeAnchor } from '../utils/encodeAnchor';
+import { AccessorInfoDoc } from './AccessorInfoDoc';
+import { ContainerExportDoc } from './ContainerExportDoc';
 import { MemberDoc } from './MemberDoc';
 
 export class PropertyMemberDoc extends MemberDoc {
   name = this.symbol.name;
   anchor = encodeAnchor(this.name);
   id = `${this.containerDoc.id}.${this.name}`;
   aliases = this.containerDoc.aliases.map(alias => `${alias}.${this.name}` );
+  getAccessor: AccessorInfoDoc | null;
+  setAccessor: AccessorInfoDoc | null;
+
+  constructor(
+    containerDoc: ContainerExportDoc,
+    symbol: Symbol,
+    declaration: Declaration | null,
+    getAccessorDeclaration: GetAccessorDeclaration | null,
+    setAccessorDeclaration: SetAccessorDeclaration | null,
+    basePath: string,
+    namespacesToInclude: string[],
+    isStatic: boolean,
+  ) {
+    super(containerDoc, symbol, (declaration || getAccessorDeclaration || setAccessorDeclaration)!, basePath, namespacesToInclude, isStatic);
+
+    // If this property has accessors then compute the type based on that instead
+    this.getAccessor = getAccessorDeclaration && new AccessorInfoDoc('get', this, getAccessorDeclaration, basePath, namespacesToInclude);
+    this.setAccessor = setAccessorDeclaration && new AccessorInfoDoc('set', this, setAccessorDeclaration, basePath, namespacesToInclude);
+    this.type = this.type || this.setAccessor && this.setAccessor.parameters[0].split(/:\s?/)[1] || '';
+    this.content = this.content || this.setAccessor && this.setAccessor.content || '';
+  }
 }

typescript/src/processors/readTypeScriptModules/index.spec.ts

@@ -2,11 +2,13 @@ import {Dgeni, DocCollection} from 'dgeni';
 import {Injector} from 'dgeni/lib/Injector';
 import { Symbol } from 'typescript';
 import {ReadTypeScriptModules} from '.';
+import {AccessorInfoDoc} from '../../api-doc-types/AccessorInfoDoc';
 import {ClassExportDoc} from '../../api-doc-types/ClassExportDoc';
 import {ExportDoc} from '../../api-doc-types/ExportDoc';
 import {InterfaceExportDoc} from '../../api-doc-types/InterfaceExportDoc';
 import {MethodMemberDoc} from '../../api-doc-types/MethodMemberDoc';
 import {ModuleDoc} from '../../api-doc-types/ModuleDoc';
+import {PropertyMemberDoc} from '../../api-doc-types/PropertyMemberDoc';
 const mockPackage = require('../../mocks/mockPackage');
 const path = require('canonical-path');
 
@@ -336,6 +338,113 @@ describe('readTypeScriptModules', () => {
         expect(readonlyProp.isReadonly).toBeTruthy();
       });
     });
+
+    describe('getters and setters', () => {
+      let docs: DocCollection;
+      let foo1: PropertyMemberDoc;
+      let foo1Getter: AccessorInfoDoc;
+      let foo1Setter: AccessorInfoDoc;
+      let foo2: PropertyMemberDoc;
+      let foo2Getter: AccessorInfoDoc;
+      let foo2Setter: AccessorInfoDoc;
+      let bar: PropertyMemberDoc;
+      let barGetter: AccessorInfoDoc;
+      let barSetter: AccessorInfoDoc;
+      let qux: PropertyMemberDoc;
+      let quxGetter: AccessorInfoDoc;
+      let quxSetter: AccessorInfoDoc;
+      let noType: PropertyMemberDoc;
+      let noTypeGetter: AccessorInfoDoc;
+      let noTypeSetter: AccessorInfoDoc;
+
+      beforeEach(() => {
+        processor.sourceFiles = ['gettersAndSetters.ts'];
+        docs = [];
+        processor.$process(docs);
+
+        foo1 = docs.find(doc => doc.name === 'foo1');
+        foo2 = docs.find(doc => doc.name === 'foo2');
+        bar = docs.find(doc => doc.name === 'bar');
+        qux = docs.find(doc => doc.name === 'qux');
+        noType = docs.find(doc => doc.name === 'noType');
+
+        foo1Getter = docs.find(doc => doc.name === 'foo1:get');
+        foo1Setter = docs.find(doc => doc.name === 'foo1:set');
+
+        foo2Getter = docs.find(doc => doc.name === 'foo2:get');
+        foo2Setter = docs.find(doc => doc.name === 'foo2:set');
+
+        barGetter = docs.find(doc => doc.name === 'bar:get');
+        barSetter = docs.find(doc => doc.name === 'bar:set');
+
+        quxGetter = docs.find(doc => doc.name === 'qux:get');
+        quxSetter = docs.find(doc => doc.name === 'qux:set');
+
+        noTypeGetter = docs.find(doc => doc.name === 'noType:get');
+        noTypeSetter = docs.find(doc => doc.name === 'noType:set');
+      });
+
+      it('should create a property member doc for property that has accessors', () => {
+        expect(foo1).toBeDefined();
+        expect(foo1.docType).toBe('member');
+        expect(foo2).toBeDefined();
+        expect(foo2.docType).toBe('member');
+        expect(bar).toBeDefined();
+        expect(bar.docType).toBe('member');
+        expect(qux).toBeDefined();
+        expect(qux.docType).toBe('member');
+      });
+
+      it('should create a doc for each accessor of a property', () => {
+        expect(foo1Getter).toBeDefined();
+        expect(foo1Getter.docType).toBe('get-accessor-info');
+        expect(foo1Getter.content).toEqual('');
+        expect(foo1Setter).toBeDefined();
+        expect(foo1Setter.docType).toBe('set-accessor-info');
+        expect(foo1Setter.content).toEqual('foo1 setter');
+        expect(foo2Getter).toBeDefined();
+        expect(foo2Getter.docType).toBe('get-accessor-info');
+        expect(foo2Getter.content).toEqual('foo2 getter');
+        expect(foo2Setter).toBeDefined();
+        expect(foo2Setter.docType).toBe('set-accessor-info');
+        expect(foo2Setter.content).toEqual('');
+        expect(barGetter).toBeDefined();
+        expect(barGetter.docType).toBe('get-accessor-info');
+        expect(barGetter.content).toEqual('bar getter');
+        expect(barSetter).toBeUndefined();
+        expect(quxGetter).toBeUndefined();
+        expect(quxSetter).toBeDefined();
+        expect(quxSetter.docType).toBe('set-accessor-info');
+        expect(quxSetter.content).toEqual('qux setter');
+      });
+
+      it('should compute the type of the property from its accessors', () => {
+        expect(foo1.type).toEqual('string');
+        expect(foo2.type).toEqual('string');
+        expect(bar.type).toEqual('number');
+        expect(qux.type).toEqual('object');
+        expect(noType.type).toEqual('string');
+      });
+
+      it('should compute the content of the property from its accessors', () => {
+        expect(foo1.content).toEqual('foo1 setter');
+        expect(foo2.content).toEqual('foo2 getter');
+        expect(bar.content).toEqual('bar getter');
+        expect(qux.content).toEqual('qux setter');
+        expect(noType.content).toEqual('This has no explicit getter return type');
+      });
+
+      it('should attach each accessor doc to its property doc', () => {
+        expect(foo1.getAccessor).toBe(foo1Getter);
+        expect(foo1.setAccessor).toBe(foo1Setter);
+        expect(foo2.getAccessor).toBe(foo2Getter);
+        expect(foo2.setAccessor).toBe(foo2Setter);
+        expect(bar.getAccessor).toBe(barGetter);
+        expect(bar.setAccessor).toBe(null);
+        expect(qux.getAccessor).toBe(null);
+        expect(qux.setAccessor).toBe(quxSetter);
+      });
+    });
   });
 
   describe('strip namespaces', () => {

typescript/src/processors/readTypeScriptModules/index.ts

@@ -16,6 +16,7 @@ import { InterfaceExportDoc } from '../../api-doc-types/InterfaceExportDoc';
 import { MemberDoc } from '../../api-doc-types/MemberDoc';
 import { MethodMemberDoc } from '../../api-doc-types/MethodMemberDoc';
 import { ModuleDoc } from '../../api-doc-types/ModuleDoc';
+import { PropertyMemberDoc } from '../../api-doc-types/PropertyMemberDoc';
 import { TypeAliasExportDoc } from '../../api-doc-types/TypeAliasExportDoc';
 
 import { expandSourceFiles, SourcePattern } from './SourcePattern';
@@ -151,6 +152,10 @@ export class ReadTypeScriptModules implements Processor {
       members.forEach(member => {
         docs.push(member);
         if (member instanceof MethodMemberDoc) member.overloads.forEach(overloadDoc => docs.push(overloadDoc));
+        if (member instanceof PropertyMemberDoc) {
+          if (member.getAccessor) docs.push(member.getAccessor);
+          if (member.setAccessor) docs.push(member.setAccessor);
+        }
       });
     }
   }