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