com.sun.source.tree.AssertTree Java Examples

@Override
public Void visitAssert(AssertTree node, Void unused) {
    sync(node);
    builder.open(ZERO);
    token("assert");
    builder.space();
    builder.open(node.getDetail() == null ? ZERO : plusFour);
    scan(node.getCondition(), null);
    if (node.getDetail() != null) {
        builder.breakOp(" ");
        token(":");
        builder.space();
        scan(node.getDetail(), null);
    }
    builder.close();
    builder.close();
    token(";");
    return null;
}
 

@Override
public Void visitAssert(AssertTree node, Void unused) {
  sync(node);
  builder.open(ZERO);
  token("assert");
  builder.space();
  builder.open(node.getDetail() == null ? ZERO : plusFour);
  scan(node.getCondition(), null);
  if (node.getDetail() != null) {
    builder.breakOp(" ");
    token(":");
    builder.space();
    scan(node.getDetail(), null);
  }
  builder.close();
  builder.close();
  token(";");
  return null;
}
 

private static List<? extends TypeMirror> computeAssert(Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssertTree at = (AssertTree) parent.getLeaf();
    
    types.add(ElementKind.PARAMETER);
    types.add(ElementKind.LOCAL_VARIABLE);
    types.add(ElementKind.FIELD);
    
    if (at.getCondition() == error) {
        return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }
    
    if (at.getDetail() == error) {
        return Collections.singletonList(info.getElements().getTypeElement("java.lang.Object").asType());
    }
    
    
    return null;
}
 

@Override
public Void visitAssert(AssertTree node, Void unused) {
    sync(node);
    builder.open(ZERO);
    token("assert");
    builder.space();
    builder.open(node.getDetail() == null ? ZERO : plusFour);
    scan(node.getCondition(), null);
    if (node.getDetail() != null) {
        builder.breakOp(" ");
        token(":");
        builder.space();
        scan(node.getDetail(), null);
    }
    builder.close();
    builder.close();
    token(";");
    return null;
}
 

private static List<? extends TypeMirror> computeAssert(Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssertTree at = (AssertTree) parent.getLeaf();
    
    types.add(ElementKind.PARAMETER);
    types.add(ElementKind.LOCAL_VARIABLE);
    types.add(ElementKind.FIELD);
    
    if (at.getCondition() == error) {
        return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }
    
    if (at.getDetail() == error) {
        return typeMirrorCollection(info, "java.lang.Object");
    }
    
    
    return null;
}
 

@TriggerTreeKind(Tree.Kind.ASSERT)
public static ErrorDescription run(HintContext ctx) {
    CompilationInfo ci = ctx.getInfo();
    AssertTree at = (AssertTree)ctx.getPath().getLeaf();
    TreePath condPath = new TreePath(ctx.getPath(), at.getCondition());
    if (ci.getTreeUtilities().isCompileTimeConstantExpression(condPath)) {
        return null;
    }
    
    SideEffectVisitor visitor = new SideEffectVisitor(ctx);
    Tree culprit;
    try {
        visitor.scan(new TreePath(ctx.getPath(), at.getCondition()), null);
        return null;
    } catch (StopProcessing stop) {
        culprit = stop.getValue();
    }
    return ErrorDescriptionFactory.forTree(ctx, culprit, TEXT_AssertWithSideEffects());
}
 

@Override
public Void visitAssert(AssertTree expected, Tree actual) {
  Optional<AssertTree> other = checkTypeAndCast(expected, actual);
  if (!other.isPresent()) {
    addTypeMismatch(expected, actual);
    return null;
  }

  scan(expected.getCondition(), other.get().getCondition());
  scan(expected.getDetail(), other.get().getDetail());
  return null;
}
 

@Override
public List<Tree> visitAssert(AssertTree node, ExpressionScanner.ExpressionsInfo p) {
    if (acceptsTree(node)) {
        List<Tree> result = scan(node.getCondition(), p);
        result = reduce(result, scan(node.getDetail(), p));
        return result;
    } else {
        return null;
    }
}
 

@Override
public List<? extends TypeMirror> visitAssert(AssertTree node, Object p) {
    if (theExpression == null) {
        initExpression(node.getCondition());
    }
    return booleanType();
}
 

@Override
public Void visitAssert(AssertTree tree, List<Node> d) {
    List<Node> below = new ArrayList<Node>();
    
    addCorrespondingType(below);
    addCorrespondingComments(below);
    super.visitAssert(tree, below);
    
    d.add(new TreeNode(info, getCurrentPath(), below));
    return null;
}
 

@Override
public Object visitAssert(AssertTree node, Object p) {
    int saveCount = negationsCount;
    Object o = super.visitAssert(node, p);
    if (ignoreAsserts) {
        this.negationsCount = saveCount;
    }
    return o;
}
 

