Refine search
private static boolean isPartOfMethodInvocation(TreePath idPath) { Kind parentKind = idPath.getParentPath().getLeaf().getKind(); if (parentKind == Kind.METHOD_INVOCATION) { // must be an argument return true; } if (parentKind == Kind.MEMBER_SELECT) { Tree maybeMethodInvocation = idPath.getParentPath().getParentPath().getLeaf(); // likely the target of the method invocation return maybeMethodInvocation.getKind() == Kind.METHOD_INVOCATION; } return false; }
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());
private void addGuaranteedNonNullFromInvokes( VisitorState state, Trees trees, Set<Element> safeInitMethods, AccessPathNullnessAnalysis nullnessAnalysis, Set<Element> guaranteedNonNull) { for (Element invoked : safeInitMethods) { Tree invokedTree = trees.getTree(invoked); guaranteedNonNull.addAll( nullnessAnalysis.getNonnullFieldsOfReceiverAtExit( new TreePath(state.getPath(), invokedTree), state.context)); } }
private static Tree findParent(Tree node, VisitorState state) { return TreePath.getPath(state.getPath().getCompilationUnit(), node).getParentPath().getLeaf(); }
private static boolean isEnhancedForLoopVar(TreePath variablePath) { Tree tree = variablePath.getLeaf(); Tree parent = variablePath.getParentPath().getLeaf(); return parent instanceof EnhancedForLoopTree && ((EnhancedForLoopTree) parent).getVariable() == tree; }
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(); Element element = trees.getElement(TreePath.getPath(cut, ((MemberSelectTree)qualIdent).getExpression())); if (element == null) element = getElementByFQN(((MemberSelectTree)qualIdent).getExpression().toString()); 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; TreePath found = TreePath.getPath(cut, qualIdent); if (found == null) { found = new TreePath(new TreePath(new TreePath(cut), imp), qualIdent); Element element = trees.getElement(found);
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 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())); } } } }
@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); } }
private boolean isStartExpression(Element element, Tree statement) { if(statement.toString().startsWith("super(") || statement.toString().startsWith("this(")) { return false; } Set<String> methods = element.getKind() == CONSTRUCTOR ? getMethods(element.getEnclosingElement().asType()) : getMethods(((ExecutableElement) element).getReturnType()); if(!methods.isEmpty() || isAnnotatedStartMethod(element)) { trees.printMessage(ERROR, message(methods), statement, getCurrentPath().getCompilationUnit()); return true; } return 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()) { return null; tp = tp.getParentPath(); continue; return null; 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;
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; }
TreePath tp = new TreePath(getCurrentPath(), expr); handlePossibleIdentifier(tp, EnumSet.of(UseTypes.READ)); Element el = info.getTrees().getElement(getCurrentPath()); if (el != null && el.getKind().isField()) { handlePossibleIdentifier(getCurrentPath(), d == null ? EnumSet.of(UseTypes.READ) : d); if (el != null && (el.getKind().isClass() || el.getKind().isInterface()) && getCurrentPath().getParentPath().getLeaf().getKind() != Kind.NEW_CLASS) { handlePossibleIdentifier(getCurrentPath(), EnumSet.of(UseTypes.CLASS_USE));
@Override public Void visitVariable(VariableTree tree, EnumSet<UseTypes> d) { tl.moveToOffset(sourcePositions.getStartPosition(info.getCompilationUnit(), tree)); TreePath type = new TreePath(getCurrentPath(), tree.getType()); if (type.getLeaf() instanceof ArrayTypeTree) { type = new TreePath(type, ((ArrayTypeTree) type.getLeaf()).getType()); if (type.getLeaf().getKind() == Kind.IDENTIFIER) handlePossibleIdentifier(type, EnumSet.of(UseTypes.CLASS_USE)); 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) { uses = EnumSet.of(UseTypes.DECLARATION, UseTypes.WRITE); } else { int[] span = info.getTreeUtilities().findNameSpan(tree); if (span != null) tl.moveToOffset(span[0]);
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); } } }
public void run(WorkingCopy workingCopy) throws Exception { workingCopy.toPhase(Phase.RESOLVED); CompilationUnitTree cut = workingCopy.getCompilationUnit(); gu = GenerationUtils.newInstance(workingCopy); for (Tree typeDecl : cut.getTypeDecls()) { if (TreeUtilities.CLASS_TREE_KINDS.contains(typeDecl.getKind())) { Element e = workingCopy.getTrees().getElement(new TreePath(new TreePath(workingCopy.getCompilationUnit()), typeDecl)); if (e != null && e.getKind().isClass()) { TypeElement te = (TypeElement) e; ClassTree ct = (ClassTree) typeDecl; workingCopy.rewrite(ct, generateInterfaces(workingCopy, te, ct, gu)); } } } } };
@Override public Void visitMethod(MethodTree methodTree, Void aVoid) { Element element = trees.getElement(trees.getPath(getCurrentPath().getCompilationUnit(), methodTree)); return nonNull(element.getAnnotation(IgnoreMissingEndMethod.class)) ? null : super.visitMethod(methodTree, aVoid); }
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)); }