/** * Returns a start position of given {@code tree}. * * <p>The only purpose of this method is to avoid doing a hacky casting to {@link JCTree}. */ private static int getStartPosition(Tree tree) { return ((JCTree) tree).getStartPosition(); } }
@Override public int getStartPosition() { return position.getStartPosition() + startPositionAdjustment; }
@Override public Description report( Set<MethodTree> affectedTrees, SuggestedFix fix, VisitorState state, BugChecker checker) { return affectedTrees.stream() .min(Comparator.comparingInt(t -> ((JCTree) t).getStartPosition())) .map(t -> checker.describeMatch(t.getModifiers(), fix)) .orElse(NO_MATCH); } },
private void removeLeftOperand(BinaryTree superBinary) { fix.replace( ((JCTree) superBinary.getLeftOperand()).getStartPosition(), ((JCTree) superBinary.getRightOperand()).getStartPosition(), ""); }
public String getRange(JCCompilationUnit unit) { try { CharSequence sequence = unit.getSourceFile().getCharContent(true); return sequence .subSequence(location.getStartPosition(), location.getEndPosition(unit.endPositions)) .toString(); } catch (IOException e) { throw new RuntimeException(e); } } }
@Override public String getRange(JCCompilationUnit unit) { try { CharSequence sequence = unit.getSourceFile().getCharContent(true); JCTree firstStatement = statements.get(0); JCTree lastStatement = Iterables.getLast(statements); return sequence .subSequence( firstStatement.getStartPosition(), lastStatement.getEndPosition(unit.endPositions)) .toString(); } catch (IOException e) { throw new RuntimeException(e); } } }
private static int getThrowsPosition(MethodTree tree, VisitorState state) { for (ErrorProneToken token : state.getTokensForNode(tree)) { if (token.kind() == Tokens.TokenKind.THROWS) { return ((JCTree) tree).getStartPosition() + token.pos(); } } throw new AssertionError(); }
void advance() { ExpressionTree nextArgument = argumentsIterator.next(); currentArgumentEndPosition = state.getEndPosition(nextArgument) - offset; previousArgumentEndPosition = currentArgumentStartPosition; currentArgumentStartPosition = ((JCTree) nextArgument).getStartPosition() - offset; if (previousCommentedResultBuilder != null) { resultBuilder.add(previousCommentedResultBuilder.build()); } previousCommentedResultBuilder = currentCommentedResultBuilder; currentCommentedResultBuilder = Commented.<ExpressionTree>builder().setTree(nextArgument); }
@Override public Description matchNewClass(NewClassTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return Description.NO_MATCH; } ExpressionTree millisArg = Iterables.getOnlyElement(tree.getArguments()); SuggestedFix fix = SuggestedFix.replace( ((JCTree) tree).getStartPosition(), ((JCTree) millisArg).getStartPosition(), state.getSourceForNode(tree.getIdentifier()) + ".millis("); return describeMatch(tree, fix); } }
private static String getMessageOrFormat(MethodInvocationTree tree, VisitorState state) { if (tree.getArguments().size() > 1) { return "String.format(" + state .getSourceCode() .subSequence( ((JCTree) tree.getArguments().get(0)).getStartPosition(), state.getEndPosition(Iterables.getLast(tree.getArguments()))) + ")"; } return state.getSourceForNode(getOnlyElement(tree.getArguments())); }
private static SuggestedFix appendArgument( NewClassTree constructor, String exception, VisitorState state, List<Type> types) { if (types.isEmpty()) { // Skip past the opening '(' of the constructor. String source = state.getSourceForNode(constructor); int startPosition = ((JCTree) constructor).getStartPosition(); int pos = source.indexOf('(', state.getEndPosition(constructor.getIdentifier()) - startPosition) + startPosition + 1; return SuggestedFix.replace(pos, pos, exception); } return SuggestedFix.postfixWith( getLast(constructor.getArguments()), String.format(", %s", exception)); }
private static int caseEndPosition(VisitorState state, JCTree.JCCase caseTree) { // if the statement group is a single block statement, handle fall through comments at the // end of the block if (caseTree.stats.size() == 1) { JCTree.JCStatement only = getOnlyElement(caseTree.stats); if (only.hasTag(JCTree.Tag.BLOCK)) { BlockTree blockTree = (BlockTree) only; return blockTree.getStatements().isEmpty() ? ((JCTree) blockTree).getStartPosition() : state.getEndPosition(getLast(blockTree.getStatements())); } } return state.getEndPosition(caseTree); } }
@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return Description.NO_MATCH; } SuggestedFix.Builder builder = SuggestedFix.builder(); String replacement = SuggestedFixes.qualifyType(state, builder, "org.joda.time.Duration") + ".millis("; ExpressionTree millisArg = Iterables.getOnlyElement(tree.getArguments()); builder.replace( ((JCTree) tree).getStartPosition(), ((JCTree) millisArg).getStartPosition(), replacement); return describeMatch(tree, builder.build()); } }
@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (!MATCHER.matches(tree, state)) { return Description.NO_MATCH; } SuggestedFix.Builder builder = SuggestedFix.builder(); String replacement = "new " + SuggestedFixes.qualifyType(state, builder, "org.joda.time.Instant") + "("; ExpressionTree millisArg = Iterables.getOnlyElement(tree.getArguments()); builder.replace( ((JCTree) tree).getStartPosition(), ((JCTree) millisArg).getStartPosition(), replacement); return describeMatch(tree, builder.build()); } }
@Override SuggestedFix fix(Fixer fixer, ExpressionTree tree, VisitorState state) { MethodInvocationTree methodInvocationTree = (MethodInvocationTree) tree; return fixer .getHazzer(/* negated= */ false, state) .map( r -> { int startPos = ((JCTree) methodInvocationTree).getStartPosition(); return SuggestedFix.builder() .replace(getLast(methodInvocationTree.getArguments()), r) .replace(startPos, startPos + "assertNotNull".length(), "assertTrue") .build(); }) .orElse(SuggestedFix.builder().build()); } },
private static SuggestedFix fixClass(ClassTree classTree, VisitorState state) { int startPos = ((JCTree) classTree).getStartPosition(); int endPos = ((JCTree) classTree.getMembers().get(0)).getStartPosition(); ImmutableList<ErrorProneToken> tokens = ErrorProneTokens.getTokens( state.getSourceCode().subSequence(startPos, endPos).toString(), state.context); String modifiers = getSymbol(classTree).owner.enclClass() == null ? "final class" : "static final class"; SuggestedFix.Builder fix = SuggestedFix.builder(); for (ErrorProneToken token : tokens) { if (token.kind() == TokenKind.INTERFACE) { fix.replace(startPos + token.pos(), startPos + token.endPos(), modifiers); } } return fix.build(); } }
SuggestedFix buildCommentArgumentsFix(InvocationInfo info) { SuggestedFix.Builder commentArgumentsFixBuilder = SuggestedFix.builder(); for (ParameterPair change : changedPairs()) { int index = change.formal().index(); ExpressionTree actual = info.actualParameters().get(index); int startPosition = ((JCTree) actual).getStartPosition(); String formal = info.formalParameters().get(index).getSimpleName().toString(); commentArgumentsFixBuilder.replace( startPosition, startPosition, NamedParameterComment.toCommentText(formal)); } return commentArgumentsFixBuilder.build(); }
@Override public Description matchParenthesized(ParenthesizedTree tree, VisitorState state) { ExpressionTree expression = tree.getExpression(); if (state.getPath().getParentPath().getLeaf() instanceof StatementTree) { return NO_MATCH; } if (ASTHelpers.requiresParentheses(expression, state)) { return NO_MATCH; } return describeMatch( tree, SuggestedFix.builder() .replace( ((JCTree) tree).getStartPosition(), ((JCTree) expression).getStartPosition(), "") .replace(state.getEndPosition(expression), state.getEndPosition(tree), "") .build()); } }
@Override public Void visitBinary(BinaryTree tree, SuggestedFix.Builder p) { if (tree.getKind() == Kind.AND || tree.getKind() == Kind.OR) { p.replace( /* startPos= */ state.getEndPosition(tree.getLeftOperand()), /* endPos= */ ((JCTree) tree.getRightOperand()).getStartPosition(), tree.getKind() == Tree.Kind.AND ? " && " : " || "); } return super.visitBinary(tree, p); } }
private Description checkCondition(ExpressionTree condition, VisitorState state) { if (!(condition instanceof AssignmentTree)) { return NO_MATCH; } AssignmentTree assign = (AssignmentTree) condition; return buildDescription(condition) .addFix( SuggestedFix.builder().prefixWith(condition, "(").postfixWith(condition, ")").build()) .addFix( SuggestedFix.replace( /*startPos=*/ state.getEndPosition(assign.getVariable()), /*endPos=*/ ((JCTree) assign.getExpression()).getStartPosition(), " == ")) .build(); } }