@atlaskit/eslint-plugin-design-system 10.8.1 → 10.8.2

package/dist/esm/rules/no-legacy-icons/helpers.js

@@ -0,0 +1,279 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getImportName } from '../utils/get-import-name';
+import migrationMap, { outcomeDescriptionMap } from './migration-map-temp';
+/**
+ * Returns the migration map object for a legacy icon or null if not found
+ * @param iconPackage The name of the legacy icon package
+ * @returns The migration map object for the legacy icon or null if not found
+ */
+export var getMigrationMapObject = function getMigrationMapObject(iconPackage) {
+  var key = getIconKey(iconPackage);
+  if (key in migrationMap) {
+    return migrationMap[key];
+  }
+  return null;
+};
+
+/**
+ * Returns the key of a legacy icon
+ * @param iconPackage The name of the legacy icon package
+ * @returns The unique identifier for the icon (the part after "@atlaskit/icon/glyph")
+ */
+export var getIconKey = function getIconKey(iconPackage) {
+  var key = iconPackage.replace(/^@atlaskit\/icon\/glyph\//, '');
+  return key;
+};
+
+/**
+ * Checks if a new icon can be auto-migrated based on guidance from the migration map
+ */
+export var canAutoMigrateNewIconBasedOnSize = function canAutoMigrateNewIconBasedOnSize(guidance) {
+  return ['swap', 'swap-slight-visual-change', 'swap-visual-change', 'swap-size-shift-utility'].includes(guidance || '');
+};
+
+/**
+ * Creates the written guidance for migrating a legacy icon to a new icon
+ */
+export var createGuidance = function createGuidance(iconPackage, size) {
+  var migrationMapObject = getMigrationMapObject(iconPackage);
+  if (migrationMapObject) {
+    var newIcon = migrationMapObject.newIcon;
+    if (!newIcon) {
+      return 'No equivalent icon in new set. An option is to contribute a custom icon into icon-labs package instead.\n';
+    }
+    if (size) {
+      var guidance = "Fix: Use ".concat(newIcon.name, " from @atlaskit/").concat(newIcon.library, "/").concat(newIcon.type, "/").concat(newIcon.name, " instead.");
+      if (migrationMapObject.sizeGuidance[size] in outcomeDescriptionMap) {
+        guidance += " Please: ".concat(outcomeDescriptionMap[migrationMapObject.sizeGuidance[size]], "\n");
+      } else {
+        guidance += ' No migration advice given.\n';
+      }
+      return guidance;
+    } else {
+      var _guidance = "Use ".concat(newIcon.name, " from @atlaskit/").concat(newIcon.library, "/").concat(newIcon.type, "/").concat(newIcon.name, " instead.\nMigration suggestions, depending on the legacy icon size:\n");
+      for (var _i = 0, _Object$entries = Object.entries(migrationMapObject.sizeGuidance); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          _size = _Object$entries$_i[0],
+          value = _Object$entries$_i[1];
+        _guidance += "\t- ".concat(_size, ": ");
+        if (!(value in outcomeDescriptionMap)) {
+          _guidance += 'No migration advice given.\n';
+        } else {
+          _guidance += "".concat(outcomeDescriptionMap[value], "\n");
+        }
+        _guidance;
+      }
+      return _guidance;
+    }
+  } else {
+    return 'Migration suggestions not found\n';
+  }
+};
+
+/**
+ * Checks if the color can be migrated
+ * @param color String representing the color to check
+ * @returns True if the color can be migrated, false otherwise
+ */
+export var canMigrateColor = function canMigrateColor(color) {
+  if (color.match(/^color\.text$/)) {
+    return true;
+  } else if (color.match(/^color\.icon/)) {
+    return true;
+  } else if (color.match(/^color\.link/)) {
+    return true;
+  } else if (color === 'currentColor') {
+    return true;
+  } else {
+    return false;
+  }
+};
+export var locToString = function locToString(node) {
+  var _node$loc, _node$loc2, _node$loc3, _node$loc4;
+  return "".concat((_node$loc = node.loc) === null || _node$loc === void 0 ? void 0 : _node$loc.start.line, ":").concat((_node$loc2 = node.loc) === null || _node$loc2 === void 0 ? void 0 : _node$loc2.start.column, ":").concat((_node$loc3 = node.loc) === null || _node$loc3 === void 0 ? void 0 : _node$loc3.end.line, ":").concat((_node$loc4 = node.loc) === null || _node$loc4 === void 0 ? void 0 : _node$loc4.end.column);
+};
+export var createCantMigrateReExportError = function createCantMigrateReExportError(node, packageName, exportName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateReExport',
+    data: {
+      packageName: packageName,
+      exportName: exportName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, packageName, exportName);
+};
+export var createCantMigrateIdentifierError = function createCantMigrateIdentifierError(node, packageName, exportName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateIdentifier',
+    data: {
+      packageName: packageName,
+      exportName: exportName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, packageName, exportName);
+};
+export var findUNSAFEProp = function findUNSAFEProp(iconAttr, button) {
+  var UNSAFE_size = null;
+  var propName = iconAttr.name.name === 'iconAfter' || iconAttr.name.name === 'iconBefore' || iconAttr.name.name === 'icon' ? iconAttr.name.name : null;
+  var buttonAttributes = button.attributes;
+  var UNSAFE_propName = propName === 'icon' ? "UNSAFE_size" : propName ? "UNSAFE_".concat(propName, "_size") : null;
+  var UNSAFE_size_index = buttonAttributes.findIndex(function (x) {
+    return UNSAFE_propName && 'name' in x && x.name && x.name.name === UNSAFE_propName;
+  });
+  var unsafeAttribute = UNSAFE_size_index !== -1 ? buttonAttributes[UNSAFE_size_index] : null;
+  if (unsafeAttribute && isNodeOfType(unsafeAttribute, 'JSXAttribute') && unsafeAttribute.value && isNodeOfType(unsafeAttribute.value, 'Literal') && unsafeAttribute.value.value && ['small', 'large', 'xlarge'].includes(unsafeAttribute.value.value)) {
+    UNSAFE_size = unsafeAttribute.value.value;
+  } else if (unsafeAttribute && isNodeOfType(unsafeAttribute, 'JSXAttribute') && unsafeAttribute.value && isNodeOfType(unsafeAttribute.value, 'JSXExpressionContainer') && isNodeOfType(unsafeAttribute.value.expression, 'Literal') && ['small', 'large', 'xlarge'].includes(unsafeAttribute.value.expression.value)) {
+    UNSAFE_size = unsafeAttribute.value.expression.value;
+  }
+  return {
+    UNSAFE_size: UNSAFE_size,
+    UNSAFE_propName: UNSAFE_propName
+  };
+};
+export var createCantMigrateUnsafeProp = function createCantMigrateUnsafeProp(node, propName, value, packageName, iconName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateUnsafeProp',
+    data: {
+      propName: propName,
+      value: value
+    }
+  };
+  pushManualError(locToString(node), errors, myError, packageName, iconName);
+};
+export var createCantFindSuitableReplacementError = function createCantFindSuitableReplacementError(node, importSource, iconName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantFindSuitableReplacement',
+    data: {
+      importSource: importSource,
+      iconName: iconName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, importSource, iconName);
+};
+export var createCantMigrateFunctionUnknownError = function createCantMigrateFunctionUnknownError(node, importSource, iconName, errors) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateFunctionUnknown',
+    data: {
+      importSource: importSource,
+      iconName: iconName
+    }
+  };
+  pushManualError(locToString(node), errors, myError, importSource, iconName);
+};
+export var createCantMigrateColorError = function createCantMigrateColorError(node, colorValue, errors, importSource, iconName) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateColor',
+    data: {
+      colorValue: colorValue
+    }
+  };
+  pushManualError(locToString(node), errors, myError, importSource, iconName);
+};
+export var createCantMigrateSpreadPropsError = function createCantMigrateSpreadPropsError(node, missingProps, errors, importSource, iconName) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateSpreadProps',
+    data: {
+      missingProps: missingProps.join(', ')
+    }
+  };
+  pushManualError(locToString(node), errors, myError, importSource, iconName);
+};
+export var createCantMigrateSizeUnknown = function createCantMigrateSizeUnknown(node, errors, importSource, iconName) {
+  var myError = {
+    node: node,
+    messageId: 'cantMigrateSizeUnknown'
+  };
+  pushManualError(locToString(node), errors, myError, importSource, iconName);
+};
+export var createAutoMigrationError = function createAutoMigrationError(node, importSource, iconName, newIcon, oldIconName, errors) {
+  var migrationKey = newIcon.name === oldIconName ? newIcon.name : "".concat(newIcon.name, "--").concat(oldIconName);
+  var newMigrationIconPackage = "@atlaskit/".concat(newIcon.library, "/").concat(newIcon.type, "/migration/").concat(migrationKey);
+  var myError = {
+    node: node,
+    messageId: 'noLegacyIconsAutoMigration',
+    data: {
+      importSource: importSource,
+      iconName: iconName,
+      newIcon: newIcon.name,
+      //TODO: provide size guidance
+      newPackage: newMigrationIconPackage
+    }
+  };
+  errors[locToString(node)] = myError;
+};
+var pushManualError = function pushManualError(key, errors, myError, importSource, iconName) {
+  if (key in errors) {
+    errors[key].errors.push(myError);
+  } else {
+    errors[key] = {
+      errors: [myError],
+      importSource: importSource,
+      iconName: iconName
+    };
+  }
+};
+export var getLiteralStringValue = function getLiteralStringValue(value) {
+  if (!value) {
+    return;
+  }
+
+  // propName="value"
+  if (isNodeOfType(value, 'Literal') && typeof value.value === 'string') {
+    return value.value;
+  }
+
+  // propName={"value"}
+  if (isNodeOfType(value, 'JSXExpressionContainer') && isNodeOfType(value.expression, 'Literal') && typeof value.expression.value === 'string') {
+    return value.expression.value;
+  }
+  return;
+};
+export var createHelpers = function createHelpers(context) {
+  /**
+   * Extracts the token name of a token() call from a JSXExpressionContainer
+   * @param value The JSXExpressionContainer to extract the token call from
+   * @returns The value of the token call, or null if it could not be extracted
+   */
+  var getTokenCallValue = function getTokenCallValue(value) {
+    var tokenName = getImportName(context.sourceCode.getScope(value), '@atlaskit/tokens', 'token');
+    if (tokenName && isNodeOfType(value, 'JSXExpressionContainer') && isNodeOfType(value.expression, 'CallExpression') && 'name' in value.expression.callee && value.expression.callee.name === tokenName) {
+      // propName={token("color...."}
+      return getLiteralStringValue(value.expression.arguments[0]);
+    }
+    return;
+  };
+
+  /**
+   * Gets the value of a boolean configuration flag
+   * @param key the key of the configuration flag
+   * @param defaultValue The default value of the configuration flag
+   * @returns defaultValue if the configuration flag is not set, the defaultValue of the configuration flag otherwise
+   */
+  var getConfigFlag = function getConfigFlag(key, defaultValue) {
+    if (context.options.length > 0 && context.options[0] && key in context.options[0]) {
+      return context.options[0][key] === !defaultValue ? !defaultValue : defaultValue;
+    }
+    return defaultValue;
+  };
+  return {
+    /**
+     * Extracts the primaryColor value from a JSXAttribute
+     */
+    getPrimaryColor: function getPrimaryColor(attr) {
+      var _ref, _getLiteralStringValu;
+      var value = attr.value;
+      return (_ref = (_getLiteralStringValu = getLiteralStringValue(value)) !== null && _getLiteralStringValu !== void 0 ? _getLiteralStringValu : getTokenCallValue(value)) !== null && _ref !== void 0 ? _ref : null;
+    },
+    getTokenCallValue: getTokenCallValue,
+    getConfigFlag: getConfigFlag
+  };
+};

