source: trip-planner-front/node_modules/@angular/cdk/schematics/ng-update/migrations/constructor-signature.mjs

Last change on this file was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit

  • Property mode set to 100644
File size: 20.2 KB
Line 
1"use strict";
2/**
3 * @license
4 * Copyright Google LLC All Rights Reserved.
5 *
6 * Use of this source code is governed by an MIT-style license that can be
7 * found in the LICENSE file at https://angular.io/license
8 */
9Object.defineProperty(exports, "__esModule", { value: true });
10exports.ConstructorSignatureMigration = void 0;
11const ts = require("typescript");
12const migration_1 = require("../../update-tool/migration");
13const version_changes_1 = require("../../update-tool/version-changes");
14/**
15 * List of diagnostic codes that refer to pre-emit diagnostics which indicate invalid
16 * new expression or super call signatures. See the list of diagnostics here:
17 *
18 * https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
19 */
20const signatureErrorDiagnostics = [
21 // Type not assignable error diagnostic.
22 2345,
23 // Constructor argument length invalid diagnostics
24 2554,
25 2555,
26 2556,
27 2557,
28];
29/**
30 * Migration that visits every TypeScript new expression or super call and checks if
31 * the parameter type signature is invalid and needs to be updated manually.
32 */
33class ConstructorSignatureMigration extends migration_1.Migration {
34 constructor() {
35 super(...arguments);
36 // Note that the data for this rule is not distinguished based on the target version because
37 // we don't keep track of the new signature and don't want to update incrementally.
38 // See: https://github.com/angular/components/pull/12970#issuecomment-418337566
39 this.data = version_changes_1.getAllChanges(this.upgradeData.constructorChecks);
40 // Only enable the migration rule if there is upgrade data.
41 this.enabled = this.data.length !== 0;
42 }
43 visitNode(node) {
44 if (ts.isSourceFile(node)) {
45 this._visitSourceFile(node);
46 }
47 }
48 /**
49 * Method that will be called for each source file of the upgrade project. In order to
50 * properly determine invalid constructor signatures, we take advantage of the pre-emit
51 * diagnostics from TypeScript.
52 *
53 * By using the diagnostics, the migration can handle type assignability. Not using
54 * diagnostics would mean that we need to use simple type equality checking which is
55 * too strict. See related issue: https://github.com/Microsoft/TypeScript/issues/9879
56 */
57 _visitSourceFile(sourceFile) {
58 // List of classes of which the constructor signature has changed.
59 const diagnostics = ts.getPreEmitDiagnostics(this.program, sourceFile)
60 .filter(diagnostic => signatureErrorDiagnostics.includes(diagnostic.code))
61 .filter(diagnostic => diagnostic.start !== undefined);
62 for (const diagnostic of diagnostics) {
63 const node = findConstructorNode(diagnostic, sourceFile);
64 if (!node) {
65 continue;
66 }
67 const classType = this.typeChecker.getTypeAtLocation(node.expression);
68 const className = classType.symbol && classType.symbol.name;
69 const isNewExpression = ts.isNewExpression(node);
70 // Determine the class names of the actual construct signatures because we cannot assume that
71 // the diagnostic refers to a constructor of the actual expression. In case the constructor
72 // is inherited, we need to detect that the owner-class of the constructor is added to the
73 // constructor checks upgrade data. e.g. `class CustomCalendar extends MatCalendar {}`.
74 const signatureClassNames = classType.getConstructSignatures()
75 .map(signature => getClassDeclarationOfSignature(signature))
76 .map(declaration => declaration && declaration.name ? declaration.name.text : null)
77 .filter(Boolean);
78 // Besides checking the signature class names, we need to check the actual class name because
79 // there can be classes without an explicit constructor.
80 if (!this.data.includes(className) &&
81 !signatureClassNames.some(name => this.data.includes(name))) {
82 continue;
83 }
84 const classSignatures = classType.getConstructSignatures().map(signature => getParameterTypesFromSignature(signature, this.typeChecker));
85 const expressionName = isNewExpression ? `new ${className}` : 'super';
86 const signatures = classSignatures
87 .map(signature => signature.map(t => t === null ? 'any' : this.typeChecker.typeToString(t)))
88 .map(signature => `${expressionName}(${signature.join(', ')})`)
89 .join(' or ');
90 this.createFailureAtNode(node, `Found "${className}" constructed with ` +
91 `an invalid signature. Please manually update the ${expressionName} expression to ` +
92 `match the new signature${classSignatures.length > 1 ? 's' : ''}: ${signatures}`);
93 }
94 }
95}
96exports.ConstructorSignatureMigration = ConstructorSignatureMigration;
97/** Resolves the type for each parameter in the specified signature. */
98function getParameterTypesFromSignature(signature, typeChecker) {
99 return signature.getParameters().map(param => param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : null);
100}
101/**
102 * Walks through each node of a source file in order to find a new-expression node or super-call
103 * expression node that is captured by the specified diagnostic.
104 */
105function findConstructorNode(diagnostic, sourceFile) {
106 let resolvedNode = null;
107 const _visitNode = (node) => {
108 // Check whether the current node contains the diagnostic. If the node contains the diagnostic,
109 // walk deeper in order to find all constructor expression nodes.
110 if (node.getStart() <= diagnostic.start && node.getEnd() >= diagnostic.start) {
111 if (ts.isNewExpression(node) ||
112 (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.SuperKeyword)) {
113 resolvedNode = node;
114 }
115 ts.forEachChild(node, _visitNode);
116 }
117 };
118 ts.forEachChild(sourceFile, _visitNode);
119 return resolvedNode;
120}
121/** Determines the class declaration of the specified construct signature. */
122function getClassDeclarationOfSignature(signature) {
123 let node = signature.getDeclaration();
124 // Handle signatures which don't have an actual declaration. This happens if a class
125 // does not have an explicitly written constructor.
126 if (!node) {
127 return null;
128 }
129 while (!ts.isSourceFile(node = node.parent)) {
130 if (ts.isClassDeclaration(node)) {
131 return node;
132 }
133 }
134 return null;
135}
136//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constructor-signature.js","sourceRoot":"","sources":["../../../../../../../../src/cdk/schematics/ng-update/migrations/constructor-signature.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 {Migration} from '../../update-tool/migration';\nimport {getAllChanges} from '../../update-tool/version-changes';\nimport {UpgradeData} 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 * Migration 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 ConstructorSignatureMigration extends Migration<UpgradeData> {\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  enabled = this.data.length !== 0;\n\n  override 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 = classSignatures\n          .map(signature =>\n              signature.map(t => t === null ? 'any' : 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|null)[] {\n  return signature.getParameters().map(\n      param => param.declarations ? typeChecker.getTypeAtLocation(param.declarations[0]) : null);\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"]}
Note: See TracBrowser for help on using the repository browser.