From 13061ac02e49816d7e101b1884f0283ab7faf2f4 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Sun, 17 Aug 2025 09:54:13 -0400
Subject: [PATCH 01/16] Add gitignore for generated gradle files

---
 docker/gradle/files/classpath/.gitignore | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 docker/gradle/files/classpath/.gitignore

diff --git a/docker/gradle/files/classpath/.gitignore b/docker/gradle/files/classpath/.gitignore
new file mode 100644
index 00000000..a86f5fa1
--- /dev/null
+++ b/docker/gradle/files/classpath/.gitignore
@@ -0,0 +1,5 @@
+build/
+.gradle/
+gradle/
+gradlew
+gradlew.bat
\ No newline at end of file

From 392abe1003ae8b12ae2bd6d112ec6b6d499bce7c Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Sun, 17 Aug 2025 23:12:04 -0400
Subject: [PATCH 02/16] Add `access` properties to logger annotations

---
 src/core/lombok/CustomLog.java                       | 7 +++++++
 src/core/lombok/extern/apachecommons/CommonsLog.java | 9 +++++++++
 src/core/lombok/extern/flogger/Flogger.java          | 8 ++++++++
 src/core/lombok/extern/java/Log.java                 | 9 +++++++++
 src/core/lombok/extern/jbosslog/JBossLog.java        | 9 +++++++++
 src/core/lombok/extern/log4j/Log4j.java              | 9 +++++++++
 src/core/lombok/extern/log4j/Log4j2.java             | 9 +++++++++
 src/core/lombok/extern/slf4j/Slf4j.java              | 9 +++++++++
 src/core/lombok/extern/slf4j/XSlf4j.java             | 9 +++++++++
 9 files changed, 78 insertions(+)

diff --git a/src/core/lombok/CustomLog.java b/src/core/lombok/CustomLog.java
index c6ea400d..0e01e29a 100644
--- a/src/core/lombok/CustomLog.java
+++ b/src/core/lombok/CustomLog.java
@@ -65,6 +65,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface CustomLog {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/**
 	 * 
 	 * Sets a custom topic/category. Note that this requires you to specify a parameter configuration for your custom logger that includes {@code TOPIC}.
diff --git a/src/core/lombok/extern/apachecommons/CommonsLog.java b/src/core/lombok/extern/apachecommons/CommonsLog.java
index 973f556f..1a5d18dc 100644
--- a/src/core/lombok/extern/apachecommons/CommonsLog.java
+++ b/src/core/lombok/extern/apachecommons/CommonsLog.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -62,6 +64,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface CommonsLog {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/flogger/Flogger.java b/src/core/lombok/extern/flogger/Flogger.java
index 893032ed..d6e4786f 100644
--- a/src/core/lombok/extern/flogger/Flogger.java
+++ b/src/core/lombok/extern/flogger/Flogger.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -60,4 +62,10 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface Flogger {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
 }
diff --git a/src/core/lombok/extern/java/Log.java b/src/core/lombok/extern/java/Log.java
index 96e52191..7478c64e 100644
--- a/src/core/lombok/extern/java/Log.java
+++ b/src/core/lombok/extern/java/Log.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -61,6 +63,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface Log {
+	/**
+	 * If you want your logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/jbosslog/JBossLog.java b/src/core/lombok/extern/jbosslog/JBossLog.java
index a6e5e353..de6b76d2 100644
--- a/src/core/lombok/extern/jbosslog/JBossLog.java
+++ b/src/core/lombok/extern/jbosslog/JBossLog.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -61,6 +63,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface JBossLog {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/log4j/Log4j.java b/src/core/lombok/extern/log4j/Log4j.java
index 3db01029..6dd809c5 100644
--- a/src/core/lombok/extern/log4j/Log4j.java
+++ b/src/core/lombok/extern/log4j/Log4j.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -62,6 +64,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface Log4j {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/log4j/Log4j2.java b/src/core/lombok/extern/log4j/Log4j2.java
index 3e59a532..741e408c 100644
--- a/src/core/lombok/extern/log4j/Log4j2.java
+++ b/src/core/lombok/extern/log4j/Log4j2.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -62,6 +64,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface Log4j2 {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/slf4j/Slf4j.java b/src/core/lombok/extern/slf4j/Slf4j.java
index da65e27c..e4747b99 100644
--- a/src/core/lombok/extern/slf4j/Slf4j.java
+++ b/src/core/lombok/extern/slf4j/Slf4j.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -61,6 +63,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface Slf4j {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }
diff --git a/src/core/lombok/extern/slf4j/XSlf4j.java b/src/core/lombok/extern/slf4j/XSlf4j.java
index 2dfef265..43ae82bc 100644
--- a/src/core/lombok/extern/slf4j/XSlf4j.java
+++ b/src/core/lombok/extern/slf4j/XSlf4j.java
@@ -26,6 +26,8 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import lombok.AccessLevel;
+
 /**
  * Causes lombok to generate a logger field.
  * <p>
@@ -61,6 +63,13 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.TYPE)
 public @interface XSlf4j {
+	/**
+	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * 
+	 * @return The constructed Logger method will be generated with this access modifier.
+	 */
+	AccessLevel access() default AccessLevel.PRIVATE;
+	
 	/** @return The category of the constructed Logger. By default, it will use the type where the annotation is placed. */
 	String topic() default "";
 }

From 7c692b559e2e8b61b6c1d396f25bfec652c9effe Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 00:14:13 -0400
Subject: [PATCH 03/16] Implement `access` for javac

---
 src/core/lombok/javac/handlers/HandleLog.java | 58 +++++++++++--------
 1 file changed, 34 insertions(+), 24 deletions(-)

diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 7484ae66..173d8f2a 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -21,10 +21,21 @@
  */
 package lombok.javac.handlers;
 
-import static lombok.core.handlers.HandlerUtil.*;
+import static lombok.core.handlers.HandlerUtil.handleFlagUsage;
 import static lombok.javac.Javac.CTC_BOT;
 import static lombok.javac.handlers.JavacHandlerUtil.*;
 
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.tree.JCTree.JCAnnotation;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCExpression;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
+import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+
+import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
 import lombok.core.AnnotationValues;
 import lombok.core.configuration.IdentifierName;
@@ -38,16 +49,6 @@ import lombok.javac.JavacTreeMaker;
 import lombok.javac.handlers.JavacHandlerUtil.MemberExistsResult;
 import lombok.spi.Provides;
 
