@dugararchit/cdk 0.0.0-dugararchit

package/schematics/schematics/ng-update/index.ts

@@ -0,0 +1,113 @@
+/**
+ * @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 {Rule, SchematicContext} from '@angular-devkit/schematics';
+import {TargetVersion} from '../update-tool/target-version';
+import {cdkUpgradeData} from './upgrade-data';
+import {createMigrationSchematicRule, NullableDevkitMigration} from './devkit-migration-rule';
+import {TildeImportMigration} from './migrations/tilde-import-v13/tilde-import-migration';
+
+const cdkMigrations: NullableDevkitMigration[] = [TildeImportMigration];
+
+/** Entry point for the migration schematics with target of Angular CDK 6.0.0 */
+export function updateToV6(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V6,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 7.0.0 */
+export function updateToV7(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V7,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 8.0.0 */
+export function updateToV8(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V8,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 9.0.0 */
+export function updateToV9(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V9,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 10.0.0 */
+export function updateToV10(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V10,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 11.0.0 */
+export function updateToV11(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V11,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 12.0.0 */
+export function updateToV12(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V12,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Entry point for the migration schematics with target of Angular CDK 13.0.0 */
+export function updateToV13(): Rule {
+  return createMigrationSchematicRule(
+    TargetVersion.V13,
+    cdkMigrations,
+    cdkUpgradeData,
+    onMigrationComplete,
+  );
+}
+
+/** Function that will be called when the migration completed. */
+function onMigrationComplete(
+  context: SchematicContext,
+  targetVersion: TargetVersion,
+  hasFailures: boolean,
+) {
+  context.logger.info('');
+  context.logger.info(`  ✓  Updated Angular CDK to ${targetVersion}`);
+  context.logger.info('');
+
+  if (hasFailures) {
+    context.logger.warn(
+      '  ⚠  Some issues were detected but could not be fixed automatically. Please check the ' +
+        'output above and fix these issues manually.',
+    );
+  }
+}

package/schematics/schematics/ng-update/migrations/attribute-selectors.ts

@@ -0,0 +1,83 @@
+/**
+ * @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 * as ts from 'typescript';
+import {WorkspacePath} from '../../update-tool/file-system';
+import {ResolvedResource} from '../../update-tool/component-resource-collector';
+import {Migration} from '../../update-tool/migration';
+import {AttributeSelectorUpgradeData} from '../data/attribute-selectors';
+import {findAllSubstringIndices} from '../typescript/literal';
+import {getVersionUpgradeData, UpgradeData} from '../upgrade-data';
+
+/**
+ * Migration that walks through every string literal, template and stylesheet
+ * in order to switch deprecated attribute selectors to the updated selector.
+ */
+export class AttributeSelectorsMigration extends Migration<UpgradeData> {
+  /** Required upgrade changes for specified target version. */
+  data = getVersionUpgradeData(this, 'attributeSelectors');
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled: boolean = this.data.length !== 0;
+
+  override visitNode(node: ts.Node) {
+    if (ts.isStringLiteralLike(node)) {
+      this._visitStringLiteralLike(node);
+    }
+  }
+
+  override visitTemplate(template: ResolvedResource) {
+    this.data.forEach(selector => {
+      findAllSubstringIndices(template.content, selector.replace)
+        .map(offset => template.start + offset)
+        .forEach(start => this._replaceSelector(template.filePath, start, selector));
+    });
+  }
+
+  override visitStylesheet(stylesheet: ResolvedResource): void {
+    this.data.forEach(selector => {
+      const currentSelector = `[${selector.replace}]`;
+      const updatedSelector = `[${selector.replaceWith}]`;
+
+      findAllSubstringIndices(stylesheet.content, currentSelector)
+        .map(offset => stylesheet.start + offset)
+        .forEach(start =>
+          this._replaceSelector(stylesheet.filePath, start, {
+            replace: currentSelector,
+            replaceWith: updatedSelector,
+          }),
+        );
+    });
+  }
+
+  private _visitStringLiteralLike(literal: ts.StringLiteralLike) {
+    if (literal.parent && literal.parent.kind !== ts.SyntaxKind.CallExpression) {
+      return;
+    }
+
+    const literalText = literal.getText();
+    const filePath = this.fileSystem.resolve(literal.getSourceFile().fileName);
+
+    this.data.forEach(selector => {
+      findAllSubstringIndices(literalText, selector.replace)
+        .map(offset => literal.getStart() + offset)
+        .forEach(start => this._replaceSelector(filePath, start, selector));
+    });
+  }
+
+  private _replaceSelector(
+    filePath: WorkspacePath,
+    start: number,
+    data: AttributeSelectorUpgradeData,
+  ) {
+    this.fileSystem
+      .edit(filePath)
+      .remove(start, data.replace.length)
+      .insertRight(start, data.replaceWith);
+  }
+}

package/schematics/schematics/ng-update/migrations/class-inheritance.ts

@@ -0,0 +1,63 @@
+/**
+ * @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 * as ts from 'typescript';
+import {Migration} from '../../update-tool/migration';
+import {PropertyNameUpgradeData} from '../data/property-names';
+import {determineBaseTypes} from '../typescript/base-types';
+import {getVersionUpgradeData, UpgradeData} from '../upgrade-data';
+
+/**
+ * Migration that identifies class declarations that extend CDK or Material classes
+ * which had a public property change.
+ */
+export class ClassInheritanceMigration extends Migration<UpgradeData> {
+  /**
+   * Map of classes that have been updated. Each class name maps to the according property
+   * change data.
+   */
+  propertyNames = new Map<string, PropertyNameUpgradeData>();
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled = this.propertyNames.size !== 0;
+
+  override init(): void {
+    getVersionUpgradeData(this, 'propertyNames')
+      .filter(data => data.limitedTo && data.limitedTo.classes)
+      .forEach(data => data.limitedTo.classes.forEach(name => this.propertyNames.set(name, data)));
+  }
+
+  override visitNode(node: ts.Node): void {
+    if (ts.isClassDeclaration(node)) {
+      this._visitClassDeclaration(node);
+    }
+  }
+
+  private _visitClassDeclaration(node: ts.ClassDeclaration) {
+    const baseTypes = determineBaseTypes(node);
+    const className = node.name ? node.name.text : '{unknown-name}';
+
+    if (!baseTypes) {
+      return;
+    }
+
+    baseTypes.forEach(typeName => {
+      const data = this.propertyNames.get(typeName);
+
+      if (data) {
+        this.createFailureAtNode(
+          node,
+          `Found class "${className}" which extends class ` +
+            `"${typeName}". Please note that the base class property ` +
+            `"${data.replace}" has changed to "${data.replaceWith}". ` +
+            `You may need to update your class as well.`,
+        );
+      }
+    });
+  }
+}

package/schematics/schematics/ng-update/migrations/class-names.ts

@@ -0,0 +1,107 @@
+/**
+ * @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 * as ts from 'typescript';
+import {Migration} from '../../update-tool/migration';
+
+import {ClassNameUpgradeData} from '../data';
+import {
+  isExportSpecifierNode,
+  isImportSpecifierNode,
+  isNamespaceImportNode,
+} from '../typescript/imports';
+import {
+  isMaterialExportDeclaration,
+  isMaterialImportDeclaration,
+} from '../typescript/module-specifiers';
+import {getVersionUpgradeData, UpgradeData} from '../upgrade-data';
+
+/**
+ * Migration that walks through every identifier that is part of Angular Material or thr CDK
+ * and replaces the outdated name with the new one if specified in the upgrade data.
+ */
+// TODO: rework this rule to identify symbols using the import identifier resolver. This
+// makes it more robust, less AST convoluted and is more TypeScript AST idiomatic. COMP-300.
+export class ClassNamesMigration extends Migration<UpgradeData> {
+  /** Change data that upgrades to the specified target version. */
+  data: ClassNameUpgradeData[] = getVersionUpgradeData(this, 'classNames');
+
+  /**
+   * List of identifier names that have been imported from `@dugararchit/material` or `@dugararchit/cdk`
+   * in the current source file and therefore can be considered trusted.
+   */
+  trustedIdentifiers: Set<string> = new Set();
+
+  /** List of namespaces that have been imported from `@dugararchit/material` or `@dugararchit/cdk`. */
+  trustedNamespaces: Set<string> = new Set();
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled = this.data.length !== 0;
+
+  override visitNode(node: ts.Node): void {
+    if (ts.isIdentifier(node)) {
+      this._visitIdentifier(node);
+    }
+  }
+
+  /** Method that is called for every identifier inside of the specified project. */
+  private _visitIdentifier(identifier: ts.Identifier) {
+    // For identifiers that aren't listed in the className data, the whole check can be
+    // skipped safely.
+    if (!this.data.some(data => data.replace === identifier.text)) {
+      return;
+    }
+
+    // For namespace imports that are referring to Angular Material or the CDK, we store the
+    // namespace name in order to be able to safely find identifiers that don't belong to the
+    // developer's application.
+    if (isNamespaceImportNode(identifier) && isMaterialImportDeclaration(identifier)) {
+      this.trustedNamespaces.add(identifier.text);
+
+      return this._createFailureWithReplacement(identifier);
+    }
+
+    // For export declarations that are referring to Angular Material or the CDK, the identifier
+    // can be immediately updated to the new name.
+    if (isExportSpecifierNode(identifier) && isMaterialExportDeclaration(identifier)) {
+      return this._createFailureWithReplacement(identifier);
+    }
+
+    // For import declarations that are referring to Angular Material or the CDK, the name of
+    // the import identifiers. This allows us to identify identifiers that belong to Material and
+    // the CDK, and we won't accidentally touch a developer's identifier.
+    if (isImportSpecifierNode(identifier) && isMaterialImportDeclaration(identifier)) {
+      this.trustedIdentifiers.add(identifier.text);
+
+      return this._createFailureWithReplacement(identifier);
+    }
+
+    // In case the identifier is part of a property access expression, we need to verify that the
+    // property access originates from a namespace that has been imported from Material or the CDK.
+    if (ts.isPropertyAccessExpression(identifier.parent)) {
+      const expression = identifier.parent.expression;
+
+      if (ts.isIdentifier(expression) && this.trustedNamespaces.has(expression.text)) {
+        return this._createFailureWithReplacement(identifier);
+      }
+    } else if (this.trustedIdentifiers.has(identifier.text)) {
+      return this._createFailureWithReplacement(identifier);
+    }
+  }
+
+  /** Creates a failure and replacement for the specified identifier. */
+  private _createFailureWithReplacement(identifier: ts.Identifier) {
+    const classData = this.data.find(data => data.replace === identifier.text)!;
+    const filePath = this.fileSystem.resolve(identifier.getSourceFile().fileName);
+
+    this.fileSystem
+      .edit(filePath)
+      .remove(identifier.getStart(), identifier.getWidth())
+      .insertRight(identifier.getStart(), classData.replaceWith);
+  }
+}

package/schematics/schematics/ng-update/migrations/constructor-signature.ts

@@ -0,0 +1,170 @@
+/**
+ * @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 * as ts from 'typescript';
+import {Migration} from '../../update-tool/migration';
+import {getAllChanges} from '../../update-tool/version-changes';
+import {UpgradeData} from '../upgrade-data';
+
+/**
+ * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid
+ * new expression or super call signatures. See the list of diagnostics here:
+ *
+ * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
+ */
+const signatureErrorDiagnostics = [
+  // Type not assignable error diagnostic.
+  2345,
+  // Constructor argument length invalid diagnostics
+  2554, 2555, 2556, 2557,
+];
+
+/**
+ * Migration that visits every TypeScript new expression or super call and checks if
+ * the parameter type signature is invalid and needs to be updated manually.
+ */
+export class ConstructorSignatureMigration extends Migration<UpgradeData> {
+  // Note that the data for this rule is not distinguished based on the target version because
+  // we don't keep track of the new signature and don't want to update incrementally.
+  // See: https://github.com/angular/components/pull/12970#issuecomment-418337566
+  data = getAllChanges(this.upgradeData.constructorChecks);
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled = this.data.length !== 0;
+
+  override visitNode(node: ts.Node): void {
+    if (ts.isSourceFile(node)) {
+      this._visitSourceFile(node);
+    }
+  }
+
+  /**
+   * Method that will be called for each source file of the upgrade project. In order to
+   * properly determine invalid constructor signatures, we take advantage of the pre-emit
+   * diagnostics from TypeScript.
+   *
+   * By using the diagnostics, the migration can handle type assignability. Not using
+   * diagnostics would mean that we need to use simple type equality checking which is
+   * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
+   */
+  private _visitSourceFile(sourceFile: ts.SourceFile) {
+    // List of classes of which the constructor signature has changed.
+    const diagnostics = ts
+      .getPreEmitDiagnostics(this.program, sourceFile)
+      .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))
+      .filter(diagnostic => diagnostic.start !== undefined);
+
+    for (const diagnostic of diagnostics) {
+      const node = findConstructorNode(diagnostic, sourceFile);
+
+      if (!node) {
+        continue;
+      }
+
+      const classType = this.typeChecker.getTypeAtLocation(node.expression);
+      const className = classType.symbol && classType.symbol.name;
+      const isNewExpression = ts.isNewExpression(node);
+
+      // 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 (
+        !this.data.includes(className) &&
+        !signatureClassNames.some(name => this.data.includes(name!))
+      ) {
+        continue;
+      }
+
+      const classSignatures = classType
+        .getConstructSignatures()
+        .map(signature => getParameterTypesFromSignature(signature, this.typeChecker));
+
+      const expressionName = isNewExpression ? `new ${className}` : 'super';
+      const signatures = classSignatures
+        .map(signature =>
+          signature.map(t => (t === null ? 'any' : this.typeChecker.typeToString(t))),
+        )
+        .map(signature => `${expressionName}(${signature.join(', ')})`)
+        .join(' or ');
+
+      this.createFailureAtNode(
+        node,
+        `Found "${className}" constructed with ` +
+          `an invalid signature. Please manually update the ${expressionName} expression to ` +
+          `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`,
+      );
+    }
+  }
+}
+
+/** Resolves the type for each parameter in the specified signature. */
+function getParameterTypesFromSignature(
+  signature: ts.Signature,
+  typeChecker: ts.TypeChecker,
+): (ts.Type | null)[] {
+  return signature
+    .getParameters()
+    .map(param =>
+      param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : 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.
+ */
+function findConstructorNode(
+  diagnostic: ts.Diagnostic,
+  sourceFile: ts.SourceFile,
+): ts.CallExpression | ts.NewExpression | null {
+  let resolvedNode: ts.Node | null = null;
+
+  const _visitNode = (node: ts.Node) => {
+    // Check whether the current node contains the diagnostic. If the node contains the diagnostic,
+    // walk deeper in order to find all constructor expression nodes.
+    if (node.getStart() <= diagnostic.start! && node.getEnd() >= diagnostic.start!) {
+      if (
+        ts.isNewExpression(node) ||
+        (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)
+      ) {
+        resolvedNode = node;
+      }
+
+      ts.forEachChild(node, _visitNode);
+    }
+  };
+
+  ts.forEachChild(sourceFile, _visitNode);
+
+  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;
+}

package/schematics/schematics/ng-update/migrations/css-selectors.ts

@@ -0,0 +1,83 @@
+/**
+ * @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 * as ts from 'typescript';
+import {WorkspacePath} from '../../update-tool/file-system';
+import {ResolvedResource} from '../../update-tool/component-resource-collector';
+import {Migration} from '../../update-tool/migration';
+import {CssSelectorUpgradeData} from '../data/css-selectors';
+import {findAllSubstringIndices} from '../typescript/literal';
+import {getVersionUpgradeData, UpgradeData} from '../upgrade-data';
+
+/**
+ * Migration that walks through every string literal, template and stylesheet in
+ * order to migrate outdated CSS selectors to the new selector.
+ */
+export class CssSelectorsMigration extends Migration<UpgradeData> {
+  /** Change data that upgrades to the specified target version. */
+  data: CssSelectorUpgradeData[] = getVersionUpgradeData(this, 'cssSelectors');
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled = this.data.length !== 0;
+
+  override visitNode(node: ts.Node): void {
+    if (ts.isStringLiteralLike(node)) {
+      this._visitStringLiteralLike(node);
+    }
+  }
+
+  override visitTemplate(template: ResolvedResource): void {
+    this.data.forEach(data => {
+      if (data.replaceIn && !data.replaceIn.html) {
+        return;
+      }
+
+      findAllSubstringIndices(template.content, data.replace)
+        .map(offset => template.start + offset)
+        .forEach(start => this._replaceSelector(template.filePath, start, data));
+    });
+  }
+
+  override visitStylesheet(stylesheet: ResolvedResource): void {
+    this.data.forEach(data => {
+      if (data.replaceIn && !data.replaceIn.stylesheet) {
+        return;
+      }
+
+      findAllSubstringIndices(stylesheet.content, data.replace)
+        .map(offset => stylesheet.start + offset)
+        .forEach(start => this._replaceSelector(stylesheet.filePath, start, data));
+    });
+  }
+
+  private _visitStringLiteralLike(node: ts.StringLiteralLike) {
+    if (node.parent && node.parent.kind !== ts.SyntaxKind.CallExpression) {
+      return;
+    }
+
+    const textContent = node.getText();
+    const filePath = this.fileSystem.resolve(node.getSourceFile().fileName);
+
+    this.data.forEach(data => {
+      if (data.replaceIn && !data.replaceIn.tsStringLiterals) {
+        return;
+      }
+
+      findAllSubstringIndices(textContent, data.replace)
+        .map(offset => node.getStart() + offset)
+        .forEach(start => this._replaceSelector(filePath, start, data));
+    });
+  }
+
+  private _replaceSelector(filePath: WorkspacePath, start: number, data: CssSelectorUpgradeData) {
+    this.fileSystem
+      .edit(filePath)
+      .remove(start, data.replace.length)
+      .insertRight(start, data.replaceWith);
+  }
+}

package/schematics/schematics/ng-update/migrations/element-selectors.ts

@@ -0,0 +1,75 @@
+/**
+ * @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 * as ts from 'typescript';
+import {ResolvedResource} from '../../update-tool/component-resource-collector';
+import {WorkspacePath} from '../../update-tool/file-system';
+import {Migration} from '../../update-tool/migration';
+import {ElementSelectorUpgradeData} from '../data/element-selectors';
+import {findAllSubstringIndices} from '../typescript/literal';
+import {getVersionUpgradeData, UpgradeData} from '../upgrade-data';
+
+/**
+ * Migration that walks through every string literal, template and stylesheet in order
+ * to migrate outdated element selectors to the new one.
+ */
+export class ElementSelectorsMigration extends Migration<UpgradeData> {
+  /** Change data that upgrades to the specified target version. */
+  data = getVersionUpgradeData(this, 'elementSelectors');
+
+  // Only enable the migration rule if there is upgrade data.
+  enabled: boolean = this.data.length !== 0;
+
+  override visitNode(node: ts.Node): void {
+    if (ts.isStringLiteralLike(node)) {
+      this._visitStringLiteralLike(node);
+    }
+  }
+
+  override visitTemplate(template: ResolvedResource): void {
+    this.data.forEach(selector => {
+      findAllSubstringIndices(template.content, selector.replace)
+        .map(offset => template.start + offset)
+        .forEach(start => this._replaceSelector(template.filePath, start, selector));
+    });
+  }
+
+  override visitStylesheet(stylesheet: ResolvedResource): void {
+    this.data.forEach(selector => {
+      findAllSubstringIndices(stylesheet.content, selector.replace)
+        .map(offset => stylesheet.start + offset)
+        .forEach(start => this._replaceSelector(stylesheet.filePath, start, selector));
+    });
+  }
+
+  private _visitStringLiteralLike(node: ts.StringLiteralLike) {
+    if (node.parent && node.parent.kind !== ts.SyntaxKind.CallExpression) {
+      return;
+    }
+
+    const textContent = node.getText();
+    const filePath = this.fileSystem.resolve(node.getSourceFile().fileName);
+
+    this.data.forEach(selector => {
+      findAllSubstringIndices(textContent, selector.replace)
+        .map(offset => node.getStart() + offset)
+        .forEach(start => this._replaceSelector(filePath, start, selector));
+    });
+  }
+
+  private _replaceSelector(
+    filePath: WorkspacePath,
+    start: number,
+    data: ElementSelectorUpgradeData,
+  ) {
+    this.fileSystem
+      .edit(filePath)
+      .remove(start, data.replace.length)
+      .insertRight(start, data.replaceWith);
+  }
+}