com.sun.source.tree.ThrowTree Java Examples

@Override
public Boolean visitThrow(ThrowTree node, Void p) {
    TypeMirror type = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), node.getExpression()));
    boolean isCaught = false;

    OUTER: for (Pair<Set<TypeMirror>, Tree> pair : caughtExceptions) {
        Set<TypeMirror> caught = pair.first();
        for (TypeMirror c : caught) {
            if (info.getTypes().isSubtype(type, c)) {
                isCaught = true;
                targetTrees.add(pair.second());
                break OUTER;
            }
        }
    }

    return super.visitThrow(node, p) == Boolean.TRUE || !isCaught;
}
 

@Override
public Void visitThrow(ThrowTree node, Collection<TreePath> trees) {
    if (!analyzeThrows) {
        return null;
    }
    TypeMirror type = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), node.getExpression()));
    boolean isCaught = false;

    OUTER: for (Set<TypeMirror> caught : caughtExceptions) {
        for (TypeMirror c : caught) {
            if (info.getTypes().isSubtype(type, c)) {
                isCaught = true;
                break OUTER;
            }
        }
    }

    super.visitThrow(node, trees);
    if (!isCaught) {
        trees.add(getCurrentPath());
    }
    return null;
}
 

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

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

@Override
public Void visitThrow(ThrowTree node, Void unused) {
    sync(node);
    token("throw");
    builder.space();
    scan(node.getExpression(), null);
    token(";");
    return null;
}
 

@Override
public CodeModel visitThrow(ThrowTree node, VisitContext context) {
  ThrowableModel throwableExpression = (ThrowableModel) scan(node.getExpression(), context);
  return StatementModel.render(writer -> {
    writer.renderThrow(throwableExpression.getType(), throwableExpression.getReason());
  });
}
 

@Override
public Void visitThrow(ThrowTree node, Void unused) {
  sync(node);
  token("throw");
  builder.space();
  scan(node.getExpression(), null);
  token(";");
  return null;
}
 

@Override
public Void visitThrow(ThrowTree node, Void unused) {
    sync(node);
    token("throw");
    builder.space();
    scan(node.getExpression(), null);
    token(";");
    return null;
}
 

@Override
public List<Tree> visitThrow(ThrowTree node, ExpressionScanner.ExpressionsInfo p) {
    List<Tree> result = null;
    if (acceptsTree(node)) {
        result = scan(node.getExpression(), p);
    }
    return result;
}
 

private static StatementTree createRethrow(WorkingCopy info, TreeMaker make, String name) {
    if (!ErrorFixesFakeHint.isRethrow(ErrorFixesFakeHint.getPreferences(info.getFileObject(), FixKind.SURROUND_WITH_TRY_CATCH))) {
        return null;
    }

    ThrowTree result = make.Throw(make.Identifier(name));

    info.tag(result.getExpression(), Utilities.TAG_SELECT);

    return result;
}
 

public Boolean visitThrow(ThrowTree node, ConstructorData p) {
    super.visitThrow(node, p);

    if (node.getExpression() != null) {
        TypeMirror thrown = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), node.getExpression()));

        recordResumeOnExceptionHandler(thrown);
    }

    return null;
}
 

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

@Override
public Boolean visitThrow(ThrowTree tree, Stack<Tree> d) {
    addToExceptionsMap(info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), tree.getExpression())), tree);
    
    super.visitThrow(tree, d);
    
    return Boolean.TRUE;
}
 

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

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

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

@Override
public Tree visitThrow(ThrowTree tree, Void p) {
    ThrowTree n = make.Throw(tree.getExpression());
    model.setType(n, model.getType(tree));
    comments.copyComments(tree, n);
    model.setPos(n, model.getPos(tree));
    return n;
}
 

/**
 * Computes possible types for throw expression. Throw can safely throw an exception, which is
 * either declared by method as a thrown type, or catched within method, by an upper try-catch block.
 * Unchecked exceptions are permitted (derivatives of RuntimeException or Error).
 */
@Override
public List<? extends TypeMirror> visitThrow(ThrowTree node, Object p) {
    List<TypeMirror> result = new ArrayList<TypeMirror>();
    TreePath parents = getCurrentPath();
    Tree prev = null;
    while (parents != null && parents.getLeaf().getKind() != Tree.Kind.METHOD) {
        Tree l = parents.getLeaf();
        if (l.getKind() == Tree.Kind.TRY) {
            TryTree tt = (TryTree) l;
            if (prev == tt.getBlock()) {
                for (CatchTree ct : tt.getCatches()) {
                    TypeMirror ex = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), ct.getParameter().getType()));
                    if (ex != null) {
                        switch (ex.getKind()) {
                            case DECLARED:
                                if (!result.contains(ex)) {
                                    result.add(ex);
                                }
                                break;
                            case UNION:
                                for (TypeMirror t : ((UnionType) ex).getAlternatives()) {
                                    if (!result.contains(t)) {
                                        result.add(t);
                                    }
                                }
                                break;
                        }
                    }
                }
            }
        }
        prev = l;
        parents = parents.getParentPath();
    }
    if (parents != null) {
        MethodTree mt = (MethodTree) parents.getLeaf();
        for (ExpressionTree etree : mt.getThrows()) {
            TypeMirror m = info.getTrees().getTypeMirror(new TreePath(parents, etree));
            if (m != null && !result.contains(m)) {
                result.add(m);
            }
        }
    }
    TypeMirror jlre = info.getElements().getTypeElement("java.lang.RuntimeException").asType(); // NOI18N
    TypeMirror jler = info.getElements().getTypeElement("java.lang.Error").asType(); // NOI18N
    for (TypeMirror em : result) {
        if (jlre != null && info.getTypes().isAssignable(jlre, em)) {
            jlre = null;
        }
        if (jler != null && info.getTypes().isAssignable(jler, em)) {
            jler = null;
        }
        if (jlre == null && jler == null) {
            break;
        }
    }
    if (jlre != null) {
        result.add(jlre);
    }
    if (jler != null) {
        result.add(jler);
    }
    return result;
}
 

@Override
public Object visitThrow(ThrowTree node, Object p) {
    complexity++;
    return super.visitThrow(node, p);
}
 

@Override
public Object visitThrow(ThrowTree node, Object p) {
    statements++;
    return super.visitThrow(node, p);
}
 

private TreeNode convertThrow(ThrowTree node, TreePath parent) {
  TreePath path = getTreePath(parent, node);
  return new ThrowStatement().setExpression((Expression) convert(node.getExpression(), path));
}
 

@Override
public UThrow visitThrow(ThrowTree tree, Void v) {
  return UThrow.create(template(tree.getExpression()));
}
 

@Override
@Nullable
public Unifier visitThrow(ThrowTree throwStmt, @Nullable Unifier unifier) {
  return getExpression().unify(throwStmt.getExpression(), unifier);
}