@Nullable @Override public Type visitMemberSelect(MemberSelectTree node, Void aVoid) { if (current.equals(node.getExpression())) { return ASTHelpers.getType(node.getExpression()); } return null; }
@Override public Boolean visitMemberSelect(MemberSelectTree node, Void p) { return node.getExpression().accept(this, null); }
@Override public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) { return matchDereference(tree.getExpression(), state); }
private void buildObservableCallChain(MethodInvocationTree tree) { ExpressionTree methodSelect = tree.getMethodSelect(); if (methodSelect instanceof MemberSelectTree) { ExpressionTree receiverExpression = ((MemberSelectTree) methodSelect).getExpression(); if (receiverExpression instanceof MethodInvocationTree) { observableOuterCallInChain.put((MethodInvocationTree) receiverExpression, tree); } } // ToDo: What else can be here? If there are other cases than MemberSelectTree, handle them. }
@Override public Void visitMemberSelect(MemberSelectTree memberSelectTree, Void aVoid) { maybeReplaceFieldRef(memberSelectTree.getExpression()); return super.visitMemberSelect(memberSelectTree, aVoid); }
@Override public Void visitMemberSelect(MemberSelectTree tree, Void unused) { fixQualifier(tree, tree.getExpression()); return super.visitMemberSelect(tree, unused); }
/** Returns true if this method invocation is of the form {@code super.foo()} */ private static boolean isSuperCall(Type type, MethodInvocationTree tree, VisitorState state) { if (tree.getMethodSelect().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree select = (MemberSelectTree) tree.getMethodSelect(); if (select.getExpression().getKind() == Kind.IDENTIFIER) { IdentifierTree ident = (IdentifierTree) select.getExpression(); return ident.getName().contentEquals("super"); } else if (select.getExpression().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree subSelect = (MemberSelectTree) select.getExpression(); return subSelect.getIdentifier().contentEquals("super") && ASTHelpers.isSameType(ASTHelpers.getType(subSelect.getExpression()), type, state); } } return false; }
@Override public boolean matches(ExpressionTree expressionTree, VisitorState state) { if (expressionTree.getKind() == Kind.MEMBER_SELECT) { MemberSelectTree select = (MemberSelectTree) expressionTree; return select.getIdentifier().contentEquals("class") && classMatcher.matches(select.getExpression(), state); } return false; } };
@Override public Void visitMemberSelect(MemberSelectTree node, Void unused) { checkForThis(node, node.getIdentifier(), thisClass, state); // Don't examine this.foo or MyClass.this.foo ExpressionTree left = node.getExpression(); if ((left instanceof IdentifierTree && ((IdentifierTree) left).getName().contentEquals("this")) || (left instanceof MemberSelectTree && ((MemberSelectTree) left).getIdentifier().contentEquals("this"))) { return null; } return super.visitMemberSelect(node, unused); }
@Override public Void visitMemberSelect(MemberSelectTree node, Void unused) { if (!crashesWithNull[0]) { Symbol symbol = getSymbol(node.getExpression()); if (symbol instanceof VarSymbol && incomingVariableSymbols.contains(symbol)) { Nullness nullness = analysis.getNullness( new TreePath(getCurrentPath(), node.getExpression()), state.context); if (nullness == Nullness.NULLABLE) { crashesWithNull[0] = true; } } } return super.visitMemberSelect(node, null); }
boolean isThisAccess(Tree tree) { if (tree.getKind() == Kind.IDENTIFIER) { return true; } if (tree.getKind() != Kind.MEMBER_SELECT) { return false; } ExpressionTree selected = ((MemberSelectTree) tree).getExpression(); if (!(selected instanceof IdentifierTree)) { return false; } IdentifierTree ident = (IdentifierTree) selected; return ident.getName().contentEquals("this"); }
@Override public boolean matches(ExpressionTree expressionTree, VisitorState state) { Symbol sym = ASTHelpers.getSymbol(expressionTree); if (sym != null && sym.getSimpleName().toString().startsWith("log")) { return true; } if (sym != null && sym.isStatic()) { if (sym.owner.getQualifiedName().toString().contains("Logger")) { return true; } } else if (expressionTree instanceof MemberSelectTree) { if (((MemberSelectTree) expressionTree).getExpression().toString().startsWith("log")) { return true; } } return false; } }
@Override public Void visitIdentifier(IdentifierTree tree, Void unused) { if (varSym.equals(ASTHelpers.getSymbol(tree))) { Tree parent = getCurrentPath().getParentPath().getLeaf(); if (parent == varTree) { // the use of the variable in its declaration gets a pass return null; } // the LHS of a select (e.g. in `sb.append(...)`) does not escape if (!(parent instanceof MemberSelectTree) || ((MemberSelectTree) parent).getExpression() != tree) { escape[0] = true; } } return null; } }.scan(methodPath, null);
@Override public Boolean visitMethodInvocation(MethodInvocationTree tree, Void unused) { boolean result = false; MethodSymbol methodSym = ASTHelpers.getSymbol(tree); if (methodSym != null) { ExpressionTree methodSelect = tree.getMethodSelect(); if (methodSelect.getKind() == Kind.MEMBER_SELECT) { MemberSelectTree memberSelect = (MemberSelectTree) methodSelect; result = isSuper(memberSelect.getExpression()) && memberSelect.getIdentifier().contentEquals(overridingMethodName); } } return result || super.visitMethodInvocation(tree, unused); }
@Override public UExpression visitMemberSelect(MemberSelectTree tree, Void v) { Symbol sym = ASTHelpers.getSymbol(tree); if (sym instanceof ClassSymbol) { return UClassIdent.create((ClassSymbol) sym); } else if (sym.isStatic()) { ExpressionTree selected = tree.getExpression(); checkState( ASTHelpers.getSymbol(selected) instanceof ClassSymbol, "Refaster cannot match static methods used on instances"); return staticMember(sym); } return UMemberSelect.create( template(tree.getExpression()), tree.getIdentifier(), template(sym.type)); }
@Override public Boolean visitMemberSelect(MemberSelectTree node, Void v) { if (node.getIdentifier().contentEquals("class")) { TypeMirror tm = getType(node.getExpression()); if (!verifier.getTypeUtils().isSubtype(tm, btraceServiceTm)) { reportError("no.class.literals", node); } } return super.visitMemberSelect(node, v); }
@Override public Choice<State<JCFieldAccess>> visitMemberSelect( final MemberSelectTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), expr -> maker().Select(expr, (Name) node.getIdentifier())); }
/** Replaces the name of the method being invoked in {@code tree} with {@code replacement}. */ public static SuggestedFix renameMethodInvocation( MethodInvocationTree tree, String replacement, VisitorState state) { Tree methodSelect = tree.getMethodSelect(); int startPos; String extra = ""; if (methodSelect instanceof MemberSelectTree) { startPos = state.getEndPosition(((MemberSelectTree) methodSelect).getExpression()); extra = "."; } else if (methodSelect instanceof IdentifierTree) { startPos = ((JCTree) tree).getStartPosition(); } else { return SuggestedFix.builder().build(); } int endPos = state.getEndPosition(methodSelect); return SuggestedFix.replace(startPos, endPos, extra + replacement); }
@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())); } }
@Override public Choice<Unifier> visitMemberSelect(MemberSelectTree fieldAccess, Unifier unifier) { if (ASTHelpers.getSymbol(fieldAccess) != null) { return getIdentifier() .unify(fieldAccess.getIdentifier(), unifier) .thenChoose(unifications(getExpression(), fieldAccess.getExpression())) .thenChoose(unifications(type(), ASTHelpers.getSymbol(fieldAccess).asType())); } return Choice.none(); }