Value has been promoted to the main package.

10 files changed, 157 insertions, 19 deletions

diff --git a/src/core/lombok/Data.java b/src/core/lombok/Data.java
index ee6f2fcb..bbc8d920 100644
--- a/src/core/lombok/Data.java
+++ b/src/core/lombok/Data.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 The Project Lombok Authors.
+ * Copyright (C) 2009-2013 The Project Lombok Authors.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -39,7 +39,7 @@ import java.lang.annotation.Target;
  * @see RequiredArgsConstructor
  * @see ToString
  * @see EqualsAndHashCode
- * @see lombok.experimental.Value
+ * @see lombok.Value
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.SOURCE)
diff --git a/src/core/lombok/Value.java b/src/core/lombok/Value.java
new file mode 100644
index 00000000..2cffe15b
--- /dev/null
+++ b/src/core/lombok/Value.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2012-2013 The Project Lombok Authors.
+ * 
+ * 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;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Generates a lot of code which fits with a class that is a representation of an immutable entity.
+ * <p>
+ * Equivalent to {@code @Getter @FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE) @RequiredArgsConstructor @ToString @EqualsAndHashCode}.
+ * <p>
+ * Complete documentation is found at <a href="http://projectlombok.org/features/experimental/Value.html">the project lombok features page for &#64;Value</a>.
+ * 
+ * @see lombok.Getter
+ * @see lombok.experimental.FieldDefaults
+ * @see lombok.RequiredArgsConstructor
+ * @see lombok.ToString
+ * @see lombok.EqualsAndHashCode
+ * @see lombok.Data
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.SOURCE)
+public @interface Value {
+	/**
+	 * If you specify a static constructor name, then the generated constructor will be private, and
+	 * instead a static factory method is created that other classes can use to create instances.
+	 * We suggest the name: "of", like so:
+	 * 
+	 * <pre>
+	 *     public @Data(staticConstructor = "of") class Point { final int x, y; }
+	 * </pre>
+	 * 
+	 * Default: No static constructor, instead the normal constructor is public.
+	 */
+	String staticConstructor() default "";
+}
diff --git a/src/core/lombok/core/LombokInternalAliasing.java b/src/core/lombok/core/LombokInternalAliasing.java
new file mode 100644
index 00000000..4fd7b29d
--- /dev/null
+++ b/src/core/lombok/core/LombokInternalAliasing.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2013 The Project Lombok Authors.
+ * 
+ * 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.core;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LombokInternalAliasing {
+	public static final Map<String, String> IMPLIED_EXTRA_STAR_IMPORTS;
+	public static final Map<String, String> ALIASES;
+	
+	/**
+	 * Provide a fully qualified name (FQN), and the canonical version of this is returned.
+	 */
+	public static String processAliases(String in) {
+		if (in == null) return null;
+		for (Map.Entry<String, String> e : ALIASES.entrySet()) {
+			if (in.equals(e.getKey())) return e.getValue();
+		}
+		return in;
+	}
+	
+	static {
+		Map<String, String> m = new HashMap<String, String>();
+		m.put("lombok.experimental", "lombok");
+		IMPLIED_EXTRA_STAR_IMPORTS = Collections.unmodifiableMap(m);
+		
+		m = new HashMap<String, String>();
+		m.put("lombok.experimental.Value", "lombok.Value");
+		ALIASES = Collections.unmodifiableMap(m);
+	}
+}
diff --git a/src/core/lombok/core/TypeLibrary.java b/src/core/lombok/core/TypeLibrary.java
index a89091c4..c0e9dc43 100644
--- a/src/core/lombok/core/TypeLibrary.java
+++ b/src/core/lombok/core/TypeLibrary.java
@@ -74,6 +74,9 @@ public class TypeLibrary {
 		
 		unqualifiedToQualifiedMap.put(unqualified, fullyQualifiedTypeName);
 		unqualifiedToQualifiedMap.put(fullyQualifiedTypeName, fullyQualifiedTypeName);
+		for (Map.Entry<String, String> e : LombokInternalAliasing.ALIASES.entrySet()) {
+			if (fullyQualifiedTypeName.equals(e.getValue())) unqualifiedToQualifiedMap.put(e.getKey(), fullyQualifiedTypeName);
+		}
 	}
 	
 	/**
@@ -85,6 +88,9 @@ public class TypeLibrary {
 	public String toQualified(String typeReference) {
 		if (unqualifiedToQualifiedMap == null) {
 			if (typeReference.equals(unqualified) || typeReference.equals(qualified)) return qualified;
+			for (Map.Entry<String, String> e : LombokInternalAliasing.ALIASES.entrySet()) {
+				if (e.getKey().equals(typeReference)) return e.getValue();
+			}
 			return null;
 		}
 		return unqualifiedToQualifiedMap.get(typeReference);
diff --git a/src/core/lombok/core/TypeResolver.java b/src/core/lombok/core/TypeResolver.java
index e2ba03b5..287a085f 100644
--- a/src/core/lombok/core/TypeResolver.java
+++ b/src/core/lombok/core/TypeResolver.java
@@ -39,19 +39,12 @@ public class TypeResolver {
 		this.imports = importList;
 	}
 	
-//	private static ImportList makeImportList(String packageString, Collection<String> importStrings) {
-//		Set<String> imports = new HashSet<String>();
-//		if (packageString != null) imports.add(packageString + ".*");
-//		imports.addAll(importStrings == null ? Collections.<String>emptySet() : importStrings);
-//		imports.add("java.lang.*");
-//		return imports;
-//	}
-//	
 	public boolean typeMatches(LombokNode<?, ?, ?> context, String fqn, String typeRef) {
 		return typeRefToFullyQualifiedName(context, TypeLibrary.createLibraryForSingleType(fqn), typeRef) != null;
 	}
 	
 	public String typeRefToFullyQualifiedName(LombokNode<?, ?, ?> context, TypeLibrary library, String typeRef) {
+		typeRef = LombokInternalAliasing.processAliases(typeRef);
 		// When asking if 'Foo' could possibly  be referring to 'bar.Baz', the answer is obviously no.
 		String qualified = library.toQualified(typeRef);
 		if (qualified == null) return null;
diff --git a/src/core/lombok/eclipse/EclipseImportList.java b/src/core/lombok/eclipse/EclipseImportList.java
index 264ed91f..69246b3c 100644
--- a/src/core/lombok/eclipse/EclipseImportList.java
+++ b/src/core/lombok/eclipse/EclipseImportList.java
@@ -21,19 +21,21 @@
  */
 package lombok.eclipse;
 
