@angular/material 12.0.0 → 12.0.4

package/schematics/ng-update/migrations/hammer-gestures-v9/hammer-gestures-migration.mjs

@@ -0,0 +1,778 @@
+"use strict";
+/**
+ * @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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HammerGesturesMigration = void 0;
+const core_1 = require("@angular-devkit/core");
+const schematics_1 = require("@angular/cdk/schematics");
+const change_1 = require("@schematics/angular/utility/change");
+const fs_1 = require("fs");
+const ts = require("typescript");
+const find_hammer_script_tags_1 = require("./find-hammer-script-tags");
+const find_main_module_1 = require("./find-main-module");
+const hammer_template_check_1 = require("./hammer-template-check");
+const import_manager_1 = require("./import-manager");
+const remove_array_element_1 = require("./remove-array-element");
+const remove_element_from_html_1 = require("./remove-element-from-html");
+const GESTURE_CONFIG_CLASS_NAME = 'GestureConfig';
+const GESTURE_CONFIG_FILE_NAME = 'gesture-config';
+const GESTURE_CONFIG_TEMPLATE_PATH = './gesture-config.template';
+const HAMMER_CONFIG_TOKEN_NAME = 'HAMMER_GESTURE_CONFIG';
+const HAMMER_CONFIG_TOKEN_MODULE = '@angular/platform-browser';
+const HAMMER_MODULE_NAME = 'HammerModule';
+const HAMMER_MODULE_IMPORT = '@angular/platform-browser';
+const HAMMER_MODULE_SPECIFIER = 'hammerjs';
+const CANNOT_REMOVE_REFERENCE_ERROR = `Cannot remove reference to "GestureConfig". Please remove manually.`;
+class HammerGesturesMigration extends schematics_1.DevkitMigration {
+    constructor() {
+        super(...arguments);
+        // Only enable this rule if the migration targets v9 or v10 and is running for a non-test
+        // target. We cannot migrate test targets since they have a limited scope
+        // (in regards to source files) and therefore the HammerJS usage detection can be incorrect.
+        this.enabled = (this.targetVersion === schematics_1.TargetVersion.V9 || this.targetVersion === schematics_1.TargetVersion.V10) &&
+            !this.context.isTestTarget;
+        this._printer = ts.createPrinter();
+        this._importManager = new import_manager_1.ImportManager(this.fileSystem, this._printer);
+        this._nodeFailures = [];
+        /**
+         * Whether custom HammerJS events provided by the Material gesture
+         * config are used in a template.
+         */
+        this._customEventsUsedInTemplate = false;
+        /** Whether standard HammerJS events are used in a template. */
+        this._standardEventsUsedInTemplate = false;
+        /** Whether HammerJS is accessed at runtime. */
+        this._usedInRuntime = false;
+        /**
+         * List of imports that make "hammerjs" available globally. We keep track of these
+         * since we might need to remove them if Hammer is not used.
+         */
+        this._installImports = [];
+        /**
+         * List of identifiers which resolve to the gesture config from Angular Material.
+         */
+        this._gestureConfigReferences = [];
+        /**
+         * List of identifiers which resolve to the "HAMMER_GESTURE_CONFIG" token from
+         * "@angular/platform-browser".
+         */
+        this._hammerConfigTokenReferences = [];
+        /**
+         * List of identifiers which resolve to the "HammerModule" from
+         * "@angular/platform-browser".
+         */
+        this._hammerModuleReferences = [];
+        /**
+         * List of identifiers that have been deleted from source files. This can be
+         * used to determine if certain imports are still used or not.
+         */
+        this._deletedIdentifiers = [];
+    }
+    visitTemplate(template) {
+        if (!this._customEventsUsedInTemplate || !this._standardEventsUsedInTemplate) {
+            const { standardEvents, customEvents } = hammer_template_check_1.isHammerJsUsedInTemplate(template.content);
+            this._customEventsUsedInTemplate = this._customEventsUsedInTemplate || customEvents;
+            this._standardEventsUsedInTemplate = this._standardEventsUsedInTemplate || standardEvents;
+        }
+    }
+    visitNode(node) {
+        this._checkHammerImports(node);
+        this._checkForRuntimeHammerUsage(node);
+        this._checkForMaterialGestureConfig(node);
+        this._checkForHammerGestureConfigToken(node);
+        this._checkForHammerModuleReference(node);
+    }
+    postAnalysis() {
+        // Walk through all hammer config token references and check if there
+        // is a potential custom gesture config setup.
+        const hasCustomGestureConfigSetup = this._hammerConfigTokenReferences.some(r => this._checkForCustomGestureConfigSetup(r));
+        const usedInTemplate = this._standardEventsUsedInTemplate || this._customEventsUsedInTemplate;
+        /*
+          Possible scenarios and how the migration should change the project:
+            1. We detect that a custom HammerJS gesture config is set up:
+                - Remove references to the Material gesture config if no HammerJS event is used.
+                - Print a warning about ambiguous configuration that cannot be handled completely
+                  if there are references to the Material gesture config.
+            2. We detect that HammerJS is only used programmatically:
+                - Remove references to GestureConfig of Material.
+                - Remove references to the "HammerModule" if present.
+            3. We detect that standard HammerJS events are used in a template:
+                - Set up the "HammerModule" from platform-browser.
+                - Remove all gesture config references.
+            4. We detect that custom HammerJS events provided by the Material gesture
+               config are used.
+                - Copy the Material gesture config into the app.
+                - Rewrite all gesture config references to the newly copied one.
+                - Set up the new gesture config in the root app module.
+                - Set up the "HammerModule" from platform-browser.
+            4. We detect no HammerJS usage at all:
+                - Remove Hammer imports
+                - Remove Material gesture config references
+                - Remove HammerModule setup if present.
+                - Remove Hammer script imports in "index.html" files.
+        */
+        if (hasCustomGestureConfigSetup) {
+            // If a custom gesture config is provided, we always assume that HammerJS is used.
+            HammerGesturesMigration.globalUsesHammer = true;
+            if (!usedInTemplate && this._gestureConfigReferences.length) {
+                // If the Angular Material gesture events are not used and we found a custom
+                // gesture config, we can safely remove references to the Material gesture config
+                // since events provided by the Material gesture config are guaranteed to be unused.
+                this._removeMaterialGestureConfigSetup();
+                this.printInfo('The HammerJS v9 migration for Angular Components detected that HammerJS is ' +
+                    'manually set up in combination with references to the Angular Material gesture ' +
+                    'config. This target cannot be migrated completely, but all references to the ' +
+                    'deprecated Angular Material gesture have been removed. Read more here: ' +
+                    'https://git.io/ng-material-v9-hammer-ambiguous-usage');
+            }
+            else if (usedInTemplate && this._gestureConfigReferences.length) {
+                // Since there is a reference to the Angular Material gesture config, and we detected
+                // usage of a gesture event that could be provided by Angular Material, we *cannot*
+                // automatically remove references. This is because we do *not* know whether the
+                // event is actually provided by the custom config or by the Material config.
+                this.printInfo('The HammerJS v9 migration for Angular Components detected that HammerJS is ' +
+                    'manually set up in combination with references to the Angular Material gesture ' +
+                    'config. This target cannot be migrated completely. Please manually remove ' +
+                    'references to the deprecated Angular Material gesture config. Read more here: ' +
+                    'https://git.io/ng-material-v9-hammer-ambiguous-usage');
+            }
+        }
+        else if (this._usedInRuntime || usedInTemplate) {
+            // We keep track of whether Hammer is used globally. This is necessary because we
+            // want to only remove Hammer from the "package.json" if it is not used in any project
+            // target. Just because it isn't used in one target doesn't mean that we can safely
+            // remove the dependency.
+            HammerGesturesMigration.globalUsesHammer = true;
+            // If hammer is only used at runtime, we don't need the gesture config or "HammerModule"
+            // and can remove it (along with the hammer config token import if no longer needed).
+            if (!usedInTemplate) {
+                this._removeMaterialGestureConfigSetup();
+                this._removeHammerModuleReferences();
+            }
+            else if (this._standardEventsUsedInTemplate && !this._customEventsUsedInTemplate) {
+                this._setupHammerWithStandardEvents();
+            }
+            else {
+                this._setupHammerWithCustomEvents();
+            }
+        }
+        else {
+            this._removeHammerSetup();
+        }
+        // Record the changes collected in the import manager. Changes need to be applied
+        // once the import manager registered all import modifications. This avoids collisions.
+        this._importManager.recordChanges();
+        // Create migration failures that will be printed by the update-tool on migration
+        // completion. We need special logic for updating failure positions to reflect
+        // the new source file after modifications from the import manager.
+        this.failures.push(...this._createMigrationFailures());
+        // The template check for HammerJS events is not completely reliable as the event
+        // output could also be from a component having an output named similarly to a known
+        // hammerjs event (e.g. "@Output() slide"). The usage is therefore somewhat ambiguous
+        // and we want to print a message that developers might be able to remove Hammer manually.
+        if (!hasCustomGestureConfigSetup && !this._usedInRuntime && usedInTemplate) {
+            this.printInfo('The HammerJS v9 migration for Angular Components migrated the ' +
+                'project to keep HammerJS installed, but detected ambiguous usage of HammerJS. Please ' +
+                'manually check if you can remove HammerJS from your application. More details: ' +
+                'https://git.io/ng-material-v9-hammer-ambiguous-usage');
+        }
+    }
+    /**
+     * Sets up the hammer gesture config in the current project. To achieve this, the
+     * following steps are performed:
+     *   1) Create copy of Angular Material gesture config.
+     *   2) Rewrite all references to the Angular Material gesture config to the
+     *      new gesture config.
+     *   3) Setup the HAMMER_GESTURE_CONFIG in the root app module (if not done already).
+     *   4) Setup the "HammerModule" in the root app module (if not done already).
+     */
+    _setupHammerWithCustomEvents() {
+        const project = this.context.project;
+        const sourceRoot = this.fileSystem.resolve(project.sourceRoot || project.root);
+        const newConfigPath = core_1.join(sourceRoot, this._getAvailableGestureConfigFileName(sourceRoot));
+        // Copy gesture config template into the CLI project.
+        this.fileSystem.create(newConfigPath, fs_1.readFileSync(require.resolve(GESTURE_CONFIG_TEMPLATE_PATH), 'utf8'));
+        // Replace all Material gesture config references to resolve to the
+        // newly copied gesture config.
+        this._gestureConfigReferences.forEach(i => {
+            const filePath = this.fileSystem.resolve(i.node.getSourceFile().fileName);
+            return this._replaceGestureConfigReference(i, GESTURE_CONFIG_CLASS_NAME, getModuleSpecifier(newConfigPath, filePath));
+        });
+        // Setup the gesture config provider and the "HammerModule" in the root module
+        // if not done already. The "HammerModule" is needed in v9 since it enables the
+        // Hammer event plugin that was previously enabled by default in v8.
+        this._setupNewGestureConfigInRootModule(newConfigPath);
+        this._setupHammerModuleInRootModule();
+    }
+    /**
+     * Sets up the standard hammer module in the project and removes all
+     * references to the deprecated Angular Material gesture config.
+     */
+    _setupHammerWithStandardEvents() {
+        // Setup the HammerModule. The HammerModule enables support for
+        // the standard HammerJS events.
+        this._setupHammerModuleInRootModule();
+        this._removeMaterialGestureConfigSetup();
+    }
+    /**
+     * Removes Hammer from the current project. The following steps are performed:
+     *   1) Delete all TypeScript imports to "hammerjs".
+     *   2) Remove references to the Angular Material gesture config.
+     *   3) Remove "hammerjs" from all index HTML files of the current project.
+     */
+    _removeHammerSetup() {
+        this._installImports.forEach(i => this._importManager.deleteImportByDeclaration(i));
+        this._removeMaterialGestureConfigSetup();
+        this._removeHammerModuleReferences();
+        this._removeHammerFromIndexFile();
+    }
+    /**
+     * Removes the gesture config setup by deleting all found references to the Angular
+     * Material gesture config. Additionally, unused imports to the hammer gesture config
+     * token from "@angular/platform-browser" will be removed as well.
+     */
+    _removeMaterialGestureConfigSetup() {
+        this._gestureConfigReferences.forEach(r => this._removeGestureConfigReference(r));
+        this._hammerConfigTokenReferences.forEach(r => {
+            if (r.isImport) {
+                this._removeHammerConfigTokenImportIfUnused(r);
+            }
+        });
+    }
+    /** Removes all references to the "HammerModule" from "@angular/platform-browser". */
+    _removeHammerModuleReferences() {
+        this._hammerModuleReferences.forEach(({ node, isImport, importData }) => {
+            const sourceFile = node.getSourceFile();
+            const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));
+            // Only remove the import for the HammerModule if the module has been accessed
+            // through a non-namespaced identifier access.
+            if (!isNamespacedIdentifierAccess(node)) {
+                this._importManager.deleteNamedBindingImport(sourceFile, HAMMER_MODULE_NAME, importData.moduleName);
+            }
+            // For references from within an import, we do not need to do anything other than
+            // removing the import. For other references, we remove the import and the actual
+            // identifier in the module imports.
+            if (isImport) {
+                return;
+            }
+            // If the "HammerModule" is referenced within an array literal, we can
+            // remove the element easily. Otherwise if it's outside of an array literal,
+            // we need to replace the reference with an empty object literal w/ todo to
+            // not break the application.
+            if (ts.isArrayLiteralExpression(node.parent)) {
+                // Removes the "HammerModule" from the parent array expression. Removes
+                // the trailing comma token if present.
+                remove_array_element_1.removeElementFromArrayExpression(node, recorder);
+            }
+            else {
+                recorder.remove(node.getStart(), node.getWidth());
+                recorder.insertRight(node.getStart(), `/* TODO: remove */ {}`);
+                this._nodeFailures.push({
+                    node: node,
+                    message: 'Unable to delete reference to "HammerModule".',
+                });
+            }
+        });
+    }
+    /**
+     * Checks if the given node is a reference to the hammer gesture config
+     * token from platform-browser. If so, keeps track of the reference.
+     */
+    _checkForHammerGestureConfigToken(node) {
+        if (ts.isIdentifier(node)) {
+            const importData = schematics_1.getImportOfIdentifier(node, this.typeChecker);
+            if (importData && importData.symbolName === HAMMER_CONFIG_TOKEN_NAME &&
+                importData.moduleName === HAMMER_CONFIG_TOKEN_MODULE) {
+                this._hammerConfigTokenReferences.push({ node, importData, isImport: ts.isImportSpecifier(node.parent) });
+            }
+        }
+    }
+    /**
+     * Checks if the given node is a reference to the HammerModule from
+     * "@angular/platform-browser". If so, keeps track of the reference.
+     */
+    _checkForHammerModuleReference(node) {
+        if (ts.isIdentifier(node)) {
+            const importData = schematics_1.getImportOfIdentifier(node, this.typeChecker);
+            if (importData && importData.symbolName === HAMMER_MODULE_NAME &&
+                importData.moduleName === HAMMER_MODULE_IMPORT) {
+                this._hammerModuleReferences.push({ node, importData, isImport: ts.isImportSpecifier(node.parent) });
+            }
+        }
+    }
+    /**
+     * Checks if the given node is an import to the HammerJS package. Imports to
+     * HammerJS which load specific symbols from the package are considered as
+     * runtime usage of Hammer. e.g. `import {Symbol} from "hammerjs";`.
+     */
+    _checkHammerImports(node) {
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&
+            node.moduleSpecifier.text === HAMMER_MODULE_SPECIFIER) {
+            // If there is an import to HammerJS that imports symbols, or is namespaced
+            // (e.g. "import {A, B} from ..." or "import * as hammer from ..."), then we
+            // assume that some exports are used at runtime.
+            if (node.importClause &&
+                !(node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings) &&
+                    node.importClause.namedBindings.elements.length === 0)) {
+                this._usedInRuntime = true;
+            }
+            else {
+                this._installImports.push(node);
+            }
+        }
+    }
+    /**
+     * Checks if the given node accesses the global "Hammer" symbol at runtime. If so,
+     * the migration rule state will be updated to reflect that Hammer is used at runtime.
+     */
+    _checkForRuntimeHammerUsage(node) {
+        if (this._usedInRuntime) {
+            return;
+        }
+        // Detects usages of "window.Hammer".
+        if (ts.isPropertyAccessExpression(node) && node.name.text === 'Hammer') {
+            const originExpr = unwrapExpression(node.expression);
+            if (ts.isIdentifier(originExpr) && originExpr.text === 'window') {
+                this._usedInRuntime = true;
+            }
+            return;
+        }
+        // Detects usages of "window['Hammer']".
+        if (ts.isElementAccessExpression(node) && ts.isStringLiteral(node.argumentExpression) &&
+            node.argumentExpression.text === 'Hammer') {
+            const originExpr = unwrapExpression(node.expression);
+            if (ts.isIdentifier(originExpr) && originExpr.text === 'window') {
+                this._usedInRuntime = true;
+            }
+            return;
+        }
+        // Handles usages of plain identifier with the name "Hammer". These usage
+        // are valid if they resolve to "@types/hammerjs". e.g. "new Hammer(myElement)".
+        if (ts.isIdentifier(node) && node.text === 'Hammer' &&
+            !ts.isPropertyAccessExpression(node.parent) && !ts.isElementAccessExpression(node.parent)) {
+            const symbol = this._getDeclarationSymbolOfNode(node);
+            if (symbol && symbol.valueDeclaration &&
+                symbol.valueDeclaration.getSourceFile().fileName.includes('@types/hammerjs')) {
+                this._usedInRuntime = true;
+            }
+        }
+    }
+    /**
+     * Checks if the given node references the gesture config from Angular Material.
+     * If so, we keep track of the found symbol reference.
+     */
+    _checkForMaterialGestureConfig(node) {
+        if (ts.isIdentifier(node)) {
+            const importData = schematics_1.getImportOfIdentifier(node, this.typeChecker);
+            if (importData && importData.symbolName === GESTURE_CONFIG_CLASS_NAME &&
+                importData.moduleName.startsWith('@angular/material/')) {
+                this._gestureConfigReferences.push({ node, importData, isImport: ts.isImportSpecifier(node.parent) });
+            }
+        }
+    }
+    /**
+     * Checks if the given Hammer gesture config token reference is part of an
+     * Angular provider definition that sets up a custom gesture config.
+     */
+    _checkForCustomGestureConfigSetup(tokenRef) {
+        // Walk up the tree to look for a parent property assignment of the
+        // reference to the hammer gesture config token.
+        let propertyAssignment = tokenRef.node;
+        while (propertyAssignment && !ts.isPropertyAssignment(propertyAssignment)) {
+            propertyAssignment = propertyAssignment.parent;
+        }
+        if (!propertyAssignment || !ts.isPropertyAssignment(propertyAssignment) ||
+            getPropertyNameText(propertyAssignment.name) !== 'provide') {
+            return false;
+        }
+        const objectLiteralExpr = propertyAssignment.parent;
+        const matchingIdentifiers = findMatchingChildNodes(objectLiteralExpr, ts.isIdentifier);
+        // We naively assume that if there is a reference to the "GestureConfig" export
+        // from Angular Material in the provider literal, that the provider sets up the
+        // Angular Material gesture config.
+        return !this._gestureConfigReferences.some(r => matchingIdentifiers.includes(r.node));
+    }
+    /**
+     * Determines an available file name for the gesture config which should
+     * be stored in the specified file path.
+     */
+    _getAvailableGestureConfigFileName(sourceRoot) {
+        if (!this.fileSystem.exists(core_1.join(sourceRoot, `${GESTURE_CONFIG_FILE_NAME}.ts`))) {
+            return `${GESTURE_CONFIG_FILE_NAME}.ts`;
+        }
+        let possibleName = `${GESTURE_CONFIG_FILE_NAME}-`;
+        let index = 1;
+        while (this.fileSystem.exists(core_1.join(sourceRoot, `${possibleName}-${index}.ts`))) {
+            index++;
+        }
+        return `${possibleName + index}.ts`;
+    }
+    /** Replaces a given gesture config reference with a new import. */
+    _replaceGestureConfigReference({ node, importData, isImport }, symbolName, moduleSpecifier) {
+        const sourceFile = node.getSourceFile();
+        const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));
+        // List of all identifiers referring to the gesture config in the current file. This
+        // allows us to add an import for the copied gesture configuration without generating a
+        // new identifier for the import to avoid collisions. i.e. "GestureConfig_1". The import
+        // manager checks for possible name collisions, but is able to ignore specific identifiers.
+        // We use this to ignore all references to the original Angular Material gesture config,
+        // because these will be replaced and therefore will not interfere.
+        const gestureIdentifiersInFile = this._getGestureConfigIdentifiersOfFile(sourceFile);
+        // If the parent of the identifier is accessed through a namespace, we can just
+        // import the new gesture config without rewriting the import declaration because
+        // the config has been imported through a namespaced import.
+        if (isNamespacedIdentifierAccess(node)) {
+            const newExpression = this._importManager.addImportToSourceFile(sourceFile, symbolName, moduleSpecifier, false, gestureIdentifiersInFile);
+            recorder.remove(node.parent.getStart(), node.parent.getWidth());
+            recorder.insertRight(node.parent.getStart(), this._printNode(newExpression, sourceFile));
+            return;
+        }
+        // Delete the old import to the "GestureConfig".
+        this._importManager.deleteNamedBindingImport(sourceFile, GESTURE_CONFIG_CLASS_NAME, importData.moduleName);
+        // If the current reference is not from inside of a import, we need to add a new
+        // import to the copied gesture config and replace the identifier. For references
+        // within an import, we do nothing but removing the actual import. This allows us
+        // to remove unused imports to the Material gesture config.
+        if (!isImport) {
+            const newExpression = this._importManager.addImportToSourceFile(sourceFile, symbolName, moduleSpecifier, false, gestureIdentifiersInFile);
+            recorder.remove(node.getStart(), node.getWidth());
+            recorder.insertRight(node.getStart(), this._printNode(newExpression, sourceFile));
+        }
+    }
+    /**
+     * Removes a given gesture config reference and its corresponding import from
+     * its containing source file. Imports will be always removed, but in some cases,
+     * where it's not guaranteed that a removal can be performed safely, we just
+     * create a migration failure (and add a TODO if possible).
+     */
+    _removeGestureConfigReference({ node, importData, isImport }) {
+        const sourceFile = node.getSourceFile();
+        const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));
+        // Only remove the import for the gesture config if the gesture config has
+        // been accessed through a non-namespaced identifier access.
+        if (!isNamespacedIdentifierAccess(node)) {
+            this._importManager.deleteNamedBindingImport(sourceFile, GESTURE_CONFIG_CLASS_NAME, importData.moduleName);
+        }
+        // For references from within an import, we do not need to do anything other than
+        // removing the import. For other references, we remove the import and the reference
+        // identifier if used inside of a provider definition.
+        if (isImport) {
+            return;
+        }
+        const providerAssignment = node.parent;
+        // Only remove references to the gesture config which are part of a statically
+        // analyzable provider definition. We only support the common case of a gesture
+        // config provider definition where the config is set up through "useClass".
+        // Otherwise, it's not guaranteed that we can safely remove the provider definition.
+        if (!ts.isPropertyAssignment(providerAssignment) ||
+            getPropertyNameText(providerAssignment.name) !== 'useClass') {
+            this._nodeFailures.push({ node, message: CANNOT_REMOVE_REFERENCE_ERROR });
+            return;
+        }
+        const objectLiteralExpr = providerAssignment.parent;
+        const provideToken = objectLiteralExpr.properties.find((p) => ts.isPropertyAssignment(p) && getPropertyNameText(p.name) === 'provide');
+        // Do not remove the reference if the gesture config is not part of a provider definition,
+        // or if the provided toke is not referring to the known HAMMER_GESTURE_CONFIG token
+        // from platform-browser.
+        if (!provideToken || !this._isReferenceToHammerConfigToken(provideToken.initializer)) {
+            this._nodeFailures.push({ node, message: CANNOT_REMOVE_REFERENCE_ERROR });
+            return;
+        }
+        // Collect all nested identifiers which will be deleted. This helps us
+        // determining if we can remove imports for the "HAMMER_GESTURE_CONFIG" token.
+        this._deletedIdentifiers.push(...findMatchingChildNodes(objectLiteralExpr, ts.isIdentifier));
+        // In case the found provider definition is not part of an array literal,
+        // we cannot safely remove the provider. This is because it could be declared
+        // as a variable. e.g. "const gestureProvider = {provide: .., useClass: GestureConfig}".
+        // In that case, we just add an empty object literal with TODO and print a failure.
+        if (!ts.isArrayLiteralExpression(objectLiteralExpr.parent)) {
+            recorder.remove(objectLiteralExpr.getStart(), objectLiteralExpr.getWidth());
+            recorder.insertRight(objectLiteralExpr.getStart(), `/* TODO: remove */ {}`);
+            this._nodeFailures.push({
+                node: objectLiteralExpr,
+                message: `Unable to delete provider definition for "GestureConfig" completely. ` +
+                    `Please clean up the provider.`
+            });
+            return;
+        }
+        // Removes the object literal from the parent array expression. Removes
+        // the trailing comma token if present.
+        remove_array_element_1.removeElementFromArrayExpression(objectLiteralExpr, recorder);
+    }
+    /** Removes the given hammer config token import if it is not used. */
+    _removeHammerConfigTokenImportIfUnused({ node, importData }) {
+        const sourceFile = node.getSourceFile();
+        const isTokenUsed = this._hammerConfigTokenReferences.some(r => !r.isImport && !isNamespacedIdentifierAccess(r.node) &&
+            r.node.getSourceFile() === sourceFile && !this._deletedIdentifiers.includes(r.node));
+        // We don't want to remove the import for the token if the token is
+        // still used somewhere.
+        if (!isTokenUsed) {
+            this._importManager.deleteNamedBindingImport(sourceFile, HAMMER_CONFIG_TOKEN_NAME, importData.moduleName);
+        }
+    }
+    /** Removes Hammer from all index HTML files of the current project. */
+    _removeHammerFromIndexFile() {
+        const indexFilePaths = schematics_1.getProjectIndexFiles(this.context.project);
+        indexFilePaths.forEach(filePath => {
+            if (!this.fileSystem.exists(filePath)) {
+                return;
+            }
+            const htmlContent = this.fileSystem.read(filePath);
+            const recorder = this.fileSystem.edit(filePath);
+            find_hammer_script_tags_1.findHammerScriptImportElements(htmlContent)
+                .forEach(el => remove_element_from_html_1.removeElementFromHtml(el, recorder));
+        });
+    }
+    /** Sets up the Hammer gesture config in the root module if needed. */
+    _setupNewGestureConfigInRootModule(gestureConfigPath) {
+        const { project } = this.context;
+        const mainFilePath = schematics_1.getProjectMainFile(project);
+        const rootModuleSymbol = this._getRootModuleSymbol(mainFilePath);
+        if (rootModuleSymbol === null || rootModuleSymbol.valueDeclaration === undefined) {
+            this.failures.push({
+                filePath: mainFilePath,
+                message: `Could not setup Hammer gestures in module. Please ` +
+                    `manually ensure that the Hammer gesture config is set up.`,
+            });
+            return;
+        }
+        const sourceFile = rootModuleSymbol.valueDeclaration.getSourceFile();
+        const metadata = schematics_1.getDecoratorMetadata(sourceFile, 'NgModule', '@angular/core');
+        // If no "NgModule" definition is found inside the source file, we just do nothing.
+        if (!metadata.length) {
+            return;
+        }
+        const filePath = this.fileSystem.resolve(sourceFile.fileName);
+        const recorder = this.fileSystem.edit(filePath);
+        const providersField = schematics_1.getMetadataField(metadata[0], 'providers')[0];
+        const providerIdentifiers = providersField ? findMatchingChildNodes(providersField, ts.isIdentifier) : null;
+        const gestureConfigExpr = this._importManager.addImportToSourceFile(sourceFile, GESTURE_CONFIG_CLASS_NAME, getModuleSpecifier(gestureConfigPath, filePath), false, this._getGestureConfigIdentifiersOfFile(sourceFile));
+        const hammerConfigTokenExpr = this._importManager.addImportToSourceFile(sourceFile, HAMMER_CONFIG_TOKEN_NAME, HAMMER_CONFIG_TOKEN_MODULE);
+        const newProviderNode = ts.createObjectLiteral([
+            ts.createPropertyAssignment('provide', hammerConfigTokenExpr),
+            ts.createPropertyAssignment('useClass', gestureConfigExpr)
+        ]);
+        // If the providers field exists and already contains references to the hammer gesture
+        // config token and the gesture config, we naively assume that the gesture config is
+        // already set up. We only want to add the gesture config provider if it is not set up.
+        if (!providerIdentifiers ||
+            !(this._hammerConfigTokenReferences.some(r => providerIdentifiers.includes(r.node)) &&
+                this._gestureConfigReferences.some(r => providerIdentifiers.includes(r.node)))) {
+            const symbolName = this._printNode(newProviderNode, sourceFile);
+            schematics_1.addSymbolToNgModuleMetadata(sourceFile, sourceFile.fileName, 'providers', symbolName, null)
+                .forEach(change => {
+                if (change instanceof change_1.InsertChange) {
+                    recorder.insertRight(change.pos, change.toAdd);
+                }
+            });
+        }
+    }
+    /**
+     * Gets the TypeScript symbol of the root module by looking for the module
+     * bootstrap expression in the specified source file.
+     */
+    _getRootModuleSymbol(mainFilePath) {
+        const mainFile = this.program.getSourceFile(mainFilePath);
+        if (!mainFile) {
+            return null;
+        }
+        const appModuleExpr = find_main_module_1.findMainModuleExpression(mainFile);
+        if (!appModuleExpr) {
+            return null;
+        }
+        const appModuleSymbol = this._getDeclarationSymbolOfNode(unwrapExpression(appModuleExpr));
+        if (!appModuleSymbol || !appModuleSymbol.valueDeclaration) {
+            return null;
+        }
+        return appModuleSymbol;
+    }
+    /** Sets up the "HammerModule" in the root module of the current project. */
+    _setupHammerModuleInRootModule() {
+        const { project } = this.context;
+        const mainFilePath = schematics_1.getProjectMainFile(project);
+        const rootModuleSymbol = this._getRootModuleSymbol(mainFilePath);
+        if (rootModuleSymbol === null || rootModuleSymbol.valueDeclaration === undefined) {
+            this.failures.push({
+                filePath: mainFilePath,
+                message: `Could not setup HammerModule. Please manually set up the "HammerModule" ` +
+                    `from "@angular/platform-browser".`,
+            });
+            return;
+        }
+        const sourceFile = rootModuleSymbol.valueDeclaration.getSourceFile();
+        const metadata = schematics_1.getDecoratorMetadata(sourceFile, 'NgModule', '@angular/core');
+        if (!metadata.length) {
+            return;
+        }
+        const importsField = schematics_1.getMetadataField(metadata[0], 'imports')[0];
+        const importIdentifiers = importsField ? findMatchingChildNodes(importsField, ts.isIdentifier) : null;
+        const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));
+        const hammerModuleExpr = this._importManager.addImportToSourceFile(sourceFile, HAMMER_MODULE_NAME, HAMMER_MODULE_IMPORT);
+        // If the "HammerModule" is not already imported in the app module, we set it up
+        // by adding it to the "imports" field of the app module.
+        if (!importIdentifiers ||
+            !this._hammerModuleReferences.some(r => importIdentifiers.includes(r.node))) {
+            const symbolName = this._printNode(hammerModuleExpr, sourceFile);
+            schematics_1.addSymbolToNgModuleMetadata(sourceFile, sourceFile.fileName, 'imports', symbolName, null)
+                .forEach(change => {
+                if (change instanceof change_1.InsertChange) {
+                    recorder.insertRight(change.pos, change.toAdd);
+                }
+            });
+        }
+    }
+    /** Prints a given node within the specified source file. */
+    _printNode(node, sourceFile) {
+        return this._printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    }
+    /** Gets all referenced gesture config identifiers of a given source file */
+    _getGestureConfigIdentifiersOfFile(sourceFile) {
+        return this._gestureConfigReferences.filter(d => d.node.getSourceFile() === sourceFile)
+            .map(d => d.node);
+    }
+    /** Gets the symbol that contains the value declaration of the specified node. */
+    _getDeclarationSymbolOfNode(node) {
+        const symbol = this.typeChecker.getSymbolAtLocation(node);
+        // Symbols can be aliases of the declaration symbol. e.g. in named import specifiers.
+        // We need to resolve the aliased symbol back to the declaration symbol.
+        // tslint:disable-next-line:no-bitwise
+        if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
+            return this.typeChecker.getAliasedSymbol(symbol);
+        }
+        return symbol;
+    }
+    /**
+     * Checks whether the given expression resolves to a hammer gesture config
+     * token reference from "@angular/platform-browser".
+     */
+    _isReferenceToHammerConfigToken(expr) {
+        const unwrapped = unwrapExpression(expr);
+        if (ts.isIdentifier(unwrapped)) {
+            return this._hammerConfigTokenReferences.some(r => r.node === unwrapped);
+        }
+        else if (ts.isPropertyAccessExpression(unwrapped)) {
+            return this._hammerConfigTokenReferences.some(r => r.node === unwrapped.name);
+        }
+        return false;
+    }
+    /**
+     * Creates migration failures of the collected node failures. The returned migration
+     * failures are updated to reflect the post-migration state of source files. Meaning
+     * that failure positions are corrected if source file modifications shifted lines.
+     */
+    _createMigrationFailures() {
+        return this._nodeFailures.map(({ node, message }) => {
+            const sourceFile = node.getSourceFile();
+            const offset = node.getStart();
+            const position = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+            return {
+                position: this._importManager.correctNodePosition(node, offset, position),
+                message: message,
+                filePath: this.fileSystem.resolve(sourceFile.fileName),
+            };
+        });
+    }
+    /**
+     * Static migration rule method that will be called once all project targets
+     * have been migrated individually. This method can be used to make changes based
+     * on the analysis of the individual targets. For example: we only remove Hammer
+     * from the "package.json" if it is not used in *any* project target.
+     */
+    static globalPostMigration(tree, context) {
+        // Always notify the developer that the Hammer v9 migration does not migrate tests.
+        context.logger.info('\n⚠  General notice: The HammerJS v9 migration for Angular Components is not able to ' +
+            'migrate tests. Please manually clean up tests in your project if they rely on ' +
+            (this.globalUsesHammer ? 'the deprecated Angular Material gesture config.' : 'HammerJS.'));
+        context.logger.info('Read more about migrating tests: https://git.io/ng-material-v9-hammer-migrate-tests');
+        if (!this.globalUsesHammer && this._removeHammerFromPackageJson(tree)) {
+            // Since Hammer has been removed from the workspace "package.json" file,
+            // we schedule a node package install task to refresh the lock file.
+            return { runPackageManager: true };
+        }
+        // Clean global state once the workspace has been migrated. This is technically
+        // not necessary in "ng update", but in tests we re-use the same rule class.
+        this.globalUsesHammer = false;
+    }
+    /**
+     * Removes the hammer package from the workspace "package.json".
+     * @returns Whether Hammer was set up and has been removed from the "package.json"
+     */
+    static _removeHammerFromPackageJson(tree) {
+        if (!tree.exists('/package.json')) {
+            return false;
+        }
+        const packageJson = JSON.parse(tree.read('/package.json').toString('utf8'));
+        // We do not handle the case where someone manually added "hammerjs" to the dev dependencies.
+        if (packageJson.dependencies && packageJson.dependencies[HAMMER_MODULE_SPECIFIER]) {
+            delete packageJson.dependencies[HAMMER_MODULE_SPECIFIER];
+            tree.overwrite('/package.json', JSON.stringify(packageJson, null, 2));
+            return true;
+        }
+        return false;
+    }
+}
+exports.HammerGesturesMigration = HammerGesturesMigration;
+/** Global state of whether Hammer is used in any analyzed project target. */
+HammerGesturesMigration.globalUsesHammer = false;
+/**
+ * Recursively unwraps a given expression if it is wrapped
+ * by parenthesis, type casts or type assertions.
+ */
+function unwrapExpression(node) {
+    if (ts.isParenthesizedExpression(node)) {
+        return unwrapExpression(node.expression);
+    }
+    else if (ts.isAsExpression(node)) {
+        return unwrapExpression(node.expression);
+    }
+    else if (ts.isTypeAssertion(node)) {
+        return unwrapExpression(node.expression);
+    }
+    return node;
+}
+/**
+ * Converts the specified path to a valid TypeScript module specifier which is
+ * relative to the given containing file.
+ */
+function getModuleSpecifier(newPath, containingFile) {
+    let result = core_1.relative(core_1.dirname(containingFile), newPath).replace(/\\/g, '/').replace(/\.ts$/, '');
+    if (!result.startsWith('.')) {
+        result = `./${result}`;
+    }
+    return result;
+}
+/**
+ * Gets the text of the given property name.
+ * @returns Text of the given property name. Null if not statically analyzable.
+ */
+function getPropertyNameText(node) {
+    if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {
+        return node.text;
+    }
+    return null;
+}
+/** Checks whether the given identifier is part of a namespaced access. */
+function isNamespacedIdentifierAccess(node) {
+    return ts.isQualifiedName(node.parent) || ts.isPropertyAccessExpression(node.parent);
+}
+/**
+ * Walks through the specified node and returns all child nodes which match the
+ * given predicate.
+ */
+function findMatchingChildNodes(parent, predicate) {
+    const result = [];
+    const visitNode = (node) => {
+        if (predicate(node)) {
+            result.push(node);
+        }
+        ts.forEachChild(node, visitNode);
+    };
+    ts.forEachChild(parent, visitNode);
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hammer-gestures-migration.js","sourceRoot":"","sources":["../../../../../../../../../src/material/schematics/ng-update/migrations/hammer-gestures-v9/hammer-gestures-migration.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  join,\n  Path,\n  relative,\n  dirname\n} from '@angular-devkit/core';\nimport {SchematicContext, Tree} from '@angular-devkit/schematics';\nimport {\n  addSymbolToNgModuleMetadata,\n  DevkitMigration,\n  getDecoratorMetadata,\n  getImportOfIdentifier,\n  getMetadataField,\n  getProjectIndexFiles,\n  getProjectMainFile,\n  Import,\n  MigrationFailure,\n  PostMigrationAction,\n  ResolvedResource,\n  TargetVersion,\n} from '@angular/cdk/schematics';\nimport {InsertChange} from '@schematics/angular/utility/change';\nimport {readFileSync} from 'fs';\nimport * as ts from 'typescript';\n\nimport {findHammerScriptImportElements} from './find-hammer-script-tags';\nimport {findMainModuleExpression} from './find-main-module';\nimport {isHammerJsUsedInTemplate} from './hammer-template-check';\nimport {ImportManager} from './import-manager';\nimport {removeElementFromArrayExpression} from './remove-array-element';\nimport {removeElementFromHtml} from './remove-element-from-html';\n\nconst GESTURE_CONFIG_CLASS_NAME = 'GestureConfig';\nconst GESTURE_CONFIG_FILE_NAME = 'gesture-config';\nconst GESTURE_CONFIG_TEMPLATE_PATH = './gesture-config.template';\n\nconst HAMMER_CONFIG_TOKEN_NAME = 'HAMMER_GESTURE_CONFIG';\nconst HAMMER_CONFIG_TOKEN_MODULE = '@angular/platform-browser';\n\nconst HAMMER_MODULE_NAME = 'HammerModule';\nconst HAMMER_MODULE_IMPORT = '@angular/platform-browser';\n\nconst HAMMER_MODULE_SPECIFIER = 'hammerjs';\n\nconst CANNOT_REMOVE_REFERENCE_ERROR =\n    `Cannot remove reference to \"GestureConfig\". Please remove manually.`;\n\ninterface IdentifierReference {\n  node: ts.Identifier;\n  importData: Import;\n  isImport: boolean;\n}\n\ninterface PackageJson {\n  dependencies: Record<string, string>;\n}\n\nexport class HammerGesturesMigration extends DevkitMigration<null> {\n  // Only enable this rule if the migration targets v9 or v10 and is running for a non-test\n  // target. We cannot migrate test targets since they have a limited scope\n  // (in regards to source files) and therefore the HammerJS usage detection can be incorrect.\n  enabled =\n      (this.targetVersion === TargetVersion.V9 || this.targetVersion === TargetVersion.V10) &&\n      !this.context.isTestTarget;\n\n  private _printer = ts.createPrinter();\n  private _importManager = new ImportManager(this.fileSystem, this._printer);\n  private _nodeFailures: {node: ts.Node, message: string}[] = [];\n\n  /**\n   * Whether custom HammerJS events provided by the Material gesture\n   * config are used in a template.\n   */\n  private _customEventsUsedInTemplate = false;\n\n  /** Whether standard HammerJS events are used in a template. */\n  private _standardEventsUsedInTemplate = false;\n\n  /** Whether HammerJS is accessed at runtime. */\n  private _usedInRuntime = false;\n\n  /**\n   * List of imports that make \"hammerjs\" available globally. We keep track of these\n   * since we might need to remove them if Hammer is not used.\n   */\n  private _installImports: ts.ImportDeclaration[] = [];\n\n  /**\n   * List of identifiers which resolve to the gesture config from Angular Material.\n   */\n  private _gestureConfigReferences: IdentifierReference[] = [];\n\n  /**\n   * List of identifiers which resolve to the \"HAMMER_GESTURE_CONFIG\" token from\n   * \"@angular/platform-browser\".\n   */\n  private _hammerConfigTokenReferences: IdentifierReference[] = [];\n\n  /**\n   * List of identifiers which resolve to the \"HammerModule\" from\n   * \"@angular/platform-browser\".\n   */\n  private _hammerModuleReferences: IdentifierReference[] = [];\n\n  /**\n   * List of identifiers that have been deleted from source files. This can be\n   * used to determine if certain imports are still used or not.\n   */\n  private _deletedIdentifiers: ts.Identifier[] = [];\n\n  visitTemplate(template: ResolvedResource): void {\n    if (!this._customEventsUsedInTemplate || !this._standardEventsUsedInTemplate) {\n      const {standardEvents, customEvents} = isHammerJsUsedInTemplate(template.content);\n      this._customEventsUsedInTemplate = this._customEventsUsedInTemplate || customEvents;\n      this._standardEventsUsedInTemplate = this._standardEventsUsedInTemplate || standardEvents;\n    }\n  }\n\n  visitNode(node: ts.Node): void {\n    this._checkHammerImports(node);\n    this._checkForRuntimeHammerUsage(node);\n    this._checkForMaterialGestureConfig(node);\n    this._checkForHammerGestureConfigToken(node);\n    this._checkForHammerModuleReference(node);\n  }\n\n  postAnalysis(): void {\n    // Walk through all hammer config token references and check if there\n    // is a potential custom gesture config setup.\n    const hasCustomGestureConfigSetup =\n        this._hammerConfigTokenReferences.some(r => this._checkForCustomGestureConfigSetup(r));\n    const usedInTemplate = this._standardEventsUsedInTemplate || this._customEventsUsedInTemplate;\n\n    /*\n      Possible scenarios and how the migration should change the project:\n        1. We detect that a custom HammerJS gesture config is set up:\n            - Remove references to the Material gesture config if no HammerJS event is used.\n            - Print a warning about ambiguous configuration that cannot be handled completely\n              if there are references to the Material gesture config.\n        2. We detect that HammerJS is only used programmatically:\n            - Remove references to GestureConfig of Material.\n            - Remove references to the \"HammerModule\" if present.\n        3. We detect that standard HammerJS events are used in a template:\n            - Set up the \"HammerModule\" from platform-browser.\n            - Remove all gesture config references.\n        4. We detect that custom HammerJS events provided by the Material gesture\n           config are used.\n            - Copy the Material gesture config into the app.\n            - Rewrite all gesture config references to the newly copied one.\n            - Set up the new gesture config in the root app module.\n            - Set up the \"HammerModule\" from platform-browser.\n        4. We detect no HammerJS usage at all:\n            - Remove Hammer imports\n            - Remove Material gesture config references\n            - Remove HammerModule setup if present.\n            - Remove Hammer script imports in \"index.html\" files.\n    */\n\n    if (hasCustomGestureConfigSetup) {\n      // If a custom gesture config is provided, we always assume that HammerJS is used.\n      HammerGesturesMigration.globalUsesHammer = true;\n      if (!usedInTemplate && this._gestureConfigReferences.length) {\n        // If the Angular Material gesture events are not used and we found a custom\n        // gesture config, we can safely remove references to the Material gesture config\n        // since events provided by the Material gesture config are guaranteed to be unused.\n        this._removeMaterialGestureConfigSetup();\n        this.printInfo(\n            'The HammerJS v9 migration for Angular Components detected that HammerJS is ' +\n            'manually set up in combination with references to the Angular Material gesture ' +\n            'config. This target cannot be migrated completely, but all references to the ' +\n            'deprecated Angular Material gesture have been removed. Read more here: ' +\n            'https://git.io/ng-material-v9-hammer-ambiguous-usage');\n      } else if (usedInTemplate && this._gestureConfigReferences.length) {\n        // Since there is a reference to the Angular Material gesture config, and we detected\n        // usage of a gesture event that could be provided by Angular Material, we *cannot*\n        // automatically remove references. This is because we do *not* know whether the\n        // event is actually provided by the custom config or by the Material config.\n        this.printInfo(\n            'The HammerJS v9 migration for Angular Components detected that HammerJS is ' +\n            'manually set up in combination with references to the Angular Material gesture ' +\n            'config. This target cannot be migrated completely. Please manually remove ' +\n            'references to the deprecated Angular Material gesture config. Read more here: ' +\n            'https://git.io/ng-material-v9-hammer-ambiguous-usage');\n      }\n    } else if (this._usedInRuntime || usedInTemplate) {\n      // We keep track of whether Hammer is used globally. This is necessary because we\n      // want to only remove Hammer from the \"package.json\" if it is not used in any project\n      // target. Just because it isn't used in one target doesn't mean that we can safely\n      // remove the dependency.\n      HammerGesturesMigration.globalUsesHammer = true;\n\n      // If hammer is only used at runtime, we don't need the gesture config or \"HammerModule\"\n      // and can remove it (along with the hammer config token import if no longer needed).\n      if (!usedInTemplate) {\n        this._removeMaterialGestureConfigSetup();\n        this._removeHammerModuleReferences();\n      } else if (this._standardEventsUsedInTemplate && !this._customEventsUsedInTemplate) {\n        this._setupHammerWithStandardEvents();\n      } else {\n        this._setupHammerWithCustomEvents();\n      }\n    } else {\n      this._removeHammerSetup();\n    }\n\n    // Record the changes collected in the import manager. Changes need to be applied\n    // once the import manager registered all import modifications. This avoids collisions.\n    this._importManager.recordChanges();\n\n    // Create migration failures that will be printed by the update-tool on migration\n    // completion. We need special logic for updating failure positions to reflect\n    // the new source file after modifications from the import manager.\n    this.failures.push(...this._createMigrationFailures());\n\n    // The template check for HammerJS events is not completely reliable as the event\n    // output could also be from a component having an output named similarly to a known\n    // hammerjs event (e.g. \"@Output() slide\"). The usage is therefore somewhat ambiguous\n    // and we want to print a message that developers might be able to remove Hammer manually.\n    if (!hasCustomGestureConfigSetup && !this._usedInRuntime && usedInTemplate) {\n      this.printInfo(\n          'The HammerJS v9 migration for Angular Components migrated the ' +\n          'project to keep HammerJS installed, but detected ambiguous usage of HammerJS. Please ' +\n          'manually check if you can remove HammerJS from your application. More details: ' +\n          'https://git.io/ng-material-v9-hammer-ambiguous-usage');\n    }\n  }\n\n  /**\n   * Sets up the hammer gesture config in the current project. To achieve this, the\n   * following steps are performed:\n   *   1) Create copy of Angular Material gesture config.\n   *   2) Rewrite all references to the Angular Material gesture config to the\n   *      new gesture config.\n   *   3) Setup the HAMMER_GESTURE_CONFIG in the root app module (if not done already).\n   *   4) Setup the \"HammerModule\" in the root app module (if not done already).\n   */\n  private _setupHammerWithCustomEvents() {\n    const project = this.context.project;\n    const sourceRoot = this.fileSystem.resolve(project.sourceRoot || project.root);\n    const newConfigPath =\n        join(sourceRoot, this._getAvailableGestureConfigFileName(sourceRoot));\n\n    // Copy gesture config template into the CLI project.\n    this.fileSystem.create(\n        newConfigPath, readFileSync(require.resolve(GESTURE_CONFIG_TEMPLATE_PATH), 'utf8'));\n\n    // Replace all Material gesture config references to resolve to the\n    // newly copied gesture config.\n    this._gestureConfigReferences.forEach(i => {\n      const filePath = this.fileSystem.resolve(i.node.getSourceFile().fileName);\n      return this._replaceGestureConfigReference(i, GESTURE_CONFIG_CLASS_NAME,\n        getModuleSpecifier(newConfigPath, filePath));\n    });\n\n    // Setup the gesture config provider and the \"HammerModule\" in the root module\n    // if not done already. The \"HammerModule\" is needed in v9 since it enables the\n    // Hammer event plugin that was previously enabled by default in v8.\n    this._setupNewGestureConfigInRootModule(newConfigPath);\n    this._setupHammerModuleInRootModule();\n  }\n\n  /**\n   * Sets up the standard hammer module in the project and removes all\n   * references to the deprecated Angular Material gesture config.\n   */\n  private _setupHammerWithStandardEvents() {\n    // Setup the HammerModule. The HammerModule enables support for\n    // the standard HammerJS events.\n    this._setupHammerModuleInRootModule();\n    this._removeMaterialGestureConfigSetup();\n  }\n\n  /**\n   * Removes Hammer from the current project. The following steps are performed:\n   *   1) Delete all TypeScript imports to \"hammerjs\".\n   *   2) Remove references to the Angular Material gesture config.\n   *   3) Remove \"hammerjs\" from all index HTML files of the current project.\n   */\n  private _removeHammerSetup() {\n    this._installImports.forEach(i => this._importManager.deleteImportByDeclaration(i));\n\n    this._removeMaterialGestureConfigSetup();\n    this._removeHammerModuleReferences();\n    this._removeHammerFromIndexFile();\n  }\n\n  /**\n   * Removes the gesture config setup by deleting all found references to the Angular\n   * Material gesture config. Additionally, unused imports to the hammer gesture config\n   * token from \"@angular/platform-browser\" will be removed as well.\n   */\n  private _removeMaterialGestureConfigSetup() {\n    this._gestureConfigReferences.forEach(r => this._removeGestureConfigReference(r));\n\n    this._hammerConfigTokenReferences.forEach(r => {\n      if (r.isImport) {\n        this._removeHammerConfigTokenImportIfUnused(r);\n      }\n    });\n  }\n\n  /** Removes all references to the \"HammerModule\" from \"@angular/platform-browser\". */\n  private _removeHammerModuleReferences() {\n    this._hammerModuleReferences.forEach(({node, isImport, importData}) => {\n      const sourceFile = node.getSourceFile();\n      const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));\n\n      // Only remove the import for the HammerModule if the module has been accessed\n      // through a non-namespaced identifier access.\n      if (!isNamespacedIdentifierAccess(node)) {\n        this._importManager.deleteNamedBindingImport(\n            sourceFile, HAMMER_MODULE_NAME, importData.moduleName);\n      }\n\n      // For references from within an import, we do not need to do anything other than\n      // removing the import. For other references, we remove the import and the actual\n      // identifier in the module imports.\n      if (isImport) {\n        return;\n      }\n\n      // If the \"HammerModule\" is referenced within an array literal, we can\n      // remove the element easily. Otherwise if it's outside of an array literal,\n      // we need to replace the reference with an empty object literal w/ todo to\n      // not break the application.\n      if (ts.isArrayLiteralExpression(node.parent)) {\n        // Removes the \"HammerModule\" from the parent array expression. Removes\n        // the trailing comma token if present.\n        removeElementFromArrayExpression(node, recorder);\n      } else {\n        recorder.remove(node.getStart(), node.getWidth());\n        recorder.insertRight(node.getStart(), `/* TODO: remove */ {}`);\n        this._nodeFailures.push({\n          node: node,\n          message: 'Unable to delete reference to \"HammerModule\".',\n        });\n      }\n    });\n  }\n\n  /**\n   * Checks if the given node is a reference to the hammer gesture config\n   * token from platform-browser. If so, keeps track of the reference.\n   */\n  private _checkForHammerGestureConfigToken(node: ts.Node) {\n    if (ts.isIdentifier(node)) {\n      const importData = getImportOfIdentifier(node, this.typeChecker);\n      if (importData && importData.symbolName === HAMMER_CONFIG_TOKEN_NAME &&\n          importData.moduleName === HAMMER_CONFIG_TOKEN_MODULE) {\n        this._hammerConfigTokenReferences.push(\n            {node, importData, isImport: ts.isImportSpecifier(node.parent)});\n      }\n    }\n  }\n\n  /**\n   * Checks if the given node is a reference to the HammerModule from\n   * \"@angular/platform-browser\". If so, keeps track of the reference.\n   */\n  private _checkForHammerModuleReference(node: ts.Node) {\n    if (ts.isIdentifier(node)) {\n      const importData = getImportOfIdentifier(node, this.typeChecker);\n      if (importData && importData.symbolName === HAMMER_MODULE_NAME &&\n          importData.moduleName === HAMMER_MODULE_IMPORT) {\n        this._hammerModuleReferences.push(\n            {node, importData, isImport: ts.isImportSpecifier(node.parent)});\n      }\n    }\n  }\n\n  /**\n   * Checks if the given node is an import to the HammerJS package. Imports to\n   * HammerJS which load specific symbols from the package are considered as\n   * runtime usage of Hammer. e.g. `import {Symbol} from \"hammerjs\";`.\n   */\n  private _checkHammerImports(node: ts.Node) {\n    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) &&\n        node.moduleSpecifier.text === HAMMER_MODULE_SPECIFIER) {\n      // If there is an import to HammerJS that imports symbols, or is namespaced\n      // (e.g. \"import {A, B} from ...\" or \"import * as hammer from ...\"), then we\n      // assume that some exports are used at runtime.\n      if (node.importClause &&\n          !(node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings) &&\n            node.importClause.namedBindings.elements.length === 0)) {\n        this._usedInRuntime = true;\n      } else {\n        this._installImports.push(node);\n      }\n    }\n  }\n\n  /**\n   * Checks if the given node accesses the global \"Hammer\" symbol at runtime. If so,\n   * the migration rule state will be updated to reflect that Hammer is used at runtime.\n   */\n  private _checkForRuntimeHammerUsage(node: ts.Node) {\n    if (this._usedInRuntime) {\n      return;\n    }\n\n    // Detects usages of \"window.Hammer\".\n    if (ts.isPropertyAccessExpression(node) && node.name.text === 'Hammer') {\n      const originExpr = unwrapExpression(node.expression);\n      if (ts.isIdentifier(originExpr) && originExpr.text === 'window') {\n        this._usedInRuntime = true;\n      }\n      return;\n    }\n\n    // Detects usages of \"window['Hammer']\".\n    if (ts.isElementAccessExpression(node) && ts.isStringLiteral(node.argumentExpression) &&\n        node.argumentExpression.text === 'Hammer') {\n      const originExpr = unwrapExpression(node.expression);\n      if (ts.isIdentifier(originExpr) && originExpr.text === 'window') {\n        this._usedInRuntime = true;\n      }\n      return;\n    }\n\n    // Handles usages of plain identifier with the name \"Hammer\". These usage\n    // are valid if they resolve to \"@types/hammerjs\". e.g. \"new Hammer(myElement)\".\n    if (ts.isIdentifier(node) && node.text === 'Hammer' &&\n        !ts.isPropertyAccessExpression(node.parent) && !ts.isElementAccessExpression(node.parent)) {\n      const symbol = this._getDeclarationSymbolOfNode(node);\n      if (symbol && symbol.valueDeclaration &&\n          symbol.valueDeclaration.getSourceFile().fileName.includes('@types/hammerjs')) {\n        this._usedInRuntime = true;\n      }\n    }\n  }\n\n  /**\n   * Checks if the given node references the gesture config from Angular Material.\n   * If so, we keep track of the found symbol reference.\n   */\n  private _checkForMaterialGestureConfig(node: ts.Node) {\n    if (ts.isIdentifier(node)) {\n      const importData = getImportOfIdentifier(node, this.typeChecker);\n      if (importData && importData.symbolName === GESTURE_CONFIG_CLASS_NAME &&\n          importData.moduleName.startsWith('@angular/material/')) {\n        this._gestureConfigReferences.push(\n            {node, importData, isImport: ts.isImportSpecifier(node.parent)});\n      }\n    }\n  }\n\n  /**\n   * Checks if the given Hammer gesture config token reference is part of an\n   * Angular provider definition that sets up a custom gesture config.\n   */\n  private _checkForCustomGestureConfigSetup(tokenRef: IdentifierReference): boolean {\n    // Walk up the tree to look for a parent property assignment of the\n    // reference to the hammer gesture config token.\n    let propertyAssignment: ts.Node = tokenRef.node;\n    while (propertyAssignment && !ts.isPropertyAssignment(propertyAssignment)) {\n      propertyAssignment = propertyAssignment.parent;\n    }\n\n    if (!propertyAssignment || !ts.isPropertyAssignment(propertyAssignment) ||\n        getPropertyNameText(propertyAssignment.name) !== 'provide') {\n      return false;\n    }\n\n    const objectLiteralExpr = propertyAssignment.parent;\n    const matchingIdentifiers = findMatchingChildNodes(objectLiteralExpr, ts.isIdentifier);\n\n    // We naively assume that if there is a reference to the \"GestureConfig\" export\n    // from Angular Material in the provider literal, that the provider sets up the\n    // Angular Material gesture config.\n    return !this._gestureConfigReferences.some(r => matchingIdentifiers.includes(r.node));\n  }\n\n  /**\n   * Determines an available file name for the gesture config which should\n   * be stored in the specified file path.\n   */\n  private _getAvailableGestureConfigFileName(sourceRoot: Path) {\n    if (!this.fileSystem.exists(join(sourceRoot, `${GESTURE_CONFIG_FILE_NAME}.ts`))) {\n      return `${GESTURE_CONFIG_FILE_NAME}.ts`;\n    }\n\n    let possibleName = `${GESTURE_CONFIG_FILE_NAME}-`;\n    let index = 1;\n    while (this.fileSystem.exists(join(sourceRoot, `${possibleName}-${index}.ts`))) {\n      index++;\n    }\n    return `${possibleName + index}.ts`;\n  }\n\n  /** Replaces a given gesture config reference with a new import. */\n  private _replaceGestureConfigReference(\n      {node, importData, isImport}: IdentifierReference, symbolName: string,\n      moduleSpecifier: string) {\n    const sourceFile = node.getSourceFile();\n    const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));\n\n    // List of all identifiers referring to the gesture config in the current file. This\n    // allows us to add an import for the copied gesture configuration without generating a\n    // new identifier for the import to avoid collisions. i.e. \"GestureConfig_1\". The import\n    // manager checks for possible name collisions, but is able to ignore specific identifiers.\n    // We use this to ignore all references to the original Angular Material gesture config,\n    // because these will be replaced and therefore will not interfere.\n    const gestureIdentifiersInFile = this._getGestureConfigIdentifiersOfFile(sourceFile);\n\n    // If the parent of the identifier is accessed through a namespace, we can just\n    // import the new gesture config without rewriting the import declaration because\n    // the config has been imported through a namespaced import.\n    if (isNamespacedIdentifierAccess(node)) {\n      const newExpression = this._importManager.addImportToSourceFile(\n          sourceFile, symbolName, moduleSpecifier, false, gestureIdentifiersInFile);\n\n      recorder.remove(node.parent.getStart(), node.parent.getWidth());\n      recorder.insertRight(node.parent.getStart(), this._printNode(newExpression, sourceFile));\n      return;\n    }\n\n    // Delete the old import to the \"GestureConfig\".\n    this._importManager.deleteNamedBindingImport(\n        sourceFile, GESTURE_CONFIG_CLASS_NAME, importData.moduleName);\n\n    // If the current reference is not from inside of a import, we need to add a new\n    // import to the copied gesture config and replace the identifier. For references\n    // within an import, we do nothing but removing the actual import. This allows us\n    // to remove unused imports to the Material gesture config.\n    if (!isImport) {\n      const newExpression = this._importManager.addImportToSourceFile(\n          sourceFile, symbolName, moduleSpecifier, false, gestureIdentifiersInFile);\n\n      recorder.remove(node.getStart(), node.getWidth());\n      recorder.insertRight(node.getStart(), this._printNode(newExpression, sourceFile));\n    }\n  }\n\n  /**\n   * Removes a given gesture config reference and its corresponding import from\n   * its containing source file. Imports will be always removed, but in some cases,\n   * where it's not guaranteed that a removal can be performed safely, we just\n   * create a migration failure (and add a TODO if possible).\n   */\n  private _removeGestureConfigReference({node, importData, isImport}: IdentifierReference) {\n    const sourceFile = node.getSourceFile();\n    const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));\n    // Only remove the import for the gesture config if the gesture config has\n    // been accessed through a non-namespaced identifier access.\n    if (!isNamespacedIdentifierAccess(node)) {\n      this._importManager.deleteNamedBindingImport(\n          sourceFile, GESTURE_CONFIG_CLASS_NAME, importData.moduleName);\n    }\n\n    // For references from within an import, we do not need to do anything other than\n    // removing the import. For other references, we remove the import and the reference\n    // identifier if used inside of a provider definition.\n    if (isImport) {\n      return;\n    }\n\n    const providerAssignment = node.parent;\n\n    // Only remove references to the gesture config which are part of a statically\n    // analyzable provider definition. We only support the common case of a gesture\n    // config provider definition where the config is set up through \"useClass\".\n    // Otherwise, it's not guaranteed that we can safely remove the provider definition.\n    if (!ts.isPropertyAssignment(providerAssignment) ||\n        getPropertyNameText(providerAssignment.name) !== 'useClass') {\n      this._nodeFailures.push({node, message: CANNOT_REMOVE_REFERENCE_ERROR});\n      return;\n    }\n\n    const objectLiteralExpr = providerAssignment.parent;\n    const provideToken = objectLiteralExpr.properties.find(\n        (p): p is ts.PropertyAssignment =>\n            ts.isPropertyAssignment(p) && getPropertyNameText(p.name) === 'provide');\n\n    // Do not remove the reference if the gesture config is not part of a provider definition,\n    // or if the provided toke is not referring to the known HAMMER_GESTURE_CONFIG token\n    // from platform-browser.\n    if (!provideToken || !this._isReferenceToHammerConfigToken(provideToken.initializer)) {\n      this._nodeFailures.push({node, message: CANNOT_REMOVE_REFERENCE_ERROR});\n      return;\n    }\n\n    // Collect all nested identifiers which will be deleted. This helps us\n    // determining if we can remove imports for the \"HAMMER_GESTURE_CONFIG\" token.\n    this._deletedIdentifiers.push(...findMatchingChildNodes(objectLiteralExpr, ts.isIdentifier));\n\n    // In case the found provider definition is not part of an array literal,\n    // we cannot safely remove the provider. This is because it could be declared\n    // as a variable. e.g. \"const gestureProvider = {provide: .., useClass: GestureConfig}\".\n    // In that case, we just add an empty object literal with TODO and print a failure.\n    if (!ts.isArrayLiteralExpression(objectLiteralExpr.parent)) {\n      recorder.remove(objectLiteralExpr.getStart(), objectLiteralExpr.getWidth());\n      recorder.insertRight(objectLiteralExpr.getStart(), `/* TODO: remove */ {}`);\n      this._nodeFailures.push({\n        node: objectLiteralExpr,\n        message: `Unable to delete provider definition for \"GestureConfig\" completely. ` +\n            `Please clean up the provider.`\n      });\n      return;\n    }\n\n    // Removes the object literal from the parent array expression. Removes\n    // the trailing comma token if present.\n    removeElementFromArrayExpression(objectLiteralExpr, recorder);\n  }\n\n  /** Removes the given hammer config token import if it is not used. */\n  private _removeHammerConfigTokenImportIfUnused({node, importData}: IdentifierReference) {\n    const sourceFile = node.getSourceFile();\n    const isTokenUsed = this._hammerConfigTokenReferences.some(\n        r => !r.isImport && !isNamespacedIdentifierAccess(r.node) &&\n            r.node.getSourceFile() === sourceFile && !this._deletedIdentifiers.includes(r.node));\n\n    // We don't want to remove the import for the token if the token is\n    // still used somewhere.\n    if (!isTokenUsed) {\n      this._importManager.deleteNamedBindingImport(\n          sourceFile, HAMMER_CONFIG_TOKEN_NAME, importData.moduleName);\n    }\n  }\n\n  /** Removes Hammer from all index HTML files of the current project. */\n  private _removeHammerFromIndexFile() {\n    const indexFilePaths = getProjectIndexFiles(this.context.project);\n    indexFilePaths.forEach(filePath => {\n      if (!this.fileSystem.exists(filePath)) {\n        return;\n      }\n\n      const htmlContent = this.fileSystem.read(filePath)!;\n      const recorder = this.fileSystem.edit(filePath);\n\n      findHammerScriptImportElements(htmlContent)\n          .forEach(el => removeElementFromHtml(el, recorder));\n    });\n  }\n\n  /** Sets up the Hammer gesture config in the root module if needed. */\n  private _setupNewGestureConfigInRootModule(gestureConfigPath: Path) {\n    const {project} = this.context;\n    const mainFilePath = getProjectMainFile(project);\n    const rootModuleSymbol = this._getRootModuleSymbol(mainFilePath);\n\n    if (rootModuleSymbol === null || rootModuleSymbol.valueDeclaration === undefined) {\n      this.failures.push({\n        filePath: mainFilePath,\n        message: `Could not setup Hammer gestures in module. Please ` +\n            `manually ensure that the Hammer gesture config is set up.`,\n      });\n      return;\n    }\n\n    const sourceFile = rootModuleSymbol.valueDeclaration.getSourceFile();\n    const metadata = getDecoratorMetadata(sourceFile, 'NgModule', '@angular/core') as\n        ts.ObjectLiteralExpression[];\n\n    // If no \"NgModule\" definition is found inside the source file, we just do nothing.\n    if (!metadata.length) {\n      return;\n    }\n\n    const filePath = this.fileSystem.resolve(sourceFile.fileName);\n    const recorder = this.fileSystem.edit(filePath);\n    const providersField = getMetadataField(metadata[0], 'providers')[0];\n    const providerIdentifiers =\n        providersField ? findMatchingChildNodes(providersField, ts.isIdentifier) : null;\n    const gestureConfigExpr = this._importManager.addImportToSourceFile(\n        sourceFile, GESTURE_CONFIG_CLASS_NAME,\n        getModuleSpecifier(gestureConfigPath, filePath), false,\n        this._getGestureConfigIdentifiersOfFile(sourceFile));\n    const hammerConfigTokenExpr = this._importManager.addImportToSourceFile(\n        sourceFile, HAMMER_CONFIG_TOKEN_NAME, HAMMER_CONFIG_TOKEN_MODULE);\n    const newProviderNode = ts.createObjectLiteral([\n      ts.createPropertyAssignment('provide', hammerConfigTokenExpr),\n      ts.createPropertyAssignment('useClass', gestureConfigExpr)\n    ]);\n\n    // If the providers field exists and already contains references to the hammer gesture\n    // config token and the gesture config, we naively assume that the gesture config is\n    // already set up. We only want to add the gesture config provider if it is not set up.\n    if (!providerIdentifiers ||\n        !(this._hammerConfigTokenReferences.some(r => providerIdentifiers.includes(r.node)) &&\n          this._gestureConfigReferences.some(r => providerIdentifiers.includes(r.node)))) {\n      const symbolName = this._printNode(newProviderNode, sourceFile);\n      addSymbolToNgModuleMetadata(sourceFile, sourceFile.fileName, 'providers', symbolName, null)\n        .forEach(change => {\n          if (change instanceof InsertChange) {\n            recorder.insertRight(change.pos, change.toAdd);\n          }\n        });\n    }\n  }\n\n  /**\n   * Gets the TypeScript symbol of the root module by looking for the module\n   * bootstrap expression in the specified source file.\n   */\n  private _getRootModuleSymbol(mainFilePath: Path): ts.Symbol|null {\n    const mainFile = this.program.getSourceFile(mainFilePath);\n    if (!mainFile) {\n      return null;\n    }\n\n    const appModuleExpr = findMainModuleExpression(mainFile);\n    if (!appModuleExpr) {\n      return null;\n    }\n\n    const appModuleSymbol = this._getDeclarationSymbolOfNode(unwrapExpression(appModuleExpr));\n    if (!appModuleSymbol || !appModuleSymbol.valueDeclaration) {\n      return null;\n    }\n    return appModuleSymbol;\n  }\n\n  /** Sets up the \"HammerModule\" in the root module of the current project. */\n  private _setupHammerModuleInRootModule() {\n    const {project} = this.context;\n    const mainFilePath = getProjectMainFile(project);\n    const rootModuleSymbol = this._getRootModuleSymbol(mainFilePath);\n\n    if (rootModuleSymbol === null || rootModuleSymbol.valueDeclaration === undefined) {\n      this.failures.push({\n        filePath: mainFilePath,\n        message: `Could not setup HammerModule. Please manually set up the \"HammerModule\" ` +\n            `from \"@angular/platform-browser\".`,\n      });\n      return;\n    }\n\n    const sourceFile = rootModuleSymbol.valueDeclaration.getSourceFile();\n    const metadata = getDecoratorMetadata(sourceFile, 'NgModule', '@angular/core') as\n        ts.ObjectLiteralExpression[];\n    if (!metadata.length) {\n      return;\n    }\n\n    const importsField = getMetadataField(metadata[0], 'imports')[0];\n    const importIdentifiers =\n        importsField ? findMatchingChildNodes(importsField, ts.isIdentifier) : null;\n    const recorder = this.fileSystem.edit(this.fileSystem.resolve(sourceFile.fileName));\n    const hammerModuleExpr = this._importManager.addImportToSourceFile(\n        sourceFile, HAMMER_MODULE_NAME, HAMMER_MODULE_IMPORT);\n\n    // If the \"HammerModule\" is not already imported in the app module, we set it up\n    // by adding it to the \"imports\" field of the app module.\n    if (!importIdentifiers ||\n        !this._hammerModuleReferences.some(r => importIdentifiers.includes(r.node))) {\n      const symbolName = this._printNode(hammerModuleExpr, sourceFile);\n      addSymbolToNgModuleMetadata(sourceFile, sourceFile.fileName, 'imports', symbolName, null)\n        .forEach(change => {\n          if (change instanceof InsertChange) {\n            recorder.insertRight(change.pos, change.toAdd);\n          }\n        });\n    }\n  }\n\n  /** Prints a given node within the specified source file. */\n  private _printNode(node: ts.Node, sourceFile: ts.SourceFile): string {\n    return this._printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);\n  }\n\n  /** Gets all referenced gesture config identifiers of a given source file */\n  private _getGestureConfigIdentifiersOfFile(sourceFile: ts.SourceFile): ts.Identifier[] {\n    return this._gestureConfigReferences.filter(d => d.node.getSourceFile() === sourceFile)\n        .map(d => d.node);\n  }\n\n  /** Gets the symbol that contains the value declaration of the specified node. */\n  private _getDeclarationSymbolOfNode(node: ts.Node): ts.Symbol|undefined {\n    const symbol = this.typeChecker.getSymbolAtLocation(node);\n\n    // Symbols can be aliases of the declaration symbol. e.g. in named import specifiers.\n    // We need to resolve the aliased symbol back to the declaration symbol.\n    // tslint:disable-next-line:no-bitwise\n    if (symbol && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {\n      return this.typeChecker.getAliasedSymbol(symbol);\n    }\n    return symbol;\n  }\n\n  /**\n   * Checks whether the given expression resolves to a hammer gesture config\n   * token reference from \"@angular/platform-browser\".\n   */\n  private _isReferenceToHammerConfigToken(expr: ts.Expression) {\n    const unwrapped = unwrapExpression(expr);\n    if (ts.isIdentifier(unwrapped)) {\n      return this._hammerConfigTokenReferences.some(r => r.node === unwrapped);\n    } else if (ts.isPropertyAccessExpression(unwrapped)) {\n      return this._hammerConfigTokenReferences.some(r => r.node === unwrapped.name);\n    }\n    return false;\n  }\n\n  /**\n   * Creates migration failures of the collected node failures. The returned migration\n   * failures are updated to reflect the post-migration state of source files. Meaning\n   * that failure positions are corrected if source file modifications shifted lines.\n   */\n  private _createMigrationFailures(): MigrationFailure[] {\n    return this._nodeFailures.map(({node, message}) => {\n      const sourceFile = node.getSourceFile();\n      const offset = node.getStart();\n      const position = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart());\n      return {\n        position: this._importManager.correctNodePosition(node, offset, position),\n        message: message,\n        filePath: this.fileSystem.resolve(sourceFile.fileName),\n      };\n    });\n  }\n\n  /** Global state of whether Hammer is used in any analyzed project target. */\n  static globalUsesHammer = false;\n\n  /**\n   * Static migration rule method that will be called once all project targets\n   * have been migrated individually. This method can be used to make changes based\n   * on the analysis of the individual targets. For example: we only remove Hammer\n   * from the \"package.json\" if it is not used in *any* project target.\n   */\n  static globalPostMigration(tree: Tree, context: SchematicContext): PostMigrationAction {\n    // Always notify the developer that the Hammer v9 migration does not migrate tests.\n    context.logger.info(\n        '\\n⚠  General notice: The HammerJS v9 migration for Angular Components is not able to ' +\n        'migrate tests. Please manually clean up tests in your project if they rely on ' +\n        (this.globalUsesHammer ? 'the deprecated Angular Material gesture config.' : 'HammerJS.'));\n    context.logger.info(\n        'Read more about migrating tests: https://git.io/ng-material-v9-hammer-migrate-tests');\n\n    if (!this.globalUsesHammer && this._removeHammerFromPackageJson(tree)) {\n      // Since Hammer has been removed from the workspace \"package.json\" file,\n      // we schedule a node package install task to refresh the lock file.\n      return {runPackageManager: true};\n    }\n\n    // Clean global state once the workspace has been migrated. This is technically\n    // not necessary in \"ng update\", but in tests we re-use the same rule class.\n    this.globalUsesHammer = false;\n  }\n\n  /**\n   * Removes the hammer package from the workspace \"package.json\".\n   * @returns Whether Hammer was set up and has been removed from the \"package.json\"\n   */\n  private static _removeHammerFromPackageJson(tree: Tree): boolean {\n    if (!tree.exists('/package.json')) {\n      return false;\n    }\n\n    const packageJson = JSON.parse(tree.read('/package.json')!.toString('utf8')) as PackageJson;\n\n    // We do not handle the case where someone manually added \"hammerjs\" to the dev dependencies.\n    if (packageJson.dependencies && packageJson.dependencies[HAMMER_MODULE_SPECIFIER]) {\n      delete packageJson.dependencies[HAMMER_MODULE_SPECIFIER];\n      tree.overwrite('/package.json', JSON.stringify(packageJson, null, 2));\n      return true;\n    }\n    return false;\n  }\n}\n\n/**\n * Recursively unwraps a given expression if it is wrapped\n * by parenthesis, type casts or type assertions.\n */\nfunction unwrapExpression(node: ts.Node): ts.Node {\n  if (ts.isParenthesizedExpression(node)) {\n    return unwrapExpression(node.expression);\n  } else if (ts.isAsExpression(node)) {\n    return unwrapExpression(node.expression);\n  } else if (ts.isTypeAssertion(node)) {\n    return unwrapExpression(node.expression);\n  }\n  return node;\n}\n\n/**\n * Converts the specified path to a valid TypeScript module specifier which is\n * relative to the given containing file.\n */\nfunction getModuleSpecifier(newPath: Path, containingFile: Path) {\n  let result = relative(dirname(containingFile), newPath).replace(/\\\\/g, '/').replace(/\\.ts$/, '');\n  if (!result.startsWith('.')) {\n    result = `./${result}`;\n  }\n  return result;\n}\n\n/**\n * Gets the text of the given property name.\n * @returns Text of the given property name. Null if not statically analyzable.\n */\nfunction getPropertyNameText(node: ts.PropertyName): string|null {\n  if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) {\n    return node.text;\n  }\n  return null;\n}\n\n/** Checks whether the given identifier is part of a namespaced access. */\nfunction isNamespacedIdentifierAccess(node: ts.Identifier): boolean {\n  return ts.isQualifiedName(node.parent) || ts.isPropertyAccessExpression(node.parent);\n}\n\n/**\n * Walks through the specified node and returns all child nodes which match the\n * given predicate.\n */\nfunction findMatchingChildNodes<T extends ts.Node>(\n    parent: ts.Node, predicate: (node: ts.Node) => node is T): T[] {\n  const result: T[] = [];\n  const visitNode = (node: ts.Node) => {\n    if (predicate(node)) {\n      result.push(node);\n    }\n    ts.forEachChild(node, visitNode);\n  };\n  ts.forEachChild(parent, visitNode);\n  return result;\n}\n"]}