Add record support

17 files changed, 142 insertions, 82 deletions

diff --git a/src/core/lombok/eclipse/EclipseAST.java b/src/core/lombok/eclipse/EclipseAST.java
index d53856af..2c860e14 100644
--- a/src/core/lombok/eclipse/EclipseAST.java
+++ b/src/core/lombok/eclipse/EclipseAST.java
@@ -21,6 +21,8 @@
  */
 package lombok.eclipse;
 
+import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
+
 import java.io.File;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -34,7 +36,6 @@ import java.util.List;
 import lombok.Lombok;
 import lombok.core.AST;
 import lombok.core.LombokImmutableList;
-import lombok.eclipse.handlers.EclipseHandlerUtil;
 import lombok.permit.Permit;
 
 import org.eclipse.core.resources.ResourcesPlugin;
@@ -117,7 +118,7 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 				try {
 					return EclipseWorkspaceBasedFileResolver.resolve(fileName);
 				} catch (IllegalArgumentException e) {
-					EclipseHandlerUtil.warning("Finding 'lombok.config' file failed for '" + fileName + "'", e);
+					warning("Finding 'lombok.config' file failed for '" + fileName + "'", e);
 //					String msg = e.getMessage();
 //					if (msg != null && msg.startsWith("Path must include project and resource name")) {
 //						// We shouldn't throw an exception at all, but we can't reproduce this so we need help from our users to figure this out.
@@ -362,7 +363,7 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 		case TYPE:
 			return buildType((TypeDeclaration) node);
 		case FIELD:
-			return buildField((FieldDeclaration) node);
+			return buildField((FieldDeclaration) node, null);
 		case INITIALIZER:
 			return buildInitializer((Initializer) node);
 		case METHOD:
@@ -401,16 +402,16 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 	private EclipseNode buildType(TypeDeclaration type) {
 		if (setAndGetAsHandled(type)) return null;
 		List<EclipseNode> childNodes = new ArrayList<EclipseNode>();
-		childNodes.addAll(buildFields(type.fields));
+		childNodes.addAll(buildFields(type.fields, getRecordFieldAnnotations(type)));
 		childNodes.addAll(buildTypes(type.memberTypes));
 		childNodes.addAll(buildMethods(type.methods));
 		childNodes.addAll(buildAnnotations(type.annotations, false));
 		return putInMap(new EclipseNode(this, type, childNodes, Kind.TYPE));
 	}
 	
-	private Collection<EclipseNode> buildFields(FieldDeclaration[] children) {
+	private Collection<EclipseNode> buildFields(FieldDeclaration[] children, Annotation[][] annotations) {
 		List<EclipseNode> childNodes = new ArrayList<EclipseNode>();
-		if (children != null) for (FieldDeclaration child : children) addIfNotNull(childNodes, buildField(child));
+		if (children != null) for (int i = 0; i < children.length; i++) addIfNotNull(childNodes, buildField(children[i], annotations[i]));
 		return childNodes;
 	}
 	
@@ -420,13 +421,13 @@ public class EclipseAST extends AST<EclipseAST, EclipseNode, ASTNode> {
 		return list;
 	}
 	
-	private EclipseNode buildField(FieldDeclaration field) {
+	private EclipseNode buildField(FieldDeclaration field, Annotation[] annotations) {
 		if (field instanceof Initializer) return buildInitializer((Initializer)field);
 		if (setAndGetAsHandled(field)) return null;
 		List<EclipseNode> childNodes = new ArrayList<EclipseNode>();
 		addIfNotNull(childNodes, buildTypeUse(field.type));
 		addIfNotNull(childNodes, buildStatement(field.initialization));
-		childNodes.addAll(buildAnnotations(field.annotations, true));
+		childNodes.addAll(buildAnnotations(annotations != null ? annotations : field.annotations, true));
 		return putInMap(new EclipseNode(this, field, childNodes, Kind.FIELD));
 	}
 	
diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index 6bfcf16e..c70e4e5c 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -124,6 +124,7 @@ import lombok.core.handlers.HandlerUtil.FieldAccess;
 import lombok.eclipse.Eclipse;
 import lombok.eclipse.EclipseAST;
 import lombok.eclipse.EclipseNode;
+import lombok.eclipse.Java14Bits;
 import lombok.experimental.Accessors;
 import lombok.experimental.Tolerate;
 import lombok.permit.Permit;
@@ -332,6 +333,7 @@ public class EclipseHandlerUtil {
 		public static final Field TYPE_REFERENCE__ANNOTATIONS;
 		public static final Class<?> INTERSECTION_BINDING1, INTERSECTION_BINDING2;
 		public static final Field INTERSECTION_BINDING_TYPES1, INTERSECTION_BINDING_TYPES2;
+		public static final Field TYPE_DECLARATION_RECORD_COMPONENTS;
 		static {
 			STRING_LITERAL__LINE_NUMBER = getField(StringLiteral.class, "lineNumber");
 			ANNOTATION__MEMBER_VALUE_PAIR_NAME = getField(Annotation.class, "memberValuePairName");
@@ -340,6 +342,7 @@ public class EclipseHandlerUtil {
 			INTERSECTION_BINDING2 = getClass("org.eclipse.jdt.internal.compiler.lookup.IntersectionCastTypeBinding");
 			INTERSECTION_BINDING_TYPES1 = INTERSECTION_BINDING1 == null ? null : getField(INTERSECTION_BINDING1, "intersectingTypes");
 			INTERSECTION_BINDING_TYPES2 = INTERSECTION_BINDING2 == null ? null : getField(INTERSECTION_BINDING2, "intersectingTypes");
+			TYPE_DECLARATION_RECORD_COMPONENTS = getField(TypeDeclaration.class, "recordComponents");
 		}
 		
 		public static int reflectInt(Field f, Object o) {
@@ -771,12 +774,10 @@ public class EclipseHandlerUtil {
 	}
 	
 	public static boolean hasNonNullAnnotations(EclipseNode node) {
-		AbstractVariableDeclaration avd = (AbstractVariableDeclaration) node.get();
-		if (avd.annotations == null) return false;
-		for (Annotation annotation : avd.annotations) {
-			TypeReference typeRef = annotation.type;
-			if (typeRef != null && typeRef.getTypeName() != null) {
-				for (String bn : NONNULL_ANNOTATIONS) if (typeMatches(bn, node, typeRef)) return true;
+		for (EclipseNode child : node.down()) {
+			if (child.getKind() == Kind.ANNOTATION) {
+				Annotation annotation = (Annotation) child.get();
+				for (String bn : NONNULL_ANNOTATIONS) if (typeMatches(bn, node, annotation.type)) return true;
 			}
 		}
 		return false;
@@ -1888,6 +1889,31 @@ public class EclipseHandlerUtil {
 	}
 	
 	/**
+	 * Checks if there is a constructor generated by lombok. 
+	 * 
+	 * @param node Any node that represents the Type (TypeDeclaration) to look in, or any child node thereof.
+	 */
+	public static boolean lombokConstructorExists(EclipseNode node) {
+		node = upToTypeNode(node);
+		if (node != null && node.get() instanceof TypeDeclaration) {
+			TypeDeclaration typeDecl = (TypeDeclaration)node.get();
+			if (typeDecl.methods != null) for (AbstractMethodDeclaration def : typeDecl.methods) {
+				if (def instanceof ConstructorDeclaration) {
+					if ((def.bits & (ASTNode.IsDefaultConstructor | Java14Bits.IsCanonicalConstructor)) != 0) continue;
+					
+					if (isTolerate(node, def)) continue;
+					
+					if (getGeneratedBy(def) != null) {
+						return true;
+					}
+				}
+			}
+		}
+		
+		return false;
+	}
+	
+	/**
 	 * Inserts a field into an existing type. The type must represent a {@code TypeDeclaration}.
 	 * The field carries the &#64;{@link SuppressWarnings}("all") annotation.
 	 */
@@ -2635,4 +2661,57 @@ public class EclipseHandlerUtil {
 		setGeneratedBy(ref, source);
 		return ref;
 	}
+	
+	static boolean isClass(EclipseNode typeNode) {
+		return isClassAndDoesNotHaveFlags(typeNode, ClassFileConstants.AccInterface | ClassFileConstants.AccEnum | ClassFileConstants.AccAnnotation | Java14Bits.AccRecord);
+	}
+	
+	static boolean isClassOrEnum(EclipseNode typeNode) {
+		return isClassAndDoesNotHaveFlags(typeNode, ClassFileConstants.AccInterface | ClassFileConstants.AccAnnotation | Java14Bits.AccRecord);
+	}
+	
+	public static boolean isClassAndDoesNotHaveFlags(EclipseNode typeNode, long flags) {
+		TypeDeclaration typeDecl = null;
+		if (typeNode.get() instanceof TypeDeclaration) typeDecl = (TypeDeclaration) typeNode.get();
+		int modifiers = typeDecl == null ? 0 : typeDecl.modifiers;
+		return (modifiers & flags) == 0;
+	}
+	
+	public static boolean isRecord(EclipseNode typeNode) {
+		return typeNode.getKind() == Kind.TYPE && isRecord((TypeDeclaration) typeNode.get());
+	}
+	
+	public static boolean isRecord(TypeDeclaration typeDeclaration) {
+		return (typeDeclaration.modifiers & Java14Bits.AccRecord) != 0;
+	}
+	
+	public static boolean isRecordField(EclipseNode fieldNode) {
+		return fieldNode.getKind() == Kind.FIELD && (((FieldDeclaration) fieldNode.get()).modifiers & Java14Bits.AccRecord) != 0;
+	}
+
+	public static AbstractVariableDeclaration[] getRecordComponents(TypeDeclaration typeDeclaration) {
+		if (!isRecord(typeDeclaration)) return null;
+		try {
+			return (AbstractVariableDeclaration[]) TYPE_DECLARATION_RECORD_COMPONENTS.get(typeDeclaration);
+		} catch (Exception e) {
+			// Ignore
+		}
+		return null;
+	}
+	
+	public static Annotation[][] getRecordFieldAnnotations(TypeDeclaration typeDeclaration) {
+		if (typeDeclaration.fields == null) return null;
+		Annotation[][] annotations = new Annotation[typeDeclaration.fields.length][];
+		
+		AbstractVariableDeclaration[] recordComponents = getRecordComponents(typeDeclaration);
+		if (recordComponents != null) {
+			int j = 0;
+			for (int i = 0; i < typeDeclaration.fields.length; i++) {
+				if ((typeDeclaration.fields[i].modifiers & Java14Bits.AccRecord) != 0) {
+					annotations[i] = recordComponents[j++].annotations;
+				}
+			}
+		}
+		return annotations;
+	}
 }
diff --git a/src/core/lombok/eclipse/handlers/HandleBuilder.java b/src/core/lombok/eclipse/handlers/HandleBuilder.java
index 801fe7e7..5054703a 100755
--- a/src/core/lombok/eclipse/handlers/HandleBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleBuilder.java
@@ -272,8 +272,10 @@ public class HandleBuilder extends EclipseAnnotationHandler<Builder> {
 				allFields.add(fieldNode);
 			}
 			
-			handleConstructor.generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, false, null, SkipIfConstructorExists.I_AM_BUILDER,
-				Collections.<Annotation>emptyList(), annotationNode);
+			if (!isRecord(tdParent)) {
+				handleConstructor.generateConstructor(tdParent, AccessLevel.PACKAGE, allFields, false, null, SkipIfConstructorExists.I_AM_BUILDER,
+					Collections.<Annotation>emptyList(), annotationNode);
+			}
 			
 			returnType = namePlusTypeParamsToTypeReference(tdParent, td.typeParameters, p);
 			typeParams = td.typeParameters;
diff --git a/src/core/lombok/eclipse/handlers/HandleConstructor.java b/src/core/lombok/eclipse/handlers/HandleConstructor.java
index 06c9ecd9..ff81b763 100755
--- a/src/core/lombok/eclipse/handlers/HandleConstructor.java
+++ b/src/core/lombok/eclipse/handlers/HandleConstructor.java
@@ -194,12 +194,7 @@ public class HandleConstructor {
 	}
 	
 	static boolean checkLegality(EclipseNode typeNode, EclipseNode errorNode, String name) {
-		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)) != 0;
-		
-		if (typeDecl == null || notAClass) {
+		if (!isClassOrEnum(typeNode)) {
 			errorNode.addError(name + " is only supported on a class or an enum.");
 			return false;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleData.java b/src/core/lombok/eclipse/handlers/HandleData.java
index 4011890d..6663d7d0 100644
--- a/src/core/lombok/eclipse/handlers/HandleData.java
+++ b/src/core/lombok/eclipse/handlers/HandleData.java
@@ -22,6 +22,7 @@
 package lombok.eclipse.handlers;
 
 import static lombok.core.handlers.HandlerUtil.*;
+import static lombok.eclipse.handlers.EclipseHandlerUtil.isClass;
 
 import java.util.Collections;
 
@@ -34,8 +35,6 @@ import lombok.eclipse.EclipseNode;
 import lombok.eclipse.handlers.HandleConstructor.SkipIfConstructorExists;
 
 import org.eclipse.jdt.internal.compiler.ast.Annotation;
-import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.mangosdk.spi.ProviderFor;
 
 /**
@@ -55,13 +54,7 @@ public class HandleData extends EclipseAnnotationHandler<Data> {
 		Data ann = annotation.getInstance();
 		EclipseNode typeNode = annotationNode.up();
 		
-		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) {
+		if (!isClass(typeNode)) {
 			annotationNode.addError("@Data is only supported on a class.");
 			return;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
index 7147343e..83e6de61 100755
--- a/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
+++ b/src/core/lombok/eclipse/handlers/HandleEqualsAndHashCode.java
@@ -137,13 +137,9 @@ public class HandleEqualsAndHashCode extends EclipseAnnotationHandler<EqualsAndH
 		Boolean callSuper, boolean whineIfExists, FieldAccess fieldAccess, List<Annotation> onParam) {
 		
 		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) {
+		if (!isClass(typeNode)) {
 			errorNode.addError("@EqualsAndHashCode is only supported on a class.");
 			return;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java b/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java
index 702713fe..4927a8fb 100644
--- a/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java
+++ b/src/core/lombok/eclipse/handlers/HandleFieldDefaults.java
@@ -63,13 +63,7 @@ public class HandleFieldDefaults extends EclipseASTAdapter {
 			}
 		}
 		
-		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)) != 0;
-		
-		if (typeDecl == null || notAClass) {
+		if (!isClassOrEnum(typeNode)) {
 			pos.addError("@FieldDefaults is only supported on a class or an enum.");
 			return false;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleGetter.java b/src/core/lombok/eclipse/handlers/HandleGetter.java
index 9cd1e2a1..755311b1 100644
--- a/src/core/lombok/eclipse/handlers/HandleGetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleGetter.java
@@ -90,13 +90,7 @@ public class HandleGetter extends EclipseAnnotationHandler<Getter> {
 			}
 		}
 		
-		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)) != 0;
-		
-		if (typeDecl == null || notAClass) {
+		if (!isClassOrEnum(typeNode)) {
 			pos.addError("@Getter is only supported on a class, an enum, or a field.");
 			return false;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index a0e431e5..9eae601b 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -85,6 +85,10 @@ public class HandleLog {
 				annotationNode.addWarning("Field '" + logFieldName + "' already exists.");
 				return;
 			}
+			if (isRecord(owner) && !useStatic) {
+				annotationNode.addError("Logger fields must be static in records.");
+				return;
+			}
 
 			Object valueGuess = annotation.getValueGuess("topic");
 			Expression loggerTopic = (Expression) annotation.getActualExpression("topic");
diff --git a/src/core/lombok/eclipse/handlers/HandleNonNull.java b/src/core/lombok/eclipse/handlers/HandleNonNull.java
index 903d098b..8dc4f4f7 100644
--- a/src/core/lombok/eclipse/handlers/HandleNonNull.java
+++ b/src/core/lombok/eclipse/handlers/HandleNonNull.java
@@ -26,6 +26,7 @@ import static lombok.eclipse.Eclipse.isPrimitive;
 import static lombok.eclipse.handlers.EclipseHandlerUtil.*;
 
 import java.util.Arrays;
+import java.util.Collections;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration;
@@ -48,17 +49,18 @@ import org.eclipse.jdt.internal.compiler.ast.TryStatement;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
 import org.mangosdk.spi.ProviderFor;
 
+import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
 import lombok.NonNull;
 import lombok.core.AST.Kind;
 import lombok.core.AnnotationValues;
 import lombok.core.HandlerPriority;
-import lombok.eclipse.DeferUntilPostDiet;
 import lombok.eclipse.EclipseAST;
 import lombok.eclipse.EclipseAnnotationHandler;
+import lombok.eclipse.EclipseAugments;
 import lombok.eclipse.EclipseNode;
+import lombok.eclipse.handlers.HandleConstructor.SkipIfConstructorExists;
 
-@DeferUntilPostDiet
 @ProviderFor(EclipseAnnotationHandler.class)
 @HandlerPriority(value = 512) // 2^9; onParameter=@__(@NonNull) has to run first.
 public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
@@ -66,6 +68,7 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 	private static final char[] CHECK_NOT_NULL = "checkNotNull".toCharArray();
 	
 	public static final HandleNonNull INSTANCE = new HandleNonNull();
+	private HandleConstructor handleConstructor = new HandleConstructor();
 	
 	public void fix(EclipseNode method) {
 		for (EclipseNode m : method.down()) {
@@ -81,6 +84,17 @@ public class HandleNonNull extends EclipseAnnotationHandler<NonNull> {
 	}
 	
 	@Override public void handle(AnnotationValues<NonNull> annotation, Annotation ast, EclipseNode annotationNode) {
+		// Generating new methods is only possible during diet parse but modifying existing methods requires a full parse.
+		// As we need both for @NonNull we reset the handled flag during diet parse.
+		if (!annotationNode.isCompleteParse()) {
+			EclipseNode typeNode = upToTypeNode(annotationNode);
+			if (isRecordField(annotationNode.up()) && !lombokConstructorExists(typeNode)) {
+				handleConstructor.generateAllArgsConstructor(typeNode, AccessLevel.PUBLIC, null, SkipIfConstructorExists.NO, Collections.<Annotation>emptyList(), annotationNode);
+			}
+			EclipseAugments.ASTNode_handled.clear(ast);
+			return;
+		}
+		
 		handle0(ast, annotationNode, false);
 	}
 	
diff --git a/src/core/lombok/eclipse/handlers/HandleSetter.java b/src/core/lombok/eclipse/handlers/HandleSetter.java
index cb2ca3bf..9ebbde6d 100644
--- a/src/core/lombok/eclipse/handlers/HandleSetter.java
+++ b/src/core/lombok/eclipse/handlers/HandleSetter.java
@@ -71,13 +71,7 @@ public class HandleSetter extends EclipseAnnotationHandler<Setter> {
 			}
 		}
 		
-		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) {
+		if (!isClass(typeNode)) {
 			pos.addError("@Setter is only supported on a class or a field.");
 			return false;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
index b1e7c419..89c27fe3 100644
--- a/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
+++ b/src/core/lombok/eclipse/handlers/HandleSuperBuilder.java
@@ -156,7 +156,7 @@ public class HandleSuperBuilder extends EclipseAnnotationHandler<SuperBuilder> {
 		
 		boolean addCleaning = false;
 		
-		if (!(tdParent.get() instanceof TypeDeclaration)) {
+		if (!isClass(tdParent)) {
 			annotationNode.addError("@SuperBuilder is only supported on types.");
 			return;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleSynchronized.java b/src/core/lombok/eclipse/handlers/HandleSynchronized.java
index 08d00d91..37d6755c 100644
--- a/src/core/lombok/eclipse/handlers/HandleSynchronized.java
+++ b/src/core/lombok/eclipse/handlers/HandleSynchronized.java
@@ -148,6 +148,12 @@ public class HandleSynchronized extends EclipseAnnotationHandler<Synchronized> {
 			return;
 		}
 		
+		EclipseNode typeNode = upToTypeNode(annotationNode);
+		if (!isClassOrEnum(typeNode)) {
+			annotationNode.addError("@Synchronized is legal only on methods in classes and enums.");
+			return;
+		}
+		
 		boolean[] isStatic = { method.isStatic() };
 		char[] lockName = createLockField(annotation, annotationNode, isStatic, true);
 		if (lockName == null) return;
@@ -163,7 +169,6 @@ public class HandleSynchronized extends EclipseAnnotationHandler<Synchronized> {
 		
 		Expression lockVariable;
 		if (isStatic[0]) {
-			EclipseNode typeNode = upToTypeNode(annotationNode);
 			char[][] n = getQualifiedInnerName(typeNode, lockName);
 			long[] ps = new long[n.length];
 			Arrays.fill(ps, pos);
diff --git a/src/core/lombok/eclipse/handlers/HandleToString.java b/src/core/lombok/eclipse/handlers/HandleToString.java
index a6bcb24f..9b58474c 100644
--- a/src/core/lombok/eclipse/handlers/HandleToString.java
+++ b/src/core/lombok/eclipse/handlers/HandleToString.java
@@ -50,7 +50,6 @@ import org.eclipse.jdt.internal.compiler.ast.SuperReference;
 import org.eclipse.jdt.internal.compiler.ast.ThisReference;
 import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
 import org.mangosdk.spi.ProviderFor;
 
@@ -116,14 +115,7 @@ public class HandleToString extends EclipseAnnotationHandler<ToString> {
 	public void generateToString(EclipseNode typeNode, EclipseNode errorNode, List<Included<EclipseNode, ToString.Include>> members,
 		boolean includeFieldNames, Boolean callSuper, boolean whineIfExists, FieldAccess fieldAccess) {
 		
-		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)) != 0;
-		
-		if (typeDecl == null || notAClass) {
+		if (!isClassOrEnum(typeNode)) {
 			errorNode.addError("@ToString is only supported on a class or enum.");
 			return;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleUtilityClass.java b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
index 2349f839..338aab0d 100644
--- a/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
+++ b/src/core/lombok/eclipse/handlers/HandleUtilityClass.java
@@ -70,13 +70,8 @@ public class HandleUtilityClass extends EclipseAnnotationHandler<UtilityClass> {
 	}
 	
 	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).");
+		if (!isClass(typeNode)) {
+			errorNode.addError("@UtilityClass is only supported on a class (can't be an interface, enum, annotation, or record).");
 			return false;
 		}
 		
diff --git a/src/core/lombok/eclipse/handlers/HandleValue.java b/src/core/lombok/eclipse/handlers/HandleValue.java
index 2e0338a8..abea5603 100644
--- a/src/core/lombok/eclipse/handlers/HandleValue.java
+++ b/src/core/lombok/eclipse/handlers/HandleValue.java
@@ -61,11 +61,8 @@ public class HandleValue extends EclipseAnnotationHandler<Value> {
 		
 		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) {
+		if (!isClass(typeNode)) {
 			annotationNode.addError("@Value is only supported on a class.");
 			return;
 		}
diff --git a/src/core/lombok/eclipse/handlers/HandleWithBy.java b/src/core/lombok/eclipse/handlers/HandleWithBy.java
index 5f229aaf..40e2d524 100644
--- a/src/core/lombok/eclipse/handlers/HandleWithBy.java
+++ b/src/core/lombok/eclipse/handlers/HandleWithBy.java
@@ -29,7 +29,9 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 import org.eclipse.jdt.internal.compiler.ast.ASTNode;
 import org.eclipse.jdt.internal.compiler.ast.AllocationExpression;
@@ -136,7 +138,10 @@ public class HandleWithBy extends EclipseAnnotationHandler<WithBy> {
 		
 		switch (node.getKind()) {
 		case FIELD:
-			createWithByForFields(level, annotationNode.upFromAnnotationToFields(), annotationNode, true, onMethod);
+			Set<EclipseNode> fields = new LinkedHashSet<EclipseNode>();
+			fields.add(node);
+			fields.addAll(annotationNode.upFromAnnotationToFields());
+			createWithByForFields(level, fields, annotationNode, true, onMethod);
 			break;
 		case TYPE:
 			if (!onMethod.isEmpty()) {