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] 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();
+  }
+}