'val' support for eclipse.

4 files changed, 327 insertions, 3 deletions

diff --git a/src/core/lombok/eclipse/Eclipse.java b/src/core/lombok/eclipse/Eclipse.java
index c70660f4..ac8505af 100644
--- a/src/core/lombok/eclipse/Eclipse.java
+++ b/src/core/lombok/eclipse/Eclipse.java
@@ -25,6 +25,7 @@ import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
@@ -62,7 +63,13 @@ import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
 import org.eclipse.jdt.internal.compiler.ast.TypeParameter;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.eclipse.jdt.internal.compiler.ast.Wildcard;
+import org.eclipse.jdt.internal.compiler.lookup.CaptureBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ParameterizedTypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
+import org.eclipse.jdt.internal.compiler.lookup.WildcardBinding;
 import org.osgi.framework.Bundle;
 
 public class Eclipse {
@@ -156,7 +163,6 @@ public class Eclipse {
 		return result;
 	}
 	
-	
 	/**
 	 * You can't share TypeParameter objects or bad things happen; for example, one 'T' resolves differently
 	 * from another 'T', even for the same T in a single class file. Unfortunately the TypeParameter type hierarchy
@@ -292,6 +298,138 @@ public class Eclipse {
 		return ref;
 	}
 	
+	private static long pos(ASTNode node) {
+		return ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL);
+	}
+	
+	public static long[] poss(ASTNode node, int repeat) {
+		long p = ((long) node.sourceStart << 32) | (node.sourceEnd & 0xFFFFFFFFL);
+		long[] out = new long[repeat];
+		Arrays.fill(out, p);
+		return out;
+	}
+	
+	public static TypeReference makeType(TypeBinding binding, ASTNode pos, boolean allowCompound) {
+		// Primitives
+		switch (binding.id) {
+		case TypeIds.T_int:
+			return new SingleTypeReference(TypeConstants.INT, pos(pos));
+		case TypeIds.T_long:
+			return new SingleTypeReference(TypeConstants.LONG, pos(pos));
+		case TypeIds.T_short:
+			return new SingleTypeReference(TypeConstants.SHORT, pos(pos));
+		case TypeIds.T_byte:
+			return new SingleTypeReference(TypeConstants.BYTE, pos(pos));
+		case TypeIds.T_double:
+			return new SingleTypeReference(TypeConstants.DOUBLE, pos(pos));
+		case TypeIds.T_float:
+			return new SingleTypeReference(TypeConstants.FLOAT, pos(pos));
+		case TypeIds.T_boolean:
+			return new SingleTypeReference(TypeConstants.BOOLEAN, pos(pos));
+		case TypeIds.T_void:
+			return new SingleTypeReference(TypeConstants.VOID, pos(pos));
+		case TypeIds.T_char:
+			return new SingleTypeReference(TypeConstants.CHAR, pos(pos));
+		case TypeIds.T_null:
+			return null;
+		}
+		
+		if (binding.isAnonymousType()) {
+			ReferenceBinding ref = (ReferenceBinding)binding;
+			ReferenceBinding[] supers = ref.superInterfaces();
+			if (supers == null || supers.length == 0) supers = new ReferenceBinding[] {ref.superclass()};
+			if (supers[0] == null) return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+			return makeType(supers[0], pos, false);
+		}
+		
+		if (binding instanceof CaptureBinding) {
+			return makeType(((CaptureBinding)binding).wildcard, pos, allowCompound);
+		}
+		
+		if (binding.isUnboundWildcard()) {
+			if (!allowCompound) {
+				return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+			} else {
+				Wildcard out = new Wildcard(Wildcard.UNBOUND);
+				out.sourceStart = pos.sourceStart;
+				out.sourceEnd = pos.sourceEnd;
+				return out;
+			}
+		}
+		
+		if (binding.isWildcard()) {
+			WildcardBinding wildcard = (WildcardBinding) binding;
+			if (wildcard.boundKind == Wildcard.EXTENDS) {
+				if (!allowCompound) {
+					return makeType(wildcard.bound, pos, false);
+				} else {
+					Wildcard out = new Wildcard(Wildcard.EXTENDS);
+					out.bound = makeType(wildcard.bound, pos, false);
+					out.sourceStart = pos.sourceStart;
+					out.sourceEnd = pos.sourceEnd;
+					return out;
+				}
+			} else if (allowCompound && wildcard.boundKind == Wildcard.SUPER) {
+				Wildcard out = new Wildcard(Wildcard.SUPER);
+				out.bound = makeType(wildcard.bound, pos, false);
+				out.sourceStart = pos.sourceStart;
+				out.sourceEnd = pos.sourceEnd;
+				return out;
+			} else {
+				return new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, poss(pos, 3));
+			}
+		}
+		
+		char[][] parts;
+		
+		if (binding.isLocalType() || binding.isTypeVariable()) {
+			parts = new char[][] { binding.shortReadableName() };
+		} else {
+			String[] pkg = new String(binding.qualifiedPackageName()).split("\\.");
+			String[] name = new String(binding.qualifiedSourceName()).split("\\.");
+			parts = new char[pkg.length + name.length][];
+			int ptr;
+			for (ptr = 0; ptr < pkg.length; ptr++) parts[ptr] = pkg[ptr].toCharArray();
+			for (; ptr < pkg.length + name.length; ptr++) parts[ptr] = name[ptr - pkg.length].toCharArray();
+		}
+		
+		TypeReference[] params = new TypeReference[0];
+		
+		if (binding instanceof ParameterizedTypeBinding) {
+			ParameterizedTypeBinding paramized = (ParameterizedTypeBinding) binding;
+			if (paramized.arguments != null) {
+				params = new TypeReference[paramized.arguments.length];
+				for (int i = 0; i < params.length; i++) {
+					params[i] = makeType(paramized.arguments[i], pos, true);
+				}
+			}
+		}
+		
+		int dims = binding.dimensions();
+		
+		if (params.length > 0) {
+			if (parts.length > 1) {
+				TypeReference[][] typeArguments = new TypeReference[parts.length][];
+				typeArguments[typeArguments.length - 1] = params;
+				return new ParameterizedQualifiedTypeReference(parts, typeArguments, dims, poss(pos, parts.length));
+			}
+			return new ParameterizedSingleTypeReference(parts[0], params, dims, pos(pos));
+		}
+		
+		if (dims > 0) {
+			if (parts.length > 1) {
+				return new ArrayQualifiedTypeReference(parts, dims, poss(pos, parts.length));
+			}
+			return new ArrayTypeReference(parts[0], dims, pos(pos));
+		}
+		
+		if (parts.length > 1) {
+			return new QualifiedTypeReference(parts, poss(pos, parts.length));
+		}
+		return new SingleTypeReference(parts[0], pos(pos));
+		
+	}
+	
 	public static Annotation[] copyAnnotations(Annotation[] annotations, ASTNode source) {
 		return copyAnnotations(annotations, null, source);
 	}
diff --git a/src/core/lombok/eclipse/handlers/HandleVal.java b/src/core/lombok/eclipse/handlers/HandleVal.java
new file mode 100644
index 00000000..6fa39b10
--- /dev/null
+++ b/src/core/lombok/eclipse/handlers/HandleVal.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright © 2009-2010 Reinier Zwitserloot, Roel Spilker and Robbert Jan Grootjans.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package lombok.eclipse.handlers;
+
+import lombok.eclipse.EclipseASTAdapter;
+import lombok.eclipse.EclipseASTVisitor;
+import lombok.eclipse.EclipseNode;
+
+import org.eclipse.jdt.internal.compiler.ast.ArrayInitializer;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
+import org.mangosdk.spi.ProviderFor;
+
+/*
+ * This class just handles 2 basic error cases. The real meat of eclipse 'val' support is in {@code EclipsePatcher}'s {@code patchHandleVal} method.
+ */
+@ProviderFor(EclipseASTVisitor.class)
+public class HandleVal extends EclipseASTAdapter {
+	@Override public void visitLocal(EclipseNode localNode, LocalDeclaration local) {
+		if (local.type instanceof SingleTypeReference) {
+			char[] token = ((SingleTypeReference)local.type).token;
+			if (token == null || token.length != 3) return;
+			else if (token[0] != 'v' || token[1] != 'a' || token[2] != 'l') return;
+			
+			if (local.initialization == null) {
+				localNode.addError("'val' on a local variable requires an initializer expression");
+			}
+			
+			if (local.initialization instanceof ArrayInitializer) {
+				localNode.addError("'val' is not compatible with array initializer expressions. Use the full form (new int[] { ... } instead of just { ... })");
+			}
+		}
+	}
+}
diff --git a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
index 2ac24a48..e962ecbf 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/EclipsePatcher.java
@@ -69,6 +69,8 @@ public class EclipsePatcher extends Agent {
 			patchPostCompileHookEcj(sm);
 		}
 		
+		patchEcjTransformers(sm);
+		
 		if (reloadExistingClasses) sm.reloadClasses(instrumentation);
 	}
 	