-import com.sun.tools.javac.code.Flags;
-import com.sun.tools.javac.tree.JCTree.JCAnnotation;
-import com.sun.tools.javac.tree.JCTree.JCClassDecl;
-import com.sun.tools.javac.tree.JCTree.JCExpression;
-import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
-import com.sun.tools.javac.tree.JCTree.JCMethodInvocation;
-import com.sun.tools.javac.tree.JCTree.JCVariableDecl;
-import com.sun.tools.javac.util.List;
-import com.sun.tools.javac.util.Name;
-
 public class HandleLog {
 	private static final IdentifierName LOG = IdentifierName.valueOf("log");
 	
@@ -55,7 +56,7 @@ public class HandleLog {
 		throw new UnsupportedOperationException();
 	}
 	
-	public static void processAnnotation(LoggingFramework framework, AnnotationValues<?> annotation, JavacNode annotationNode) {
+	public static void processAnnotation(LoggingFramework framework, AccessLevel access, AnnotationValues<?> annotation, JavacNode annotationNode) {
 		deleteAnnotationIfNeccessary(annotationNode, framework.getAnnotationClass());
 		
 		JavacNode typeNode = annotationNode.up();
@@ -99,7 +100,7 @@ public class HandleLog {
 			}
 			
 			JCFieldAccess loggingType = selfType(typeNode);
-			createField(framework, typeNode, loggingType, annotationNode, logFieldName.getName(), useStatic, loggerTopic);
+			createField(framework, access, typeNode, loggingType, annotationNode, logFieldName.getName(), useStatic, loggerTopic);
 			break;
 		default:
 			annotationNode.addError("@Log is legal only on types.");
@@ -113,7 +114,16 @@ public class HandleLog {
 		return maker.Select(maker.Ident(name), typeNode.toName("class"));
 	}
 	
-	private static boolean createField(LoggingFramework framework, JavacNode typeNode, JCFieldAccess loggingType, JavacNode source, String logFieldName, boolean useStatic, JCExpression loggerTopic) {
+	private static int toFlags(AccessLevel level) {
+		switch (level) {
+			case PUBLIC: return Flags.PUBLIC; 
+			case PROTECTED: return Flags.PROTECTED;
+			case PRIVATE: return Flags.PUBLIC;
+			default: return 0;
+		}
+	}
+	
+	private static boolean createField(LoggingFramework framework, AccessLevel access, JavacNode typeNode, JCFieldAccess loggingType, JavacNode source, String logFieldName, boolean useStatic, JCExpression loggerTopic) {
 		JavacTreeMaker maker = typeNode.getTreeMaker();
 		
 		LogDeclaration logDeclaration = framework.getDeclaration();
@@ -126,7 +136,7 @@ public class HandleLog {
 		JCMethodInvocation factoryMethodCall = maker.Apply(List.<JCExpression>nil(), factoryMethod, List.<JCExpression>from(factoryParameters));
 		
 		JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef(
-			maker.Modifiers(Flags.PRIVATE | Flags.FINAL | (useStatic ? Flags.STATIC : 0)),
+			maker.Modifiers(toFlags(access) | Flags.FINAL | (useStatic ? Flags.STATIC : 0)),
 			typeNode.toName(logFieldName), loggerType, factoryMethodCall), source);
 		
 		if (isRecord(typeNode) && Javac.getJavaCompilerVersion() < 16) {
@@ -177,7 +187,7 @@ public class HandleLog {
 	public static class HandleCommonsLog extends JavacAnnotationHandler<lombok.extern.apachecommons.CommonsLog> {
 		@Override public void handle(AnnotationValues<lombok.extern.apachecommons.CommonsLog> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_COMMONS_FLAG_USAGE, "@apachecommons.CommonsLog", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.COMMONS, annotation, annotationNode);
+			processAnnotation(LoggingFramework.COMMONS, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -188,7 +198,7 @@ public class HandleLog {
 	public static class HandleJulLog extends JavacAnnotationHandler<lombok.extern.java.Log> {
 		@Override public void handle(AnnotationValues<lombok.extern.java.Log> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_JUL_FLAG_USAGE, "@java.Log", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.JUL, annotation, annotationNode);
+			processAnnotation(LoggingFramework.JUL, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -199,7 +209,7 @@ public class HandleLog {
 	public static class HandleLog4jLog extends JavacAnnotationHandler<lombok.extern.log4j.Log4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_LOG4J_FLAG_USAGE, "@Log4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.LOG4J, annotation, annotationNode);
+			processAnnotation(LoggingFramework.LOG4J, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -210,7 +220,7 @@ public class HandleLog {
 	public static class HandleLog4j2Log extends JavacAnnotationHandler<lombok.extern.log4j.Log4j2> {
 		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j2> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_LOG4J2_FLAG_USAGE, "@Log4j2", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.LOG4J2, annotation, annotationNode);
+			processAnnotation(LoggingFramework.LOG4J2, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -221,7 +231,7 @@ public class HandleLog {
 	public static class HandleSlf4jLog extends JavacAnnotationHandler<lombok.extern.slf4j.Slf4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.slf4j.Slf4j> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_SLF4J_FLAG_USAGE, "@Slf4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.SLF4J, annotation, annotationNode);
+			processAnnotation(LoggingFramework.SLF4J, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -232,7 +242,7 @@ public class HandleLog {
 	public static class HandleXSlf4jLog extends JavacAnnotationHandler<lombok.extern.slf4j.XSlf4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.slf4j.XSlf4j> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_XSLF4J_FLAG_USAGE, "@XSlf4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.XSLF4J, annotation, annotationNode);
+			processAnnotation(LoggingFramework.XSLF4J, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -243,7 +253,7 @@ public class HandleLog {
 	public static class HandleJBossLog extends JavacAnnotationHandler<lombok.extern.jbosslog.JBossLog> {
 		@Override public void handle(AnnotationValues<lombok.extern.jbosslog.JBossLog> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_JBOSSLOG_FLAG_USAGE, "@JBossLog", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.JBOSSLOG, annotation, annotationNode);
+			processAnnotation(LoggingFramework.JBOSSLOG, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -254,7 +264,7 @@ public class HandleLog {
 	public static class HandleFloggerLog extends JavacAnnotationHandler<lombok.extern.flogger.Flogger> {
 		@Override public void handle(AnnotationValues<lombok.extern.flogger.Flogger> annotation, JCAnnotation ast, JavacNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_FLOGGER_FLAG_USAGE, "@Flogger", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.FLOGGER, annotation, annotationNode);
+			processAnnotation(LoggingFramework.FLOGGER, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 	
@@ -271,7 +281,7 @@ public class HandleLog {
 				return;
 			}
 			LoggingFramework framework = new LoggingFramework(lombok.CustomLog.class, logDeclaration);
-			processAnnotation(framework, annotation, annotationNode);
+			processAnnotation(framework, annotation.getInstance().access(), annotation, annotationNode);
 		}
 	}
 }

From 3d15eb6782ca0dba50fdec54e0e3871e64e27ee5 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 00:17:42 -0400
Subject: [PATCH 04/16] Implement `access` for eclipse

---
 .../lombok/eclipse/handlers/HandleLog.java    | 38 ++++++++++++-------
 1 file changed, 25 insertions(+), 13 deletions(-)

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index 2bbc300a..8a2d1483 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -39,6 +39,9 @@ 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 com.sun.tools.javac.code.Flags;
+
+import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
 import lombok.core.AnnotationValues;
 import lombok.core.configuration.IdentifierName;
@@ -57,7 +60,7 @@ public class HandleLog {
 		throw new UnsupportedOperationException();
 	}
 	
-	public static void processAnnotation(LoggingFramework framework, AnnotationValues<? extends java.lang.annotation.Annotation> annotation, Annotation source, EclipseNode annotationNode) {
+	public static void processAnnotation(LoggingFramework framework, AccessLevel access, AnnotationValues<? extends java.lang.annotation.Annotation> annotation, Annotation source, EclipseNode annotationNode) {
 		EclipseNode owner = annotationNode.up();
 		
 		switch (owner.getKind()) {
@@ -107,7 +110,7 @@ public class HandleLog {
 			}
 			
 			ClassLiteralAccess loggingType = selfType(owner, source);
-			FieldDeclaration fieldDeclaration = createField(framework, source, loggingType, logFieldName.getName(), useStatic, loggerTopic);
+			FieldDeclaration fieldDeclaration = createField(framework, access, source, loggingType, logFieldName.getName(), useStatic, loggerTopic);
 			fieldDeclaration.traverse(new SetGeneratedByVisitor(source), typeDecl.staticInitializerScope);
 			injectFieldAndMarkGenerated(owner, fieldDeclaration);
 			owner.rebuild();
@@ -131,7 +134,16 @@ public class HandleLog {
 		return result;
 	}
 	
-	private static FieldDeclaration createField(LoggingFramework framework, Annotation source, ClassLiteralAccess loggingType, String logFieldName, boolean useStatic, Expression loggerTopic) {
+	private static int toFlags(AccessLevel level) {
+		switch (level) {
+			case PUBLIC: return Flags.PUBLIC; 
+			case PROTECTED: return Flags.PROTECTED;
+			case PRIVATE: return Flags.PUBLIC;
+			default: return 0;
+		}
+	}
+	
+	private static FieldDeclaration createField(LoggingFramework framework, AccessLevel access, Annotation source, ClassLiteralAccess loggingType, String logFieldName, boolean useStatic, Expression loggerTopic) {
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long) pS << 32 | pE;
 		
@@ -139,7 +151,7 @@ public class HandleLog {
 		FieldDeclaration fieldDecl = new FieldDeclaration(logFieldName.toCharArray(), 0, -1);
 		setGeneratedBy(fieldDecl, source);
 		fieldDecl.declarationSourceEnd = -1;
-		fieldDecl.modifiers = Modifier.PRIVATE | (useStatic ? Modifier.STATIC : 0) | Modifier.FINAL;
+		fieldDecl.modifiers = toFlags(access) | (useStatic ? Modifier.STATIC : 0) | Modifier.FINAL;
 		
 		LogDeclaration logDeclaration = framework.getDeclaration();
 		fieldDecl.type = createTypeReference(logDeclaration.getLoggerType().getName(), source);
@@ -215,7 +227,7 @@ public class HandleLog {
 	public static class HandleCommonsLog extends EclipseAnnotationHandler<lombok.extern.apachecommons.CommonsLog> {
 		@Override public void handle(AnnotationValues<lombok.extern.apachecommons.CommonsLog> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_COMMONS_FLAG_USAGE, "@apachecommons.CommonsLog", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.COMMONS, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.COMMONS, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -226,7 +238,7 @@ public class HandleLog {
 	public static class HandleJulLog extends EclipseAnnotationHandler<lombok.extern.java.Log> {
 		@Override public void handle(AnnotationValues<lombok.extern.java.Log> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_JUL_FLAG_USAGE, "@java.Log", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.JUL, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.JUL, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -237,7 +249,7 @@ public class HandleLog {
 	public static class HandleLog4jLog extends EclipseAnnotationHandler<lombok.extern.log4j.Log4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_LOG4J_FLAG_USAGE, "@Log4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.LOG4J, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.LOG4J, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -248,7 +260,7 @@ public class HandleLog {
 	public static class HandleLog4j2Log extends EclipseAnnotationHandler<lombok.extern.log4j.Log4j2> {
 		@Override public void handle(AnnotationValues<lombok.extern.log4j.Log4j2> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_LOG4J2_FLAG_USAGE, "@Log4j2", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.LOG4J2, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.LOG4J2, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -259,7 +271,7 @@ public class HandleLog {
 	public static class HandleSlf4jLog extends EclipseAnnotationHandler<lombok.extern.slf4j.Slf4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.slf4j.Slf4j> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_SLF4J_FLAG_USAGE, "@Slf4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.SLF4J, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.SLF4J, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -270,7 +282,7 @@ public class HandleLog {
 	public static class HandleXSlf4jLog extends EclipseAnnotationHandler<lombok.extern.slf4j.XSlf4j> {
 		@Override public void handle(AnnotationValues<lombok.extern.slf4j.XSlf4j> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_XSLF4J_FLAG_USAGE, "@XSlf4j", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.XSLF4J, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.XSLF4J, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -281,7 +293,7 @@ public class HandleLog {
 	public static class HandleJBossLog extends EclipseAnnotationHandler<lombok.extern.jbosslog.JBossLog> {
 		@Override public void handle(AnnotationValues<lombok.extern.jbosslog.JBossLog> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_JBOSSLOG_FLAG_USAGE, "@JBossLog", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.JBOSSLOG, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.JBOSSLOG, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -292,7 +304,7 @@ public class HandleLog {
 	public static class HandleFloggerLog extends EclipseAnnotationHandler<lombok.extern.flogger.Flogger> {
 		@Override public void handle(AnnotationValues<lombok.extern.flogger.Flogger> annotation, Annotation source, EclipseNode annotationNode) {
 			handleFlagUsage(annotationNode, ConfigurationKeys.LOG_FLOGGER_FLAG_USAGE, "@Flogger", ConfigurationKeys.LOG_ANY_FLAG_USAGE, "any @Log");
-			processAnnotation(LoggingFramework.FLOGGER, annotation, source, annotationNode);
+			processAnnotation(LoggingFramework.FLOGGER, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 	
@@ -309,7 +321,7 @@ public class HandleLog {
 				return;
 			}
 			LoggingFramework framework = new LoggingFramework(lombok.CustomLog.class, logDeclaration);
-			processAnnotation(framework, annotation, source, annotationNode);
+			processAnnotation(framework, annotation.getInstance().access(), annotation, source, annotationNode);
 		}
 	}
 }

From 7bf709420fc4ec083a4309de9871038795083baa Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 18:19:52 -0400
Subject: [PATCH 05/16] Add before transforms for various loggers

---
 .../resource/before/LoggerCommonsAccess.java  | 26 +++++++++++++++++++
 .../resource/before/LoggerCustomAccess.java   | 26 +++++++++++++++++++
 .../resource/before/LoggerFloggerAccess.java  | 26 +++++++++++++++++++
 .../resource/before/LoggerJbossLogAccess.java | 26 +++++++++++++++++++
 .../resource/before/LoggerJulAccess.java      | 26 +++++++++++++++++++
 .../resource/before/LoggerLog4j2Access.java   | 26 +++++++++++++++++++
 .../resource/before/LoggerLog4jAccess.java    | 26 +++++++++++++++++++
 .../resource/before/LoggerSlf4jAccess.java    | 26 +++++++++++++++++++
 .../resource/before/LoggerXslf4jAccess.java   | 26 +++++++++++++++++++
 9 files changed, 234 insertions(+)
 create mode 100644 test/transform/resource/before/LoggerCommonsAccess.java
 create mode 100644 test/transform/resource/before/LoggerCustomAccess.java
 create mode 100644 test/transform/resource/before/LoggerFloggerAccess.java
 create mode 100644 test/transform/resource/before/LoggerJbossLogAccess.java
 create mode 100644 test/transform/resource/before/LoggerJulAccess.java
 create mode 100644 test/transform/resource/before/LoggerLog4j2Access.java
 create mode 100644 test/transform/resource/before/LoggerLog4jAccess.java
 create mode 100644 test/transform/resource/before/LoggerSlf4jAccess.java
 create mode 100644 test/transform/resource/before/LoggerXslf4jAccess.java

diff --git a/test/transform/resource/before/LoggerCommonsAccess.java b/test/transform/resource/before/LoggerCommonsAccess.java
new file mode 100644
index 00000000..91c2930a
--- /dev/null
+++ b/test/transform/resource/before/LoggerCommonsAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.apachecommons.CommonsLog;
+
+@CommonsLog(access=AccessLevel.PUBLIC)
+class LoggerCommonsAccessPublic {
+}
+
+@CommonsLog(access=AccessLevel.MODULE)
+class LoggerCommonsAccessModule {
+}
+
+@CommonsLog(access=AccessLevel.PROTECTED)
+class LoggerCommonsAccessProtected {
+}
+
+@CommonsLog(access=AccessLevel.PACKAGE)
+class LoggerCommonsAccessPackage {
+}
+
+@CommonsLog(access=AccessLevel.PRIVATE)
+class LoggerCommonsAccessPrivate {
+}
+
+@CommonsLog(access=AccessLevel.NONE)
+class LoggerCommonsAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerCustomAccess.java b/test/transform/resource/before/LoggerCustomAccess.java
new file mode 100644
index 00000000..404fb9b6
--- /dev/null
+++ b/test/transform/resource/before/LoggerCustomAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.CustomLog;
+
+@CustomLog(access=AccessLevel.PUBLIC)
+class LoggerCustomAccessPublic {
+}
+
+@CustomLog(access=AccessLevel.MODULE)
+class LoggerCustomAccessModule {
+}
+
+@CustomLog(access=AccessLevel.PROTECTED)
+class LoggerCustomAccessProtected {
+}
+
+@CustomLog(access=AccessLevel.PACKAGE)
+class LoggerCustomAccessPackage {
+}
+
+@CustomLog(access=AccessLevel.PRIVATE)
+class LoggerCustomAccessPrivate {
+}
+
+@CustomLog(access=AccessLevel.NONE)
+class LoggerCustomAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerFloggerAccess.java b/test/transform/resource/before/LoggerFloggerAccess.java
new file mode 100644
index 00000000..9673ebe6
--- /dev/null
+++ b/test/transform/resource/before/LoggerFloggerAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.flogger.Flogger;
+
+@Flogger(access=AccessLevel.PUBLIC)
+class LoggerFloggerAccessPublic {
+}
+
+@Flogger(access=AccessLevel.MODULE)
+class LoggerFloggerAccessModule {
+}
+
+@Flogger(access=AccessLevel.PROTECTED)
+class LoggerFloggerAccessProtected {
+}
+
+@Flogger(access=AccessLevel.PACKAGE)
+class LoggerFloggerAccessPackage {
+}
+
+@Flogger(access=AccessLevel.PRIVATE)
+class LoggerFloggerAccessPrivate {
+}
+
+@Flogger(access=AccessLevel.NONE)
+class LoggerFloggerAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerJbossLogAccess.java b/test/transform/resource/before/LoggerJbossLogAccess.java
new file mode 100644
index 00000000..ac79e222
--- /dev/null
+++ b/test/transform/resource/before/LoggerJbossLogAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.jbosslog.JBossLog;
+
+@JBossLog(access=AccessLevel.PUBLIC)
+class LoggerJBossLogAccessPublic {
+}
+
+@JBossLog(access=AccessLevel.MODULE)
+class LoggerJBossLogAccessModule {
+}
+
+@JBossLog(access=AccessLevel.PROTECTED)
+class LoggerJBossLogAccessProtected {
+}
+
+@JBossLog(access=AccessLevel.PACKAGE)
+class LoggerJBossLogAccessPackage {
+}
+
+@JBossLog(access=AccessLevel.PRIVATE)
+class LoggerJBossLogAccessPrivate {
+}
+
+@JBossLog(access=AccessLevel.NONE)
+class LoggerJBossLogAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerJulAccess.java b/test/transform/resource/before/LoggerJulAccess.java
new file mode 100644
index 00000000..a6200ca5
--- /dev/null
+++ b/test/transform/resource/before/LoggerJulAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.java.Log;
+
+@Log(access=AccessLevel.PUBLIC)
+class LoggerJulAccessPublic {
+}
+
+@Log(access=AccessLevel.MODULE)
+class LoggerJulAccessModule {
+}
+
+@Log(access=AccessLevel.PROTECTED)
+class LoggerJulAccessProtected {
+}
+
+@Log(access=AccessLevel.PACKAGE)
+class LoggerJulAccessPackage {
+}
+
+@Log(access=AccessLevel.PRIVATE)
+class LoggerJulAccessPrivate {
+}
+
+@Log(access=AccessLevel.NONE)
+class LoggerJulAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerLog4j2Access.java b/test/transform/resource/before/LoggerLog4j2Access.java
new file mode 100644
index 00000000..c3fa3232
--- /dev/null
+++ b/test/transform/resource/before/LoggerLog4j2Access.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.log4j.Log4j2;
+
+@Log4j2(access=AccessLevel.PUBLIC)
+class LoggerLog4j2AccessPublic {
+}
+
+@Log4j2(access=AccessLevel.MODULE)
+class LoggerLog4j2AccessModule {
+}
+
+@Log4j2(access=AccessLevel.PROTECTED)
+class LoggerLog4j2AccessProtected {
+}
+
+@Log4j2(access=AccessLevel.PACKAGE)
+class LoggerLog4j2AccessPackage {
+}
+
+@Log4j2(access=AccessLevel.PRIVATE)
+class LoggerLog4j2AccessPrivate {
+}
+
+@Log4j2(access=AccessLevel.NONE)
+class LoggerLog4j2AccessNone {
+}
diff --git a/test/transform/resource/before/LoggerLog4jAccess.java b/test/transform/resource/before/LoggerLog4jAccess.java
new file mode 100644
index 00000000..a1410a0b
--- /dev/null
+++ b/test/transform/resource/before/LoggerLog4jAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.log4j.Log4j;
+
+@Log4j(access=AccessLevel.PUBLIC)
+class LoggerLog4jAccessPublic {
+}
+
+@Log4j(access=AccessLevel.MODULE)
+class LoggerLog4jAccessModule {
+}
+
+@Log4j(access=AccessLevel.PROTECTED)
+class LoggerLog4jAccessProtected {
+}
+
+@Log4j(access=AccessLevel.PACKAGE)
+class LoggerLog4jAccessPackage {
+}
+
+@Log4j(access=AccessLevel.PRIVATE)
+class LoggerLog4jAccessPrivate {
+}
+
+@Log4j(access=AccessLevel.NONE)
+class LoggerLog4jAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerSlf4jAccess.java b/test/transform/resource/before/LoggerSlf4jAccess.java
new file mode 100644
index 00000000..65a14c75
--- /dev/null
+++ b/test/transform/resource/before/LoggerSlf4jAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j(access=AccessLevel.PUBLIC)
+class LoggerSlf4jAccessPublic {
+}
+
+@Slf4j(access=AccessLevel.MODULE)
+class LoggerSlf4jAccessModule {
+}
+
+@Slf4j(access=AccessLevel.PROTECTED)
+class LoggerSlf4jAccessProtected {
+}
+
+@Slf4j(access=AccessLevel.PACKAGE)
+class LoggerSlf4jAccessPackage {
+}
+
+@Slf4j(access=AccessLevel.PRIVATE)
+class LoggerSlf4jAccessPrivate {
+}
+
+@Slf4j(access=AccessLevel.NONE)
+class LoggerSlf4jAccessNone {
+}
diff --git a/test/transform/resource/before/LoggerXslf4jAccess.java b/test/transform/resource/before/LoggerXslf4jAccess.java
new file mode 100644
index 00000000..80d453c7
--- /dev/null
+++ b/test/transform/resource/before/LoggerXslf4jAccess.java
@@ -0,0 +1,26 @@
+import lombok.AccessLevel;
+import lombok.extern.slf4j.XSlf4j;
+
+@XSlf4j(access=AccessLevel.PUBLIC)
+class LoggerXslf4jAccessPublic {
+}
+
+@XSlf4j(access=AccessLevel.MODULE)
+class LoggerXslf4jAccessModule {
+}
+
+@XSlf4j(access=AccessLevel.PROTECTED)
+class LoggerXslf4jAccessProtected {
+}
+
+@XSlf4j(access=AccessLevel.PACKAGE)
+class LoggerXslf4jAccessPackage {
+}
+
+@XSlf4j(access=AccessLevel.PRIVATE)
+class LoggerXslf4jAccessPrivate {
+}
+
+@XSlf4j(access=AccessLevel.NONE)
+class LoggerXslf4jAccessNone {
+}

From 1100dfae2e6bc4ea1cc663ceb10df0051ff05c5b Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 18:55:23 -0400
Subject: [PATCH 06/16] Add after-ecj transform for various loggers

---
 .../after-ecj/LoggerCommonsAccess.java        | 49 +++++++++++++++++++
 .../after-ecj/LoggerCustomAccess.java         | 49 +++++++++++++++++++
 .../after-ecj/LoggerFloggerAccess.java        | 49 +++++++++++++++++++
 .../after-ecj/LoggerJBossLogAccess.java       | 49 +++++++++++++++++++
 .../resource/after-ecj/LoggerJulAccess.java   | 49 +++++++++++++++++++
 .../after-ecj/LoggerLog4j2Access.java         | 49 +++++++++++++++++++
 .../resource/after-ecj/LoggerLog4jAccess.java | 49 +++++++++++++++++++
 .../resource/after-ecj/LoggerSlf4jAccess.java | 49 +++++++++++++++++++
 .../after-ecj/LoggerXslf4jAccess.java         | 49 +++++++++++++++++++
 9 files changed, 441 insertions(+)
 create mode 100644 test/transform/resource/after-ecj/LoggerCommonsAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerCustomAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerFloggerAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerJBossLogAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerJulAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerLog4j2Access.java
 create mode 100644 test/transform/resource/after-ecj/LoggerLog4jAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerSlf4jAccess.java
 create mode 100644 test/transform/resource/after-ecj/LoggerXslf4jAccess.java

diff --git a/test/transform/resource/after-ecj/LoggerCommonsAccess.java b/test/transform/resource/after-ecj/LoggerCommonsAccess.java
new file mode 100644
index 00000000..b5e7e93c
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerCommonsAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.apachecommons.CommonsLog;
+@CommonsLog(access=AccessLevel.PUBLIC) class LoggerCommonsAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerCommonsAccessPublic() {
+    super();
+  }
+}
+@CommonsLog(access=AccessLevel.MODULE) class LoggerCommonsAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessModule.class);
+  <clinit>() {
+  }
+  LoggerCommonsAccessModule() {
+    super();
+  }
+}
+@CommonsLog(access=AccessLevel.PROTECTED) class LoggerCommonsAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerCommonsAccessProtected() {
+    super();
+  }
+}
+@CommonsLog(access=AccessLevel.PACKAGE) class LoggerCommonsAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerCommonsAccessPackage() {
+    super();
+  }
+}
+@CommonsLog(access=AccessLevel.PRIVATE) class LoggerCommonsAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerCommonsAccessPrivate() {
+    super();
+  }
+}
+@CommonsLog(access=AccessLevel.NONE) class LoggerCommonsAccessNone {
+  <clinit>() {
+  }
+  LoggerCommonsAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerCustomAccess.java b/test/transform/resource/after-ecj/LoggerCustomAccess.java
new file mode 100644
index 00000000..755e622a
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerCustomAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.CustomLog;
+@CustomLog(access=AccessLevel.PUBLIC) class LoggerCustomAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerCustomAccessPublic() {
+    super();
+  }
+}
+@CustomLog(access=AccessLevel.MODULE) class LoggerCustomAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessModule.class);
+  <clinit>() {
+  }
+  LoggerCustomAccessModule() {
+    super();
+  }
+}
+@CustomLog(access=AccessLevel.PROTECTED) class LoggerCustomAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerCustomAccessProtected() {
+    super();
+  }
+}
+@CustomLog(access=AccessLevel.PACKAGE) class LoggerCustomAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerCustomAccessPackage() {
+    super();
+  }
+}
+@CustomLog(access=AccessLevel.PRIVATE) class LoggerCustomAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerCustomAccessPrivate() {
+    super();
+  }
+}
+@CustomLog(access=AccessLevel.NONE) class LoggerCustomAccessNone {
+  <clinit>() {
+  }
+  LoggerCustomAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerFloggerAccess.java b/test/transform/resource/after-ecj/LoggerFloggerAccess.java
new file mode 100644
index 00000000..ce470dfc
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerFloggerAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.flogger.Flogger;
+@Flogger(access=AccessLevel.PUBLIC) class LoggerFloggerAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+  <clinit>() {
+  }
+  LoggerFloggerAccessPublic() {
+    super();
+  }
+}
+@Flogger(access=AccessLevel.MODULE) class LoggerFloggerAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+  <clinit>() {
+  }
+  LoggerFloggerAccessModule() {
+    super();
+  }
+}
+@Flogger(access=AccessLevel.PROTECTED) class LoggerFloggerAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+  <clinit>() {
+  }
+  LoggerFloggerAccessProtected() {
+    super();
+  }
+}
+@Flogger(access=AccessLevel.PACKAGE) class LoggerFloggerAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+  <clinit>() {
+  }
+  LoggerFloggerAccessPackage() {
+    super();
+  }
+}
+@Flogger(access=AccessLevel.PRIVATE) class LoggerFloggerAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+  <clinit>() {
+  }
+  LoggerFloggerAccessPrivate() {
+    super();
+  }
+}
+@Flogger(access=AccessLevel.NONE) class LoggerFloggerAccessNone {
+  <clinit>() {
+  }
+  LoggerFloggerAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerJBossLogAccess.java b/test/transform/resource/after-ecj/LoggerJBossLogAccess.java
new file mode 100644
index 00000000..8d40f320
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerJBossLogAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.jbosslog.JBossLog;
+@JBossLog(access=AccessLevel.PUBLIC) class LoggerJBossLogAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerJBossLogAccessPublic() {
+    super();
+  }
+}
+@JBossLog(access=AccessLevel.MODULE) class LoggerJBossLogAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessModule.class);
+  <clinit>() {
+  }
+  LoggerJBossLogAccessModule() {
+    super();
+  }
+}
+@JBossLog(access=AccessLevel.PROTECTED) class LoggerJBossLogAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerJBossLogAccessProtected() {
+    super();
+  }
+}
+@JBossLog(access=AccessLevel.PACKAGE) class LoggerJBossLogAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerJBossLogAccessPackage() {
+    super();
+  }
+}
+@JBossLog(access=AccessLevel.PRIVATE) class LoggerJBossLogAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerJBossLogAccessPrivate() {
+    super();
+  }
+}
+@JBossLog(access=AccessLevel.NONE) class LoggerJBossLogAccessNone {
+  <clinit>() {
+  }
+  LoggerJBossLogAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerJulAccess.java b/test/transform/resource/after-ecj/LoggerJulAccess.java
new file mode 100644
index 00000000..66fd6f26
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerJulAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.java.Log;
+@Log(access=AccessLevel.PUBLIC) class LoggerJulAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPublic.class.getName());
+  <clinit>() {
+  }
+  LoggerJulAccessPublic() {
+    super();
+  }
+}
+@Log(access=AccessLevel.MODULE) class LoggerJulAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessModule.class.getName());
+  <clinit>() {
+  }
+  LoggerJulAccessModule() {
+    super();
+  }
+}
+@Log(access=AccessLevel.PROTECTED) class LoggerJulAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessProtected.class.getName());
+  <clinit>() {
+  }
+  LoggerJulAccessProtected() {
+    super();
+  }
+}
+@Log(access=AccessLevel.PACKAGE) class LoggerJulAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPackage.class.getName());
+  <clinit>() {
+  }
+  LoggerJulAccessPackage() {
+    super();
+  }
+}
+@Log(access=AccessLevel.PRIVATE) class LoggerJulAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPrivate.class.getName());
+  <clinit>() {
+  }
+  LoggerJulAccessPrivate() {
+    super();
+  }
+}
+@Log(access=AccessLevel.NONE) class LoggerJulAccessNone {
+  <clinit>() {
+  }
+  LoggerJulAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerLog4j2Access.java b/test/transform/resource/after-ecj/LoggerLog4j2Access.java
new file mode 100644
index 00000000..b979a99c
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerLog4j2Access.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.log4j.Log4j2;
+@Log4j2(access=AccessLevel.PUBLIC) class LoggerLog4j2AccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPublic.class);
+  <clinit>() {
+  }
+  LoggerLog4j2AccessPublic() {
+    super();
+  }
+}
+@Log4j2(access=AccessLevel.MODULE) class LoggerLog4j2AccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessModule.class);
+  <clinit>() {
+  }
+  LoggerLog4j2AccessModule() {
+    super();
+  }
+}
+@Log4j2(access=AccessLevel.PROTECTED) class LoggerLog4j2AccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessProtected.class);
+  <clinit>() {
+  }
+  LoggerLog4j2AccessProtected() {
+    super();
+  }
+}
+@Log4j2(access=AccessLevel.PACKAGE) class LoggerLog4j2AccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPackage.class);
+  <clinit>() {
+  }
+  LoggerLog4j2AccessPackage() {
+    super();
+  }
+}
+@Log4j2(access=AccessLevel.PRIVATE) class LoggerLog4j2AccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerLog4j2AccessPrivate() {
+    super();
+  }
+}
+@Log4j2(access=AccessLevel.NONE) class LoggerLog4j2AccessNone {
+  <clinit>() {
+  }
+  LoggerLog4j2AccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerLog4jAccess.java b/test/transform/resource/after-ecj/LoggerLog4jAccess.java
new file mode 100644
index 00000000..25f58013
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerLog4jAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.log4j.Log4j;
+@Log4j(access=AccessLevel.PUBLIC) class LoggerLog4jAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerLog4jAccessPublic() {
+    super();
+  }
+}
+@Log4j(access=AccessLevel.MODULE) class LoggerLog4jAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessModule.class);
+  <clinit>() {
+  }
+  LoggerLog4jAccessModule() {
+    super();
+  }
+}
+@Log4j(access=AccessLevel.PROTECTED) class LoggerLog4jAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerLog4jAccessProtected() {
+    super();
+  }
+}
+@Log4j(access=AccessLevel.PACKAGE) class LoggerLog4jAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerLog4jAccessPackage() {
+    super();
+  }
+}
+@Log4j(access=AccessLevel.PRIVATE) class LoggerLog4jAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerLog4jAccessPrivate() {
+    super();
+  }
+}
+@Log4j(access=AccessLevel.NONE) class LoggerLog4jAccessNone {
+  <clinit>() {
+  }
+  LoggerLog4jAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerSlf4jAccess.java b/test/transform/resource/after-ecj/LoggerSlf4jAccess.java
new file mode 100644
index 00000000..1445218a
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerSlf4jAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.slf4j.Slf4j;
+@Slf4j(access=AccessLevel.PUBLIC) class LoggerSlf4jAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerSlf4jAccessPublic() {
+    super();
+  }
+}
+@Slf4j(access=AccessLevel.MODULE) class LoggerSlf4jAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessModule.class);
+  <clinit>() {
+  }
+  LoggerSlf4jAccessModule() {
+    super();
+  }
+}
+@Slf4j(access=AccessLevel.PROTECTED) class LoggerSlf4jAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerSlf4jAccessProtected() {
+    super();
+  }
+}
+@Slf4j(access=AccessLevel.PACKAGE) class LoggerSlf4jAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerSlf4jAccessPackage() {
+    super();
+  }
+}
+@Slf4j(access=AccessLevel.PRIVATE) class LoggerSlf4jAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerSlf4jAccessPrivate() {
+    super();
+  }
+}
+@Slf4j(access=AccessLevel.NONE) class LoggerSlf4jAccessNone {
+  <clinit>() {
+  }
+  LoggerSlf4jAccessNone() {
+    super();
+  }
+}
diff --git a/test/transform/resource/after-ecj/LoggerXslf4jAccess.java b/test/transform/resource/after-ecj/LoggerXslf4jAccess.java
new file mode 100644
index 00000000..e87ebb0b
--- /dev/null
+++ b/test/transform/resource/after-ecj/LoggerXslf4jAccess.java
@@ -0,0 +1,49 @@
+import lombok.AccessLevel;
+import lombok.extern.slf4j.XSlf4j;
+@XSlf4j(access=AccessLevel.PUBLIC) class LoggerXslf4jAccessPublic {
+  public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPublic.class);
+  <clinit>() {
+  }
+  LoggerXslf4jAccessPublic() {
+    super();
+  }
+}
+@XSlf4j(access=AccessLevel.MODULE) class LoggerXslf4jAccessModule {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessModule.class);
+  <clinit>() {
+  }
+  LoggerXslf4jAccessModule() {
+    super();
+  }
+}
+@XSlf4j(access=AccessLevel.PROTECTED) class LoggerXslf4jAccessProtected {
+  protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessProtected.class);
+  <clinit>() {
+  }
+  LoggerXslf4jAccessProtected() {
+    super();
+  }
+}
+@XSlf4j(access=AccessLevel.PACKAGE) class LoggerXslf4jAccessPackage {
+  static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPackage.class);
+  <clinit>() {
+  }
+  LoggerXslf4jAccessPackage() {
+    super();
+  }
+}
+@XSlf4j(access=AccessLevel.PRIVATE) class LoggerXslf4jAccessPrivate {
+  private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPrivate.class);
+  <clinit>() {
+  }
+  LoggerXslf4jAccessPrivate() {
+    super();
+  }
+}
+@XSlf4j(access=AccessLevel.NONE) class LoggerXslf4jAccessNone {
+  <clinit>() {
+  }
+  LoggerXslf4jAccessNone() {
+    super();
+  }
+}

