refactor(core): move google3 migration rules into single directory (#30956)

Moves all google3 migration tslint rules into a single directory.
This makes it easier to wire up multiple migration rules in
google3 without having to update the rule directories each time
a new migration is available.

PR Close #30956

packages/core/schematics/migrations/google3/BUILD.bazel

@@ -0,0 +1,19 @@
+load("//tools:defaults.bzl", "ts_library")
+
+ts_library(
+    name = "google3",
+    srcs = glob(["**/*.ts"]),
+    tsconfig = "//packages/core/schematics:tsconfig.json",
+    visibility = ["//packages/core/schematics/test:__pkg__"],
+    deps = [
+        "//packages/core/schematics/migrations/injectable-pipe",
+        "//packages/core/schematics/migrations/missing-injectable",
+        "//packages/core/schematics/migrations/missing-injectable/google3",
+        "//packages/core/schematics/migrations/static-queries",
+        "//packages/core/schematics/migrations/template-var-assignment",
+        "//packages/core/schematics/utils",
+        "//packages/core/schematics/utils/tslint",
+        "@npm//tslint",
+        "@npm//typescript",
+    ],
+)

packages/core/schematics/migrations/google3/explicitQueryTimingRule.ts

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {Replacement, RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+
+import {NgComponentTemplateVisitor} from '../../utils/ng_component_template';
+import {NgQueryResolveVisitor} from '../static-queries/angular/ng_query_visitor';
+import {QueryTiming} from '../static-queries/angular/query-definition';
+import {QueryUsageStrategy} from '../static-queries/strategies/usage_strategy/usage_strategy';
+import {getTransformedQueryCallExpr} from '../static-queries/transform';
+
+const FAILURE_MESSAGE = 'Query does not explicitly specify its timing. Read more here: ' +
+    'https://github.com/angular/angular/pull/28810';
+
+/**
+ * Rule that reports if an Angular "ViewChild" or "ContentChild" query is not explicitly
+ * specifying its timing. The rule also provides TSLint automatic replacements that can
+ * be applied in order to automatically migrate to the explicit query timing API.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    const typeChecker = program.getTypeChecker();
+    const queryVisitor = new NgQueryResolveVisitor(program.getTypeChecker());
+    const templateVisitor = new NgComponentTemplateVisitor(typeChecker);
+    const rootSourceFiles = program.getRootFileNames().map(f => program.getSourceFile(f) !);
+    const printer = ts.createPrinter();
+    const failures: RuleFailure[] = [];
+
+    // Analyze source files by detecting queries, class relations and component templates.
+    rootSourceFiles.forEach(sourceFile => {
+      queryVisitor.visitNode(sourceFile);
+      templateVisitor.visitNode(sourceFile);
+    });
+
+    const {resolvedQueries, classMetadata} = queryVisitor;
+
+    // Add all resolved templates to the class metadata so that we can also
+    // check component templates for static query usage.
+    templateVisitor.resolvedTemplates.forEach(template => {
+      if (classMetadata.has(template.container)) {
+        classMetadata.get(template.container) !.template = template;
+      }
+    });
+
+    const queries = resolvedQueries.get(sourceFile);
+    const usageStrategy = new QueryUsageStrategy(classMetadata, typeChecker);
+
+    // No queries detected for the given source file.
+    if (!queries) {
+      return [];
+    }
+
+    // Compute the query usage for all resolved queries and update the
+    // query definitions to explicitly declare the query timing (static or dynamic)
+    queries.forEach(q => {
+      const queryExpr = q.decorator.node.expression;
+      const {timing, message} = usageStrategy.detectTiming(q);
+      const result = getTransformedQueryCallExpr(q, timing, !!message);
+
+      if (!result) {
+        return;
+      }
+
+      const newText = printer.printNode(ts.EmitHint.Unspecified, result.node, sourceFile);
+
+      // Replace the existing query decorator call expression with the
+      // updated call expression node.
+      const fix = new Replacement(queryExpr.getStart(), queryExpr.getWidth(), newText);
+      const failureMessage = `${FAILURE_MESSAGE}. Based on analysis of the query it can be ` +
+          `marked as "{static: ${(timing === QueryTiming.STATIC).toString()}}".`;
+
+      failures.push(new RuleFailure(
+          sourceFile, queryExpr.getStart(), queryExpr.getEnd(), failureMessage, this.ruleName,
+          fix));
+    });
+
+    return failures;
+  }
+}

packages/core/schematics/migrations/google3/injectablePipeRule.ts

@@ -0,0 +1,55 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {Replacement, RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+
+import {InjectablePipeVisitor} from '../injectable-pipe/angular/injectable_pipe_visitor';
+import {INJECTABLE_DECORATOR_NAME, addImport, getNamedImports} from '../injectable-pipe/util';
+
+
+/**
+ * TSLint rule that flags `@Pipe` classes that haven't been marked as `@Injectable`.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    const visitor = new InjectablePipeVisitor(program.getTypeChecker());
+    const printer = ts.createPrinter();
+    const failures: RuleFailure[] = [];
+
+    visitor.visitNode(sourceFile);
+
+    visitor.missingInjectablePipes.forEach(data => {
+      const {pipeDecorator, importDeclarationMissingImport} = data;
+      const fixes = [new Replacement(
+          pipeDecorator.getStart(), pipeDecorator.getWidth(),
+          `@${INJECTABLE_DECORATOR_NAME}()\n${pipeDecorator.getText()}`)];
+
+      if (importDeclarationMissingImport) {
+        const namedImports = getNamedImports(importDeclarationMissingImport);
+
+        // Add another fix that'll add the missing import.
+        if (namedImports) {
+          fixes.push(new Replacement(
+              namedImports.getStart(), namedImports.getWidth(),
+              printer.printNode(
+                  ts.EmitHint.Unspecified, addImport(namedImports, INJECTABLE_DECORATOR_NAME),
+                  sourceFile)));
+        }
+      }
+
+      // Add a failure on Pipe decorators that are missing the Injectable decorator.
+      failures.push(new RuleFailure(
+          sourceFile, pipeDecorator.getStart(), pipeDecorator.getWidth(),
+          'Classes with @Pipe should be decorated with @Injectable so that they can be injected.',
+          this.ruleName, fixes));
+    });
+
+    return failures;
+  }
+}

packages/core/schematics/migrations/google3/noMissingInjectableRule.ts

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+
+import {TslintUpdateRecorder} from '../missing-injectable/google3/tslint_update_recorder';
+import {NgModuleCollector} from '../missing-injectable/module_collector';
+import {MissingInjectableTransform} from '../missing-injectable/transform';
+
+
+/**
+ * TSLint rule that flags classes which are declared as providers in NgModules but
+ * aren't decorated with any Angular decorator.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    const ruleName = this.ruleName;
+    const typeChecker = program.getTypeChecker();
+    const sourceFiles = program.getSourceFiles().filter(
+        s => !s.isDeclarationFile && !program.isSourceFileFromExternalLibrary(s));
+    const moduleCollector = new NgModuleCollector(typeChecker);
+    const failures: RuleFailure[] = [];
+
+    // Analyze source files by detecting all NgModule definitions.
+    sourceFiles.forEach(sourceFile => moduleCollector.visitNode(sourceFile));
+
+    const {resolvedModules} = moduleCollector;
+    const transformer = new MissingInjectableTransform(typeChecker, getUpdateRecorder);
+    const updateRecorders = new Map<ts.SourceFile, TslintUpdateRecorder>();
+
+    resolvedModules.forEach(module => {
+      transformer.migrateModule(module).forEach(({message, node}) => {
+        // Only report failures for the current source file that is visited.
+        if (node.getSourceFile() === sourceFile) {
+          failures.push(
+              new RuleFailure(node.getSourceFile(), node.getStart(), 0, message, ruleName));
+        }
+      });
+    });
+
+    // Record the changes collected in the import manager and NgModule manager.
+    transformer.recordChanges();
+
+    if (updateRecorders.has(sourceFile)) {
+      failures.push(...updateRecorders.get(sourceFile) !.failures);
+    }
+
+    return failures;
+
+    /** Gets the update recorder for the specified source file. */
+    function getUpdateRecorder(sourceFile: ts.SourceFile): TslintUpdateRecorder {
+      if (updateRecorders.has(sourceFile)) {
+        return updateRecorders.get(sourceFile) !;
+      }
+      const recorder = new TslintUpdateRecorder(ruleName, sourceFile);
+      updateRecorders.set(sourceFile, recorder);
+      return recorder;
+    }
+  }
+}

