@babel/traverse 7.19.6 → 7.20.1

package/lib/path/index.js

@@ -4,60 +4,36 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.SHOULD_STOP = exports.SHOULD_SKIP = exports.REMOVED = void 0;
-
 var virtualTypes = require("./lib/virtual-types");
-
 var _debug = require("debug");
-
 var _index = require("../index");
-
 var _scope = require("../scope");
-
 var _t = require("@babel/types");
-
 var t = _t;
-
 var _cache = require("../cache");
-
 var _generator = require("@babel/generator");
-
 var NodePath_ancestry = require("./ancestry");
-
 var NodePath_inference = require("./inference");
-
 var NodePath_replacement = require("./replacement");
-
 var NodePath_evaluation = require("./evaluation");
-
 var NodePath_conversion = require("./conversion");
-
 var NodePath_introspection = require("./introspection");
-
 var NodePath_context = require("./context");
-
 var NodePath_removal = require("./removal");
-
 var NodePath_modification = require("./modification");
-
 var NodePath_family = require("./family");
-
 var NodePath_comments = require("./comments");
-
 var NodePath_virtual_types_validator = require("./lib/virtual-types-validator");
-
 const {
   validate
 } = _t;
-
 const debug = _debug("babel");
-
 const REMOVED = 1 << 0;
 exports.REMOVED = REMOVED;
 const SHOULD_STOP = 1 << 1;
 exports.SHOULD_STOP = SHOULD_STOP;
 const SHOULD_SKIP = 1 << 2;
 exports.SHOULD_SKIP = SHOULD_SKIP;