@@ -253,4 +255,47 @@ public class EclipsePatcher extends Agent {
 				.wrapMethod(new Hook("lombok.eclipse.TransformEclipseAST", "transform_swapped", "void", CUD_SIG, PARSER_SIG))
 				.request(StackRequest.THIS, StackRequest.RETURN_VALUE).build());
 	}
+	
+	private static void patchEcjTransformers(ScriptManager sm) {
+		patchHandleVal(sm);
+	}
+	
+	// Creates a copy of the 'initialization' field on a LocalDeclaration if the type of the LocalDeclaration is 'val', because the completion parser will null this out,
+	// which in turn stops us from inferring the intended type for 'val x = 5;'. We look at the copy.
+	// Also patches local declaration to not call .resolveType() on the initializer expression if we've already done so (calling it twice causes weird errors),
+	// and patches .resolve() on LocalDeclaration itself to just-in-time replace the 'val' vartype with the right one.
+	
+	private static void patchHandleVal(ScriptManager sm) {
+		final String LOCALDECLARATION_SIG = "org.eclipse.jdt.internal.compiler.ast.LocalDeclaration";
+		final String EXPRESSION_SIG = "org.eclipse.jdt.internal.compiler.ast.Expression";
+		final String BLOCKSCOPE_SIG = "org.eclipse.jdt.internal.compiler.lookup.BlockScope";
+		final String PARSER_SIG = "org.eclipse.jdt.internal.compiler.parser.Parser";
+		final String TYPEBINDING_SIG = "org.eclipse.jdt.internal.compiler.lookup.TypeBinding";
+		
+		sm.addScript(ScriptBuilder.exitEarly()
+				.target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
+				.request(StackRequest.THIS, StackRequest.PARAM1)
+				.decisionMethod(new Hook("lombok.eclipse.agent.PatchFixes", "handleValForLocalDeclaration", "boolean", LOCALDECLARATION_SIG, BLOCKSCOPE_SIG))
+				.build());
+		
+		sm.addScript(ScriptBuilder.addField()
+				.fieldName("$initCopy")
+				.fieldType("Lorg/eclipse/jdt/internal/compiler/ast/ASTNode;")
+				.setPublic()
+				.setTransient()
+				.targetClass("org.eclipse.jdt.internal.compiler.ast.LocalDeclaration")
+				.build());
+		
+		sm.addScript(ScriptBuilder.wrapReturnValue()
+				.target(new MethodTarget(PARSER_SIG, "consumeExitVariableWithInitialization", "void"))
+				.request(StackRequest.THIS)
+				.wrapMethod(new Hook("lombok.eclipse.agent.PatchFixes", "copyInitializationOfLocalDeclarationForVal", "void", PARSER_SIG))
+				.build());
+		
+		sm.addScript(ScriptBuilder.replaceMethodCall()
+				.target(new MethodTarget(LOCALDECLARATION_SIG, "resolve", "void", BLOCKSCOPE_SIG))
+				.methodToReplace(new Hook(EXPRESSION_SIG, "resolveType", TYPEBINDING_SIG, BLOCKSCOPE_SIG))
+				.replacementMethod(new Hook("lombok.eclipse.agent.PatchFixes", "skipResolveInitializerIfAlreadyCalled", TYPEBINDING_SIG, EXPRESSION_SIG, BLOCKSCOPE_SIG))
+				.build());
+	}
 }
