Refine search
private void variableTypeFix( SuggestedFix.Builder fix, VisitorState state, Class<?> original, Class<?> replacement) { Tree parent = state.getPath().getParentPath().getLeaf(); Symbol sym; switch (parent.getKind()) { case VARIABLE: sym = ASTHelpers.getSymbol((VariableTree) parent); break; case ASSIGNMENT: sym = ASTHelpers.getSymbol(((AssignmentTree) parent).getVariable()); break; default: .getCompilationUnit() .accept( new TreeScanner<Void, Void>() {
@Override public Void visitAssignment(AssignmentTree node, Void unused) { Type lhsType = node.getVariable() instanceof ArrayAccessTree ? ((JCArrayAccess) node.getVariable()).getExpression().type : TreeInfo.symbol((JCTree) node.getVariable()).type; generateConstraintsForWrite(lhsType, node.getExpression(), node); return super.visitAssignment(node, unused); }
private static Optional<ExpressionTree> findArgument( AnnotationTree annotation, String parameter) { for (ExpressionTree argument : annotation.getArguments()) { if (argument.getKind().equals(ASSIGNMENT)) { AssignmentTree assignment = (AssignmentTree) argument; if (assignment.getVariable().toString().equals(parameter)) { return Optional.of(ASTHelpers.stripParentheses(assignment.getExpression())); } } } return Optional.empty(); }
@Override public Void visitAssignment(AssignmentTree node, Void aVoid) { if (symbol.equals(getSymbol(node.getVariable()))) { initializers.add(new TreePath(getCurrentPath(), node.getExpression())); } return super.visitAssignment(node, aVoid); } }.scan(state.getPath().getParentPath(), null);
private void insideAnnotation(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); AnnotationTree ann = (AnnotationTree) path.getLeaf(); CompilationController controller = env.getController(); SourcePositions sourcePositions = env.getSourcePositions(); int typeEndPos = (int) sourcePositions.getEndPosition(root, ann.getAnnotationType()); if (offset <= typeEndPos) { TreePath parentPath = path.getParentPath(); if (parentPath.getLeaf().getKind() == Tree.Kind.MODIFIERS && (parentPath.getParentPath().getLeaf().getKind() != Tree.Kind.VARIABLE || parentPath.getParentPath().getParentPath().getLeaf().getKind() == Tree.Kind.CLASS)) { addKeyword(env, INTERFACE_KEYWORD, SPACE, false); Element annTypeElement = trees.getElement(new TreePath(path, ann.getAnnotationType())); if (annTypeElement != null && annTypeElement.getKind() == ANNOTATION_TYPE) { HashSet<String> names = new HashSet<>(); for (ExpressionTree arg : ann.getArguments()) { if (arg.getKind() == Tree.Kind.ASSIGNMENT && sourcePositions.getEndPosition(root, arg) < offset) { ExpressionTree var = ((AssignmentTree) arg).getVariable(); if (var.getKind() == Tree.Kind.IDENTIFIER) { names.add(((IdentifierTree) var).getName().toString());
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); ExpressionTree exprTree = assignTree.getExpression(); if (exprTree.getKind() == Kind.STRING_LITERAL) { long pos = positions.getStartPosition(unitTree, exprTree); lines.add(lineMap.getLineNumber(pos));
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()); } else if (parent.getKind() == Tree.Kind.ASSIGNMENT && ((AssignmentTree) parent).getExpression() == fa && grandParent != null && grandParent.getKind() == Tree.Kind.ANNOTATION) { if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName()); break; TypeMirror t = trees.getTypeMirror(new TreePath(path, thr)); for (Iterator<TypeMirror> it = exs.iterator(); it.hasNext();) { if (types.isSubtype(it.next(), t)) { case SHORT: case VOID: boolean b = exp.getKind() == Tree.Kind.PARENTHESIZED || exp.getKind() == Tree.Kind.TYPE_CAST;
private void insideExpression(Env env, TreePath exPath) throws IOException { int offset = env.getOffset(); String prefix = env.getPrefix(); Tree et = exPath.getLeaf(); Tree parent = exPath.getParentPath().getLeaf(); final CompilationController controller = env.getController(); int endPos = (int) env.getSourcePositions().getEndPosition(env.getRoot(), et); if (et.getKind() == Tree.Kind.ANNOTATED_TYPE) { et = ((AnnotatedTypeTree) et).getUnderlyingType(); exPath = new TreePath(exPath, et); if (parent.getKind() != Tree.Kind.PARENTHESIZED && (et.getKind() == Tree.Kind.PRIMITIVE_TYPE || et.getKind() == Tree.Kind.ARRAY_TYPE || et.getKind() == Tree.Kind.PARAMETERIZED_TYPE)) { TypeMirror tm = controller.getTrees().getTypeMirror(exPath); final Map<Name, ? extends Element> illegalForwardRefs = env.getForwardReferences(); Scope scope = env.getScope(); if (et.getKind() == Tree.Kind.IDENTIFIER) { Element e = controller.getTrees().getElement(exPath); if (e == null) { return; } else if (et.getKind() == Tree.Kind.ASSIGNMENT) { Tree t = ((AssignmentTree) et).getExpression(); if (t.getKind() == Tree.Kind.PARENTHESIZED && env.getSourcePositions().getEndPosition(env.getRoot(), t) < offset) { exp = ((ParenthesizedTree) t).getExpression();
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; expression = assignment.getExpression(); } else if ("value".equals(attributeName)) { expression = et; 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 Description matchAssignment(AssignmentTree tree, VisitorState state) { Symbol assigned = ASTHelpers.getSymbol(tree.getVariable()); if (assigned == null || assigned.getKind() != ElementKind.FIELD ExpressionTree expression = tree.getExpression(); if (ASTHelpers.constValue(expression) != null) { if (expression.getKind() == Tree.Kind.NULL_LITERAL) { return makeFix(state, fieldDecl, tree, "Assigning null literal to field"); .getNullness(new TreePath(state.getPath(), expression), state.context); if (nullness == null) {
private boolean isLeftSideOfAssignment(IdentifierTree identifierTree) { Tree parent = getCurrentPath().getParentPath().getLeaf(); if (parent instanceof AssignmentTree) { return identifierTree.equals(((AssignmentTree) parent).getVariable()); } return false; } }.scan(compilationUnit, null);
if(isLiteral(valueExpr)){ value = ((LiteralTree)valueExpr).getValue(); }else if(valueExpr.getKind() == Tree.Kind.MEMBER_SELECT) { if(memSelTree.getExpression().getKind() != Tree.Kind.MEMBER_SELECT) { }else if(valueExpr.getKind() == Tree.Kind.METHOD_INVOCATION) { MethodInvocationTree mInvoke = (MethodInvocationTree)valueExpr; ExpressionTree selectTree = mInvoke.getMethodSelect(); String cname = null; Element elem = cinfo.getTrees().getElement(cinfo.getTrees().getPath(cinfo.getCompilationUnit(), memSelTree)); Object object = null; if(elem instanceof ExecutableElement) { Class[] argvt = new Class[count]; java.lang.reflect.Constructor ctor = null; Element elem = cinfo.getTrees().getElement(cinfo.getTrees().getPath(cinfo.getCompilationUnit(), newClassTree)); if(elem instanceof ExecutableElement) { ExecutableElement ctorElem = (ExecutableElement)elem; value = getValue(cinfo, ((TypeCastTree)valueExpr).getExpression()); }else if(valueExpr instanceof AssignmentTree) { value = getValue(cinfo, ((AssignmentTree)valueExpr).getExpression());
ClassTree clazz = null; for (Tree typeDecl : cu.getTypeDecls()) { if (TreeUtilities.CLASS_TREE_KINDS.contains(typeDecl.getKind())) { ClassTree candidate = (ClassTree) typeDecl; if (candidate.getModifiers().getFlags().contains(javax.lang.model.element.Modifier.PUBLIC)) { if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; String type = variable.getType().toString(); if (clMember.getKind() == Tree.Kind.METHOD) { MethodTree method = (MethodTree)clMember; String methodName = method.getName().toString(); if (statement.getKind() != Tree.Kind.EXPRESSION_STATEMENT) continue; ExpressionTree expression = ((ExpressionStatementTree)statement).getExpression(); if (expression.getKind() != Tree.Kind.ASSIGNMENT) continue; AssignmentTree assignment = (AssignmentTree)expression; String parName = assignment.getExpression().toString(); VariableTree parameter = method.getParameters().get(0); if (!parameter.getName().toString().equals(parName)) continue; ExpressionTree persistentVariable = assignment.getVariable();
@Override public boolean matches(Tree tree, VisitorState visitorState) { if (tree instanceof AssignmentTree) { return variableExpressionTree .toString() .equals(((AssignmentTree) tree).getVariable().toString()); } return false; } }
@Override public Void visitAssignment(AssignmentTree node, Boolean p) { Element el = trees.getElement(new TreePath(getCurrentPath(), node.getVariable())); fields.remove(el); return null; } @Override
ModifiersTree modifiers = ((ClassTree) wc.getTrees().getTree(element)).getModifiers(); AnnotationTree annotationTree = (AnnotationTree) wc.getTrees().getTree(element, annotation); List<ExpressionTree> arguments = new ArrayList<>(); for (ExpressionTree expressionTree : annotationTree.getArguments()) { if (expressionTree.getKind() == Tree.Kind.ASSIGNMENT) { AssignmentTree at = (AssignmentTree) expressionTree; String varName = ((IdentifierTree) at.getVariable()).getName().toString(); if (varName.equals("name")) { //NOI18N ExpressionTree valueTree = make.Identifier(at.getExpression().toString()); arguments.add(valueTree); ModifiersTree newModifiersTree = make.removeModifiersAnnotation(modifiers, (AnnotationTree) wc.getTrees().getTree(element, annotation)); AnnotationTree newTree = GenerationUtils.newInstance(wc).createAnnotation(replacingClass, arguments); newModifiersTree = make.addModifiersAnnotation(newModifiersTree, newTree);
SuggestedFix.builder().setShortDescription("remove unused variable and any side effects"); for (TreePath usagePath : usagePaths) { StatementTree statement = (StatementTree) usagePath.getLeaf(); if (statement.getKind() == Kind.VARIABLE) { VariableTree variableTree = (VariableTree) statement; ExpressionTree initializer = variableTree.getInitializer(); if (hasSideEffect(initializer) && TOP_LEVEL_EXPRESSIONS.contains(initializer.getKind())) { encounteredSideEffects = true; if (varKind == ElementKind.FIELD) { if (hasSideEffect(((AssignmentTree) tree).getExpression())) { encounteredSideEffects = true; fix.replace(
public Boolean visitAssignment(AssignmentTree node, TreePath p) { if (p == null) return super.visitAssignment(node, p); AssignmentTree at = (AssignmentTree) p.getLeaf(); boolean result = scan(node.getExpression(), at.getExpression(), p); return result && scan(node.getVariable(), at.getVariable(), p); }
@Override public String visitAssignment(AssignmentTree node, Void v) { StringBuilder out = new StringBuilder(); ExpressionTree variable = node.getVariable(); ExpressionTree expression = node.getExpression(); out.append(variable.accept(this, v)); out.append(" = "); out.append(expression.accept(this, v)); return out.toString(); }
private int setupLimit(Tree t) { int pos = ((JCTree)t).pos; Tree child; switch (t.getKind()) { child = ((AssignmentTree)t).getVariable(); break;