public Boolean visitAssert(AssertTree node, TreePath p) {
    if (p == null) {
        super.visitAssert(node, p);
        return false;
    }

    AssertTree at = (AssertTree) p.getLeaf();

    if (!scan(node.getCondition(), at.getCondition(), p)) {
        return false;
    }

    return scan(node.getDetail(), at.getDetail(), p);
}
 

@Override
public Tree visitAssert(AssertTree tree, Void p) {
    AssertTree n = make.Assert(tree.getCondition(), tree.getDetail());
    model.setType(n, model.getType(tree));
    comments.copyComments(tree, n);
    model.setPos(n, model.getPos(tree));
    return n;
}
 

@Override
public Boolean visitAssert(AssertTree node, ConstructorData p) {
    Map< Element, State> oldVariable2State = variable2State;

    variable2State = new HashMap< Element, Flow.State>(oldVariable2State);

    scan(node.getCondition(), null);

    if (node.getDetail() != null) {
        Map< Element, State> beforeDetailState = new HashMap< Element, Flow.State>(variable2State);

        scan(node.getDetail(), null);

        variable2State = mergeOr(variable2State, beforeDetailState);
    }
    
    variable2State = mergeOr(variable2State, oldVariable2State);

    recordResumeOnExceptionHandler("java.lang.AssertionError");
    return null;
}
 

/**
 * Evaluates the constant expression encoded by tree at 'tp' path. See {@link ArithmeticUtilities} for more information.
 * <b>Always</b> check the result value for instanceof before using the value. Without the check, only != null test
 * is valid and has meaning "the expression is known to be constant".
 * 
 * @param info context
 * @param tp tree path for the expression
 * @param resolveCompileTimeConstants if false, symbol resolution is enabled
 * @param enhanced if true, improved analysis is enabled. If false, strict JLS rules apply.
 * @return 
 */
public static Object compute(CompilationInfo info, TreePath tp, boolean resolveCompileTimeConstants, boolean enhanced) {
    // examine parent, if the expression is in some condition/cycle, it might be already evaluated
    boolean save = false;
    ElementValue v = null;
    Map<Object, ElementValue> cache = null;
    if (tp.getParentPath() != null) {
        Tree parentL = tp.getParentPath().getLeaf();
        switch (parentL.getKind()) {
            case IF: 
            case DO_WHILE_LOOP:
            case CONDITIONAL_EXPRESSION:
            case FOR_LOOP:
            case ASSIGNMENT:
            case VARIABLE:
                save = true;
                break;
            case ASSERT: 
                save = ((AssertTree)parentL).getCondition() == tp.getLeaf();
                break;
        }
        
        if (save) {
            cache = VisitorImpl.getValueCache(info);
            v = cache.get(tp.getLeaf());
            if (v != null) {
                if (enhanced && v.constant != null) {
                    return v.constant == UNKNOWN ? null : v.constant;
                } else if (!enhanced && v.jlsConstant != null) {
                    return v.jlsConstant == UNKNOWN ? null : v.jlsConstant;
                }
            }
            
        }
    }
    Object o;
    try {
        o = new VisitorImpl(info, resolveCompileTimeConstants, enhanced).scan(tp, null);
    } catch (ArithmeticException | IndexOutOfBoundsException | IllegalArgumentException ex) {
        o = null;
    }
    if (save) {
        if (v == null) {
            v = new ElementValue();
            cache.put(tp.getLeaf(), v);
        }
        if (enhanced) {
            v.constant = o == null ? UNKNOWN : o;
        } else {
            v.jlsConstant = o == null ? UNKNOWN : o;
        }
    }
    return o;
    
}
 

@Override
    public Object visitAssert(AssertTree node, Object p) {
//      do not count... option ?
//        statements++;
        return super.visitAssert(node, p); 
    }
 

private TreeNode convertAssert(AssertTree node, TreePath parent) {
  TreePath path = getTreePath(parent, node);
  return new AssertStatement()
      .setExpression((Expression) convert(node.getCondition(), path))
      .setMessage((Expression) convert(node.getDetail(), path));
}
 

void beforeVisitCondition(AssertTree node, List<ErrMsg> errMsgs, GlobalContext ctx, Closure<List<Map<String, Long>>> resolveRowAndCol,
Closure<Void> setError);
 

void afterVisitConditionAndBeforeDetail(AssertTree node, List<ErrMsg> errMsgs, GlobalContext ctx,
Closure<List<Map<String, Long>>> resolveRowAndCol, Closure<Void> setError);
 

void afterVisitDetail(AssertTree node, List<ErrMsg> errMsgs, GlobalContext ctx, Closure<List<Map<String, Long>>> resolveRowAndCol,
Closure<Void> setError);