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()); documentedMethod.params.add(variableElement.toString()); documentedMethod.returnType = methodElement.getReturnType().toString(); for (TypeMirror typeMirror : methodElement.getThrownTypes()) { documentedMethod.exceptions.add(typeMirror.toString());
SourcePositions getSourcePositions() { return treeUtils.getSourcePositions(); }
@Nullable private VariableTree findDeclaration(VisitorState state, Symbol field) { JavacProcessingEnvironment javacEnv = JavacProcessingEnvironment.instance(state.context); TreePath fieldDeclPath = Trees.instance(javacEnv).getPath(field); // Skip fields declared in other compilation units since we can't make a fix for them here. if (fieldDeclPath != null && fieldDeclPath.getCompilationUnit() == state.getPath().getCompilationUnit() && (fieldDeclPath.getLeaf() instanceof VariableTree)) { return (VariableTree) fieldDeclPath.getLeaf(); } return null; }
private TypeMirror getType(Tree t) { TreePath tp = verifier.getTreeUtils().getPath(verifier.getCompilationUnit(), t); return verifier.getTreeUtils().getTypeMirror(tp); }
private Element getElement(Tree t) { TreePath tp = verifier.getTreeUtils().getPath(verifier.getCompilationUnit(), t); Element e = verifier.getTreeUtils().getElement(tp); if (e == null) { // hack to make JDK 7 symbol resolution working if (t instanceof MethodInvocationTree) { JCTree.JCExpression jce = ((JCTree.JCMethodInvocation)t).meth; if (jce instanceof IdentifierTree) { e = ((JCTree.JCIdent)jce).sym; } else if (jce instanceof MemberSelectTree) { e = ((JCTree.JCFieldAccess)jce).sym; } } else if (t instanceof JCTree.JCIdent) { e = ((JCTree.JCIdent)t).sym; } else if (t instanceof JCTree.JCNewClass) { e = ((JCTree.JCIdent)((JCTree.JCNewClass)t).clazz).sym; } else if (t instanceof JCTree.JCThrow) { e = ((JCTree.JCNewClass)((JCTree.JCThrow)t).expr).type.tsym; } } return e; }
public Void visitIdentifier(IdentifierTree node, Void p) { TreePath path = getCurrentPath(); Element element = info.getTrees().getElement(path); if (element != null && element.asType().getKind() != TypeKind.ERROR) { // solve the imports only when declared type!!! if (element.getKind().isClass() || element.getKind().isInterface() || (element.getKind().isField() && ((Symbol) element).isStatic())) { Tree parent = path.getParentPath() != null ? path.getParentPath().getLeaf() : null; if ( (parent != null && parent.getKind() == Kind.CASE && ((CaseTree) parent).getExpression() == node && element.getKind() == ElementKind.ENUM_CONSTANT) || (path.getCompilationUnit() != null && ((Symbol) element).enclClass() != null && path.getCompilationUnit().getSourceFile() == ((Symbol) element).enclClass().sourcefile)) { translateMap.put(node, make.Identifier(element.getSimpleName())); } else { translateMap.put(node, make.QualIdent(element)); } } } return null; }
private @NonNull VerifyResult fullVerifyElements(TreePath node, TreePath p) { Element nodeEl = info.getTrees().getElement(node); Element pEl = info.getTrees().getElement(p); if (!nodeEl.getModifiers().contains(Modifier.STATIC)) { if ((nodeEl.getKind().isClass() || nodeEl.getKind().isInterface())) { if (p.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT && node.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT) { Tree selector = ((MemberSelectTree)p.getLeaf()).getExpression(); if (getWildcardTreeName(selector) != null) { Element nodeSelector = info.getTrees().getElement(new TreePath(node, ((MemberSelectTree)node.getLeaf()).getExpression())); if (nodeSelector != null && (nodeSelector.getKind().isClass() || nodeSelector.getKind().isInterface())) { matchingResult = VerifyResult.NO_MATCH; TypeMirror nodeTM = info.getTrees().getTypeMirror(node); if (nodeTM == null || nodeTM.getKind() == TypeKind.ERROR) { return VerifyResult.NO_MATCH_CONTINUE; TypeMirror pTM = info.getTrees().getTypeMirror(p); if (pTM == null || pTM.getKind() == TypeKind.ERROR) { return VerifyResult.NO_MATCH_CONTINUE;
private void addEnumConstants(Env env, TypeElement elem) { Elements elements = env.getController().getElements(); Trees trees = env.getController().getTrees(); TreePath path = env.getPath().getParentPath(); Set<Element> alreadyUsed = new HashSet<>(); if (path != null && path.getLeaf().getKind() == Tree.Kind.SWITCH) { SwitchTree st = (SwitchTree)path.getLeaf(); for (CaseTree ct : st.getCases()) { Element e = trees.getElement(new TreePath(path, ct.getExpression())); if (e != null && e.getKind() == ENUM_CONSTANT) { alreadyUsed.add(e); } } } for (Element e : elem.getEnclosedElements()) { if (e.getKind() == ENUM_CONSTANT && !alreadyUsed.contains(e)) { String name = e.getSimpleName().toString(); if (startsWith(env, name) && (Utilities.isShowDeprecatedMembers() || !elements.isDeprecated(e))) { results.add(itemFactory.createVariableItem(env.getController(), (VariableElement) e, e.asType(), anchorOffset, null, false, elements.isDeprecated(e), false, env.assignToVarPos())); } } } }
private void insideUnionType(Env env) throws IOException { TreePath path = env.getPath(); UnionTypeTree dtt = (UnionTypeTree) path.getLeaf(); CompilationController controller = env.getController(); TokenSequence<JavaTokenId> last = findLastNonWhitespaceToken(env, dtt, env.getOffset()); Types types = controller.getTypes(); for (Tree t : dtt.getTypeAlternatives()) { TypeMirror tm = trees.getTypeMirror(new TreePath(path, t)); if (tm != null && tm.getKind() != TypeKind.ERROR) { for (Iterator<TypeMirror> it = exs.iterator(); it.hasNext();) { if (types.isSubtype(tm, it.next())) { if (ex.getKind() == TypeKind.DECLARED && startsWith(env, ((DeclaredType) ex).asElement().getSimpleName().toString()) && (Utilities.isShowDeprecatedMembers() || !elements.isDeprecated(((DeclaredType) ex).asElement())) && !Utilities.isExcluded(((TypeElement)((DeclaredType) ex).asElement()).getQualifiedName())) {
@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); } }
public Void visitMethodInvocation(MethodInvocationTree node, Set<TypeMirror> p) { super.visitMethodInvocation(node, p); Element el = info.getTrees().getElement(getCurrentPath()); if (el != null && el.getKind() == ElementKind.METHOD) p.addAll(((ExecutableElement)el).getThrownTypes()); return null; }
private boolean isVoidLambda(Tree tree) { ExecutableElementTest<Void> test = new ExecutableElementTest<>((e, o) -> !e.isDefault() && !e.getModifiers().contains(STATIC) && "void".equals(e.getReturnType().toString())); return types.asElement(trees.getTypeMirror(trees.getPath(getCurrentPath().getCompilationUnit(), tree))).getEnclosedElements().stream().anyMatch(m -> m.accept(test, null)); }
private void insideCase(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); CaseTree cst = (CaseTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); CompilationController controller = env.getController(); if (cst.getExpression() != null && ((sourcePositions.getStartPosition(root, cst.getExpression()) >= offset) || (cst.getExpression().getKind() == Tree.Kind.ERRONEOUS && ((ErroneousTree) cst.getExpression()).getErrorTrees().isEmpty() && sourcePositions.getEndPosition(root, cst.getExpression()) >= offset))) { TreePath path1 = path.getParentPath(); if (path1.getLeaf().getKind() == Tree.Kind.SWITCH) { TypeMirror tm = controller.getTrees().getTypeMirror(new TreePath(path1, ((SwitchTree) path1.getLeaf()).getExpression())); if (tm.getKind() == TypeKind.DECLARED && ((DeclaredType) tm).asElement().getKind() == ENUM) { addEnumConstants(env, (TypeElement) ((DeclaredType) tm).asElement()); } else { addLocalConstantsAndTypes(env); } } } else { TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, cst, offset); if (ts != null && ts.token().id() != JavaTokenId.DEFAULT) { localResult(env); addKeywordsForBlock(env); } } }
private void insideMemberReference(Env env) throws IOException { TreePath path = env.getPath(); MemberReferenceTree mr = (MemberReferenceTree) path.getLeaf(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, mr, env.getOffset()); if (ts != null) { CompilationController controller = env.getController(); ExpressionTree exp = mr.getQualifierExpression(); TreePath expPath = new TreePath(path, exp); Trees trees = controller.getTrees(); TypeMirror type = trees.getTypeMirror(expPath); if (type != null && type.getKind() == TypeKind.TYPEVAR) { while (type != null && type.getKind() == TypeKind.TYPEVAR) { type = ((TypeVariable) type).getUpperBound(); if (type != null && (type.getKind() == TypeKind.DECLARED || type.getKind() == TypeKind.ARRAY || type.getKind() == TypeKind.TYPEVAR)) { Element e = trees.getElement(expPath); addMethodReferences(env, type, e); if (e == null || e.getKind().isClass() || e.getKind().isInterface()) { addKeyword(env, NEW_KEYWORD, SPACE, false);
while (it.hasNext()) { Tree tr = it.next(); if (tr.getKind() == Tree.Kind.VARIABLE) { Trees trees = myInfo.getTrees(); TreePath path = new TreePath(getCurrentPath(), tr); Element el = trees.getElement(path); String sname = el.getSimpleName().toString(); if (sname.equals(myMember)) { myFieldHandle = TreePathHandle.create(path, myInfo); } else if (tr.getKind() == Tree.Kind.METHOD) { Trees trees = myInfo.getTrees(); TreePath path = new TreePath(getCurrentPath(), tr); Element el = trees.getElement(path); String sname = el.getSimpleName().toString(); if (sname.equals(myMethod)) { ExecutableElement method = (ExecutableElement) el;
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()) { TreePath declPath = new TreePath(new TreePath(treePath, memberSelectTree), memberSelectTree.getExpression()); TypeElement decl = (TypeElement) info.getTrees().getElement(declPath); if (decl==null) { return null; for (Element e : info.getElements().getAllMembers((TypeElement) decl)) { if (!e.getModifiers().contains(Modifier.STATIC)) { continue; if (!e.getSimpleName().equals(simpleName)) { continue;
CompilationInfo info = context.getInfo(); TreePath treePath = context.getPath(); Element el = info.getTrees().getElement(treePath); if (el == null) { return null; TypeMirror type = el.asType(); if (type == null) { return null; String name = type.toString(); if (!(name.startsWith("javax.xml.rpc") || name.startsWith("javax.xml.registry") || name.startsWith("javax.enterprise.deploy"))) { // NOI18N return null; return null; Tree t = treePath.getLeaf(); int start = (int) info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), t); int end = (int) info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), t);
private String getPackageName(CompilationInfo cinfo) { Element e = cinfo.getTrees().getElement(new TreePath(cinfo.getCompilationUnit())); if (e != null && e.getKind() == ElementKind.PACKAGE) { return ((PackageElement) e).getQualifiedName().toString(); } return null; }
private List<int[]> detectMethodsForClass(CompilationInfo info, Document document, TreePath clazz, List<TypeElement> superTypes, TypeElement thisType) { List<int[]> highlights = new ArrayList<int[]>(); ClassTree clazzTree = (ClassTree) clazz.getLeaf(); TypeElement jlObject = info.getElements().getTypeElement("java.lang.Object"); OUTER: for (Tree member: clazzTree.getMembers()) { if (isCancelled()) { return null; } if (member.getKind() == Kind.METHOD) { TreePath path = new TreePath(clazz, member); Element el = info.getTrees().getElement(path); if (el.getKind() == ElementKind.METHOD) { for (TypeElement superType : superTypes) { for (ExecutableElement ee : ElementFilter.methodsIn(info.getElements().getAllMembers(superType))) { if (info.getElements().overrides((ExecutableElement) el, ee, thisType) && (superType.getKind().isClass() || !ee.getEnclosingElement().equals(jlObject))) { Token t = Utilities.getToken(info, document, path); if (t != null) { highlights.add(new int[] {t.offset(null), t.offset(null) + t.length()}); } continue OUTER; } } } } } } return highlights; }