Refine search
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 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; }
/** * Creates a new instance of ElementGrip */ public ElementGrip(TreePath treePath, CompilationInfo info) { this.delegateElementHandle = TreePathHandle.create(treePath, info); this.toString = UiUtils.getHeader(treePath, info, UiUtils.PrintPart.NAME); this.fileObject = info.getFileObject(); this.icon = UiUtils.getDeclarationIcon(info.getTrees().getElement(treePath)); }
public AssignComments(final CompilationInfo info, final Tree commentMapTarget, final TokenSequence<JavaTokenId> seq, final SourcePositions positions) { this(info, commentMapTarget, seq, info.getCompilationUnit(), positions); }
public static String getArgumentSource(CompilationInfo cinfo, ExpressionTree exprTree) { long end = cinfo.getTrees().getSourcePositions().getEndPosition(cinfo.getCompilationUnit(), exprTree); long start = cinfo.getTrees().getSourcePositions().getStartPosition(cinfo.getCompilationUnit(), exprTree); return cinfo.getText().substring((int)start, (int)end); } }
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; if (nodeEl.getKind() == pEl.getKind() && nodeEl.getKind() == ElementKind.METHOD) { if (info.getElements().overrides((ExecutableElement) nodeEl, (ExecutableElement) pEl, (TypeElement) nodeEl.getEnclosingElement())) { return VerifyResult.MATCH_CHECK_DEEPER; 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;
@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); } }
InjectableTreeNode(FileObject fileObject, T element, DeclaredType parentType, boolean disabled , CompilationInfo compilationInfo) { myFileObject = fileObject; myElementHandle = ElementHandle.create(element); myElementKind = element.getKind(); myModifiers = element.getModifiers(); myCpInfo = compilationInfo.getClasspathInfo(); isDisabled = disabled; setName(element.getSimpleName().toString()); setIcon(ElementIcons.getElementIcon(element.getKind(), element.getModifiers())); setLabel(Utils.format(element, parentType, compilationInfo)); setFQNLabel(Utils.format(element, parentType, compilationInfo , false, true)); setToolTip(Utils.format(element, parentType, compilationInfo, true, WebBeansNavigationOptions.isShowFQN())); }
CompilationUnitTree cut = info.getCompilationUnit(); final Trees trees = info.getTrees(); final Scope scope = trees.getScope(context); String qName = fqn; StringBuilder sqName = new StringBuilder(); boolean clashing = false; ElementUtilities eu = info.getElementUtilities(); ElementUtilities.ElementAcceptor acceptor = new ElementUtilities.ElementAcceptor() { @Override int lastDot = qName.lastIndexOf('.'); Element element; if ((element = info.getElements().getTypeElement(qName)) != null) { clashing = false; String simple = qName.substring(lastDot < 0 ? 0 : lastDot + 1); } else if ((element = info.getElements().getPackageElement(qName)) != null) { if (toImport == null || GeneratorUtilities.checkPackagesForStarImport(qName, cs)) { toImport = element; String topLevelLanguageMIMEType = info.getFileObject().getMIMEType(); if ("text/x-java".equals(topLevelLanguageMIMEType)){ //NOI18N final Set<Element> elementsToImport = Collections.singleton(toImport); if (info instanceof WorkingCopy) { CompilationUnitTree nue = (CompilationUnitTree) ((WorkingCopy)info).resolveRewriteTarget(cut); ((WorkingCopy)info).rewrite(info.getCompilationUnit(), GeneratorUtilities.get((WorkingCopy)info).addImports(nue, elementsToImport)); } else { final ElementHandle handle = ElementHandle.create(toImport);
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;
protected void checkMembers( TypeElement element, CdiAnalysisResult result , String localizedWarning ) { List<ExecutableElement> methods = ElementFilter.methodsIn( element.getEnclosedElements()); for (ExecutableElement executableElement : methods) { TypeMirror returnType = executableElement.getReturnType(); boolean warning = false; if ( returnType.getKind() == TypeKind.ARRAY ){ warning = true; } else if ( returnType.getKind() == TypeKind.DECLARED){ Element returnElement = result.getInfo().getTypes().asElement( returnType ); warning = returnElement.getKind() == ElementKind.ANNOTATION_TYPE; } if ( !warning ){ continue; } if (AnnotationUtil.hasAnnotation(executableElement, AnnotationUtil.NON_BINDING, result.getInfo()) ) { continue; } result.addNotification(Severity.WARNING, element, localizedWarning); } }
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); Bundle.OptionalEE7APIsHint_DisplayName(), fixes, info.getFileObject(), start, end));
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;
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; }
public Void visitMethod(MethodTree node, Set<TypeMirror> p) { Set<TypeMirror> s = new LinkedHashSet<TypeMirror>(); scan(node.getBody(), s); for (ExpressionTree et : node.getThrows()) { TypeMirror t = info.getTrees().getTypeMirror(new TreePath(getCurrentPath(), et)); if (t != null && t.getKind() != TypeKind.ERROR) { for (Iterator<TypeMirror> it = s.iterator(); it.hasNext();) if (info.getTypes().isSubtype(it.next(), t)) it.remove(); } } p.addAll(s); return null; }
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); 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 String getSuperTypeClassName(TypeElement classElement, CompilationInfo ci) { String superClassName = null; TypeMirror superclass = classElement.getSuperclass(); if (superclass != null) { Element superclassElement = ci.getTypes().asElement(superclass); if ((superclassElement != null) && (superclassElement.getKind() == ElementKind.CLASS)) { String superclassName = ElementUtilities.getBinaryName((TypeElement) superclassElement); if (!superclassName.equals("java.lang.Object")) { superClassName = superclassName; } } } return superClassName; }
private List<Fix> createQualifierFix( CompilationInfo compilationInfo, Element annotation, Element classElement ) { PackageElement packageElement = compilationInfo.getElements() .getPackageOf(classElement); FileObject targetFile = SourceUtils.getFile( ElementHandle.create(classElement), compilationInfo.getClasspathInfo()); return Collections.<Fix> singletonList(new CreateQualifierFix( compilationInfo, annotation.getSimpleName().toString(), packageElement.getQualifiedName().toString(), targetFile)); }