Refine search
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); Tree superClass = node.getExtendsClause(); if (superClass != null) { String name = superClass.toString(); List<? extends Tree> interfaces = node.getImplementsClause(); if (interfaces != null && interfaces.size() > 0) { reportError("no.interface.implementation", interfaces.get(0)); ModifiersTree mt = node.getModifiers(); if (!shortSyntax && ! isPublic(mt.getFlags())) { reportError("class.should.be.public", node); String oldClassName = className; try { className = node.getSimpleName().toString(); fqn = getElement(node).asType().toString(); return super.visitClass(node, v);
@Override public Description matchClass(ClassTree tree, VisitorState state) { if (tree.getTypeParameters().isEmpty()) { return Description.NO_MATCH; } return findDuplicatesOf(tree, tree.getTypeParameters(), state); }
@Override public Description matchClass(ClassTree classTree, VisitorState state) { if (!classTree.getKind().equals(CLASS) || classTree.getExtendsClause() != null || !classTree.getImplementsClause().isEmpty() || isInPrivateScope(state) || hasAnnotation(getSymbol(classTree), "org.junit.runner.RunWith", state)) { FluentIterable.from(classTree.getMembers()) .filter( Predicates.not( classTree, addMembers(classTree, state, "private " + classTree.getSimpleName() + "() {}"));
@Override public Description matchClass(ClassTree tree, VisitorState state) { return handle(tree, tree.getSimpleName(), tree.getModifiers(), state); }
private static boolean matchAnySuperType(ClassTree tree, VisitorState state) { List<Tree> superTypes = Lists.<Tree>newArrayList(tree.getImplementsClause()); Tree superClass = tree.getExtendsClause(); if (superClass != null) { superTypes.add(superClass); } return superTypes.stream() .anyMatch(superType -> COMPARABLE_AND_COMPARATOR_MATCHER.matches(superType, state)); }
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 (((JCModifiers) classTree.getModifiers()).pos == -1) { makeAbstract.prefixWith(classTree, Joiner.on(' ').join(modifiers.build())); } else { makeAbstract.replace(classTree.getModifiers(), Joiner.on(' ').join(modifiers.build()));
return null; Tree leaf = decl.getLeaf(); 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; 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())) { if (class2Kind.get(ClassTree.class).contains(leaf.getKind())) { String name = ((ClassTree) leaf).getSimpleName().toString(); SourcePositions positions = info.getTrees().getSourcePositions(); CompilationUnitTree cu = info.getCompilationUnit(); ModifiersTree mods = ((ClassTree) leaf).getModifiers();
for (Tree t : tree.getThrows()) { TreePath tp = new TreePath(getCurrentPath(), t); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.CLASS_USE)); Element el = info.getTrees().getElement(getCurrentPath()); scan(tree.getModifiers(), null); tl.moveToEnd(tree.getModifiers()); scan(tree.getTypeParameters(), null); tl.moveToEnd(tree.getTypeParameters()); while (tp != null && !TreeUtilities.CLASS_TREE_KINDS.contains(tp.getLeaf().getKind())) { tp = tp.getParentPath(); if (tp != null && TreeUtilities.CLASS_TREE_KINDS.contains(tp.getLeaf().getKind())) { name = ((ClassTree) tp.getLeaf()).getSimpleName().toString(); } else { name = null;
private ClassTree modifyClassTypeParameter(ClassTree clazz, int index, TypeParameterTree typeParameter, Operation op) { ClassTree copy = Class( clazz.getModifiers(), clazz.getSimpleName(), c(clazz.getTypeParameters(), index, typeParameter, op), clazz.getExtendsClause(), (List<ExpressionTree>) clazz.getImplementsClause(), clazz.getMembers() ); return copy; }
insideExpression(env, new TreePath(path, fa.getExpression())); TreePath parentPath = path.getParentPath(); boolean inImport = false; boolean insideNew = false; if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && ((ClassTree) parent).getExtendsClause() == fa) { kinds = EnumSet.of(CLASS); env.afterExtends(); } else if (TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && ((ClassTree) parent).getImplementsClause().contains(fa)) { kinds = EnumSet.of(INTERFACE); } else if (parent.getKind() == Tree.Kind.IMPORT) { inImport = true; kinds = ((ImportTree) parent).isStatic() ? EnumSet.of(CLASS, ENUM, INTERFACE, ANNOTATION_TYPE, FIELD, METHOD, ENUM_CONSTANT) : EnumSet.of(CLASS, ANNOTATION_TYPE, ENUM, INTERFACE); } 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)) {
Tree prev = state.getPath().getLeaf(); for (Tree curr : state.getPath().getParentPath()) { switch (curr.getKind()) { case BLOCK: for (StatementTree stmt : ((BlockTree) curr).getStatements()) { for (VariableTree param : ((MethodTree) curr).getParameters()) { result.add(ASTHelpers.getSymbol(param)); for (Tree member : ((ClassTree) curr).getMembers()) { if (member.equals(prev)) { break; for (ImportTree importTree : ((CompilationUnitTree) curr).getImports()) { if (importTree.isStatic() && importTree.getQualifiedIdentifier().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree memberSelectTree = (MemberSelectTree) importTree.getQualifiedIdentifier();
@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()); } } });
@Override public Void visitClass(ClassTree t, Void v) { if (variableElement == null) { // try to find the component's field variable in the class List<? extends Tree> members = (List<? extends Tree>) t.getMembers(); Iterator<? extends Tree> it = members.iterator(); while(it.hasNext()){ Tree tr = it.next(); if (tr.getKind() == Tree.Kind.VARIABLE) { Trees trees = info.getTrees(); TreePath path = new TreePath(getCurrentPath(), tr); Element el = trees.getElement(path); if (el != null) { // Issue 185420 String sname = el.getSimpleName().toString(); if(sname.equals(this.member)){ this.handle = TreePathHandle.create(path, info); variableElement = el; if (findUsages) { usagesPositions = new ArrayList<Integer>(); } } } } } } if (findUsages) { super.visitClass(t, v); } return null; }
if (typePath != null && typePath.getParentPath().getLeaf().getKind() == Kind.METHOD) { MethodTree decl = (MethodTree) typePath.getParentPath().getLeaf(); Tree type = decl.getReturnType(); && isIn(cu, info.getTrees().getSourcePositions(), type, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); if (typePath != null && ((typePath.getParentPath().getLeaf().getKind() == Kind.UNION_TYPE && typePath.getParentPath().getParentPath().getLeaf().getKind() == Kind.VARIABLE && typePath.getParentPath().getParentPath().getParentPath().getLeaf().getKind() == Kind.CATCH) if (typePath != null && TreeUtilities.CLASS_TREE_KINDS.contains(typePath.getParentPath().getLeaf().getKind())) { ClassTree ctree = (ClassTree) typePath.getParentPath().getLeaf(); int bodyStart = Utilities.findBodyStart(info, ctree, cu, info.getTrees().getSourcePositions(), doc); boolean isExtends = ctree.getExtendsClause() == typePath.getLeaf(); boolean isImplements = false; for (Tree t : ctree.getImplementsClause()) { if (t == typePath.getLeaf()) { isImplements = true; Tree superClass = ((ClassTree) tp.getLeaf()).getExtendsClause(); List<? extends Tree> superClasses = ((ClassTree) tp.getLeaf()).getImplementsClause();
@Override public Void visitClass(ClassTree tree, EnumSet<UseTypes> d) { tl.moveToOffset(sourcePositions.getStartPosition(info.getCompilationUnit(), tree)); for (TypeParameterTree t : tree.getTypeParameters()) { for (Tree bound : t.getBounds()) { TreePath tp = new TreePath(new TreePath(getCurrentPath(), t), bound); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.CLASS_USE)); if(getCurrentPath().getParentPath().getLeaf().getKind() != Kind.NEW_CLASS) { Tree extnds = tree.getExtendsClause(); for (Tree t : tree.getImplementsClause()) { TreePath tp = new TreePath(getCurrentPath(), t); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.CLASS_USE)); scan(tree.getModifiers(), null); tl.moveToEnd(tree.getModifiers()); firstIdentifier(tree.getSimpleName().toString()); scan(tree.getTypeParameters(), null); scan(tree.getExtendsClause(), null); scan(tree.getImplementsClause(), null); scan(tree.getMembers(), null);
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);
env.insideClass(); TreePath path = env.getPath(); ClassTree cls = (ClassTree) path.getLeaf(); CompilationController controller = env.getController(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); int startPos = (int) sourcePositions.getEndPosition(root, cls.getModifiers()); if (startPos <= 0) { startPos = (int) sourcePositions.getStartPosition(root, cls); for (Tree impl : cls.getImplementsClause()) { int implPos = (int) sourcePositions.getEndPosition(root, impl); if (implPos == Diagnostic.NOPOS || offset <= implPos) { Tree ext = cls.getExtendsClause(); if (ext != null) { int extPos = (int) sourcePositions.getEndPosition(root, ext); for (TypeParameterTree tp : cls.getTypeParameters()) { int tpPos = (int) sourcePositions.getEndPosition(root, tp); if (tpPos == Diagnostic.NOPOS || offset <= tpPos) { 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);
Trees trees = Trees.instance(processingEnv); ClassTree tree = trees.getTree(el); for (Tree member : tree.getMembers()) { 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) {
@Override public void run(CompilationController controller) throws Exception { controller.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED); for (Tree t: controller.getCompilationUnit().getTypeDecls()) { if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) { ClassTree classT = (ClassTree) t; if (fileName.equals(classT.getSimpleName().toString())) { Tree superT = classT.getExtendsClause(); if (superT != null) { Trees trees = controller.getTrees(); TreePath classTPath = trees.getPath(controller.getCompilationUnit(), classT); TypeElement classEl = (TypeElement) trees.getElement(classTPath); TypeElement appEl = controller.getElements().getTypeElement("org.jdesktop.application.Application"); // NOI18N Types types = controller.getTypes(); TypeMirror tm1 = types.erasure(classEl.asType()); TypeMirror tm2 = types.erasure(appEl.asType()); if (types.isSubtype(tm1, tm2)) { String clsName = classEl.getQualifiedName().toString(); if (!clsName.startsWith("org.jdesktop.application.")) { // NOI18N result[0] = clsName; return; } } break; } } } } } }, true);
@Override public Description matchNewClass(NewClassTree newClassTree, VisitorState state) { if (state.getPath().getParentPath().getLeaf().getKind() != Kind.EXPRESSION_STATEMENT) { return Description.NO_MATCH; return Description.NO_MATCH; for (Tree def : newClassTree.getClassBody().getMembers()) { switch (def.getKind()) { case VARIABLE: if (variableTree.getInitializer() != null) { return Description.NO_MATCH;