@Override public Choice<State<JCVariableDecl>> visitVariable(final VariableTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getInitializer(), s), init -> maker() .VarDef( (JCModifiers) node.getModifiers(), (Name) node.getName(), (JCExpression) node.getType(), init)); }
private static boolean isValidParameterTree(VariableTree variableTree) { // A valid parameter has no initializer. if (variableTree.getInitializer() != null) { return false; } // A valid parameter either has no modifiers or has only `final` keyword. Set<Modifier> flags = variableTree.getModifiers().getFlags(); return flags.isEmpty() || (flags.size() == 1 && flags.contains(Modifier.FINAL)); }
@Override public UVariableDecl visitVariable(VariableTree tree, Void v) { return UVariableDecl.create( tree.getName(), templateType(tree.getType()), (tree.getInitializer() == null) ? null : template(tree.getInitializer())); }
private static Token<JavaTokenId> findIdentifierSpanImpl(CompilationInfo info, TreePath decl) { if (info.getTreeUtilities().isSynthetic(decl)) return null; Tree leaf = decl.getLeaf(); if (class2Kind.get(MethodTree.class).contains(leaf.getKind())) { MethodTree method = (MethodTree) leaf; List<Tree> rightTrees = new ArrayList<Tree>(); Name name = method.getName(); if (method.getReturnType() == null) name = ((ClassTree) decl.getParentPath().getLeaf()).getSimpleName(); return findIdentifierSpanImpl(info, leaf, method.getReturnType(), rightTrees, name.toString(), info.getCompilationUnit(), info.getTrees().getSourcePositions()); if (class2Kind.get(VariableTree.class).contains(leaf.getKind())) { VariableTree var = (VariableTree) leaf; boolean typeSynthetic = var.getType() == null || info.getTreeUtilities().isSynthetic(new TreePath(decl, var.getType())); return findIdentifierSpanImpl(info, leaf, typeSynthetic ? null : var.getType(), Collections.singletonList(var.getInitializer()), var.getName().toString(), info.getCompilationUnit(), info.getTrees().getSourcePositions()); if (class2Kind.get(MemberSelectTree.class).contains(leaf.getKind())) { return findIdentifierSpanImpl(info, (MemberSelectTree) leaf, info.getCompilationUnit(), info.getTrees().getSourcePositions()); if (class2Kind.get(MemberReferenceTree.class).contains(leaf.getKind())) {
@Override public void run(WorkingCopy wc) throws Exception { wc.toPhase(JavaSource.Phase.RESOLVED); CompilationUnitTree cu = wc.getCompilationUnit(); 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)) { for (Tree member : clazz.getMembers()) { idx++; if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; fields.add(variable.getName().toString()); fieldIndex = idx; } else if (Tree.Kind.METHOD == member.getKind()) { MethodTree method = (MethodTree)member; methods.add(method.getName().toString()); TreeMaker make = wc.getTreeMaker(); TypeElement cascadeTypeElement = wc.getElements().getTypeElement("javax.persistence.CascadeType"); // NOI18N AssignmentTree cascadeParameter = make.Assignment(make.Identifier("cascade"), make.MemberSelect(make.QualIdent(cascadeTypeElement),"ALL")); // NOI18N AssignmentTree mappedByParameter = make.Assignment(make.Identifier("mappedBy"), make.Literal(df[0])); // NOI18N List<ExpressionTree> parameters = new ArrayList<ExpressionTree>();
TreePath fieldDeclPath = Trees.instance(javacEnv).getPath(accessed.symbol); || fieldDeclPath.getCompilationUnit() != compilationUnit || !(fieldDeclPath.getLeaf() instanceof VariableTree)) { return null; ExpressionTree initializer = ((VariableTree) fieldDeclPath.getLeaf()).getInitializer(); if (initializer == null) { return null;
@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; }
if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; String type = variable.getType().toString(); if (type.endsWith("PropertyChangeSupport")) { // NOI18N alreadyUpdated[0] = true; TreeMaker make = wc.getTreeMaker(); ClassTree modifiedClass = clazz; Tree transientType = make.Type(transientMirror); AnnotationTree transientTree = make.Annotation(transientType, Collections.EMPTY_LIST); ModifiersTree modifiers = make.Modifiers(Modifier.PRIVATE, Collections.singletonList(transientTree)); BlockTree block = method.getBody(); if (block.getStatements().size() != 1) continue; StatementTree statement = block.getStatements().get(0); if (!parameter.getName().toString().equals(parName)) continue; ExpressionTree persistentVariable = assignment.getVariable(); String parameterName = parameter.getName().toString(); String oldParameterName = "old" + Character.toUpperCase(parameterName.charAt(0)) + parameterName.substring(1); // NOI18N Tree parameterTree = parameter.getType();
switch (node.getKind()) { case VARIABLE: { VariableTree t = (VariableTree) node; @SuppressWarnings("unchecked") N clone = (N) Variable( t.getModifiers(), t.getName(), t.getType(), initializer ); MethodTree t = (MethodTree) node; @SuppressWarnings("unchecked") N clone = (N) Method( t.getModifiers(), t.getName(), t.getReturnType(), t.getTypeParameters(), t.getParameters(), throw new IllegalArgumentException("Invalid kind " + node.getKind());
String prefix = env.getPrefix(); TreePath path = env.getPath(); MemberSelectTree fa = (MemberSelectTree) path.getLeaf(); CompilationController controller = env.getController(); CompilationUnitTree root = env.getRoot(); insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); TypeMirror type = controller.getTrees().getTypeMirror(expPath); if (type != null) { Element el = controller.getTrees().getElement(expPath); EnumSet<ElementKind> kinds; DeclaredType baseType = null; } else if (parent.getKind() == Tree.Kind.VARIABLE && ((VariableTree) parent).getType() == fa) { kinds = EnumSet.of(CLASS, ENUM, ANNOTATION_TYPE, INTERFACE); break; TypeMirror t = trees.getTypeMirror(new TreePath(path, thr)); for (Iterator<TypeMirror> it = exs.iterator(); it.hasNext();) { if (types.isSubtype(it.next(), t)) {
if (tree.getType() != null) { TreePath type = new TreePath(getCurrentPath(), tree.getType()); 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 (e != null && e.getKind() == ElementKind.FIELD) { scan(tree.getModifiers(), null); tl.moveToEnd(tree.getModifiers()); scan(tree.getType(), null); int[] span = info.getTreeUtilities().findNameSpan(tree); if (span != null) tl.moveToOffset(span[0]); else tl.moveToEnd(tree.getType()); firstIdentifier(tree.getName().toString()); scan(tree.getInitializer(), EnumSet.of(UseTypes.READ));
@Override public void run(WorkingCopy wc) throws Exception { wc.toPhase(JavaSource.Phase.RESOLVED); CompilationUnitTree cu = wc.getCompilationUnit(); 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)) { TreeMaker make = wc.getTreeMaker(); ModifiersTree parMods = make.Modifiers(Collections.EMPTY_SET, Collections.EMPTY_LIST); TypeElement changeListenerElement = wc.getElements().getTypeElement("java.beans.PropertyChangeListener"); // NOI18N VariableTree par = make.Variable(parMods, "listener", make.QualIdent(changeListenerElement), null); // NOI18N TypeElement changeSupportElement = wc.getElements().getTypeElement("java.beans.PropertyChangeSupport"); // NOI18N VariableTree changeSupport = make.Variable(parMods, "changeSupport", make.QualIdent(changeSupportElement), null); // NOI18N MemberSelectTree addCall = make.MemberSelect(make.Identifier(changeSupport.getName()), "addPropertyChangeListener"); // NOI18N MethodInvocationTree addInvocation = make.MethodInvocation(Collections.EMPTY_LIST, addCall, Collections.singletonList(make.Identifier(par.getName()))); MethodTree addMethod = make.Method( make.Modifiers(Modifier.PUBLIC, Collections.EMPTY_LIST),
Tree tree = currentPath.getLeaf(); TypeElement te; if (TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())) { te = (TypeElement) ci.getTrees().getElement(currentPath); } else { Scope scope = ci.getTreeUtilities().scopeFor(currentOffset); Tree tree = path != null ? path.getLeaf() : null; while (tree != null && !(tree instanceof MethodTree || tree instanceof ClassTree)) { path = path.getParentPath(); String name = ((MethodTree)tree).getName().toString(); if (name.equals("<init>") && scope.getEnclosingClass() != null) { name = scope.getEnclosingClass().getSimpleName().toString(); Tree tree = tp.getLeaf(); if (selectedIdentifier == null) { while (tree.getKind() != Tree.Kind.VARIABLE) { tp = tp.getParentPath(); if (tp == null) { el = ci.getTrees().getElement(ci.getTrees().getPath(ci.getCompilationUnit(), tree)); if (el != null && (el.getKind() == ElementKind.FIELD || el.getKind() == ElementKind.ENUM_CONSTANT)) { currentElementPtr[0] = ((VariableTree) tree).getName().toString(); } else if (tree.getKind() == Tree.Kind.IDENTIFIER && selectedIdentifier != null) {
} else if (path.getLeaf() instanceof TryTree && !((TryTree) path.getLeaf()).getCatches().isEmpty()) { tryTree = (TryTree) path.getLeaf(); catches.put(ASTHelpers.getType(c.getParameter().getType()), c); Tree lastType = last.getParameter().getType(); if (lastType.getKind() == Tree.Kind.UNION_TYPE) { Type roe = state.getTypeFromString(ReflectiveOperationException.class.getName()); Set<String> exceptions = new LinkedHashSet<>(); String name = last.getParameter().getName().toString(); fix.postfixWith( last, if (newInstanceInCatch.get()) { fix.replace( Iterables.getLast(result.handles.values()).getParameter().getType(), "ReflectiveOperationException"); return true; for (CatchTree ct : result.handles.values()) { if (first) { fix.replace(ct.getParameter().getType(), "ReflectiveOperationException"); first = false; } else {
Scope scope = controller.getTrees().getScope(path); break; case METHOD: stmts = ((MethodTree) path.getLeaf()).getParameters(); break; case SWITCH: break; case ARROW: scope = controller.getTrees().getScope(blockPath); scope = tu.reattributeTreeTo(block, scope, lambdaBody); return new Env(offset, prefix, controller, path, sourcePositions, scope); && parent != null && parent.getKind() == Tree.Kind.VARIABLE && unwrapErrTree(((VariableTree) parent).getInitializer()) == tree) { if (tu.isEnum((ClassTree) grandParent)) { controller.toPhase(JavaSource.Phase.RESOLVED); && ((VariableTree) tree).getInitializer() != null && orig == path && sourcePositions.getStartPosition(root, ((VariableTree) tree).getInitializer()) >= 0 && sourcePositions.getStartPosition(root, ((VariableTree) tree).getInitializer()) <= offset) { controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); tree = ((VariableTree) tree).getInitializer();
switch(path.getLeaf().getKind()) { case VARIABLE: el = trees.getElement(path); if (el != null) { refs.add(el); TreePath parent = path.getParentPath(); if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getLeaf().getKind())) { boolean isStatic = ((VariableTree)path.getLeaf()).getModifiers().getFlags().contains(Modifier.STATIC); for(Tree member : ((ClassTree)parent.getLeaf()).getMembers()) { if (member.getKind() == Tree.Kind.VARIABLE && sourcePositions.getStartPosition(path.getCompilationUnit(), member) >= pos && (isStatic || !((VariableTree)member).getModifiers().getFlags().contains(Modifier.STATIC))) { el = trees.getElement(new TreePath(parent, member)); if (el != null) { refs.add(el); EnhancedForLoopTree efl = (EnhancedForLoopTree)path.getLeaf(); if (sourcePositions.getEndPosition(path.getCompilationUnit(), efl.getExpression()) >= pos) { el = trees.getElement(new TreePath(path, efl.getVariable())); if (el != null) { refs.add(el);
Trees trees = Trees.instance(processingEnv); ClassTree tree = trees.getTree(el); if (member.getKind() == Tree.Kind.METHOD) { MethodTree m = (MethodTree) member; if (m.getName().toString().equals("<init>")) { BlockTree body = m.getBody(); List<? extends StatementTree> b = body.getStatements(); if (member.getKind() == Tree.Kind.VARIABLE) { VariableTree t = (VariableTree) member; if (t.getInitializer() != null) return false; if (member.getKind() == Tree.Kind.BLOCK) {
ElementKind varKind = ElementKind.LOCAL_VARIABLE; Set<Modifier> varMods = EnumSet.noneOf(Modifier.class); if (parent.getKind() == Tree.Kind.VARIABLE) { varMods = ((VariableTree) parent).getModifiers().getFlags(); Element varEl = controller.getTrees().getElement(exPath.getParentPath()); if (varEl != null) { varKind = varEl.getKind(); 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;
@Override public Description matchNewClass(NewClassTree newClassTree, VisitorState state) { if (state.getPath().getParentPath().getLeaf().getKind() != Kind.EXPRESSION_STATEMENT) { return Description.NO_MATCH; switch (def.getKind()) { case VARIABLE: if (variableTree.getInitializer() != null) { return Description.NO_MATCH;