@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (state.isAndroidCompatible()) { // Android's default platform Charset is always UTF-8 return NO_MATCH; } if (STRING_GET_BYTES.matches(tree, state)) { Description.Builder description = buildDescription(tree); Tree parent = state.getPath().getParentPath().getLeaf(); if (parent instanceof ExpressionTree && BYTESTRING_COPY_FROM.matches((ExpressionTree) parent, state)) { byteStringFixes(description, tree, (ExpressionTree) parent, state); } else { appendCharsets(description, tree, tree.getMethodSelect(), tree.getArguments(), state); } return description.build(); } if (FILE_NEW_WRITER.matches(tree, state)) { Description.Builder description = buildDescription(tree); appendCharsets(description, tree, tree.getMethodSelect(), tree.getArguments(), state); return description.build(); } return NO_MATCH; }
@Override public GuardedByExpression visitMethodInvocation( MethodInvocationTree node, BinderContext context) { checkGuardedBy( node.getArguments().isEmpty() && node.getTypeArguments().isEmpty(), "Only nullary methods are allowed."); ExpressionTree methodSelect = node.getMethodSelect(); switch (methodSelect.getKind()) { case IDENTIFIER: { IdentifierTree identifier = (IdentifierTree) methodSelect; Symbol.MethodSymbol method = context.resolver.resolveMethod(node, identifier.getName()); checkGuardedBy(method != null, identifier.toString()); return bindSelect(computeBase(context, method), method); } case MEMBER_SELECT: { MemberSelectTree select = (MemberSelectTree) methodSelect; GuardedByExpression base = visit(select.getExpression(), context); checkGuardedBy(base != null, select.getExpression().toString()); Symbol.MethodSymbol method = context.resolver.resolveMethod(node, base, select.getIdentifier()); checkGuardedBy(method != null, select.toString()); return bindSelect(normalizeBase(context, method, base), method); } default: throw new IllegalGuardedBy(methodSelect.getKind().toString()); } }
@Override Fixer match(ExpressionTree tree, VisitorState state) { if (tree.getKind() != Kind.METHOD_INVOCATION) { return null; } MethodInvocationTree method = (MethodInvocationTree) tree; if (!method.getArguments().isEmpty()) { return null; } if (RETURNS_LIST.matches(method, state)) { return null; } ExpressionTree expressionTree = method.getMethodSelect(); return isGetter(expressionTree) ? (n, s) -> generateFix(method, n, s) : null; }
@Override public Void visitMethodInvocation(MethodInvocationTree tree, ExpressionTree optionalVar) { if (tree.getArguments().stream().anyMatch(m -> ASTHelpers.sameVariable(m, optionalVar))) { hasAssignment = true; } ExpressionTree receiver = ASTHelpers.getReceiver(tree); if (receiver != null && ASTHelpers.sameVariable(receiver, optionalVar)) { ExpressionTree treeIdent = tree.getMethodSelect(); if (treeIdent instanceof MemberSelectTree) { if (((MemberSelectTree) treeIdent).getIdentifier().contentEquals("get")) { hasGet = true; } } } return super.visitMethodInvocation(tree, optionalVar); }
@Override public Void visitMethodInvocation( MethodInvocationTree methodInvocationTree, VarSymbol varSymbol) { ExpressionTree methodSelectTree = methodInvocationTree.getMethodSelect(); MemberSelectTree memberSelectTree; boolean hasParameterAndSameSymbol = methodInvocationTree.getArguments().size() == 1 && Objects.equals( ASTHelpers.getSymbol(methodInvocationTree.getArguments().get(0)), varSymbol); if (methodSelectTree instanceof MemberSelectTree) { memberSelectTree = (MemberSelectTree) methodSelectTree; // this.equals(o) // not using o.equals(this) because all instances of this were false positives // (people checked to see if o was an instance of this class) if (memberSelectTree.getExpression().toString().equals("this") && Objects.equals( ASTHelpers.getSymbol(methodTree), ASTHelpers.getSymbol(memberSelectTree)) && hasParameterAndSameSymbol) { hasIllegalEquals = true; } } else if (methodInvocationTree.getMethodSelect() instanceof IdentifierTree) { IdentifierTree methodSelect = (IdentifierTree) methodInvocationTree.getMethodSelect(); if (Objects.equals(ASTHelpers.getSymbol(methodTree), ASTHelpers.getSymbol(methodSelect)) && hasParameterAndSameSymbol) { hasIllegalEquals = true; } } return super.visitMethodInvocation(methodInvocationTree, varSymbol); } }
TreePath path = env.getPath(); while (path != null) { Tree tree = path.getLeaf(); if (tree.getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mi = (MethodInvocationTree) tree; CompilationUnitTree root = env.getRoot(); SourcePositions sourcePositions = env.getSourcePositions(); int startPos = lastTree != null ? (int) sourcePositions.getStartPosition(root, lastTree) : offset; List<Tree> argTypes = getArgumentsUpToPos(env, mi.getArguments(), (int) sourcePositions.getEndPosition(root, mi.getMethodSelect()), startPos, false); if (argTypes != null) { controller.toPhase(JavaSource.Phase.RESOLVED); int j = 0; for (Tree t : argTypes) { types[j++] = controller.getTrees().getTypeMirror(new TreePath(path, t)); Tree mid = mi.getMethodSelect(); path = new TreePath(path, mid); switch (mid.getKind()) { case MEMBER_SELECT: { ExpressionTree exp = ((MemberSelectTree) mid).getExpression(); toolTipData = getMatchingParams(controller, type, controller.getElementUtilities().getMembers(type, acceptor), ((MemberSelectTree) mid).getIdentifier().toString(), types, controller.getTypes()); break; startPos = (int) sourcePositions.getEndPosition(env.getRoot(), mi.getMethodSelect()); String text = controller.getText().substring(startPos, offset); int idx = text.indexOf('('); //NOI18N
SourcePositions sp = trees.getSourcePositions(); for (int treeIndex = 0; treeIndex < length; treeIndex++) { Tree node = treeNodes.get(treeIndex); Tree.Kind kind = node.getKind(); EditorContext.Operation op = null; if (kind.equals(Tree.Kind.METHOD_INVOCATION) || if (!ci.getTreeUtilities().isSynthetic(ci.getTrees().getPath(cu, node))) { int pos = (int) sp.getStartPosition(cu, node); EditorContext.Position startPosition = identifier = ((NewClassTree) node).getIdentifier(); methodName = "<init>"; TreePath iPath = TreePath.getPath(cu, identifier); TypeMirror type = trees.getTypeMirror(iPath); if (type.getKind() == TypeKind.ERROR) { } else { identifier = ((MethodInvocationTree) node).getMethodSelect(); if (identifier.getKind() == Tree.Kind.IDENTIFIER) { methodName = ((IdentifierTree) identifier).getName().toString(); TreePath iPath = TreePath.getPath(cu, identifier); TypeElement te = trees.getScope(iPath).getEnclosingClass(); if (te == null) {
getEmbeddedOffset(span[0] + 1); TreePath path = controller.getTreeUtilities().pathFor(exactOffset); TreePath parent = path.getParentPath(); if (parent != null) { Tree parentLeaf = parent.getLeaf(); if ( parentLeaf.getKind() == Kind.METHOD_INVOCATION){ ExpressionTree select = ((MethodInvocationTree)parentLeaf). getMethodSelect(); if ( select.getKind() == Kind.MEMBER_SELECT ){ Scope scope = controller.getTrees().getScope(path); Element subjectClass = scope.getEnclosingClass(); Element method = controller.getTrees().getElement( new TreePath(path, select)); Element caller = controller.getTrees().getElement( new TreePath(path, ((MemberSelectTree)select).getExpression())); String methodName = method.getSimpleName().toString(); if ( FIRE.equals( methodName) && method instanceof ExecutableElement && caller instanceof VariableElement ) String variableName = caller.getSimpleName().toString(); TypeElement enclosingTypeElement = controller.getElementUtilities().
@Override public Boolean visitMethodInvocation(MethodInvocationTree tree, Stack<Tree> d) { Element el = info.getTrees().getElement(new TreePath(getCurrentPath(), tree.getMethodSelect())); if (el == null) { System.err.println("Warning: decl == null"); System.err.println("tree=" + tree); } if (el != null && el.getKind() == ElementKind.METHOD) { for (TypeMirror m : ((ExecutableElement) el).getThrownTypes()) { addToExceptionsMap(m, tree); } } super.visitMethodInvocation(tree, d); return null; }
@Override public Void visitMethodInvocation(MethodInvocationTree tree, EnumSet<UseTypes> d) { Tree possibleIdent = tree.getMethodSelect(); boolean handled = false; if (possibleIdent.getKind() == Kind.IDENTIFIER) { List<? extends Tree> ta = tree.getTypeArguments(); long afterTypeArguments = ta.isEmpty() ? -1 : info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), ta.get(ta.size() - 1)); switch (tree.getMethodSelect().getKind()) { case IDENTIFIER: case MEMBER_SELECT: memberSelectBypass = afterTypeArguments; scan(tree.getMethodSelect(), EnumSet.of(UseTypes.READ)); memberSelectBypass = -1; break; default: scan(tree.getMethodSelect(), EnumSet.of(UseTypes.READ)); scan(tree.getTypeArguments(), null); if (tree.getArguments() != null) { for (Tree expr : tree.getArguments()) { if (expr instanceof IdentifierTree) { handlePossibleIdentifier(new TreePath(getCurrentPath(), expr), EnumSet.of(UseTypes.READ)); scan(tree.getArguments(), EnumSet.of(UseTypes.READ));
if(isLiteral(valueExpr)){ value = ((LiteralTree)valueExpr).getValue(); }else if(valueExpr.getKind() == Tree.Kind.MEMBER_SELECT) { if(memSelTree.getExpression().getKind() != Tree.Kind.MEMBER_SELECT) { object = getValue(cinfo, memSelTree.getExpression()); if(object != null) { cls = object.getClass(); cls = getClass(cinfo, memSelTree.getExpression()); }catch(ClassNotFoundException cnfe) { object = getValue(cinfo, memSelTree.getExpression()); }else if(valueExpr.getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mInvoke = (MethodInvocationTree)valueExpr; ExpressionTree selectTree = mInvoke.getMethodSelect(); if(selectTree.getKind() != Tree.Kind.MEMBER_SELECT) { return null; String mname = memSelTree.getIdentifier().toString(); List<? extends ExpressionTree> params = mInvoke.getArguments(); int count = params.size(); Object[] argv = new Object[count]; String cname = null;
/** 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; }
private void matchedShadowOf(MethodInvocationTree shadowOfCall, VisitorState state) { ExpressionTree shadowOfArg = shadowOfCall.getArguments().get(0); Type shadowOfArgType = getExpressionType(shadowOfArg); Tree parent = state.getPath().getParentPath().getLeaf(); CompilationUnitTree compilationUnit = state.getPath().getCompilationUnit(); if (parent.getKind() == Kind.TYPE_CAST) { parent = removeCastIfUnnecessary((JCTypeCast) parent, state); switch (parent.getKind()) { case VARIABLE: // ShadowType shadowType = shadowOf(type); System.out.println("WARN: not sure what to do with " + parent.getKind() + ": " + parent); break;
private MethodInvocationTree modifyMethodInvocationArgument(MethodInvocationTree methodInvocation, int index, ExpressionTree argument, Operation op) { MethodInvocationTree copy = MethodInvocation( (List<? extends ExpressionTree>) methodInvocation.getTypeArguments(), methodInvocation.getMethodSelect(), c(methodInvocation.getArguments(), index, argument, op) ); return copy; }
private void maybeReplaceFieldRef(ExpressionTree subject) { Symbol symbol = getSymbol(subject); if (symbol != null && symbol.getKind() == ElementKind.FIELD) { TreePath subjectPath = TreePath.getPath(compilationUnit, subject); if (symbol.equals(fieldSymbol) && isPartOfMethodInvocation(subjectPath)) { String fieldRef = subject.toString().startsWith("this.") ? "this." + newFieldName : newFieldName; JCTree replaceNode = (JCTree) subject; Tree container = subjectPath.getParentPath().getLeaf(); if (container instanceof JCFieldAccess) { JCFieldAccess fieldAccess = (JCFieldAccess) container; JCMethodInvocation newShadowOfCall = createSyntheticShadowAccess(shadowOfCall, newFieldName, symbol, state); replaceFieldSelected(fieldAccess, newShadowOfCall, state); replaceNode = newShadowOfCall; } String replaceWith = shouldCallDirectlyOnFramework(subjectPath) ? fieldRef : shadowOfCall.getMethodSelect() + "(" + fieldRef + ")"; possibleFixes.put( replaceNode, possibleFixes.new ReplacementFix(subject, replaceWith)); } } } }.scan(compilationUnit, null);
@Override public Description matchMethodInvocation( MethodInvocationTree methodInvocationTree, VisitorState state) { if (!matcher.matches(methodInvocationTree, state)) { return Description.NO_MATCH; } List<? extends ExpressionTree> arguments = methodInvocationTree.getArguments(); ExpressionTree stringLiteralValue = arguments.get(0); Fix fix; if (arguments.size() == 2) { fix = SuggestedFix.swap(arguments.get(0), arguments.get(1)); } else { fix = SuggestedFix.delete(state.getPath().getParentPath().getLeaf()); } return describeMatch(stringLiteralValue, fix); } }
StatementTree findPropertyStatement(CompilationInfo cinfo, String beanName, String methodName) { ExecutableElement execElement = execElementHandle.resolve(cinfo); BlockTree block = cinfo.getTrees().getTree(execElement).getBody(); for(StatementTree statement : block.getStatements()) { if(statement.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree exprStatTree = (ExpressionStatementTree)statement; if(exprStatTree.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree methInvkTree = (MethodInvocationTree)exprStatTree.getExpression(); if(methInvkTree.getMethodSelect().getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree memSelTree = (MemberSelectTree)methInvkTree.getMethodSelect(); ExpressionTree exprTree = memSelTree.getExpression(); if(exprTree.getKind() == Tree.Kind.IDENTIFIER && memSelTree.getIdentifier().toString().equals(methodName) && ((IdentifierTree)exprTree).getName().toString().equals(beanName)) { return statement; } } } } } return null; }
return true; if (leaf.getKind() == Kind.METHOD) { if (leaf.getKind() == Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree est = (ExpressionStatementTree) leaf; if (est.getExpression().getKind() == Kind.METHOD_INVOCATION) { MethodInvocationTree mit = (MethodInvocationTree) est.getExpression(); if (mit.getMethodSelect().getKind() == Kind.IDENTIFIER) { IdentifierTree it = (IdentifierTree) mit.getMethodSelect(); SourcePositions sp = info.getTrees().getSourcePositions();
public static ExpressionTree getReceiver(ExpressionTree expressionTree) { if (expressionTree instanceof MethodInvocationTree) { ExpressionTree methodSelect = ((MethodInvocationTree) expressionTree).getMethodSelect(); if (methodSelect instanceof IdentifierTree) { return null; return ((MemberSelectTree) expressionTree).getExpression(); } else if (expressionTree instanceof MemberReferenceTree) { return ((MemberReferenceTree) expressionTree).getQualifierExpression(); String.format( "Expected expression '%s' to be a method invocation or field access, but was %s", expressionTree, expressionTree.getKind()));
private boolean isSynthetic(CompilationUnitTree cut, Tree leaf) { JCTree tree = (JCTree) leaf; if (tree.pos == (-1)) return true; if (leaf.getKind() == Tree.Kind.METHOD) { //check for synthetic constructor: return (((JCMethodDecl)leaf).mods.flags & Flags.GENERATEDCONSTR) != 0L; } //check for synthetic superconstructor call: if (leaf.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree est = (ExpressionStatementTree) leaf; if (est.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mit = (MethodInvocationTree) est.getExpression(); if (mit.getMethodSelect().getKind() == Tree.Kind.IDENTIFIER) { IdentifierTree it = (IdentifierTree) mit.getMethodSelect(); if ("super".equals(it.getName().toString())) { return sp.getEndPosition(cut, leaf) == (-1); } } } } return false; }