7 files changed, 504 insertions, 0 deletions
diff --git a/src/lombok/javac/HandlerLibrary.java b/src/lombok/javac/HandlerLibrary.java
new file mode 100644
index 00000000..6f33003f
--- /dev/null
+++ b/src/lombok/javac/HandlerLibrary.java
@@ -0,0 +1,222 @@
+package lombok.javac;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.ServiceConfigurationError;
+import java.util.ServiceLoader;
+
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.ExecutableElement;
+import javax.lang.model.element.Name;
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.TypeMirror;
+import javax.tools.Diagnostic;
+
+import lombok.core.SpiLoadUtil;
+
+
+public class HandlerLibrary {
+	private final Map<String, AnnotationHandlerContainer<?>> annotationHandlers = new HashMap<String, AnnotationHandlerContainer<?>>();
+//	private final Collection<JavacASTVisitor> visitorHandlers = new ArrayList<JavacASTVisitor>();
+	
+	private static class AnnotationHandlerContainer<T extends Annotation> {
+		private JavacAnnotationHandler<T> handler;
+		private Class<T> annotationClass;
+		
+		AnnotationHandlerContainer(JavacAnnotationHandler<T> handler, Class<T> annotationClass) {
+			this.handler = handler;
+			this.annotationClass = annotationClass;
+		}
+		
+		@SuppressWarnings("unchecked")
+		public void handle(JavacNode node, Object annInstance) {
+			handler.handle(node, (T) annInstance);
+		}
+	}
+	
+	public static HandlerLibrary load(Messager messager) {
+		HandlerLibrary library = new HandlerLibrary();
+		loadAnnotationHandlers(messager, library);
+		return library;
+	}
+	
+	@SuppressWarnings("unchecked")
+	private static void loadAnnotationHandlers(Messager messager, HandlerLibrary lib) {
+		//No, that seemingly superfluous reference to JavacAnnotationHandler's classloader is not in fact superfluous!
+		Iterator<JavacAnnotationHandler> it = ServiceLoader.load(JavacAnnotationHandler.class,
+				JavacAnnotationHandler.class.getClassLoader()).iterator();
+		while ( it.hasNext() ) {
+			try {
+				JavacAnnotationHandler<?> handler = it.next();
+				Class<? extends Annotation> annotationClass =
+					SpiLoadUtil.findAnnotationClass(handler.getClass(), JavacAnnotationHandler.class);
+				AnnotationHandlerContainer<?> container = new AnnotationHandlerContainer(handler, annotationClass);
+				if ( lib.annotationHandlers.put(container.annotationClass.getName(), container) != null ) {
+					messager.printMessage(Diagnostic.Kind.WARNING,
+							"Duplicate handlers for annotation type: " + container.annotationClass.getName());
+				}
+			} catch ( ServiceConfigurationError e ) {
+				messager.printMessage(Diagnostic.Kind.WARNING,
+						"Can't load Lombok annotation handler for javac: " + e);
+			}
+		}
+	}
+	
+	public void handleAnnotation(JavacNode node, TypeElement annotationType) {
+		AnnotationHandlerContainer<?> container = annotationHandlers.get(annotationType.getQualifiedName().toString());
+		if ( container == null ) return;
+		try {
+			container.handle(node, createAnnotation(container.annotationClass, annotationType.getQualifiedName(), node));
+		} catch ( AnnotationValueDecodeFail e ) {
+			node.addError(e.getMessage(), e.mirror, e.value);
+		}
+	}
+	
+	private Object createAnnotation(Class<? extends Annotation> target, Name annotationName, JavacNode node)
+			throws AnnotationValueDecodeFail {
+		AnnotationMirror mirror = fetchMirror(annotationName, node);
+		if ( mirror == null ) throw new AssertionError("This can't be.");
+		
+		InvocationHandler invocations = new AnnotationMirrorInvocationHandler(target, mirror);
+		return Proxy.newProxyInstance(target.getClassLoader(), new Class[] { target }, invocations);
+	}
+	
+	private static class AnnotationValueDecodeFail extends Exception {
+		private static final long serialVersionUID = 1L;
+		
+		AnnotationMirror mirror;
+		AnnotationValue value;
+		
+		AnnotationValueDecodeFail(String msg, AnnotationMirror mirror, AnnotationValue value) {
+			super(msg);
+			this.mirror = mirror;
+			this.value = value;
+		}
+	}
+	
+	private static class AnnotationMirrorInvocationHandler implements InvocationHandler {
+		private final AnnotationMirror mirror;
+		private final Map<String, Object> values = new HashMap<String, Object>();
+		
+		AnnotationMirrorInvocationHandler(Class<?> target, AnnotationMirror mirror) throws AnnotationValueDecodeFail {
+			this.mirror = mirror;
+			
+			for ( Method m : target.getDeclaredMethods() ) {
+				if ( !Modifier.isPublic(m.getModifiers()) ) continue;
+				values.put(m.getName(), decode(m));
+			}
+		}
+		
+		private Object decode(Method m) throws AnnotationValueDecodeFail {
+			for ( Map.Entry<? extends ExecutableElement, ? extends AnnotationValue> entry :
+				mirror.getElementValues().entrySet() ) {
+				
+				if ( entry.getKey().getSimpleName().contentEquals(m.getName()) ) {
+					AnnotationValue value = entry.getValue();
+					return convert(m.getReturnType(), mirror, value, value.getValue());
+				}
+			}
+			
+			return m.getDefaultValue();
+		}
+		
+		@Override public Object invoke(Object proxy, Method method, Object[] args) {
+			return values.get(method.getName());
+		}
+		
+		private Object convert(Class<?> expected, AnnotationMirror mirror, AnnotationValue value, Object v) throws AnnotationValueDecodeFail {
+			if ( expected == int.class ) {
+				if ( v instanceof Number ) return ((Number)v).intValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == long.class ) {
+				if ( v instanceof Number ) return ((Number)v).longValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == short.class ) {
+				if ( v instanceof Number ) return ((Number)v).shortValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == byte.class ) {
+				if ( v instanceof Number ) return ((Number)v).byteValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == double.class ) {
+				if ( v instanceof Number ) return ((Number)v).doubleValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == float.class ) {
+				if ( v instanceof Number ) return ((Number)v).floatValue();
+				else throw new AnnotationValueDecodeFail("Expected a numeric value here", mirror, value);
+			} else if ( expected == char.class ) {
+				if ( v instanceof Character ) return v;
+				else throw new AnnotationValueDecodeFail("Expected a character here", mirror, value);
+			} else if ( expected == boolean.class ) {
+				if ( v instanceof Boolean ) return v;
+				else throw new AnnotationValueDecodeFail("Expected a boolean here", mirror, value);
+			} else if ( expected == String.class ) {
+				if ( v instanceof String ) return v;
+				else throw new AnnotationValueDecodeFail("Expected a String here", mirror, value);
+			} else if ( expected == Class.class ) {
+				if ( v instanceof TypeMirror ) {
+					try {
+						return Class.forName(v.toString());
+					} catch ( ClassNotFoundException e ) {
+						throw new AnnotationValueDecodeFail(
+								"I can't find this class. Lombok only works well with types in the core java libraries.",
+								mirror, value);
+					}
+				} else throw new AnnotationValueDecodeFail("Expected a class literal here", mirror, value);
+			} else if ( Enum.class.isAssignableFrom(expected) ) {
+				if ( v instanceof VariableElement ) {
+					String n = ((VariableElement)v).getSimpleName().toString();
+					@SuppressWarnings("unchecked")
+					Object enumVal = Enum.valueOf((Class<? extends Enum>)expected, n);
+					return enumVal;
+				} else throw new AnnotationValueDecodeFail("Expected an enum value here", mirror, value);
+			} else if ( expected.isArray() ) {
+				if ( v instanceof Collection<?> ) {
+					List<Object> convertedValues = new ArrayList<Object>();
+					Class<?> componentType = expected.getComponentType();
+					for ( Object innerV : (Collection<?>)v ) {
+						convertedValues.add(convert(componentType, mirror, value, innerV));
+					}
+					
+					Object array = Array.newInstance(componentType, convertedValues.size());
+					int pos = 0;
+					for ( Object converted : convertedValues ) Array.set(array, pos++, converted);
+					return array;
+				} else throw new AnnotationValueDecodeFail("Expected an array value here", mirror, value);
+//				Collection<AnnotationValue> result = (Collection<AnnotationValue>)entry.getValue().getValue();
+//				return result;
+			} else {
+				throw new AssertionError("We didn't know this is even a legal annotation type: " + expected);
+			}
+		}
+	}
+	
+	private AnnotationMirror fetchMirror(Name lookingFor, JavacNode node) {
+		for ( AnnotationMirror mirror : node.getJavacAST().getAnnotationMirrors() ) {
+			if ( !lookingFor.contentEquals(
+					((TypeElement)(mirror.getAnnotationType()).asElement()).getQualifiedName()) ) continue;
+			return mirror;
+		}
+		return null;
+	}
+
+	public void handleType(TypeElement typeElement) {
+		//Later!
+	}
+	
+	public boolean hasHandlerFor(TypeElement annotationType) {
+		return annotationHandlers.containsKey(annotationType.getQualifiedName().toString());
+	}
+}
diff --git a/src/lombok/javac/JavacAnnotationHandler.java b/src/lombok/javac/JavacAnnotationHandler.java
new file mode 100644
index 00000000..67542a12
--- /dev/null
+++ b/src/lombok/javac/JavacAnnotationHandler.java
@@ -0,0 +1,7 @@
+package lombok.javac;
+
+import java.lang.annotation.Annotation;
+
+public interface JavacAnnotationHandler<T extends Annotation> {
+	void handle(JavacNode annotedElement, T annotation);
+}
diff --git a/src/lombok/javac/JavacNode.java b/src/lombok/javac/JavacNode.java
new file mode 100644
index 00000000..2e65e1d1
--- /dev/null
+++ b/src/lombok/javac/JavacNode.java
@@ -0,0 +1,63 @@
+package lombok.javac;
+
+import javax.annotation.processing.Messager;
+import javax.lang.model.element.AnnotationMirror;
+import javax.lang.model.element.AnnotationValue;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+import javax.tools.Diagnostic;
+
+import com.sun.source.util.Trees;
+import com.sun.tools.javac.processing.JavacProcessingEnvironment;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.util.Name;
+
+public class JavacNode {
+	private final Element node;
+	private final Messager messager;
+	private final JavacProcessingEnvironment env;
+	private final Trees trees;
+	
+	public JavacNode(Trees trees, JavacProcessingEnvironment env, Element node) {
+		this.trees = trees;
+		this.env = env;
+		this.node = node;
+		this.messager = env.getMessager();
+	}
+	
+	public Element getJavacAST() {
+		return node;
+	}
+	
+	public JCClassDecl getEnclosingType() {
+		Element parent = node;
+		while ( !(parent instanceof TypeElement) ) parent = node.getEnclosingElement();
+		TypeElement classElement = (TypeElement)parent;
+		return (JCClassDecl)trees.getTree(classElement);
+	}
+	
+	public Name.Table createNameTable() {
+		return Name.Table.instance(env.getContext());
+	}
+	
+	public TreeMaker createTreeMaker() {
+		return TreeMaker.instance(env.getContext());
+	}
+	
+	public void addError(String message) {
+		this.messager.printMessage(Diagnostic.Kind.ERROR, message, node);
+	}
+	
+	public void addError(String message, AnnotationMirror mirror, AnnotationValue value) {
+		this.messager.printMessage(Diagnostic.Kind.ERROR, message, node, mirror, value);
+	}
+	
+	public void addWarning(String message) {
+		this.messager.printMessage(Diagnostic.Kind.WARNING, message, node);
+	}
+	
+	public void addWarning(String message, AnnotationMirror mirror, AnnotationValue value) {
+		this.messager.printMessage(Diagnostic.Kind.WARNING, message, node, mirror, value);
+	}
+}
diff --git a/src/lombok/javac/apt/PKG.java b/src/lombok/javac/apt/PKG.java
new file mode 100644
index 00000000..2ecf1c7a
--- /dev/null
+++ b/src/lombok/javac/apt/PKG.java
@@ -0,0 +1,56 @@
+package lombok.javac.apt;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import lombok.Lombok;
+
+
+class PKG {
+	private PKG() {}
+	
+	static boolean isInstanceOf(Object o, String className) {
+		if ( o == null ) return false;
+		return isInstanceOf(o.getClass(), className);
+	}
+	
+	static boolean isInstanceOf(Class<?> c, String className) {
+		if ( c == Object.class || c == null ) return false;
+		
+		if ( c.getName().equals(className) ) return true;
+		
+		if ( isInstanceOf(c.getSuperclass(), className) ) return true;
+		for ( Class<?> iface : c.getInterfaces() ) {
+			if ( isInstanceOf(iface, className) ) return true;
+		}
+		
+		return false;
+	}
+	
+	static byte[] readResource(String name) {
+		return readResource(PKG.class.getClassLoader(), name);
+	}
+	
+	static byte[] readResource(ClassLoader loader, String name) {
+		InputStream in = loader.getResourceAsStream(name);
+		if ( in == null ) throw Lombok.sneakyThrow(new IOException("Not found: " + name));
+		
+		try {
+			return readStream(in);
+		} catch (IOException e) {
+			throw Lombok.sneakyThrow(e);
+		}
+	}
+	
+	static byte[] readStream(InputStream in) throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		byte[] b = new byte[65536];
+		while ( true ) {
+			int r = in.read(b);
+			if ( r == -1 ) break;
+			if ( r > 0 ) baos.write(b, 0, r);
+		}
+		return baos.toByteArray();
+	}
+}
diff --git a/src/lombok/javac/apt/Processor.java b/src/lombok/javac/apt/Processor.java
new file mode 100644
index 00000000..14a62367
--- /dev/null
+++ b/src/lombok/javac/apt/Processor.java
@@ -0,0 +1,62 @@
+package lombok.javac.apt;
+
+import java.util.Set;
+
+import javax.annotation.processing.AbstractProcessor;
+import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.RoundEnvironment;
+import javax.annotation.processing.SupportedAnnotationTypes;
+import javax.annotation.processing.SupportedSourceVersion;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.Element;
+import javax.lang.model.element.TypeElement;
+
+import lombok.javac.HandlerLibrary;
+import lombok.javac.JavacNode;
+
+import com.sun.source.util.Trees;
+import com.sun.tools.javac.processing.JavacProcessingEnvironment;
+
+
+@SupportedAnnotationTypes("*")
+@SupportedSourceVersion(SourceVersion.RELEASE_6)
+public class Processor extends AbstractProcessor {
+	private JavacProcessingEnvironment processingEnv;
+	private HandlerLibrary handlers;
+	private Trees trees;
+	
+	@Override public void init(ProcessingEnvironment processingEnv) {
+		super.init(processingEnv);
+		if ( !(processingEnv instanceof JavacProcessingEnvironment) ) this.processingEnv = null;
+		else {
+			this.processingEnv = (JavacProcessingEnvironment) processingEnv;
+			handlers = HandlerLibrary.load(processingEnv.getMessager());
+		}
+	}
+	
+	@Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+		if ( processingEnv == null ) return false;
+		
+		trees = Trees.instance(processingEnv);
+		
+		for ( TypeElement annotationType : annotations ) {
+			if ( !handlers.hasHandlerFor(annotationType) ) continue;
+			for ( Element element : roundEnv.getElementsAnnotatedWith(annotationType) ) {
+				System.out.println("HIGHER PING: " + element);
+				handlers.handleAnnotation(createNode(element), annotationType);
+			}
+		}
+		
+		for ( Element element : roundEnv.getRootElements() ) {
+			if ( element instanceof TypeElement ) {
+				handlers.handleType((TypeElement)element);
+			}
+		}
+		
+		return false;
+	}
+	
+	private JavacNode createNode(Element element) {
+		return new JavacNode(trees, processingEnv, element);
+	}
+}
diff --git a/src/lombok/javac/handlers/HandleGetter_javac.java b/src/lombok/javac/handlers/HandleGetter_javac.java
new file mode 100644
index 00000000..77ce2b4f
--- /dev/null
+++ b/src/lombok/javac/handlers/HandleGetter_javac.java
@@ -0,0 +1,60 @@
+package lombok.javac.handlers;
+
+import static lombok.javac.handlers.PKG.*;
+
+import javax.lang.model.element.Element;
+
+import lombok.Getter;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.source.tree.MethodTree;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.TreeMaker;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCBlock;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCStatement;
+import com.sun.tools.javac.tree.JCTree.JCTypeParameter;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+
+@ProviderFor(JavacAnnotationHandler.class)
+public class HandleGetter_javac implements JavacAnnotationHandler<Getter> {
+	@Override public void handle(JavacNode node, Getter getter) {
+		System.out.println("PING: " + node.getJavacAST());
+		if ( !node.getJavacAST().getKind().isField() ) {
+			node.addError("@Getter is only supported on a field.");
+			return;
+		}
+		
+		JCClassDecl javacClassTree = node.getEnclosingType();
+		
+		int access = toJavacModifier(getter.value());
+		
+		MethodTree getterMethod = createGetter(access, node.getJavacAST(), node.createTreeMaker(), node.createNameTable());
+		javacClassTree.defs = javacClassTree.defs.append((JCTree)getterMethod);
+	}
+	
+	private MethodTree createGetter(int access, Element field, TreeMaker treeMaker, Name.Table nameTable) {
+		JCStatement returnStatement = treeMaker.Return(treeMaker.Ident((Symbol)field));
+		
+		JCBlock methodBody = treeMaker.Block(0, List.of(returnStatement));
+		Name methodName = Name.fromString(nameTable, toGetterName(field));
+		JCExpression methodType = treeMaker.Type((Type)field.asType());
+		
+		List<JCTypeParameter> methodGenericParams = List.nil();
+		List<JCVariableDecl> parameters = List.nil();
+		List<JCExpression> throwsClauses = List.nil();
+		JCExpression annotationMethodDefaultValue = null;
+		
+		return treeMaker.MethodDef(treeMaker.Modifiers(access, List.<JCAnnotation>nil()), methodName, methodType,
+				methodGenericParams, parameters, throwsClauses, methodBody, annotationMethodDefaultValue);
+	}
+}
diff --git a/src/lombok/javac/handlers/PKG.java b/src/lombok/javac/handlers/PKG.java
new file mode 100644
index 00000000..4622c3ee
--- /dev/null
+++ b/src/lombok/javac/handlers/PKG.java
@@ -0,0 +1,34 @@
+package lombok.javac.handlers;
+
+import java.lang.reflect.Modifier;
+
+import javax.lang.model.element.Element;
+import javax.lang.model.type.TypeKind;
+
+import lombok.AccessLevel;
+import lombok.core.TransformationsUtil;
+
+class PKG {
+	static String toGetterName(Element field) {
+		CharSequence fieldName = field.getSimpleName();
+		
+		boolean isBoolean = field.asType().getKind() == TypeKind.BOOLEAN;
+		
+		return TransformationsUtil.toGetterName(fieldName, isBoolean);
+	}
+	
+	static int toJavacModifier(AccessLevel accessLevel) {
+		switch ( accessLevel ) {
+		case MODULE:
+		case PACKAGE:
+			return 0;
+		default:
+		case PUBLIC:
+			return Modifier.PUBLIC;
+		case PRIVATE:
+			return Modifier.PRIVATE;
+		case PROTECTED:
+			return Modifier.PROTECTED;
+		}
+	}
+}