Refine search
private void captureJavadoc(TypeElement elem) { List<String> imports = new ArrayList<>(); List<? extends ImportTree> importLines = Trees.instance(env).getPath(elem).getCompilationUnit().getImports(); for (ImportTree importLine : importLines) { imports.add(importLine.getQualifiedIdentifier().toString()); try { ExecutableElement methodElement = (ExecutableElement) memberElement; Implementation implementation = memberElement.getAnnotation(Implementation.class); for (Modifier modifier : memberElement.getModifiers()) { documentedMethod.modifiers.add(modifier.toString());
Tree prev = state.getPath().getLeaf(); for (Tree curr : state.getPath().getParentPath()) { switch (curr.getKind()) { case BLOCK: for (StatementTree stmt : ((BlockTree) curr).getStatements()) { case COMPILATION_UNIT: for (ImportTree importTree : ((CompilationUnitTree) curr).getImports()) { if (importTree.isStatic() && importTree.getQualifiedIdentifier().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree memberSelectTree = (MemberSelectTree) importTree.getQualifiedIdentifier(); Scope scope = state .getTypes() .membersClosure( ASTHelpers.getType(memberSelectTree.getExpression()), /* skipInterface= */ false); for (Symbol var : sym -> sym instanceof VarSymbol && sym.getSimpleName().equals(memberSelectTree.getIdentifier()))) { result.add((VarSymbol) var);
private static ImmutableSet<Symbol> getImportedSymbols( ImportTree importTree, VisitorState state) { if (importTree.isStatic()) { StaticImportInfo staticImportInfo = StaticImports.tryCreate(importTree, state); return staticImportInfo == null ? ImmutableSet.<Symbol>of() : staticImportInfo.members(); } else { @Nullable Symbol importedSymbol = getSymbol(importTree.getQualifiedIdentifier()); return importedSymbol == null ? ImmutableSet.<Symbol>of() : ImmutableSet.of(importedSymbol); } } }
if (!tree.isStatic()) { return null; if (!(tree.getQualifiedIdentifier() instanceof JCTree.JCFieldAccess)) { return null; JCTree.JCFieldAccess access = (JCTree.JCFieldAccess) tree.getQualifiedIdentifier(); Name identifier = access.getIdentifier(); if (identifier.contentEquals("*")) { ((JCTree.JCCompilationUnit) state.getPath().getCompilationUnit()).packge; ImmutableSet<Symbol> members = lookup(baseType, baseType, identifier, types, pkgSym); if (members.isEmpty()) {
private Element getImportedElement(CompilationUnitTree cut, ImportTree imp) { Trees trees = copy.getTrees(); Tree qualIdent = imp.getQualifiedIdentifier(); if (qualIdent.getKind() != Tree.Kind.MEMBER_SELECT) { Element element = trees.getElement(TreePath.getPath(cut, qualIdent)); if (element == null) { String fqn = qualIdent.toString(); Name name = ((MemberSelectTree)qualIdent).getIdentifier(); if ("*".contentEquals(name)) { //NOI18N Element element = trees.getElement(TreePath.getPath(cut, ((MemberSelectTree)qualIdent).getExpression())); if (element == null) element = getElementByFQN(((MemberSelectTree)qualIdent).getExpression().toString()); return element; if (imp.isStatic()) { Element parent = trees.getElement(TreePath.getPath(cut, ((MemberSelectTree)qualIdent).getExpression())); if (parent == null) parent = getElementByFQN(((MemberSelectTree)qualIdent).getExpression().toString()); if (parent != null && (parent.getKind().isClass() || parent.getKind().isInterface())) { Scope s = trees.getScope(new TreePath(cut)); for (Element e : parent.getEnclosedElements()) { if (name == e.getSimpleName() && e.getModifiers().contains(Modifier.STATIC) && trees.isAccessible(s, e, (DeclaredType)parent.asType())) return e;
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); 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)) { if (type.getKind() == TypeKind.ERROR && el.getKind().isClass()) { el = controller.getElements().getPackageElement(((TypeElement) el).getQualifiedName());
return super.visitImport(tree, null); if (tree.getQualifiedIdentifier() == null || tree.getQualifiedIdentifier().getKind() != Tree.Kind.MEMBER_SELECT) { return super.visitImport(tree, null); MemberSelectTree qualIdent = (MemberSelectTree) tree.getQualifiedIdentifier(); boolean assign = false; TreePath tp = tree.isStatic() || star ? new TreePath(new TreePath(getCurrentPath(), qualIdent), qualIdent.getExpression()) : new TreePath(getCurrentPath(), tree.getQualifiedIdentifier()); Element decl = info.getTrees().getElement(tp); if (!tree.isStatic()) { if (star) { List<TypeElement> types = ElementFilter.typesIn(decl.getEnclosedElements()); for (TypeElement te : types) { assign = true; importedBySingleImport.add(decl); if (!tree.isStatic() && star) { unresolvablePackageImports.add(tree); } else { addUnresolvableImport(qualIdent.getIdentifier(), tree);
continue; pkg = packageName != null ? (PackageElement)trees.getElement(TreePath.getPath(cut, packageName)) : null; if (pkg == null && packageName != null) { pkg = elements.getPackageElement(elements.getName(packageName.toString())); Element e = getImportedElement(cut, imp); if (!elementsToImport.contains(e)) { if (imp.isStatic()) { int threshold = imp.isStatic() ? staticTreshold : treshold; if (isStarImport(imp) && threshold == Integer.MAX_VALUE) { Map map = imp.isStatic() ? typeCounts : pkgCounts; Integer cnt = (Integer)map.get(e); if (cnt != null) { if (imp.isStatic()) { cnt = typeCounts.get(e); } else { ImportTree imp = imports.get(currentExisting); Element impElement = getImportedElement(cut, imp); el = imp.isStatic() if (isStatic == imp.isStatic() && (currentToImportElement == impElement || isStar && currentToImportElement == el)) { imports.remove(currentExisting); } else {
@Override public Void visitImport(ImportTree node, Stack<Tree> p) { if (node.isStatic() && toFind.getModifiers().contains(Modifier.STATIC)) { Tree qualIdent = node.getQualifiedIdentifier(); if (qualIdent.getKind() == Kind.MEMBER_SELECT) { MemberSelectTree mst = (MemberSelectTree) qualIdent; if (toFind.getSimpleName().contentEquals(mst.getIdentifier())) { Element el = info.getTrees().getElement(new TreePath(getCurrentPath(), mst.getExpression())); if (el != null && el.equals(toFind.getEnclosingElement())) { Token<JavaTokenId> t = Utilities.getToken(info, doc, new TreePath(getCurrentPath(), mst)); if (t != null) usages.add(t); } } } } return super.visitImport(node, p); } }
StringBuilder sb1 = new StringBuilder(); if (o1 instanceof ImportTree) { isStatic1 = ((ImportTree)o1).isStatic(); sb1.append(((ImportTree)o1).getQualifiedIdentifier().toString()); } else if (o1 instanceof Element) { Element e1 = (Element)o1; if (e1.getKind().isField() || e1.getKind() == ElementKind.METHOD) { sb1.append('.').append(e1.getSimpleName()); e1 = e1.getEnclosingElement(); isStatic1 = true; StringBuilder sb2 = new StringBuilder(); if (o2 instanceof ImportTree) { isStatic2 = ((ImportTree)o2).isStatic(); sb2.append(((ImportTree)o2).getQualifiedIdentifier().toString()); } else if (o2 instanceof Element) { Element e2 = (Element)o2;
if (treePath.getLeaf().getKind() != Tree.Kind.MEMBER_SELECT) return null; MemberSelectTree memberSelectTree = (MemberSelectTree) treePath.getLeaf(); TreePath tp = treePath; while (tp!=null) { Kind treeKind = tp.getLeaf().getKind(); if (treeKind == Tree.Kind.IMPORT) { if (!((ImportTree) tp.getLeaf()).isStatic()) { return null; Name simpleName = memberSelectTree.getIdentifier(); if (simpleName == null) { return null; TreePath declPath = new TreePath(new TreePath(treePath, memberSelectTree), memberSelectTree.getExpression()); TypeElement decl = (TypeElement) info.getTrees().getElement(declPath); if (decl==null) { return null; if (!e.getModifiers().contains(Modifier.STATIC)) { continue; if (!e.getSimpleName().equals(simpleName)) { continue;
private void addImport(ImportTree imp) { String fqn = getFQN(imp); if (!imp.isStatic()) { Element resolve = overlay.resolve(model, elements, fqn); simpleNames2Elements.put(resolve.getSimpleName().toString(), resolve); } else { classes = ElementFilter.typesIn(clazz.getEnclosedElements()); for (Element e : resolved.getEnclosedElements()) { if (!e.getModifiers().contains(Modifier.STATIC)) { continue;
if (typePath != null && typePath.getParentPath().getLeaf().getKind() == Kind.METHOD) { && isIn(cu, info.getTrees().getSourcePositions(), type, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); && isIn(cu, info.getTrees().getSourcePositions(), exc, caretPosition)) { MethodExitDetector med = new MethodExitDetector(); if (typePath != null && ((typePath.getParentPath().getLeaf().getKind() == Kind.UNION_TYPE int bodyStart = Utilities.findBodyStart(info, ctree, cu, info.getTrees().getSourcePositions(), doc); if (it.isStatic() && tp.getLeaf().getKind() == Kind.MEMBER_SELECT) { MemberSelectTree mst = (MemberSelectTree) tp.getLeaf(); if (!"*".contentEquals(mst.getIdentifier())) { List<int[]> bag = new ArrayList<int[]>(); Token<JavaTokenId> tok = Utilities.getToken(info, doc, tp); if (tok != null) bag.add(new int[] {tok.offset(null), tok.offset(null) + tok.length()}); el = info.getTrees().getElement(new TreePath(tp, mst.getExpression())); if (el != null) { FindLocalUsagesQuery fluq = new FindLocalUsagesQuery(); setLocalUsages(fluq); try { for (Element element : el.getEnclosedElements()) { if (element.getModifiers().contains(Modifier.STATIC)) { for (Token t : fluq.findUsages(element, info, doc)) { bag.add(new int[] {t.offset(null), t.offset(null) + t.length()});
private void handleUnresolvableImports(Element decl, boolean methodInvocation, boolean removeStarImports) { Name simpleName = decl.getSimpleName(); if (simpleName != null) { Collection<ImportTree> imps = simpleName2UnresolvableImports.get(simpleName.toString()); if (imps != null) { for (ImportTree imp : imps) { if (!methodInvocation || imp.isStatic()) { import2Highlight.remove(imp); } } } else { if (removeStarImports) { //TODO: explain for (ImportTree unresolvable : unresolvablePackageImports) { if (!methodInvocation || unresolvable.isStatic()) { import2Highlight.remove(unresolvable); } } } } } } }
if(importTree.getQualifiedIdentifier().getKind() == Tree.Kind.MEMBER_SELECT) { MemberSelectTree memSelectTree = (MemberSelectTree)importTree.getQualifiedIdentifier(); String importClassName = memSelectTree.getIdentifier().toString(); if(getFQN(cinfo, memSelectTree.getExpression()).equals(pkgName)) { return ImportStatus.exists;
private boolean isStar(ImportTree tree) { Tree qualIdent = tree.getQualifiedIdentifier(); if (qualIdent == null || qualIdent.getKind() == Kind.IDENTIFIER) { return false; } return ((MemberSelectTree) qualIdent).getIdentifier().contentEquals("*"); }
public static Set<String> getImportNames(ProcessingEnvironment processingEnv, Element element) { Trees treeUtils = Trees.instance(processingEnv); if (treeUtils == null) { return Collections.emptySet(); TreePath path = treeUtils.getPath(element); if (path == null) { return Collections.emptySet(); CompilationUnitTree unitTree = path.getCompilationUnit(); if (importTree.isStatic()) { buffer.append("static "); buffer.append(importTree.getQualifiedIdentifier().toString()); importNames.add(buffer.toString());
@Override @CheckForNull public Void visitImport (@NonNull final ImportTree node, @NonNull final Map<Pair<BinaryName,String>, UsagesData<String>> p) { this.isStaticImport = node.isStatic(); final Tree qit = node.getQualifiedIdentifier(); isPkgImport = qit.getKind() == Tree.Kind.MEMBER_SELECT && names.asterisk == (((MemberSelectTree)qit).getIdentifier()); final Void ret = super.visitImport(node, p); isStaticImport = isPkgImport = false; return ret; }
private static Set<String> getImports(VisitorState state) { Set<String> imports = new HashSet<>(); for (ImportTree importTree : state.getPath().getCompilationUnit().getImports()) { imports.add(importTree.getQualifiedIdentifier().toString()); } return imports; }
.filter( i -> { Symbol s = ASTHelpers.getSymbol(i.getQualifiedIdentifier()); return s != null && s.getQualifiedName()