@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { if (ASSERTION.matches(state.getPath().getParentPath().getLeaf(), state)) { return NO_MATCH; } List<? extends ExpressionTree> args = tree.getArguments(); ExpressionTree toReplace; if (INSTANCE_MATCHER.matches(tree, state)) { toReplace = args.get(0); } else if (STATIC_MATCHER.matches(tree, state)) { if (args.get(0).getKind() == Kind.IDENTIFIER && args.get(1).getKind() != Kind.IDENTIFIER) { toReplace = args.get(0); } else { toReplace = args.get(1); } } else { return NO_MATCH; } Description.Builder description = buildDescription(tree); Fix fix = fieldFix(toReplace, state); if (fix != null) { description.addFix(fix); } return description.build(); }
@Override public Boolean visitMemberSelect(MemberSelectTree node, Void p) { return node.getExpression().accept(this, 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; }
type = controller.getTrees().getTypeMirror(new TreePath(path, ((AssignmentTree) tree).getVariable())); if (type == null) { return null; return null; if (methodOrLambdaPath.getLeaf().getKind() == Tree.Kind.METHOD) { return null; case SWITCH: SwitchTree sw = (SwitchTree) tree; if (sw.getExpression() != lastTree && sw.getExpression().getKind() != Tree.Kind.ERRONEOUS) { return null; if (!mi.getTypeArguments().isEmpty()) { String name = ((MemberSelectTree) mid).getIdentifier().toString(); ExpressionTree exp = ((MemberSelectTree) mid).getExpression(); case EXPRESSION_STATEMENT: exp = ((ExpressionStatementTree) tree).getExpression(); if (exp.getKind() == Tree.Kind.PARENTHESIZED) { text = controller.getText().substring((int) env.getSourcePositions().getStartPosition(env.getRoot(), exp), offset).trim(); if (text.endsWith(")")) //NOI18N
private void addSyntheticTrees(DiffContext diffContext, Tree node) { if (node == null) return ; if (((JCTree) node).pos == (-1)) { diffContext.syntheticTrees.add(node); return ; } if (node.getKind() == Kind.EXPRESSION_STATEMENT) { ExpressionTree est = ((ExpressionStatementTree) node).getExpression(); if (est.getKind() == Kind.METHOD_INVOCATION) { ExpressionTree select = ((MethodInvocationTree) est).getMethodSelect(); if (select.getKind() == Kind.IDENTIFIER && ((IdentifierTree) select).getName().contentEquals("super")) { if (getTreeUtilities().isSynthetic(diffContext.origUnit, node)) { diffContext.syntheticTrees.add(node); } } } } }
@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; }
@Override public Void visitMethodInvocation(MethodInvocationTree tree, EnumSet<UseTypes> d) { Tree possibleIdent = tree.getMethodSelect(); boolean handled = false; if (possibleIdent.getKind() == Kind.IDENTIFIER) { String ident = ((IdentifierTree) possibleIdent).getName().toString(); Element resolved = info.getTrees().getElement(getCurrentPath()); handlePossibleIdentifier(new TreePath(getCurrentPath(), possibleIdent), EnumSet.of(UseTypes.EXECUTE)); 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: for (Tree expr : tree.getArguments()) { if (expr instanceof IdentifierTree) { handlePossibleIdentifier(new TreePath(getCurrentPath(), expr), EnumSet.of(UseTypes.READ));
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) &&
private void insideCase(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); CaseTree cst = (CaseTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); CompilationController controller = env.getController(); if (cst.getExpression() != null && ((sourcePositions.getStartPosition(root, cst.getExpression()) >= offset) || (cst.getExpression().getKind() == Tree.Kind.ERRONEOUS && ((ErroneousTree) cst.getExpression()).getErrorTrees().isEmpty() && sourcePositions.getEndPosition(root, cst.getExpression()) >= offset))) { TreePath path1 = path.getParentPath(); if (path1.getLeaf().getKind() == Tree.Kind.SWITCH) { TypeMirror tm = controller.getTrees().getTypeMirror(new TreePath(path1, ((SwitchTree) path1.getLeaf()).getExpression())); if (tm.getKind() == TypeKind.DECLARED && ((DeclaredType) tm).asElement().getKind() == ENUM) { addEnumConstants(env, (TypeElement) ((DeclaredType) tm).asElement()); } else { addLocalConstantsAndTypes(env); } } } else { TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, cst, offset); if (ts != null && ts.token().id() != JavaTokenId.DEFAULT) { localResult(env); addKeywordsForBlock(env); } } }
insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); if (it.hasNext()) { ExpressionTree et = it.next(); if (et == fa || (et.getKind() == Tree.Kind.ASSIGNMENT && ((AssignmentTree) et).getExpression() == fa)) { if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName()); break; case SHORT: case VOID: boolean b = exp.getKind() == Tree.Kind.PARENTHESIZED || exp.getKind() == Tree.Kind.TYPE_CAST; while (b) { if (exp.getKind() == Tree.Kind.PARENTHESIZED) { } else if (exp.getKind() == Tree.Kind.TYPE_CAST) { if (exp.getKind() == Tree.Kind.ARRAY_TYPE) { TypeMirror tm = type; while (tm.getKind() == TypeKind.ARRAY) { } else if (exp.getKind() == Tree.Kind.PRIMITIVE_TYPE) { if (type.getKind().isPrimitive()) { el = controller.getTypes().boxedClass((PrimitiveType) type);
public static List<Long> getLineNumbers(ProcessingEnvironment processingEnv, Element element, AnnotationMirror annotation) { Trees treeUtils = Trees.instance(processingEnv); if (treeUtils == null) { return Collections.emptyList(); TreePath path = treeUtils.getPath(element, annotation); if (path == null) { return Collections.emptyList(); CompilationUnitTree unitTree = path.getCompilationUnit(); LineMap lineMap = unitTree.getLineMap(); SourcePositions positions = treeUtils.getSourcePositions(); AnnotationTree annotationTree = (AnnotationTree) path.getLeaf(); AssignmentTree assignTree = (AssignmentTree) annotationTree.getArguments().get(0); if (exprTree.getKind() == Kind.STRING_LITERAL) { long pos = positions.getStartPosition(unitTree, exprTree); lines.add(lineMap.getLineNumber(pos));
@Override public final Description matchReturn(ReturnTree tree, VisitorState state) { if (tree.getExpression() == null || tree.getExpression().getKind() != NULL_LITERAL) { return NO_MATCH; } TreePath path = state.getPath(); while (path != null && path.getLeaf() instanceof StatementTree) { path = path.getParentPath(); } if (path == null || !(path.getLeaf() instanceof MethodTree)) { return NO_MATCH; } if (!implementsAsyncTypeMethod.matches((MethodTree) path.getLeaf(), state)) { return NO_MATCH; } return describeMatch( tree, SuggestedFix.builder() .replace(tree.getExpression(), "immediateFuture(null)") .addStaticImport(Futures.class.getName() + ".immediateFuture") .build()); }
statement.accept( new SimpleTreeVisitor<ExpressionTree, Void>() { @Override return NO_MATCH; ExpressionTree select = ((MethodInvocationTree) expr).getMethodSelect(); switch (select.getKind()) { case IDENTIFIER: break; case MEMBER_SELECT: ExpressionTree receiver = ((MemberSelectTree) select).getExpression(); if (receiver.getKind() != Kind.IDENTIFIER) { return NO_MATCH; if (!((IdentifierTree) receiver).getName().contentEquals("this")) { return NO_MATCH;
@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) -> Optional.of(generateFix(n, method)) : null; }
TreePath type = new TreePath(getCurrentPath(), tree.getType()); if (type.getLeaf() instanceof ArrayTypeTree) { type = new TreePath(type, ((ArrayTypeTree) type.getLeaf()).getType()); if (type.getLeaf().getKind() == Kind.IDENTIFIER) handlePossibleIdentifier(type, EnumSet.of(UseTypes.CLASS_USE)); Element e = info.getTrees().getElement(getCurrentPath()); if (tree.getInitializer() != null) { uses = EnumSet.of(UseTypes.DECLARATION, UseTypes.WRITE); if (tree.getInitializer().getKind() == Kind.IDENTIFIER) handlePossibleIdentifier(new TreePath(getCurrentPath(), tree.getInitializer()), EnumSet.of(UseTypes.READ)); } else {
if (modifiers.getKind() == Kind.MODIFIERS) { annotations = ((ModifiersTree) modifiers).getAnnotations(); } else if (modifiers.getKind() == Kind.COMPILATION_UNIT) { annotations = ((CompilationUnitTree) modifiers).getPackageAnnotations(); } else { TreePath tp = new TreePath(new TreePath(copy.getCompilationUnit()), at.getAnnotationType()); Element e = copy.getTrees().getElement(tp); ExpressionTree expression; if (et.getKind() == Kind.ASSIGNMENT) { AssignmentTree assignment = (AssignmentTree) et; if (!((IdentifierTree) assignment.getVariable()).getName().contentEquals(attributeName)) continue; if (expression.getKind() == Kind.NEW_ARRAY) { currentValues = ((NewArrayTree) expression).getInitializers(); } else { if (modifiers.getKind() == Kind.MODIFIERS) { return make.addModifiersAnnotation((ModifiersTree) modifiers, newAnnotation); } else if (modifiers.getKind() == Kind.COMPILATION_UNIT) {
@Override public String visitMethodInvocation(MethodInvocationTree node, Void v) { StringBuilder out = new StringBuilder(); List<? extends ExpressionTree> arguments = node.getArguments(); ExpressionTree methodSelect = node.getMethodSelect(); if (methodSelect instanceof IdentifierTree) { skipSymConversion = true; out.append(methodSelect.accept(this, v)); skipSymConversion = false; } else { String ms = methodSelect.accept(this, v); int i = ms.indexOf(".super."); if (methodSelect instanceof JCTree.JCFieldAccess && i > 0) { List<? extends Tree> typeArguments = node.getTypeArguments(); if (!typeArguments.isEmpty()) { out.append("<"); out.append(t.accept(this, v)); out.append(arg.accept(this, v));
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()));
public static boolean IsPropertySetter(CompilationInfo cinfo, StatementTree stmtTree) { if(stmtTree.getKind() == Tree.Kind.EXPRESSION_STATEMENT) { ExpressionStatementTree exprStmtTree = (ExpressionStatementTree)stmtTree; if(exprStmtTree.getExpression().getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree methInvkTree = (MethodInvocationTree)exprStmtTree.getExpression(); if(methInvkTree.getMethodSelect().getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree memSelTree = (MemberSelectTree)methInvkTree.getMethodSelect(); if(methInvkTree.getArguments().size() == 1 && memSelTree.getExpression().getKind() == Tree.Kind.IDENTIFIER) { return true; } } } } return false; }