@depup/eslint-plugin-jest 29.15.1-depup.0

package/lib/rules/utils/padding.js

@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPaddingRule = exports.StatementType = exports.PaddingType = void 0;
+var _utils = require("@typescript-eslint/utils");
+var astUtils = _interopRequireWildcard(require("./ast-utils"));
+var _misc = require("./misc");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Require/fix newlines around jest functions
+ *
+ * Based on eslint/padding-line-between-statements by Toru Nagashima
+ * See: https://github.com/eslint/eslint/blob/master/lib/rules/padding-line-between-statements.js
+ *
+ * Some helpers borrowed from eslint ast-utils by Gyandeep Singh
+ * See: https://github.com/eslint/eslint/blob/master/lib/rules/utils/ast-utils.js
+ */
+// Statement types we'll respond to
+let StatementType = exports.StatementType = /*#__PURE__*/function (StatementType) {
+  StatementType[StatementType["Any"] = 0] = "Any";
+  StatementType[StatementType["AfterAllToken"] = 1] = "AfterAllToken";
+  StatementType[StatementType["AfterEachToken"] = 2] = "AfterEachToken";
+  StatementType[StatementType["BeforeAllToken"] = 3] = "BeforeAllToken";
+  StatementType[StatementType["BeforeEachToken"] = 4] = "BeforeEachToken";
+  StatementType[StatementType["DescribeToken"] = 5] = "DescribeToken";
+  StatementType[StatementType["ExpectToken"] = 6] = "ExpectToken";
+  StatementType[StatementType["FdescribeToken"] = 7] = "FdescribeToken";
+  StatementType[StatementType["FitToken"] = 8] = "FitToken";
+  StatementType[StatementType["ItToken"] = 9] = "ItToken";
+  StatementType[StatementType["TestToken"] = 10] = "TestToken";
+  StatementType[StatementType["XdescribeToken"] = 11] = "XdescribeToken";
+  StatementType[StatementType["XitToken"] = 12] = "XitToken";
+  StatementType[StatementType["XtestToken"] = 13] = "XtestToken";
+  return StatementType;
+}({});
+// Padding type to apply between statements
+let PaddingType = exports.PaddingType = /*#__PURE__*/function (PaddingType) {
+  PaddingType[PaddingType["Any"] = 0] = "Any";
+  PaddingType[PaddingType["Always"] = 1] = "Always";
+  return PaddingType;
+}({}); // A configuration object for padding type and the two statement types
+// Tracks position in scope and prevNode. Used to compare current and prev node
+// and then to walk back up to the parent scope or down into the next one.
+// And so on...
+// Creates a StatementTester to test an ExpressionStatement's first token name
+const createTokenTester = tokenName => {
+  return (node, sourceCode) => {
+    let activeNode = node;
+    if (activeNode.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
+      // In the case of `await`, we actually care about its argument
+      if (activeNode.expression.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+        activeNode = activeNode.expression.argument;
+      }
+      const token = sourceCode.getFirstToken(activeNode);
+      return token?.type === _utils.AST_TOKEN_TYPES.Identifier && token.value === tokenName;
+    }
+    return false;
+  };
+};
+
+// A mapping of StatementType to StatementTester for... testing statements
+const statementTesters = {
+  [StatementType.Any]: () => true,
+  [StatementType.AfterAllToken]: createTokenTester('afterAll'),
+  [StatementType.AfterEachToken]: createTokenTester('afterEach'),
+  [StatementType.BeforeAllToken]: createTokenTester('beforeAll'),
+  [StatementType.BeforeEachToken]: createTokenTester('beforeEach'),
+  [StatementType.DescribeToken]: createTokenTester('describe'),
+  [StatementType.ExpectToken]: createTokenTester('expect'),
+  [StatementType.FdescribeToken]: createTokenTester('fdescribe'),
+  [StatementType.FitToken]: createTokenTester('fit'),
+  [StatementType.ItToken]: createTokenTester('it'),
+  [StatementType.TestToken]: createTokenTester('test'),
+  [StatementType.XdescribeToken]: createTokenTester('xdescribe'),
+  [StatementType.XitToken]: createTokenTester('xit'),
+  [StatementType.XtestToken]: createTokenTester('xtest')
+};
+
+/**
+ * Check and report statements for `PaddingType.Always` configuration.
+ * This autofix inserts a blank line between the given 2 statements.
+ * If the `prevNode` has trailing comments, it inserts a blank line after the
+ * trailing comments.
+ */
+const paddingAlwaysTester = (prevNode, nextNode, paddingContext) => {
+  const {
+    sourceCode,
+    ruleContext
+  } = paddingContext;
+  const paddingLines = astUtils.getPaddingLineSequences(prevNode, nextNode, sourceCode);
+
+  // We've got some padding lines. Great.
+  if (paddingLines.length > 0) {
+    return;
+  }
+
+  // Missing padding line
+  ruleContext.report({
+    node: nextNode,
+    messageId: 'missingPadding',
+    fix(fixer) {
+      let prevToken = astUtils.getActualLastToken(sourceCode, prevNode);
+      const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+        includeComments: true,
+        /**
+         * Skip the trailing comments of the previous node.
+         * This inserts a blank line after the last trailing comment.
+         *
+         * For example:
+         *
+         *     foo(); // trailing comment.
+         *     // comment.
+         *     bar();
+         *
+         * Get fixed to:
+         *
+         *     foo(); // trailing comment.
+         *
+         *     // comment.
+         *     bar();
+         */
+        filter(token) {
+          if (astUtils.areTokensOnSameLine(prevToken, token)) {
+            prevToken = token;
+            return false;
+          }
+          return true;
+        }
+      }) || nextNode;
+      const insertText = astUtils.areTokensOnSameLine(prevToken, nextToken) ? '\n\n' : '\n';
+      return fixer.insertTextAfter(prevToken, insertText);
+    }
+  });
+};
+
+// A mapping of PaddingType to PaddingTester
+const paddingTesters = {
+  [PaddingType.Any]: () => true,
+  [PaddingType.Always]: paddingAlwaysTester
+};
+const createScopeInfo = () => {
+  let scope = null;
+
+  // todo: explore seeing if we can refactor to a more TypeScript friendly structure
+  return {
+    get prevNode() {
+      return scope.prevNode;
+    },
+    set prevNode(node) {
+      scope.prevNode = node;
+    },
+    enter() {
+      scope = {
+        upper: scope,
+        prevNode: null
+      };
+    },
+    exit() {
+      scope = scope.upper;
+    }
+  };
+};
+
+/**
+ * Check whether the given node matches the statement type
+ */
+const nodeMatchesType = (node, statementType, paddingContext) => {
+  let innerStatementNode = node;
+  const {
+    sourceCode
+  } = paddingContext;
+
+  // Dig into LabeledStatement body until it's not that anymore
+  while (innerStatementNode.type === _utils.AST_NODE_TYPES.LabeledStatement) {
+    innerStatementNode = innerStatementNode.body;
+  }
+
+  // If it's an array recursively check if any of the statement types match
+  // the node
+  if (Array.isArray(statementType)) {
+    return statementType.some(type => nodeMatchesType(innerStatementNode, type, paddingContext));
+  }
+  return statementTesters[statementType](innerStatementNode, sourceCode);
+};
+
+/**
+ * Executes matching padding tester for last matched padding config for given
+ * nodes
+ */
+const testPadding = (prevNode, nextNode, paddingContext) => {
+  const {
+    configs
+  } = paddingContext;
+  const testType = type => paddingTesters[type](prevNode, nextNode, paddingContext);
+  for (let i = configs.length - 1; i >= 0; --i) {
+    const {
+      prevStatementType: prevType,
+      nextStatementType: nextType,
+      paddingType
+    } = configs[i];
+    if (nodeMatchesType(prevNode, prevType, paddingContext) && nodeMatchesType(nextNode, nextType, paddingContext)) {
+      testType(paddingType);
+      return;
+    }
+  }
+
+  // There were no matching padding rules for the prevNode, nextNode,
+  // paddingType combination... so we'll use PaddingType.Any which is always ok
+  testType(PaddingType.Any);
+};
+
+/**
+ * Verify padding lines between the given node and the previous node.
+ */
+const verifyNode = (node, paddingContext) => {
+  const {
+    scopeInfo
+  } = paddingContext;
+
+  // NOTE: ESLint types use ESTree which provides a Node type, however
+  //  ESTree.Node doesn't support the parent property which is added by
+  //  ESLint during traversal. Our best bet is to ignore the property access
+  //  here as it's the only place that it's checked.
+
+  if (!astUtils.isValidParent(node.parent.type)) {
+    return;
+  }
+  if (scopeInfo.prevNode) {
+    testPadding(scopeInfo.prevNode, node, paddingContext);
+  }
+  scopeInfo.prevNode = node;
+};
+
+/**
+ * Creates an ESLint rule for a given set of padding Config objects.
+ *
+ * The algorithm is approximately this:
+ *
+ * For each 'scope' in the program
+ * - Enter the scope (store the parent scope and previous node)
+ * - For each statement in the scope
+ *   - Check the current node and previous node against the Config objects
+ *   - If the current node and previous node match a Config, check the padding.
+ *     Otherwise, ignore it.
+ *   - If the padding is missing (and required), report and fix
+ *   - Store the current node as the previous
+ *   - Repeat
+ * - Exit scope (return to parent scope and clear previous node)
+ *
+ * The items we're looking for with this rule are ExpressionStatement nodes
+ * where the first token is an Identifier with a name matching one of the Jest
+ * functions. It's not foolproof, of course, but it's probably good enough for
+ * almost all cases.
+ *
+ * The Config objects specify a padding type, a previous statement type, and a
+ * next statement type. Wildcard statement types and padding types are
+ * supported. The current node and previous node are checked against the
+ * statement types. If they match then the specified padding type is
+ * tested/enforced.
+ *
+ * See src/index.ts for examples of Config usage.
+ */
+const createPaddingRule = (name, description, configs, deprecated = false) => {
+  return (0, _misc.createRule)({
+    name,
+    meta: {
+      docs: {
+        description
+      },
+      fixable: 'whitespace',
+      deprecated,
+      messages: {
+        missingPadding: 'Expected blank line before this statement.'
+      },
+      schema: [],
+      type: 'suggestion'
+    },
+    defaultOptions: [],
+    create(context) {
+      const paddingContext = {
+        ruleContext: context,
+        sourceCode: context.sourceCode,
+        scopeInfo: createScopeInfo(),
+        configs
+      };
+      const {
+        scopeInfo
+      } = paddingContext;
+      return {
+        Program: scopeInfo.enter,
+        'Program:exit': scopeInfo.enter,
+        BlockStatement: scopeInfo.enter,
+        'BlockStatement:exit': scopeInfo.exit,
+        SwitchStatement: scopeInfo.enter,
+        'SwitchStatement:exit': scopeInfo.exit,
+        ':statement': node => verifyNode(node, paddingContext),
+        SwitchCase(node) {
+          verifyNode(node, paddingContext);
+          scopeInfo.enter();
+        },
+        'SwitchCase:exit': scopeInfo.exit
+      };
+    }
+  });
+};
+exports.createPaddingRule = createPaddingRule;

