下面列出了javax.lang.model.element.ElementKind#PACKAGE 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private ExpressionTree qualIdentFor(Element e) {
TreeMaker tm = copy.getTreeMaker();
if (e.getKind() == ElementKind.PACKAGE) {
String name = ((PackageElement)e).getQualifiedName().toString();
if (e instanceof Symbol) {
int lastDot = name.lastIndexOf('.');
if (lastDot < 0)
return tm.Identifier(e);
return tm.MemberSelect(qualIdentFor(name.substring(0, lastDot)), e);
}
return qualIdentFor(name);
}
Element ee = e.getEnclosingElement();
if (e instanceof Symbol)
return ee.getSimpleName().length() > 0 ? tm.MemberSelect(qualIdentFor(ee), e) : tm.Identifier(e);
return ee.getSimpleName().length() > 0 ? tm.MemberSelect(qualIdentFor(ee), e.getSimpleName()) : tm.Identifier(e.getSimpleName());
}
private String fqnFor(Tree t) {
Element el = ASTService.getElementImpl(t);
if (el != null) {
if (el.getKind().isClass() || el.getKind().isInterface() || el.getKind() == ElementKind.PACKAGE) {
return ((QualifiedNameable) el).getQualifiedName().toString();
} else {
Logger.getLogger(ElementOverlay.class.getName()).log(Level.SEVERE, "Not a QualifiedNameable: {0}", el);
return null;
}
} else if (t instanceof QualIdentTree) {
return ((QualIdentTree) t).getFQN();
} else if (t.getKind() == Kind.PARAMETERIZED_TYPE) {
return fqnFor(((ParameterizedTypeTree) t).getType());
} else {
Logger.getLogger(ElementOverlay.class.getName()).log(Level.FINE, "No element and no QualIdent");
return null;
}
}
/**
* Returns a {@link QualifiedName} for {@code type}.
*/
public static QualifiedName of(TypeElement type) {
switch (type.getNestingKind()) {
case TOP_LEVEL:
PackageElement pkg = (PackageElement) type.getEnclosingElement();
return QualifiedName.of(pkg.getQualifiedName().toString(), type.getSimpleName().toString());
case MEMBER:
List<String> reversedNames = new ArrayList<String>();
reversedNames.add(type.getSimpleName().toString());
Element parent = type.getEnclosingElement();
while (parent.getKind() != ElementKind.PACKAGE) {
reversedNames.add(parent.getSimpleName().toString());
parent = parent.getEnclosingElement();
}
return new QualifiedName(
((PackageElement) parent).getQualifiedName().toString(),
ImmutableList.copyOf(Lists.reverse(reversedNames)));
default:
throw new IllegalArgumentException("Cannot determine qualified name of " + type);
}
}
private void addAllElements(Element rootElement, Map<Path, Element> elements) {
if (rootElement.getKind() == ElementKind.PACKAGE) {
PackageElement packageElement = (PackageElement) rootElement;
if (!packageElement.getAnnotationMirrors().isEmpty()) {
elements.put(
getRelativePathToClass(packageElement.getQualifiedName() + ".package-info"),
packageElement);
}
}
if (!rootElement.getKind().isClass() && !rootElement.getKind().isInterface()) {
return;
}
TypeElement typeElement = (TypeElement) rootElement;
elements.put(getRelativePath(typeElement), typeElement);
for (Element enclosed : typeElement.getEnclosedElements()) {
addAllElements(enclosed, elements);
}
}
@Nullable
private TypeElement validated(Element element) {
Element enclosingElement = element.getEnclosingElement();
if (element.getKind() == ElementKind.CLASS
&& element.getModifiers().contains(Modifier.PUBLIC)
&& enclosingElement != null) {
if (enclosingElement.getKind() == ElementKind.PACKAGE
&& !element.getModifiers().contains(Modifier.ABSTRACT)
&& !((PackageElement) enclosingElement).isUnnamed()) {
return (TypeElement) element;
}
if (enclosingElement.getKind() == ElementKind.CLASS
&& element.getModifiers().contains(Modifier.STATIC)) {
return (TypeElement) element;
}
}
processing().getMessager()
.printMessage(Diagnostic.Kind.ERROR,
"Element annotated with @Metainf.Service annotation should be public top-level non-abstract or static class in a package",
element);
return null;
}
protected boolean isNonStaticInnerClass(TypeElement typeElement) {
Element outerClassOrPackage = typeElement.getEnclosingElement();
if (outerClassOrPackage.getKind() != ElementKind.PACKAGE
&& !typeElement.getModifiers().contains(Modifier.STATIC)) {
error(
typeElement,
"Class %s is a non static inner class. @Inject constructors are not allowed in non static inner classes.",
typeElement.getQualifiedName());
return true;
}
return false;
}
private static Element handlePossibleAnonymousInnerClass(CompilationInfo info, final Element el) {
Element encl = el.getEnclosingElement();
Element doubleEncl = encl != null ? encl.getEnclosingElement() : null;
if ( doubleEncl != null
&& !doubleEncl.getKind().isClass()
&& !doubleEncl.getKind().isInterface()
&& doubleEncl.getKind() != ElementKind.PACKAGE
&& encl.getKind() == ElementKind.CLASS) {
TreePath enclTreePath = info.getTrees().getPath(encl);
Tree enclTree = enclTreePath != null ? enclTreePath.getLeaf() : null;
if (enclTree != null && TreeUtilities.CLASS_TREE_KINDS.contains(enclTree.getKind()) && enclTreePath.getParentPath().getLeaf().getKind() == Tree.Kind.NEW_CLASS) {
NewClassTree nct = (NewClassTree) enclTreePath.getParentPath().getLeaf();
if (nct.getClassBody() != null) {
Element parentElement = info.getTrees().getElement(new TreePath(enclTreePath, nct.getIdentifier()));
if (parentElement == null || parentElement.getKind().isInterface()) {
return parentElement;
} else {
//annonymous innerclass extending a class. Find out which constructor is used:
TreePath superConstructorCall = new FindSuperConstructorCall().scan(enclTreePath, null);
if (superConstructorCall != null) {
return info.getTrees().getElement(superConstructorCall);
}
}
}
}
return null;//prevent jumps to incorrect positions
} else {
if (encl != null) {
return encl;
} else {
return el;
}
}
}
/**
* Creates an {@link ElementHandle} representing a {@link PackageElement}.
* @param packageName the name of the package
* @return the created {@link ElementHandle}
* @since 0.98
*/
@NonNull
public static ElementHandle<PackageElement> createPackageElementHandle (
@NonNull final String packageName) {
Parameters.notNull("packageName", packageName); //NOI18N
return new ElementHandle<PackageElement>(ElementKind.PACKAGE, packageName);
}
private TypeElement outermostTypeElement(Element el) {
while (el.getEnclosingElement().getKind() != ElementKind.PACKAGE) {
el = el.getEnclosingElement();
}
return (TypeElement) el;
}
@Override
@Value.Derived
@Value.Auxiliary
public DeclaringPackage packageOf() {
Element e = element();
for (; e.getKind() != ElementKind.PACKAGE; e = e.getEnclosingElement()) {
}
return interner().forPackage(
ImmutableProto.DeclaringPackage.builder()
.environment(environment())
.interner(interner())
.element((PackageElement) e)
.build());
}
private static boolean isLocalized(final URL docURL, final Element element) {
if (docURL == null) {
return false;
}
Element pkg = element;
while (pkg.getKind() != ElementKind.PACKAGE) {
pkg = pkg.getEnclosingElement();
if (pkg == null) {
return false;
}
}
String pkgBinName = ((PackageElement)pkg).getQualifiedName().toString();
String surl = docURL.toString();
int index = surl.lastIndexOf('/'); //NOI18N
if (index < 0) {
return false;
}
index-=(pkgBinName.length()+1);
if (index < 0) {
return false;
}
index-=API.length();
if (index < 0 || !surl.regionMatches(index,API,0,API.length())) {
return false;
}
int index2 = surl.lastIndexOf('/', index-1); //NOI18N
if (index2 < 0) {
return false;
}
String lang = surl.substring(index2+1, index);
return LANGS.contains(lang);
}
private PackageElement getPackageOf(Element el) {
while ((el != null) && (el.getKind() != ElementKind.PACKAGE)) el = el.getEnclosingElement();
return (PackageElement) el;
}
@Override
public int compare(Object o1, Object o2) {
if (o1 == o2)
return 0;
boolean isStatic1 = false;
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;
}
if (e1.getKind().isClass() || e1.getKind().isInterface()) {
sb1.insert(0, ((TypeElement)e1).getQualifiedName());
} else if (e1.getKind() == ElementKind.PACKAGE) {
sb1.insert(0, ((PackageElement)e1).getQualifiedName());
}
}
String s1 = sb1.toString();
boolean isStatic2 = false;
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 (e2.getKind().isField() || e2.getKind() == ElementKind.METHOD) {
sb2.append('.').append(e2.getSimpleName());
e2 = e2.getEnclosingElement();
isStatic2 = true;
}
if (e2.getKind().isClass() || e2.getKind().isInterface()) {
sb2.insert(0, ((TypeElement)e2).getQualifiedName());
} else if (e2.getKind() == ElementKind.PACKAGE) {
sb2.insert(0, ((PackageElement)e2).getQualifiedName());
}
}
String s2 = sb2.toString();
int bal = groups.getGroupId(s1, isStatic1) - groups.getGroupId(s2, isStatic2);
return bal == 0 ? s1.compareTo(s2) : bal;
}
private static PackageElement getPackage(Element type) {
while (type.getKind() != ElementKind.PACKAGE) {
type = type.getEnclosingElement();
}
return (PackageElement) type;
}
@Override
public <T> void search (
@NonNull final ElementHandle<?> element,
@NonNull final Set<? extends UsageType> usageType,
@NonNull final Set<? extends ClassIndex.SearchScopeType> scope,
@NonNull final Convertor<? super Document, T> convertor,
@NonNull final Set<? super T> result) throws InterruptedException, IOException {
Parameters.notNull("element", element); //NOI18N
Parameters.notNull("usageType", usageType); //NOI18N
Parameters.notNull("scope", scope); //NOI18N
Parameters.notNull("convertor", convertor); //NOI18N
Parameters.notNull("result", result); //NOI18N
final Pair<Convertor<? super Document, T>,Index> ctu = indexPath.getPatch(convertor);
try {
final String binaryName = SourceUtils.getJVMSignature(element)[0];
final ElementKind kind = element.getKind();
if (kind == ElementKind.PACKAGE) {
IndexManager.priorityAccess(() -> {
final Query q = QueryUtil.scopeFilter(
QueryUtil.createPackageUsagesQuery(binaryName,usageType,Occur.SHOULD),
scope);
if (q != null) {
index.query(result, ctu.first(), DocumentUtil.declaredTypesFieldSelector(false, false), cancel.get(), q);
if (ctu.second() != null) {
ctu.second().query(result, convertor, DocumentUtil.declaredTypesFieldSelector(false, false), cancel.get(), q);
}
}
return null;
});
} else if (kind.isClass() ||
kind.isInterface() ||
kind == ElementKind.OTHER) {
if (BinaryAnalyser.OBJECT.equals(binaryName)) {
getDeclaredElements(
"", //NOI18N
ClassIndex.NameKind.PREFIX,
scope,
DocumentUtil.declaredTypesFieldSelector(false, false),
convertor,
result);
} else {
IndexManager.priorityAccess(() -> {
final Query usagesQuery = QueryUtil.scopeFilter(
QueryUtil.createUsagesQuery(binaryName, usageType, Occur.SHOULD),
scope);
if (usagesQuery != null) {
index.query(result, ctu.first(), DocumentUtil.declaredTypesFieldSelector(false, false), cancel.get(), usagesQuery);
if (ctu.second() != null) {
ctu.second().query(result, convertor, DocumentUtil.declaredTypesFieldSelector(false, false), cancel.get(), usagesQuery);
}
}
return null;
});
}
} else {
throw new IllegalArgumentException(element.toString());
}
} catch (IOException ioe) {
this.<Void,IOException>handleException(null, ioe, root);
}
}
@TriggerTreeKind({Tree.Kind.CLASS, Tree.Kind.INTERFACE})
public static ErrorDescription check(HintContext context) {
TreePath tp = context.getPath();
ClassTree cls = (ClassTree) tp.getLeaf();
CompilationInfo info = context.getInfo();
SourcePositions sourcePositions = info.getTrees().getSourcePositions();
long startPos = sourcePositions.getStartPosition(tp.getCompilationUnit(), cls);
if (startPos > Integer.MAX_VALUE) {
return null;
}
int[] bodySpan = info.getTreeUtilities().findBodySpan(cls);
if (bodySpan == null || bodySpan[0] <= startPos) {
return null;
}
int caret = context.getCaretLocation();
if (startPos < 0 || caret < 0 || caret < startPos || caret >= bodySpan[0]) {
return null;
}
// #222487
// If there is a compile-time error on the class, then don't offer to
// create a subclass.
List<Diagnostic> errors = info.getDiagnostics();
if (!errors.isEmpty()) {
for (Diagnostic d : errors) {
if (d.getKind() != Diagnostic.Kind.ERROR) {
continue;
}
// Check that the error's start position is within the class header
// Note: d.getEndPosition() is not used because, for example,
// a "compiler.err.does.not.override.abstract" error ends at
// the end of the class tree.
if (startPos <= d.getStartPosition() && d.getStartPosition() <= bodySpan[0]) {
return null;
}
}
}
TypeElement typeElement = (TypeElement) info.getTrees().getElement(tp);
if (typeElement == null || typeElement.getModifiers().contains(Modifier.FINAL)) return null;
Element outer = typeElement.getEnclosingElement();
// do not offer the hint for non-static inner classes. Permit for classes nested into itnerface - no enclosing instance
if (outer != null && outer.getKind() != ElementKind.PACKAGE && outer.getKind() != ElementKind.INTERFACE) {
if (outer.getKind() != ElementKind.CLASS && outer.getKind() != ElementKind.ENUM) {
return null;
}
if (!typeElement.getModifiers().contains(Modifier.STATIC)) {
return null;
}
}
ClassPath cp = info.getClasspathInfo().getClassPath(PathKind.SOURCE);
FileObject root = cp.findOwnerRoot(info.getFileObject());
if (root == null) { //File not part of any project
return null;
}
PackageElement packageElement = (PackageElement) info.getElementUtilities().outermostTypeElement(typeElement).getEnclosingElement();
CreateSubclassFix fix = new CreateSubclassFix(info, root, packageElement.getQualifiedName().toString(), typeElement.getSimpleName().toString() + "Impl", typeElement); //NOI18N
return ErrorDescriptionFactory.forTree(context, context.getPath(), NbBundle.getMessage(CreateSubclass.class, typeElement.getKind() == ElementKind.CLASS
? typeElement.getModifiers().contains(Modifier.ABSTRACT) ? "ERR_ImplementAbstractClass" : "ERR_CreateSubclass" : "ERR_ImplementInterface"), fix); //NOI18N
}
private PackageElement getPackage(Element element) {
while (element.getKind() != ElementKind.PACKAGE) {
element = element.getEnclosingElement();
}
return (PackageElement) element;
}
public PackageElement getPackage(Element type) {
while (type.getKind() != ElementKind.PACKAGE) {
type = type.getEnclosingElement();
}
return (PackageElement) type;
}
@Override
public RefactoringUI create(CompilationInfo info, TreePathHandle[] handles, FileObject[] files, NonRecursiveFolder[] packages) {
final boolean b = lookup.lookup(ExplorerContext.class)!=null;
if (packages != null && packages.length == 1) {
return new SafeDeleteUI(packages[0], b);
}
if (handles != null && handles.length == 0 || (files!=null && files.length > 1)) {
return new SafeDeleteUI(files, Arrays.asList(handles), b);
}
if (b && files!=null && files.length == 1) {
return new SafeDeleteUI(files, Arrays.asList(handles), b);
}
if (info == null) {
return new SafeDeleteUI(handles);
}
TreePathHandle selectedElement = handles[0];
Element selected = selectedElement.resolveElement(info);
TreePath selectedTree = selectedElement.resolve(info);
if (selected == null || selectedTree == null) {
return null;
}
if (selected.getKind() == ElementKind.PACKAGE || selected.getEnclosingElement().getKind() == ElementKind.PACKAGE) {
ElementHandle<Element> handle = ElementHandle.create(selected);
FileObject file = SourceUtils.getFile(handle, info.getClasspathInfo());
if (file == null) {
return null;
}
if (file.getName().equals(selected.getSimpleName().toString())) {
return new SafeDeleteUI(new FileObject[]{file}, Collections.singleton(selectedElement), b);
}
}
if(!TreeUtilities.CLASS_TREE_KINDS.contains(selectedTree.getParentPath().getLeaf().getKind())
&& selectedTree.getParentPath().getLeaf().getKind() != Tree.Kind.COMPILATION_UNIT
&& selectedTree.getLeaf().getKind() == Tree.Kind.VARIABLE) {
switch (selectedTree.getParentPath().getLeaf().getKind()) {
case BLOCK:
case METHOD:
break;
default:
return null;
}
}
return new SafeDeleteUI(new TreePathHandle[]{selectedElement});
}
private static PackageElement findPkg(Element e) {
while (e.getKind() != ElementKind.PACKAGE) {
e = e.getEnclosingElement();
}
return (PackageElement)e;
}