Inheritance support - Method inheritance for classes.

Author: cesarParra

docs/Misc-Group/ChildClass.md

@@ -34,4 +34,22 @@ This is a protected string, use carefully.
 ---
 ## Methods
 ### `doSomething()`
+### `override overridableMethodOverridden()`
+
+This method was overridden.
+
+#### Return
+
+**Type**
+
+String
+
+**Description**
+
+A String.
+
+### `overridableMethod()`
+
+*Inherited*
+
 ---

docs/Misc-Group/ParentClass.md

@@ -33,4 +33,5 @@ This is a protected string, use carefully.
 ---
 ## Methods
 ### `overridableMethod()`
+### `overridableMethodOverridden()`
 ---

examples/force-app/main/default/classes/ChildClass.cls

@@ -2,4 +2,12 @@ public class ChildClass extends ParentClass {
     public void doSomething() {
         System.debug('Do something');
     }
+
+    /**
+     * @description This method was overridden.
+     * @return A String.
+     */
+    public override String overridableMethodOverridden() {
+        return '';
+    }
 }

examples/force-app/main/default/classes/ParentClass.cls

@@ -9,4 +9,8 @@ public virtual class ParentClass extends GrandparentClass{
     public virtual String overridableMethod() {
         return '';
     }
+
+    public virtual String overridableMethodOverridden() {
+        return '';
+    }
 }

src/model/inheritance.ts

@@ -0,0 +1,7 @@
+import { FieldMirror, MethodMirror, PropertyMirror } from '@cparra/apex-reflection';
+
+export type InheritanceSupport = { inherited: boolean };
+export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
+export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
+export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
+export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;

src/model/markdown-generation-util/field-declaration-util.ts

@@ -1,10 +1,5 @@
 import { MarkdownFile } from '../markdown-file';
