'val' support for eclipse.

2 files changed, 192 insertions, 1 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 { ... })");
+			}
+		}
+	}
+}