private static boolean isStatic(VariableTree varTree) { return varTree.getModifiers().getFlags().contains(Modifier.STATIC); }
private static boolean isValidParameterTree(VariableTree variableTree) { // A valid parameter has no initializer. if (variableTree.getInitializer() != null) { return false; } // A valid parameter either has no modifiers or has only `final` keyword. Set<Modifier> flags = variableTree.getModifiers().getFlags(); return flags.isEmpty() || (flags.size() == 1 && flags.contains(Modifier.FINAL)); }
/** Returns the modifiers tree of the given class, method, or variable declaration. */ @Nullable public static ModifiersTree getModifiers(Tree tree) { if (tree instanceof ClassTree) { return ((ClassTree) tree).getModifiers(); } else if (tree instanceof MethodTree) { return ((MethodTree) tree).getModifiers(); } else if (tree instanceof VariableTree) { return ((VariableTree) tree).getModifiers(); } else { return null; } }
private static Optional<SuggestedFix> removeInjectAnnotationFromVariable( VariableTree variableTree, VisitorState state) { for (AnnotationTree annotation : variableTree.getModifiers().getAnnotations()) { if (InjectMatchers.IS_APPLICATION_OF_AT_INJECT.matches(annotation, state)) { return Optional.of(SuggestedFix.replace(annotation, "")); } } return Optional.empty(); } }
@Override public Description matchVariable(VariableTree tree, VisitorState state) { Symbol.VarSymbol sym = ASTHelpers.getSymbol(tree); if (sym == null) { return NO_MATCH; } return check(sym.type, tree.getModifiers().getAnnotations()); }
@Override public Description matchVariable(VariableTree tree, VisitorState state) { Symbol symbol = getSymbol(tree); if (symbol.getKind() != ElementKind.FIELD) { return NO_MATCH; } return handle(tree, tree.getName(), tree.getModifiers(), state); }
@Override public Unifier apply(Unifier unifier) { unifier.putBinding( key(), LocalVarBinding.create(ASTHelpers.getSymbol(decl), decl.getModifiers())); return unifier; } });
@Override public boolean apply(Tree tree) { switch (tree.getKind()) { case CLASS: return ((ClassTree) tree).getModifiers().getFlags().contains(STATIC); case METHOD: return ((MethodTree) tree).getModifiers().getFlags().contains(STATIC); case VARIABLE: return ((VariableTree) tree).getModifiers().getFlags().contains(STATIC); case BLOCK: return ((BlockTree) tree).isStatic(); case ENUM: case ANNOTATION_TYPE: case INTERFACE: return true; default: throw new AssertionError("unknown member type:" + tree.getKind()); } } });
(suggestTree instanceof MethodTree) ? ((MethodTree) suggestTree).getModifiers() : ((VariableTree) suggestTree).getModifiers(); List<? extends AnnotationTree> annotations = modifiers.getAnnotations();
@Override protected Iterable<? extends AnnotationTree> getChildNodes(T tree, VisitorState state) { if (tree instanceof ClassTree) { return ((ClassTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof VariableTree) { return ((VariableTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof MethodTree) { return ((MethodTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof CompilationUnitTree) { return ((CompilationUnitTree) tree).getPackageAnnotations(); } else if (tree instanceof AnnotatedTypeTree) { return ((AnnotatedTypeTree) tree).getAnnotations(); } else if (tree instanceof PackageTree) { return ((PackageTree) tree).getAnnotations(); } else { throw new IllegalArgumentException( "Cannot access annotations from tree of type " + tree.getClass()); } } }
@Override public Choice<State<JCVariableDecl>> visitVariable(final VariableTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getInitializer(), s), init -> maker() .VarDef( (JCModifiers) node.getModifiers(), (Name) node.getName(), (JCExpression) node.getType(), init)); }
@Override public Description matchVariable(VariableTree tree, VisitorState state) { ExpressionTree initializer = stripNullCheck(tree.getInitializer(), state); Tree parent = state.getPath().getParentPath().getLeaf(); // must be a static class variable with member select initializer if (initializer == null || initializer.getKind() != MEMBER_SELECT || parent.getKind() != CLASS || !tree.getModifiers().getFlags().contains(STATIC)) { return Description.NO_MATCH; } MemberSelectTree rhs = (MemberSelectTree) initializer; Symbol rhsClass = ASTHelpers.getSymbol(rhs.getExpression()); Symbol lhsClass = ASTHelpers.getSymbol(parent); if (rhsClass != null && lhsClass != null && rhsClass.equals(lhsClass) && rhs.getIdentifier().contentEquals(tree.getName())) { return describeForVarDecl(tree, state); } return Description.NO_MATCH; }
boolean isStatic = isStatic(vt.getModifiers().getFlags()); if (shortSyntax) { if (isStatic) {
for (AnnotationTree anno : varDecl.getModifiers().getAnnotations()) { if (IMPLICIT_VAR_ANNOTATION_SIMPLE_NAMES.contains(ASTHelpers.getAnnotationName(anno))) { return Description.NO_MATCH;
for (AnnotationTree anno : paramDecl.getModifiers().getAnnotations()) { String annoType = ASTHelpers.getSymbol(anno).type.toString(); if (annoType.endsWith(".Nullable")
String modifiers = nullToEmpty( variableTree.getModifiers() == null ? null : state.getSourceForNode(variableTree.getModifiers())); String newContent = String.format(
/** * Checks wheteher given variable tree represents an enum constant. */ public boolean isEnumConstant(VariableTree tree) { return (((JCTree.JCModifiers) tree.getModifiers()).flags & Flags.ENUM) != 0; }
public IModifierList getModifierList() { if (_modifierList == null) { final ModifiersTree modifiers = _fieldTree.getModifiers(); _modifierList = new JavaSourceModifierList(this, modifiers); } return _modifierList; }
private static String removeFieldPrefixSuffix(VariableTree var, CodeStyle cs) { boolean isStatic = var.getModifiers().getFlags().contains(Modifier.STATIC); return CodeStyleUtils.removePrefixSuffix(var.getName(), isStatic ? cs.getStaticFieldNamePrefix() : cs.getFieldNamePrefix(), isStatic ? cs.getStaticFieldNameSuffix() : cs.getFieldNameSuffix()); }
public R visitVariable(VariableTree node, P p) { R r = scan(node.getModifiers(), p); r = scanAndReduce(node.getType(), p, r); r = scanAndReduce(node.getNameExpression(), p, r); r = scanAndReduce(node.getInitializer(), p, r); return r; }