{"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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"}