@Override public boolean accepts(Symbol symbol) { return symbol.getKind() == ElementKind.FIELD && !symbol.isStatic(); } };
private static boolean isField(@Nullable ExpressionTree tree) { if (!(tree instanceof IdentifierTree)) { return false; } Symbol symbol = getSymbol(tree); return symbol != null && symbol.getKind() == ElementKind.FIELD; }
@Override public Boolean visitIdentifier(IdentifierTree tree, Void unused) { Symbol sym = ASTHelpers.getSymbol(tree); if (sym instanceof Symbol.VarSymbol) { switch (sym.getKind()) { case LOCAL_VARIABLE: case PARAMETER: conditionVars.add((Symbol.VarSymbol) sym); return true; default: // fall out } } return false; }
private void handleSymbol(Symbol symbol) { if (symbol.getKind() == ElementKind.FIELD && !symbol.isStatic() && symbol.owner.equals(classSymbol)) { String name = symbol.name.toString(); if (name.equals("this") || name.equals("super")) { return; } accessedFields.add(symbol); } }
Select select(GuardedByExpression base, Symbol member) { if (member instanceof VarSymbol) { return select(base, (VarSymbol) member); } if (member instanceof MethodSymbol) { return select(base, (MethodSymbol) member); } throw new IllegalStateException("Bad select expression: expected symbol " + member.getKind()); }
private static List<TypeVariableSymbol> typeVariablesEnclosing(Symbol sym) { List<TypeVariableSymbol> typeVarScopes = new ArrayList<>(); outer: while (!sym.isStatic()) { sym = sym.owner; switch (sym.getKind()) { case PACKAGE: break outer; case METHOD: case CLASS: typeVarScopes.addAll(0, sym.getTypeParameters()); break; default: // fall out } } return typeVarScopes; }
@Override public Boolean visitIdentifier(IdentifierTree node, Void p) { return ASTHelpers.getSymbol(node) != null && ASTHelpers.getSymbol(node).getKind() == ElementKind.PACKAGE; } };
private static List<TypeVariableSymbol> typeVariablesEnclosing(Symbol sym) { List<TypeVariableSymbol> typeVarScopes = new ArrayList<>(); outer: while (!sym.isStatic()) { sym = sym.owner; switch (sym.getKind()) { case PACKAGE: break outer; case METHOD: case CLASS: typeVarScopes.addAll(sym.getTypeParameters()); break; default: // fall out } } return typeVarScopes; } }
@Override public boolean matches(ExpressionTree expressionTree, VisitorState state) { Symbol symbol = ASTHelpers.getSymbol(expressionTree); return symbol != null && symbol.getKind() == ElementKind.FIELD && !symbol.isStatic(); } };
/** Records an assignment to a variable. */ public void recordAssignment(Tree tree, InitializationContext init) { Symbol sym = ASTHelpers.getSymbol(tree); if (sym != null && sym.getKind() == ElementKind.FIELD) { recordAssignment((VarSymbol) sym, init); } }
private static Stream<VarSymbol> getFields(TypeSymbol s) { return Streams.stream(s.members().getSymbols(m -> m.getKind() == ElementKind.FIELD)) .map(VarSymbol.class::cast); }
@Override public Void visitAssignment(AssignmentTree tree, Void unused) { Symbol symbol = ASTHelpers.getSymbol(tree.getVariable()); // check if it is instance field. if (symbol != null && symbol.getKind() == ElementKind.FIELD && !symbol.isStatic()) { variablesAssigned.add(symbol); } return super.visitAssignment(tree, null); } }.scan((JCTree) getOnlyElement(ctorsWithInject), null);
@Override public Void visitVariable(VariableTree tree, Void unused) { Symbol symbol = ASTHelpers.getSymbol(tree); /* It is quite common to have upper case static field names that match variable names, * as for example between HTTP request parameters name definitions and their corresponding * extracted value. */ if (symbol.getKind().equals(ElementKind.FIELD) && !isUpperCaseAndStatic(symbol) && ASTHelpers.enclosingClass(symbol).equals(classSymbol)) { fields.add(symbol); } return super.visitVariable(tree, unused); } }
private boolean isSymbolFieldInAppropriateClass(@Nullable Symbol symbol) { if (symbol == null) { return false; } return symbol.getKind().isField() && fieldSymbolIsAppropriate(symbol) && classIsAppropriate(symbol.owner.enclClass()); }
private static boolean isConstantField(Symbol sym) { return sym.getKind() == ElementKind.FIELD && isStaticFinalField(sym) && isConstantFieldName(sym.getSimpleName().toString()); }
@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 Void visitVariable(VariableTree tree, Void unused) { Symbol symbol = ASTHelpers.getSymbol(tree); if (!symbol.getKind().equals(ElementKind.PARAMETER)) { return super.visitVariable(tree, unused); } String variableName = symbol.toString(); Symbol matchedField = fields.get(Ascii.toLowerCase(variableName)); if (matchedField != null) { String fieldName = matchedField.toString(); if (!variableName.equals(fieldName)) { matchedParameters.put(getCurrentPath(), matchedField); } } return super.visitVariable(tree, unused); } }
@Override public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) { Symbol baseSym = ASTHelpers.getSymbol(tree.getExpression()); if (baseSym == null || baseSym.getKind() != ElementKind.TYPE_PARAMETER) { return Description.NO_MATCH; } TreeMaker make = TreeMaker.instance(state.context) .forToplevel((JCCompilationUnit) state.getPath().getCompilationUnit()); JCExpression qual = make.QualIdent(ASTHelpers.getSymbol(tree)); return describeMatch(tree, SuggestedFix.replace(tree, qual.toString())); } }
/** Gets a human-friendly name for the given {@link Symbol} to use in diagnostics. */ public String getPrettyName(Symbol sym) { if (!sym.getSimpleName().isEmpty()) { return sym.getSimpleName().toString(); } if (sym.getKind() == ElementKind.ENUM) { // anonymous classes for enum constants are identified by the enclosing constant // declaration return sym.owner.getSimpleName().toString(); } // anonymous classes have an empty name, but a recognizable superclass or interface // e.g. refer to `new Runnable() { ... }` as "Runnable" Type superType = state.getTypes().supertype(sym.type); if (state.getTypes().isSameType(superType, state.getSymtab().objectType)) { superType = Iterables.getFirst(state.getTypes().interfaces(sym.type), superType); } return superType.tsym.getSimpleName().toString(); }