Merge branch 'master' of https://github.com/luanpotter/lombok into utility-class

3 files changed, 179 insertions, 0 deletions

diff --git a/src/core/lombok/ConfigurationKeys.java b/src/core/lombok/ConfigurationKeys.java
index 3e2330fd..6c595504 100644
--- a/src/core/lombok/ConfigurationKeys.java
+++ b/src/core/lombok/ConfigurationKeys.java
@@ -411,6 +411,14 @@ public class ConfigurationKeys {
 	 */
 	public static final ConfigurationKey<FlagUsageType> WITHER_FLAG_USAGE = new ConfigurationKey<FlagUsageType>("lombok.wither.flagUsage", "Emit a warning or error if @Wither is used.") {};
 	
+	// ----- UtilityClass -----
+	
+	/**
+	 * lombok configuration: {@code lombok.utilityClass.flagUsage} = {@code WARNING} | {@code ERROR}.
+	 * 
+	 * If set, <em>any</em> usage of {@code @UtilityClass} results in a warning / error.
+	 */
+	public static final ConfigurationKey<FlagUsageType> UTLITY_CLASS_FLAG_USAGE = new ConfigurationKey<FlagUsageType>("lombok.utilityClass.flagUsage", "Emit a warning or error if @UtilityClass is used.") {};
 	
 	// ----- Configuration System -----
 	
diff --git a/src/core/lombok/experimental/UtilityClass.java b/src/core/lombok/experimental/UtilityClass.java
new file mode 100644
index 00000000..778cfb80
--- /dev/null
+++ b/src/core/lombok/experimental/UtilityClass.java
@@ -0,0 +1,37 @@
+/*
+ * 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.experimental;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * A helper to create utilities classes.
+ * <p>
+ * It makes the class final, makes all its methods static, creates a private default constructor that throws a RuntimeException when called and yields an error when other constructors are defined.
+ */
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.SOURCE)
+public @interface UtilityClass {
+}
diff --git a/src/core/lombok/javac/handlers/HandleUtilityClass.java b/src/core/lombok/javac/handlers/HandleUtilityClass.java
new file mode 100644
index 00000000..4ab3f8dc
--- /dev/null
+++ b/src/core/lombok/javac/handlers/HandleUtilityClass.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2012-2014 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.javac.handlers;
+
+import static lombok.core.handlers.HandlerUtil.handleExperimentalFlagUsage;
+import static lombok.javac.handlers.JavacHandlerUtil.*;
+import lombok.ConfigurationKeys;
+import lombok.core.AST.Kind;
+import lombok.core.AnnotationValues;
+import lombok.experimental.UtilityClass;
+import lombok.javac.JavacAnnotationHandler;
+import lombok.javac.JavacNode;
+import lombok.javac.JavacTreeMaker;
+
+import org.mangosdk.spi.ProviderFor;
+
+import com.sun.tools.javac.code.Flags;
+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.JCMethodDecl;
+import com.sun.tools.javac.tree.JCTree.JCModifiers;
+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.ListBuffer;
+import com.sun.tools.javac.util.Name;
+
+/**
+ * Handles the {@code lombok.experimental.UtilityClass} annotation for javac.
+ */
+@ProviderFor(JavacAnnotationHandler.class) public class HandleUtilityClass extends JavacAnnotationHandler<UtilityClass> {
+
+	@Override public void handle(AnnotationValues<UtilityClass> annotation, JCAnnotation ast, JavacNode annotationNode) {
+		handleExperimentalFlagUsage(annotationNode, ConfigurationKeys.UTLITY_CLASS_FLAG_USAGE, "@UtilityClass");
+		deleteAnnotationIfNeccessary(annotationNode, UtilityClass.class);
+
+		parse(annotationNode.up(), annotationNode);
+	}
+
+	private JCClassDecl getClassDecl(JavacNode typeNode) {
+		JCClassDecl typeDecl = null;
+		if (typeNode.get() instanceof JCClassDecl) {
+			typeDecl = (JCClassDecl) typeNode.get();
+		}
+
+		long modifiers = typeDecl == null ? 0 : typeDecl.mods.flags;
+		boolean notAClass = (modifiers & (Flags.INTERFACE | Flags.ANNOTATION | Flags.ENUM)) != 0;
+		return notAClass ? null : typeDecl;
+	}
+
+	public void parse(JavacNode typeNode, JavacNode errorNode) {
+		JCClassDecl classDecl = getClassDecl(typeNode);
+		if (classDecl == null) {
+			errorNode.addError("@UtilityClass is only supported on a class (can't be interface, enum or annotation).");
+			return;
+		}
+
+		if (!is(classDecl.getModifiers(), Flags.FINAL)) {
+			classDecl.mods.flags |= Flags.FINAL;
+		}
+
+		for (JavacNode element : typeNode.down()) {
+			if (element.getKind() == Kind.FIELD) {
+				JCVariableDecl fieldDecl = (JCVariableDecl) element.get();
+				if (!is(fieldDecl.mods, Flags.STATIC)) {
+					fieldDecl.mods.flags |= Flags.STATIC;
+				}
+			} else if (element.getKind() == Kind.METHOD) {
+				JCMethodDecl methodDecl = (JCMethodDecl) element.get();
+				if (methodDecl.name.contentEquals("<init>")) {
+					if (!is(methodDecl.mods, Flags.GENERATEDCONSTR)) {
+						errorNode.addError("@UtilityClasses cannot have declared constructors.");
+						continue;
+					}
+				} else if (!is(methodDecl.mods, Flags.STATIC)) {
+					methodDecl.mods.flags |= Flags.STATIC;
+				}
+			} else if (element.getKind() == Kind.TYPE) {
+				JCClassDecl innerClassDecl = (JCClassDecl) typeNode.get();
+				if (!is(innerClassDecl.mods, Flags.STATIC)) {
+					innerClassDecl.mods.flags |= Flags.STATIC;
+				}
+			}
+		}
+
+		createPrivateDefaultConstructor(typeNode);
+	}
+
+	private static boolean is(JCModifiers mods, long f) {
+		return (mods.flags & f) != 0;
+	}
+
+	private void createPrivateDefaultConstructor(JavacNode typeNode) {
+		JavacTreeMaker maker = typeNode.getTreeMaker();
+		JCModifiers mods = maker.Modifiers(Flags.PRIVATE, List.<JCAnnotation>nil());
+		
+		Name name = typeNode.toName("<init>");
+		JCBlock block = maker.Block(0L, createThrowStatement(typeNode, maker));
+		JCMethodDecl methodDef = maker.MethodDef(mods, name, null, List.<JCTypeParameter>nil(), List.<JCVariableDecl>nil(), List.<JCExpression>nil(), block, null);
+		JCMethodDecl constructor = recursiveSetGeneratedBy(methodDef, typeNode.get(), typeNode.getContext());
+		JavacHandlerUtil.injectMethod(typeNode, constructor);
+	}
+	
+	private List<JCStatement> createThrowStatement(JavacNode typeNode, JavacTreeMaker maker) {
+		ListBuffer<JCStatement> statements = new ListBuffer<JCStatement>();
+		JCExpression exceptionType = genTypeRef(typeNode, "java.lang.RuntimeException");
+		JCExpression exceptionInstance = maker.NewClass(null, List.<JCExpression>nil(), exceptionType, List.<JCExpression>of(maker.Literal("Should not be instanciated!")), null);
+		JCStatement throwStatement = maker.Throw(exceptionInstance);
+		statements.add(throwStatement);
+		return statements.toList();
+	}
+}