-
 class NodePath {
   constructor(hub, parent) {
     this.contexts = [];
@@ -77,7 +53,6 @@ class NodePath {
     this.context = null;
     this.scope = null;
   }
-
   static get({
     hub,
     parentPath,
@@ -89,97 +64,74 @@ class NodePath {
     if (!hub && parentPath) {
       hub = parentPath.hub;
     }
-
     if (!parent) {
       throw new Error("To get a node path the parent needs to exist");
     }
-
-    const targetNode = container[key];
-
+    const targetNode =
+    container[key];
     let paths = _cache.path.get(parent);
-
     if (!paths) {
       paths = new Map();
-
       _cache.path.set(parent, paths);
     }
-
     let path = paths.get(targetNode);
-
     if (!path) {
       path = new NodePath(hub, parent);
       if (targetNode) paths.set(targetNode, path);
     }
-
     path.setup(parentPath, container, listKey, key);
     return path;
   }
-
   getScope(scope) {
     return this.isScope() ? new _scope.default(this) : scope;
   }
-
   setData(key, val) {
     if (this.data == null) {
       this.data = Object.create(null);
     }
-
     return this.data[key] = val;
   }
-
   getData(key, def) {
     if (this.data == null) {
       this.data = Object.create(null);
     }
-
     let val = this.data[key];
     if (val === undefined && def !== undefined) val = this.data[key] = def;
     return val;
   }
-
   hasNode() {
     return this.node != null;
   }
-
   buildCodeFrameError(msg, Error = SyntaxError) {
     return this.hub.buildError(this.node, msg, Error);
   }
-
   traverse(visitor, state) {
     (0, _index.default)(this.node, visitor, this.scope, state, this);
   }
-
   set(key, node) {
     validate(this.node, key, node);
     this.node[key] = node;
   }
-
   getPathLocation() {
     const parts = [];
     let path = this;
-
     do {
       let key = path.key;
       if (path.inList) key = `${path.listKey}[${key}]`;
       parts.unshift(key);
     } while (path = path.parentPath);
-
     return parts.join(".");
   }
-
   debug(message) {
     if (!debug.enabled) return;
     debug(`${this.getPathLocation()} ${this.type}: ${message}`);
   }
-
   toString() {
     return (0, _generator.default)(this.node).code;
   }
-
   get inList() {
     return !!this.listKey;
   }
-
   set inList(inList) {
     if (!inList) {
       this.listKey = null;
@@ -189,11 +141,9 @@ class NodePath {
   get parentKey() {
     return this.listKey || this.key;
   }
-
   get shouldSkip() {
     return !!(this._traverseFlags & SHOULD_SKIP);
   }
-
   set shouldSkip(v) {
     if (v) {
       this._traverseFlags |= SHOULD_SKIP;
@@ -201,11 +151,9 @@ class NodePath {
       this._traverseFlags &= ~SHOULD_SKIP;
     }
   }
-
   get shouldStop() {
     return !!(this._traverseFlags & SHOULD_STOP);
   }
-
   set shouldStop(v) {
     if (v) {
       this._traverseFlags |= SHOULD_STOP;
@@ -213,11 +161,9 @@ class NodePath {
       this._traverseFlags &= ~SHOULD_STOP;
     }
   }
-
   get removed() {
     return !!(this._traverseFlags & REMOVED);
   }
-
   set removed(v) {
     if (v) {
       this._traverseFlags |= REMOVED;
@@ -225,9 +171,7 @@ class NodePath {
       this._traverseFlags &= ~REMOVED;
     }
   }
-
 }
-
 Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePath_replacement, NodePath_evaluation, NodePath_conversion, NodePath_introspection, NodePath_context, NodePath_removal, NodePath_modification, NodePath_family, NodePath_comments);
 {
   NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions = NodePath_introspection._guessExecutionStatusRelativeTo;
@@ -236,7 +180,6 @@ Object.assign(NodePath.prototype, NodePath_ancestry, NodePath_inference, NodePat
 for (const type of t.TYPES) {
   const typeKey = `is${type}`;
   const fn = t[typeKey];
-
   NodePath.prototype[typeKey] = function (opts) {
     return fn(this.node, opts);
   };
@@ -249,12 +192,10 @@ for (const type of t.TYPES) {
 }
 
 Object.assign(NodePath.prototype, NodePath_virtual_types_validator);
-
 for (const type of Object.keys(virtualTypes)) {
   if (type[0] === "_") continue;
   if (!t.TYPES.includes(type)) t.TYPES.push(type);
 }
-
 var _default = NodePath;
 exports.default = _default;
 

package/lib/path/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["validate","debug","buildDebug","REMOVED","SHOULD_STOP","SHOULD_SKIP","NodePath","constructor","hub","parent","contexts","state","opts","_traverseFlags","skipKeys","parentPath","container","listKey","key","node","type","data","context","scope","get","Error","targetNode","paths","pathCache","Map","set","path","setup","getScope","isScope","Scope","setData","val","Object","create","getData","def","undefined","hasNode","buildCodeFrameError","msg","SyntaxError","buildError","traverse","visitor","getPathLocation","parts","inList","unshift","join","message","enabled","toString","generator","code","parentKey","shouldSkip","v","shouldStop","removed","assign","prototype","NodePath_ancestry","NodePath_inference","NodePath_replacement","NodePath_evaluation","NodePath_conversion","NodePath_introspection","NodePath_context","NodePath_removal","NodePath_modification","NodePath_family","NodePath_comments","_guessExecutionStatusRelativeToDifferentFunctions","_guessExecutionStatusRelativeTo","t","TYPES","typeKey","fn","TypeError","NodePath_virtual_types_validator","keys","virtualTypes","includes","push"],"sources":["../../src/path/index.ts"],"sourcesContent":["import type { HubInterface } from \"../hub\";\nimport type TraversalContext from \"../context\";\nimport * as virtualTypes from \"./lib/virtual-types\";\nimport buildDebug from \"debug\";\nimport traverse from \"../index\";\nimport type { Visitor } from \"../types\";\nimport Scope from \"../scope\";\nimport { validate } from \"@babel/types\";\nimport * as t from \"@babel/types\";\nimport { path as pathCache } from \"../cache\";\nimport generator from \"@babel/generator\";\n\n// NodePath is split across many files.\nimport * as NodePath_ancestry from \"./ancestry\";\nimport * as NodePath_inference from \"./inference\";\nimport * as NodePath_replacement from \"./replacement\";\nimport * as NodePath_evaluation from \"./evaluation\";\nimport * as NodePath_conversion from \"./conversion\";\nimport * as NodePath_introspection from \"./introspection\";\nimport * as NodePath_context from \"./context\";\nimport * as NodePath_removal from \"./removal\";\nimport * as NodePath_modification from \"./modification\";\nimport * as NodePath_family from \"./family\";\nimport * as NodePath_comments from \"./comments\";\nimport * as NodePath_virtual_types_validator from \"./lib/virtual-types-validator\";\nimport type { NodePathAssetions } from \"./generated/asserts\";\nimport type { NodePathValidators } from \"./generated/validators\";\n\nconst debug = buildDebug(\"babel\");\n\nexport const REMOVED = 1 << 0;\nexport const SHOULD_STOP = 1 << 1;\nexport const SHOULD_SKIP = 1 << 2;\n\nclass NodePath<T extends t.Node = t.Node> {\n  constructor(hub: HubInterface, parent: t.ParentMaps[T[\"type\"]]) {\n    this.parent = parent;\n    this.hub = hub;\n    this.data = null;\n\n    this.context = null;\n    this.scope = null;\n  }\n\n  declare parent: t.ParentMaps[T[\"type\"]];\n  declare hub: HubInterface;\n  declare data: Record<string | symbol, unknown>;\n  // TraversalContext is configured by setContext\n  declare context: TraversalContext;\n  declare scope: Scope;\n\n  contexts: Array<TraversalContext> = [];\n  state: any = null;\n  opts: any = null;\n  // this.shouldSkip = false; this.shouldStop = false; this.removed = false;\n  _traverseFlags: number = 0;\n  skipKeys: any = null;\n  parentPath: t.ParentMaps[T[\"type\"]] extends null\n    ? null\n    : NodePath<t.ParentMaps[T[\"type\"]]> | null = null;\n  container: t.Node | Array<t.Node> | null = null;\n  listKey: string | null = null;\n  key: string | number | null = null;\n  node: T = null;\n  type: T[\"type\"] | null = null;\n\n  static get({\n    hub,\n    parentPath,\n    parent,\n    container,\n    listKey,\n    key,\n  }: {\n    hub?: HubInterface;\n    parentPath: NodePath | null;\n    parent: t.Node;\n    container: t.Node | t.Node[];\n    listKey?: string;\n    key: string | number;\n  }): NodePath {\n    if (!hub && parentPath) {\n      hub = parentPath.hub;\n    }\n\n    if (!parent) {\n      throw new Error(\"To get a node path the parent needs to exist\");\n    }\n\n    const targetNode =\n      // @ts-expect-error key must present in container\n      container[key];\n\n    let paths = pathCache.get(parent);\n    if (!paths) {\n      paths = new Map();\n      pathCache.set(parent, paths);\n    }\n\n    let path = paths.get(targetNode);\n    if (!path) {\n      path = new NodePath(hub, parent);\n      if (targetNode) paths.set(targetNode, path);\n    }\n\n    path.setup(parentPath, container, listKey, key);\n\n    return path;\n  }\n\n  getScope(scope: Scope): Scope {\n    return this.isScope() ? new Scope(this) : scope;\n  }\n\n  setData(key: string | symbol, val: any): any {\n    if (this.data == null) {\n      this.data = Object.create(null);\n    }\n    return (this.data[key] = val);\n  }\n\n  getData(key: string | symbol, def?: any): any {\n    if (this.data == null) {\n      this.data = Object.create(null);\n    }\n    let val = this.data[key];\n    if (val === undefined && def !== undefined) val = this.data[key] = def;\n    return val;\n  }\n\n  hasNode(): this is NodePath<NonNullable<this[\"node\"]>> {\n    return this.node != null;\n  }\n\n  buildCodeFrameError(\n    msg: string,\n    Error: new () => Error = SyntaxError,\n  ): Error {\n    return this.hub.buildError(this.node, msg, Error);\n  }\n\n  traverse<T>(visitor: Visitor<T>, state: T): void;\n  traverse(visitor: Visitor): void;\n  traverse(visitor: any, state?: any) {\n    traverse(this.node, visitor, this.scope, state, this);\n  }\n\n  set(key: string, node: any) {\n    validate(this.node, key, node);\n    // @ts-expect-error key must present in this.node\n    this.node[key] = node;\n  }\n\n  getPathLocation(): string {\n    const parts = [];\n    let path: NodePath = this;\n    do {\n      let key = path.key;\n      if (path.inList) key = `${path.listKey}[${key}]`;\n      parts.unshift(key);\n    } while ((path = path.parentPath));\n    return parts.join(\".\");\n  }\n\n  debug(message: string) {\n    if (!debug.enabled) return;\n    debug(`${this.getPathLocation()} ${this.type}: ${message}`);\n  }\n\n  toString() {\n    return generator(this.node).code;\n  }\n\n  get inList() {\n    return !!this.listKey;\n  }\n\n  set inList(inList) {\n    if (!inList) {\n      this.listKey = null;\n    }\n    // ignore inList = true as it should depend on `listKey`\n  }\n\n  get parentKey(): string {\n    return (this.listKey || this.key) as string;\n  }\n\n  get shouldSkip() {\n    return !!(this._traverseFlags & SHOULD_SKIP);\n  }\n\n  set shouldSkip(v) {\n    if (v) {\n      this._traverseFlags |= SHOULD_SKIP;\n    } else {\n      this._traverseFlags &= ~SHOULD_SKIP;\n    }\n  }\n\n  get shouldStop() {\n    return !!(this._traverseFlags & SHOULD_STOP);\n  }\n\n  set shouldStop(v) {\n    if (v) {\n      this._traverseFlags |= SHOULD_STOP;\n    } else {\n      this._traverseFlags &= ~SHOULD_STOP;\n    }\n  }\n\n  get removed() {\n    return !!(this._traverseFlags & REMOVED);\n  }\n  set removed(v) {\n    if (v) {\n      this._traverseFlags |= REMOVED;\n    } else {\n      this._traverseFlags &= ~REMOVED;\n    }\n  }\n}\n\nObject.assign(\n  NodePath.prototype,\n  NodePath_ancestry,\n  NodePath_inference,\n  NodePath_replacement,\n  NodePath_evaluation,\n  NodePath_conversion,\n  NodePath_introspection,\n  NodePath_context,\n  NodePath_removal,\n  NodePath_modification,\n  NodePath_family,\n  NodePath_comments,\n);\n\nif (!process.env.BABEL_8_BREAKING) {\n  // @ts-expect-error The original _guessExecutionStatusRelativeToDifferentFunctions only worked for paths in\n  // different functions, but _guessExecutionStatusRelativeTo works as a replacement in those cases.\n  NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions =\n    NodePath_introspection._guessExecutionStatusRelativeTo;\n}\n\n// we can not use `import { TYPES } from \"@babel/types\"` here\n// because the transformNamedBabelTypesImportToDestructuring plugin in babel.config.js\n// does not offer live bindings for `TYPES`\n// we can change to `import { TYPES }` when we are publishing ES modules only\nfor (const type of t.TYPES) {\n  const typeKey = `is${type}`;\n  // @ts-expect-error typeKey must present in t\n  const fn = t[typeKey];\n  // @ts-expect-error augmenting NodePath prototype\n  NodePath.prototype[typeKey] = function (opts: any) {\n    return fn(this.node, opts);\n  };\n\n  // @ts-expect-error augmenting NodePath prototype\n  NodePath.prototype[`assert${type}`] = function (opts: any) {\n    if (!fn(this.node, opts)) {\n      throw new TypeError(`Expected node path of type ${type}`);\n    }\n  };\n}\n\n// Register virtual types validators after base types validators\nObject.assign(NodePath.prototype, NodePath_virtual_types_validator);\n\nfor (const type of Object.keys(virtualTypes) as (keyof typeof virtualTypes)[]) {\n  if (type[0] === \"_\") continue;\n  if (!t.TYPES.includes(type)) t.TYPES.push(type);\n}\n\ntype NodePathMixins = typeof NodePath_ancestry &\n  typeof NodePath_inference &\n  typeof NodePath_replacement &\n  typeof NodePath_evaluation &\n  typeof NodePath_conversion &\n  typeof NodePath_introspection &\n  typeof NodePath_context &\n  typeof NodePath_removal &\n  typeof NodePath_modification &\n  typeof NodePath_family &\n  typeof NodePath_comments;\n\n// @ts-expect-error TS throws because ensureBlock returns the body node path\n// however, we don't use the return value and treat it as a transform and\n// assertion utilities. For better type inference we annotate it as an\n// assertion method\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface NodePath<T>\n  extends NodePathAssetions,\n    NodePathValidators,\n    NodePathMixins {\n  /**\n   * @see ./conversion.ts for implementation\n   */\n  ensureBlock<\n    T extends\n      | t.Loop\n      | t.WithStatement\n      | t.Function\n      | t.LabeledStatement\n      | t.CatchClause,\n  >(\n    this: NodePath<T>,\n  ): asserts this is NodePath<T & { body: t.BlockStatement }>;\n}\n\nexport default NodePath;\n"],"mappings":";;;;;;;AAEA;;AACA;;AACA;;AAEA;;AACA;;;;AAEA;;AACA;;AAGA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;EAjBSA;;;AAqBT,MAAMC,KAAK,GAAGC,MAAU,CAAC,OAAD,CAAxB;;AAEO,MAAMC,OAAO,GAAG,KAAK,CAArB;;AACA,MAAMC,WAAW,GAAG,KAAK,CAAzB;;AACA,MAAMC,WAAW,GAAG,KAAK,CAAzB;;;AAEP,MAAMC,QAAN,CAA0C;EACxCC,WAAW,CAACC,GAAD,EAAoBC,MAApB,EAAqD;IAAA,KAgBhEC,QAhBgE,GAgB5B,EAhB4B;IAAA,KAiBhEC,KAjBgE,GAiBnD,IAjBmD;IAAA,KAkBhEC,IAlBgE,GAkBpD,IAlBoD;IAAA,KAoBhEC,cApBgE,GAoBvC,CApBuC;IAAA,KAqBhEC,QArBgE,GAqBhD,IArBgD;IAAA,KAsBhEC,UAtBgE,GAwBjB,IAxBiB;IAAA,KAyBhEC,SAzBgE,GAyBrB,IAzBqB;IAAA,KA0BhEC,OA1BgE,GA0BvC,IA1BuC;IAAA,KA2BhEC,GA3BgE,GA2BlC,IA3BkC;IAAA,KA4BhEC,IA5BgE,GA4BtD,IA5BsD;IAAA,KA6BhEC,IA7BgE,GA6BvC,IA7BuC;IAC9D,KAAKX,MAAL,GAAcA,MAAd;IACA,KAAKD,GAAL,GAAWA,GAAX;IACA,KAAKa,IAAL,GAAY,IAAZ;IAEA,KAAKC,OAAL,GAAe,IAAf;IACA,KAAKC,KAAL,GAAa,IAAb;EACD;;EAwBS,OAAHC,GAAG,CAAC;IACThB,GADS;IAETO,UAFS;IAGTN,MAHS;IAITO,SAJS;IAKTC,OALS;IAMTC;EANS,CAAD,EAcG;IACX,IAAI,CAACV,GAAD,IAAQO,UAAZ,EAAwB;MACtBP,GAAG,GAAGO,UAAU,CAACP,GAAjB;IACD;;IAED,IAAI,CAACC,MAAL,EAAa;MACX,MAAM,IAAIgB,KAAJ,CAAU,8CAAV,CAAN;IACD;;IAED,MAAMC,UAAU,GAEdV,SAAS,CAACE,GAAD,CAFX;;IAIA,IAAIS,KAAK,GAAGC,WAAA,CAAUJ,GAAV,CAAcf,MAAd,CAAZ;;IACA,IAAI,CAACkB,KAAL,EAAY;MACVA,KAAK,GAAG,IAAIE,GAAJ,EAAR;;MACAD,WAAA,CAAUE,GAAV,CAAcrB,MAAd,EAAsBkB,KAAtB;IACD;;IAED,IAAII,IAAI,GAAGJ,KAAK,CAACH,GAAN,CAAUE,UAAV,CAAX;;IACA,IAAI,CAACK,IAAL,EAAW;MACTA,IAAI,GAAG,IAAIzB,QAAJ,CAAaE,GAAb,EAAkBC,MAAlB,CAAP;MACA,IAAIiB,UAAJ,EAAgBC,KAAK,CAACG,GAAN,CAAUJ,UAAV,EAAsBK,IAAtB;IACjB;;IAEDA,IAAI,CAACC,KAAL,CAAWjB,UAAX,EAAuBC,SAAvB,EAAkCC,OAAlC,EAA2CC,GAA3C;IAEA,OAAOa,IAAP;EACD;;EAEDE,QAAQ,CAACV,KAAD,EAAsB;IAC5B,OAAO,KAAKW,OAAL,KAAiB,IAAIC,cAAJ,CAAU,IAAV,CAAjB,GAAmCZ,KAA1C;EACD;;EAEDa,OAAO,CAAClB,GAAD,EAAuBmB,GAAvB,EAAsC;IAC3C,IAAI,KAAKhB,IAAL,IAAa,IAAjB,EAAuB;MACrB,KAAKA,IAAL,GAAYiB,MAAM,CAACC,MAAP,CAAc,IAAd,CAAZ;IACD;;IACD,OAAQ,KAAKlB,IAAL,CAAUH,GAAV,IAAiBmB,GAAzB;EACD;;EAEDG,OAAO,CAACtB,GAAD,EAAuBuB,GAAvB,EAAuC;IAC5C,IAAI,KAAKpB,IAAL,IAAa,IAAjB,EAAuB;MACrB,KAAKA,IAAL,GAAYiB,MAAM,CAACC,MAAP,CAAc,IAAd,CAAZ;IACD;;IACD,IAAIF,GAAG,GAAG,KAAKhB,IAAL,CAAUH,GAAV,CAAV;IACA,IAAImB,GAAG,KAAKK,SAAR,IAAqBD,GAAG,KAAKC,SAAjC,EAA4CL,GAAG,GAAG,KAAKhB,IAAL,CAAUH,GAAV,IAAiBuB,GAAvB;IAC5C,OAAOJ,GAAP;EACD;;EAEDM,OAAO,GAAgD;IACrD,OAAO,KAAKxB,IAAL,IAAa,IAApB;EACD;;EAEDyB,mBAAmB,CACjBC,GADiB,EAEjBpB,KAAsB,GAAGqB,WAFR,EAGV;IACP,OAAO,KAAKtC,GAAL,CAASuC,UAAT,CAAoB,KAAK5B,IAAzB,EAA+B0B,GAA/B,EAAoCpB,KAApC,CAAP;EACD;;EAIDuB,QAAQ,CAACC,OAAD,EAAetC,KAAf,EAA4B;IAClC,IAAAqC,cAAA,EAAS,KAAK7B,IAAd,EAAoB8B,OAApB,EAA6B,KAAK1B,KAAlC,EAAyCZ,KAAzC,EAAgD,IAAhD;EACD;;EAEDmB,GAAG,CAACZ,GAAD,EAAcC,IAAd,EAAyB;IAC1BnB,QAAQ,CAAC,KAAKmB,IAAN,EAAYD,GAAZ,EAAiBC,IAAjB,CAAR;IAEA,KAAKA,IAAL,CAAUD,GAAV,IAAiBC,IAAjB;EACD;;EAED+B,eAAe,GAAW;IACxB,MAAMC,KAAK,GAAG,EAAd;IACA,IAAIpB,IAAc,GAAG,IAArB;;IACA,GAAG;MACD,IAAIb,GAAG,GAAGa,IAAI,CAACb,GAAf;MACA,IAAIa,IAAI,CAACqB,MAAT,EAAiBlC,GAAG,GAAI,GAAEa,IAAI,CAACd,OAAQ,IAAGC,GAAI,GAA7B;MACjBiC,KAAK,CAACE,OAAN,CAAcnC,GAAd;IACD,CAJD,QAIUa,IAAI,GAAGA,IAAI,CAAChB,UAJtB;;IAKA,OAAOoC,KAAK,CAACG,IAAN,CAAW,GAAX,CAAP;EACD;;EAEDrD,KAAK,CAACsD,OAAD,EAAkB;IACrB,IAAI,CAACtD,KAAK,CAACuD,OAAX,EAAoB;IACpBvD,KAAK,CAAE,GAAE,KAAKiD,eAAL,EAAuB,IAAG,KAAK9B,IAAK,KAAImC,OAAQ,EAApD,CAAL;EACD;;EAEDE,QAAQ,GAAG;IACT,OAAO,IAAAC,kBAAA,EAAU,KAAKvC,IAAf,EAAqBwC,IAA5B;EACD;;EAES,IAANP,MAAM,GAAG;IACX,OAAO,CAAC,CAAC,KAAKnC,OAAd;EACD;;EAES,IAANmC,MAAM,CAACA,MAAD,EAAS;IACjB,IAAI,CAACA,MAAL,EAAa;MACX,KAAKnC,OAAL,GAAe,IAAf;IACD;EAEF;;EAEY,IAAT2C,SAAS,GAAW;IACtB,OAAQ,KAAK3C,OAAL,IAAgB,KAAKC,GAA7B;EACD;;EAEa,IAAV2C,UAAU,GAAG;IACf,OAAO,CAAC,EAAE,KAAKhD,cAAL,GAAsBR,WAAxB,CAAR;EACD;;EAEa,IAAVwD,UAAU,CAACC,CAAD,EAAI;IAChB,IAAIA,CAAJ,EAAO;MACL,KAAKjD,cAAL,IAAuBR,WAAvB;IACD,CAFD,MAEO;MACL,KAAKQ,cAAL,IAAuB,CAACR,WAAxB;IACD;EACF;;EAEa,IAAV0D,UAAU,GAAG;IACf,OAAO,CAAC,EAAE,KAAKlD,cAAL,GAAsBT,WAAxB,CAAR;EACD;;EAEa,IAAV2D,UAAU,CAACD,CAAD,EAAI;IAChB,IAAIA,CAAJ,EAAO;MACL,KAAKjD,cAAL,IAAuBT,WAAvB;IACD,CAFD,MAEO;MACL,KAAKS,cAAL,IAAuB,CAACT,WAAxB;IACD;EACF;;EAEU,IAAP4D,OAAO,GAAG;IACZ,OAAO,CAAC,EAAE,KAAKnD,cAAL,GAAsBV,OAAxB,CAAR;EACD;;EACU,IAAP6D,OAAO,CAACF,CAAD,EAAI;IACb,IAAIA,CAAJ,EAAO;MACL,KAAKjD,cAAL,IAAuBV,OAAvB;IACD,CAFD,MAEO;MACL,KAAKU,cAAL,IAAuB,CAACV,OAAxB;IACD;EACF;;AA3LuC;;AA8L1CmC,MAAM,CAAC2B,MAAP,CACE3D,QAAQ,CAAC4D,SADX,EAEEC,iBAFF,EAGEC,kBAHF,EAIEC,oBAJF,EAKEC,mBALF,EAMEC,mBANF,EAOEC,sBAPF,EAQEC,gBARF,EASEC,gBATF,EAUEC,qBAVF,EAWEC,eAXF,EAYEC,iBAZF;AAemC;EAGjCvE,QAAQ,CAAC4D,SAAT,CAAmBY,iDAAnB,GACEN,sBAAsB,CAACO,+BADzB;AAED;;AAMD,KAAK,MAAM3D,IAAX,IAAmB4D,CAAC,CAACC,KAArB,EAA4B;EAC1B,MAAMC,OAAO,GAAI,KAAI9D,IAAK,EAA1B;EAEA,MAAM+D,EAAE,GAAGH,CAAC,CAACE,OAAD,CAAZ;;EAEA5E,QAAQ,CAAC4D,SAAT,CAAmBgB,OAAnB,IAA8B,UAAUtE,IAAV,EAAqB;IACjD,OAAOuE,EAAE,CAAC,KAAKhE,IAAN,EAAYP,IAAZ,CAAT;EACD,CAFD;;EAKAN,QAAQ,CAAC4D,SAAT,CAAoB,SAAQ9C,IAAK,EAAjC,IAAsC,UAAUR,IAAV,EAAqB;IACzD,IAAI,CAACuE,EAAE,CAAC,KAAKhE,IAAN,EAAYP,IAAZ,CAAP,EAA0B;MACxB,MAAM,IAAIwE,SAAJ,CAAe,8BAA6BhE,IAAK,EAAjD,CAAN;IACD;EACF,CAJD;AAKD;;AAGDkB,MAAM,CAAC2B,MAAP,CAAc3D,QAAQ,CAAC4D,SAAvB,EAAkCmB,gCAAlC;;AAEA,KAAK,MAAMjE,IAAX,IAAmBkB,MAAM,CAACgD,IAAP,CAAYC,YAAZ,CAAnB,EAA+E;EAC7E,IAAInE,IAAI,CAAC,CAAD,CAAJ,KAAY,GAAhB,EAAqB;EACrB,IAAI,CAAC4D,CAAC,CAACC,KAAF,CAAQO,QAAR,CAAiBpE,IAAjB,CAAL,EAA6B4D,CAAC,CAACC,KAAF,CAAQQ,IAAR,CAAarE,IAAb;AAC9B;;eAsCcd,Q"}
+{"version":3,"names":["validate","debug","buildDebug","REMOVED","SHOULD_STOP","SHOULD_SKIP","NodePath","constructor","hub","parent","contexts","state","opts","_traverseFlags","skipKeys","parentPath","container","listKey","key","node","type","data","context","scope","get","Error","targetNode","paths","pathCache","Map","set","path","setup","getScope","isScope","Scope","setData","val","Object","create","getData","def","undefined","hasNode","buildCodeFrameError","msg","SyntaxError","buildError","traverse","visitor","getPathLocation","parts","inList","unshift","join","message","enabled","toString","generator","code","parentKey","shouldSkip","v","shouldStop","removed","assign","prototype","NodePath_ancestry","NodePath_inference","NodePath_replacement","NodePath_evaluation","NodePath_conversion","NodePath_introspection","NodePath_context","NodePath_removal","NodePath_modification","NodePath_family","NodePath_comments","_guessExecutionStatusRelativeToDifferentFunctions","_guessExecutionStatusRelativeTo","t","TYPES","typeKey","fn","TypeError","NodePath_virtual_types_validator","keys","virtualTypes","includes","push"],"sources":["../../src/path/index.ts"],"sourcesContent":["import type { HubInterface } from \"../hub\";\nimport type TraversalContext from \"../context\";\nimport * as virtualTypes from \"./lib/virtual-types\";\nimport buildDebug from \"debug\";\nimport traverse from \"../index\";\nimport type { Visitor } from \"../types\";\nimport Scope from \"../scope\";\nimport { validate } from \"@babel/types\";\nimport * as t from \"@babel/types\";\nimport { path as pathCache } from \"../cache\";\nimport generator from \"@babel/generator\";\n\n// NodePath is split across many files.\nimport * as NodePath_ancestry from \"./ancestry\";\nimport * as NodePath_inference from \"./inference\";\nimport * as NodePath_replacement from \"./replacement\";\nimport * as NodePath_evaluation from \"./evaluation\";\nimport * as NodePath_conversion from \"./conversion\";\nimport * as NodePath_introspection from \"./introspection\";\nimport * as NodePath_context from \"./context\";\nimport * as NodePath_removal from \"./removal\";\nimport * as NodePath_modification from \"./modification\";\nimport * as NodePath_family from \"./family\";\nimport * as NodePath_comments from \"./comments\";\nimport * as NodePath_virtual_types_validator from \"./lib/virtual-types-validator\";\nimport type { NodePathAssetions } from \"./generated/asserts\";\nimport type { NodePathValidators } from \"./generated/validators\";\n\nconst debug = buildDebug(\"babel\");\n\nexport const REMOVED = 1 << 0;\nexport const SHOULD_STOP = 1 << 1;\nexport const SHOULD_SKIP = 1 << 2;\n\nclass NodePath<T extends t.Node = t.Node> {\n  constructor(hub: HubInterface, parent: t.ParentMaps[T[\"type\"]]) {\n    this.parent = parent;\n    this.hub = hub;\n    this.data = null;\n\n    this.context = null;\n    this.scope = null;\n  }\n\n  declare parent: t.ParentMaps[T[\"type\"]];\n  declare hub: HubInterface;\n  declare data: Record<string | symbol, unknown>;\n  // TraversalContext is configured by setContext\n  declare context: TraversalContext;\n  declare scope: Scope;\n\n  contexts: Array<TraversalContext> = [];\n  state: any = null;\n  opts: any = null;\n  // this.shouldSkip = false; this.shouldStop = false; this.removed = false;\n  _traverseFlags: number = 0;\n  skipKeys: any = null;\n  parentPath: t.ParentMaps[T[\"type\"]] extends null\n    ? null\n    : NodePath<t.ParentMaps[T[\"type\"]]> | null = null;\n  container: t.Node | Array<t.Node> | null = null;\n  listKey: string | null = null;\n  key: string | number | null = null;\n  node: T = null;\n  type: T[\"type\"] | null = null;\n\n  static get({\n    hub,\n    parentPath,\n    parent,\n    container,\n    listKey,\n    key,\n  }: {\n    hub?: HubInterface;\n    parentPath: NodePath | null;\n    parent: t.Node;\n    container: t.Node | t.Node[];\n    listKey?: string;\n    key: string | number;\n  }): NodePath {\n    if (!hub && parentPath) {\n      hub = parentPath.hub;\n    }\n\n    if (!parent) {\n      throw new Error(\"To get a node path the parent needs to exist\");\n    }\n\n    const targetNode =\n      // @ts-expect-error key must present in container\n      container[key];\n\n    let paths = pathCache.get(parent);\n    if (!paths) {\n      paths = new Map();\n      pathCache.set(parent, paths);\n    }\n\n    let path = paths.get(targetNode);\n    if (!path) {\n      path = new NodePath(hub, parent);\n      if (targetNode) paths.set(targetNode, path);\n    }\n\n    path.setup(parentPath, container, listKey, key);\n\n    return path;\n  }\n\n  getScope(scope: Scope): Scope {\n    return this.isScope() ? new Scope(this) : scope;\n  }\n\n  setData(key: string | symbol, val: any): any {\n    if (this.data == null) {\n      this.data = Object.create(null);\n    }\n    return (this.data[key] = val);\n  }\n\n  getData(key: string | symbol, def?: any): any {\n    if (this.data == null) {\n      this.data = Object.create(null);\n    }\n    let val = this.data[key];\n    if (val === undefined && def !== undefined) val = this.data[key] = def;\n    return val;\n  }\n\n  hasNode(): this is NodePath<NonNullable<this[\"node\"]>> {\n    return this.node != null;\n  }\n\n  buildCodeFrameError(\n    msg: string,\n    Error: new () => Error = SyntaxError,\n  ): Error {\n    return this.hub.buildError(this.node, msg, Error);\n  }\n\n  traverse<T>(visitor: Visitor<T>, state: T): void;\n  traverse(visitor: Visitor): void;\n  traverse(visitor: any, state?: any) {\n    traverse(this.node, visitor, this.scope, state, this);\n  }\n\n  set(key: string, node: any) {\n    validate(this.node, key, node);\n    // @ts-expect-error key must present in this.node\n    this.node[key] = node;\n  }\n\n  getPathLocation(): string {\n    const parts = [];\n    let path: NodePath = this;\n    do {\n      let key = path.key;\n      if (path.inList) key = `${path.listKey}[${key}]`;\n      parts.unshift(key);\n    } while ((path = path.parentPath));\n    return parts.join(\".\");\n  }\n\n  debug(message: string) {\n    if (!debug.enabled) return;\n    debug(`${this.getPathLocation()} ${this.type}: ${message}`);\n  }\n\n  toString() {\n    return generator(this.node).code;\n  }\n\n  get inList() {\n    return !!this.listKey;\n  }\n\n  set inList(inList) {\n    if (!inList) {\n      this.listKey = null;\n    }\n    // ignore inList = true as it should depend on `listKey`\n  }\n\n  get parentKey(): string {\n    return (this.listKey || this.key) as string;\n  }\n\n  get shouldSkip() {\n    return !!(this._traverseFlags & SHOULD_SKIP);\n  }\n\n  set shouldSkip(v) {\n    if (v) {\n      this._traverseFlags |= SHOULD_SKIP;\n    } else {\n      this._traverseFlags &= ~SHOULD_SKIP;\n    }\n  }\n\n  get shouldStop() {\n    return !!(this._traverseFlags & SHOULD_STOP);\n  }\n\n  set shouldStop(v) {\n    if (v) {\n      this._traverseFlags |= SHOULD_STOP;\n    } else {\n      this._traverseFlags &= ~SHOULD_STOP;\n    }\n  }\n\n  get removed() {\n    return !!(this._traverseFlags & REMOVED);\n  }\n  set removed(v) {\n    if (v) {\n      this._traverseFlags |= REMOVED;\n    } else {\n      this._traverseFlags &= ~REMOVED;\n    }\n  }\n}\n\nObject.assign(\n  NodePath.prototype,\n  NodePath_ancestry,\n  NodePath_inference,\n  NodePath_replacement,\n  NodePath_evaluation,\n  NodePath_conversion,\n  NodePath_introspection,\n  NodePath_context,\n  NodePath_removal,\n  NodePath_modification,\n  NodePath_family,\n  NodePath_comments,\n);\n\nif (!process.env.BABEL_8_BREAKING) {\n  // @ts-expect-error The original _guessExecutionStatusRelativeToDifferentFunctions only worked for paths in\n  // different functions, but _guessExecutionStatusRelativeTo works as a replacement in those cases.\n  NodePath.prototype._guessExecutionStatusRelativeToDifferentFunctions =\n    NodePath_introspection._guessExecutionStatusRelativeTo;\n}\n\n// we can not use `import { TYPES } from \"@babel/types\"` here\n// because the transformNamedBabelTypesImportToDestructuring plugin in babel.config.js\n// does not offer live bindings for `TYPES`\n// we can change to `import { TYPES }` when we are publishing ES modules only\nfor (const type of t.TYPES) {\n  const typeKey = `is${type}`;\n  // @ts-expect-error typeKey must present in t\n  const fn = t[typeKey];\n  // @ts-expect-error augmenting NodePath prototype\n  NodePath.prototype[typeKey] = function (opts: any) {\n    return fn(this.node, opts);\n  };\n\n  // @ts-expect-error augmenting NodePath prototype\n  NodePath.prototype[`assert${type}`] = function (opts: any) {\n    if (!fn(this.node, opts)) {\n      throw new TypeError(`Expected node path of type ${type}`);\n    }\n  };\n}\n\n// Register virtual types validators after base types validators\nObject.assign(NodePath.prototype, NodePath_virtual_types_validator);\n\nfor (const type of Object.keys(virtualTypes) as (keyof typeof virtualTypes)[]) {\n  if (type[0] === \"_\") continue;\n  if (!t.TYPES.includes(type)) t.TYPES.push(type);\n}\n\ntype NodePathMixins = typeof NodePath_ancestry &\n  typeof NodePath_inference &\n  typeof NodePath_replacement &\n  typeof NodePath_evaluation &\n  typeof NodePath_conversion &\n  typeof NodePath_introspection &\n  typeof NodePath_context &\n  typeof NodePath_removal &\n  typeof NodePath_modification &\n  typeof NodePath_family &\n  typeof NodePath_comments;\n\n// @ts-expect-error TS throws because ensureBlock returns the body node path\n// however, we don't use the return value and treat it as a transform and\n// assertion utilities. For better type inference we annotate it as an\n// assertion method\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ninterface NodePath<T>\n  extends NodePathAssetions,\n    NodePathValidators,\n    NodePathMixins {\n  /**\n   * @see ./conversion.ts for implementation\n   */\n  ensureBlock<\n    T extends\n      | t.Loop\n      | t.WithStatement\n      | t.Function\n      | t.LabeledStatement\n      | t.CatchClause,\n  >(\n    this: NodePath<T>,\n  ): asserts this is NodePath<T & { body: t.BlockStatement }>;\n}\n\nexport default NodePath;\n"],"mappings":"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"}

package/lib/path/inference/index.js

@@ -9,11 +9,8 @@ exports.couldBeBaseType = couldBeBaseType;
 exports.getTypeAnnotation = getTypeAnnotation;
 exports.isBaseType = isBaseType;
 exports.isGenericType = isGenericType;
-
 var inferers = require("./inferers");
-
 var _t = require("@babel/types");
-
 const {
   anyTypeAnnotation,
   isAnyTypeAnnotation,
@@ -39,17 +36,13 @@ const {
 
 function getTypeAnnotation() {
   let type = this.getData("typeAnnotation");
-
   if (type != null) {
     return type;
   }
-
   type = this._getTypeAnnotation() || anyTypeAnnotation();
-
   if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {
     type = type.typeAnnotation;
   }
-
   this.setData("typeAnnotation", type);
   return type;
 }
@@ -58,7 +51,6 @@ const typeAnnotationInferringNodes = new WeakSet();
 
 function _getTypeAnnotation() {
   const node = this.node;
-
   if (!node) {
     if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
       const declar = this.parentPath.parentPath;
@@ -71,7 +63,6 @@ function _getTypeAnnotation() {
       if (declar.key === "left" && declarParent.isForOfStatement()) {
         return anyTypeAnnotation();
       }
-
       return voidTypeAnnotation();
     } else {
       return;
@@ -81,24 +72,19 @@ function _getTypeAnnotation() {
   if (node.typeAnnotation) {
     return node.typeAnnotation;
   }
-
   if (typeAnnotationInferringNodes.has(node)) {
     return;
   }
-
   typeAnnotationInferringNodes.add(node);
-
   try {
     var _inferer;
-
-    let inferer = inferers[node.type];
-
+    let inferer =
+    inferers[node.type];
     if (inferer) {
       return inferer.call(this, node);
     }
 
     inferer = inferers[this.parentPath.type];
-
     if ((_inferer = inferer) != null && _inferer.validParent) {
       return this.parentPath.getTypeAnnotation();
     }
@@ -106,11 +92,9 @@ function _getTypeAnnotation() {
     typeAnnotationInferringNodes.delete(node);
   }
 }
-
 function isBaseType(baseName, soft) {
   return _isBaseType(baseName, this.getTypeAnnotation(), soft);
 }
-
 function _isBaseType(baseName, type, soft) {
   if (baseName === "string") {
     return isStringTypeAnnotation(type);
@@ -134,44 +118,35 @@ function _isBaseType(baseName, type, soft) {
     }
   }
 }
-
 function couldBeBaseType(name) {
   const type = this.getTypeAnnotation();
   if (isAnyTypeAnnotation(type)) return true;
-
   if (isUnionTypeAnnotation(type)) {
     for (const type2 of type.types) {
       if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
         return true;
       }
     }
-
     return false;
   } else {
     return _isBaseType(name, type, true);
   }
 }
-
 function baseTypeStrictlyMatches(rightArg) {
   const left = this.getTypeAnnotation();
   const right = rightArg.getTypeAnnotation();
-
   if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {
     return right.type === left.type;
   }
-
   return false;
 }
-
 function isGenericType(genericName) {
   const type = this.getTypeAnnotation();
-
   if (genericName === "Array") {
     if (isTSArrayType(type) || isArrayTypeAnnotation(type) || isTupleTypeAnnotation(type)) {
       return true;
     }
   }
-
   return isGenericTypeAnnotation(type) && isIdentifier(type.id, {
     name: genericName
   }) || isTSTypeReference(type) && isIdentifier(type.typeName, {

package/lib/path/inference/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["anyTypeAnnotation","isAnyTypeAnnotation","isArrayTypeAnnotation","isBooleanTypeAnnotation","isEmptyTypeAnnotation","isFlowBaseAnnotation","isGenericTypeAnnotation","isIdentifier","isMixedTypeAnnotation","isNumberTypeAnnotation","isStringTypeAnnotation","isTSArrayType","isTSTypeAnnotation","isTSTypeReference","isTupleTypeAnnotation","isTypeAnnotation","isUnionTypeAnnotation","isVoidTypeAnnotation","stringTypeAnnotation","voidTypeAnnotation","getTypeAnnotation","type","getData","_getTypeAnnotation","typeAnnotation","setData","typeAnnotationInferringNodes","WeakSet","node","key","parentPath","isVariableDeclarator","declar","declarParent","isForInStatement","isForOfStatement","has","add","inferer","inferers","call","validParent","delete","isBaseType","baseName","soft","_isBaseType","Error","couldBeBaseType","name","type2","types","baseTypeStrictlyMatches","rightArg","left","right","isGenericType","genericName","id","typeName"],"sources":["../../../src/path/inference/index.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport * as inferers from \"./inferers\";\nimport {\n  anyTypeAnnotation,\n  isAnyTypeAnnotation,\n  isArrayTypeAnnotation,\n  isBooleanTypeAnnotation,\n  isEmptyTypeAnnotation,\n  isFlowBaseAnnotation,\n  isGenericTypeAnnotation,\n  isIdentifier,\n  isMixedTypeAnnotation,\n  isNumberTypeAnnotation,\n  isStringTypeAnnotation,\n  isTSArrayType,\n  isTSTypeAnnotation,\n  isTSTypeReference,\n  isTupleTypeAnnotation,\n  isTypeAnnotation,\n  isUnionTypeAnnotation,\n  isVoidTypeAnnotation,\n  stringTypeAnnotation,\n  voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n/**\n * Infer the type of the current `NodePath`.\n */\n\nexport function getTypeAnnotation(this: NodePath): t.FlowType | t.TSType {\n  let type = this.getData(\"typeAnnotation\");\n  if (type != null) {\n    return type;\n  }\n  type = this._getTypeAnnotation() || anyTypeAnnotation();\n  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {\n    type = type.typeAnnotation;\n  }\n  this.setData(\"typeAnnotation\", type);\n  return type;\n}\n\n// Used to avoid infinite recursion in cases like\n//   var b, c; if (0) { c = 1; b = c; } c = b;\n// It also works with indirect recursion.\nconst typeAnnotationInferringNodes = new WeakSet();\n\n/**\n * todo: split up this method\n */\n\nexport function _getTypeAnnotation(this: NodePath): any {\n  const node = this.node;\n\n  if (!node) {\n    // handle initializerless variables, add in checks for loop initializers too\n    if (this.key === \"init\" && this.parentPath.isVariableDeclarator()) {\n      const declar = this.parentPath.parentPath;\n      const declarParent = declar.parentPath;\n\n      // for (let NODE in bar) {}\n      if (declar.key === \"left\" && declarParent.isForInStatement()) {\n        return stringTypeAnnotation();\n      }\n\n      // for (let NODE of bar) {}\n      if (declar.key === \"left\" && declarParent.isForOfStatement()) {\n        return anyTypeAnnotation();\n      }\n\n      return voidTypeAnnotation();\n    } else {\n      return;\n    }\n  }\n\n  // @ts-expect-error typeAnnotation may not index node\n  if (node.typeAnnotation) {\n    // @ts-expect-error typeAnnotation may not index node\n    return node.typeAnnotation;\n  }\n\n  if (typeAnnotationInferringNodes.has(node)) {\n    // Bail out from type inference to avoid infinite loops\n    return;\n  }\n  typeAnnotationInferringNodes.add(node);\n\n  try {\n    let inferer =\n      // @ts-expect-error inferers do not cover all AST types\n      inferers[node.type];\n    if (inferer) {\n      return inferer.call(this, node);\n    }\n\n    // @ts-expect-error inferers do not cover all AST types\n    inferer = inferers[this.parentPath.type];\n    if (inferer?.validParent) {\n      return this.parentPath.getTypeAnnotation();\n    }\n  } finally {\n    typeAnnotationInferringNodes.delete(node);\n  }\n}\n\nexport function isBaseType(\n  this: NodePath,\n  baseName: string,\n  soft?: boolean,\n): boolean {\n  return _isBaseType(baseName, this.getTypeAnnotation(), soft);\n}\n\nfunction _isBaseType(\n  baseName: string,\n  type?: t.FlowType | t.TSType,\n  soft?: boolean,\n): boolean {\n  if (baseName === \"string\") {\n    return isStringTypeAnnotation(type);\n  } else if (baseName === \"number\") {\n    return isNumberTypeAnnotation(type);\n  } else if (baseName === \"boolean\") {\n    return isBooleanTypeAnnotation(type);\n  } else if (baseName === \"any\") {\n    return isAnyTypeAnnotation(type);\n  } else if (baseName === \"mixed\") {\n    return isMixedTypeAnnotation(type);\n  } else if (baseName === \"empty\") {\n    return isEmptyTypeAnnotation(type);\n  } else if (baseName === \"void\") {\n    return isVoidTypeAnnotation(type);\n  } else {\n    if (soft) {\n      return false;\n    } else {\n      throw new Error(`Unknown base type ${baseName}`);\n    }\n  }\n}\n\nexport function couldBeBaseType(this: NodePath, name: string): boolean {\n  const type = this.getTypeAnnotation();\n  if (isAnyTypeAnnotation(type)) return true;\n\n  if (isUnionTypeAnnotation(type)) {\n    for (const type2 of type.types) {\n      if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {\n        return true;\n      }\n    }\n    return false;\n  } else {\n    return _isBaseType(name, type, true);\n  }\n}\n\nexport function baseTypeStrictlyMatches(\n  this: NodePath,\n  rightArg: NodePath,\n): boolean {\n  const left = this.getTypeAnnotation();\n  const right = rightArg.getTypeAnnotation();\n\n  if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {\n    return right.type === left.type;\n  }\n  return false;\n}\n\nexport function isGenericType(this: NodePath, genericName: string): boolean {\n  const type = this.getTypeAnnotation();\n  if (genericName === \"Array\") {\n    // T[]\n    if (\n      isTSArrayType(type) ||\n      isArrayTypeAnnotation(type) ||\n      isTupleTypeAnnotation(type)\n    ) {\n      return true;\n    }\n  }\n  return (\n    (isGenericTypeAnnotation(type) &&\n      isIdentifier(type.id, {\n        name: genericName,\n      })) ||\n    (isTSTypeReference(type) &&\n      isIdentifier(type.typeName, {\n        name: genericName,\n      }))\n  );\n}\n"],"mappings":";;;;;;;;;;;;AACA;;AACA;;;EACEA,iB;EACAC,mB;EACAC,qB;EACAC,uB;EACAC,qB;EACAC,oB;EACAC,uB;EACAC,Y;EACAC,qB;EACAC,sB;EACAC,sB;EACAC,a;EACAC,kB;EACAC,iB;EACAC,qB;EACAC,gB;EACAC,qB;EACAC,oB;EACAC,oB;EACAC;;;AAQK,SAASC,iBAAT,GAAkE;EACvE,IAAIC,IAAI,GAAG,KAAKC,OAAL,CAAa,gBAAb,CAAX;;EACA,IAAID,IAAI,IAAI,IAAZ,EAAkB;IAChB,OAAOA,IAAP;EACD;;EACDA,IAAI,GAAG,KAAKE,kBAAL,MAA6BvB,iBAAiB,EAArD;;EACA,IAAIe,gBAAgB,CAACM,IAAD,CAAhB,IAA0BT,kBAAkB,CAACS,IAAD,CAAhD,EAAwD;IACtDA,IAAI,GAAGA,IAAI,CAACG,cAAZ;EACD;;EACD,KAAKC,OAAL,CAAa,gBAAb,EAA+BJ,IAA/B;EACA,OAAOA,IAAP;AACD;;AAKD,MAAMK,4BAA4B,GAAG,IAAIC,OAAJ,EAArC;;AAMO,SAASJ,kBAAT,GAAiD;EACtD,MAAMK,IAAI,GAAG,KAAKA,IAAlB;;EAEA,IAAI,CAACA,IAAL,EAAW;IAET,IAAI,KAAKC,GAAL,KAAa,MAAb,IAAuB,KAAKC,UAAL,CAAgBC,oBAAhB,EAA3B,EAAmE;MACjE,MAAMC,MAAM,GAAG,KAAKF,UAAL,CAAgBA,UAA/B;MACA,MAAMG,YAAY,GAAGD,MAAM,CAACF,UAA5B;;MAGA,IAAIE,MAAM,CAACH,GAAP,KAAe,MAAf,IAAyBI,YAAY,CAACC,gBAAb,EAA7B,EAA8D;QAC5D,OAAOhB,oBAAoB,EAA3B;MACD;;MAGD,IAAIc,MAAM,CAACH,GAAP,KAAe,MAAf,IAAyBI,YAAY,CAACE,gBAAb,EAA7B,EAA8D;QAC5D,OAAOnC,iBAAiB,EAAxB;MACD;;MAED,OAAOmB,kBAAkB,EAAzB;IACD,CAfD,MAeO;MACL;IACD;EACF;;EAGD,IAAIS,IAAI,CAACJ,cAAT,EAAyB;IAEvB,OAAOI,IAAI,CAACJ,cAAZ;EACD;;EAED,IAAIE,4BAA4B,CAACU,GAA7B,CAAiCR,IAAjC,CAAJ,EAA4C;IAE1C;EACD;;EACDF,4BAA4B,CAACW,GAA7B,CAAiCT,IAAjC;;EAEA,IAAI;IAAA;;IACF,IAAIU,OAAO,GAETC,QAAQ,CAACX,IAAI,CAACP,IAAN,CAFV;;IAGA,IAAIiB,OAAJ,EAAa;MACX,OAAOA,OAAO,CAACE,IAAR,CAAa,IAAb,EAAmBZ,IAAnB,CAAP;IACD;;IAGDU,OAAO,GAAGC,QAAQ,CAAC,KAAKT,UAAL,CAAgBT,IAAjB,CAAlB;;IACA,gBAAIiB,OAAJ,aAAI,SAASG,WAAb,EAA0B;MACxB,OAAO,KAAKX,UAAL,CAAgBV,iBAAhB,EAAP;IACD;EACF,CAbD,SAaU;IACRM,4BAA4B,CAACgB,MAA7B,CAAoCd,IAApC;EACD;AACF;;AAEM,SAASe,UAAT,CAELC,QAFK,EAGLC,IAHK,EAII;EACT,OAAOC,WAAW,CAACF,QAAD,EAAW,KAAKxB,iBAAL,EAAX,EAAqCyB,IAArC,CAAlB;AACD;;AAED,SAASC,WAAT,CACEF,QADF,EAEEvB,IAFF,EAGEwB,IAHF,EAIW;EACT,IAAID,QAAQ,KAAK,QAAjB,EAA2B;IACzB,OAAOlC,sBAAsB,CAACW,IAAD,CAA7B;EACD,CAFD,MAEO,IAAIuB,QAAQ,KAAK,QAAjB,EAA2B;IAChC,OAAOnC,sBAAsB,CAACY,IAAD,CAA7B;EACD,CAFM,MAEA,IAAIuB,QAAQ,KAAK,SAAjB,EAA4B;IACjC,OAAOzC,uBAAuB,CAACkB,IAAD,CAA9B;EACD,CAFM,MAEA,IAAIuB,QAAQ,KAAK,KAAjB,EAAwB;IAC7B,OAAO3C,mBAAmB,CAACoB,IAAD,CAA1B;EACD,CAFM,MAEA,IAAIuB,QAAQ,KAAK,OAAjB,EAA0B;IAC/B,OAAOpC,qBAAqB,CAACa,IAAD,CAA5B;EACD,CAFM,MAEA,IAAIuB,QAAQ,KAAK,OAAjB,EAA0B;IAC/B,OAAOxC,qBAAqB,CAACiB,IAAD,CAA5B;EACD,CAFM,MAEA,IAAIuB,QAAQ,KAAK,MAAjB,EAAyB;IAC9B,OAAO3B,oBAAoB,CAACI,IAAD,CAA3B;EACD,CAFM,MAEA;IACL,IAAIwB,IAAJ,EAAU;MACR,OAAO,KAAP;IACD,CAFD,MAEO;MACL,MAAM,IAAIE,KAAJ,CAAW,qBAAoBH,QAAS,EAAxC,CAAN;IACD;EACF;AACF;;AAEM,SAASI,eAAT,CAAyCC,IAAzC,EAAgE;EACrE,MAAM5B,IAAI,GAAG,KAAKD,iBAAL,EAAb;EACA,IAAInB,mBAAmB,CAACoB,IAAD,CAAvB,EAA+B,OAAO,IAAP;;EAE/B,IAAIL,qBAAqB,CAACK,IAAD,CAAzB,EAAiC;IAC/B,KAAK,MAAM6B,KAAX,IAAoB7B,IAAI,CAAC8B,KAAzB,EAAgC;MAC9B,IAAIlD,mBAAmB,CAACiD,KAAD,CAAnB,IAA8BJ,WAAW,CAACG,IAAD,EAAOC,KAAP,EAAc,IAAd,CAA7C,EAAkE;QAChE,OAAO,IAAP;MACD;IACF;;IACD,OAAO,KAAP;EACD,CAPD,MAOO;IACL,OAAOJ,WAAW,CAACG,IAAD,EAAO5B,IAAP,EAAa,IAAb,CAAlB;EACD;AACF;;AAEM,SAAS+B,uBAAT,CAELC,QAFK,EAGI;EACT,MAAMC,IAAI,GAAG,KAAKlC,iBAAL,EAAb;EACA,MAAMmC,KAAK,GAAGF,QAAQ,CAACjC,iBAAT,EAAd;;EAEA,IAAI,CAACnB,mBAAmB,CAACqD,IAAD,CAApB,IAA8BjD,oBAAoB,CAACiD,IAAD,CAAtD,EAA8D;IAC5D,OAAOC,KAAK,CAAClC,IAAN,KAAeiC,IAAI,CAACjC,IAA3B;EACD;;EACD,OAAO,KAAP;AACD;;AAEM,SAASmC,aAAT,CAAuCC,WAAvC,EAAqE;EAC1E,MAAMpC,IAAI,GAAG,KAAKD,iBAAL,EAAb;;EACA,IAAIqC,WAAW,KAAK,OAApB,EAA6B;IAE3B,IACE9C,aAAa,CAACU,IAAD,CAAb,IACAnB,qBAAqB,CAACmB,IAAD,CADrB,IAEAP,qBAAqB,CAACO,IAAD,CAHvB,EAIE;MACA,OAAO,IAAP;IACD;EACF;;EACD,OACGf,uBAAuB,CAACe,IAAD,CAAvB,IACCd,YAAY,CAACc,IAAI,CAACqC,EAAN,EAAU;IACpBT,IAAI,EAAEQ;EADc,CAAV,CADd,IAIC5C,iBAAiB,CAACQ,IAAD,CAAjB,IACCd,YAAY,CAACc,IAAI,CAACsC,QAAN,EAAgB;IAC1BV,IAAI,EAAEQ;EADoB,CAAhB,CANhB;AAUD"}
+{"version":3,"names":["anyTypeAnnotation","isAnyTypeAnnotation","isArrayTypeAnnotation","isBooleanTypeAnnotation","isEmptyTypeAnnotation","isFlowBaseAnnotation","isGenericTypeAnnotation","isIdentifier","isMixedTypeAnnotation","isNumberTypeAnnotation","isStringTypeAnnotation","isTSArrayType","isTSTypeAnnotation","isTSTypeReference","isTupleTypeAnnotation","isTypeAnnotation","isUnionTypeAnnotation","isVoidTypeAnnotation","stringTypeAnnotation","voidTypeAnnotation","getTypeAnnotation","type","getData","_getTypeAnnotation","typeAnnotation","setData","typeAnnotationInferringNodes","WeakSet","node","key","parentPath","isVariableDeclarator","declar","declarParent","isForInStatement","isForOfStatement","has","add","inferer","inferers","call","validParent","delete","isBaseType","baseName","soft","_isBaseType","Error","couldBeBaseType","name","type2","types","baseTypeStrictlyMatches","rightArg","left","right","isGenericType","genericName","id","typeName"],"sources":["../../../src/path/inference/index.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport * as inferers from \"./inferers\";\nimport {\n  anyTypeAnnotation,\n  isAnyTypeAnnotation,\n  isArrayTypeAnnotation,\n  isBooleanTypeAnnotation,\n  isEmptyTypeAnnotation,\n  isFlowBaseAnnotation,\n  isGenericTypeAnnotation,\n  isIdentifier,\n  isMixedTypeAnnotation,\n  isNumberTypeAnnotation,\n  isStringTypeAnnotation,\n  isTSArrayType,\n  isTSTypeAnnotation,\n  isTSTypeReference,\n  isTupleTypeAnnotation,\n  isTypeAnnotation,\n  isUnionTypeAnnotation,\n  isVoidTypeAnnotation,\n  stringTypeAnnotation,\n  voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\n/**\n * Infer the type of the current `NodePath`.\n */\n\nexport function getTypeAnnotation(this: NodePath): t.FlowType | t.TSType {\n  let type = this.getData(\"typeAnnotation\");\n  if (type != null) {\n    return type;\n  }\n  type = this._getTypeAnnotation() || anyTypeAnnotation();\n  if (isTypeAnnotation(type) || isTSTypeAnnotation(type)) {\n    type = type.typeAnnotation;\n  }\n  this.setData(\"typeAnnotation\", type);\n  return type;\n}\n\n// Used to avoid infinite recursion in cases like\n//   var b, c; if (0) { c = 1; b = c; } c = b;\n// It also works with indirect recursion.\nconst typeAnnotationInferringNodes = new WeakSet();\n\n/**\n * todo: split up this method\n */\n\nexport function _getTypeAnnotation(this: NodePath): any {\n  const node = this.node;\n\n  if (!node) {\n    // handle initializerless variables, add in checks for loop initializers too\n    if (this.key === \"init\" && this.parentPath.isVariableDeclarator()) {\n      const declar = this.parentPath.parentPath;\n      const declarParent = declar.parentPath;\n\n      // for (let NODE in bar) {}\n      if (declar.key === \"left\" && declarParent.isForInStatement()) {\n        return stringTypeAnnotation();\n      }\n\n      // for (let NODE of bar) {}\n      if (declar.key === \"left\" && declarParent.isForOfStatement()) {\n        return anyTypeAnnotation();\n      }\n\n      return voidTypeAnnotation();\n    } else {\n      return;\n    }\n  }\n\n  // @ts-expect-error typeAnnotation may not index node\n  if (node.typeAnnotation) {\n    // @ts-expect-error typeAnnotation may not index node\n    return node.typeAnnotation;\n  }\n\n  if (typeAnnotationInferringNodes.has(node)) {\n    // Bail out from type inference to avoid infinite loops\n    return;\n  }\n  typeAnnotationInferringNodes.add(node);\n\n  try {\n    let inferer =\n      // @ts-expect-error inferers do not cover all AST types\n      inferers[node.type];\n    if (inferer) {\n      return inferer.call(this, node);\n    }\n\n    // @ts-expect-error inferers do not cover all AST types\n    inferer = inferers[this.parentPath.type];\n    if (inferer?.validParent) {\n      return this.parentPath.getTypeAnnotation();\n    }\n  } finally {\n    typeAnnotationInferringNodes.delete(node);\n  }\n}\n\nexport function isBaseType(\n  this: NodePath,\n  baseName: string,\n  soft?: boolean,\n): boolean {\n  return _isBaseType(baseName, this.getTypeAnnotation(), soft);\n}\n\nfunction _isBaseType(\n  baseName: string,\n  type?: t.FlowType | t.TSType,\n  soft?: boolean,\n): boolean {\n  if (baseName === \"string\") {\n    return isStringTypeAnnotation(type);\n  } else if (baseName === \"number\") {\n    return isNumberTypeAnnotation(type);\n  } else if (baseName === \"boolean\") {\n    return isBooleanTypeAnnotation(type);\n  } else if (baseName === \"any\") {\n    return isAnyTypeAnnotation(type);\n  } else if (baseName === \"mixed\") {\n    return isMixedTypeAnnotation(type);\n  } else if (baseName === \"empty\") {\n    return isEmptyTypeAnnotation(type);\n  } else if (baseName === \"void\") {\n    return isVoidTypeAnnotation(type);\n  } else {\n    if (soft) {\n      return false;\n    } else {\n      throw new Error(`Unknown base type ${baseName}`);\n    }\n  }\n}\n\nexport function couldBeBaseType(this: NodePath, name: string): boolean {\n  const type = this.getTypeAnnotation();\n  if (isAnyTypeAnnotation(type)) return true;\n\n  if (isUnionTypeAnnotation(type)) {\n    for (const type2 of type.types) {\n      if (isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {\n        return true;\n      }\n    }\n    return false;\n  } else {\n    return _isBaseType(name, type, true);\n  }\n}\n\nexport function baseTypeStrictlyMatches(\n  this: NodePath,\n  rightArg: NodePath,\n): boolean {\n  const left = this.getTypeAnnotation();\n  const right = rightArg.getTypeAnnotation();\n\n  if (!isAnyTypeAnnotation(left) && isFlowBaseAnnotation(left)) {\n    return right.type === left.type;\n  }\n  return false;\n}\n\nexport function isGenericType(this: NodePath, genericName: string): boolean {\n  const type = this.getTypeAnnotation();\n  if (genericName === \"Array\") {\n    // T[]\n    if (\n      isTSArrayType(type) ||\n      isArrayTypeAnnotation(type) ||\n      isTupleTypeAnnotation(type)\n    ) {\n      return true;\n    }\n  }\n  return (\n    (isGenericTypeAnnotation(type) &&\n      isIdentifier(type.id, {\n        name: genericName,\n      })) ||\n    (isTSTypeReference(type) &&\n      isIdentifier(type.typeName, {\n        name: genericName,\n      }))\n  );\n}\n"],"mappings":"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"}

package/lib/path/inference/inferer-reference.js

@@ -4,22 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
-
 var _t = require("@babel/types");
-
 var _util = require("./util");
-
 const {
   BOOLEAN_NUMBER_BINARY_OPERATORS,
   createTypeAnnotationBasedOnTypeof,
   numberTypeAnnotation,
   voidTypeAnnotation
 } = _t;
-
 function _default(node) {
   if (!this.isReferenced()) return;
-  const binding = this.scope.getBinding(node.name);
 
+  const binding = this.scope.getBinding(node.name);
   if (binding) {
     if (binding.identifier.typeAnnotation) {
       return binding.identifier.typeAnnotation;
@@ -32,55 +28,49 @@ function _default(node) {
     return voidTypeAnnotation();
   } else if (node.name === "NaN" || node.name === "Infinity") {
     return numberTypeAnnotation();
-  } else if (node.name === "arguments") {}
+  } else if (node.name === "arguments") {
+  }
 }
-
 function getTypeAnnotationBindingConstantViolations(binding, path, name) {
   const types = [];
   const functionConstantViolations = [];
   let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations);
   const testType = getConditionalAnnotation(binding, path, name);
-
   if (testType) {
     const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement);
+
     constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0);
+
     types.push(testType.typeAnnotation);
   }
-
   if (constantViolations.length) {
+
     constantViolations.push(...functionConstantViolations);
 
     for (const violation of constantViolations) {
       types.push(violation.getTypeAnnotation());
     }
   }
-
   if (!types.length) {
     return;
   }
-
   return (0, _util.createUnionType)(types);
 }
-
 function getConstantViolationsBefore(binding, path, functions) {
   const violations = binding.constantViolations.slice();
   violations.unshift(binding.path);
   return violations.filter(violation => {
     violation = violation.resolve();
-
     const status = violation._guessExecutionStatusRelativeTo(path);
-
     if (functions && status === "unknown") functions.push(violation);
     return status === "before";
   });
 }
-
 function inferAnnotationFromBinaryExpression(name, path) {
   const operator = path.node.operator;
   const right = path.get("right").resolve();
   const left = path.get("left").resolve();
   let target;
-
   if (left.isIdentifier({
     name
   })) {
@@ -90,23 +80,19 @@ function inferAnnotationFromBinaryExpression(name, path) {
   })) {
     target = left;
   }
-
   if (target) {
     if (operator === "===") {
       return target.getTypeAnnotation();
     }
-
     if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
       return numberTypeAnnotation();
     }
-
     return;
   }
-
   if (operator !== "===" && operator !== "==") return;
+
   let typeofPath;
   let typePath;
-
   if (left.isUnaryExpression({
     operator: "typeof"
   })) {
@@ -118,48 +104,42 @@ function inferAnnotationFromBinaryExpression(name, path) {
     typeofPath = right;
     typePath = left;
   }
-
   if (!typeofPath) return;
   if (!typeofPath.get("argument").isIdentifier({
     name
   })) return;
+
   typePath = typePath.resolve();
   if (!typePath.isLiteral()) return;
+
   const typeValue = typePath.node.value;
   if (typeof typeValue !== "string") return;
+
   return createTypeAnnotationBasedOnTypeof(typeValue);
 }
-
 function getParentConditionalPath(binding, path, name) {
   let parentPath;
-
   while (parentPath = path.parentPath) {
     if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {
       if (path.key === "test") {
         return;
       }
-
       return parentPath;
     }
-
     if (parentPath.isFunction()) {
       if (parentPath.parentPath.scope.getBinding(name) !== binding) return;
     }
-
     path = parentPath;
   }
 }
-
 function getConditionalAnnotation(binding, path, name) {
   const ifStatement = getParentConditionalPath(binding, path, name);
   if (!ifStatement) return;
   const test = ifStatement.get("test");
   const paths = [test];
   const types = [];
-
   for (let i = 0; i < paths.length; i++) {
     const path = paths[i];
-
     if (path.isLogicalExpression()) {
       if (path.node.operator === "&&") {
         paths.push(path.get("left"));
@@ -170,14 +150,12 @@ function getConditionalAnnotation(binding, path, name) {
       if (type) types.push(type);
     }
   }
-
   if (types.length) {
     return {
       typeAnnotation: (0, _util.createUnionType)(types),
       ifStatement
     };
   }
-
   return getConditionalAnnotation(binding, ifStatement, name);
 }