aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/lombok/eclipse/handlers/HandleUtilityClass.java173
-rw-r--r--src/core/lombok/experimental/UtilityClass.java12
-rw-r--r--src/core/lombok/javac/handlers/HandleUtilityClass.java103
3 files changed, 239 insertions, 49 deletions
diff --git a/src/core/lombok/eclipse/handlers/HandleUtilityClass.java b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
new file mode 100644
index 00000000..36a7dc9c
--- /dev/null
+++ b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2015 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.eclipse.handlers;
+
+import static lombok.core.handlers.HandlerUtil.*;
+import static lombok.eclipse.Eclipse.*;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
+
+import java.util.Arrays;
+
+import org.eclipse.jdt.internal.compiler.ast.ASTNode;
+import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
+import org.eclipse.jdt.internal.compiler.ast.Annotation;
+import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.ExplicitConstructorCall;
+import org.eclipse.jdt.internal.compiler.ast.Expression;
+import org.eclipse.jdt.internal.compiler.ast.FieldDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.MethodDeclaration;
+import org.eclipse.jdt.internal.compiler.ast.QualifiedTypeReference;
+import org.eclipse.jdt.internal.compiler.ast.Statement;
+import org.eclipse.jdt.internal.compiler.ast.StringLiteral;
+import org.eclipse.jdt.internal.compiler.ast.ThrowStatement;
+import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
+import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
+import org.mangosdk.spi.ProviderFor;
+
+import lombok.ConfigurationKeys;
+import lombok.core.AnnotationValues;
+import lombok.core.AST.Kind;
+import lombok.eclipse.EclipseAnnotationHandler;
+import lombok.eclipse.EclipseNode;
+import lombok.experimental.UtilityClass;
+
+/**
+ * Handles the {@code lombok.experimental.UtilityClass} annotation for eclipse.
+ */
+@ProviderFor(EclipseAnnotationHandler.class)
+public class HandleUtilityClass extends EclipseAnnotationHandler<UtilityClass> {
+ @Override public void handle(AnnotationValues<UtilityClass> annotation, Annotation ast, EclipseNode annotationNode) {
+ handleFlagUsage(annotationNode, ConfigurationKeys.UTLITY_CLASS_FLAG_USAGE, "@UtilityClass");
+
+ EclipseNode typeNode = annotationNode.up();
+ if (!checkLegality(typeNode, annotationNode)) return;
+ changeModifiersAndGenerateConstructor(annotationNode.up(), annotationNode);
+ }
+
+ private static boolean checkLegality(EclipseNode typeNode, EclipseNode errorNode) {
+ TypeDeclaration typeDecl = null;
+ if (typeNode.get() instanceof TypeDeclaration) typeDecl = (TypeDeclaration) typeNode.get();
+ int modifiers = typeDecl == null ? 0 : typeDecl.modifiers;
+ boolean notAClass = (modifiers & (ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation | ClassFileConstants.AccEnum)) != 0;
+
+ if (typeDecl == null || notAClass) {
+ errorNode.addError("@UtilityClass is only supported on a class (can't be an interface, enum, or annotation).");
+ return false;
+ }
+
+ // It might be an inner class. This is okay, but only if it is / can be a static inner class. Thus, all of its parents have to be static inner classes until the top-level.
+ EclipseNode typeWalk = typeNode;
+ while (true) {
+ typeWalk = typeWalk.up();
+ switch (typeWalk.getKind()) {
+ case TYPE:
+ if ((((TypeDeclaration) typeWalk.get()).modifiers & ClassFileConstants.AccStatic) != 0) continue;
+ if (typeWalk.up().getKind() == Kind.COMPILATION_UNIT) return true;
+ case COMPILATION_UNIT:
+ return true;
+ default:
+ errorNode.addError("@UtilityClass cannot be placed on a method local or anonymous inner class, or any class nested in such a class.");
+ return false;
+ }
+ }
+ }
+
+ private void changeModifiersAndGenerateConstructor(EclipseNode typeNode, EclipseNode annotationNode) {
+ TypeDeclaration classDecl = (TypeDeclaration) typeNode.get();
+
+ boolean makeConstructor = true;
+
+ classDecl.modifiers |= ClassFileConstants.AccFinal;
+
+ if (typeNode.up().getKind() != Kind.COMPILATION_UNIT) classDecl.modifiers |= ClassFileConstants.AccStatic;
+
+ for (EclipseNode element : typeNode.down()) {
+ if (element.getKind() == Kind.FIELD) {
+ FieldDeclaration fieldDecl = (FieldDeclaration) element.get();
+ fieldDecl.modifiers |= ClassFileConstants.AccStatic;
+ } else if (element.getKind() == Kind.METHOD) {
+ AbstractMethodDeclaration amd = (AbstractMethodDeclaration) element.get();
+ if (amd instanceof ConstructorDeclaration) {
+ ConstructorDeclaration constrDecl = (ConstructorDeclaration) element.get();
+ if (getGeneratedBy(constrDecl) == null && (constrDecl.bits & ASTNode.IsDefaultConstructor) == 0) {
+ element.addError("@UtilityClasses cannot have declared constructors.");
+ makeConstructor = false;
+ continue;
+ }
+ } else if (amd instanceof MethodDeclaration) {
+ amd.modifiers |= ClassFileConstants.AccStatic;
+ }
+ } else if (element.getKind() == Kind.TYPE) {
+ ((TypeDeclaration) element.get()).modifiers |= ClassFileConstants.AccStatic;
+ }
+ }
+
+ if (makeConstructor) createPrivateDefaultConstructor(typeNode, annotationNode);
+ }
+
+ private static final char[][] JAVA_LANG_UNSUPPORTED_OPERATION_EXCEPTION = new char[][] {
+ TypeConstants.JAVA, TypeConstants.LANG, "UnsupportedOperationException".toCharArray()
+ };
+
+ private static final char[] UNSUPPORTED_MESSAGE = "This is a utility class and cannot be instantiated".toCharArray();
+
+ private void createPrivateDefaultConstructor(EclipseNode typeNode, EclipseNode sourceNode) {
+ ASTNode source = sourceNode.get();
+
+ TypeDeclaration typeDeclaration = ((TypeDeclaration) typeNode.get());
+ long p = (long) source.sourceStart << 32 | source.sourceEnd;
+
+ ConstructorDeclaration constructor = new ConstructorDeclaration(((CompilationUnitDeclaration) typeNode.top().get()).compilationResult);
+
+ constructor.modifiers = ClassFileConstants.AccPrivate;
+ constructor.selector = typeDeclaration.name;
+ constructor.constructorCall = new ExplicitConstructorCall(ExplicitConstructorCall.ImplicitSuper);
+ constructor.constructorCall.sourceStart = source.sourceStart;
+ constructor.constructorCall.sourceEnd = source.sourceEnd;
+ constructor.thrownExceptions = null;
+ constructor.typeParameters = null;
+ constructor.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
+ constructor.bodyStart = constructor.declarationSourceStart = constructor.sourceStart = source.sourceStart;
+ constructor.bodyEnd = constructor.declarationSourceEnd = constructor.sourceEnd = source.sourceEnd;
+ constructor.arguments = null;
+
+ AllocationExpression exception = new AllocationExpression();
+ setGeneratedBy(exception, source);
+ long[] ps = new long[3];
+ Arrays.fill(ps, p);
+ exception.type = new QualifiedTypeReference(JAVA_LANG_UNSUPPORTED_OPERATION_EXCEPTION, ps);
+ setGeneratedBy(exception.type, source);
+ exception.arguments = new Expression[] {
+ new StringLiteral(UNSUPPORTED_MESSAGE, source.sourceStart, source.sourceEnd, 0)
+ };
+ setGeneratedBy(exception.arguments[0], source);
+ ThrowStatement throwStatement = new ThrowStatement(exception, source.sourceStart, source.sourceEnd);
+ setGeneratedBy(throwStatement, source);
+
+ constructor.statements = new Statement[] {throwStatement};
+
+ injectMethod(typeNode, constructor);
+ }
+}
diff --git a/src/core/lombok/experimental/UtilityClass.java b/src/core/lombok/experimental/UtilityClass.java
index 778cfb80..80f3eee9 100644
--- a/src/core/lombok/experimental/UtilityClass.java
+++ b/src/core/lombok/experimental/UtilityClass.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012-2013 The Project Lombok Authors.
+ * Copyright (C) 2015 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
@@ -27,9 +27,13 @@ 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.
+ * An annotation to create utility classes.
+ *
+ * If a class is annotated with {@code @UtilityClass}, the following things happen to it:<ul>
+ * <li>It is marked final.</li>
+ * <li>If any constructors are declared in it, an error is generated. Otherwise, a private no-args constructor is generated; it throws a {@code UnsupportedOperationException}.</li>
+ * <li>All methods, inner classes, and fields in the class are marked static.</li>
+ * </ul>
*/
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.SOURCE)
diff --git a/src/core/lombok/javac/handlers/HandleUtilityClass.java b/src/core/lombok/javac/handlers/HandleUtilityClass.java
index 4ab3f8dc..9a37653e 100644
--- a/src/core/lombok/javac/handlers/HandleUtilityClass.java
+++ b/src/core/lombok/javac/handlers/HandleUtilityClass.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2012-2014 The Project Lombok Authors.
+ * Copyright (C) 2015 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
@@ -21,7 +21,7 @@
*/
package lombok.javac.handlers;
-import static lombok.core.handlers.HandlerUtil.handleExperimentalFlagUsage;
+import static lombok.core.handlers.HandlerUtil.*;
import static lombok.javac.handlers.JavacHandlerUtil.*;
import lombok.ConfigurationKeys;
import lombok.core.AST.Kind;
@@ -48,70 +48,81 @@ import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Name;
/**
- * Handles the {@code lombok.experimental.UtilityClass} annotation for javac.
+ * Handles the {@code @UtilityClass} annotation for javac.
*/
-@ProviderFor(JavacAnnotationHandler.class) public class HandleUtilityClass extends JavacAnnotationHandler<UtilityClass> {
-
+@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);
+
+ JavacNode typeNode = annotationNode.up();
+ if (!checkLegality(typeNode, annotationNode)) return;
+ changeModifiersAndGenerateConstructor(annotationNode.up(), annotationNode);
}
-
- private JCClassDecl getClassDecl(JavacNode typeNode) {
+
+ private static boolean checkLegality(JavacNode typeNode, JavacNode errorNode) {
JCClassDecl typeDecl = null;
- if (typeNode.get() instanceof JCClassDecl) {
- typeDecl = (JCClassDecl) typeNode.get();
- }
-
+ 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 (typeDecl == null || notAClass) {
+ errorNode.addError("@UtilityClass is only supported on a class (can't be an interface, enum, or annotation).");
+ return false;
}
-
- if (!is(classDecl.getModifiers(), Flags.FINAL)) {
- classDecl.mods.flags |= Flags.FINAL;
+
+ // It might be an inner class. This is okay, but only if it is / can be a static inner class. Thus, all of its parents have to be static inner classes until the top-level.
+ JavacNode typeWalk = typeNode;
+ while (true) {
+ typeWalk = typeWalk.up();
+ switch (typeWalk.getKind()) {
+ case TYPE:
+ if ((((JCClassDecl) typeWalk.get()).mods.flags & Flags.STATIC) != 0) continue;
+ if (typeWalk.up().getKind() == Kind.COMPILATION_UNIT) return true;
+ case COMPILATION_UNIT:
+ return true;
+ default:
+ errorNode.addError("@UtilityClass cannot be placed on a method local or anonymous inner class, or any class nested in such a class.");
+ return false;
+ }
}
-
+ }
+
+ private void changeModifiersAndGenerateConstructor(JavacNode typeNode, JavacNode errorNode) {
+ JCClassDecl classDecl = (JCClassDecl) typeNode.get();
+
+ boolean makeConstructor = true;
+
+ classDecl.mods.flags |= Flags.FINAL;
+
+ if (typeNode.up().getKind() != Kind.COMPILATION_UNIT) classDecl.mods.flags |= Flags.STATIC;
+
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;
- }
+ 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.");
+ if (getGeneratedBy(methodDecl) == null && (methodDecl.mods.flags & Flags.GENERATEDCONSTR) == 0) {
+ element.addError("@UtilityClasses cannot have declared constructors.");
+ makeConstructor = false;
continue;
}
- } else if (!is(methodDecl.mods, Flags.STATIC)) {
- methodDecl.mods.flags |= 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;
- }
+ JCClassDecl innerClassDecl = (JCClassDecl) element.get();
+ innerClassDecl.mods.flags |= Flags.STATIC;
}
}
-
- createPrivateDefaultConstructor(typeNode);
- }
-
- private static boolean is(JCModifiers mods, long f) {
- return (mods.flags & f) != 0;
+
+ if (makeConstructor) createPrivateDefaultConstructor(typeNode);
}
-
+
private void createPrivateDefaultConstructor(JavacNode typeNode) {
JavacTreeMaker maker = typeNode.getTreeMaker();
JCModifiers mods = maker.Modifiers(Flags.PRIVATE, List.<JCAnnotation>nil());
@@ -125,8 +136,10 @@ import com.sun.tools.javac.util.Name;
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);
+ JCExpression exceptionType = genTypeRef(typeNode, "java.lang.UnsupportedOperationException");
+ List<JCExpression> jceBlank = List.nil();
+ JCExpression message = maker.Literal("This is a utility class and cannot be instantiated");
+ JCExpression exceptionInstance = maker.NewClass(null, jceBlank, exceptionType, List.of(message), null);
JCStatement throwStatement = maker.Throw(exceptionInstance);
statements.add(throwStatement);
return statements.toList();
generated by cgit (git 2.46.0) at 2024-12-18 11:35:02 +0000