From 9a2e7cb4091e13807a24c1c5329ac91e4ad95351 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 19:04:26 -0400
Subject: [PATCH 07/16] Add after-delombok transforms for various loggers

---
 .../after-delombok/LoggerCommonsAccess.java   | 33 +++++++++++++++++++
 .../after-delombok/LoggerCustomAccess.java    | 33 +++++++++++++++++++
 .../after-delombok/LoggerFloggerAccess.java   | 33 +++++++++++++++++++
 .../after-delombok/LoggerJBossLogAccess.java  | 33 +++++++++++++++++++
 .../after-delombok/LoggerJulAccess.java       | 33 +++++++++++++++++++
 .../after-delombok/LoggerLog4j2Access.java    | 33 +++++++++++++++++++
 .../after-delombok/LoggerLog4jAccess.java     | 33 +++++++++++++++++++
 .../after-delombok/LoggerSlf4jAccess.java     | 33 +++++++++++++++++++
 .../after-delombok/LoggerXslf4jAccess.java    | 33 +++++++++++++++++++
 9 files changed, 297 insertions(+)
 create mode 100644 test/transform/resource/after-delombok/LoggerCommonsAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerCustomAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerFloggerAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerJBossLogAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerJulAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerLog4j2Access.java
 create mode 100644 test/transform/resource/after-delombok/LoggerLog4jAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerSlf4jAccess.java
 create mode 100644 test/transform/resource/after-delombok/LoggerXslf4jAccess.java

