refactor(schematics): properly handle inherited constructors for signature checks

* Currently if someone extends an Angular Material class of which the signature has changed and the constructor is inherited, the constructor signature checks rule won't report the breaking change because the rule does not properly handle the inherited constructor.

Author: devversion

src/lib/schematics/update/rules/signature-check/constructorSignatureCheckRule.ts

@@ -60,9 +60,20 @@ function visitSourceFile(context: WalkContext<null>, program: ts.Program) {
     const className = classType.symbol && classType.symbol.name;
     const isNewExpression = ts.isNewExpression(node);
 
-    // TODO(devversion): Consider handling pass-through classes better.
-    // TODO(devversion): e.g. `export class CustomCalendar extends MatCalendar {}`
-    if (!constructorChecks.includes(className)) {
+    // Determine the class names of the actual construct signatures because we cannot assume
+    // that the diagnostic refers to a constructor of the actual expression. In case the constructor
+    // is inherited, we need to detect that the constructor comes from the inherited class and
+    // check if the inherited is added to the constructor checks upgrade data.
+    // e.g. `class CustomCalendar extends MatCalendar {}`.
+    const signatureClassNames = classType.getConstructSignatures()
+      .map(signature => getClassDeclarationOfSignature(signature))
+      .map(declaration => declaration && declaration.name ? declaration.name.text : null)
+      .filter(Boolean);
+
+    // Besides checking the signature class names, we need to check the actual class name because
+    // there can be classes without an explicit constructor.
+    if (!constructorChecks.includes(className) &&
+        !signatureClassNames.some(name => constructorChecks.includes(name!))) {
       continue;
     }
 
@@ -89,6 +100,25 @@ function getParameterTypesFromSignature(signature: ts.Signature, program: ts.Pro
     .map(typeNode => program.getTypeChecker().getTypeFromTypeNode(typeNode!));
 }
 
+/** Determines the class declaration of the given construct signature. */
+function getClassDeclarationOfSignature(signature: ts.Signature): ts.ClassDeclaration | null {
+  let node: ts.Node = signature.getDeclaration();
+
+  // Handle signatures which don't have an actual declaration. This happens if a class
+  // does not have an explicitly written constructor.
+  if (!node) {
+    return null;
+  }
+
+  while (!ts.isSourceFile(node = node.parent)) {
+    if (ts.isClassDeclaration(node)) {
+      return node;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Walks through each node of a source file in order to find a new-expression node or super-call
  * expression node that is captured by the specified diagnostic.

src/lib/schematics/update/test-cases/misc/constructor-checks.spec.ts

@@ -43,6 +43,9 @@ describe('v5 constructor checks', () => {
 
     expect(output).toMatch(/Found "MatSidenavContent".*super.*: super\((any, ){4}any\)/);
     expect(output).toMatch(/Found "MatSidenavContent".*: new \w+\((any, ){4}any\)/);
+
+    expect(output).toMatch(/Found "ExtendedDateAdapter".*super.*: super\(string, Platform\)/);
+    expect(output).toMatch(/Found "ExtendedDateAdapter".*: new \w+\(string, Platform\)/);
   });
 });
 

src/lib/schematics/update/test-cases/misc/constructor-checks_input.ts

@@ -64,6 +64,8 @@ class MatSidenavContent {
                _ngZone: any) {}
 }
 
+class ExtendedDateAdapter extends NativeDateAdapter {}
+
 /* Actual test case using the previously defined definitions. */
 
 class A extends NativeDateAdapter {
@@ -127,3 +129,11 @@ class G extends MatSidenavContent {
 }
 
 const _G = new MatSidenavContent({}, 'container');
+
+class H extends ExtendedDateAdapter {
+  constructor() {
+    super('myLocale');
+  }
+}
+
+const _H = new ExtendedDateAdapter('myLocale');