@babel/traverse 7.20.0 → 7.20.5

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

@@ -1 +1 @@
-{"version":3,"names":["BOOLEAN_NUMBER_BINARY_OPERATORS","createTypeAnnotationBasedOnTypeof","numberTypeAnnotation","voidTypeAnnotation","node","isReferenced","binding","scope","getBinding","name","identifier","typeAnnotation","getTypeAnnotationBindingConstantViolations","path","types","functionConstantViolations","constantViolations","getConstantViolationsBefore","testType","getConditionalAnnotation","testConstantViolations","ifStatement","filter","indexOf","push","length","violation","getTypeAnnotation","createUnionType","functions","violations","slice","unshift","resolve","status","_guessExecutionStatusRelativeTo","inferAnnotationFromBinaryExpression","operator","right","get","left","target","isIdentifier","typeofPath","typePath","isUnaryExpression","isLiteral","typeValue","value","getParentConditionalPath","parentPath","isIfStatement","isConditionalExpression","key","isFunction","test","paths","i","isLogicalExpression","isBinaryExpression","type"],"sources":["../../../src/path/inference/inferer-reference.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n  BOOLEAN_NUMBER_BINARY_OPERATORS,\n  createTypeAnnotationBasedOnTypeof,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Binding from \"../../scope/binding\";\n\nimport { createUnionType } from \"./util\";\n\nexport default function (this: NodePath<t.Identifier>, node: t.Identifier) {\n  if (!this.isReferenced()) return;\n\n  // check if a binding exists of this value and if so then return a union type of all\n  // possible types that the binding could be\n  const binding = this.scope.getBinding(node.name);\n  if (binding) {\n    if (binding.identifier.typeAnnotation) {\n      return binding.identifier.typeAnnotation;\n    } else {\n      return getTypeAnnotationBindingConstantViolations(\n        binding,\n        this,\n        node.name,\n      );\n    }\n  }\n\n  // built-in values\n  if (node.name === \"undefined\") {\n    return voidTypeAnnotation();\n  } else if (node.name === \"NaN\" || node.name === \"Infinity\") {\n    return numberTypeAnnotation();\n  } else if (node.name === \"arguments\") {\n    // todo\n  }\n}\n\nfunction getTypeAnnotationBindingConstantViolations(\n  binding: Binding,\n  path: NodePath<t.Identifier>,\n  name: string,\n) {\n  const types = [];\n\n  const functionConstantViolations: NodePath[] = [];\n  let constantViolations = getConstantViolationsBefore(\n    binding,\n    path,\n    functionConstantViolations,\n  );\n\n  const testType = getConditionalAnnotation(binding, path, name);\n  if (testType) {\n    const testConstantViolations = getConstantViolationsBefore(\n      binding,\n      testType.ifStatement,\n    );\n\n    // remove constant violations observed before the IfStatement\n    constantViolations = constantViolations.filter(\n      path => testConstantViolations.indexOf(path) < 0,\n    );\n\n    // clear current types and add in observed test type\n    types.push(testType.typeAnnotation);\n  }\n\n  if (constantViolations.length) {\n    // pick one constant from each scope which will represent the last possible\n    // control flow path that it could've taken/been\n    /* This code is broken for the following problems:\n     * It thinks that assignments can only happen in scopes.\n     * What about conditionals, if statements without block,\n     * or guarded assignments.\n     * It also checks to see if one of the assignments is in the\n     * same scope and uses that as the only \"violation\". However,\n     * the binding is returned by `getConstantViolationsBefore` so we for\n     * sure always going to return that as the only \"violation\".\n    let rawConstantViolations = constantViolations.reverse();\n    let visitedScopes = [];\n    constantViolations = [];\n    for (let violation of (rawConstantViolations: Array<NodePath>)) {\n      let violationScope = violation.scope;\n      if (visitedScopes.indexOf(violationScope) >= 0) continue;\n\n      visitedScopes.push(violationScope);\n      constantViolations.push(violation);\n\n      if (violationScope === path.scope) {\n        constantViolations = [violation];\n        break;\n      }\n    }*/\n\n    // add back on function constant violations since we can't track calls\n    constantViolations.push(...functionConstantViolations);\n\n    // push on inferred types of violated paths\n    for (const violation of constantViolations) {\n      types.push(violation.getTypeAnnotation());\n    }\n  }\n\n  if (!types.length) {\n    return;\n  }\n\n  return createUnionType(types);\n}\n\nfunction getConstantViolationsBefore(\n  binding: Binding,\n  path: NodePath,\n  functions?: NodePath[],\n) {\n  const violations = binding.constantViolations.slice();\n  violations.unshift(binding.path);\n  return violations.filter(violation => {\n    violation = violation.resolve();\n    const status = violation._guessExecutionStatusRelativeTo(path);\n    if (functions && status === \"unknown\") functions.push(violation);\n    return status === \"before\";\n  });\n}\n\nfunction inferAnnotationFromBinaryExpression(\n  name: string,\n  path: NodePath<t.BinaryExpression>,\n) {\n  const operator = path.node.operator;\n\n  const right = path.get(\"right\").resolve();\n  const left = path.get(\"left\").resolve();\n\n  let target;\n  if (left.isIdentifier({ name })) {\n    target = right;\n  } else if (right.isIdentifier({ name })) {\n    target = left;\n  }\n\n  if (target) {\n    if (operator === \"===\") {\n      return target.getTypeAnnotation();\n    }\n    if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n      return numberTypeAnnotation();\n    }\n\n    return;\n  }\n\n  if (operator !== \"===\" && operator !== \"==\") return;\n\n  //\n  let typeofPath: NodePath<t.UnaryExpression>;\n  let typePath: NodePath<t.Expression>;\n  if (left.isUnaryExpression({ operator: \"typeof\" })) {\n    typeofPath = left;\n    typePath = right as NodePath<t.Expression>;\n  } else if (right.isUnaryExpression({ operator: \"typeof\" })) {\n    typeofPath = right;\n    typePath = left as NodePath<t.Expression>;\n  }\n\n  if (!typeofPath) return;\n  // and that the argument of the typeof path references us!\n  if (!typeofPath.get(\"argument\").isIdentifier({ name })) return;\n\n  // ensure that the type path is a Literal\n  typePath = typePath.resolve() as NodePath<t.Expression>;\n  if (!typePath.isLiteral()) return;\n\n  // and that it's a string so we can infer it\n  // @ts-expect-error todo(flow->ts): value is not defined for NullLiteral and some other\n  const typeValue = typePath.node.value;\n  if (typeof typeValue !== \"string\") return;\n\n  // turn type value into a type annotation\n  // @ts-expect-error todo(flow->ts): move validation from helper or relax type constraint to just a string\n  return createTypeAnnotationBasedOnTypeof(typeValue);\n}\n\nfunction getParentConditionalPath(\n  binding: Binding,\n  path: NodePath,\n  name: string,\n) {\n  let parentPath;\n  while ((parentPath = path.parentPath)) {\n    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {\n      if (path.key === \"test\") {\n        return;\n      }\n\n      return parentPath as NodePath<t.IfStatement | t.ConditionalExpression>;\n    }\n    if (parentPath.isFunction()) {\n      if (parentPath.parentPath.scope.getBinding(name) !== binding) return;\n    }\n\n    path = parentPath;\n  }\n}\n\nfunction getConditionalAnnotation<T extends t.Node>(\n  binding: Binding,\n  path: NodePath<T>,\n  name?: string,\n): {\n  typeAnnotation: t.FlowType | t.TSType;\n  ifStatement: NodePath<t.IfStatement | t.ConditionalExpression>;\n} {\n  const ifStatement = getParentConditionalPath(binding, path, name);\n  if (!ifStatement) return;\n\n  const test = ifStatement.get(\"test\");\n  const paths = [test];\n  const types = [];\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i];\n\n    if (path.isLogicalExpression()) {\n      if (path.node.operator === \"&&\") {\n        paths.push(path.get(\"left\"));\n        paths.push(path.get(\"right\"));\n      }\n    } else if (path.isBinaryExpression()) {\n      const type = inferAnnotationFromBinaryExpression(name, path);\n      if (type) types.push(type);\n    }\n  }\n\n  if (types.length) {\n    return {\n      typeAnnotation: createUnionType(types),\n      ifStatement,\n    };\n  }\n\n  return getConditionalAnnotation(binding, ifStatement, name);\n}\n"],"mappings":"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"}
+{"version":3,"names":["BOOLEAN_NUMBER_BINARY_OPERATORS","createTypeAnnotationBasedOnTypeof","numberTypeAnnotation","voidTypeAnnotation","node","isReferenced","binding","scope","getBinding","name","identifier","typeAnnotation","getTypeAnnotationBindingConstantViolations","path","types","functionConstantViolations","constantViolations","getConstantViolationsBefore","testType","getConditionalAnnotation","testConstantViolations","ifStatement","filter","indexOf","push","length","violation","getTypeAnnotation","createUnionType","functions","violations","slice","unshift","resolve","status","_guessExecutionStatusRelativeTo","inferAnnotationFromBinaryExpression","operator","right","get","left","target","isIdentifier","typeofPath","typePath","isUnaryExpression","isLiteral","typeValue","value","getParentConditionalPath","parentPath","isIfStatement","isConditionalExpression","key","isFunction","test","paths","i","isLogicalExpression","isBinaryExpression","type"],"sources":["../../../src/path/inference/inferer-reference.ts"],"sourcesContent":["import type NodePath from \"../index\";\nimport {\n  BOOLEAN_NUMBER_BINARY_OPERATORS,\n  createTypeAnnotationBasedOnTypeof,\n  numberTypeAnnotation,\n  voidTypeAnnotation,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\nimport type Binding from \"../../scope/binding\";\n\nimport { createUnionType } from \"./util\";\n\nexport default function (this: NodePath<t.Identifier>, node: t.Identifier) {\n  if (!this.isReferenced()) return;\n\n  // check if a binding exists of this value and if so then return a union type of all\n  // possible types that the binding could be\n  const binding = this.scope.getBinding(node.name);\n  if (binding) {\n    if (binding.identifier.typeAnnotation) {\n      return binding.identifier.typeAnnotation;\n    } else {\n      return getTypeAnnotationBindingConstantViolations(\n        binding,\n        this,\n        node.name,\n      );\n    }\n  }\n\n  // built-in values\n  if (node.name === \"undefined\") {\n    return voidTypeAnnotation();\n  } else if (node.name === \"NaN\" || node.name === \"Infinity\") {\n    return numberTypeAnnotation();\n  } else if (node.name === \"arguments\") {\n    // todo\n  }\n}\n\nfunction getTypeAnnotationBindingConstantViolations(\n  binding: Binding,\n  path: NodePath<t.Identifier>,\n  name: string,\n) {\n  const types = [];\n\n  const functionConstantViolations: NodePath[] = [];\n  let constantViolations = getConstantViolationsBefore(\n    binding,\n    path,\n    functionConstantViolations,\n  );\n\n  const testType = getConditionalAnnotation(binding, path, name);\n  if (testType) {\n    const testConstantViolations = getConstantViolationsBefore(\n      binding,\n      testType.ifStatement,\n    );\n\n    // remove constant violations observed before the IfStatement\n    constantViolations = constantViolations.filter(\n      path => testConstantViolations.indexOf(path) < 0,\n    );\n\n    // clear current types and add in observed test type\n    types.push(testType.typeAnnotation);\n  }\n\n  if (constantViolations.length) {\n    // pick one constant from each scope which will represent the last possible\n    // control flow path that it could've taken/been\n    /* This code is broken for the following problems:\n     * It thinks that assignments can only happen in scopes.\n     * What about conditionals, if statements without block,\n     * or guarded assignments.\n     * It also checks to see if one of the assignments is in the\n     * same scope and uses that as the only \"violation\". However,\n     * the binding is returned by `getConstantViolationsBefore` so we for\n     * sure always going to return that as the only \"violation\".\n    let rawConstantViolations = constantViolations.reverse();\n    let visitedScopes = [];\n    constantViolations = [];\n    for (let violation of (rawConstantViolations: Array<NodePath>)) {\n      let violationScope = violation.scope;\n      if (visitedScopes.indexOf(violationScope) >= 0) continue;\n\n      visitedScopes.push(violationScope);\n      constantViolations.push(violation);\n\n      if (violationScope === path.scope) {\n        constantViolations = [violation];\n        break;\n      }\n    }*/\n\n    // add back on function constant violations since we can't track calls\n    constantViolations.push(...functionConstantViolations);\n\n    // push on inferred types of violated paths\n    for (const violation of constantViolations) {\n      types.push(violation.getTypeAnnotation());\n    }\n  }\n\n  if (!types.length) {\n    return;\n  }\n\n  return createUnionType(types);\n}\n\nfunction getConstantViolationsBefore(\n  binding: Binding,\n  path: NodePath,\n  functions?: NodePath[],\n) {\n  const violations = binding.constantViolations.slice();\n  violations.unshift(binding.path);\n  return violations.filter(violation => {\n    violation = violation.resolve();\n    const status = violation._guessExecutionStatusRelativeTo(path);\n    if (functions && status === \"unknown\") functions.push(violation);\n    return status === \"before\";\n  });\n}\n\nfunction inferAnnotationFromBinaryExpression(\n  name: string,\n  path: NodePath<t.BinaryExpression>,\n) {\n  const operator = path.node.operator;\n\n  const right = path.get(\"right\").resolve();\n  const left = path.get(\"left\").resolve();\n\n  let target;\n  if (left.isIdentifier({ name })) {\n    target = right;\n  } else if (right.isIdentifier({ name })) {\n    target = left;\n  }\n\n  if (target) {\n    if (operator === \"===\") {\n      return target.getTypeAnnotation();\n    }\n    if (BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n      return numberTypeAnnotation();\n    }\n\n    return;\n  }\n\n  if (operator !== \"===\" && operator !== \"==\") return;\n\n  //\n  let typeofPath: NodePath<t.UnaryExpression>;\n  let typePath: NodePath<t.Expression>;\n  if (left.isUnaryExpression({ operator: \"typeof\" })) {\n    typeofPath = left;\n    typePath = right as NodePath<t.Expression>;\n  } else if (right.isUnaryExpression({ operator: \"typeof\" })) {\n    typeofPath = right;\n    typePath = left as NodePath<t.Expression>;\n  }\n\n  if (!typeofPath) return;\n  // and that the argument of the typeof path references us!\n  if (!typeofPath.get(\"argument\").isIdentifier({ name })) return;\n\n  // ensure that the type path is a Literal\n  typePath = typePath.resolve() as NodePath<t.Expression>;\n  if (!typePath.isLiteral()) return;\n\n  // and that it's a string so we can infer it\n  // @ts-expect-error todo(flow->ts): value is not defined for NullLiteral and some other\n  const typeValue = typePath.node.value;\n  if (typeof typeValue !== \"string\") return;\n\n  // turn type value into a type annotation\n  // @ts-expect-error todo(flow->ts): move validation from helper or relax type constraint to just a string\n  return createTypeAnnotationBasedOnTypeof(typeValue);\n}\n\nfunction getParentConditionalPath(\n  binding: Binding,\n  path: NodePath,\n  name: string,\n) {\n  let parentPath;\n  while ((parentPath = path.parentPath)) {\n    if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) {\n      if (path.key === \"test\") {\n        return;\n      }\n\n      return parentPath as NodePath<t.IfStatement | t.ConditionalExpression>;\n    }\n    if (parentPath.isFunction()) {\n      if (parentPath.parentPath.scope.getBinding(name) !== binding) return;\n    }\n\n    path = parentPath;\n  }\n}\n\nfunction getConditionalAnnotation<T extends t.Node>(\n  binding: Binding,\n  path: NodePath<T>,\n  name?: string,\n): {\n  typeAnnotation: t.FlowType | t.TSType;\n  ifStatement: NodePath<t.IfStatement | t.ConditionalExpression>;\n} {\n  const ifStatement = getParentConditionalPath(binding, path, name);\n  if (!ifStatement) return;\n\n  const test = ifStatement.get(\"test\");\n  const paths = [test];\n  const types = [];\n\n  for (let i = 0; i < paths.length; i++) {\n    const path = paths[i];\n\n    if (path.isLogicalExpression()) {\n      if (path.node.operator === \"&&\") {\n        paths.push(path.get(\"left\"));\n        paths.push(path.get(\"right\"));\n      }\n    } else if (path.isBinaryExpression()) {\n      const type = inferAnnotationFromBinaryExpression(name, path);\n      if (type) types.push(type);\n    }\n  }\n\n  if (types.length) {\n    return {\n      typeAnnotation: createUnionType(types),\n      ifStatement,\n    };\n  }\n\n  return getConditionalAnnotation(binding, ifStatement, name);\n}\n"],"mappings":"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"}