diff --git a/test/transform/resource/after-delombok/LoggerCommonsAccess.java b/test/transform/resource/after-delombok/LoggerCommonsAccess.java
new file mode 100644
index 00000000..5a4c648f
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerCommonsAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerCommonsAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPublic.class);
+
+}
+class LoggerCommonsAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessModule.class);
+
+}
+class LoggerCommonsAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessProtected.class);
+
+}
+class LoggerCommonsAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPackage.class);
+
+}
+class LoggerCommonsAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPrivate.class);
+
+}
+class LoggerCommonsAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerCustomAccess.java b/test/transform/resource/after-delombok/LoggerCustomAccess.java
new file mode 100644
index 00000000..f9c766f0
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerCustomAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerCustomAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPublic.class);
+
+}
+class LoggerCustomAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final MyLogger log = MyLoggerFactory.create(LoggerCustomAccessModule.class);
+
+}
+class LoggerCustomAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final MyLogger log = MyLoggerFactory.create(LoggerCustomAccessProtected.class);
+
+}
+class LoggerCustomAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPackage.class);
+
+}
+class LoggerCustomAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPrivate.class);
+
+}
+class LoggerCustomAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerFloggerAccess.java b/test/transform/resource/after-delombok/LoggerFloggerAccess.java
new file mode 100644
index 00000000..8da287c4
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerFloggerAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerFloggerAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+
+}
+class LoggerFloggerAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+
+}
+class LoggerFloggerAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+
+}
+class LoggerFloggerAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+
+}
+class LoggerFloggerAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
+
+}
+class LoggerFloggerAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerJBossLogAccess.java b/test/transform/resource/after-delombok/LoggerJBossLogAccess.java
new file mode 100644
index 00000000..bcb25fd4
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerJBossLogAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerJBossLogAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPublic.class);
+
+}
+class LoggerJBossLogAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessModule.class);
+
+}
+class LoggerJBossLogAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessProtected.class);
+
+}
+class LoggerJBossLogAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPackage.class);
+
+}
+class LoggerJBossLogAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPrivate.class);
+
+}
+class LoggerJBossLogAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerJulAccess.java b/test/transform/resource/after-delombok/LoggerJulAccess.java
new file mode 100644
index 00000000..37aa78b7
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerJulAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerJulAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPublic.class.getName());
+
+}
+class LoggerJulAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessModule.class.getName());
+
+}
+class LoggerJulAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessProtected.class.getName());
+
+}
+class LoggerJulAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPackage.class.getName());
+
+}
+class LoggerJulAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPrivate.class.getName());
+
+}
+class LoggerJulAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerLog4j2Access.java b/test/transform/resource/after-delombok/LoggerLog4j2Access.java
new file mode 100644
index 00000000..fc067a86
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerLog4j2Access.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerLog4j2AccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPublic.class);
+
+}
+class LoggerLog4j2AccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessModule.class);
+
+}
+class LoggerLog4j2AccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessProtected.class);
+
+}
+class LoggerLog4j2AccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPackage.class);
+
+}
+class LoggerLog4j2AccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPrivate.class);
+
+}
+class LoggerLog4j2AccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerLog4jAccess.java b/test/transform/resource/after-delombok/LoggerLog4jAccess.java
new file mode 100644
index 00000000..fd7939ce
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerLog4jAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerLog4jAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPublic.class);
+
+}
+class LoggerLog4jAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessModule.class);
+
+}
+class LoggerLog4jAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessProtected.class);
+
+}
+class LoggerLog4jAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPackage.class);
+
+}
+class LoggerLog4jAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPrivate.class);
+
+}
+class LoggerLog4jAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerSlf4jAccess.java b/test/transform/resource/after-delombok/LoggerSlf4jAccess.java
new file mode 100644
index 00000000..e43304a8
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerSlf4jAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerSlf4jAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPublic.class);
+
+}
+class LoggerSlf4jAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessModule.class);
+
+}
+class LoggerSlf4jAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessProtected.class);
+
+}
+class LoggerSlf4jAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPackage.class);
+
+}
+class LoggerSlf4jAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPrivate.class);
+
+}
+class LoggerSlf4jAccessNone {
+}
diff --git a/test/transform/resource/after-delombok/LoggerXslf4jAccess.java b/test/transform/resource/after-delombok/LoggerXslf4jAccess.java
new file mode 100644
index 00000000..47035f59
--- /dev/null
+++ b/test/transform/resource/after-delombok/LoggerXslf4jAccess.java
@@ -0,0 +1,33 @@
+import lombok.AccessLevel;
+class LoggerXslf4jAccessPublic {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	public static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPublic.class);
+
+}
+class LoggerXslf4jAccessModule {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessModule.class);
+
+}
+class LoggerXslf4jAccessProtected {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	protected static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessProtected.class);
+
+}
+class LoggerXslf4jAccessPackage {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPackage.class);
+
+}
+class LoggerXslf4jAccessPrivate {
+	@java.lang.SuppressWarnings("all")
+	@lombok.Generated
+	private static final org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPrivate.class);
+
+}
+class LoggerXslf4jAccessNone {
+}

From 121cfabac23c1cedf0870329764023acbd01bf45 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 19:11:09 -0400
Subject: [PATCH 08/16] fix: add custom logger classes to tests

---
 .../after-delombok/LoggerCustomAccess.java         |  8 ++++++++
 .../resource/after-ecj/LoggerCustomAccess.java     | 14 ++++++++++++++
 .../resource/before/LoggerCustomAccess.java        |  8 ++++++++
 3 files changed, 30 insertions(+)

diff --git a/test/transform/resource/after-delombok/LoggerCustomAccess.java b/test/transform/resource/after-delombok/LoggerCustomAccess.java
index f9c766f0..d3f3806d 100644
--- a/test/transform/resource/after-delombok/LoggerCustomAccess.java
+++ b/test/transform/resource/after-delombok/LoggerCustomAccess.java
@@ -31,3 +31,11 @@ class LoggerCustomAccessPrivate {
 }
 class LoggerCustomAccessNone {
 }
+class MyLoggerFactory {
+	static MyLogger create(Class<?> clazz) {
+		return null;
+	}
+}
+class MyLogger {
+}
+
diff --git a/test/transform/resource/after-ecj/LoggerCustomAccess.java b/test/transform/resource/after-ecj/LoggerCustomAccess.java
index 755e622a..e34e7b52 100644
--- a/test/transform/resource/after-ecj/LoggerCustomAccess.java
+++ b/test/transform/resource/after-ecj/LoggerCustomAccess.java
@@ -47,3 +47,17 @@ import lombok.CustomLog;
     super();
   }
 }