-import static lombok.eclipse.Eclipse.*;
+import static lombok.eclipse.Eclipse.toQualifiedName;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+
+import lombok.core.ImportList;
+import lombok.core.LombokInternalAliasing;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.ImportReference;
 
-import lombok.core.ImportList;
-
 public class EclipseImportList implements ImportList {
 	private ImportReference[] imports;
 	private ImportReference pkg;
@@ -53,13 +55,16 @@ public class EclipseImportList implements ImportList {
 				int len = token.length;
 				if (len != unqualified.length()) continue;
 				for (int i = 0; i < len; i++) if (token[i] != unqualified.charAt(i)) continue outer;
-				return toQualifiedName(tokens);
+				return LombokInternalAliasing.processAliases(toQualifiedName(tokens));
 			}
 		}
 		return null;
 	}
 	
 	@Override public boolean hasStarImport(String packageName) {
+		for (Map.Entry<String, String> e : LombokInternalAliasing.IMPLIED_EXTRA_STAR_IMPORTS.entrySet()) {
+			if (e.getValue().equals(packageName) && hasStarImport(e.getKey())) return true;
+		}
 		if (isEqual(packageName, pkg)) return true;
 		if ("java.lang".equals(packageName)) return true;
 		if (imports != null) for (ImportReference imp : imports) {
diff --git a/src/core/lombok/eclipse/handlers/HandleValue.java b/src/core/lombok/eclipse/handlers/HandleValue.java
index 60938649..0607137b 100644
--- a/src/core/lombok/eclipse/handlers/HandleValue.java
+++ b/src/core/lombok/eclipse/handlers/HandleValue.java
@@ -32,7 +32,7 @@ import lombok.eclipse.EclipseAnnotationHandler;
 import lombok.eclipse.EclipseNode;
 import lombok.eclipse.handlers.HandleConstructor.SkipIfConstructorExists;
 import lombok.experimental.NonFinal;
-import lombok.experimental.Value;
+import lombok.Value;
 
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
diff --git a/src/core/lombok/javac/JavacImportList.java b/src/core/lombok/javac/JavacImportList.java
index fbd4a518..d5d7460a 100644
--- a/src/core/lombok/javac/JavacImportList.java
+++ b/src/core/lombok/javac/JavacImportList.java
@@ -23,6 +23,7 @@ package lombok.javac;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Map;
 
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
@@ -32,6 +33,7 @@ import com.sun.tools.javac.tree.JCTree.JCImport;
 import com.sun.tools.javac.util.List;
 
 import lombok.core.ImportList;
+import lombok.core.LombokInternalAliasing;
 
 public class JavacImportList implements ImportList {
 	private final JCExpression pkg;
@@ -48,13 +50,18 @@ public class JavacImportList implements ImportList {
 			JCTree qual = ((JCImport) def).qualid;
 			if (!(qual instanceof JCFieldAccess)) continue;
 			String simpleName = ((JCFieldAccess) qual).name.toString();
-			if (simpleName.equals(unqualified)) return qual.toString();
+			if (simpleName.equals(unqualified)) {
+				return LombokInternalAliasing.processAliases(qual.toString());
+			}
 		}
 		
 		return null;
 	}
 	
 	@Override public boolean hasStarImport(String packageName) {
+		for (Map.Entry<String, String> e : LombokInternalAliasing.IMPLIED_EXTRA_STAR_IMPORTS.entrySet()) {
+			if (e.getValue().equals(packageName) && hasStarImport(e.getKey())) return true;
+		}
 		if (pkg != null && pkg.toString().equals(packageName)) return true;
 		if ("java.lang".equals(packageName)) return true;
 		
diff --git a/src/core/lombok/javac/handlers/HandleValue.java b/src/core/lombok/javac/handlers/HandleValue.java
index a59865f7..c0127f3c 100644
--- a/src/core/lombok/javac/handlers/HandleValue.java
+++ b/src/core/lombok/javac/handlers/HandleValue.java
@@ -26,7 +26,7 @@ import lombok.AccessLevel;
 import lombok.core.AnnotationValues;
 import lombok.core.HandlerPriority;
 import lombok.experimental.NonFinal;
-import lombok.experimental.Value;
+import lombok.Value;
 import lombok.javac.JavacAnnotationHandler;
 import lombok.javac.JavacNode;
 import lombok.javac.handlers.HandleConstructor.SkipIfConstructorExists;
@@ -45,7 +45,7 @@ import com.sun.tools.javac.tree.JCTree.JCModifiers;
 @HandlerPriority(-512) //-2^9; to ensure @EqualsAndHashCode and such pick up on this handler making the class final and messing with the fields' access levels, run earlier.
 public class HandleValue extends JavacAnnotationHandler<Value> {
 	@Override public void handle(AnnotationValues<Value> annotation, JCAnnotation ast, JavacNode annotationNode) {
-		deleteAnnotationIfNeccessary(annotationNode, Value.class);
+		deleteAnnotationIfNeccessary(annotationNode, Value.class, lombok.experimental.Value.class);
 		JavacNode typeNode = annotationNode.up();
 		boolean notAClass = !isClass(typeNode);
 		
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index 92cebf4c..1784be90 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -280,7 +280,22 @@ public class JavacHandlerUtil {
 	 * then removes any import statement that imports this exact annotation (not star imports).
 	 * Only does this if the DeleteLombokAnnotations class is in the context.
 	 */
+	@SuppressWarnings("unchecked")
 	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType) {
+		deleteAnnotationIfNeccessary0(annotation, annotationType);
+	}
+	
+	/**
+	 * Removes the annotation from javac's AST (it remains in lombok's AST),
+	 * then removes any import statement that imports this exact annotation (not star imports).
+	 * Only does this if the DeleteLombokAnnotations class is in the context.
+	 */
+	@SuppressWarnings("unchecked")
+	public static void deleteAnnotationIfNeccessary(JavacNode annotation, Class<? extends Annotation> annotationType1, Class<? extends Annotation> annotationType2) {
+		deleteAnnotationIfNeccessary0(annotation, annotationType1, annotationType2);
+	}
+	
+	private static void deleteAnnotationIfNeccessary0(JavacNode annotation, Class<? extends Annotation>... annotationTypes) {
 		if (inNetbeansEditor(annotation)) return;
 		if (!annotation.shouldDeleteLombokAnnotations()) return;
 		JavacNode parentNode = annotation.directUp();
@@ -309,7 +324,9 @@ public class JavacHandlerUtil {
 		}
 		
 		parentNode.getAst().setChanged();
-		deleteImportFromCompilationUnit(annotation, annotationType.getName());
+		for (Class<?> annotationType : annotationTypes) {
+			deleteImportFromCompilationUnit(annotation, annotationType.getName());
+		}
 	}
 	
 	public static void deleteImportFromCompilationUnit(JavacNode node, String name) {