implement Covariant and Contravariant annotation, and impose strict if specified

Author: FelixAnthonisen

pom.xml

@@ -43,6 +43,11 @@
       <artifactId>auto-service</artifactId>
       <version>1.0-rc5</version>
     </dependency>
+    <dependency>
+      <groupId>io.leangen.geantyref</groupId>
+      <artifactId>geantyref</artifactId>
+      <version>2.0.0</version>
+  </dependency>
   </dependencies>
 
 

src/main/java/anthonisen/felix/annotationProcessing/Contravariant.java

@@ -0,0 +1,12 @@
+package anthonisen.felix.annotationProcessing;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE_PARAMETER)
+public @interface Contravariant {
+
+}

src/main/java/anthonisen/felix/annotationProcessing/Covariant.java

@@ -0,0 +1,12 @@
+package anthonisen.felix.annotationProcessing;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.SOURCE)
+@Target(ElementType.TYPE_PARAMETER)
+public @interface Covariant {
+
+}

src/main/java/anthonisen/felix/annotationProcessing/VarianceProcessor.java

@@ -2,7 +2,13 @@
 
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.type.Type;
+
+import java.lang.annotation.Annotation;
+
+import io.leangen.geantyref.AnnotationFormatException;
+import io.leangen.geantyref.TypeFactory;
 import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
 import javax.annotation.processing.AbstractProcessor;
 import javax.annotation.processing.Messager;
@@ -16,70 +22,98 @@
 import javax.lang.model.element.TypeParameterElement;
 import javax.tools.Diagnostic.Kind;
 import com.google.auto.service.AutoService;
+import com.google.common.collect.ImmutableList;
+
 import anthonisen.felix.astParsing.AstManipulator;
 import anthonisen.felix.astParsing.util.TypeHandler;
 import anthonisen.felix.astParsing.visitors.ParameterTypeCollector;
 import anthonisen.felix.astParsing.visitors.ReturnTypeCollector;
 
 @AutoService(Processor.class)
 @SupportedSourceVersion(SourceVersion.RELEASE_17)
-@SupportedAnnotationTypes("anthonisen.felix.annotationProcessing.MyVariance")
+@SupportedAnnotationTypes({
+        "anthonisen.felix.annotationProcessing.MyVariance",
+        "anthonisen.felix.annotationProcessing.Covariant",
+        "anthonisen.felix.annotationProcessing.Contravariant",
+})
 public class VarianceProcessor extends AbstractProcessor {
     private Messager messager;
     private AstManipulator astManipulator;
+    private final ImmutableList<Class<? extends Annotation>> supportedAnnotations = ImmutableList.of(MyVariance.class,
+            Covariant.class, Contravariant.class);
 
     @Override
     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
         messager = processingEnv.getMessager();
         astManipulator = new AstManipulator(messager,
                 System.getProperty("user.dir") + "/src/main/java");
         messager.printMessage(Kind.NOTE, "Processing annotations:\n");
-        for (Element e : roundEnv.getElementsAnnotatedWith(MyVariance.class)) {
-            MyVariance annotation = e.getAnnotation(MyVariance.class);
-            // should not process method declarations
-            if (!isClassParameter(e))
-                continue;
+        for (Class<? extends Annotation> annotationType : supportedAnnotations) {
+            for (Element e : roundEnv.getElementsAnnotatedWith(annotationType)) {
+                MyVariance annotation = e.getAnnotation(MyVariance.class);
+                try {
+                    if (annotationType.equals(Covariant.class))
+                        annotation = TypeFactory.annotation(MyVariance.class,
+                                Map.of("variance", VarianceType.COVARIANT, "strict", true));
+                    else if (annotationType.equals(Contravariant.class))
+                        annotation = TypeFactory.annotation(MyVariance.class,
+                                Map.of("variance", VarianceType.CONTRAVARIANT, "strict", true));
 
-            TypeParameterElement tE = (TypeParameterElement) e;
-            String className = tE.getEnclosingElement().getSimpleName().toString();
-            String packageName = processingEnv.getElementUtils().getPackageOf(tE.getEnclosingElement()).toString();
+                } catch (AnnotationFormatException ex) {
+                    // catch this later
+                }
+                if (annotation != null)
+                    processElement(annotation, e);
+                else
+                    messager.printMessage(Kind.WARNING, "Could not parse annotation for element: " + e);
+            }
+        }
+        astManipulator.applyChanges();
+        return true;
+    }
 
-            if (packageName.contains("output"))
-                continue;
+    private void processElement(MyVariance annotation, Element e) {
+        // should not process method declarations
+        if (!isClassParameter(e))
+            return;
 
-            if (annotation.variance() == VarianceType.INVARIANT) {
-                messager.printMessage(Kind.NOTE,
-                        String.format(
-                                "Invariant type parameter detected in class: %s\nWill not proceed with AST manipulation",
-                                className));
-            }
+        TypeParameterElement tE = (TypeParameterElement) e;
+        String className = tE.getEnclosingElement().getSimpleName().toString();
+        String packageName = processingEnv.getElementUtils().getPackageOf(tE.getEnclosingElement()).toString();
 
-            checkVariance(className, annotation.variance(), packageName, tE.getSimpleName().toString());
-            astManipulator.eraseTypesAndInsertCasts(className + ".java", packageName, tE.getSimpleName().toString());
+        if (packageName.contains("output"))
+            return;
 
+        if (annotation.variance() == VarianceType.INVARIANT) {
+            messager.printMessage(Kind.NOTE,
+                    String.format(
+                            "Invariant type parameter detected in class: %s\nWill not proceed with AST manipulation",
+                            className));
         }
-        astManipulator.applyChanges();
-        return true;
+
+        checkVariance(className, annotation, packageName, tE.getSimpleName().toString());
+        astManipulator.eraseTypesAndInsertCasts(className + ".java", packageName,
+                tE.getSimpleName().toString());
     }
 
-    private void checkVariance(String className, VarianceType variance, String packageName, String typeOfInterest) {
+    private void checkVariance(String className, MyVariance annotation, String packageName, String typeOfInterest) {
         Set<Type> types = new HashSet<>();
         CompilationUnit cu = astManipulator.getSourceRoot().parse(packageName, className
                 + ".java");
-        if (variance == VarianceType.CONTRAVARIANT)
+        if (annotation.variance() == VarianceType.CONTRAVARIANT)
             cu.accept(new ReturnTypeCollector(), types);
         else
             cu.accept(new ParameterTypeCollector(), types);
 
         for (Type type : types) {
             if (TypeHandler.containsType(type, typeOfInterest)) {
                 messager.printMessage(
-                        Kind.WARNING,
+                        annotation.strict() ? Kind.ERROR : Kind.WARNING,
                         String.format(
                                 "%s is declared as %s, but does not conform to constraints: contains T in %s position",
                                 className,
-                                variance,
-                                variance == VarianceType.COVARIANT ? "IN" : "OUT"));
+                                annotation.variance(),
+                                annotation.variance() == VarianceType.COVARIANT ? "IN" : "OUT"));
                 break;
             }
         }