-import { FieldMirror, PropertyMirror } from '@cparra/apex-reflection';
-
-type InheritanceSupport = { inherited: boolean };
-type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
-type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
-type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;
+import { FieldMirrorWithInheritance, FieldOrProperty, PropertyMirrorWithInheritance } from '../inheritance';
 
 export function declareField(
   markdownFile: MarkdownFile,

src/model/markdown-generation-util/method-declaration-util.ts

@@ -1,17 +1,29 @@
-import { ConstructorMirror, DocComment, MethodMirror } from '@cparra/apex-reflection';
+import { ConstructorMirror, DocComment } from '@cparra/apex-reflection';
 import { MarkdownFile } from '../markdown-file';
 import { ParameterMirror } from '@cparra/apex-reflection/index';
 import { addCustomDocCommentAnnotations } from './doc-comment-annotation-util';
+import { MethodMirrorWithInheritance } from '../inheritance';
 
 export function declareMethod(
   markdownFile: MarkdownFile,
-  methods: ConstructorMirror[] | MethodMirror[],
+  methods: ConstructorMirror[] | MethodMirrorWithInheritance[],
   startingHeadingLevel: number,
   className = '',
 ): void {
   methods.forEach((currentMethod) => {
-    const signatureName = isMethod(currentMethod) ? (currentMethod as MethodMirror).name : className;
+    const signatureName = isMethod(currentMethod) ? (currentMethod as MethodMirrorWithInheritance).name : className;
     markdownFile.addTitle(`\`${buildSignature(signatureName, currentMethod)}\``, startingHeadingLevel + 2);
+
+    // Inheritance tag
+    if (isMethod(currentMethod)) {
+      const asMethodMirror = currentMethod as MethodMirrorWithInheritance;
+      if (asMethodMirror.inherited) {
+        markdownFile.addBlankLine();
+        markdownFile.addText('*Inherited*');
+        markdownFile.addBlankLine();
+      }
+    }
+
     currentMethod.annotations.forEach((annotation) => {
       markdownFile.addBlankLine();
       markdownFile.addText(`\`${annotation.type.toUpperCase()}\``);
@@ -28,7 +40,7 @@ export function declareMethod(
     }
 
     if (isMethod(currentMethod)) {
-      addReturns(markdownFile, currentMethod as MethodMirror, startingHeadingLevel);
+      addReturns(markdownFile, currentMethod as MethodMirrorWithInheritance, startingHeadingLevel);
     }
 
     addThrowsBlock(markdownFile, currentMethod, startingHeadingLevel);
@@ -53,8 +65,8 @@ type DocCommentAware = {
 
 function buildSignature(name: string, parameterAware: ParameterAware): string {
   let signature = `${name}(`;
-  if (isMethod(parameterAware) && (parameterAware as MethodMirror).memberModifiers.length) {
-    signature = (parameterAware as MethodMirror).memberModifiers.join(' ') + ' ' + signature;
+  if (isMethod(parameterAware) && (parameterAware as MethodMirrorWithInheritance).memberModifiers.length) {
+    signature = (parameterAware as MethodMirrorWithInheritance).memberModifiers.join(' ') + ' ' + signature;
   }
   const signatureParameters = parameterAware.parameters.map((param) => `${param.type} ${param.name}`);
   signature += signatureParameters.join(', ');
@@ -63,7 +75,7 @@ function buildSignature(name: string, parameterAware: ParameterAware): string {
 
 function addParameters(
   markdownFile: MarkdownFile,
-  methodModel: MethodMirror | ConstructorMirror,
+  methodModel: MethodMirrorWithInheritance | ConstructorMirror,
   startingHeadingLevel: number,
 ) {
   if (!methodModel.docComment?.paramAnnotations.length) {
@@ -83,7 +95,11 @@ function addParameters(
   markdownFile.addBlankLine();
 }
 
-function addReturns(markdownFile: MarkdownFile, methodModel: MethodMirror, startingHeadingLevel: number) {
+function addReturns(
+  markdownFile: MarkdownFile,
+  methodModel: MethodMirrorWithInheritance,
+  startingHeadingLevel: number,
+) {
   if (!methodModel.docComment?.returnAnnotation) {
     return;
   }
@@ -127,6 +143,8 @@ function addExample(markdownFile: MarkdownFile, docCommentAware: DocCommentAware
   markdownFile.addBlankLine();
 }
 
-function isMethod(method: MethodMirror | ConstructorMirror | ParameterAware): method is ConstructorMirror {
-  return (method as MethodMirror).type !== undefined;
+function isMethod(
+  method: MethodMirrorWithInheritance | ConstructorMirror | ParameterAware,
+): method is ConstructorMirror {
+  return (method as MethodMirrorWithInheritance).type !== undefined;
 }

src/model/markdown-type-file.ts

@@ -2,17 +2,16 @@ import {
   ClassMirror,
   ConstructorMirror,
   EnumMirror,
-  FieldMirror,
   InterfaceMirror,
   MethodMirror,
-  PropertyMirror,
   Type,
 } from '@cparra/apex-reflection';
 import { WalkerFactory } from '../service/walkers/walker-factory';
 import { WalkerListener } from '../service/walkers/walker';
 import { MarkdownFile } from './markdown-file';
 import { declareType, declareMethod, declareField } from './markdown-generation-util';
 import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
+import { FieldMirrorWithInheritance, MethodMirrorWithInheritance, PropertyMirrorWithInheritance } from './inheritance';
 
 interface GroupAware {
   group?: string;
@@ -42,12 +41,12 @@ export class MarkdownTypeFile extends MarkdownFile implements WalkerListener {
     this.declareMethodWithGroupings(constructors, className);
   }
 
-  public onFieldsDeclaration(fields: FieldMirror[]): void {
+  public onFieldsDeclaration(fields: FieldMirrorWithInheritance[]): void {
     this.addTitle('Fields', this.headingLevel + 1);
     this.declareFieldOrProperty(fields);
   }
 
-  public onPropertiesDeclaration(properties: PropertyMirror[]): void {
+  public onPropertiesDeclaration(properties: PropertyMirrorWithInheritance[]): void {
     this.addTitle('Properties', this.headingLevel + 1);
     this.declareFieldOrProperty(properties);
   }
@@ -90,7 +89,10 @@ export class MarkdownTypeFile extends MarkdownFile implements WalkerListener {
     return !!groupAware.find((current) => !!current.group);
   }
 
-  private declareMethodWithGroupings(methods: ConstructorMirror[] | MethodMirror[], className = ''): void {
+  private declareMethodWithGroupings(
+    methods: ConstructorMirror[] | MethodMirrorWithInheritance[],
+    className = '',
+  ): void {
     const hasGroupings = this.hasGroupings(methods);
     if (!hasGroupings) {
       declareMethod(this, methods, this.headingLevel, className);
@@ -105,15 +107,17 @@ export class MarkdownTypeFile extends MarkdownFile implements WalkerListener {
     }
   }
 
-  private declareFieldOrProperty(fieldsOrProperties: FieldMirror[] | PropertyMirror[]): void {
+  private declareFieldOrProperty(
+    fieldsOrProperties: FieldMirrorWithInheritance[] | PropertyMirrorWithInheritance[],
+  ): void {
     const hasGroupings = this.hasGroupings(fieldsOrProperties);
     if (!hasGroupings) {
       declareField(this, fieldsOrProperties, this.headingLevel, false);
     } else {
       const groupedFields = this.group(fieldsOrProperties);
       for (const key in groupedFields) {
         this.startGroup(key);
-        const fieldsForGroup = groupedFields[key] as FieldMirror[];
+        const fieldsForGroup = groupedFields[key] as FieldMirrorWithInheritance[];
         declareField(this, fieldsForGroup, this.headingLevel, true);
         this.endGroup();
       }

src/service/parser.ts

@@ -1,4 +1,11 @@
-import { Type, ReflectionResult, ClassMirror, FieldMirror, PropertyMirror } from '@cparra/apex-reflection';
+import {
+  Type,
+  ReflectionResult,
+  ClassMirror,
+  FieldMirror,
+  PropertyMirror,
+  MethodMirror,
+} from '@cparra/apex-reflection';
 import ApexBundle from '../model/apex-bundle';
 import MetadataProcessor from './metadata-processor';
 import { Logger } from '../util/logger';
@@ -7,6 +14,8 @@ export interface TypeParser {
   parse(reflect: (apexBundle: ApexBundle) => ReflectionResult): Type[];
 }
 
+type NameAware = { name: string };
+
 export class RawBodyParser implements TypeParser {
   constructor(public typeBundles: ApexBundle[]) {}
 
@@ -74,6 +83,7 @@ export class RawBodyParser implements TypeParser {
 
     currentClass.fields = [...currentClass.fields, ...this.getInheritedFields(parentAsClass, currentClass)];
     currentClass.properties = [...currentClass.properties, ...this.getInheritedProperties(parentAsClass, currentClass)];
+    currentClass.methods = [...currentClass.methods, ...this.getInheritedMethods(parentAsClass, currentClass)];
     return currentClass;
   }
 
@@ -103,7 +113,20 @@ export class RawBodyParser implements TypeParser {
     return parentProperties;
   }
 
-  memberExists(members: FieldMirror[] | PropertyMirror[], fieldName: string): boolean {
+  private getInheritedMethods(parentAsClass: ClassMirror, currentClass: ClassMirror) {
+    const parentMethods = parentAsClass.methods
+      // Filter out private methods
+      .filter((currentMethod) => currentMethod.access_modifier.toLowerCase() !== 'private')
+      // Filter out methods that also exist on the child
+      .filter((currentMethod) => !this.memberExists(currentClass.methods, currentMethod.name))
+      .map((currentMethod) => ({
+        ...currentMethod,
+        inherited: true,
+      }));
+    return parentMethods;
+  }
+
+  memberExists(members: NameAware[], fieldName: string): boolean {
     const fieldNames = members.map((currentMember) => currentMember.name);
     return fieldNames.includes(fieldName);
   }