@Override public TypeMirror getEnclosingType() { return delegate.getEnclosingType(); }
@Override public TypeName visitDeclared(DeclaredType t, Void p) { ClassName rawType = ClassName.get((TypeElement) t.asElement()); TypeMirror enclosingType = t.getEnclosingType(); TypeName enclosing = (enclosingType.getKind() != TypeKind.NONE) && !t.asElement().getModifiers().contains(Modifier.STATIC) ? enclosingType.accept(this, null) : null; if (t.getTypeArguments().isEmpty() && !(enclosing instanceof ParameterizedTypeName)) { return rawType; } List<TypeName> typeArgumentNames = new ArrayList<>(); for (TypeMirror mirror : t.getTypeArguments()) { typeArgumentNames.add(get(mirror, typeVariables)); } return enclosing instanceof ParameterizedTypeName ? ((ParameterizedTypeName) enclosing).nestedClass( rawType.simpleName(), typeArgumentNames) : new ParameterizedTypeName(null, rawType, typeArgumentNames); }
declaredType.asElement(), declaredType.asElement().getKind(), declaredType.asElement().getClass(), declaredType.getTypeArguments(), declaredType.getEnclosingType())); for (TypeMirror tm : declaredType.getTypeArguments()) { if (!tm.equals(typeMirror)) {
private static boolean isInnerClass(DeclaredType mirror) { if (mirror.getEnclosingType().getKind() == TypeKind.NONE) { return false; } // Work around a little Eclipse bug if (asElement(mirror).getModifiers().contains(Modifier.STATIC)) { return false; } return true; }
@Override public Void visitDeclared(DeclaredType mirror, QualifiedNameAppendable a) { if (!isInnerClass(mirror)) { a.append(QualifiedName.of(asElement(mirror))); } else { mirror.getEnclosingType().accept(this, a); a.append('.'); a.append(mirror.asElement().getSimpleName()); } if (!mirror.getTypeArguments().isEmpty()) { String prefix = "<"; for (TypeMirror typeArgument : mirror.getTypeArguments()) { a.append(prefix); typeArgument.accept(this, a); prefix = ", "; } a.append(">"); } return null; }
@Override public TypeMirror getEnclosingType() { return root.getEnclosingType(); }
@Override public TypeMirror getEnclosingType() { return root.getEnclosingType(); }
@Override public TypeMirror getEnclosingType() { return root.getEnclosingType(); }
@Override public TypeMirror getEnclosingType() { return root.getEnclosingType(); }
private boolean isEnclosedToConfiguration(DeclaredType type) { TypeMirror enclosingType = type.getEnclosingType(); while (enclosingType.getKind().equals(TypeKind.DECLARED)) { type = (DeclaredType)enclosingType; //TODO read from configuration if (type.asElement().getAnnotation(Configuration.class) != null) { return true; } } return false; }
@Override public TypeMirror getEnclosingType() { return TypeMirrorDecorator.decorate(this.delegate.getEnclosingType(), env); }
@Override public TypeMirror getEnclosingType() { return TypeMirrorDecorator.decorate(this.delegate.getEnclosingType(), env); }
/** * Returns the type of the innermost enclosing instance, or null if there is none. This is the * same as {@link DeclaredType#getEnclosingType()} except that it returns null rather than * NoType for a static type. We need this because of * <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=508222">this bug</a> whereby * the Eclipse compiler returns a value for static classes that is not NoType. */ private static TypeMirror enclosingType(DeclaredType t) { TypeMirror enclosing = t.getEnclosingType(); if (enclosing.getKind().equals(TypeKind.NONE) || t.asElement().getModifiers().contains(Modifier.STATIC)) { return null; } return enclosing; }
private static boolean isInnerClass(DeclaredType mirror) { if (mirror.getEnclosingType().getKind() == TypeKind.NONE) { return false; } // Work around a little Eclipse bug if (asElement(mirror).getModifiers().contains(Modifier.STATIC)) { return false; } return true; }
private String toJava(DeclaredType declaredType) { TypeMirror enclosingType = declaredType.getEnclosingType(); StringBuilder sb = new StringBuilder(); if (enclosingType.getKind() != TypeKind.NONE) { sb.append(toJava(enclosingType)) .append(".") .append(declaredType.asElement().getSimpleName()); } else { sb.append(toJava(declaredType.asElement())); } List<? extends TypeMirror> typeArgs = declaredType.getTypeArguments(); if (typeArgs != null && !typeArgs.isEmpty()) { String typeArgsString = typeArgs.stream() .map(typeArg -> toJava(typeArg)) .collect(Collectors.joining(",", "<", ">")); sb.append(typeArgsString); } return sb.toString(); }
@Override public Integer visitDeclared(DeclaredType t, Set<Element> visiting) { Element element = t.asElement(); if (visiting.contains(element)) { return 0; } Set<Element> newVisiting = new HashSet<Element>(visiting); newVisiting.add(element); int result = hashKind(HASH_SEED, t); result *= HASH_MULTIPLIER; result += t.asElement().hashCode(); result *= HASH_MULTIPLIER; result += t.getEnclosingType().accept(this, newVisiting); result *= HASH_MULTIPLIER; result += hashList(t.getTypeArguments(), newVisiting); return result; }
@Override public Integer visitDeclared(DeclaredType t, Set<Element> visiting) { Element element = t.asElement(); if (visiting.contains(element)) { return 0; } Set<Element> newVisiting = new HashSet<Element>(visiting); newVisiting.add(element); int result = hashKind(HASH_SEED, t); result *= HASH_MULTIPLIER; result += t.asElement().hashCode(); result *= HASH_MULTIPLIER; result += t.getEnclosingType().accept(this, newVisiting); result *= HASH_MULTIPLIER; result += hashList(t.getTypeArguments(), newVisiting); return result; }
@Override public Boolean visitDeclared(DeclaredType type, Void p) { if (!isAccessible(type.getEnclosingType())) { // TODO(gak): investigate this check. see comment in Binding return false; } if (!isElementAccessibleFrom(type.asElement(), packageName)) { return false; } for (TypeMirror typeArgument : type.getTypeArguments()) { if (!isAccessible(typeArgument)) { return false; } } return true; }
TypeMirror asMemberOf(Element element, TypeMirror type, Types types) { TypeMirror ret = element.asType(); TypeMirror enclType = element.getEnclosingElement().asType(); if (enclType.getKind() == TypeKind.DECLARED) { enclType = types.erasure(enclType); } while (type != null && type.getKind() == TypeKind.DECLARED) { if ((enclType.getKind() != TypeKind.DECLARED || ((DeclaredType) enclType).asElement().getSimpleName().length() > 0) && types.isSubtype(type, enclType)) { ret = types.asMemberOf((DeclaredType) type, element); break; } type = ((DeclaredType) type).getEnclosingType(); } return ret; }
@Override public Integer visitDeclared(DeclaredType t, Set<Element> visiting) { Element element = t.asElement(); if (visiting.contains(element)) { return 0; } Set<Element> newVisiting = new HashSet<Element>(visiting); newVisiting.add(element); int result = hashKind(HASH_SEED, t); result *= HASH_MULTIPLIER; result += t.asElement().hashCode(); result *= HASH_MULTIPLIER; result += t.getEnclosingType().accept(this, newVisiting); result *= HASH_MULTIPLIER; result += hashList(t.getTypeArguments(), newVisiting); return result; }