@Override public List<? extends TypeParameterElement> getTypeParameters() { List<? extends TypeParameterElement> tps = typeParameters; if (tps == null) { tps = delegate.getTypeParameters(); typeParameters = tps; } return tps; } }
@Override public Void visitDeclared(DeclaredType t, VariableElement v) { List<? extends TypeMirror> typeParams = t.getTypeArguments(); List<? extends TypeParameterElement> parentTypeParams = parent.getTypeParameters(); if (!parentTypeParams.isEmpty() && typeParams.isEmpty()) { messager.printMessage(Kind.ERROR, "@RealObject is missing type parameters", v); } else { String typeString = join(typeParams); String parentString = join(parentTypeParams); if (!typeString.equals(parentString)) { messager.printMessage(Kind.ERROR, "Parameter type mismatch: expecting <" + parentString + ">, was <" + typeString + '>', v); } } return null; }
@Override default List<? extends TypeParameterElement> getTypeParameters() { return getDelegate().getTypeParameters(); }
TypevarContext(TypeElement element, String renderedTypeString) { List<? extends TypeParameterElement> typeParameters = element.getTypeParameters(); if (!typeParameters.isEmpty()) { this.arguments = SourceTypes.extract(renderedTypeString).getValue(); this.parameters = Lists.newArrayList(); for (TypeParameterElement p : typeParameters) { parameters.add(p.getSimpleName().toString()); } // we allow having no arguments in a string as raw type/unspecified argument scenario Verify.verify(arguments.isEmpty() || (parameters.size() == arguments.size()), parameters + " =/> " + arguments); } else { this.parameters = Collections.emptyList(); this.arguments = Collections.emptyList(); } } }
/** * Get the type variables from the given {@link TypeElement}. */ public static List<TypeVariableName> getTypeVariables(TypeElement typeElement) { final List<? extends TypeParameterElement> typeParameters = typeElement.getTypeParameters(); final int typeParameterCount = typeParameters.size(); final List<TypeVariableName> typeVariables = new ArrayList<>(typeParameterCount); for (TypeParameterElement typeParameterElement : typeParameters) { final int boundTypesCount = typeParameterElement.getBounds().size(); final TypeName[] boundsTypeNames = new TypeName[boundTypesCount]; for (int i = 0; i < boundTypesCount; i++) { boundsTypeNames[i] = TypeName.get(typeParameterElement.getBounds().get(i)); } final TypeVariableName typeVariable = TypeVariableName.get(typeParameterElement.getSimpleName().toString(), boundsTypeNames); typeVariables.add(typeVariable); } return typeVariables; } }
public void generify(IJGenerifiable generifiable, TypeElement fromTypeParameters) { for (TypeParameterElement param : fromTypeParameters.getTypeParameters()) { List<AbstractJClass> bounds = typeBoundsToJClass(param.getBounds()); addTypeBounds(generifiable, bounds, param.getSimpleName().toString()); } }
private void writeAsyncClass(Element elem) throws ClassNotFoundException, IOException, Exception { if (elem.getKind().isInterface()) { TypeElement interfaceClazz = (TypeElement) elem; String className = interfaceClazz.getSimpleName().toString(); TypeSpec.Builder classBuilder = TypeSpec.interfaceBuilder(className + ASYNC).addModifiers(Modifier.PUBLIC) .addSuperinterface(TypeName.get(elem.asType())); // add class generic type classBuilder.addTypeVariables(getTypeNames(interfaceClazz.getTypeParameters())); // add direct method addMethods(interfaceClazz, classBuilder); // add method form superinterface addSuperInterfaceMethods(interfaceClazz.getInterfaces(), classBuilder); // write class JavaFile javaFile = JavaFile.builder(processingEnv.getElementUtils().getPackageOf(interfaceClazz).getQualifiedName().toString(), classBuilder.build()).build(); javaFile.writeTo(new File(System.getProperty("basedir"), TARGET_DIR)); } else { processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "MotanAsyncProcessor not process, because " + elem.toString() + " not a interface."); } }
private void registerType(TypeElement type) { if (type != null && !importMap.containsKey(type)) { typeMap.put(type.getSimpleName().toString(), type); importMap.put(type, type); for (TypeParameterElement typeParam : type.getTypeParameters()) { for (TypeMirror bound : typeParam.getBounds()) { // FIXME: get rid of cast using a visitor TypeElement boundElement = TYPE_ELEMENT_VISITOR.visit(helpers.asElement(bound)); registerType(boundElement); } } } }
StringBuilder paramDef = new StringBuilder("<"); StringBuilder paramUse = new StringBuilder("<"); for (TypeParameterElement typeParam : actualType.getTypeParameters()) { if (paramCount > 0) { paramDef.append(',');
private TypeMirror getRealElementType(Element element) { AnnotationMirror mirror = TypeUtils.getAnnotationMirrorOfType(element, ManyToOne.class); if (mirror == null) { mirror = TypeUtils.getAnnotationMirrorOfType(element, OneToOne.class); } if (mirror != null) { return TypeUtils.getAnnotationValueAsTypeMirror(mirror, "targetEntity"); } mirror = TypeUtils.getAnnotationMirrorOfType(element, OneToMany.class); if (mirror == null) { mirror = TypeUtils.getAnnotationMirrorOfType(element, ManyToMany.class); } if (mirror != null) { TypeMirror typeArg = TypeUtils.getAnnotationValueAsTypeMirror(mirror, "targetEntity"); TypeMirror erasure = types.erasure(element.asType()); TypeElement typeElement = (TypeElement) types.asElement(erasure); if (typeElement != null && typeArg != null) { if (typeElement.getTypeParameters().size() == 1) { return types.getDeclaredType(typeElement, typeArg); } else if (typeElement.getTypeParameters().size() == 2) { if (element.asType() instanceof DeclaredType) { TypeMirror first = ((DeclaredType) element.asType()).getTypeArguments().get(0); return types.getDeclaredType(typeElement, first, typeArg); } } } } return null; }
if (genericElt.getKind().isClass() || genericElt.getKind().isInterface()) { ((TypeElement) genericElt) .getTypeParameters().stream() .filter( typeParam ->
TypeElement superclassElement = (TypeElement)types.asElement(superclass); if (superclassElement.getAnnotation(JsonObject.class) != null) { if (superclassElement.getTypeParameters() != null) { parentTypeParameters = superclassElement.getTypeParameters(); .setSerializeNullObjects(annotation.serializeNullObjects()) .setSerializeNullCollectionElements(annotation.serializeNullCollectionElements()) .setTypeParameters(typeElement.getTypeParameters()) .build();
private boolean isEligibleFromType(TypeElement typeElement, ValueAttribute attr) { if (!typeElement.getTypeParameters().isEmpty()) { return false;
return null; final List<? extends TypeParameterElement> typeTP = actualType.getTypeParameters(); final List<? extends TypeParameterElement> elemTP = shadowType.getTypeParameters(); if (!helpers.isSameParameterList(typeTP, elemTP)) { StringBuilder message = new StringBuilder(); if (elemTP.isEmpty()) { message.append("Shadow type is missing type parameters, expected <"); helpers.appendParameterList(message, actualType.getTypeParameters()); message.append('>'); } else if (typeTP.isEmpty()) { } else { message.append("Shadow type must have same type parameters as its real counterpart: expected <"); helpers.appendParameterList(message, actualType.getTypeParameters()); message.append(">, was <"); helpers.appendParameterList(message, shadowType.getTypeParameters()); message.append('>');
List<? extends TypeParameterElement> getTypeParameterElements() { return typeToExtend.getTypeParameters(); } }
public static TypeClass from(TypeElement typeElement) { return new TypeClass(QualifiedName.of(typeElement), typeElement.getTypeParameters()); }
/** * Returns a parameterised generic type. * * @throws IllegalArgumentException if {@code rawType} is not in fact a raw type, or if * the number of given parameters does not match the number declared on the raw type. */ private static DeclaredType parameterisedType( Types typeUtils, TypeMirror rawType, List<TypeMirror> paramTypes) { Preconditions.checkArgument( rawType.getKind() == TypeKind.DECLARED && ((DeclaredType) rawType).getTypeArguments().isEmpty(), "Expected raw type, got '%s'", rawType); TypeElement genericType = (TypeElement) typeUtils.asElement(rawType); Preconditions.checkArgument( genericType.getTypeParameters().size() == paramTypes.size(), "Incorrect number of arguments for %s (expected %s, got %s)", genericType, genericType.getTypeParameters().size(), paramTypes.size()); DeclaredType declaredType = typeUtils.getDeclaredType( genericType, paramTypes.toArray(new TypeMirror[paramTypes.size()])); return declaredType; }
@Test public void testBoundedGenericElement() { Consumer<TypeElement> test = foobar -> { assertThat(foobar.getSimpleName().toString()).isEqualTo("FooBar"); assertThat(foobar.getTypeParameters()).hasSize(2); assertThat(foobar.getTypeParameters().get(0).getSimpleName().toString()).isEqualTo("T"); assertThat(foobar.getTypeParameters().get(0).toString()).isEqualTo("T"); assertThat(foobar.getTypeParameters().get(1).getSimpleName().toString()).isEqualTo("C"); assertThat(foobar.getTypeParameters().get(1).toString()).isEqualTo("C"); }; TypeElement realFoobar = model.newType("package org.example; interface FooBar<T extends Number, C> { }"); GenericElement fakeFoobar = new GenericElement.Builder(FOO_BAR_NAME) .addTypeParameter("T", newTopLevelClass("java.lang.Number")) .addTypeParameter("C") .build(); test.accept(realFoobar); test.accept(fakeFoobar); }
@Test public void testGenericMirror_withSelfReference() { Consumer<DeclaredType> test = foobar -> { // FooBar<E extends FooBar<E>> TypeElement foobarElement = maybeAsTypeElement(foobar).get(); assertThat(foobarElement.getSimpleName().toString()).isEqualTo("FooBar"); assertThat(foobar.getTypeArguments()).hasSize(1); assertThat(SourceBuilder.forTesting().add("%s", foobar).toString()) .isEqualTo("FooBar<E>"); // E extends FooBar<E> TypeParameterElement typeParameter = foobarElement.getTypeParameters().get(0); assertThat(typeParameter.getSimpleName().toString()).isEqualTo("E"); assertThat(typeParameter.getBounds()).hasSize(1); // FooBar<E> DeclaredType bound = maybeDeclared(typeParameter.getBounds().get(0)).get(); assertThat(bound.asElement().getSimpleName().toString()).isEqualTo("FooBar"); assertThat(bound.getTypeArguments()).hasSize(1); // E TypeVariable typeArgument = maybeVariable(bound.getTypeArguments().get(0)).get(); assertThat(typeArgument.asElement()).isEqualTo(typeParameter); }; DeclaredType realFoobar = (DeclaredType) model .newType("package org.example; interface FooBar<E extends FooBar<E>> { }").asType(); GenericElement.Builder fakeFoobarBuilder = new GenericElement.Builder(FOO_BAR_NAME); fakeFoobarBuilder.getTypeParameter("E").addBound(fakeFoobarBuilder.asType()); GenericMirror fakeFoobar = fakeFoobarBuilder.build().asType(); test.accept(realFoobar); test.accept(fakeFoobar); } }
" class Builder<K, V> extends DataType_Builder<K, V> { }", "}"); TypeParameterElement k = typeElement.getTypeParameters().get(0); TypeParameterElement v = typeElement.getTypeParameters().get(1); DeclaredType mirror = (DeclaredType) typeElement.asType(); TypeVariable kVar = (TypeVariable) mirror.getTypeArguments().get(0);