5ce71e0fbc
Adds a migration that finds all imports and calls to the deprecated `async` function from `@angular/core/testing` and replaces them with `waitForAsync`. These changes also move a bit of code out of the `Renderer2` migration so that it can be reused. PR Close #39212
81 lines
3.2 KiB
TypeScript
81 lines
3.2 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
import * as ts from 'typescript';
|
|
|
|
import {getImportSpecifier} from '../../utils/typescript/imports';
|
|
import {isReferenceToImport} from '../../utils/typescript/symbol';
|
|
|
|
/**
|
|
* Finds typed nodes (e.g. function parameters or class properties) that are referencing the old
|
|
* `Renderer`, as well as calls to the `Renderer` methods.
|
|
*/
|
|
export function findRendererReferences(
|
|
sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker,
|
|
rendererImportSpecifier: ts.ImportSpecifier) {
|
|
const typedNodes = new Set<ts.ParameterDeclaration|ts.PropertyDeclaration|ts.AsExpression>();
|
|
const methodCalls = new Set<ts.CallExpression>();
|
|
const forwardRefs = new Set<ts.Identifier>();
|
|
const forwardRefSpecifier = getImportSpecifier(sourceFile, '@angular/core', 'forwardRef');
|
|
|
|
ts.forEachChild(sourceFile, function visitNode(node: ts.Node) {
|
|
if ((ts.isParameter(node) || ts.isPropertyDeclaration(node)) &&
|
|
isReferenceToImport(typeChecker, node.name, rendererImportSpecifier)) {
|
|
typedNodes.add(node);
|
|
} else if (
|
|
ts.isAsExpression(node) &&
|
|
isReferenceToImport(typeChecker, node.type, rendererImportSpecifier)) {
|
|
typedNodes.add(node);
|
|
} else if (ts.isCallExpression(node)) {
|
|
if (ts.isPropertyAccessExpression(node.expression) &&
|
|
isReferenceToImport(typeChecker, node.expression.expression, rendererImportSpecifier)) {
|
|
methodCalls.add(node);
|
|
} else if (
|
|
// If we're dealing with a forwardRef that's returning a Renderer.
|
|
forwardRefSpecifier && ts.isIdentifier(node.expression) &&
|
|
isReferenceToImport(typeChecker, node.expression, forwardRefSpecifier) &&
|
|
node.arguments.length) {
|
|
const rendererIdentifier =
|
|
findRendererIdentifierInForwardRef(typeChecker, node, rendererImportSpecifier);
|
|
if (rendererIdentifier) {
|
|
forwardRefs.add(rendererIdentifier);
|
|
}
|
|
}
|
|
}
|
|
|
|
ts.forEachChild(node, visitNode);
|
|
});
|
|
|
|
return {typedNodes, methodCalls, forwardRefs};
|
|
}
|
|
|
|
/** Finds the identifier referring to the `Renderer` inside a `forwardRef` call expression. */
|
|
function findRendererIdentifierInForwardRef(
|
|
typeChecker: ts.TypeChecker, node: ts.CallExpression,
|
|
rendererImport: ts.ImportSpecifier|null): ts.Identifier|null {
|
|
const firstArg = node.arguments[0];
|
|
|
|
if (ts.isArrowFunction(firstArg) && rendererImport) {
|
|
// Check if the function is `forwardRef(() => Renderer)`.
|
|
if (ts.isIdentifier(firstArg.body) &&
|
|
isReferenceToImport(typeChecker, firstArg.body, rendererImport)) {
|
|
return firstArg.body;
|
|
} else if (ts.isBlock(firstArg.body) && ts.isReturnStatement(firstArg.body.statements[0])) {
|
|
// Otherwise check if the expression is `forwardRef(() => { return Renderer })`.
|
|
const returnStatement = firstArg.body.statements[0] as ts.ReturnStatement;
|
|
|
|
if (returnStatement.expression && ts.isIdentifier(returnStatement.expression) &&
|
|
isReferenceToImport(typeChecker, returnStatement.expression, rendererImport)) {
|
|
return returnStatement.expression;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|