Refine search
@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; }
Set<Modifier> mods = node.getModifiers().getFlags(); if (!mods.contains(Modifier.PRIVATE) && !mods.contains(Modifier.PROTECTED) && List<? extends Tree> members = node.getMembers(); for (Tree m : members) { if (m.getKind() == Tree.Kind.CLASS) { reportError("no.nested.class", m); if (m.getKind() == Tree.Kind.VARIABLE) { VariableTree vt = (VariableTree)m; boolean isStatic = isStatic(vt.getModifiers().getFlags()); if (shortSyntax) { if (isStatic) { Tree superClass = node.getExtendsClause(); if (superClass != null) { String name = superClass.toString(); ModifiersTree mt = node.getModifiers(); if (!shortSyntax && ! isPublic(mt.getFlags())) { reportError("class.should.be.public", node); List<? extends AnnotationTree> anno = mt.getAnnotations(); if (anno != null && !anno.isEmpty()) { String btrace = BTrace.class.getName();
flags.addAll(classTree.getModifiers().getFlags()); boolean wasFinal = flags.remove(FINAL); boolean wasAbstract = !flags.add(ABSTRACT); if (classTree.getKind().equals(INTERFACE) || (!wasFinal && wasAbstract)) { return SuggestedFix.builder(); // no-op for (AnnotationTree annotation : classTree.getModifiers().getAnnotations()) { modifiers.add(state.getSourceForNode(annotation));
if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) { ClassTree classT = (ClassTree) t; if (sourceFile.getName().equals(classT.getSimpleName().toString())) { classTree = classT; break; TypeElement classEl = (TypeElement) trees.getElement(trees.getPath(cut, classTree)); MethodTree method = null; ExecutableElement methodEl = null; && el.getModifiers().contains(Modifier.PUBLIC)) { MethodTree mt = trees.getTree(el); for (AnnotationTree at : mt.getModifiers().getAnnotations()) { TypeElement annEl = (TypeElement) trees.getElement( trees.getPath(cut, at.getAnnotationType())); BlockTree body = method.getBody(); SourcePositions sp = trees.getSourcePositions(); int start = (int) sp.getStartPosition(cut, body); method.getModifiers(), method.getName(), make.QualIdent(workingCopy.getElements().getTypeElement("org.jdesktop.application.Task")), // NOI18N
@Override public String visitMethod(MethodTree node, Void v) { StringBuilder out = new StringBuilder(); BlockTree body = node.getBody(); ModifiersTree modifiers = node.getModifiers(); String name = node.getName().toString(); List<? extends VariableTree> parameters = node.getParameters(); Tree returnType = node.getReturnType(); out.append(modifiers.accept(this, v)); if (name.equals("<init>")) { if (isEnum && !modifiers.getFlags().contains(Modifier.PRIVATE)) { out.append("private "); out.append(t.accept(this, v)); out.append(par.accept(this, v)); if (returnType != null) { out.append(" : "); out.append(returnType.accept(this, v)); if (defaultValue != null) { out.append(" = "); out.append(defaultValue.accept(this, v));
private void insideMethod(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); MethodTree mth = (MethodTree) path.getLeaf(); CompilationController controller = env.getController(); SourcePositions sourcePositions = env.getSourcePositions(); Tree lastTree = null; int state = 0; for (Tree thr : mth.getThrows()) { int thrPos = (int) sourcePositions.getEndPosition(root, thr); if (thrPos == Diagnostic.NOPOS || offset <= thrPos) { for (VariableTree param : mth.getParameters()) { int parPos = (int) sourcePositions.getEndPosition(root, param); if (parPos == Diagnostic.NOPOS || offset <= parPos) { Tree retType = mth.getReturnType(); if (retType != null) { int retPos = (int) sourcePositions.getEndPosition(root, retType); TypeMirror t = trees.getTypeMirror(new TreePath(path, thr)); for (Iterator<TypeMirror> it = exs.iterator(); it.hasNext();) { if (types.isSubtype(it.next(), t)) { addMemberModifiers(env, mth.getModifiers().getFlags(), false); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); break;
@Override public boolean apply(Tree tree) { switch (tree.getKind()) { case CLASS: return ((ClassTree) tree).getModifiers().getFlags().contains(STATIC); case METHOD: return ((MethodTree) tree).getModifiers().getFlags().contains(STATIC); case VARIABLE: return ((VariableTree) tree).getModifiers().getFlags().contains(STATIC); case BLOCK: return ((BlockTree) tree).isStatic(); case ENUM: case ANNOTATION_TYPE: case INTERFACE: return true; default: throw new AssertionError("unknown member type:" + tree.getKind()); } } });
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);
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)) { clazz = candidate; break; for (Tree member : clazz.getMembers()) { if (Tree.Kind.VARIABLE == member.getKind()) { VariableTree variable = (VariableTree)member; String type = variable.getType().toString(); if (type.endsWith("PropertyChangeSupport")) { // NOI18N alreadyUpdated[0] = true; BlockTree block = method.getBody(); if (block.getStatements().size() != 1) continue; StatementTree statement = block.getStatements().get(0); String parName = assignment.getExpression().toString(); VariableTree parameter = method.getParameters().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();
for (Tree impl : cls.getImplementsClause()) { int implPos = (int) sourcePositions.getEndPosition(root, impl); if (implPos == Diagnostic.NOPOS || offset <= implPos) { if (last != null && last.token().id() == JavaTokenId.COMMA) { controller.toPhase(Phase.ELEMENTS_RESOLVED); env.addToExcludes(controller.getTrees().getElement(path)); addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null); Tree ext = cls.getExtendsClause(); if (ext != null) { int extPos = (int) sourcePositions.getEndPosition(root, ext); if (last != null && last.token().id() == JavaTokenId.IMPLEMENTS) { controller.toPhase(Phase.ELEMENTS_RESOLVED); env.addToExcludes(controller.getTrees().getElement(path)); addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null); } else { addKeyword(env, INTERFACE_KEYWORD, SPACE, false); addTypes(env, EnumSet.of(ANNOTATION_TYPE), null); } else if (path.getParentPath().getLeaf().getKind() == Tree.Kind.COMPILATION_UNIT) { addClassModifiers(env, cls.getModifiers().getFlags()); } else { addMemberModifiers(env, cls.getModifiers().getFlags(), false); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null);
return; for (Tree clMember : clazz.getMembers()) { if (clMember.getKind() == Tree.Kind.METHOD) { MethodTree method = (MethodTree)clMember; if (!method.getParameters().isEmpty()) continue; Set<javax.lang.model.element.Modifier> modifiers = method.getModifiers().getFlags(); if (modifiers.contains(javax.lang.model.element.Modifier.STATIC) || !modifiers.contains(javax.lang.model.element.Modifier.PUBLIC)) { continue; String methodName = method.getName().toString(); Tree returnType = method.getReturnType(); propName = methodName.substring(3); } else if (methodName.startsWith("is")) { // NOI18N if ((returnType.getKind() == Tree.Kind.PRIMITIVE_TYPE) && (((PrimitiveTypeTree)returnType).getPrimitiveTypeKind() == TypeKind.BOOLEAN)) { propName = methodName.substring(2); Tree superTree = clazz.getExtendsClause(); TypeHelper type = treeToType(cc, superTree, formModel); String typeName = type.getName();
private void insideVariable(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); VariableTree var = (VariableTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); Tree type = var.getType(); int typePos = type.getKind() == Tree.Kind.ERRONEOUS && ((ErroneousTree) type).getErrorTrees().isEmpty() ? (int) sourcePositions.getEndPosition(root, type) : (int) sourcePositions.getStartPosition(root, type); if (offset <= typePos) { Tree parent = path.getParentPath().getLeaf(); if (parent.getKind() == Tree.Kind.CATCH) { CompilationController controller = env.getController(); if (!options.contains(Options.ALL_COMPLETION)) { addTypes(env, EnumSet.of(CLASS, INTERFACE, TYPE_PARAMETER), controller.getTypes().getDeclaredType(te)); } else if (parent.getKind() == Tree.Kind.TRY) { CompilationController controller = env.getController(); TypeElement te = controller.getElements().getTypeElement("java.lang.AutoCloseable"); //NOI18N boolean isLocal = !TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()); addMemberModifiers(env, var.getModifiers().getFlags(), isLocal); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); ModifiersTree mods = var.getModifiers(); if (mods.getFlags().isEmpty() && mods.getAnnotations().isEmpty()) { addElementCreators(env);
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)) { clazz = candidate; break; Set<String> methods = new HashSet<String>(); Set<String> fields = new HashSet<String>(); 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());
@Override protected Iterable<? extends AnnotationTree> getChildNodes(T tree, VisitorState state) { if (tree instanceof ClassTree) { return ((ClassTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof VariableTree) { return ((VariableTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof MethodTree) { return ((MethodTree) tree).getModifiers().getAnnotations(); } else if (tree instanceof CompilationUnitTree) { return ((CompilationUnitTree) tree).getPackageAnnotations(); } else if (tree instanceof AnnotatedTypeTree) { return ((AnnotatedTypeTree) tree).getAnnotations(); } else if (tree instanceof PackageTree) { return ((PackageTree) tree).getAnnotations(); } else { throw new IllegalArgumentException( "Cannot access annotations from tree of type " + tree.getClass()); } } }
Name name = node.getSimpleName(); List<? extends TypeParameterTree> typeParameters = node.getTypeParameters(); String declType; Tree.Kind kind = node.getKind(); isEnum = false; isInterface = false; ModifiersTree modifiers = node.getModifiers(); out.append(modifiers.accept(this, v)); out.append(declType); out.append(" "); out.append(t.accept(this, v)); if (extendsClause != null) { out.append("extends "); out.append(extendsClause.accept(this, v)); out.append(" "); for (Tree implement : implementsClause) { if (first) { out.append(implement.accept(this, v)); first = false; } else {
int lastPos = getStartPosition(last); int currentIndent = getCurrentIndent(last, path); switch (last.getKind()) { case COMPILATION_UNIT: break; for (Tree member : ((ClassTree)last).getMembers()) { if (getEndPosition(member) > startOffset) { break; switch (prevTokenId) { case LBRACE: if (path.get(1).getKind() == Kind.NEW_CLASS && isLeftBraceOnNewLine(lastPos, startOffset)) { switch (cs.getClassDeclBracePlacement()) { case SAME_LINE: currentIndent = getMultilineIndent(((ClassTree)last).getImplementsClause(), path, token.offset(), currentIndent, cs.alignMultilineImplements(), true); break; case IDENTIFIER: last = ((VariableTree)last).getModifiers(); if (last == null) break; for (Tree ann : ((ModifiersTree)last).getAnnotations()) { if (getEndPosition(ann) > startOffset) { break;
@Override public String visitVariable(VariableTree node, Void v) { StringBuilder out = new StringBuilder(); String name = node.getName().toString(); ExpressionTree initializer = node.getInitializer(); if (mode != Mode.CLASS_VAR && !isAEnumConstant(node)) { name = symTable.addLocally(name); ModifiersTree modifiers = node.getModifiers(); out.append(modifiers.accept(this, v)); Tree type = node.getType(); String varType = type == null ? "" : type.accept(this, v); skipSymConversion = false; String iniz = null;
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;
TypeElement typeElement = SourceUtils.classTree2TypeElement(copy, classTree); if (typeElement == null) { throw new IllegalArgumentException("No TypeElement for ClassTree " + classTree.getSimpleName()); MethodTree constructorTree = constructor != null ? copy.getTrees().getTree(constructor) : null; MethodTree newConstructorTree = null; TreeMaker make = getTreeMaker(); if (constructor != null) { if (!constructor.getModifiers().contains(Modifier.PUBLIC)) { ModifiersTree oldModifiersTree = constructorTree.getModifiers(); Set<Modifier> newModifiers = EnumSet.of(Modifier.PUBLIC); for (Modifier modifier : oldModifiersTree.getFlags()) { if (!Modifier.PROTECTED.equals(modifier) && !Modifier.PRIVATE.equals(modifier)) { newModifiers.add(modifier); constructorTree.getTypeParameters(), constructorTree.getParameters(), constructorTree.getThrows(), constructorTree.getBody());
CodeStyle codeStyle = DiffContext.getCodeStyle(copy); ClassMemberComparator comparator = new ClassMemberComparator(codeStyle); SourcePositions sp = copy.getTrees().getSourcePositions(); TreeUtilities utils = copy.getTreeUtilities(); CompilationUnitTree compilationUnit = copy.getCompilationUnit(); if (member.getKind() == Tree.Kind.VARIABLE) { v = new FieldRefVisitor(clazz, vt.getModifiers().getFlags().contains(Modifier.STATIC)); v.registerTreeName(member, vt.getName()); if (member.getKind() == Tree.Kind.BLOCK) { v = new FieldRefVisitor(clazz, ((BlockTree)member).isStatic()); TreePath classTP = new TreePath(new TreePath(compilationUnit), clazz); v.scan(classTP, null); continue; minIndex = Math.max(minIndex, 1 + clazz.getMembers().indexOf(t)); maxIndex = Math.min(maxIndex, clazz.getMembers().indexOf(t)); for (Tree tree : clazz.getMembers()) { if (!utils.isSynthetic(compilationUnit, tree)) { if (gsnames != null && gsidx < 0) {