import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
BooleanOutcomePair(
    BooleanLiteralSet toBooleanOutcomes, BooleanLiteralSet booleanValues,
    FlowScope leftScope, FlowScope rightScope) {
  this.toBooleanOutcomes = toBooleanOutcomes;
  this.booleanValues = booleanValues;
  this.leftScope = leftScope;
  this.rightScope = rightScope;
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private BooleanOutcomePair newBooleanOutcomePair(
    JSType jsType, FlowScope flowScope) {
  if (jsType == null) {
    return new BooleanOutcomePair(
        BooleanLiteralSet.BOTH, BooleanLiteralSet.BOTH, flowScope, flowScope);
  }
  return new BooleanOutcomePair(jsType.getPossibleToBooleanOutcomes(),
      registry.getNativeType(BOOLEAN_TYPE).isSubtype(jsType) ?
          BooleanLiteralSet.BOTH : BooleanLiteralSet.EMPTY,
      flowScope, flowScope);
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private static BooleanLiteralSet joinBooleanOutcomes(
    boolean isAnd, BooleanLiteralSet left, BooleanLiteralSet right) {
  // A truthy value on the lhs of an {@code &&} can never make it to the
  // result. Same for a falsy value on the lhs of an {@code ||}.
  // Hence the intersection.
  return right.union(left.intersection(BooleanLiteralSet.get(!isAnd)));
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private BooleanOutcomePair traverseShortCircuitingBinOp(
    Node n, FlowScope scope, boolean condition) {
  Node left = n.getFirstChild();
  Node right = n.getLastChild();

  // type the left node
  BooleanOutcomePair leftLiterals =
      traverseWithinShortCircuitingBinOp(left,
          scope.createChildFlowScope());
  JSType leftType = left.getJSType();

  // reverse abstract interpret the left node to produce the correct
  // scope in which to verify the right node
  FlowScope rightScope = reverseInterpreter.
      getPreciserScopeKnowingConditionOutcome(
          left, leftLiterals.getOutcomeFlowScope(left.getType(), condition),
          condition);

  // type the right node
  BooleanOutcomePair rightLiterals =
      traverseWithinShortCircuitingBinOp(
          right, rightScope.createChildFlowScope());
  JSType rightType = right.getJSType();

  JSType type;
  BooleanOutcomePair literals;
  if (leftType != null && rightType != null) {
    leftType = leftType.getRestrictedTypeGivenToBooleanOutcome(!condition);
    if (leftLiterals.toBooleanOutcomes ==
        BooleanLiteralSet.get(!condition)) {
      // Use the restricted left type, since the right side never gets
      // evaluated.
      type = leftType;
      literals = leftLiterals;
    } else {
      // Use the join of the restricted left type knowing the outcome of the
      // ToBoolean predicate and of the right type.
      type = leftType.getLeastSupertype(rightType);
      literals =
          getBooleanOutcomePair(leftLiterals, rightLiterals, condition);
    }

    // Exclude the boolean type if the literal set is empty because a boolean
    // can never actually be returned.
    if (literals.booleanValues == BooleanLiteralSet.EMPTY &&
        getNativeType(BOOLEAN_TYPE).isSubtype(type)) {
      // Exclusion only make sense for a union type.
      if (type instanceof UnionType) {
        type = ((UnionType) type).getRestrictedUnion(
            getNativeType(BOOLEAN_TYPE));
      }
    }
  } else {
    type = null;
    literals = new BooleanOutcomePair(
        BooleanLiteralSet.BOTH, BooleanLiteralSet.BOTH,
        leftLiterals.getJoinedFlowScope(),
        rightLiterals.getJoinedFlowScope());
  }
  n.setJSType(type);

  return literals;
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private BooleanOutcomePair traverseShortCircuitingBinOp(
    Node n, FlowScope scope, boolean condition) {
  Node left = n.getFirstChild();
  Node right = n.getLastChild();

  // type the left node
  BooleanOutcomePair leftLiterals =
      traverseWithinShortCircuitingBinOp(left,
          scope.createChildFlowScope());
  JSType leftType = left.getJSType();

  // reverse abstract interpret the left node to produce the correct
  // scope in which to verify the right node
  FlowScope rightScope = reverseInterpreter.
      getPreciserScopeKnowingConditionOutcome(
          left, leftLiterals.getOutcomeFlowScope(left.getType(), condition),
          condition);

  // type the right node
  BooleanOutcomePair rightLiterals =
      traverseWithinShortCircuitingBinOp(
          right, rightScope.createChildFlowScope());
  JSType rightType = right.getJSType();

  JSType type;
  BooleanOutcomePair literals;
  if (leftType != null && rightType != null) {
    leftType = leftType.getRestrictedTypeGivenToBooleanOutcome(!condition);
    if (leftLiterals.toBooleanOutcomes ==
        BooleanLiteralSet.get(!condition)) {
      // Use the restricted left type, since the right side never gets
      // evaluated.
      type = leftType;
      literals = leftLiterals;
    } else {
      // Use the join of the restricted left type knowing the outcome of the
      // ToBoolean predicate and of the right type.
      type = leftType.getLeastSupertype(rightType);
      literals =
          getBooleanOutcomePair(leftLiterals, rightLiterals, condition);
    }

    // Exclude the boolean type if the literal set is empty because a boolean
    // can never actually be returned.
    if (literals.booleanValues == BooleanLiteralSet.EMPTY &&
        getNativeType(BOOLEAN_TYPE).isSubtype(type)) {
      // Exclusion only make sense for a union type.
      if (type.isUnionType()) {
        type = type.toMaybeUnionType().getRestrictedUnion(
            getNativeType(BOOLEAN_TYPE));
      }
    }
  } else {
    type = null;
    literals = new BooleanOutcomePair(
        BooleanLiteralSet.BOTH, BooleanLiteralSet.BOTH,
        leftLiterals.getJoinedFlowScope(),
        rightLiterals.getJoinedFlowScope());
  }
  n.setJSType(type);

  return literals;
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private BooleanOutcomePair traverseShortCircuitingBinOp(
    Node n, FlowScope scope) {
  checkArgument(n.isAnd() || n.isOr());
  boolean nIsAnd = n.isAnd();
  Node left = n.getFirstChild();
  Node right = n.getLastChild();

  // type the left node
  BooleanOutcomePair leftOutcome = traverseWithinShortCircuitingBinOp(
      left, scope.createChildFlowScope());
  JSType leftType = left.getJSType();

  // reverse abstract interpret the left node to produce the correct
  // scope in which to verify the right node
  FlowScope rightScope =
      reverseInterpreter.getPreciserScopeKnowingConditionOutcome(
          left, leftOutcome.getOutcomeFlowScope(left.getToken(), nIsAnd), nIsAnd);

  // type the right node
  BooleanOutcomePair rightOutcome = traverseWithinShortCircuitingBinOp(
      right, rightScope.createChildFlowScope());
  JSType rightType = right.getJSType();

  JSType type;
  BooleanOutcomePair outcome;
  if (leftType != null && rightType != null) {
    leftType = leftType.getRestrictedTypeGivenToBooleanOutcome(!nIsAnd);
    if (leftOutcome.toBooleanOutcomes == BooleanLiteralSet.get(!nIsAnd)) {
      // Either n is && and lhs is false, or n is || and lhs is true.
      // Use the restricted left type; the right side never gets evaluated.
      type = leftType;
      outcome = leftOutcome;
    } else {
      // Use the join of the restricted left type knowing the outcome of the
      // ToBoolean predicate and of the right type.
      type = leftType.getLeastSupertype(rightType);
      outcome = new BooleanOutcomePair(
          joinBooleanOutcomes(nIsAnd,
              leftOutcome.toBooleanOutcomes, rightOutcome.toBooleanOutcomes),
          joinBooleanOutcomes(nIsAnd,
              leftOutcome.booleanValues, rightOutcome.booleanValues),
          leftOutcome.getJoinedFlowScope(),
          rightOutcome.getJoinedFlowScope());
    }
    // Exclude the boolean type if the literal set is empty because a boolean
    // can never actually be returned.
    if (outcome.booleanValues == BooleanLiteralSet.EMPTY &&
        getNativeType(BOOLEAN_TYPE).isSubtype(type)) {
      // Exclusion only makes sense for a union type.
      if (type.isUnionType()) {
        type = type.toMaybeUnionType().getRestrictedUnion(
            getNativeType(BOOLEAN_TYPE));
      }
    }
  } else {
    type = null;
    outcome = new BooleanOutcomePair(
        BooleanLiteralSet.BOTH, BooleanLiteralSet.BOTH,
        leftOutcome.getJoinedFlowScope(),
        rightOutcome.getJoinedFlowScope());
  }
  n.setJSType(type);
  return outcome;
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
private BooleanOutcomePair traverseShortCircuitingBinOp(
    Node n, FlowScope scope) {
  Preconditions.checkArgument(n.isAnd() || n.isOr());
  boolean nIsAnd = n.isAnd();
  Node left = n.getFirstChild();
  Node right = n.getLastChild();

  // type the left node
  BooleanOutcomePair leftOutcome = traverseWithinShortCircuitingBinOp(
      left, scope.createChildFlowScope());
  JSType leftType = left.getJSType();

  // reverse abstract interpret the left node to produce the correct
  // scope in which to verify the right node
  FlowScope rightScope = reverseInterpreter.
      getPreciserScopeKnowingConditionOutcome(left,
          leftOutcome.getOutcomeFlowScope(left.getType(), nIsAnd),
          nIsAnd);

  // type the right node
  BooleanOutcomePair rightOutcome = traverseWithinShortCircuitingBinOp(
      right, rightScope.createChildFlowScope());
  JSType rightType = right.getJSType();

  JSType type;
  BooleanOutcomePair outcome;
  if (leftType != null && rightType != null) {
    leftType = leftType.getRestrictedTypeGivenToBooleanOutcome(!nIsAnd);
    if (leftOutcome.toBooleanOutcomes == BooleanLiteralSet.get(!nIsAnd)) {
      // Either n is && and lhs is false, or n is || and lhs is true.
      // Use the restricted left type; the right side never gets evaluated.
      type = leftType;
      outcome = leftOutcome;
    } else {
      // Use the join of the restricted left type knowing the outcome of the
      // ToBoolean predicate and of the right type.
      type = leftType.getLeastSupertype(rightType);
      outcome = new BooleanOutcomePair(
          joinBooleanOutcomes(nIsAnd,
              leftOutcome.toBooleanOutcomes, rightOutcome.toBooleanOutcomes),
          joinBooleanOutcomes(nIsAnd,
              leftOutcome.booleanValues, rightOutcome.booleanValues),
          leftOutcome.getJoinedFlowScope(),
          rightOutcome.getJoinedFlowScope());
    }
    // Exclude the boolean type if the literal set is empty because a boolean
    // can never actually be returned.
    if (outcome.booleanValues == BooleanLiteralSet.EMPTY &&
        getNativeType(BOOLEAN_TYPE).isSubtype(type)) {
      // Exclusion only makes sense for a union type.
      if (type.isUnionType()) {
        type = type.toMaybeUnionType().getRestrictedUnion(
            getNativeType(BOOLEAN_TYPE));
      }
    }
  } else {
    type = null;
    outcome = new BooleanOutcomePair(
        BooleanLiteralSet.BOTH, BooleanLiteralSet.BOTH,
        leftOutcome.getJoinedFlowScope(),
        rightOutcome.getJoinedFlowScope());
  }
  n.setJSType(type);
  return outcome;
}
 

import com.google.javascript.rhino.jstype.BooleanLiteralSet; //导入依赖的package包/类
/**
 * Infers the boolean literal set that can be taken by a
 * short-circuiting binary operation ({@code &&} or {@code ||}).
 * @param left the set of possible {@code ToBoolean} predicate results for
 *    the expression on the left side of the operator
 * @param right the set of possible {@code ToBoolean} predicate results for
 *    the expression on the right side of the operator
 * @param condition the left side {@code ToBoolean} predicate result that
 *    causes the right side to get evaluated (i.e. not short-circuited)
 * @return a set of possible {@code ToBoolean} predicate results for the
 *    entire expression
 */
static BooleanLiteralSet getBooleanOutcomes(BooleanLiteralSet left,
    BooleanLiteralSet right, boolean condition) {
  return right.union(left.intersection(BooleanLiteralSet.get(!condition)));
}