How to use

getStartPosition

method

in

com.sun.tools.javac.tree.JCTree

 /**
  * 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();
 }
}