refactor(schematics): cleanup remaining rules

* Fixes that the `method-check` rule does not throw if the type of a class instantiation could not be determined.
* Cleans up the remaining rules.
* Removes the `exportAs` rule for now. Since it's unused and also extremely brittle (search & replace).

Author: devversion

src/lib/schematics/update/material/data/export-as-names.ts

@@ -43,7 +43,7 @@ export const methodCallChecks = transformChanges<MaterialMethodCallData>([
         invalidArgCounts: [
           {
             count: 2,
-            message: '"g{{default}}" is now required as a third argument'
+            message: '"g{{defaults}}" is now required as a third argument'
           }
         ]
       }

src/lib/schematics/update/material/data/method-call-checks.ts

@@ -9,7 +9,8 @@
 import {bold, green, red} from 'chalk';
 import {ProgramAwareRuleWalker, RuleFailure, Rules} from 'tslint';
 import * as ts from 'typescript';
-import {MaterialPropertyNameData, propertyNames} from '../material/data/property-names';
+import {MaterialPropertyNameData, propertyNames} from '../../material/data/property-names';
+import {determineBaseTypes} from '../../typescript/base-types';
 
 /**
  * Map of classes that have been updated. Each class name maps to the according property change
@@ -34,7 +35,7 @@ export class Rule extends Rules.TypedRule {
 export class Walker extends ProgramAwareRuleWalker {
 
   visitClassDeclaration(node: ts.ClassDeclaration) {
-    const baseTypes = this._determineBaseTypes(node);
+    const baseTypes = determineBaseTypes(node);
 
     if (!baseTypes) {
       return;
@@ -44,24 +45,11 @@ export class Walker extends ProgramAwareRuleWalker {
       const data = changedClassesMap.get(typeName);
 
       if (data) {
-        this.addFailureAtNode(node,
-          `Found class "${bold(node.name.text)}" which extends class ` +
-          `"${bold(typeName)}". Please note that the base class property ` +
-          `"${red(data.replace)}" has changed to "${green(data.replaceWith)}". ` +
-          `You may need to update your class as well`);
+        this.addFailureAtNode(node, `Found class "${bold(node.name.text)}" which extends class ` +
+            `"${bold(typeName)}". Please note that the base class property ` +
+            `"${red(data.replace)}" has changed to "${green(data.replaceWith)}". ` +
+            `You may need to update your class as well`);
       }
     });
   }
-
-  private _determineBaseTypes(node: ts.ClassDeclaration): string[] | null {
-    if (!node.heritageClauses) {
-      return null;
-    }
-
-    return node.heritageClauses
-      .reduce((types, clause) => types.concat(clause.types), [])
-      .map(typeExpression => typeExpression.expression)
-      .filter(expression => expression && ts.isIdentifier(expression))
-      .map(identifier => identifier.text);
-  }
 }

src/lib/schematics/update/rules/checkClassDeclarationMiscRule.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {bold, green} from 'chalk';
+import {ProgramAwareRuleWalker, RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+import {determineBaseTypes} from '../../typescript/base-types';
+
+/**
+ * Rule that checks for classes that extend Angular Material or CDK classes which have
+ * changed their API.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    return this.applyWithWalker(new Walker(sourceFile, this.getOptions(), program));
+  }
+}
+
+export class Walker extends ProgramAwareRuleWalker {
+
+  visitClassDeclaration(node: ts.ClassDeclaration) {
+    const baseTypes = determineBaseTypes(node);
+
+    if (!baseTypes) {
+      return;
+    }
+
+    if (baseTypes.includes('MatFormFieldControl')) {
+      const hasFloatLabelMember = node.members
+          .find(member => member.name && member.name.getText() === 'shouldFloatLabel');
+
+      if (!hasFloatLabelMember) {
+        this.addFailureAtNode(node, `Found class "${bold(node.name.text)}" which extends ` +
+            `"${bold('MatFormFieldControl')}". This class must define ` +
+            `"${green('shouldLabelFloat')}" which is now a required property.`);
+      }
+    }
+  }
+}

src/lib/schematics/update/rules/checkMethodCallsRule.ts

@@ -0,0 +1,92 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import {bold} from 'chalk';
+import {ProgramAwareRuleWalker, RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+import {color} from '../../material/color';
+import {methodCallChecks} from '../../material/data/method-call-checks';
+
+/**
+ * Rule that visits every TypeScript call expression or TypeScript new expression and checks
+ * if the argument count is invalid and needs to be *manually* updated.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    return this.applyWithWalker(new Walker(sourceFile, this.getOptions(), program));
+  }
+}
+
+export class Walker extends ProgramAwareRuleWalker {
+
+  visitNewExpression(expression: ts.NewExpression) {
+    const classType = this.getTypeChecker().getTypeAtLocation(expression);
+
+    if (classType && classType.symbol) {
+      this.checkConstructor(expression, classType.symbol.name);
+    }
+  }
+
+  visitCallExpression(node: ts.CallExpression) {
+    if (node.expression.kind === ts.SyntaxKind.SuperKeyword) {
+      const superClassType = this.getTypeChecker().getTypeAtLocation(node.expression);
+      const superClassName = superClassType.symbol && superClassType.symbol.name;
+
+      if (superClassName) {
+        this.checkConstructor(node, superClassName);
+      }
+    }
+
+    if (ts.isPropertyAccessExpression(node.expression)) {
+      this._checkPropertyAccessMethodCall(node);
+    }
+
+    return super.visitCallExpression(node);
+  }
+
+  private _checkPropertyAccessMethodCall(node: ts.CallExpression) {
+    const propertyAccess = node.expression as ts.PropertyAccessExpression;
+
+    if (!ts.isIdentifier(propertyAccess.name)) {
+      return;
+    }
+
+    const hostType = this.getTypeChecker().getTypeAtLocation(propertyAccess.expression);
+    const hostTypeName = hostType.symbol && hostType.symbol.name;
+    const methodName = propertyAccess.name.text;
+
+    if (!hostTypeName) {
+      return;
+    }
+
+    const failure = methodCallChecks
+        .filter(data => data.method === methodName && data.className === hostTypeName)
+        .map(data => data.invalidArgCounts.find(f => f.count === node.arguments.length))[0];
+
+    if (!failure) {
+      return;
+    }
+
+    this.addFailureAtNode(node, `Found call to "${bold(hostTypeName + '.' + methodName)}" ` +
+        `with ${bold(`${failure.count}`)} arguments. Message: ${color(failure.message)}`);
+  }
+
+  private checkConstructor(node: ts.NewExpression | ts.CallExpression, className: string) {
+    const argumentsLength = node.arguments ? node.arguments.length : 0;
+    const failure = methodCallChecks
+        .filter(data => data.method === 'constructor' && data.className === className)
+        .map(data => data.invalidArgCounts.find(f => f.count === argumentsLength))[0];
+
+    if (!failure) {
+      return;
+    }
+
+    this.addFailureAtNode(node, `Found "${bold(className)}" constructed with ` +
+        `${bold(`${failure.count}`)} arguments. Message: ${color(failure.message)}`);
+  }
+}