+class MyLoggerFactory {
+  MyLoggerFactory() {
+    super();
+  }
+  static MyLogger create(Class<?> clazz) {
+    return null;
+  }
+}
+class MyLogger {
+  MyLogger() {
+    super();
+  }
+}
+
diff --git a/test/transform/resource/before/LoggerCustomAccess.java b/test/transform/resource/before/LoggerCustomAccess.java
index 404fb9b6..c01735d2 100644
--- a/test/transform/resource/before/LoggerCustomAccess.java
+++ b/test/transform/resource/before/LoggerCustomAccess.java
@@ -24,3 +24,11 @@ class LoggerCustomAccessPrivate {
 @CustomLog(access=AccessLevel.NONE)
 class LoggerCustomAccessNone {
 }
+class MyLoggerFactory {
+	static MyLogger create(Class<?> clazz) {
+		return null;
+	}
+}
+class MyLogger {
+}
+

From 9152c3408f7f058e40db570b38fc5ccb46149ae8 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 19:35:28 -0400
Subject: [PATCH 09/16] Fix failing tests

---
 .../lombok/eclipse/handlers/HandleLog.java    |  6 +++++-
 src/core/lombok/javac/handlers/HandleLog.java |  5 ++++-
 .../after-ecj/LoggerCommonsAccess.java        | 19 +++++++++++--------
 .../after-ecj/LoggerCustomAccess.java         | 19 +++++++++++--------
 .../after-ecj/LoggerFloggerAccess.java        | 19 +++++++++++--------
 .../after-ecj/LoggerJBossLogAccess.java       | 19 +++++++++++--------
 .../resource/after-ecj/LoggerJulAccess.java   | 19 +++++++++++--------
 .../after-ecj/LoggerLog4j2Access.java         | 19 +++++++++++--------
 .../resource/after-ecj/LoggerLog4jAccess.java | 19 +++++++++++--------
 .../resource/after-ecj/LoggerSlf4jAccess.java | 19 +++++++++++--------
 .../after-ecj/LoggerXslf4jAccess.java         | 19 +++++++++++--------
 .../resource/before/LoggerCommonsAccess.java  | 12 ++++++------
 .../resource/before/LoggerCustomAccess.java   | 13 +++++++------
 .../resource/before/LoggerFloggerAccess.java  | 12 ++++++------
 .../resource/before/LoggerJbossLogAccess.java | 12 ++++++------
 .../resource/before/LoggerJulAccess.java      | 12 ++++++------
 .../resource/before/LoggerLog4j2Access.java   | 12 ++++++------
 .../resource/before/LoggerLog4jAccess.java    | 12 ++++++------
 .../resource/before/LoggerSlf4jAccess.java    | 12 ++++++------
 .../resource/before/LoggerXslf4jAccess.java   | 12 ++++++------
 20 files changed, 163 insertions(+), 128 deletions(-)

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index 8a2d1483..3f6044bd 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -100,6 +100,7 @@ public class HandleLog {
 			Expression loggerTopic = (Expression) annotation.getActualExpression("topic");
 			
 			if (valueGuess instanceof String && ((String) valueGuess).trim().isEmpty()) loggerTopic = null;
+			
 			if (framework.getDeclaration().getParametersWithTopic() == null && loggerTopic != null) {
 				annotationNode.addError(framework.getAnnotationAsString() + " does not allow a topic.");
 				loggerTopic = null;
@@ -109,6 +110,9 @@ public class HandleLog {
 				loggerTopic = new StringLiteral(new char[]{}, 0, 0, 0);
 			}
 			
+			if (access == AccessLevel.NONE)
+				break;
+			
 			ClassLiteralAccess loggingType = selfType(owner, source);
 			FieldDeclaration fieldDeclaration = createField(framework, access, source, loggingType, logFieldName.getName(), useStatic, loggerTopic);
 			fieldDeclaration.traverse(new SetGeneratedByVisitor(source), typeDecl.staticInitializerScope);
@@ -138,7 +142,7 @@ public class HandleLog {
 		switch (level) {
 			case PUBLIC: return Flags.PUBLIC; 
 			case PROTECTED: return Flags.PROTECTED;
-			case PRIVATE: return Flags.PUBLIC;
+			case PRIVATE: return Flags.PRIVATE;
 			default: return 0;
 		}
 	}
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 173d8f2a..92f65fc8 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -99,6 +99,9 @@ public class HandleLog {
 				loggerTopic = typeNode.getTreeMaker().Literal("");
 			}
 			
+			if (access == AccessLevel.NONE)
+				break;
+			
 			JCFieldAccess loggingType = selfType(typeNode);
 			createField(framework, access, typeNode, loggingType, annotationNode, logFieldName.getName(), useStatic, loggerTopic);
 			break;
@@ -118,7 +121,7 @@ public class HandleLog {
 		switch (level) {
 			case PUBLIC: return Flags.PUBLIC; 
 			case PROTECTED: return Flags.PROTECTED;
-			case PRIVATE: return Flags.PUBLIC;
+			case PRIVATE: return Flags.PRIVATE;
 			default: return 0;
 		}
 	}
diff --git a/test/transform/resource/after-ecj/LoggerCommonsAccess.java b/test/transform/resource/after-ecj/LoggerCommonsAccess.java
index b5e7e93c..308fa2a5 100644
--- a/test/transform/resource/after-ecj/LoggerCommonsAccess.java
+++ b/test/transform/resource/after-ecj/LoggerCommonsAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.apachecommons.CommonsLog;
-@CommonsLog(access=AccessLevel.PUBLIC) class LoggerCommonsAccessPublic {
+@CommonsLog(access = AccessLevel.PUBLIC) class LoggerCommonsAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPublic.class);
   <clinit>() {
   }
+
   LoggerCommonsAccessPublic() {
     super();
   }
 }
-@CommonsLog(access=AccessLevel.MODULE) class LoggerCommonsAccessModule {
+@CommonsLog(access = AccessLevel.MODULE) class LoggerCommonsAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessModule.class);
   <clinit>() {
   }
+
   LoggerCommonsAccessModule() {
     super();
   }
 }
-@CommonsLog(access=AccessLevel.PROTECTED) class LoggerCommonsAccessProtected {
+@CommonsLog(access = AccessLevel.PROTECTED) class LoggerCommonsAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessProtected.class);
   <clinit>() {
   }
+
   LoggerCommonsAccessProtected() {
     super();
   }
 }
-@CommonsLog(access=AccessLevel.PACKAGE) class LoggerCommonsAccessPackage {
+@CommonsLog(access = AccessLevel.PACKAGE) class LoggerCommonsAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPackage.class);
   <clinit>() {
   }
+
   LoggerCommonsAccessPackage() {
     super();
   }
 }
-@CommonsLog(access=AccessLevel.PRIVATE) class LoggerCommonsAccessPrivate {
+@CommonsLog(access = AccessLevel.PRIVATE) class LoggerCommonsAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.commons.logging.Log log = org.apache.commons.logging.LogFactory.getLog(LoggerCommonsAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerCommonsAccessPrivate() {
     super();
   }
 }
-@CommonsLog(access=AccessLevel.NONE) class LoggerCommonsAccessNone {
-  <clinit>() {
-  }
+@CommonsLog(access = AccessLevel.NONE) class LoggerCommonsAccessNone {
   LoggerCommonsAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerCustomAccess.java b/test/transform/resource/after-ecj/LoggerCustomAccess.java
index e34e7b52..82b72ef1 100644
--- a/test/transform/resource/after-ecj/LoggerCustomAccess.java
+++ b/test/transform/resource/after-ecj/LoggerCustomAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.CustomLog;
-@CustomLog(access=AccessLevel.PUBLIC) class LoggerCustomAccessPublic {
+@CustomLog(access = AccessLevel.PUBLIC) class LoggerCustomAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPublic.class);
   <clinit>() {
   }
+
   LoggerCustomAccessPublic() {
     super();
   }
 }
-@CustomLog(access=AccessLevel.MODULE) class LoggerCustomAccessModule {
+@CustomLog(access = AccessLevel.MODULE) class LoggerCustomAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessModule.class);
   <clinit>() {
   }
+
   LoggerCustomAccessModule() {
     super();
   }
 }
-@CustomLog(access=AccessLevel.PROTECTED) class LoggerCustomAccessProtected {
+@CustomLog(access = AccessLevel.PROTECTED) class LoggerCustomAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessProtected.class);
   <clinit>() {
   }
+
   LoggerCustomAccessProtected() {
     super();
   }
 }
-@CustomLog(access=AccessLevel.PACKAGE) class LoggerCustomAccessPackage {
+@CustomLog(access = AccessLevel.PACKAGE) class LoggerCustomAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPackage.class);
   <clinit>() {
   }
+
   LoggerCustomAccessPackage() {
     super();
   }
 }
-@CustomLog(access=AccessLevel.PRIVATE) class LoggerCustomAccessPrivate {
+@CustomLog(access = AccessLevel.PRIVATE) class LoggerCustomAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated MyLogger log = MyLoggerFactory.create(LoggerCustomAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerCustomAccessPrivate() {
     super();
   }
 }
-@CustomLog(access=AccessLevel.NONE) class LoggerCustomAccessNone {
-  <clinit>() {
-  }
+@CustomLog(access = AccessLevel.NONE) class LoggerCustomAccessNone {
   LoggerCustomAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerFloggerAccess.java b/test/transform/resource/after-ecj/LoggerFloggerAccess.java
index ce470dfc..125c479f 100644
--- a/test/transform/resource/after-ecj/LoggerFloggerAccess.java
+++ b/test/transform/resource/after-ecj/LoggerFloggerAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.flogger.Flogger;
-@Flogger(access=AccessLevel.PUBLIC) class LoggerFloggerAccessPublic {
+@Flogger(access = AccessLevel.PUBLIC) class LoggerFloggerAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
   <clinit>() {
   }
+
   LoggerFloggerAccessPublic() {
     super();
   }
 }
-@Flogger(access=AccessLevel.MODULE) class LoggerFloggerAccessModule {
+@Flogger(access = AccessLevel.MODULE) class LoggerFloggerAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
   <clinit>() {
   }
+
   LoggerFloggerAccessModule() {
     super();
   }
 }
-@Flogger(access=AccessLevel.PROTECTED) class LoggerFloggerAccessProtected {
+@Flogger(access = AccessLevel.PROTECTED) class LoggerFloggerAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
   <clinit>() {
   }
+
   LoggerFloggerAccessProtected() {
     super();
   }
 }
-@Flogger(access=AccessLevel.PACKAGE) class LoggerFloggerAccessPackage {
+@Flogger(access = AccessLevel.PACKAGE) class LoggerFloggerAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
   <clinit>() {
   }
+
   LoggerFloggerAccessPackage() {
     super();
   }
 }
-@Flogger(access=AccessLevel.PRIVATE) class LoggerFloggerAccessPrivate {
+@Flogger(access = AccessLevel.PRIVATE) class LoggerFloggerAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated com.google.common.flogger.FluentLogger log = com.google.common.flogger.FluentLogger.forEnclosingClass();
   <clinit>() {
   }
+
   LoggerFloggerAccessPrivate() {
     super();
   }
 }
-@Flogger(access=AccessLevel.NONE) class LoggerFloggerAccessNone {
-  <clinit>() {
-  }
+@Flogger(access = AccessLevel.NONE) class LoggerFloggerAccessNone {
   LoggerFloggerAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerJBossLogAccess.java b/test/transform/resource/after-ecj/LoggerJBossLogAccess.java
index 8d40f320..5a156783 100644
--- a/test/transform/resource/after-ecj/LoggerJBossLogAccess.java
+++ b/test/transform/resource/after-ecj/LoggerJBossLogAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.jbosslog.JBossLog;
-@JBossLog(access=AccessLevel.PUBLIC) class LoggerJBossLogAccessPublic {
+@JBossLog(access = AccessLevel.PUBLIC) class LoggerJBossLogAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPublic.class);
   <clinit>() {
   }
+
   LoggerJBossLogAccessPublic() {
     super();
   }
 }
-@JBossLog(access=AccessLevel.MODULE) class LoggerJBossLogAccessModule {
+@JBossLog(access = AccessLevel.MODULE) class LoggerJBossLogAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessModule.class);
   <clinit>() {
   }
+
   LoggerJBossLogAccessModule() {
     super();
   }
 }
-@JBossLog(access=AccessLevel.PROTECTED) class LoggerJBossLogAccessProtected {
+@JBossLog(access = AccessLevel.PROTECTED) class LoggerJBossLogAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessProtected.class);
   <clinit>() {
   }
+
   LoggerJBossLogAccessProtected() {
     super();
   }
 }
-@JBossLog(access=AccessLevel.PACKAGE) class LoggerJBossLogAccessPackage {
+@JBossLog(access = AccessLevel.PACKAGE) class LoggerJBossLogAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPackage.class);
   <clinit>() {
   }
+
   LoggerJBossLogAccessPackage() {
     super();
   }
 }
-@JBossLog(access=AccessLevel.PRIVATE) class LoggerJBossLogAccessPrivate {
+@JBossLog(access = AccessLevel.PRIVATE) class LoggerJBossLogAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.jboss.logging.Logger log = org.jboss.logging.Logger.getLogger(LoggerJBossLogAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerJBossLogAccessPrivate() {
     super();
   }
 }
-@JBossLog(access=AccessLevel.NONE) class LoggerJBossLogAccessNone {
-  <clinit>() {
-  }
+@JBossLog(access = AccessLevel.NONE) class LoggerJBossLogAccessNone {
   LoggerJBossLogAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerJulAccess.java b/test/transform/resource/after-ecj/LoggerJulAccess.java
index 66fd6f26..6f0210f6 100644
--- a/test/transform/resource/after-ecj/LoggerJulAccess.java
+++ b/test/transform/resource/after-ecj/LoggerJulAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.java.Log;
-@Log(access=AccessLevel.PUBLIC) class LoggerJulAccessPublic {
+@Log(access = AccessLevel.PUBLIC) class LoggerJulAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPublic.class.getName());
   <clinit>() {
   }
+
   LoggerJulAccessPublic() {
     super();
   }
 }
-@Log(access=AccessLevel.MODULE) class LoggerJulAccessModule {
+@Log(access = AccessLevel.MODULE) class LoggerJulAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessModule.class.getName());
   <clinit>() {
   }
+
   LoggerJulAccessModule() {
     super();
   }
 }
-@Log(access=AccessLevel.PROTECTED) class LoggerJulAccessProtected {
+@Log(access = AccessLevel.PROTECTED) class LoggerJulAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessProtected.class.getName());
   <clinit>() {
   }
+
   LoggerJulAccessProtected() {
     super();
   }
 }
-@Log(access=AccessLevel.PACKAGE) class LoggerJulAccessPackage {
+@Log(access = AccessLevel.PACKAGE) class LoggerJulAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPackage.class.getName());
   <clinit>() {
   }
+
   LoggerJulAccessPackage() {
     super();
   }
 }
-@Log(access=AccessLevel.PRIVATE) class LoggerJulAccessPrivate {
+@Log(access = AccessLevel.PRIVATE) class LoggerJulAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated java.util.logging.Logger log = java.util.logging.Logger.getLogger(LoggerJulAccessPrivate.class.getName());
   <clinit>() {
   }
+
   LoggerJulAccessPrivate() {
     super();
   }
 }
-@Log(access=AccessLevel.NONE) class LoggerJulAccessNone {
-  <clinit>() {
-  }
+@Log(access = AccessLevel.NONE) class LoggerJulAccessNone {
   LoggerJulAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerLog4j2Access.java b/test/transform/resource/after-ecj/LoggerLog4j2Access.java
index b979a99c..0ce19d8d 100644
--- a/test/transform/resource/after-ecj/LoggerLog4j2Access.java
+++ b/test/transform/resource/after-ecj/LoggerLog4j2Access.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.log4j.Log4j2;
-@Log4j2(access=AccessLevel.PUBLIC) class LoggerLog4j2AccessPublic {
+@Log4j2(access = AccessLevel.PUBLIC) class LoggerLog4j2AccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPublic.class);
   <clinit>() {
   }
+
   LoggerLog4j2AccessPublic() {
     super();
   }
 }
-@Log4j2(access=AccessLevel.MODULE) class LoggerLog4j2AccessModule {
+@Log4j2(access = AccessLevel.MODULE) class LoggerLog4j2AccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessModule.class);
   <clinit>() {
   }
+
   LoggerLog4j2AccessModule() {
     super();
   }
 }