package/lib/rules/utils/parseJestFnCall.js

@@ -0,0 +1,325 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNodeChain = getNodeChain;
+exports.resolveScope = exports.parseJestFnCallWithReason = exports.parseJestFnCall = exports.isTypeOfJestFnCall = void 0;
+var _utils = require("@typescript-eslint/utils");
+var _utils2 = require("../utils");
+const isTypeOfJestFnCall = (node, context, types) => {
+  const jestFnCall = parseJestFnCall(node, context);
+  return jestFnCall !== null && types.includes(jestFnCall.type);
+};
+exports.isTypeOfJestFnCall = isTypeOfJestFnCall;
+const joinChains = (a, b) => a && b ? [...a, ...b] : null;
+function getNodeChain(node) {
+  if ((0, _utils2.isSupportedAccessor)(node)) {
+    return [node];
+  }
+  switch (node.type) {
+    case _utils.AST_NODE_TYPES.TaggedTemplateExpression:
+      return getNodeChain(node.tag);
+    case _utils.AST_NODE_TYPES.MemberExpression:
+      return joinChains(getNodeChain(node.object), getNodeChain(node.property));
+    case _utils.AST_NODE_TYPES.CallExpression:
+      return getNodeChain(node.callee);
+  }
+  return null;
+}
+const determineJestFnType = name => {
+  if (name === 'expect') {
+    return 'expect';
+  }
+  if (name === 'jest') {
+    return 'jest';
+  }
+  if (_utils2.DescribeAlias.hasOwnProperty(name)) {
+    return 'describe';
+  }
+  if (_utils2.TestCaseName.hasOwnProperty(name)) {
+    return 'test';
+  }
+
+  /* istanbul ignore else */
+  if (_utils2.HookName.hasOwnProperty(name)) {
+    return 'hook';
+  }
+
+  /* istanbul ignore next */
+  return 'unknown';
+};
+const ValidJestFnCallChains = ['afterAll', 'afterEach', 'beforeAll', 'beforeEach', 'describe', 'describe.each', 'describe.only', 'describe.only.each', 'describe.skip', 'describe.skip.each', 'fdescribe', 'fdescribe.each', 'xdescribe', 'xdescribe.each', 'it', 'it.concurrent', 'it.concurrent.failing', 'it.concurrent.each', 'it.concurrent.failing.each', 'it.concurrent.failing.only.each', 'it.concurrent.failing.skip.each', 'it.concurrent.only.each', 'it.concurrent.skip.each', 'it.each', 'it.failing', 'it.failing.each', 'it.only', 'it.only.each', 'it.only.failing', 'it.only.failing.each', 'it.skip', 'it.skip.each', 'it.skip.failing', 'it.skip.failing.each', 'it.todo', 'fit', 'fit.each', 'fit.failing', 'fit.failing.each', 'xit', 'xit.each', 'xit.failing', 'xit.failing.each', 'test', 'test.concurrent', 'test.concurrent.failing', 'test.concurrent.each', 'test.concurrent.failing.each', 'test.concurrent.failing.only.each', 'test.concurrent.failing.skip.each', 'test.concurrent.only.each', 'test.concurrent.skip.each', 'test.each', 'test.failing', 'test.failing.each', 'test.only', 'test.only.each', 'test.only.failing', 'test.only.failing.each', 'test.skip', 'test.skip.each', 'test.skip.failing', 'test.skip.failing.each', 'test.todo', 'xtest', 'xtest.each', 'xtest.failing', 'xtest.failing.each'];
+const resolvePossibleAliasedGlobal = (global, context) => {
+  const globalAliases = context.settings.jest?.globalAliases ?? {};
+  const alias = Object.entries(globalAliases).find(([, aliases]) => aliases.includes(global));
+  if (alias) {
+    return alias[0];
+  }
+  return null;
+};
+const parseJestFnCallCache = new WeakMap();
+const parseJestFnCall = (node, context) => {
+  const jestFnCall = parseJestFnCallWithReason(node, context);
+  if (typeof jestFnCall === 'string') {
+    return null;
+  }
+  return jestFnCall;
+};
+exports.parseJestFnCall = parseJestFnCall;
+const parseJestFnCallWithReason = (node, context) => {
+  let parsedJestFnCall = parseJestFnCallCache.get(node);
+  if (parsedJestFnCall) {
+    return parsedJestFnCall;
+  }
+  parsedJestFnCall = parseJestFnCallWithReasonInner(node, context);
+  parseJestFnCallCache.set(node, parsedJestFnCall);
+  return parsedJestFnCall;
+};
+exports.parseJestFnCallWithReason = parseJestFnCallWithReason;
+const parseJestFnCallWithReasonInner = (node, context) => {
+  const chain = getNodeChain(node);
+  if (!chain?.length) {
+    return null;
+  }
+  const [first, ...rest] = chain;
+  const lastLink = (0, _utils2.getAccessorValue)(chain[chain.length - 1]);
+
+  // if we're an `each()`, ensure we're the outer CallExpression (i.e `.each()()`)
+  if (lastLink === 'each') {
+    if (node.callee.type !== _utils.AST_NODE_TYPES.CallExpression && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
+      return null;
+    }
+  }
+  if (node.callee.type === _utils.AST_NODE_TYPES.TaggedTemplateExpression && lastLink !== 'each') {
+    return null;
+  }
+  const resolved = resolveToJestFn(context, first);
+
+  // we're not a jest function
+  if (!resolved) {
+    return null;
+  }
+  const name = resolved.original ?? resolved.local;
+  const links = [name, ...rest.map(link => (0, _utils2.getAccessorValue)(link))];
+  if (name !== 'jest' && name !== 'expect' && !ValidJestFnCallChains.includes(links.join('.'))) {
+    return null;
+  }
+  const parsedJestFnCall = {
+    name,
+    head: {
+      ...resolved,
+      node: first
+    },
+    // every member node must have a member expression as their parent
+    // in order to be part of the call chain we're parsing
+    members: rest
+  };
+  const type = determineJestFnType(name);
+  if (type === 'expect') {
+    const result = parseJestExpectCall(parsedJestFnCall);
+
+    // if the `expect` call chain is not valid, only report on the topmost node
+    // since all members in the chain are likely to get flagged for some reason
+    if (typeof result === 'string' && (0, _utils2.findTopMostCallExpression)(node) !== node) {
+      return null;
+    }
+    if (result === 'matcher-not-found') {
+      if (node.parent.type === _utils.AST_NODE_TYPES.MemberExpression) {
+        return 'matcher-not-called';
+      }
+    }
+    return result;
+  }
+
+  // check that every link in the chain except the last is a member expression
+  if (chain.slice(0, chain.length - 1).some(nod => nod.parent.type !== _utils.AST_NODE_TYPES.MemberExpression)) {
+    return null;
+  }
+
+  // ensure that we're at the "top" of the function call chain otherwise when
+  // parsing e.g. x().y.z(), we'll incorrectly find & parse "x()" even though
+  // the full chain is not a valid jest function call chain
+  if (node.parent.type === _utils.AST_NODE_TYPES.CallExpression || node.parent.type === _utils.AST_NODE_TYPES.MemberExpression) {
+    return null;
+  }
+  return {
+    ...parsedJestFnCall,
+    type
+  };
+};
+const findModifiersAndMatcher = members => {
+  const modifiers = [];
+  for (const member of members) {
+    // check if the member is being called, which means it is the matcher
+    // (and also the end of the entire "expect" call chain)
+    if (member.parent.parent.type === _utils.AST_NODE_TYPES.CallExpression) {
+      return {
+        matcher: member,
+        args: member.parent.parent.arguments,
+        modifiers
+      };
+    }
+
+    // otherwise, it should be a modifier
+    const name = (0, _utils2.getAccessorValue)(member);
+    if (modifiers.length === 0) {
+      // the first modifier can be any of the three modifiers
+      if (!_utils2.ModifierName.hasOwnProperty(name)) {
+        return 'modifier-unknown';
+      }
+    } else if (modifiers.length === 1) {
+      // the second modifier can only be "not"
+      if (name !== _utils2.ModifierName.not) {
+        return 'modifier-unknown';
+      }
+      const firstModifier = (0, _utils2.getAccessorValue)(modifiers[0]);
+
+      // and the first modifier has to be either "resolves" or "rejects"
+      if (firstModifier !== _utils2.ModifierName.resolves && firstModifier !== _utils2.ModifierName.rejects) {
+        return 'modifier-unknown';
+      }
+    } else {
+      return 'modifier-unknown';
+    }
+    modifiers.push(member);
+  }
+
+  // this will only really happen if there are no members
+  return 'matcher-not-found';
+};
+const parseJestExpectCall = typelessParsedJestFnCall => {
+  const modifiersAndMatcher = findModifiersAndMatcher(typelessParsedJestFnCall.members);
+  if (typeof modifiersAndMatcher === 'string') {
+    return modifiersAndMatcher;
+  }
+  return {
+    ...typelessParsedJestFnCall,
+    type: 'expect',
+    ...modifiersAndMatcher
+  };
+};
+const describeImportDefAsImport = def => {
+  if (def.parent.type === _utils.AST_NODE_TYPES.TSImportEqualsDeclaration) {
+    return null;
+  }
+  if (def.node.type !== _utils.AST_NODE_TYPES.ImportSpecifier) {
+    return null;
+  }
+
+  // we only care about value imports
+  if (def.parent.importKind === 'type') {
+    return null;
+  }
+  return {
+    source: def.parent.source.value,
+    imported: 'name' in def.node.imported ? def.node.imported.name : def.node.imported.value,
+    local: def.node.local.name
+  };
+};
+
+/**
+ * Attempts to find the node that represents the import source for the
+ * given expression node, if it looks like it's an import.
+ *
+ * If no such node can be found (e.g. because the expression doesn't look
+ * like an import), then `null` is returned instead.
+ */
+const findImportSourceNode = node => {
+  if (node.type === _utils.AST_NODE_TYPES.AwaitExpression) {
+    if (node.argument.type === _utils.AST_NODE_TYPES.ImportExpression) {
+      return node.argument.source;
+    }
+    return null;
+  }
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isIdentifier)(node.callee, 'require')) {
+    return node.arguments[0] ?? null;
+  }
+  return null;
+};
+const describeVariableDefAsImport = def => {
+  // make sure that we've actually being assigned a value
+  if (!def.node.init) {
+    return null;
+  }
+  const sourceNode = findImportSourceNode(def.node.init);
+  if (!sourceNode || !(0, _utils2.isStringNode)(sourceNode)) {
+    return null;
+  }
+  if (def.name.parent.type !== _utils.AST_NODE_TYPES.Property) {
+    return null;
+  }
+  if (!(0, _utils2.isSupportedAccessor)(def.name.parent.key)) {
+    return null;
+  }
+  return {
+    source: (0, _utils2.getStringValue)(sourceNode),
+    imported: (0, _utils2.getAccessorValue)(def.name.parent.key),
+    local: def.name.name
+  };
+};
+
+/**
+ * Attempts to describe a definition as an import if possible.
+ *
+ * If the definition is an import binding, it's described as you'd expect.
+ * If the definition is a variable, then we try and determine if it's either
+ * a dynamic `import()` or otherwise a call to `require()`.
+ *
+ * If it's neither of these, `null` is returned to indicate that the definition
+ * is not describable as an import of any kind.
+ */
+const describePossibleImportDef = def => {
+  if (def.type === 'Variable') {
+    return describeVariableDefAsImport(def);
+  }
+  if (def.type === 'ImportBinding') {
+    return describeImportDefAsImport(def);
+  }
+  return null;
+};
+const resolveScope = (scope, identifier) => {
+  let currentScope = scope;
+  while (currentScope !== null) {
+    const ref = currentScope.set.get(identifier);
+    if (ref && ref.defs.length > 0) {
+      const def = ref.defs[ref.defs.length - 1];
+      const importDetails = describePossibleImportDef(def);
+      if (importDetails?.local === identifier) {
+        return importDetails;
+      }
+      return 'local';
+    }
+    currentScope = currentScope.upper;
+  }
+  return null;
+};
+exports.resolveScope = resolveScope;
+const resolveToJestFn = (context, accessor) => {
+  const identifier = (0, _utils2.getAccessorValue)(accessor);
+  const maybeImport = resolveScope(context.sourceCode.getScope(accessor), identifier);
+
+  // the identifier was found as a local variable or function declaration
+  // meaning it's not a function from jest
+  if (maybeImport === 'local') {
+    return null;
+  }
+  if (maybeImport) {
+    const globalPackage = context.settings.jest?.globalPackage ?? '@jest/globals';
+
+    // the identifier is imported from our global package so return the original import name
+    if (maybeImport.source === globalPackage) {
+      return {
+        original: maybeImport.imported,
+        local: maybeImport.local,
+        type: 'import'
+      };
+    }
+    return null;
+  }
+  return {
+    original: resolvePossibleAliasedGlobal(identifier, context),
+    local: identifier,
+    type: 'global'
+  };
+};