packages/core/schematics/migrations/google3/noTemplateVariableAssignmentRule.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 {RuleFailure, Rules} from 'tslint';
+import * as ts from 'typescript';
+
+import {NgComponentTemplateVisitor} from '../../utils/ng_component_template';
+import {createHtmlSourceFile} from '../../utils/tslint/tslint_html_source_file';
+import {analyzeResolvedTemplate} from '../template-var-assignment/analyze_template';
+
+const FAILURE_MESSAGE = 'Found assignment to template variable. This does not work with Ivy and ' +
+    'needs to be updated.';
+
+/**
+ * Rule that reports if an Angular template contains property assignments to template variables.
+ */
+export class Rule extends Rules.TypedRule {
+  applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): RuleFailure[] {
+    const typeChecker = program.getTypeChecker();
+    const templateVisitor = new NgComponentTemplateVisitor(typeChecker);
+    const failures: RuleFailure[] = [];
+
+    // Analyze the current source files by detecting all referenced HTML templates.
+    templateVisitor.visitNode(sourceFile);
+
+    const {resolvedTemplates} = templateVisitor;
+
+    // Analyze each resolved template and print a warning for property writes to
+    // template variables.
+    resolvedTemplates.forEach(template => {
+      const filePath = template.filePath;
+      const nodes = analyzeResolvedTemplate(template);
+      const templateFile =
+          template.inline ? sourceFile : createHtmlSourceFile(filePath, template.content);
+
+      if (!nodes) {
+        return;
+      }
+
+      nodes.forEach(n => {
+        failures.push(new RuleFailure(
+            templateFile, template.start + n.start, template.start + n.end, FAILURE_MESSAGE,
+            this.ruleName));
+      });
+    });
+
+    return failures;
+  }
+}