Java JSType.getRestrictedTypeGivenToBooleanOutcome方法代码示例

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
private FlowScope caseNameOrGetProp(Node name, FlowScope blindScope,
    boolean outcome) {
  JSType type = getTypeIfRefinable(name, blindScope);
  if (type != null) {
    JSType restrictedType =
        type.getRestrictedTypeGivenToBooleanOutcome(outcome);
    FlowScope informed = blindScope.createChildFlowScope();
    declareNameInScope(informed, name, restrictedType);
    return informed;
  }
  return blindScope;
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的package包/类
private FlowScope caseAndOrNotShortCircuiting(Node left, Node right,
      FlowScope blindScope, boolean condition) {
  // left type
  JSType leftType = getTypeIfRefinable(left, blindScope);
  boolean leftIsRefineable;
  if (leftType != null) {
    leftIsRefineable = true;
  } else {
    leftIsRefineable = false;
    leftType = left.getJSType();
    blindScope = firstPreciserScopeKnowingConditionOutcome(
        left, blindScope, condition);
  }

  // restricting left type
  leftType = (leftType == null) ? null :
      leftType.getRestrictedTypeGivenToBooleanOutcome(condition);
  if (leftType == null) {
    return firstPreciserScopeKnowingConditionOutcome(
        right, blindScope, condition);
  }

  // right type
  JSType rightType = getTypeIfRefinable(right, blindScope);
  boolean rightIsRefineable;
  if (rightType != null) {
    rightIsRefineable = true;
  } else {
    rightIsRefineable = false;
    rightType = right.getJSType();
    blindScope = firstPreciserScopeKnowingConditionOutcome(
        right, blindScope, condition);
  }

  if (condition) {
    rightType = (rightType == null) ? null :
        rightType.getRestrictedTypeGivenToBooleanOutcome(condition);

    // creating new scope
    if ((leftType != null && leftIsRefineable) ||
        (rightType != null && rightIsRefineable)) {
      FlowScope informed = blindScope.createChildFlowScope();
      if (leftIsRefineable && leftType != null) {
        declareNameInScope(informed, left, leftType);
      }
      if (rightIsRefineable && rightType != null) {
        declareNameInScope(informed, right, rightType);
      }
      return informed;
    }
  }
  return blindScope;
}
 

import com.google.javascript.rhino.jstype.JSType; //导入方法依赖的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;
}