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

@@ -26,7 +26,7 @@ const signatureErrorDiagnostics = [
 ];
 
 /** List of classes of which the constructor signature has changed. */
-const signatureChangedClasses = getAllChanges(constructorChecks);
+const signatureChangeData = getAllChanges(constructorChecks);
 
 /**
  * Rule that visits every TypeScript new expression or super call and checks if the parameter
@@ -64,9 +64,19 @@ 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 (!signatureChangedClasses.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 owner-class of the constructor 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 (!signatureChangeData.includes(className) &&
+        !signatureClassNames.some(name => signatureChangeData.includes(name!))) {
       continue;
     }
 
@@ -120,3 +130,22 @@ function findConstructorNode(diagnostic: ts.Diagnostic, sourceFile: ts.SourceFil
 
   return resolvedNode;
 }
+
+/** Determines the class declaration of the specified 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;
+}

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

@@ -43,6 +43,9 @@ describe('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');