package/lib/path/inference/inferers.js

@@ -34,13 +34,9 @@ exports.TypeCastExpression = TypeCastExpression;
 exports.UnaryExpression = UnaryExpression;
 exports.UpdateExpression = UpdateExpression;
 exports.VariableDeclarator = VariableDeclarator;
-
 var _t = require("@babel/types");
-
 var _infererReference = require("./inferer-reference");
-
 var _util = require("./util");
-
 const {
   BOOLEAN_BINARY_OPERATORS,
   BOOLEAN_UNARY_OPERATORS,
@@ -61,41 +57,31 @@ const {
   voidTypeAnnotation,
   isIdentifier
 } = _t;
-
 function VariableDeclarator() {
   if (!this.get("id").isIdentifier()) return;
   return this.get("init").getTypeAnnotation();
 }
-
 function TypeCastExpression(node) {
   return node.typeAnnotation;
 }
-
 TypeCastExpression.validParent = true;
-
 function TSAsExpression(node) {
   return node.typeAnnotation;
 }
-
 TSAsExpression.validParent = true;
-
 function TSNonNullExpression() {
   return this.get("expression").getTypeAnnotation();
 }
-
 function NewExpression(node) {
   if (node.callee.type === "Identifier") {
     return genericTypeAnnotation(node.callee);
   }
 }
-
 function TemplateLiteral() {
   return stringTypeAnnotation();
 }
-
 function UnaryExpression(node) {
   const operator = node.operator;
-
   if (operator === "void") {
     return voidTypeAnnotation();
   } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {
@@ -106,10 +92,8 @@ function UnaryExpression(node) {
     return booleanTypeAnnotation();
   }
 }
-
 function BinaryExpression(node) {
   const operator = node.operator;
-
   if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {
     return numberTypeAnnotation();
   } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {
@@ -117,7 +101,6 @@ function BinaryExpression(node) {
   } else if (operator === "+") {
     const right = this.get("right");
     const left = this.get("left");
-
     if (left.isBaseType("number") && right.isBaseType("number")) {
       return numberTypeAnnotation();
     } else if (left.isBaseType("string") || right.isBaseType("string")) {
@@ -127,110 +110,86 @@ function BinaryExpression(node) {
     return unionTypeAnnotation([stringTypeAnnotation(), numberTypeAnnotation()]);
   }
 }
-
 function LogicalExpression() {
   const argumentTypes = [this.get("left").getTypeAnnotation(), this.get("right").getTypeAnnotation()];
   return (0, _util.createUnionType)(argumentTypes);
 }
-
 function ConditionalExpression() {
   const argumentTypes = [this.get("consequent").getTypeAnnotation(), this.get("alternate").getTypeAnnotation()];
   return (0, _util.createUnionType)(argumentTypes);
 }
-
 function SequenceExpression() {
   return this.get("expressions").pop().getTypeAnnotation();
 }
-
 function ParenthesizedExpression() {
   return this.get("expression").getTypeAnnotation();
 }
-
 function AssignmentExpression() {
   return this.get("right").getTypeAnnotation();
 }
-
 function UpdateExpression(node) {
   const operator = node.operator;
-
   if (operator === "++" || operator === "--") {
     return numberTypeAnnotation();
   }
 }
-
 function StringLiteral() {
   return stringTypeAnnotation();
 }
-
 function NumericLiteral() {
   return numberTypeAnnotation();
 }
-
 function BooleanLiteral() {
   return booleanTypeAnnotation();
 }
-
 function NullLiteral() {
   return nullLiteralTypeAnnotation();
 }
-
 function RegExpLiteral() {
   return genericTypeAnnotation(identifier("RegExp"));
 }
-
 function ObjectExpression() {
   return genericTypeAnnotation(identifier("Object"));
 }
-
 function ArrayExpression() {
   return genericTypeAnnotation(identifier("Array"));
 }
-
 function RestElement() {
   return ArrayExpression();
 }
-
 RestElement.validParent = true;
-
 function Func() {
   return genericTypeAnnotation(identifier("Function"));
 }
-
 const isArrayFrom = buildMatchMemberExpression("Array.from");
 const isObjectKeys = buildMatchMemberExpression("Object.keys");
 const isObjectValues = buildMatchMemberExpression("Object.values");
 const isObjectEntries = buildMatchMemberExpression("Object.entries");
-
 function CallExpression() {
   const {
     callee
   } = this.node;
-
   if (isObjectKeys(callee)) {
     return arrayTypeAnnotation(stringTypeAnnotation());
-  } else if (isArrayFrom(callee) || isObjectValues(callee) || isIdentifier(callee, {
+  } else if (isArrayFrom(callee) || isObjectValues(callee) ||
+  isIdentifier(callee, {
     name: "Array"
   })) {
     return arrayTypeAnnotation(anyTypeAnnotation());
   } else if (isObjectEntries(callee)) {
     return arrayTypeAnnotation(tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]));
   }
-
   return resolveCall(this.get("callee"));
 }
-
 function TaggedTemplateExpression() {
   return resolveCall(this.get("tag"));
 }
-
 function resolveCall(callee) {
   callee = callee.resolve();
-
   if (callee.isFunction()) {
     const {
       node
     } = callee;
-
     if (node.async) {
       if (node.generator) {
         return genericTypeAnnotation(identifier("AsyncIterator"));
@@ -242,7 +201,8 @@ function resolveCall(callee) {
         return genericTypeAnnotation(identifier("Iterator"));
       } else if (callee.node.returnType) {
         return callee.node.returnType;
-      } else {}
+      } else {
+      }
     }
   }
 }

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

@@ -1 +1 @@
-{"version":3,"names":["BOOLEAN_BINARY_OPERATORS","BOOLEAN_UNARY_OPERATORS","NUMBER_BINARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","anyTypeAnnotation","arrayTypeAnnotation","booleanTypeAnnotation","buildMatchMemberExpression","genericTypeAnnotation","identifier","nullLiteralTypeAnnotation","numberTypeAnnotation","stringTypeAnnotation","tupleTypeAnnotation","unionTypeAnnotation","voidTypeAnnotation","isIdentifier","VariableDeclarator","get","getTypeAnnotation","TypeCastExpression","node","typeAnnotation","validParent","TSAsExpression","TSNonNullExpression","NewExpression","callee","type","TemplateLiteral","UnaryExpression","operator","indexOf","BinaryExpression","right","left","isBaseType","LogicalExpression","argumentTypes","createUnionType","ConditionalExpression","SequenceExpression","pop","ParenthesizedExpression","AssignmentExpression","UpdateExpression","StringLiteral","NumericLiteral","BooleanLiteral","NullLiteral","RegExpLiteral","ObjectExpression","ArrayExpression","RestElement","Func","isArrayFrom","isObjectKeys","isObjectValues","isObjectEntries","CallExpression","name","resolveCall","TaggedTemplateExpression","resolve","isFunction","async","generator","returnType"],"sources":["../../../src/path/inference/inferers.ts"],"sourcesContent":["import {\n  BOOLEAN_BINARY_OPERATORS,\n  BOOLEAN_UNARY_OPERATORS,\n  NUMBER_BINARY_OPERATORS,\n  NUMBER_UNARY_OPERATORS,\n  STRING_UNARY_OPERATORS,\n  anyTypeAnnotation,\n  arrayTypeAnnotation,\n  booleanTypeAnnotation,\n  buildMatchMemberExpression,\n  genericTypeAnnotation,\n  identifier,\n  nullLiteralTypeAnnotation,\n  numberTypeAnnotation,\n  stringTypeAnnotation,\n  tupleTypeAnnotation,\n  unionTypeAnnotation,\n  voidTypeAnnotation,\n  isIdentifier,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport { default as Identifier } from \"./inferer-reference\";\n\nimport { createUnionType } from \"./util\";\nimport type NodePath from \"..\";\n\nexport function VariableDeclarator(this: NodePath<t.VariableDeclarator>) {\n  if (!this.get(\"id\").isIdentifier()) return;\n  return this.get(\"init\").getTypeAnnotation();\n}\n\nexport function TypeCastExpression(node: t.TypeCastExpression) {\n  return node.typeAnnotation;\n}\n\nTypeCastExpression.validParent = true;\n\nexport function TSAsExpression(node: t.TSAsExpression) {\n  return node.typeAnnotation;\n}\n\nTSAsExpression.validParent = true;\n\nexport function TSNonNullExpression(this: NodePath<t.TSNonNullExpression>) {\n  return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function NewExpression(\n  this: NodePath<t.NewExpression>,\n  node: t.NewExpression,\n) {\n  if (node.callee.type === \"Identifier\") {\n    // only resolve identifier callee\n    return genericTypeAnnotation(node.callee);\n  }\n}\n\nexport function TemplateLiteral() {\n  return stringTypeAnnotation();\n}\n\nexport function UnaryExpression(node: t.UnaryExpression) {\n  const operator = node.operator;\n\n  if (operator === \"void\") {\n    return voidTypeAnnotation();\n  } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return numberTypeAnnotation();\n  } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return stringTypeAnnotation();\n  } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return booleanTypeAnnotation();\n  }\n}\n\nexport function BinaryExpression(\n  this: NodePath<t.BinaryExpression>,\n  node: t.BinaryExpression,\n) {\n  const operator = node.operator;\n\n  if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n    return numberTypeAnnotation();\n  } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {\n    return booleanTypeAnnotation();\n  } else if (operator === \"+\") {\n    const right = this.get(\"right\");\n    const left = this.get(\"left\");\n\n    if (left.isBaseType(\"number\") && right.isBaseType(\"number\")) {\n      // both numbers so this will be a number\n      return numberTypeAnnotation();\n    } else if (left.isBaseType(\"string\") || right.isBaseType(\"string\")) {\n      // one is a string so the result will be a string\n      return stringTypeAnnotation();\n    }\n\n    // unsure if left and right are strings or numbers so stay on the safe side\n    return unionTypeAnnotation([\n      stringTypeAnnotation(),\n      numberTypeAnnotation(),\n    ]);\n  }\n}\n\nexport function LogicalExpression(this: NodePath<t.LogicalExpression>) {\n  const argumentTypes = [\n    this.get(\"left\").getTypeAnnotation(),\n    this.get(\"right\").getTypeAnnotation(),\n  ];\n\n  return createUnionType(argumentTypes);\n}\n\nexport function ConditionalExpression(this: NodePath<t.ConditionalExpression>) {\n  const argumentTypes = [\n    this.get(\"consequent\").getTypeAnnotation(),\n    this.get(\"alternate\").getTypeAnnotation(),\n  ];\n\n  return createUnionType(argumentTypes);\n}\n\nexport function SequenceExpression(this: NodePath<t.SequenceExpression>) {\n  return this.get(\"expressions\").pop().getTypeAnnotation();\n}\n\nexport function ParenthesizedExpression(\n  this: NodePath<t.ParenthesizedExpression>,\n) {\n  return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function AssignmentExpression(this: NodePath<t.AssignmentExpression>) {\n  return this.get(\"right\").getTypeAnnotation();\n}\n\nexport function UpdateExpression(\n  this: NodePath<t.UpdateExpression>,\n  node: t.UpdateExpression,\n) {\n  const operator = node.operator;\n  if (operator === \"++\" || operator === \"--\") {\n    return numberTypeAnnotation();\n  }\n}\n\nexport function StringLiteral() {\n  return stringTypeAnnotation();\n}\n\nexport function NumericLiteral() {\n  return numberTypeAnnotation();\n}\n\nexport function BooleanLiteral() {\n  return booleanTypeAnnotation();\n}\n\nexport function NullLiteral() {\n  return nullLiteralTypeAnnotation();\n}\n\nexport function RegExpLiteral() {\n  return genericTypeAnnotation(identifier(\"RegExp\"));\n}\n\nexport function ObjectExpression() {\n  return genericTypeAnnotation(identifier(\"Object\"));\n}\n\nexport function ArrayExpression() {\n  return genericTypeAnnotation(identifier(\"Array\"));\n}\n\nexport function RestElement() {\n  return ArrayExpression();\n}\n\nRestElement.validParent = true;\n\nfunction Func() {\n  return genericTypeAnnotation(identifier(\"Function\"));\n}\n\nexport {\n  Func as FunctionExpression,\n  Func as ArrowFunctionExpression,\n  Func as FunctionDeclaration,\n  Func as ClassExpression,\n  Func as ClassDeclaration,\n};\n\nconst isArrayFrom = buildMatchMemberExpression(\"Array.from\");\nconst isObjectKeys = buildMatchMemberExpression(\"Object.keys\");\nconst isObjectValues = buildMatchMemberExpression(\"Object.values\");\nconst isObjectEntries = buildMatchMemberExpression(\"Object.entries\");\nexport function CallExpression(this: NodePath<t.CallExpression>) {\n  const { callee } = this.node;\n  if (isObjectKeys(callee)) {\n    return arrayTypeAnnotation(stringTypeAnnotation());\n  } else if (\n    isArrayFrom(callee) ||\n    isObjectValues(callee) ||\n    // Detect \"var foo = Array()\" calls so we can optimize for arrays vs iterables.\n    isIdentifier(callee, { name: \"Array\" })\n  ) {\n    return arrayTypeAnnotation(anyTypeAnnotation());\n  } else if (isObjectEntries(callee)) {\n    return arrayTypeAnnotation(\n      tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]),\n    );\n  }\n\n  return resolveCall(this.get(\"callee\"));\n}\n\nexport function TaggedTemplateExpression(\n  this: NodePath<t.TaggedTemplateExpression>,\n) {\n  return resolveCall(this.get(\"tag\"));\n}\n\nfunction resolveCall(callee: NodePath) {\n  callee = callee.resolve();\n\n  if (callee.isFunction()) {\n    const { node } = callee;\n    if (node.async) {\n      if (node.generator) {\n        return genericTypeAnnotation(identifier(\"AsyncIterator\"));\n      } else {\n        return genericTypeAnnotation(identifier(\"Promise\"));\n      }\n    } else {\n      if (node.generator) {\n        return genericTypeAnnotation(identifier(\"Iterator\"));\n      } else if (callee.node.returnType) {\n        return callee.node.returnType;\n      } else {\n        // todo: get union type of all return arguments\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAsBA;;AAEA;;;EAvBEA,wB;EACAC,uB;EACAC,uB;EACAC,sB;EACAC,sB;EACAC,iB;EACAC,mB;EACAC,qB;EACAC,0B;EACAC,qB;EACAC,U;EACAC,yB;EACAC,oB;EACAC,oB;EACAC,mB;EACAC,mB;EACAC,kB;EACAC;;;AASK,SAASC,kBAAT,GAAkE;EACvE,IAAI,CAAC,KAAKC,GAAL,CAAS,IAAT,EAAeF,YAAf,EAAL,EAAoC;EACpC,OAAO,KAAKE,GAAL,CAAS,MAAT,EAAiBC,iBAAjB,EAAP;AACD;;AAEM,SAASC,kBAAT,CAA4BC,IAA5B,EAAwD;EAC7D,OAAOA,IAAI,CAACC,cAAZ;AACD;;AAEDF,kBAAkB,CAACG,WAAnB,GAAiC,IAAjC;;AAEO,SAASC,cAAT,CAAwBH,IAAxB,EAAgD;EACrD,OAAOA,IAAI,CAACC,cAAZ;AACD;;AAEDE,cAAc,CAACD,WAAf,GAA6B,IAA7B;;AAEO,SAASE,mBAAT,GAAoE;EACzE,OAAO,KAAKP,GAAL,CAAS,YAAT,EAAuBC,iBAAvB,EAAP;AACD;;AAEM,SAASO,aAAT,CAELL,IAFK,EAGL;EACA,IAAIA,IAAI,CAACM,MAAL,CAAYC,IAAZ,KAAqB,YAAzB,EAAuC;IAErC,OAAOpB,qBAAqB,CAACa,IAAI,CAACM,MAAN,CAA5B;EACD;AACF;;AAEM,SAASE,eAAT,GAA2B;EAChC,OAAOjB,oBAAoB,EAA3B;AACD;;AAEM,SAASkB,eAAT,CAAyBT,IAAzB,EAAkD;EACvD,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAtB;;EAEA,IAAIA,QAAQ,KAAK,MAAjB,EAAyB;IACvB,OAAOhB,kBAAkB,EAAzB;EACD,CAFD,MAEO,IAAIb,sBAAsB,CAAC8B,OAAvB,CAA+BD,QAA/B,KAA4C,CAAhD,EAAmD;IACxD,OAAOpB,oBAAoB,EAA3B;EACD,CAFM,MAEA,IAAIR,sBAAsB,CAAC6B,OAAvB,CAA+BD,QAA/B,KAA4C,CAAhD,EAAmD;IACxD,OAAOnB,oBAAoB,EAA3B;EACD,CAFM,MAEA,IAAIZ,uBAAuB,CAACgC,OAAxB,CAAgCD,QAAhC,KAA6C,CAAjD,EAAoD;IACzD,OAAOzB,qBAAqB,EAA5B;EACD;AACF;;AAEM,SAAS2B,gBAAT,CAELZ,IAFK,EAGL;EACA,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAtB;;EAEA,IAAI9B,uBAAuB,CAAC+B,OAAxB,CAAgCD,QAAhC,KAA6C,CAAjD,EAAoD;IAClD,OAAOpB,oBAAoB,EAA3B;EACD,CAFD,MAEO,IAAIZ,wBAAwB,CAACiC,OAAzB,CAAiCD,QAAjC,KAA8C,CAAlD,EAAqD;IAC1D,OAAOzB,qBAAqB,EAA5B;EACD,CAFM,MAEA,IAAIyB,QAAQ,KAAK,GAAjB,EAAsB;IAC3B,MAAMG,KAAK,GAAG,KAAKhB,GAAL,CAAS,OAAT,CAAd;IACA,MAAMiB,IAAI,GAAG,KAAKjB,GAAL,CAAS,MAAT,CAAb;;IAEA,IAAIiB,IAAI,CAACC,UAAL,CAAgB,QAAhB,KAA6BF,KAAK,CAACE,UAAN,CAAiB,QAAjB,CAAjC,EAA6D;MAE3D,OAAOzB,oBAAoB,EAA3B;IACD,CAHD,MAGO,IAAIwB,IAAI,CAACC,UAAL,CAAgB,QAAhB,KAA6BF,KAAK,CAACE,UAAN,CAAiB,QAAjB,CAAjC,EAA6D;MAElE,OAAOxB,oBAAoB,EAA3B;IACD;;IAGD,OAAOE,mBAAmB,CAAC,CACzBF,oBAAoB,EADK,EAEzBD,oBAAoB,EAFK,CAAD,CAA1B;EAID;AACF;;AAEM,SAAS0B,iBAAT,GAAgE;EACrE,MAAMC,aAAa,GAAG,CACpB,KAAKpB,GAAL,CAAS,MAAT,EAAiBC,iBAAjB,EADoB,EAEpB,KAAKD,GAAL,CAAS,OAAT,EAAkBC,iBAAlB,EAFoB,CAAtB;EAKA,OAAO,IAAAoB,qBAAA,EAAgBD,aAAhB,CAAP;AACD;;AAEM,SAASE,qBAAT,GAAwE;EAC7E,MAAMF,aAAa,GAAG,CACpB,KAAKpB,GAAL,CAAS,YAAT,EAAuBC,iBAAvB,EADoB,EAEpB,KAAKD,GAAL,CAAS,WAAT,EAAsBC,iBAAtB,EAFoB,CAAtB;EAKA,OAAO,IAAAoB,qBAAA,EAAgBD,aAAhB,CAAP;AACD;;AAEM,SAASG,kBAAT,GAAkE;EACvE,OAAO,KAAKvB,GAAL,CAAS,aAAT,EAAwBwB,GAAxB,GAA8BvB,iBAA9B,EAAP;AACD;;AAEM,SAASwB,uBAAT,GAEL;EACA,OAAO,KAAKzB,GAAL,CAAS,YAAT,EAAuBC,iBAAvB,EAAP;AACD;;AAEM,SAASyB,oBAAT,GAAsE;EAC3E,OAAO,KAAK1B,GAAL,CAAS,OAAT,EAAkBC,iBAAlB,EAAP;AACD;;AAEM,SAAS0B,gBAAT,CAELxB,IAFK,EAGL;EACA,MAAMU,QAAQ,GAAGV,IAAI,CAACU,QAAtB;;EACA,IAAIA,QAAQ,KAAK,IAAb,IAAqBA,QAAQ,KAAK,IAAtC,EAA4C;IAC1C,OAAOpB,oBAAoB,EAA3B;EACD;AACF;;AAEM,SAASmC,aAAT,GAAyB;EAC9B,OAAOlC,oBAAoB,EAA3B;AACD;;AAEM,SAASmC,cAAT,GAA0B;EAC/B,OAAOpC,oBAAoB,EAA3B;AACD;;AAEM,SAASqC,cAAT,GAA0B;EAC/B,OAAO1C,qBAAqB,EAA5B;AACD;;AAEM,SAAS2C,WAAT,GAAuB;EAC5B,OAAOvC,yBAAyB,EAAhC;AACD;;AAEM,SAASwC,aAAT,GAAyB;EAC9B,OAAO1C,qBAAqB,CAACC,UAAU,CAAC,QAAD,CAAX,CAA5B;AACD;;AAEM,SAAS0C,gBAAT,GAA4B;EACjC,OAAO3C,qBAAqB,CAACC,UAAU,CAAC,QAAD,CAAX,CAA5B;AACD;;AAEM,SAAS2C,eAAT,GAA2B;EAChC,OAAO5C,qBAAqB,CAACC,UAAU,CAAC,OAAD,CAAX,CAA5B;AACD;;AAEM,SAAS4C,WAAT,GAAuB;EAC5B,OAAOD,eAAe,EAAtB;AACD;;AAEDC,WAAW,CAAC9B,WAAZ,GAA0B,IAA1B;;AAEA,SAAS+B,IAAT,GAAgB;EACd,OAAO9C,qBAAqB,CAACC,UAAU,CAAC,UAAD,CAAX,CAA5B;AACD;;AAUD,MAAM8C,WAAW,GAAGhD,0BAA0B,CAAC,YAAD,CAA9C;AACA,MAAMiD,YAAY,GAAGjD,0BAA0B,CAAC,aAAD,CAA/C;AACA,MAAMkD,cAAc,GAAGlD,0BAA0B,CAAC,eAAD,CAAjD;AACA,MAAMmD,eAAe,GAAGnD,0BAA0B,CAAC,gBAAD,CAAlD;;AACO,SAASoD,cAAT,GAA0D;EAC/D,MAAM;IAAEhC;EAAF,IAAa,KAAKN,IAAxB;;EACA,IAAImC,YAAY,CAAC7B,MAAD,CAAhB,EAA0B;IACxB,OAAOtB,mBAAmB,CAACO,oBAAoB,EAArB,CAA1B;EACD,CAFD,MAEO,IACL2C,WAAW,CAAC5B,MAAD,CAAX,IACA8B,cAAc,CAAC9B,MAAD,CADd,IAGAX,YAAY,CAACW,MAAD,EAAS;IAAEiC,IAAI,EAAE;EAAR,CAAT,CAJP,EAKL;IACA,OAAOvD,mBAAmB,CAACD,iBAAiB,EAAlB,CAA1B;EACD,CAPM,MAOA,IAAIsD,eAAe,CAAC/B,MAAD,CAAnB,EAA6B;IAClC,OAAOtB,mBAAmB,CACxBQ,mBAAmB,CAAC,CAACD,oBAAoB,EAArB,EAAyBR,iBAAiB,EAA1C,CAAD,CADK,CAA1B;EAGD;;EAED,OAAOyD,WAAW,CAAC,KAAK3C,GAAL,CAAS,QAAT,CAAD,CAAlB;AACD;;AAEM,SAAS4C,wBAAT,GAEL;EACA,OAAOD,WAAW,CAAC,KAAK3C,GAAL,CAAS,KAAT,CAAD,CAAlB;AACD;;AAED,SAAS2C,WAAT,CAAqBlC,MAArB,EAAuC;EACrCA,MAAM,GAAGA,MAAM,CAACoC,OAAP,EAAT;;EAEA,IAAIpC,MAAM,CAACqC,UAAP,EAAJ,EAAyB;IACvB,MAAM;MAAE3C;IAAF,IAAWM,MAAjB;;IACA,IAAIN,IAAI,CAAC4C,KAAT,EAAgB;MACd,IAAI5C,IAAI,CAAC6C,SAAT,EAAoB;QAClB,OAAO1D,qBAAqB,CAACC,UAAU,CAAC,eAAD,CAAX,CAA5B;MACD,CAFD,MAEO;QACL,OAAOD,qBAAqB,CAACC,UAAU,CAAC,SAAD,CAAX,CAA5B;MACD;IACF,CAND,MAMO;MACL,IAAIY,IAAI,CAAC6C,SAAT,EAAoB;QAClB,OAAO1D,qBAAqB,CAACC,UAAU,CAAC,UAAD,CAAX,CAA5B;MACD,CAFD,MAEO,IAAIkB,MAAM,CAACN,IAAP,CAAY8C,UAAhB,EAA4B;QACjC,OAAOxC,MAAM,CAACN,IAAP,CAAY8C,UAAnB;MACD,CAFM,MAEA,CAEN;IACF;EACF;AACF"}
+{"version":3,"names":["BOOLEAN_BINARY_OPERATORS","BOOLEAN_UNARY_OPERATORS","NUMBER_BINARY_OPERATORS","NUMBER_UNARY_OPERATORS","STRING_UNARY_OPERATORS","anyTypeAnnotation","arrayTypeAnnotation","booleanTypeAnnotation","buildMatchMemberExpression","genericTypeAnnotation","identifier","nullLiteralTypeAnnotation","numberTypeAnnotation","stringTypeAnnotation","tupleTypeAnnotation","unionTypeAnnotation","voidTypeAnnotation","isIdentifier","VariableDeclarator","get","getTypeAnnotation","TypeCastExpression","node","typeAnnotation","validParent","TSAsExpression","TSNonNullExpression","NewExpression","callee","type","TemplateLiteral","UnaryExpression","operator","indexOf","BinaryExpression","right","left","isBaseType","LogicalExpression","argumentTypes","createUnionType","ConditionalExpression","SequenceExpression","pop","ParenthesizedExpression","AssignmentExpression","UpdateExpression","StringLiteral","NumericLiteral","BooleanLiteral","NullLiteral","RegExpLiteral","ObjectExpression","ArrayExpression","RestElement","Func","isArrayFrom","isObjectKeys","isObjectValues","isObjectEntries","CallExpression","name","resolveCall","TaggedTemplateExpression","resolve","isFunction","async","generator","returnType"],"sources":["../../../src/path/inference/inferers.ts"],"sourcesContent":["import {\n  BOOLEAN_BINARY_OPERATORS,\n  BOOLEAN_UNARY_OPERATORS,\n  NUMBER_BINARY_OPERATORS,\n  NUMBER_UNARY_OPERATORS,\n  STRING_UNARY_OPERATORS,\n  anyTypeAnnotation,\n  arrayTypeAnnotation,\n  booleanTypeAnnotation,\n  buildMatchMemberExpression,\n  genericTypeAnnotation,\n  identifier,\n  nullLiteralTypeAnnotation,\n  numberTypeAnnotation,\n  stringTypeAnnotation,\n  tupleTypeAnnotation,\n  unionTypeAnnotation,\n  voidTypeAnnotation,\n  isIdentifier,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport { default as Identifier } from \"./inferer-reference\";\n\nimport { createUnionType } from \"./util\";\nimport type NodePath from \"..\";\n\nexport function VariableDeclarator(this: NodePath<t.VariableDeclarator>) {\n  if (!this.get(\"id\").isIdentifier()) return;\n  return this.get(\"init\").getTypeAnnotation();\n}\n\nexport function TypeCastExpression(node: t.TypeCastExpression) {\n  return node.typeAnnotation;\n}\n\nTypeCastExpression.validParent = true;\n\nexport function TSAsExpression(node: t.TSAsExpression) {\n  return node.typeAnnotation;\n}\n\nTSAsExpression.validParent = true;\n\nexport function TSNonNullExpression(this: NodePath<t.TSNonNullExpression>) {\n  return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function NewExpression(\n  this: NodePath<t.NewExpression>,\n  node: t.NewExpression,\n) {\n  if (node.callee.type === \"Identifier\") {\n    // only resolve identifier callee\n    return genericTypeAnnotation(node.callee);\n  }\n}\n\nexport function TemplateLiteral() {\n  return stringTypeAnnotation();\n}\n\nexport function UnaryExpression(node: t.UnaryExpression) {\n  const operator = node.operator;\n\n  if (operator === \"void\") {\n    return voidTypeAnnotation();\n  } else if (NUMBER_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return numberTypeAnnotation();\n  } else if (STRING_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return stringTypeAnnotation();\n  } else if (BOOLEAN_UNARY_OPERATORS.indexOf(operator) >= 0) {\n    return booleanTypeAnnotation();\n  }\n}\n\nexport function BinaryExpression(\n  this: NodePath<t.BinaryExpression>,\n  node: t.BinaryExpression,\n) {\n  const operator = node.operator;\n\n  if (NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) {\n    return numberTypeAnnotation();\n  } else if (BOOLEAN_BINARY_OPERATORS.indexOf(operator) >= 0) {\n    return booleanTypeAnnotation();\n  } else if (operator === \"+\") {\n    const right = this.get(\"right\");\n    const left = this.get(\"left\");\n\n    if (left.isBaseType(\"number\") && right.isBaseType(\"number\")) {\n      // both numbers so this will be a number\n      return numberTypeAnnotation();\n    } else if (left.isBaseType(\"string\") || right.isBaseType(\"string\")) {\n      // one is a string so the result will be a string\n      return stringTypeAnnotation();\n    }\n\n    // unsure if left and right are strings or numbers so stay on the safe side\n    return unionTypeAnnotation([\n      stringTypeAnnotation(),\n      numberTypeAnnotation(),\n    ]);\n  }\n}\n\nexport function LogicalExpression(this: NodePath<t.LogicalExpression>) {\n  const argumentTypes = [\n    this.get(\"left\").getTypeAnnotation(),\n    this.get(\"right\").getTypeAnnotation(),\n  ];\n\n  return createUnionType(argumentTypes);\n}\n\nexport function ConditionalExpression(this: NodePath<t.ConditionalExpression>) {\n  const argumentTypes = [\n    this.get(\"consequent\").getTypeAnnotation(),\n    this.get(\"alternate\").getTypeAnnotation(),\n  ];\n\n  return createUnionType(argumentTypes);\n}\n\nexport function SequenceExpression(this: NodePath<t.SequenceExpression>) {\n  return this.get(\"expressions\").pop().getTypeAnnotation();\n}\n\nexport function ParenthesizedExpression(\n  this: NodePath<t.ParenthesizedExpression>,\n) {\n  return this.get(\"expression\").getTypeAnnotation();\n}\n\nexport function AssignmentExpression(this: NodePath<t.AssignmentExpression>) {\n  return this.get(\"right\").getTypeAnnotation();\n}\n\nexport function UpdateExpression(\n  this: NodePath<t.UpdateExpression>,\n  node: t.UpdateExpression,\n) {\n  const operator = node.operator;\n  if (operator === \"++\" || operator === \"--\") {\n    return numberTypeAnnotation();\n  }\n}\n\nexport function StringLiteral() {\n  return stringTypeAnnotation();\n}\n\nexport function NumericLiteral() {\n  return numberTypeAnnotation();\n}\n\nexport function BooleanLiteral() {\n  return booleanTypeAnnotation();\n}\n\nexport function NullLiteral() {\n  return nullLiteralTypeAnnotation();\n}\n\nexport function RegExpLiteral() {\n  return genericTypeAnnotation(identifier(\"RegExp\"));\n}\n\nexport function ObjectExpression() {\n  return genericTypeAnnotation(identifier(\"Object\"));\n}\n\nexport function ArrayExpression() {\n  return genericTypeAnnotation(identifier(\"Array\"));\n}\n\nexport function RestElement() {\n  return ArrayExpression();\n}\n\nRestElement.validParent = true;\n\nfunction Func() {\n  return genericTypeAnnotation(identifier(\"Function\"));\n}\n\nexport {\n  Func as FunctionExpression,\n  Func as ArrowFunctionExpression,\n  Func as FunctionDeclaration,\n  Func as ClassExpression,\n  Func as ClassDeclaration,\n};\n\nconst isArrayFrom = buildMatchMemberExpression(\"Array.from\");\nconst isObjectKeys = buildMatchMemberExpression(\"Object.keys\");\nconst isObjectValues = buildMatchMemberExpression(\"Object.values\");\nconst isObjectEntries = buildMatchMemberExpression(\"Object.entries\");\nexport function CallExpression(this: NodePath<t.CallExpression>) {\n  const { callee } = this.node;\n  if (isObjectKeys(callee)) {\n    return arrayTypeAnnotation(stringTypeAnnotation());\n  } else if (\n    isArrayFrom(callee) ||\n    isObjectValues(callee) ||\n    // Detect \"var foo = Array()\" calls so we can optimize for arrays vs iterables.\n    isIdentifier(callee, { name: \"Array\" })\n  ) {\n    return arrayTypeAnnotation(anyTypeAnnotation());\n  } else if (isObjectEntries(callee)) {\n    return arrayTypeAnnotation(\n      tupleTypeAnnotation([stringTypeAnnotation(), anyTypeAnnotation()]),\n    );\n  }\n\n  return resolveCall(this.get(\"callee\"));\n}\n\nexport function TaggedTemplateExpression(\n  this: NodePath<t.TaggedTemplateExpression>,\n) {\n  return resolveCall(this.get(\"tag\"));\n}\n\nfunction resolveCall(callee: NodePath) {\n  callee = callee.resolve();\n\n  if (callee.isFunction()) {\n    const { node } = callee;\n    if (node.async) {\n      if (node.generator) {\n        return genericTypeAnnotation(identifier(\"AsyncIterator\"));\n      } else {\n        return genericTypeAnnotation(identifier(\"Promise\"));\n      }\n    } else {\n      if (node.generator) {\n        return genericTypeAnnotation(identifier(\"Iterator\"));\n      } else if (callee.node.returnType) {\n        return callee.node.returnType;\n      } else {\n        // todo: get union type of all return arguments\n      }\n    }\n  }\n}\n"],"mappings":"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"}

package/lib/path/inference/util.js

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createUnionType = createUnionType;
-
 var _t = require("@babel/types");
-
 const {
   createFlowUnionType,
   createTSUnionType,
@@ -14,14 +12,12 @@ const {
   isFlowType,
   isTSType
 } = _t;
-
 function createUnionType(types) {
   {
     if (isFlowType(types[0])) {
       if (createFlowUnionType) {
         return createFlowUnionType(types);
       }
-
       return createUnionTypeAnnotation(types);
     } else {
       if (createTSUnionType) {

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

@@ -1 +1 @@
-{"version":3,"names":["createFlowUnionType","createTSUnionType","createUnionTypeAnnotation","isFlowType","isTSType","createUnionType","types"],"sources":["../../../src/path/inference/util.ts"],"sourcesContent":["import {\n  createFlowUnionType,\n  createTSUnionType,\n  createUnionTypeAnnotation,\n  isFlowType,\n  isTSType,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport function createUnionType(\n  types: Array<t.FlowType | t.TSType>,\n): t.FlowType | t.TSType {\n  if (process.env.BABEL_8_BREAKING) {\n    if (isFlowType(types[0])) {\n      return createFlowUnionType(types as t.FlowType[]);\n    }\n    if (isTSType(types[0])) {\n      return createTSUnionType(types as t.TSType[]);\n    }\n  } else {\n    if (isFlowType(types[0])) {\n      if (createFlowUnionType) {\n        return createFlowUnionType(types as t.FlowType[]);\n      }\n\n      return createUnionTypeAnnotation(types as t.FlowType[]);\n    } else {\n      if (createTSUnionType) {\n        return createTSUnionType(types as t.TSType[]);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;AAAA;;;EACEA,mB;EACAC,iB;EACAC,yB;EACAC,U;EACAC;;;AAIK,SAASC,eAAT,CACLC,KADK,EAEkB;EAQhB;IACL,IAAIH,UAAU,CAACG,KAAK,CAAC,CAAD,CAAN,CAAd,EAA0B;MACxB,IAAIN,mBAAJ,EAAyB;QACvB,OAAOA,mBAAmB,CAACM,KAAD,CAA1B;MACD;;MAED,OAAOJ,yBAAyB,CAACI,KAAD,CAAhC;IACD,CAND,MAMO;MACL,IAAIL,iBAAJ,EAAuB;QACrB,OAAOA,iBAAiB,CAACK,KAAD,CAAxB;MACD;IACF;EACF;AACF"}
+{"version":3,"names":["createFlowUnionType","createTSUnionType","createUnionTypeAnnotation","isFlowType","isTSType","createUnionType","types"],"sources":["../../../src/path/inference/util.ts"],"sourcesContent":["import {\n  createFlowUnionType,\n  createTSUnionType,\n  createUnionTypeAnnotation,\n  isFlowType,\n  isTSType,\n} from \"@babel/types\";\nimport type * as t from \"@babel/types\";\n\nexport function createUnionType(\n  types: Array<t.FlowType | t.TSType>,\n): t.FlowType | t.TSType {\n  if (process.env.BABEL_8_BREAKING) {\n    if (isFlowType(types[0])) {\n      return createFlowUnionType(types as t.FlowType[]);\n    }\n    if (isTSType(types[0])) {\n      return createTSUnionType(types as t.TSType[]);\n    }\n  } else {\n    if (isFlowType(types[0])) {\n      if (createFlowUnionType) {\n        return createFlowUnionType(types as t.FlowType[]);\n      }\n\n      return createUnionTypeAnnotation(types as t.FlowType[]);\n    } else {\n      if (createTSUnionType) {\n        return createTSUnionType(types as t.TSType[]);\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;AAAA;AAMsB;EALpBA,mBAAmB;EACnBC,iBAAiB;EACjBC,yBAAyB;EACzBC,UAAU;EACVC;AAAQ;AAIH,SAASC,eAAe,CAC7BC,KAAmC,EACZ;EAQhB;IACL,IAAIH,UAAU,CAACG,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE;MACxB,IAAIN,mBAAmB,EAAE;QACvB,OAAOA,mBAAmB,CAACM,KAAK,CAAiB;MACnD;MAEA,OAAOJ,yBAAyB,CAACI,KAAK,CAAiB;IACzD,CAAC,MAAM;MACL,IAAIL,iBAAiB,EAAE;QACrB,OAAOA,iBAAiB,CAACK,KAAK,CAAe;MAC/C;IACF;EACF;AACF"}