package/dist/esm/rules/no-legacy-icons/index.js

@@ -1,8 +1,7 @@
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-import { isNodeOfType } from 'eslint-codemod-utils';
 import { createLintRule } from '../utils/create-rule';
+import { errorBoundary } from '../utils/error-boundary';
+import { createChecks } from './checks';
+import { createHelpers } from './helpers';
 var rule = createLintRule({
   meta: {
     name: 'no-legacy-icons',
@@ -12,155 +11,136 @@ var rule = createLintRule({
       recommended: false,
       severity: 'warn'
     },
+    schema: [{
+      type: 'object',
+      properties: {
+        shouldErrorForManualMigration: {
+          type: 'boolean'
+        },
+        shouldErrorForAutoMigration: {
+          type: 'boolean'
+        },
+        quiet: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }],
     messages: {
-      noLegacyIcons: "Legacy icon '{{iconName}}', is being rendered from import '{{importSource}}'. Migrate to an icon from '@atlaskit/icon/(core|utility)', or '@atlaskit/icon-labs/(core|utility)'.\nLearn more in our [code migration guide](https://hello.atlassian.net/wiki/spaces/DST/pages/3748692796/New+ADS+iconography+-+Code+migration+guide)."
+      noLegacyIconsAutoMigration: "Auto Migration:\nLegacy icon '{{iconName}}' from '{{importSource}}' detected.\nAutomatic migration is possible to '{{newIcon}}' from '{{newPackage}}.\nAtlassians: See https://go.atlassian.com/icon-migration-guide for details.'",
+      noLegacyIconsManualMigration: "Manual Migration:\nLegacy icon '{{iconName}}' from '{{importSource}}' detected.\nAutomatic migration not possible.{{quietModeGuidance}}.\nAtlassians: See https://go.atlassian.com/icon-migration-guide for details.",
+      cantFindSuitableReplacement: "No suitable replacement found for '{{iconName}}' from '{{importSource}}' at the size listed. Please manually migrate this icon.",
+      cantMigrateReExport: "'{{exportName}}' is a re-export of icon from '{{packageName}}' and cannot be automatically migrated. Please utilize the export from icons directly.",
+      cantMigrateColor: "Primary Color prop has {{colorValue}} which cannot be automatically migrated to color prop in the new Icon API. Please use either an appropriate color.icon, color.link token, or currentColor (as a last resort).",
+      cantMigrateSpreadProps: "This usage of Icon uses spread props in a way that can't be automatically migrated. Please explicitly define the following props after spread: '{{missingProps}}' ",
+      cantMigrateSizeUnknown: "This usage of Icon sets the size via a variable or function that can't be determined.",
+      cantMigrateFunctionUnknown: "'{{iconName}}' from legacy '{{importSource}}' is used in unknown function/component. Please manually migrate this icon.",
+      cantMigrateIdentifier: "This icon is passed to other components via a map or array, in a way that can't be automatically migrated. Please manually migrate wherever this expression is used and use the icon components directly.",
+      cantMigrateUnsafeProp: "Property '{{propName}}' with value of '{{value}}' is unable to be auto-migrated to the new button. Please manually migrate this icon.",
+      guidance: "Guidance:\n'{{guidance}}'"
     }
   },
   create: function create(context) {
-    var legacyIconImports = {};
+    var _createHelpers = createHelpers(context),
+      getConfigFlag = _createHelpers.getConfigFlag;
+    var failSilently = getConfigFlag('failSilently', false);
+    var _createChecks = createChecks(context),
+      checkImportDeclarations = _createChecks.checkImportDeclarations,
+      checkVariableDeclarations = _createChecks.checkVariableDeclarations,
+      checkExportDefaultDeclaration = _createChecks.checkExportDefaultDeclaration,
+      checkExportNamedVariables = _createChecks.checkExportNamedVariables,
+      checkArrayOrMap = _createChecks.checkArrayOrMap,
+      checkIconAsProp = _createChecks.checkIconAsProp,
+      checkJSXElement = _createChecks.checkJSXElement,
+      checkCallExpression = _createChecks.checkCallExpression,
+      throwErrors = _createChecks.throwErrors;
     return {
+      // Track imports of relevant components
       ImportDeclaration: function ImportDeclaration(node) {
-        var moduleSource = node.source.value;
-        if (typeof moduleSource === 'string' && ['@atlaskit/icon/glyph/', '@atlaskit/icon-object/glyph/'].find(function (val) {
-          return moduleSource.startsWith(val);
-        }) && node.specifiers.length) {
-          var defaultImport = node.specifiers.find(function (spec) {
-            return spec.type === 'ImportDefaultSpecifier';
-          });
-          if (!defaultImport) {
-            return;
+        errorBoundary(function () {
+          return checkImportDeclarations(node);
+        }, {
+          config: {
+            failSilently: failSilently
           }
-          var defaultImportName = defaultImport.local.name;
-          legacyIconImports[defaultImportName] = moduleSource;
-        }
+        });
       },
+      // Keep track of the relevant variable declarations and renames
       VariableDeclaration: function VariableDeclaration(node) {
-        if (isNodeOfType(node, 'VariableDeclaration')) {
-          var _iterator = _createForOfIteratorHelper(node.declarations),
-            _step;
-          try {
-            for (_iterator.s(); !(_step = _iterator.n()).done;) {
-              var decl = _step.value;
-              if (isNodeOfType(decl, 'VariableDeclarator') && 'init' in decl && 'id' in decl && decl.init && decl.id && 'name' in decl.id && decl.id.name && isNodeOfType(decl.init, 'Identifier') && decl.init.name in legacyIconImports) {
-                legacyIconImports[decl.id.name] = legacyIconImports[decl.init.name];
-              }
-            }
-          } catch (err) {
-            _iterator.e(err);
-          } finally {
-            _iterator.f();
+        errorBoundary(function () {
+          return checkVariableDeclarations(node);
+        }, {
+          config: {
+            failSilently: failSilently
           }
-        }
+        });
       },
+      // Case: default re-exports. Can't be auto-migrated
       ExportDefaultDeclaration: function ExportDefaultDeclaration(node) {
-        if ('declaration' in node && node.declaration && isNodeOfType(node.declaration, 'Identifier') && node.declaration.name in legacyIconImports) {
-          context.report({
-            node: node,
-            messageId: 'noLegacyIcons',
-            data: {
-              importSource: legacyIconImports[node.declaration.name],
-              iconName: node.declaration.name
-            }
-          });
-        }
+        errorBoundary(function () {
+          return checkExportDefaultDeclaration(node);
+        }, {
+          config: {
+            failSilently: failSilently
+          }
+        });
       },
       ExportNamedDeclaration: function ExportNamedDeclaration(node) {
-        if ('source' in node && node.source && isNodeOfType(node.source, 'Literal') && 'value' in node.source) {
-          var moduleSource = node.source.value;
-          if (typeof moduleSource === 'string' && ['@atlaskit/icon/glyph/', '@atlaskit/icon-object/glyph/'].find(function (val) {
-            return moduleSource.startsWith(val);
-          }) && node.specifiers.length) {
-            context.report({
-              node: node,
-              messageId: 'noLegacyIcons',
-              data: {
-                importSource: moduleSource,
-                iconName: node.specifiers[0].exported.name
-              }
-            });
+        errorBoundary(function () {
+          return checkExportNamedVariables(node);
+        }, {
+          config: {
+            failSilently: failSilently
           }
-        } else if ('declaration' in node && node.declaration && isNodeOfType(node.declaration, 'VariableDeclaration')) {
-          var _iterator2 = _createForOfIteratorHelper(node.declaration.declarations),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var decl = _step2.value;
-              if (isNodeOfType(decl, 'VariableDeclarator') && 'init' in decl && decl.init && isNodeOfType(decl.init, 'Identifier') && decl.init.name in legacyIconImports) {
-                context.report({
-                  node: node,
-                  messageId: 'noLegacyIcons',
-                  data: {
-                    importSource: legacyIconImports[decl.init.name],
-                    iconName: decl.init.name
-                  }
-                });
-              }
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
+        });
+      },
+      // Legacy icons found in arrays/objects
+      'ObjectExpression > Property > Identifier, ArrayExpression > Identifier ': function ObjectExpressionPropertyIdentifierArrayExpressionIdentifier(node) {
+        errorBoundary(function () {
+          return checkArrayOrMap(node);
+        }, {
+          config: {
+            failSilently: failSilently
           }
-        }
+        });
       },
-      JSXAttribute: function JSXAttribute(node) {
-        if (!isNodeOfType(node.value, 'JSXExpressionContainer')) {
-          return;
-        }
-        if (isNodeOfType(node.value.expression, 'Identifier') && node.value.expression.name in legacyIconImports && isNodeOfType(node.name, 'JSXIdentifier') && !node.name.name.startsWith('LEGACY_')) {
-          context.report({
-            node: node,
-            messageId: 'noLegacyIcons',
-            data: {
-              importSource: legacyIconImports[node.value.expression.name],
-              iconName: node.value.expression.name
-            }
-          });
-        }
+      // Legacy icons passed in via props, as JSX identifier (i.e. icon={AddIcon})
+      'JSXOpeningElement > JSXAttribute > JSXExpressionContainer > Identifier': function JSXOpeningElementJSXAttributeJSXExpressionContainerIdentifier(node) {
+        errorBoundary(function () {
+          return checkIconAsProp(node);
+        }, {
+          config: {
+            failSilently: failSilently
+          }
+        });
       },
       JSXElement: function JSXElement(node) {
-        if (!isNodeOfType(node, 'JSXElement')) {
-          return;
-        }
-        if (!isNodeOfType(node.openingElement.name, 'JSXIdentifier')) {
-          return;
-        }
-        var name = node.openingElement.name.name;
-        if (name in legacyIconImports) {
-          context.report({
-            node: node,
-            messageId: 'noLegacyIcons',
-            data: {
-              importSource: legacyIconImports[name],
-              iconName: name
-            }
-          });
-        }
+        errorBoundary(function () {
+          return checkJSXElement(node);
+        }, {
+          config: {
+            failSilently: failSilently
+          }
+        });
       },
+      // Icons called as an argument of a function (i.e. icon={DefaultIcon(AddIcon)})
       CallExpression: function CallExpression(node) {
-        if ('arguments' in node && node.arguments.length) {
-          var _iterator3 = _createForOfIteratorHelper(node.arguments),
-            _step3;
-          try {
-            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-              var arg = _step3.value;
-              if (isNodeOfType(arg, 'Identifier') && arg.name in legacyIconImports) {
-                context.report({
-                  node: arg,
-                  messageId: 'noLegacyIcons',
-                  data: {
-                    importSource: legacyIconImports[arg.name],
-                    iconName: arg.name
-                  }
-                });
-              }
-            }
-          } catch (err) {
-            _iterator3.e(err);
-          } finally {
-            _iterator3.f();
+        errorBoundary(function () {
+          return checkCallExpression(node);
+        }, {
+          config: {
+            failSilently: failSilently
           }
-        }
+        });
+      },
+      'Program:exit': function ProgramExit() {
+        errorBoundary(function () {
+          return throwErrors();
+        }, {
+          config: {
+            failSilently: failSilently
+          }
+        });
       }
     };
   }