-@Log4j2(access=AccessLevel.PROTECTED) class LoggerLog4j2AccessProtected {
+@Log4j2(access = AccessLevel.PROTECTED) class LoggerLog4j2AccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessProtected.class);
   <clinit>() {
   }
+
   LoggerLog4j2AccessProtected() {
     super();
   }
 }
-@Log4j2(access=AccessLevel.PACKAGE) class LoggerLog4j2AccessPackage {
+@Log4j2(access = AccessLevel.PACKAGE) class LoggerLog4j2AccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPackage.class);
   <clinit>() {
   }
+
   LoggerLog4j2AccessPackage() {
     super();
   }
 }
-@Log4j2(access=AccessLevel.PRIVATE) class LoggerLog4j2AccessPrivate {
+@Log4j2(access = AccessLevel.PRIVATE) class LoggerLog4j2AccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LoggerLog4j2AccessPrivate.class);
   <clinit>() {
   }
+
   LoggerLog4j2AccessPrivate() {
     super();
   }
 }
-@Log4j2(access=AccessLevel.NONE) class LoggerLog4j2AccessNone {
-  <clinit>() {
-  }
+@Log4j2(access = AccessLevel.NONE) class LoggerLog4j2AccessNone {
   LoggerLog4j2AccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerLog4jAccess.java b/test/transform/resource/after-ecj/LoggerLog4jAccess.java
index 25f58013..fb82d92b 100644
--- a/test/transform/resource/after-ecj/LoggerLog4jAccess.java
+++ b/test/transform/resource/after-ecj/LoggerLog4jAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.log4j.Log4j;
-@Log4j(access=AccessLevel.PUBLIC) class LoggerLog4jAccessPublic {
+@Log4j(access = AccessLevel.PUBLIC) class LoggerLog4jAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPublic.class);
   <clinit>() {
   }
+
   LoggerLog4jAccessPublic() {
     super();
   }
 }
-@Log4j(access=AccessLevel.MODULE) class LoggerLog4jAccessModule {
+@Log4j(access = AccessLevel.MODULE) class LoggerLog4jAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessModule.class);
   <clinit>() {
   }
+
   LoggerLog4jAccessModule() {
     super();
   }
 }
-@Log4j(access=AccessLevel.PROTECTED) class LoggerLog4jAccessProtected {
+@Log4j(access = AccessLevel.PROTECTED) class LoggerLog4jAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessProtected.class);
   <clinit>() {
   }
+
   LoggerLog4jAccessProtected() {
     super();
   }
 }
-@Log4j(access=AccessLevel.PACKAGE) class LoggerLog4jAccessPackage {
+@Log4j(access = AccessLevel.PACKAGE) class LoggerLog4jAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPackage.class);
   <clinit>() {
   }
+
   LoggerLog4jAccessPackage() {
     super();
   }
 }
-@Log4j(access=AccessLevel.PRIVATE) class LoggerLog4jAccessPrivate {
+@Log4j(access = AccessLevel.PRIVATE) class LoggerLog4jAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LoggerLog4jAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerLog4jAccessPrivate() {
     super();
   }
 }
-@Log4j(access=AccessLevel.NONE) class LoggerLog4jAccessNone {
-  <clinit>() {
-  }
+@Log4j(access = AccessLevel.NONE) class LoggerLog4jAccessNone {
   LoggerLog4jAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerSlf4jAccess.java b/test/transform/resource/after-ecj/LoggerSlf4jAccess.java
index 1445218a..90fad6f1 100644
--- a/test/transform/resource/after-ecj/LoggerSlf4jAccess.java
+++ b/test/transform/resource/after-ecj/LoggerSlf4jAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.slf4j.Slf4j;
-@Slf4j(access=AccessLevel.PUBLIC) class LoggerSlf4jAccessPublic {
+@Slf4j(access = AccessLevel.PUBLIC) class LoggerSlf4jAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPublic.class);
   <clinit>() {
   }
+
   LoggerSlf4jAccessPublic() {
     super();
   }
 }
-@Slf4j(access=AccessLevel.MODULE) class LoggerSlf4jAccessModule {
+@Slf4j(access = AccessLevel.MODULE) class LoggerSlf4jAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessModule.class);
   <clinit>() {
   }
+
   LoggerSlf4jAccessModule() {
     super();
   }
 }
-@Slf4j(access=AccessLevel.PROTECTED) class LoggerSlf4jAccessProtected {
+@Slf4j(access = AccessLevel.PROTECTED) class LoggerSlf4jAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessProtected.class);
   <clinit>() {
   }
+
   LoggerSlf4jAccessProtected() {
     super();
   }
 }
-@Slf4j(access=AccessLevel.PACKAGE) class LoggerSlf4jAccessPackage {
+@Slf4j(access = AccessLevel.PACKAGE) class LoggerSlf4jAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPackage.class);
   <clinit>() {
   }
+
   LoggerSlf4jAccessPackage() {
     super();
   }
 }
-@Slf4j(access=AccessLevel.PRIVATE) class LoggerSlf4jAccessPrivate {
+@Slf4j(access = AccessLevel.PRIVATE) class LoggerSlf4jAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LoggerSlf4jAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerSlf4jAccessPrivate() {
     super();
   }
 }
