@angular/cdk
Version:
Angular Material Component Development Kit
139 lines • 6.82 kB
JavaScript
;
/**
* @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.dev/license
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConstructorSignatureMigration = void 0;
const ts = require("typescript");
const migration_1 = require("../../update-tool/migration");
const version_changes_1 = require("../../update-tool/version-changes");
/**
* List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid
* new expression or super call signatures. See the list of diagnostics here:
*
* https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
*/
const signatureErrorDiagnostics = [
// Type not assignable error diagnostic.
2345,
// Constructor argument length invalid diagnostics
2554, 2555, 2556, 2557,
];
/**
* Migration that visits every TypeScript new expression or super call and checks if
* the parameter type signature is invalid and needs to be updated manually.
*/
class ConstructorSignatureMigration extends migration_1.Migration {
constructor() {
super(...arguments);
// Note that the data for this rule is not distinguished based on the target version because
// we don't keep track of the new signature and don't want to update incrementally.
// See: https://github.com/angular/components/pull/12970#issuecomment-418337566
this.data = (0, version_changes_1.getAllChanges)(this.upgradeData.constructorChecks);
// Only enable the migration rule if there is upgrade data.
this.enabled = this.data.length !== 0;
}
visitNode(node) {
if (ts.isSourceFile(node)) {
this._visitSourceFile(node);
}
}
/**
* Method that will be called for each source file of the upgrade project. In order to
* properly determine invalid constructor signatures, we take advantage of the pre-emit
* diagnostics from TypeScript.
*
* By using the diagnostics, the migration can handle type assignability. Not using
* diagnostics would mean that we need to use simple type equality checking which is
* too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
*/
_visitSourceFile(sourceFile) {
// List of classes of which the constructor signature has changed.
const diagnostics = ts
.getPreEmitDiagnostics(this.program, sourceFile)
.filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))
.filter(diagnostic => diagnostic.start !== undefined);
for (const diagnostic of diagnostics) {
const node = findConstructorNode(diagnostic, sourceFile);
if (!node) {
continue;
}
const classType = this.typeChecker.getTypeAtLocation(node.expression);
const className = classType.symbol && classType.symbol.name;
const isNewExpression = ts.isNewExpression(node);
// Determine the class names of the actual construct signatures because we cannot assume that
// the diagnostic refers to a constructor of the actual expression. In case the constructor
// is inherited, we need to detect that the owner-class of the constructor is added to the
// constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.
const signatureClassNames = classType
.getConstructSignatures()
.map(signature => getClassDeclarationOfSignature(signature))
.map(declaration => (declaration && declaration.name ? declaration.name.text : null))
.filter(Boolean);
// Besides checking the signature class names, we need to check the actual class name because
// there can be classes without an explicit constructor.
if (!this.data.includes(className) &&
!signatureClassNames.some(name => this.data.includes(name))) {
continue;
}
const classSignatures = classType
.getConstructSignatures()
.map(signature => getParameterTypesFromSignature(signature, this.typeChecker));
const expressionName = isNewExpression ? `new ${className}` : 'super';
const signatures = classSignatures
.map(signature => signature.map(t => (t === null ? 'any' : this.typeChecker.typeToString(t))))
.map(signature => `${expressionName}(${signature.join(', ')})`)
.join(' or ');
this.createFailureAtNode(node, `Found "${className}" constructed with ` +
`an invalid signature. Please manually update the ${expressionName} expression to ` +
`match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`);
}
}
}
exports.ConstructorSignatureMigration = ConstructorSignatureMigration;
/** Resolves the type for each parameter in the specified signature. */
function getParameterTypesFromSignature(signature, typeChecker) {
return signature
.getParameters()
.map(param => param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : null);
}
/**
* Walks through each node of a source file in order to find a new-expression node or super-call
* expression node that is captured by the specified diagnostic.
*/
function findConstructorNode(diagnostic, sourceFile) {
let resolvedNode = null;
const _visitNode = (node) => {
// Check whether the current node contains the diagnostic. If the node contains the diagnostic,
// walk deeper in order to find all constructor expression nodes.
if (node.getStart() <= diagnostic.start && node.getEnd() >= diagnostic.start) {
if (ts.isNewExpression(node) ||
(ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)) {
resolvedNode = node;
}
ts.forEachChild(node, _visitNode);
}
};
ts.forEachChild(sourceFile, _visitNode);
return resolvedNode;
}
/** Determines the class declaration of the specified construct signature. */
function getClassDeclarationOfSignature(signature) {
let node = signature.getDeclaration();
// Handle signatures which don't have an actual declaration. This happens if a class
// does not have an explicitly written constructor.
if (!node) {
return null;
}
while (!ts.isSourceFile((node = node.parent))) {
if (ts.isClassDeclaration(node)) {
return node;
}
}
return null;
}
//# sourceMappingURL=constructor-signature.js.map