package org.graalvm.compiler.serviceprovider.processor;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.PackageElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeMirror;
import javax.tools.Diagnostic.Kind;
import org.graalvm.compiler.processor.AbstractProcessor;
@SupportedAnnotationTypes("org.graalvm.compiler.serviceprovider.ServiceProvider")
public class ServiceProviderProcessor extends AbstractProcessor {
private static final String SERVICE_PROVIDER_CLASS_NAME = "org.graalvm.compiler.serviceprovider.ServiceProvider";
private final Set<TypeElement> processed = new HashSet<>();
private final Map<TypeElement, String> serviceProviders = new HashMap<>();
@Override
public SourceVersion getSupportedSourceVersion() {
return SourceVersion.latest();
}
private boolean verifyAnnotation(TypeMirror serviceInterface, TypeElement serviceProvider) {
if (!processingEnv.getTypeUtils().isSubtype(serviceProvider.asType(), serviceInterface)) {
String msg = String.format("Service provider class %s must implement service interface %s", serviceProvider.getSimpleName(), serviceInterface);
processingEnv.getMessager().printMessage(Kind.ERROR, msg, serviceProvider);
return false;
}
return true;
}
private void processElement(TypeElement serviceProvider) {
if (processed.contains(serviceProvider)) {
return;
}
processed.add(serviceProvider);
AnnotationMirror annotation = getAnnotation(serviceProvider, getType(SERVICE_PROVIDER_CLASS_NAME));
if (annotation != null) {
TypeMirror service = getAnnotationValue(annotation, "value", TypeMirror.class);
if (verifyAnnotation(service, serviceProvider)) {
if (serviceProvider.getNestingKind().isNested()) {
String msg = String.format("Service provider class %s must be a top level class", serviceProvider.getSimpleName());
processingEnv.getMessager().printMessage(Kind.ERROR, msg, serviceProvider);
} else {
TypeElement serviceElement = (TypeElement) processingEnv.getTypeUtils().asElement(service);
String serviceName = serviceElement.getSimpleName().toString();
Element enclosing = serviceElement.getEnclosingElement();
while (enclosing != null) {
final ElementKind kind = enclosing.getKind();
if (kind == ElementKind.PACKAGE) {
serviceName = ((PackageElement) enclosing).getQualifiedName().toString() + "." + serviceName;
break;
} else if (kind == ElementKind.CLASS || kind == ElementKind.INTERFACE) {
serviceName = ((TypeElement) enclosing).getSimpleName().toString() + "$" + serviceName;
enclosing = enclosing.getEnclosingElement();
} else {
String msg = String.format("Cannot generate provider descriptor for service class %s as it is not nested in a package, class or interface",
serviceElement.getQualifiedName());
processingEnv.getMessager().printMessage(Kind.ERROR, msg, serviceProvider);
return;
}
}
serviceProviders.put(serviceProvider, serviceName);
}
}
}
}
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
if (roundEnv.processingOver()) {
for (Entry<TypeElement, String> e : serviceProviders.entrySet()) {
createProviderFile(e.getKey().getQualifiedName().toString(), e.getValue(), e.getKey());
}
serviceProviders.clear();
return true;
}
TypeElement serviceProviderTypeElement = getTypeElement(SERVICE_PROVIDER_CLASS_NAME);
for (Element element : roundEnv.getElementsAnnotatedWith(serviceProviderTypeElement)) {
assert element.getKind().isClass();
processElement((TypeElement) element);
}
return true;
}
}