-@Slf4j(access=AccessLevel.NONE) class LoggerSlf4jAccessNone {
-  <clinit>() {
-  }
+@Slf4j(access = AccessLevel.NONE) class LoggerSlf4jAccessNone {
   LoggerSlf4jAccessNone() {
     super();
   }
diff --git a/test/transform/resource/after-ecj/LoggerXslf4jAccess.java b/test/transform/resource/after-ecj/LoggerXslf4jAccess.java
index e87ebb0b..b64f50c5 100644
--- a/test/transform/resource/after-ecj/LoggerXslf4jAccess.java
+++ b/test/transform/resource/after-ecj/LoggerXslf4jAccess.java
@@ -1,48 +1,51 @@
 import lombok.AccessLevel;
 import lombok.extern.slf4j.XSlf4j;
-@XSlf4j(access=AccessLevel.PUBLIC) class LoggerXslf4jAccessPublic {
+@XSlf4j(access = AccessLevel.PUBLIC) class LoggerXslf4jAccessPublic {
   public static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPublic.class);
   <clinit>() {
   }
+
   LoggerXslf4jAccessPublic() {
     super();
   }
 }
-@XSlf4j(access=AccessLevel.MODULE) class LoggerXslf4jAccessModule {
+@XSlf4j(access = AccessLevel.MODULE) class LoggerXslf4jAccessModule {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessModule.class);
   <clinit>() {
   }
+
   LoggerXslf4jAccessModule() {
     super();
   }
 }
-@XSlf4j(access=AccessLevel.PROTECTED) class LoggerXslf4jAccessProtected {
+@XSlf4j(access = AccessLevel.PROTECTED) class LoggerXslf4jAccessProtected {
   protected static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessProtected.class);
   <clinit>() {
   }
+
   LoggerXslf4jAccessProtected() {
     super();
   }
 }
-@XSlf4j(access=AccessLevel.PACKAGE) class LoggerXslf4jAccessPackage {
+@XSlf4j(access = AccessLevel.PACKAGE) class LoggerXslf4jAccessPackage {
   static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPackage.class);
   <clinit>() {
   }
+
   LoggerXslf4jAccessPackage() {
     super();
   }
 }
-@XSlf4j(access=AccessLevel.PRIVATE) class LoggerXslf4jAccessPrivate {
+@XSlf4j(access = AccessLevel.PRIVATE) class LoggerXslf4jAccessPrivate {
   private static final @java.lang.SuppressWarnings("all") @lombok.Generated org.slf4j.ext.XLogger log = org.slf4j.ext.XLoggerFactory.getXLogger(LoggerXslf4jAccessPrivate.class);
   <clinit>() {
   }
+
   LoggerXslf4jAccessPrivate() {
     super();
   }
 }
-@XSlf4j(access=AccessLevel.NONE) class LoggerXslf4jAccessNone {
-  <clinit>() {
-  }
+@XSlf4j(access = AccessLevel.NONE) class LoggerXslf4jAccessNone {
   LoggerXslf4jAccessNone() {
     super();
   }
diff --git a/test/transform/resource/before/LoggerCommonsAccess.java b/test/transform/resource/before/LoggerCommonsAccess.java
index 91c2930a..7b8ad198 100644
--- a/test/transform/resource/before/LoggerCommonsAccess.java
+++ b/test/transform/resource/before/LoggerCommonsAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.apachecommons.CommonsLog;
 
-@CommonsLog(access=AccessLevel.PUBLIC)
+@CommonsLog(access = AccessLevel.PUBLIC)
 class LoggerCommonsAccessPublic {
 }
 
-@CommonsLog(access=AccessLevel.MODULE)
+@CommonsLog(access = AccessLevel.MODULE)
 class LoggerCommonsAccessModule {
 }
 
-@CommonsLog(access=AccessLevel.PROTECTED)
+@CommonsLog(access = AccessLevel.PROTECTED)
 class LoggerCommonsAccessProtected {
 }
 
-@CommonsLog(access=AccessLevel.PACKAGE)
+@CommonsLog(access = AccessLevel.PACKAGE)
 class LoggerCommonsAccessPackage {
 }
 
-@CommonsLog(access=AccessLevel.PRIVATE)
+@CommonsLog(access = AccessLevel.PRIVATE)
 class LoggerCommonsAccessPrivate {
 }
 
-@CommonsLog(access=AccessLevel.NONE)
+@CommonsLog(access = AccessLevel.NONE)
 class LoggerCommonsAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerCustomAccess.java b/test/transform/resource/before/LoggerCustomAccess.java
index c01735d2..3602e917 100644
--- a/test/transform/resource/before/LoggerCustomAccess.java
+++ b/test/transform/resource/before/LoggerCustomAccess.java
@@ -1,27 +1,28 @@
+//CONF: lombok.log.custom.declaration = MyLogger MyLoggerFactory.create(TYPE)
 import lombok.AccessLevel;
 import lombok.CustomLog;
 
-@CustomLog(access=AccessLevel.PUBLIC)
+@CustomLog(access = AccessLevel.PUBLIC)
 class LoggerCustomAccessPublic {
 }
 
-@CustomLog(access=AccessLevel.MODULE)
+@CustomLog(access = AccessLevel.MODULE)
 class LoggerCustomAccessModule {
 }
 
-@CustomLog(access=AccessLevel.PROTECTED)
+@CustomLog(access = AccessLevel.PROTECTED)
 class LoggerCustomAccessProtected {
 }
 
-@CustomLog(access=AccessLevel.PACKAGE)
+@CustomLog(access = AccessLevel.PACKAGE)
 class LoggerCustomAccessPackage {
 }
 
-@CustomLog(access=AccessLevel.PRIVATE)
+@CustomLog(access = AccessLevel.PRIVATE)
 class LoggerCustomAccessPrivate {
 }
 
-@CustomLog(access=AccessLevel.NONE)
+@CustomLog(access = AccessLevel.NONE)
 class LoggerCustomAccessNone {
 }
 class MyLoggerFactory {
diff --git a/test/transform/resource/before/LoggerFloggerAccess.java b/test/transform/resource/before/LoggerFloggerAccess.java
index 9673ebe6..65873a73 100644
--- a/test/transform/resource/before/LoggerFloggerAccess.java
+++ b/test/transform/resource/before/LoggerFloggerAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.flogger.Flogger;
 
-@Flogger(access=AccessLevel.PUBLIC)
+@Flogger(access = AccessLevel.PUBLIC)
 class LoggerFloggerAccessPublic {
 }
 
-@Flogger(access=AccessLevel.MODULE)
+@Flogger(access = AccessLevel.MODULE)
 class LoggerFloggerAccessModule {
 }
 
-@Flogger(access=AccessLevel.PROTECTED)
+@Flogger(access = AccessLevel.PROTECTED)
 class LoggerFloggerAccessProtected {
 }
 
-@Flogger(access=AccessLevel.PACKAGE)
+@Flogger(access = AccessLevel.PACKAGE)
 class LoggerFloggerAccessPackage {
 }
 
-@Flogger(access=AccessLevel.PRIVATE)
+@Flogger(access = AccessLevel.PRIVATE)
 class LoggerFloggerAccessPrivate {
 }
 
-@Flogger(access=AccessLevel.NONE)
+@Flogger(access = AccessLevel.NONE)
 class LoggerFloggerAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerJbossLogAccess.java b/test/transform/resource/before/LoggerJbossLogAccess.java
index ac79e222..6174c794 100644
--- a/test/transform/resource/before/LoggerJbossLogAccess.java
+++ b/test/transform/resource/before/LoggerJbossLogAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.jbosslog.JBossLog;
 
-@JBossLog(access=AccessLevel.PUBLIC)
+@JBossLog(access = AccessLevel.PUBLIC)
 class LoggerJBossLogAccessPublic {
 }
 
-@JBossLog(access=AccessLevel.MODULE)
+@JBossLog(access = AccessLevel.MODULE)
 class LoggerJBossLogAccessModule {
 }
 
-@JBossLog(access=AccessLevel.PROTECTED)
+@JBossLog(access = AccessLevel.PROTECTED)
 class LoggerJBossLogAccessProtected {
 }
 
-@JBossLog(access=AccessLevel.PACKAGE)
+@JBossLog(access = AccessLevel.PACKAGE)
 class LoggerJBossLogAccessPackage {
 }
 
-@JBossLog(access=AccessLevel.PRIVATE)
+@JBossLog(access = AccessLevel.PRIVATE)
 class LoggerJBossLogAccessPrivate {
 }
 
-@JBossLog(access=AccessLevel.NONE)
+@JBossLog(access = AccessLevel.NONE)
 class LoggerJBossLogAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerJulAccess.java b/test/transform/resource/before/LoggerJulAccess.java
index a6200ca5..144b8c4c 100644
--- a/test/transform/resource/before/LoggerJulAccess.java
+++ b/test/transform/resource/before/LoggerJulAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.java.Log;
 
-@Log(access=AccessLevel.PUBLIC)
+@Log(access = AccessLevel.PUBLIC)
 class LoggerJulAccessPublic {
 }
 
-@Log(access=AccessLevel.MODULE)
+@Log(access = AccessLevel.MODULE)
 class LoggerJulAccessModule {
 }
 
-@Log(access=AccessLevel.PROTECTED)
+@Log(access = AccessLevel.PROTECTED)
 class LoggerJulAccessProtected {
 }
 
-@Log(access=AccessLevel.PACKAGE)
+@Log(access = AccessLevel.PACKAGE)
 class LoggerJulAccessPackage {
 }
 
-@Log(access=AccessLevel.PRIVATE)
+@Log(access = AccessLevel.PRIVATE)
 class LoggerJulAccessPrivate {
 }
 
-@Log(access=AccessLevel.NONE)
+@Log(access = AccessLevel.NONE)
 class LoggerJulAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerLog4j2Access.java b/test/transform/resource/before/LoggerLog4j2Access.java
index c3fa3232..44bbf71e 100644
--- a/test/transform/resource/before/LoggerLog4j2Access.java
+++ b/test/transform/resource/before/LoggerLog4j2Access.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.log4j.Log4j2;
 
-@Log4j2(access=AccessLevel.PUBLIC)
+@Log4j2(access = AccessLevel.PUBLIC)
 class LoggerLog4j2AccessPublic {
 }
 
-@Log4j2(access=AccessLevel.MODULE)
+@Log4j2(access = AccessLevel.MODULE)
 class LoggerLog4j2AccessModule {
 }
 
-@Log4j2(access=AccessLevel.PROTECTED)
+@Log4j2(access = AccessLevel.PROTECTED)
 class LoggerLog4j2AccessProtected {
 }
 
-@Log4j2(access=AccessLevel.PACKAGE)
+@Log4j2(access = AccessLevel.PACKAGE)
 class LoggerLog4j2AccessPackage {
 }
 
-@Log4j2(access=AccessLevel.PRIVATE)
+@Log4j2(access = AccessLevel.PRIVATE)
 class LoggerLog4j2AccessPrivate {
 }
 
-@Log4j2(access=AccessLevel.NONE)
+@Log4j2(access = AccessLevel.NONE)
 class LoggerLog4j2AccessNone {
 }
diff --git a/test/transform/resource/before/LoggerLog4jAccess.java b/test/transform/resource/before/LoggerLog4jAccess.java
index a1410a0b..78e37454 100644
--- a/test/transform/resource/before/LoggerLog4jAccess.java
+++ b/test/transform/resource/before/LoggerLog4jAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.log4j.Log4j;
 
-@Log4j(access=AccessLevel.PUBLIC)
+@Log4j(access = AccessLevel.PUBLIC)
 class LoggerLog4jAccessPublic {
 }
 
-@Log4j(access=AccessLevel.MODULE)
+@Log4j(access = AccessLevel.MODULE)
 class LoggerLog4jAccessModule {
 }
 
-@Log4j(access=AccessLevel.PROTECTED)
+@Log4j(access = AccessLevel.PROTECTED)
 class LoggerLog4jAccessProtected {
 }
 
-@Log4j(access=AccessLevel.PACKAGE)
+@Log4j(access = AccessLevel.PACKAGE)
 class LoggerLog4jAccessPackage {
 }
 
-@Log4j(access=AccessLevel.PRIVATE)
+@Log4j(access = AccessLevel.PRIVATE)
 class LoggerLog4jAccessPrivate {
 }
 
-@Log4j(access=AccessLevel.NONE)
+@Log4j(access = AccessLevel.NONE)
 class LoggerLog4jAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerSlf4jAccess.java b/test/transform/resource/before/LoggerSlf4jAccess.java
index 65a14c75..fadac141 100644
--- a/test/transform/resource/before/LoggerSlf4jAccess.java
+++ b/test/transform/resource/before/LoggerSlf4jAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.slf4j.Slf4j;
 
-@Slf4j(access=AccessLevel.PUBLIC)
+@Slf4j(access = AccessLevel.PUBLIC)
 class LoggerSlf4jAccessPublic {
 }
 
-@Slf4j(access=AccessLevel.MODULE)
+@Slf4j(access = AccessLevel.MODULE)
 class LoggerSlf4jAccessModule {
 }
 
-@Slf4j(access=AccessLevel.PROTECTED)
+@Slf4j(access = AccessLevel.PROTECTED)
 class LoggerSlf4jAccessProtected {
 }
 
-@Slf4j(access=AccessLevel.PACKAGE)
+@Slf4j(access = AccessLevel.PACKAGE)
 class LoggerSlf4jAccessPackage {
 }
 
-@Slf4j(access=AccessLevel.PRIVATE)
+@Slf4j(access = AccessLevel.PRIVATE)
 class LoggerSlf4jAccessPrivate {
 }
 
-@Slf4j(access=AccessLevel.NONE)
+@Slf4j(access = AccessLevel.NONE)
 class LoggerSlf4jAccessNone {
 }
diff --git a/test/transform/resource/before/LoggerXslf4jAccess.java b/test/transform/resource/before/LoggerXslf4jAccess.java
index 80d453c7..4707c301 100644
--- a/test/transform/resource/before/LoggerXslf4jAccess.java
+++ b/test/transform/resource/before/LoggerXslf4jAccess.java
@@ -1,26 +1,26 @@
 import lombok.AccessLevel;
 import lombok.extern.slf4j.XSlf4j;
 
-@XSlf4j(access=AccessLevel.PUBLIC)
+@XSlf4j(access = AccessLevel.PUBLIC)
 class LoggerXslf4jAccessPublic {
 }
 
-@XSlf4j(access=AccessLevel.MODULE)
+@XSlf4j(access = AccessLevel.MODULE)
 class LoggerXslf4jAccessModule {
 }
 
-@XSlf4j(access=AccessLevel.PROTECTED)
+@XSlf4j(access = AccessLevel.PROTECTED)
 class LoggerXslf4jAccessProtected {
 }
 
-@XSlf4j(access=AccessLevel.PACKAGE)
+@XSlf4j(access = AccessLevel.PACKAGE)
 class LoggerXslf4jAccessPackage {
 }
 
-@XSlf4j(access=AccessLevel.PRIVATE)
+@XSlf4j(access = AccessLevel.PRIVATE)
 class LoggerXslf4jAccessPrivate {
 }
 
-@XSlf4j(access=AccessLevel.NONE)
+@XSlf4j(access = AccessLevel.NONE)
 class LoggerXslf4jAccessNone {
 }

From f63f40aa48eee97d9bb99416cfe252a104420e29 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 19:41:16 -0400
Subject: [PATCH 10/16] Add myself to AUTHORS

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index d83703de..3226cee6 100755
--- a/AUTHORS
+++ b/AUTHORS
@@ -26,6 +26,7 @@ John Paul Taylor II <johnpaultaylorii@gmail.com>
 Karthik kathari <44122128+varkart@users.noreply.github.com>
 Kevin Chirls <kchirls@users.noreply.github.com>
 Liu DongMiao <liudongmiao@gmail.com>
+Liam Pace <liam.hollum.pace@gmail.com>
 Luan Nico <luannico27@gmail.com>
 Maarten Mulders <mthmulders@users.noreply.github.com>
 Manu Sridharan <msridhar@gmail.com>

From c1f7f660c596ed65997974b70b0eecb0675c43f1 Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Mon, 18 Aug 2025 20:54:17 -0400
Subject: [PATCH 11/16] Update copyright in logger files

---
 src/core/lombok/eclipse/handlers/HandleLog.java      | 2 +-
 src/core/lombok/extern/apachecommons/CommonsLog.java | 2 +-
 src/core/lombok/extern/flogger/Flogger.java          | 2 +-
 src/core/lombok/extern/java/Log.java                 | 2 +-
 src/core/lombok/extern/jbosslog/JBossLog.java        | 2 +-
 src/core/lombok/extern/log4j/Log4j.java              | 2 +-
 src/core/lombok/extern/log4j/Log4j2.java             | 2 +-
 src/core/lombok/extern/slf4j/Slf4j.java              | 2 +-
 src/core/lombok/extern/slf4j/XSlf4j.java             | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index 3f6044bd..46f7c73e 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2024 The Project Lombok Authors.
+ * Copyright (C) 2010-2025 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
diff --git a/src/core/lombok/extern/apachecommons/CommonsLog.java b/src/core/lombok/extern/apachecommons/CommonsLog.java
index 1a5d18dc..221ed403 100644
--- a/src/core/lombok/extern/apachecommons/CommonsLog.java
+++ b/src/core/lombok/extern/apachecommons/CommonsLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2017 The Project Lombok Authors.
+ * Copyright (C) 2010-2025 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
diff --git a/src/core/lombok/extern/flogger/Flogger.java b/src/core/lombok/extern/flogger/Flogger.java
index d6e4786f..22782a30 100644
--- a/src/core/lombok/extern/flogger/Flogger.java
+++ b/src/core/lombok/extern/flogger/Flogger.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 The Project Lombok Authors.
+ * Copyright (C) 2018-2025 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
diff --git a/src/core/lombok/extern/java/Log.java b/src/core/lombok/extern/java/Log.java
index 7478c64e..e74afdf3 100644
--- a/src/core/lombok/extern/java/Log.java
+++ b/src/core/lombok/extern/java/Log.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2017 The Project Lombok Authors.
+ * Copyright (C) 2010-2025 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
diff --git a/src/core/lombok/extern/jbosslog/JBossLog.java b/src/core/lombok/extern/jbosslog/JBossLog.java
index de6b76d2..85d5ebf3 100644
--- a/src/core/lombok/extern/jbosslog/JBossLog.java
+++ b/src/core/lombok/extern/jbosslog/JBossLog.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2016-2017 The Project Lombok Authors.
+ * Copyright (C) 2016-2025 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
diff --git a/src/core/lombok/extern/log4j/Log4j.java b/src/core/lombok/extern/log4j/Log4j.java
index 6dd809c5..ecdf0b3d 100644
--- a/src/core/lombok/extern/log4j/Log4j.java
+++ b/src/core/lombok/extern/log4j/Log4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2017 The Project Lombok Authors.
+ * Copyright (C) 2010-2025 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
diff --git a/src/core/lombok/extern/log4j/Log4j2.java b/src/core/lombok/extern/log4j/Log4j2.java
index 741e408c..398b27db 100644
--- a/src/core/lombok/extern/log4j/Log4j2.java
+++ b/src/core/lombok/extern/log4j/Log4j2.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2017 The Project Lombok Authors.
+ * Copyright (C) 2013-2025 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
diff --git a/src/core/lombok/extern/slf4j/Slf4j.java b/src/core/lombok/extern/slf4j/Slf4j.java
index e4747b99..af71b6a3 100644
--- a/src/core/lombok/extern/slf4j/Slf4j.java
+++ b/src/core/lombok/extern/slf4j/Slf4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010-2017 The Project Lombok Authors.
+ * Copyright (C) 2010-2025 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
diff --git a/src/core/lombok/extern/slf4j/XSlf4j.java b/src/core/lombok/extern/slf4j/XSlf4j.java
index 43ae82bc..11d7693a 100644
--- a/src/core/lombok/extern/slf4j/XSlf4j.java
+++ b/src/core/lombok/extern/slf4j/XSlf4j.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012-2017 The Project Lombok Authors.
+ * Copyright (C) 2012-2025 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

From 492011df4fa72dfa9bb2a5cef38199fb292253be Mon Sep 17 00:00:00 2001
From: Liam Pace <146035497+liampace@users.noreply.github.com>
Date: Wed, 20 Aug 2025 12:34:58 -0400
Subject: [PATCH 12/16] Refactored to use Javac/Eclipse utility function

---
 src/core/lombok/eclipse/handlers/HandleLog.java | 13 +------------
 src/core/lombok/javac/handlers/HandleLog.java   | 10 +---------
 2 files changed, 2 insertions(+), 21 deletions(-)

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index 46f7c73e..85b1b68a 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -39,8 +39,6 @@ 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 com.sun.tools.javac.code.Flags;
-
 import lombok.AccessLevel;
 import lombok.ConfigurationKeys;
 import lombok.core.AnnotationValues;
@@ -138,15 +136,6 @@ public class HandleLog {
 		return result;
 	}
 	
-	private static int toFlags(AccessLevel level) {
-		switch (level) {
-			case PUBLIC: return Flags.PUBLIC; 
-			case PROTECTED: return Flags.PROTECTED;
-			case PRIVATE: return Flags.PRIVATE;
-			default: return 0;
-		}
-	}
-	
 	private static FieldDeclaration createField(LoggingFramework framework, AccessLevel access, Annotation source, ClassLiteralAccess loggingType, String logFieldName, boolean useStatic, Expression loggerTopic) {
 		int pS = source.sourceStart, pE = source.sourceEnd;
 		long p = (long) pS << 32 | pE;
@@ -155,7 +144,7 @@ public class HandleLog {
 		FieldDeclaration fieldDecl = new FieldDeclaration(logFieldName.toCharArray(), 0, -1);
 		setGeneratedBy(fieldDecl, source);
 		fieldDecl.declarationSourceEnd = -1;
-		fieldDecl.modifiers = toFlags(access) | (useStatic ? Modifier.STATIC : 0) | Modifier.FINAL;
+		fieldDecl.modifiers = toEclipseModifier(access) | (useStatic ? Modifier.STATIC : 0) | Modifier.FINAL;
 		
 		LogDeclaration logDeclaration = framework.getDeclaration();
 		fieldDecl.type = createTypeReference(logDeclaration.getLoggerType().getName(), source);
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index 92f65fc8..ba755827 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -117,14 +117,6 @@ public class HandleLog {
 		return maker.Select(maker.Ident(name), typeNode.toName("class"));
 	}
 	
-	private static int toFlags(AccessLevel level) {
-		switch (level) {
-			case PUBLIC: return Flags.PUBLIC; 
-			case PROTECTED: return Flags.PROTECTED;
-			case PRIVATE: return Flags.PRIVATE;
-			default: return 0;
-		}
-	}
 	
 	private static boolean createField(LoggingFramework framework, AccessLevel access, JavacNode typeNode, JCFieldAccess loggingType, JavacNode source, String logFieldName, boolean useStatic, JCExpression loggerTopic) {
 		JavacTreeMaker maker = typeNode.getTreeMaker();
@@ -139,7 +131,7 @@ public class HandleLog {
 		JCMethodInvocation factoryMethodCall = maker.Apply(List.<JCExpression>nil(), factoryMethod, List.<JCExpression>from(factoryParameters));
 		
 		JCVariableDecl fieldDecl = recursiveSetGeneratedBy(maker.VarDef(
-			maker.Modifiers(toFlags(access) | Flags.FINAL | (useStatic ? Flags.STATIC : 0)),
+			maker.Modifiers(toJavacModifier(access) | Flags.FINAL | (useStatic ? Flags.STATIC : 0)),
 			typeNode.toName(logFieldName), loggerType, factoryMethodCall), source);
 		
 		if (isRecord(typeNode) && Javac.getJavaCompilerVersion() < 16) {

From a6d556856cec89be2786e5598d904497d13ed5be Mon Sep 17 00:00:00 2001
From: Reinier Zwitserloot <r.zwitserloot@projectlombok.org>
Date: Wed, 17 Sep 2025 22:35:07 +0200
Subject: [PATCH 13/16] [deprecation] Marked `AccessLevel.MODULE` as
 deprecated. It was written for a future that never came to pass, and should
 never be used.

---
 src/core/lombok/AccessLevel.java              | 21 +++++++++++++++++--
 .../eclipse/handlers/EclipseHandlerUtil.java  |  1 +
 .../javac/handlers/JavacHandlerUtil.java      |  1 +
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/core/lombok/AccessLevel.java b/src/core/lombok/AccessLevel.java
index 9c138e53..86722229 100644
--- a/src/core/lombok/AccessLevel.java
+++ b/src/core/lombok/AccessLevel.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009 The Project Lombok Authors.
+ * Copyright (C) 2009-2025 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
@@ -25,7 +25,24 @@ package lombok;
  * Represents an AccessLevel. Used e.g. to specify the access level for generated methods and fields.
  */
 public enum AccessLevel {
-	PUBLIC, MODULE, PROTECTED, PACKAGE, PRIVATE,
+	/** Represents the {@code public} access level. */
+	PUBLIC,
+	
+	/**
+	 * Acts exactly like {@code PACKAGE} - the package private access level.
+	 * @deprecated This value was created at a time when a module-level access keyword was planned as a way of being prepared for the future. But that's not the direction java went in; a 'module access level' is not likely to ever exist. This enum acts like {@code PACKAGE} in every way.
+	 */
+	@Deprecated MODULE,
+	
+	/** Represents the {@code protected} access level (any code in the same package as well as any subtype). */
+	PROTECTED,
+	
+	/** Represents the default access level: package private. (any code in the same package). */
+	PACKAGE,
+	
+	/** Represents the {@code private} access level. */
+	PRIVATE,
+	
 	/** Represents not generating anything or the complete lack of a method. */
 	NONE;
 }
diff --git a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
index c45d95a1..7eaaf7b6 100644
--- a/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
+++ b/src/core/lombok/eclipse/handlers/EclipseHandlerUtil.java
@@ -1393,6 +1393,7 @@ public class EclipseHandlerUtil {
 	/**
 	 * Turns an {@code AccessLevel} instance into the flag bit used by eclipse.
 	 */
+	@SuppressWarnings("deprecation") // We have to use MODULE here to make it act according to spec, which is to treat it like `PACKAGE`.
 	public static int toEclipseModifier(AccessLevel value) {
 		switch (value) {
 		case MODULE:
diff --git a/src/core/lombok/javac/handlers/JavacHandlerUtil.java b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
index f243c56a..0c075295 100644
--- a/src/core/lombok/javac/handlers/JavacHandlerUtil.java
+++ b/src/core/lombok/javac/handlers/JavacHandlerUtil.java
@@ -997,6 +997,7 @@ public class JavacHandlerUtil {
 	/**
 	 * Turns an {@code AccessLevel} instance into the flag bit used by javac.
 	 */
+	@SuppressWarnings("deprecation") // We have to use MODULE here to make it act according to spec, which is to treat it like `PACKAGE`.
 	public static int toJavacModifier(AccessLevel accessLevel) {
 		switch (accessLevel) {
 		case MODULE:

From e9cf11ef01081ee1e4446666afadf36368939e96 Mon Sep 17 00:00:00 2001
From: Reinier Zwitserloot <r.zwitserloot@projectlombok.org>
Date: Wed, 17 Sep 2025 22:35:22 +0200
Subject: [PATCH 14/16] [trivial][style]

---
 src/core/lombok/eclipse/handlers/HandleLog.java | 3 +--
 src/core/lombok/javac/handlers/HandleLog.java   | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/core/lombok/eclipse/handlers/HandleLog.java b/src/core/lombok/eclipse/handlers/HandleLog.java
index 85b1b68a..99bd874b 100644
--- a/src/core/lombok/eclipse/handlers/HandleLog.java
+++ b/src/core/lombok/eclipse/handlers/HandleLog.java
@@ -108,8 +108,7 @@ public class HandleLog {
 				loggerTopic = new StringLiteral(new char[]{}, 0, 0, 0);
 			}
 			
-			if (access == AccessLevel.NONE)
-				break;
+			if (access == AccessLevel.NONE) break;
 			
 			ClassLiteralAccess loggingType = selfType(owner, source);
 			FieldDeclaration fieldDeclaration = createField(framework, access, source, loggingType, logFieldName.getName(), useStatic, loggerTopic);
diff --git a/src/core/lombok/javac/handlers/HandleLog.java b/src/core/lombok/javac/handlers/HandleLog.java
index ba755827..9dca9f48 100644
--- a/src/core/lombok/javac/handlers/HandleLog.java
+++ b/src/core/lombok/javac/handlers/HandleLog.java
@@ -99,8 +99,7 @@ public class HandleLog {
 				loggerTopic = typeNode.getTreeMaker().Literal("");
 			}
 			
-			if (access == AccessLevel.NONE)
-				break;
+			if (access == AccessLevel.NONE) break;
 			
 			JCFieldAccess loggingType = selfType(typeNode);
 			createField(framework, access, typeNode, loggingType, annotationNode, logFieldName.getName(), useStatic, loggerTopic);

From 99ba3e31daee7772af4eb712b0a108acdbc86962 Mon Sep 17 00:00:00 2001
From: Reinier Zwitserloot <r.zwitserloot@projectlombok.org>
Date: Wed, 17 Sep 2025 22:35:45 +0200
Subject: [PATCH 15/16] [trivial] Slightly reworded the javadoc on each `@Log`
 annotation's `access()` method.

---
 src/core/lombok/CustomLog.java                       | 3 ++-
 src/core/lombok/extern/apachecommons/CommonsLog.java | 3 ++-
 src/core/lombok/extern/flogger/Flogger.java          | 3 ++-
 src/core/lombok/extern/java/Log.java                 | 3 ++-
 src/core/lombok/extern/jbosslog/JBossLog.java        | 3 ++-
 src/core/lombok/extern/log4j/Log4j.java              | 3 ++-
 src/core/lombok/extern/log4j/Log4j2.java             | 3 ++-
 src/core/lombok/extern/slf4j/Slf4j.java              | 3 ++-
 src/core/lombok/extern/slf4j/XSlf4j.java             | 3 ++-
 9 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/src/core/lombok/CustomLog.java b/src/core/lombok/CustomLog.java
index 0e01e29a..352ab92d 100644
--- a/src/core/lombok/CustomLog.java
+++ b/src/core/lombok/CustomLog.java
@@ -66,7 +66,8 @@ import java.lang.annotation.Target;
 @Target(ElementType.TYPE)
 public @interface CustomLog {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/apachecommons/CommonsLog.java b/src/core/lombok/extern/apachecommons/CommonsLog.java
index 221ed403..4ce5a6b7 100644
--- a/src/core/lombok/extern/apachecommons/CommonsLog.java
+++ b/src/core/lombok/extern/apachecommons/CommonsLog.java
@@ -65,7 +65,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface CommonsLog {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/flogger/Flogger.java b/src/core/lombok/extern/flogger/Flogger.java
index 22782a30..81f216f9 100644
--- a/src/core/lombok/extern/flogger/Flogger.java
+++ b/src/core/lombok/extern/flogger/Flogger.java
@@ -63,7 +63,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface Flogger {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/java/Log.java b/src/core/lombok/extern/java/Log.java
index e74afdf3..1ecf3c07 100644
--- a/src/core/lombok/extern/java/Log.java
+++ b/src/core/lombok/extern/java/Log.java
@@ -64,7 +64,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface Log {
 	/**
-	 * If you want your logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/jbosslog/JBossLog.java b/src/core/lombok/extern/jbosslog/JBossLog.java
index 85d5ebf3..1c9165e5 100644
--- a/src/core/lombok/extern/jbosslog/JBossLog.java
+++ b/src/core/lombok/extern/jbosslog/JBossLog.java
@@ -64,7 +64,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface JBossLog {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/log4j/Log4j.java b/src/core/lombok/extern/log4j/Log4j.java
index ecdf0b3d..0e421e9d 100644
--- a/src/core/lombok/extern/log4j/Log4j.java
+++ b/src/core/lombok/extern/log4j/Log4j.java
@@ -65,7 +65,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface Log4j {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/log4j/Log4j2.java b/src/core/lombok/extern/log4j/Log4j2.java
index 398b27db..9aea5a7a 100644
--- a/src/core/lombok/extern/log4j/Log4j2.java
+++ b/src/core/lombok/extern/log4j/Log4j2.java
@@ -65,7 +65,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface Log4j2 {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/slf4j/Slf4j.java b/src/core/lombok/extern/slf4j/Slf4j.java
index af71b6a3..bc8cf9fc 100644
--- a/src/core/lombok/extern/slf4j/Slf4j.java
+++ b/src/core/lombok/extern/slf4j/Slf4j.java
@@ -64,7 +64,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface Slf4j {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */
diff --git a/src/core/lombok/extern/slf4j/XSlf4j.java b/src/core/lombok/extern/slf4j/XSlf4j.java
index 11d7693a..0ddad2e4 100644
--- a/src/core/lombok/extern/slf4j/XSlf4j.java
+++ b/src/core/lombok/extern/slf4j/XSlf4j.java
@@ -64,7 +64,8 @@ import lombok.AccessLevel;
 @Target(ElementType.TYPE)
 public @interface XSlf4j {
 	/**
-	 * If you want your Logger to be non-private, you can specify an alternate access level here.
+	 * Sets the access level of the generated log field.
+	 * Default: {@code AccessLevel.PRIVATE}.
 	 * 
 	 * @return The constructed Logger method will be generated with this access modifier.
 	 */

From 71d85caef501ce987f26e498154574489dbe36ee Mon Sep 17 00:00:00 2001
From: Reinier Zwitserloot <r.zwitserloot@projectlombok.org>
Date: Thu, 18 Sep 2025 01:45:17 +0200
Subject: [PATCH 16/16] [#2280] Add delivery of this '`access` for logging' to
 the changelog.

---
 doc/changelog.markdown | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/changelog.markdown b/doc/changelog.markdown
index 744156ed..8dac881b 100644
--- a/doc/changelog.markdown
+++ b/doc/changelog.markdown
@@ -2,6 +2,7 @@ Lombok Changelog
 ----------------
 
 ### v1.18.41 "Edgy Guinea Pig"
+* FEATURE: All the various `@Log` annotations now allow you to change their access level (they still default to `private`). [#2280](https://github.com/projectlombok/lombok/issues/2280). Thanks to new contributor Liam Pace!
 * BUGFIX: Javadoc parsing was broken in Netbeans and ErrorProne for JDK25 [#3940](https://github.com/projectlombok/lombok/issues/3940).
 
 ### v1.18.40 (September 4th, 2025)