node_modules/@angular/core/schematics/migrations/abstract-control-parent/util.js

/**
 * @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
 */
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define("@angular/core/schematics/migrations/abstract-control-parent/util", ["require", "exports", "path", "typescript"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    exports.findParentAccesses = void 0;
    const path_1 = require("path");
    const ts = require("typescript");
    /** Names of symbols from `@angular/forms` whose `parent` accesses have to be migrated. */
    const abstractControlSymbols = new Set([
        'AbstractControl',
        'FormArray',
        'FormControl',
        'FormGroup',
    ]);
    /**
     * Finds the `PropertyAccessExpression`-s that are accessing the `parent` property in
     * such a way that may result in a compilation error after the v11 type changes.
     */
    function findParentAccesses(typeChecker, sourceFile) {
        const results = [];
        sourceFile.forEachChild(function walk(node) {
            if (ts.isPropertyAccessExpression(node) && node.name.text === 'parent' && !isNullCheck(node) &&
                !isSafeAccess(node) && results.indexOf(node) === -1 &&
                isAbstractControlReference(typeChecker, node) && isNullableType(typeChecker, node)) {
                results.unshift(node);
            }
            node.forEachChild(walk);
        });
        return results;
    }
    exports.findParentAccesses = findParentAccesses;
    /** Checks whether a node's type is nullable (`null`, `undefined` or `void`). */
    function isNullableType(typeChecker, node) {
        // Skip expressions in the form of `foo.bar!.baz` since the `TypeChecker` seems
        // to identify them as null, even though the user indicated that it won't be.
        if (node.parent && ts.isNonNullExpression(node.parent)) {
            return false;
        }
        const type = typeChecker.getTypeAtLocation(node);
        const typeNode = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.None);
        let hasSeenNullableType = false;
        // Trace the type of the node back to a type node, walk
        // through all of its sub-nodes and look for nullable tyes.
        if (typeNode) {
            (function walk(current) {
                if (current.kind === ts.SyntaxKind.NullKeyword ||
                    current.kind === ts.SyntaxKind.UndefinedKeyword ||
                    current.kind === ts.SyntaxKind.VoidKeyword) {
                    hasSeenNullableType = true;
                    // Note that we don't descend into type literals, because it may cause
                    // us to mis-identify the root type as nullable, because it has a nullable
                    // property (e.g. `{ foo: string | null }`).
                }
                else if (!hasSeenNullableType && !ts.isTypeLiteralNode(current)) {
                    current.forEachChild(walk);
                }
            })(typeNode);
        }
        return hasSeenNullableType;
    }
    /**
     * Checks whether a particular node is part of a null check. E.g. given:
     * `control.parent ? control.parent.value : null` the null check would be `control.parent`.
     */
    function isNullCheck(node) {
        if (!node.parent) {
            return false;
        }
        // `control.parent && control.parent.value` where `node` is `control.parent`.
        if (ts.isBinaryExpression(node.parent) && node.parent.left === node) {
            return true;
        }
        // `control.parent && control.parent.parent && control.parent.parent.value`
        // where `node` is `control.parent`.
        if (node.parent.parent && ts.isBinaryExpression(node.parent.parent) &&
            node.parent.parent.left === node.parent) {
            return true;
        }
        // `if (control.parent) {...}` where `node` is `control.parent`.
        if (ts.isIfStatement(node.parent) && node.parent.expression === node) {
            return true;
        }
        // `control.parent ? control.parent.value : null` where `node` is `control.parent`.
        if (ts.isConditionalExpression(node.parent) && node.parent.condition === node) {
            return true;
        }
        return false;
    }
    /** Checks whether a property access is safe (e.g. `foo.parent?.value`). */
    function isSafeAccess(node) {
        return node.parent != null && ts.isPropertyAccessExpression(node.parent) &&
            node.parent.expression === node && node.parent.questionDotToken != null;
    }
    /** Checks whether a property access is on an `AbstractControl` coming from `@angular/forms`. */
    function isAbstractControlReference(typeChecker, node) {
        var _a;
        let current = node;
        const formsPattern = /node_modules\/?.*\/@angular\/forms/;
        // Walks up the property access chain and tries to find a symbol tied to a `SourceFile`.
        // If such a node is found, we check whether the type is one of the `AbstractControl` symbols
        // and whether it comes from the `@angular/forms` directory in the `node_modules`.
        while (ts.isPropertyAccessExpression(current)) {
            const type = typeChecker.getTypeAtLocation(current.expression);
            const symbol = type.getSymbol();
            if (symbol && type) {
                const sourceFile = (_a = symbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.getSourceFile();
                return sourceFile != null &&
                    formsPattern.test(path_1.normalize(sourceFile.fileName).replace(/\\/g, '/')) &&
                    hasAbstractControlType(typeChecker, type);
            }
            current = current.expression;
        }
        return false;
    }
    /**
     * Walks through the sub-types of a type, looking for a type that
     * has the same name as one of the `AbstractControl` types.
     */
    function hasAbstractControlType(typeChecker, type) {
        const typeNode = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.None);
        let hasMatch = false;
        if (typeNode) {
            (function walk(current) {
                if (ts.isIdentifier(current) && abstractControlSymbols.has(current.text)) {
                    hasMatch = true;
                    // Note that we don't descend into type literals, because it may cause
                    // us to mis-identify the root type as nullable, because it has a nullable
                    // property (e.g. `{ foo: FormControl }`).
                }
                else if (!hasMatch && !ts.isTypeLiteralNode(current)) {
                    current.forEachChild(walk);
                }
            })(typeNode);
        }
        return hasMatch;
    }
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../../../packages/core/schematics/migrations/abstract-control-parent/util.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 {normalize} from 'path';\nimport * as ts from 'typescript';\n\n/** Names of symbols from `@angular/forms` whose `parent` accesses have to be migrated. */\nconst abstractControlSymbols = new Set<string>([\n  'AbstractControl',\n  'FormArray',\n  'FormControl',\n  'FormGroup',\n]);\n\n/**\n * Finds the `PropertyAccessExpression`-s that are accessing the `parent` property in\n * such a way that may result in a compilation error after the v11 type changes.\n */\nexport function findParentAccesses(\n    typeChecker: ts.TypeChecker, sourceFile: ts.SourceFile): ts.PropertyAccessExpression[] {\n  const results: ts.PropertyAccessExpression[] = [];\n\n  sourceFile.forEachChild(function walk(node: ts.Node) {\n    if (ts.isPropertyAccessExpression(node) && node.name.text === 'parent' && !isNullCheck(node) &&\n        !isSafeAccess(node) && results.indexOf(node) === -1 &&\n        isAbstractControlReference(typeChecker, node) && isNullableType(typeChecker, node)) {\n      results.unshift(node);\n    }\n\n    node.forEachChild(walk);\n  });\n\n  return results;\n}\n\n/** Checks whether a node's type is nullable (`null`, `undefined` or `void`). */\nfunction isNullableType(typeChecker: ts.TypeChecker, node: ts.Node) {\n  // Skip expressions in the form of `foo.bar!.baz` since the `TypeChecker` seems\n  // to identify them as null, even though the user indicated that it won't be.\n  if (node.parent && ts.isNonNullExpression(node.parent)) {\n    return false;\n  }\n\n  const type = typeChecker.getTypeAtLocation(node);\n  const typeNode = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.None);\n  let hasSeenNullableType = false;\n\n  // Trace the type of the node back to a type node, walk\n  // through all of its sub-nodes and look for nullable tyes.\n  if (typeNode) {\n    (function walk(current: ts.Node) {\n      if (current.kind === ts.SyntaxKind.NullKeyword ||\n          current.kind === ts.SyntaxKind.UndefinedKeyword ||\n          current.kind === ts.SyntaxKind.VoidKeyword) {\n        hasSeenNullableType = true;\n        // Note that we don't descend into type literals, because it may cause\n        // us to mis-identify the root type as nullable, because it has a nullable\n        // property (e.g. `{ foo: string | null }`).\n      } else if (!hasSeenNullableType && !ts.isTypeLiteralNode(current)) {\n        current.forEachChild(walk);\n      }\n    })(typeNode);\n  }\n\n  return hasSeenNullableType;\n}\n\n/**\n * Checks whether a particular node is part of a null check. E.g. given:\n * `control.parent ? control.parent.value : null` the null check would be `control.parent`.\n */\nfunction isNullCheck(node: ts.PropertyAccessExpression): boolean {\n  if (!node.parent) {\n    return false;\n  }\n\n  // `control.parent && control.parent.value` where `node` is `control.parent`.\n  if (ts.isBinaryExpression(node.parent) && node.parent.left === node) {\n    return true;\n  }\n\n  // `control.parent && control.parent.parent && control.parent.parent.value`\n  // where `node` is `control.parent`.\n  if (node.parent.parent && ts.isBinaryExpression(node.parent.parent) &&\n      node.parent.parent.left === node.parent) {\n    return true;\n  }\n\n  // `if (control.parent) {...}` where `node` is `control.parent`.\n  if (ts.isIfStatement(node.parent) && node.parent.expression === node) {\n    return true;\n  }\n\n  // `control.parent ? control.parent.value : null` where `node` is `control.parent`.\n  if (ts.isConditionalExpression(node.parent) && node.parent.condition === node) {\n    return true;\n  }\n\n  return false;\n}\n\n/** Checks whether a property access is safe (e.g. `foo.parent?.value`). */\nfunction isSafeAccess(node: ts.PropertyAccessExpression): boolean {\n  return node.parent != null && ts.isPropertyAccessExpression(node.parent) &&\n      node.parent.expression === node && node.parent.questionDotToken != null;\n}\n\n/** Checks whether a property access is on an `AbstractControl` coming from `@angular/forms`. */\nfunction isAbstractControlReference(\n    typeChecker: ts.TypeChecker, node: ts.PropertyAccessExpression): boolean {\n  let current: ts.Expression = node;\n  const formsPattern = /node_modules\\/?.*\\/@angular\\/forms/;\n  // Walks up the property access chain and tries to find a symbol tied to a `SourceFile`.\n  // If such a node is found, we check whether the type is one of the `AbstractControl` symbols\n  // and whether it comes from the `@angular/forms` directory in the `node_modules`.\n  while (ts.isPropertyAccessExpression(current)) {\n    const type = typeChecker.getTypeAtLocation(current.expression);\n    const symbol = type.getSymbol();\n    if (symbol && type) {\n      const sourceFile = symbol.valueDeclaration?.getSourceFile();\n      return sourceFile != null &&\n          formsPattern.test(normalize(sourceFile.fileName).replace(/\\\\/g, '/')) &&\n          hasAbstractControlType(typeChecker, type);\n    }\n    current = current.expression;\n  }\n  return false;\n}\n\n/**\n * Walks through the sub-types of a type, looking for a type that\n * has the same name as one of the `AbstractControl` types.\n */\nfunction hasAbstractControlType(typeChecker: ts.TypeChecker, type: ts.Type): boolean {\n  const typeNode = typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.None);\n  let hasMatch = false;\n  if (typeNode) {\n    (function walk(current: ts.Node) {\n      if (ts.isIdentifier(current) && abstractControlSymbols.has(current.text)) {\n        hasMatch = true;\n        // Note that we don't descend into type literals, because it may cause\n        // us to mis-identify the root type as nullable, because it has a nullable\n        // property (e.g. `{ foo: FormControl }`).\n      } else if (!hasMatch && !ts.isTypeLiteralNode(current)) {\n        current.forEachChild(walk);\n      }\n    })(typeNode);\n  }\n  return hasMatch;\n}\n"]}