diff --git a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java b/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
index daf1cbf2..eef6fd9a 100644
--- a/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
+++ b/src/eclipseAgent/lombok/eclipse/agent/PatchFixes.java
@@ -31,10 +31,22 @@ import java.util.List;
 
 import lombok.core.DiagnosticsReceiver;
 import lombok.core.PostCompiler;
+import lombok.eclipse.Eclipse;
 
 import org.eclipse.jdt.core.IMethod;
-import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.AbstractVariableDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.LocalDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.SingleTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.TypeReference;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
+import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
+import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
+import org.eclipse.jdt.internal.compiler.parser.Parser;
 
 public class PatchFixes {
 	public static int fixRetrieveStartingCatchPosition(int in) {
@@ -78,7 +90,7 @@ public class PatchFixes {
 		boolean isGenerated = internalNode.getClass().getField("$generatedBy").get(internalNode) != null;
 		if (isGenerated) {
 			domNode.getClass().getField("$isGenerated").set(domNode, true);
-			domNode.setFlags(domNode.getFlags() & ~ASTNode.ORIGINAL);
+			domNode.setFlags(domNode.getFlags() & ~org.eclipse.jdt.core.dom.ASTNode.ORIGINAL);
 		}
 	}
 	
@@ -127,4 +139,80 @@ public class PatchFixes {
 		String fileName = path + "/" + name;
 		return new BufferedOutputStream(PostCompiler.wrapOutputStream(out, fileName, DiagnosticsReceiver.CONSOLE));
 	}
+	
+	public static void copyInitializationOfLocalDeclarationForVal(Parser parser) {
+		ASTNode[] astStack;
+		int astPtr;
+		try {
+			Field astStackF = Parser.class.getDeclaredField("astStack");
+			astStackF.setAccessible(true);
+			astStack = (ASTNode[]) astStackF.get(parser);
+			Field astPtrF = Parser.class.getDeclaredField("astPtr");
+			astPtrF.setAccessible(true);
+			astPtr = (Integer)astPtrF.get(parser);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+		AbstractVariableDeclaration variableDecl = (AbstractVariableDeclaration) astStack[astPtr];
+		if (!(variableDecl instanceof LocalDeclaration)) return;
+		ASTNode init = variableDecl.initialization;
+		if (init == null) return;
+		if (variableDecl.type instanceof SingleTypeReference) {
+			SingleTypeReference ref = (SingleTypeReference) variableDecl.type;
+			if (ref.token == null || ref.token.length != 3 || ref.token[0] != 'v' || ref.token[1] != 'a' || ref.token[2] != 'l') return;
+		} else return;
+		
+		try {
+			LocalDeclaration.class.getDeclaredField("$initCopy").set(variableDecl, init);
+		} catch (Exception e) {
+			e.printStackTrace(System.out);
+			// In ecj mode this field isn't there and we don't need the copy anyway, so, we ignore the exception.
+		}
+	}
+	
+	private static Field initCopyField;
+	
+	static {
+		try {
+			initCopyField = LocalDeclaration.class.getDeclaredField("$initCopy");
+		} catch (Throwable t) {
+			 //ignore - no $generatedBy exists when running in ecj.
+		}
+	}
+	
+	public static boolean handleValForLocalDeclaration(LocalDeclaration local, BlockScope scope) {
+		if (local.type instanceof SingleTypeReference) {
+			char[] token = ((SingleTypeReference)local.type).token;
+			if (token == null || token.length != 3) return false;
+			else if (token[0] != 'v' || token[1] != 'a' || token[2] != 'l') return false;
+		} else return false;
+		
+		Expression init = local.initialization;
+		if (init == null && initCopyField != null) {
+			try {
+				init = (Expression) initCopyField.get(local);
+				System.out.println("copy = " + init);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+		
+		TypeReference replacement = null;
+		if (init != null) {
+			TypeBinding resolved = init.resolveType(scope);
+			if (resolved != null) {
+				replacement = Eclipse.makeType(resolved, local.type, false);
+			}
+		}
+		
+		local.modifiers |= ClassFileConstants.AccFinal;
+		local.type = replacement != null ? replacement : new QualifiedTypeReference(TypeConstants.JAVA_LANG_OBJECT, Eclipse.poss(local.type, 3));
+		
+		return false;
+	}
+	
+	public static TypeBinding skipResolveInitializerIfAlreadyCalled(Expression expr, BlockScope scope) {
+		if (expr.resolvedType != null) return expr.resolvedType;
+		return expr.resolveType(scope);
+	}
 }