enhanced filtering

Author: Maowcraft

example-java-9/src/main/java/org/transparent/lucent/example/ExampleTranslator.java

@@ -7,22 +7,21 @@
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import org.transparent.lucent.transform.LucentTranslator;
+import org.transparent.lucent.transform.LucentValidator;
 
 import javax.lang.model.element.Element;
 
 public final class ExampleTranslator extends LucentTranslator {
-    public ExampleTranslator(Names names, TreeMaker factory) {
-        super(names, factory);
+    public ExampleTranslator(Names names, TreeMaker factory, LucentValidator validator) {
+        super(names, factory, validator);
     }
 
     @Override
-    public void translate(JCTree tree, Element element) {
-        if (tree instanceof JCClassDecl) {
-            final JCClassDecl clazz = (JCClassDecl) tree;
-            clazz.defs = clazz.defs
-                    .append(field());
-            result = clazz;
-        }
+    public void visitClassDef(JCClassDecl tree) {
+        super.visitClassDef(tree);
+        tree.defs = tree.defs
+                .append(field());
+        result = tree;
     }
 
     private JCVariableDecl field() {

example-test/src/main/java/org/transparent/lucent/example/test/Test2.java

@@ -0,0 +1,6 @@
+package org.transparent.lucent.example.test;
+
+// This class isn't annotated, if the generated field appears on it,
+// it means that the annotated filtering doesn't work.
+public class Test2 {
+}

example/src/main/java/org/transparent/lucent/example/ExampleTranslator.java

@@ -7,22 +7,21 @@
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import org.transparent.lucent.transform.LucentTranslator;
+import org.transparent.lucent.transform.LucentValidator;
 
 import javax.lang.model.element.Element;
 
 public final class ExampleTranslator extends LucentTranslator {
-    public ExampleTranslator(Names names, TreeMaker factory) {
-        super(names, factory);
+    public ExampleTranslator(Names names, TreeMaker factory, LucentValidator validator) {
+        super(names, factory, validator);
     }
 
     @Override
-    public void translate(JCTree tree, Element element) {
-        if (tree instanceof JCClassDecl) {
-            final JCClassDecl clazz = (JCClassDecl) tree;
-            clazz.defs = clazz.defs
-                    .append(field());
-            result = clazz;
-        }
+    public void visitClassDef(JCClassDecl tree) {
+        super.visitClassDef(tree);
+        tree.defs = tree.defs
+                .append(field());
+        result = tree;
     }
 
     private JCVariableDecl field() {

src/main/java/org/transparent/lucent/processor/LucentProcessor.java

@@ -8,6 +8,8 @@
 import com.sun.tools.javac.util.Names;
 import org.transparent.lucent.transform.LucentTranslator;
 import org.transparent.lucent.transform.LucentValidator;
+import org.transparent.lucent.util.FilteringTranslator;
+import org.transparent.lucent.util.TriFunction;
 import org.transparent.lucent.util.TypeKind;
 
 import javax.annotation.processing.AbstractProcessor;
@@ -19,17 +21,17 @@
 import javax.lang.model.element.ElementKind;
 import javax.lang.model.element.TypeElement;
 import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
 import java.util.*;
-import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
+import static org.transparent.lucent.util.CollectionsUtil.*;
+
 /**
  * A wrapper around {@link AbstractProcessor} that allows for cleaner AST modification.
  * <p>
  * This processor will process root elements,
  * skip the ones that aren't supported by the processor,
- * and invoke {@link LucentTranslator#translate(JCTree, Element)} on them.
+ * and visit the root elements' trees via {@link JCTree#accept(JCTree.Visitor)}.
  * <p>
  * It is up to the associated {@link LucentTranslator}
  * specified by {@link #getTranslator()} to filter and transform trees obtained from
@@ -45,6 +47,7 @@
 public abstract class LucentProcessor extends AbstractProcessor {
     private final Set<TypeKind> kinds;
     private LucentTranslator translator;
+    private LucentValidator validator;
 
     protected Trees trees;
     protected Context context;
@@ -67,6 +70,7 @@ public synchronized void init(ProcessingEnvironment env) {
         factory = TreeMaker.instance(context);
         names = Names.instance(context);
         translator = getTranslator();
+        validator = getValidator();
     }
 
     /**
@@ -100,7 +104,8 @@ protected boolean process(RoundEnvironment env) {
                 final JCTree tree = (JCTree) trees.getTree(element);
                 preTranslate(tree, element, translator);
                 if (translator != null)
-                    translator.translate(tree, element);
+                    new FilteringTranslator(getSupportedAnnotations(), translator)
+                            .filter(tree);
                 postTranslate(tree, element, translator);
             }
         }
@@ -160,9 +165,7 @@ protected void postTranslate(JCTree tree, Element element, LucentTranslator tran
      * @return a set of supported type kinds
      */
     public Set<TypeKind> getSupportedTypeKinds() {
-        final Set<TypeKind> types = new HashSet<>();
-        Collections.addAll(types, TypeKind.values());
-        return types;
+        return hashSetOf(TypeKind.values());
     }
 
     /**
@@ -181,6 +184,17 @@ public LucentTranslator getTranslator() {
         return null;
     }
 
+    /**
+     * Returns the validator associated with this processor.
+     * <p>
+     * An instance of this is passed to the translator.
+     *
+     * @return the associated {@link LucentValidator}
+     */
+    public LucentValidator getValidator() {
+        return null;
+    }
+
     /**
      * Returns an instance of {@link LucentTranslator} based on the fields of this processor.
      * <p>
@@ -191,9 +205,10 @@ public LucentTranslator getTranslator() {
      * @return an instance of {@code LucentTranslator}
      */
     protected LucentTranslator translator(
-            BiFunction<Names, TreeMaker,
+            TriFunction<Names, TreeMaker,
+                    LucentValidator,
                     LucentTranslator> constructor) {
-        return constructor.apply(names, factory);
+        return constructor.apply(names, factory, validator);
     }
 
     /**

src/main/java/org/transparent/lucent/transform/LucentTranslator.java

@@ -16,7 +16,7 @@
  * These are usually instantiated by {@link LucentProcessor} and are called when a valid element
  * has been processed and is able to be transformed.
  * <p>
- * The processor's filtering is lightweight however, and as such, this class provides access to a
+ * The processor's filtering is lightweight however, and as such, is provided access to a
  * {@link LucentValidator} which allows individual types of {@code JCTree}s to be validated based on the
  * implementation of the validator.
  *
@@ -37,31 +37,10 @@ public abstract class LucentTranslator extends TreeTranslator {
      * @param names an instance of {@code Names} that can be used to get instances of {@link Name}
      * @param factory an instance of {@code TreeMaker} that allows for transformation of trees
      */
-    public LucentTranslator(Names names, TreeMaker factory) {
-        this.validator = getValidator();
+    public LucentTranslator(Names names, TreeMaker factory, LucentValidator validator) {
         this.names = names;
         this.factory = factory;
+        this.validator = validator;
     }
-
-    /**
-     * Returns the validator associated with this translator.
-     * <p>
-     * If necessary, it's possible to use this to have
-     * dynamic validation set up for your processor as the {@link #validator}
-     * field of all translators is mutable.
-     *
-     * @return the associated {@link LucentValidator}
-     */
-    protected LucentValidator getValidator() {
-        return null;
-    }
-
-    /**
-     * Where the {@link JCTree} transformations occur.
-     *
-     * @param tree the target {@code JCTree}
-     * @param element the {@link Element} associated with this tree
-     */
-    public abstract void translate(JCTree tree, Element element);
 }
 

src/main/java/org/transparent/lucent/util/CollectionsUtil.java

@@ -0,0 +1,20 @@
+package org.transparent.lucent.util;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+public final class CollectionsUtil {
+    private CollectionsUtil() {}
+
+    @SafeVarargs
+    public static <T> Set<T> hashSetOf(T... elements) {
+        return new HashSet<>(Arrays.asList(elements));
+    }
+
+    @SafeVarargs
+    public static <T> Set<T> linkedHashSetOf(T... elements) {
+        return new LinkedHashSet<>(Arrays.asList(elements));
+    }
+}

src/main/java/org/transparent/lucent/util/FilteringTranslator.java

@@ -0,0 +1,75 @@
+package org.transparent.lucent.util;
+
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.tree.TreeTranslator;
+import org.transparent.lucent.transform.LucentTranslator;
+
+import java.lang.annotation.Annotation;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * This implementation of a {@link TreeTranslator} stores a {@link LucentTranslator}
+ * and filters through annotated elements so that manual filtering doesn't need to be done.
+ *
+ * @author Maow
+ * @version %I%
+ * @since 1.0.0
+ */
+// TODO: Document methods
+public final class FilteringTranslator extends TreeTranslator {
+    private final Set<String> annotations;
+    private final LucentTranslator translator;
+
+    public FilteringTranslator(
+            Set<Class<? extends Annotation>> annotations,
+            LucentTranslator translator) {
+        this.annotations = annotations
+                .stream()
+                .map(Class::getCanonicalName)
+                .collect(Collectors.toSet());
+        this.translator = translator;
+    }
+
+    public void filter(JCTree tree) {
+        if (tree instanceof JCClassDecl) {
+            final JCClassDecl clazz = (JCClassDecl) tree;
+            filterClass(clazz);
+            for (JCTree def : clazz.defs)
+                filterMember(def);
+        }
+    }
+
+    private void filterClass(JCClassDecl clazz) {
+        if (isAnnotated(clazz))
+            clazz.accept(translator);
+    }
+
+    private void filterMember(JCTree tree) {
+        if (isAnnotated(tree))
+            tree.accept(translator);
+    }
+
+    private boolean isAnnotated(JCTree tree) {
+        JCModifiers mods = null;
+        if (tree instanceof JCClassDecl)
+            mods = ((JCClassDecl) tree).mods;
+        else if (tree instanceof JCVariableDecl)
+            mods = ((JCVariableDecl) tree).mods;
+        else if (tree instanceof JCMethodDecl)
+            mods = ((JCMethodDecl) tree).mods;
+        if (mods != null) return isAnnotated(mods);
+        return false;
+    }
+
+    private boolean isAnnotated(JCModifiers mods) {
+        if (mods.annotations.isEmpty()) return false;
+        return mods.annotations.stream().anyMatch(annotation ->
+                annotations.contains(
+                        annotation.type.tsym
+                                .getQualifiedName()
+                                .toString()
+                ));
+    }
+}

src/main/java/org/transparent/lucent/util/TriFunction.java

@@ -0,0 +1,20 @@
+package org.transparent.lucent.util;
+
+import java.util.function.Function;
+
+/**
+ * A functional interface returning a type from three parameters.
+ *
+ * @author Maow
+ * @version %I%
+ * @param <T> first parameter
+ * @param <U> second parameter
+ * @param <V> third parameter
+ * @param <W> type to return
+ * @see Function
+ * @since 1.0.0
+ */
+@FunctionalInterface
+public interface TriFunction<T, U, V, W> {
+    W apply(T t, U u, V v);
+}