diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ArrayHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ArrayHandler.java index 8c31197e8d..37b9c421fd 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ArrayHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ArrayHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.ArrayType; import javax.lang.model.type.PrimitiveType; import javax.lang.model.type.TypeMirror; @@ -52,7 +53,7 @@ public class ArrayHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { var dataType = dataType(element); // known to be an array type (assuming isLoggable is checked first); this is a safe cast @@ -63,13 +64,17 @@ public class ArrayHandler extends ElementHandler { return "backend.log(\"" + loggedName(element) + "\", " - + elementAccess(element) + + elementAccess(element, loggedClass) + ", " + m_structHandler.structAccess(componentType) + ")"; } else { // Primitive or string array - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/CollectionHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/CollectionHandler.java index 3fe4abb3aa..d864f093d6 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/CollectionHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/CollectionHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; @@ -38,7 +39,7 @@ public class CollectionHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { var dataType = dataType(element); var componentType = ((DeclaredType) dataType).getTypeArguments().get(0); @@ -46,12 +47,16 @@ public class CollectionHandler extends ElementHandler { return "backend.log(\"" + loggedName(element) + "\", " - + elementAccess(element) + + elementAccess(element, loggedClass) + ", " + m_structHandler.structAccess(componentType) + ")"; } else { - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ConfiguredLoggerHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ConfiguredLoggerHandler.java index f7e6744edf..086e7fbe40 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ConfiguredLoggerHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ConfiguredLoggerHandler.java @@ -7,6 +7,7 @@ package edu.wpi.first.epilogue.processor; import java.util.Map; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.DeclaredType; import javax.lang.model.type.TypeMirror; @@ -27,7 +28,7 @@ public class ConfiguredLoggerHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { var dataType = dataType(element); var loggerType = m_customLoggers.entrySet().stream() @@ -44,7 +45,7 @@ public class ConfiguredLoggerHandler extends ElementHandler { + ".tryUpdate(backend.getNested(\"" + loggedName(element) + "\"), " - + elementAccess(element) + + elementAccess(element, loggedClass) + ", Epilogue.getConfig().errorHandler)"; } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java index d12acb7ecc..61e3d49974 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java @@ -117,9 +117,9 @@ public abstract class ElementHandler { * @param element the element to generate the access for * @return the generated access snippet */ - public String elementAccess(Element element) { + public String elementAccess(Element element, TypeElement loggedClass) { if (element instanceof VariableElement field) { - return fieldAccess(field); + return fieldAccess(field, loggedClass); } else if (element instanceof ExecutableElement method) { return methodAccess(method); } else { @@ -127,8 +127,20 @@ public abstract class ElementHandler { } } - private static String fieldAccess(VariableElement field) { - if (!field.getModifiers().contains(Modifier.PUBLIC)) { + private static String fieldAccess(VariableElement field, TypeElement loggedClass) { + var mods = field.getModifiers(); + + // To be directly accessible, the field needs to be: + // - public; or + // - protected or package-private, and declared by a superclass in the same package + // However, we can't cleanly access package information, so we'll always emit a VarHandle + // for any field declared in a superclass unless it's public and we know we can read it. + boolean isVarHandle = + field.getEnclosingElement().equals(loggedClass) + ? mods.contains(Modifier.PRIVATE) + : !mods.contains(Modifier.PUBLIC); + + if (isVarHandle) { // ((com.example.Foo) $fooField.get(object)) // Extra parentheses so cast evaluates before appended methods // (e.g. when appending .getAsDouble()) @@ -136,7 +148,7 @@ public abstract class ElementHandler { if (type.getKind() == TypeKind.TYPEVAR) { type = ((TypeVariable) type).getUpperBound(); } - return "((" + type.toString() + ") $" + field.getSimpleName() + ".get(object))"; + return "((" + type.toString() + ") " + LoggerGenerator.varHandleName(field) + ".get(object))"; } else { // object.fooField return "object." + field.getSimpleName(); @@ -171,5 +183,5 @@ public abstract class ElementHandler { * @param element the field or method element to generate the logger call for * @return the generated log invocation */ - public abstract String logInvocation(Element element); + public abstract String logInvocation(Element element, TypeElement loggedClass); } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EnumHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EnumHandler.java index 78b14b4636..f8c05670b0 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EnumHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EnumHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; public class EnumHandler extends ElementHandler { @@ -27,7 +28,11 @@ public class EnumHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + public String logInvocation(Element element, TypeElement loggedClass) { + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java index ba14022a2c..001716a637 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java @@ -39,7 +39,7 @@ public class LoggableHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { TypeMirror dataType = dataType(element); var declaredType = m_processingEnv @@ -61,7 +61,7 @@ public class LoggableHandler extends ElementHandler { // If there are no known loggable subtypes, return just the single logger call if (size == 1) { - return generateLoggerCall(element, declaredType, elementAccess(element)); + return generateLoggerCall(element, declaredType, elementAccess(element, loggedClass)); } // Otherwise, generate an if-else chain to compare the element with its known loggable subtypes @@ -73,7 +73,7 @@ public class LoggableHandler extends ElementHandler { StringBuilder builder = new StringBuilder(); // Cache the value in a variable so it's only read once - builder.append("var %s = %s;\n".formatted(varName, elementAccess(element))); + builder.append("var %s = %s;\n".formatted(varName, elementAccess(element, loggedClass))); for (int i = 0; i < size; i++) { TypeElement type = loggableSubtypes.get(i); diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java index 7fbb82a931..20b1e1cebc 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java @@ -18,9 +18,11 @@ import java.io.PrintWriter; import java.lang.annotation.Annotation; import java.util.ArrayDeque; import java.util.ArrayList; +import java.util.Comparator; import java.util.Deque; import java.util.EnumMap; import java.util.HashMap; +import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Objects; @@ -185,7 +187,21 @@ public class LoggerGenerator { var loggerFile = m_processingEnv.getFiler().createSourceFile(loggerClassName); var varHandleFields = - loggableFields.stream().filter(e -> !e.getModifiers().contains(Modifier.PUBLIC)).toList(); + loggableFields.stream() + .filter( + e -> { + if (e.getEnclosingElement().equals(clazz)) { + // The generated logger is in the same package as the logged class, so the + // only fields it can't read are private ones. + return e.getModifiers().contains(Modifier.PRIVATE); + } else { + // Logging from a superclass. Can only read public fields, unless the superclass + // is in the same package, in which case protected and package-private fields + // are also readable. + return !e.getModifiers().contains(Modifier.PUBLIC); + } + }) + .toList(); boolean requiresVarHandles = !varHandleFields.isEmpty(); try (var out = new PrintWriter(loggerFile.openWriter())) { @@ -214,41 +230,67 @@ public class LoggerGenerator { + "> {"); if (requiresVarHandles) { - for (var varHandleField : varHandleFields) { + for (var privateField : varHandleFields) { // This field needs a VarHandle to access. // Cache it in the class to avoid lookups - out.println(" private static final VarHandle $" + varHandleField.getSimpleName() + ";"); + out.printf( + " // Accesses private or superclass field %s.%s%n", + privateField.getEnclosingElement(), privateField.getSimpleName()); + out.printf(" private static final VarHandle %s;%n", varHandleName(privateField)); } out.println(); + } - var classReference = simpleClassName + ".class"; - + // Static initializer block to load VarHandles and reflection fields + if (requiresVarHandles) { out.println(" static {"); - out.println(" try {"); - out.println( - " var lookup = MethodHandles.privateLookupIn(" - + classReference - + ", MethodHandles.lookup());"); - for (var varHandleField : varHandleFields) { - var fieldName = varHandleField.getSimpleName(); - out.println( - " $" - + fieldName - + " = lookup.findVarHandle(" - + classReference - + ", \"" - + fieldName - + "\", " - + m_processingEnv.getTypeUtils().erasure(varHandleField.asType()) - + ".class);"); - } + out.println(" try {"); + + out.println(" var rootLookup = MethodHandles.lookup();"); + + // Group private fields by class, then generate a private lookup for each class + // and a VarHandle for each field using that lookup. Sorting and then collecting into a + // LinkedHashMap gives deterministic output ordering (mostly for tests, which check exact + // file contents, but also results in less churn when regenerating files for users who like + // to read the generated logger classes). + // + // This lets us read private fields from superclasses. + Map> privateFieldsByClass = + varHandleFields.stream() + .sorted(Comparator.comparing(e -> e.getSimpleName().toString())) + .collect( + Collectors.groupingBy( + VariableElement::getEnclosingElement, + LinkedHashMap::new, + Collectors.toList())); + + privateFieldsByClass.forEach( + (enclosingClass, fields) -> { + String className = enclosingClass.toString(); + String lookupName = "lookup$$" + className.replace(".", "_"); + out.printf( + " var %s = MethodHandles.privateLookupIn(%s.class, rootLookup);%n", + lookupName, className); + + for (var field : fields) { + var fieldname = field.getSimpleName(); + out.printf( + " %s = %s.findVarHandle(%s.class, \"%s\", %s.class);%n", + varHandleName(field), + lookupName, + className, + fieldname, + m_processingEnv.getTypeUtils().erasure(field.asType())); + } + }); out.println(" } catch (ReflectiveOperationException e) {"); out.println( " throw new RuntimeException(" + "\"[EPILOGUE] Could not load private fields for logging!\", e);"); out.println(" }"); + out.println(" }"); out.println(); } @@ -300,7 +342,7 @@ public class LoggerGenerator { // to be logged. For example, the sendable handler consumes all sendable types // but does not log commands or subsystems, to prevent excessive warnings about // unloggable commands. - var logInvocation = h.logInvocation(loggableElement); + var logInvocation = h.logInvocation(loggableElement, clazz); if (logInvocation != null) { out.println(logInvocation.indent(6).stripTrailing() + ";"); } @@ -315,6 +357,18 @@ public class LoggerGenerator { } } + /** + * Generates the name of a VarHandle for access to the given field. The VarHandle variable's name + * is guaranteed to be unique. + * + * @param field The field to generate a VarHandle for + * @return The name of the generated VarHandle variable + */ + public static String varHandleName(VariableElement field) { + return "$%s_%s" + .formatted(field.getEnclosingElement().toString().replace(".", "_"), field.getSimpleName()); + } + private void collectLoggables( TypeElement clazz, List fields, List methods) { var config = clazz.getAnnotation(Logged.class); diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/MeasureHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/MeasureHandler.java index 8933306d65..bff3e8533a 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/MeasureHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/MeasureHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; public class MeasureHandler extends ElementHandler { @@ -30,8 +31,12 @@ public class MeasureHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { // EpilogueBackend has builtin support for logging measures - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/PrimitiveHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/PrimitiveHandler.java index 5563bd9b31..8da8ece405 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/PrimitiveHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/PrimitiveHandler.java @@ -16,6 +16,7 @@ import static javax.lang.model.type.TypeKind.SHORT; import java.util.Set; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; public class PrimitiveHandler extends ElementHandler { @@ -35,7 +36,11 @@ public class PrimitiveHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + public String logInvocation(Element element, TypeElement loggedClass) { + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java index d25ce09d31..635b565940 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java @@ -44,7 +44,7 @@ public class SendableHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { var dataType = dataType(element); // Do not log commands or subsystems via their sendable implementations @@ -66,7 +66,7 @@ public class SendableHandler extends ElementHandler { return "logSendable(backend.getNested(\"" + loggedName(element) + "\"), " - + elementAccess(element) + + elementAccess(element, loggedClass) + ")"; } } diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StructHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StructHandler.java index ddd753a818..1c658818e6 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StructHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StructHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; import javax.lang.model.util.Types; @@ -38,11 +39,11 @@ public class StructHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { + public String logInvocation(Element element, TypeElement loggedClass) { return "backend.log(\"" + loggedName(element) + "\", " - + elementAccess(element) + + elementAccess(element, loggedClass) + ", " + structAccess(dataType(element)) + ")"; diff --git a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SupplierHandler.java b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SupplierHandler.java index 173e371c05..49f2e06935 100644 --- a/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SupplierHandler.java +++ b/epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SupplierHandler.java @@ -6,6 +6,7 @@ package edu.wpi.first.epilogue.processor; import javax.annotation.processing.ProcessingEnvironment; import javax.lang.model.element.Element; +import javax.lang.model.element.TypeElement; import javax.lang.model.type.TypeMirror; public class SupplierHandler extends ElementHandler { @@ -42,15 +43,19 @@ public class SupplierHandler extends ElementHandler { } @Override - public String logInvocation(Element element) { - return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")"; + public String logInvocation(Element element, TypeElement loggedClass) { + return "backend.log(\"" + + loggedName(element) + + "\", " + + elementAccess(element, loggedClass) + + ")"; } @Override - public String elementAccess(Element element) { + public String elementAccess(Element element, TypeElement loggedClass) { var typeUtils = m_processingEnv.getTypeUtils(); var dataType = dataType(element); - String base = super.elementAccess(element); + String base = super.elementAccess(element, loggedClass); if (typeUtils.isAssignable(dataType, m_booleanSupplier)) { return base + ".getAsBoolean()"; diff --git a/epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/AnnotationProcessorTest.java b/epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/AnnotationProcessorTest.java index bc6189bf0b..65a7a2e736 100644 --- a/epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/AnnotationProcessorTest.java +++ b/epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/AnnotationProcessorTest.java @@ -42,21 +42,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -64,7 +51,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", object.x); } } } @@ -93,23 +80,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $y; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); - $y = lookup.findVarHandle(Example.class, "y", int.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -117,8 +89,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); - backend.log("y", ((int) $y.get(object))); + backend.log("x", object.x); + backend.log("y", object.y); } } } @@ -210,23 +182,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $y; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); - $y = lookup.findVarHandle(Example.class, "y", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -234,8 +191,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); - backend.log("y", ((double) $y.get(object))); + backend.log("x", object.x); + backend.log("y", object.y); } } } @@ -268,12 +225,14 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.x + private static final VarHandle $edu_wpi_first_epilogue_Example_x; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_x = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "x", double.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -286,7 +245,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", ((double) $edu_wpi_first_epilogue_Example_x.get(object))); } } } @@ -321,12 +280,14 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.x + private static final VarHandle $edu_wpi_first_epilogue_Example_x; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", java.util.function.DoubleSupplier.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_x = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "x", java.util.function.DoubleSupplier.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -339,7 +300,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((java.util.function.DoubleSupplier) $x.get(object)).getAsDouble()); + backend.log("x", ((java.util.function.DoubleSupplier) $edu_wpi_first_epilogue_Example_x.get(object)).getAsDouble()); } } } @@ -372,12 +333,14 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $chooser; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.chooser + private static final VarHandle $edu_wpi_first_epilogue_Example_chooser; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $chooser = lookup.findVarHandle(Example.class, "chooser", edu.wpi.first.wpilibj.smartdashboard.SendableChooser.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_chooser = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "chooser", edu.wpi.first.wpilibj.smartdashboard.SendableChooser.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -390,7 +353,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - logSendable(backend.getNested("chooser"), ((edu.wpi.first.wpilibj.smartdashboard.SendableChooser) $chooser.get(object))); + logSendable(backend.getNested("chooser"), ((edu.wpi.first.wpilibj.smartdashboard.SendableChooser) $edu_wpi_first_epilogue_Example_chooser.get(object))); } } } @@ -421,25 +384,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $low; - private static final VarHandle $medium; - private static final VarHandle $high; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $low = lookup.findVarHandle(Example.class, "low", double.class); - $medium = lookup.findVarHandle(Example.class, "medium", int.class); - $high = lookup.findVarHandle(Example.class, "high", long.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -447,13 +393,13 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("low", ((double) $low.get(object))); + backend.log("low", object.low); } if (Epilogue.shouldLog(Logged.Importance.INFO)) { - backend.log("medium", ((int) $medium.get(object))); + backend.log("medium", object.medium); } if (Epilogue.shouldLog(Logged.Importance.CRITICAL)) { - backend.log("high", ((long) $high.get(object))); + backend.log("high", object.high); } } } @@ -486,21 +432,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $enumValue; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $enumValue = lookup.findVarHandle(Example.class, "enumValue", edu.wpi.first.epilogue.Example.E.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -508,7 +441,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("enumValue", ((edu.wpi.first.epilogue.Example.E) $enumValue.get(object))); + backend.log("enumValue", object.enumValue); } } } @@ -535,6 +468,52 @@ class AnnotationProcessorTest { } """; + String expectedGeneratedSource = + """ + package edu.wpi.first.epilogue; + + import edu.wpi.first.epilogue.Logged; + import edu.wpi.first.epilogue.Epilogue; + import edu.wpi.first.epilogue.logging.ClassSpecificLogger; + import edu.wpi.first.epilogue.logging.EpilogueBackend; + + public class ExampleLogger extends ClassSpecificLogger { + public ExampleLogger() { + super(Example.class); + } + + @Override + public void update(EpilogueBackend backend, Example object) { + if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { + backend.log("y", object.y); + } + } + } + """; + + assertLoggerGenerates(source, expectedGeneratedSource); + } + + @Test + void simpleSuperclass() { + String source = + """ + package edu.wpi.first.epilogue; + + @Logged + class BaseExample { + public double a; + protected double b; + private double c; + double d; + } + + @Logged + class Example extends BaseExample { + double e; + } + """; + String expectedGeneratedSource = """ package edu.wpi.first.epilogue; @@ -547,12 +526,20 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $y; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.b + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_b; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.c + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_c; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.d + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_d; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $y = lookup.findVarHandle(Example.class, "y", double.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_BaseExample = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.BaseExample.class, rootLookup); + $edu_wpi_first_epilogue_BaseExample_b = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "b", double.class); + $edu_wpi_first_epilogue_BaseExample_c = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "c", double.class); + $edu_wpi_first_epilogue_BaseExample_d = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "d", double.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -565,7 +552,11 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("y", ((double) $y.get(object))); + backend.log("e", object.e); + backend.log("a", object.a); + backend.log("b", ((double) $edu_wpi_first_epilogue_BaseExample_b.get(object))); + backend.log("c", ((double) $edu_wpi_first_epilogue_BaseExample_c.get(object))); + backend.log("d", ((double) $edu_wpi_first_epilogue_BaseExample_d.get(object))); } } } @@ -575,7 +566,7 @@ class AnnotationProcessorTest { } @Test - void superclass() { + void complexSuperclass() { String source = """ package edu.wpi.first.epilogue; @@ -600,6 +591,7 @@ class AnnotationProcessorTest { @Logged class Example extends BaseExample { double h; + private double i; } """; @@ -615,18 +607,24 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $h; - private static final VarHandle $d; - private static final VarHandle $f; - private static final VarHandle $g; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.i + private static final VarHandle $edu_wpi_first_epilogue_Example_i; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.d + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_d; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.f + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_f; + // Accesses private or superclass field edu.wpi.first.epilogue.BaseExample.g + private static final VarHandle $edu_wpi_first_epilogue_BaseExample_g; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $h = lookup.findVarHandle(Example.class, "h", double.class); - $d = lookup.findVarHandle(Example.class, "d", double.class); - $f = lookup.findVarHandle(Example.class, "f", double.class); - $g = lookup.findVarHandle(Example.class, "g", double.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_BaseExample = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.BaseExample.class, rootLookup); + $edu_wpi_first_epilogue_BaseExample_d = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "d", double.class); + $edu_wpi_first_epilogue_BaseExample_f = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "f", double.class); + $edu_wpi_first_epilogue_BaseExample_g = lookup$$edu_wpi_first_epilogue_BaseExample.findVarHandle(edu.wpi.first.epilogue.BaseExample.class, "g", double.class); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_i = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "i", double.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -639,11 +637,12 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("h", ((double) $h.get(object))); - backend.log("d", ((double) $d.get(object))); + backend.log("h", object.h); + backend.log("i", ((double) $edu_wpi_first_epilogue_Example_i.get(object))); + backend.log("d", ((double) $edu_wpi_first_epilogue_BaseExample_d.get(object))); backend.log("e", object.e); - backend.log("f", ((double) $f.get(object))); - backend.log("g", ((double) $g.get(object))); + backend.log("f", ((double) $edu_wpi_first_epilogue_BaseExample_f.get(object))); + backend.log("g", ((double) $edu_wpi_first_epilogue_BaseExample_g.get(object))); backend.log("a", object.a); backend.log("getValue", object.getValue()); backend.log("getB", object.getB()); @@ -681,23 +680,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", byte.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", byte[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -705,8 +689,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((byte) $x.get(object))); - backend.log("arr1", ((byte[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -743,21 +727,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", char.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -765,7 +736,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((char) $x.get(object))); + backend.log("x", object.x); backend.log("getX", object.getX()); } } @@ -801,21 +772,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", short.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -823,7 +781,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((short) $x.get(object))); + backend.log("x", object.x); backend.log("getX", object.getX()); } } @@ -859,23 +817,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", int.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", int[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -883,8 +826,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((int) $x.get(object))); - backend.log("arr1", ((int[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -921,23 +864,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", long.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", long[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -945,8 +873,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((long) $x.get(object))); - backend.log("arr1", ((long[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -983,23 +911,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", float.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", float[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1007,8 +920,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((float) $x.get(object))); - backend.log("arr1", ((float[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -1048,23 +961,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", double[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1072,8 +970,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); - backend.log("arr1", ((double[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -1112,23 +1010,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", boolean.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", boolean[].class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1136,8 +1019,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((boolean) $x.get(object))); - backend.log("arr1", ((boolean[]) $arr1.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -1177,25 +1060,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - private static final VarHandle $list; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", java.lang.String.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", java.lang.String[].class); - $list = lookup.findVarHandle(Example.class, "list", java.util.List.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1203,9 +1069,9 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((java.lang.String) $x.get(object))); - backend.log("arr1", ((java.lang.String[]) $arr1.get(object))); - backend.log("list", ((java.util.List) $list.get(object))); + backend.log("x", object.x); + backend.log("arr1", object.arr1); + backend.log("list", object.list); backend.log("getX", object.getX()); backend.log("getArr1", object.getArr1()); } @@ -1253,25 +1119,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - private static final VarHandle $arr1; - private static final VarHandle $list; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", edu.wpi.first.epilogue.Example.Structable.class); - $arr1 = lookup.findVarHandle(Example.class, "arr1", edu.wpi.first.epilogue.Example.Structable[].class); - $list = lookup.findVarHandle(Example.class, "list", java.util.List.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1279,9 +1128,9 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((edu.wpi.first.epilogue.Example.Structable) $x.get(object)), edu.wpi.first.epilogue.Example.Structable.struct); - backend.log("arr1", ((edu.wpi.first.epilogue.Example.Structable[]) $arr1.get(object)), edu.wpi.first.epilogue.Example.Structable.struct); - backend.log("list", ((java.util.List) $list.get(object)), edu.wpi.first.epilogue.Example.Structable.struct); + backend.log("x", object.x, edu.wpi.first.epilogue.Example.Structable.struct); + backend.log("arr1", object.arr1, edu.wpi.first.epilogue.Example.Structable.struct); + backend.log("list", object.list, edu.wpi.first.epilogue.Example.Structable.struct); backend.log("getX", object.getX(), edu.wpi.first.epilogue.Example.Structable.struct); backend.log("getArr1", object.getArr1(), edu.wpi.first.epilogue.Example.Structable.struct); } @@ -1321,27 +1170,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $list; - private static final VarHandle $set; - private static final VarHandle $queue; - private static final VarHandle $stack; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $list = lookup.findVarHandle(Example.class, "list", java.util.List.class); - $set = lookup.findVarHandle(Example.class, "set", java.util.Set.class); - $queue = lookup.findVarHandle(Example.class, "queue", java.util.Queue.class); - $stack = lookup.findVarHandle(Example.class, "stack", java.util.Stack.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1349,10 +1179,10 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("list", ((java.util.List) $list.get(object))); - backend.log("set", ((java.util.Set) $set.get(object))); - backend.log("queue", ((java.util.Queue) $queue.get(object))); - backend.log("stack", ((java.util.Stack) $stack.get(object))); + backend.log("list", object.list); + backend.log("set", object.set); + backend.log("queue", object.queue); + backend.log("stack", object.stack); } } } @@ -1507,9 +1337,10 @@ class AnnotationProcessorTest { @Logged class Example { - T value; + T valueA; + private T valueB; - public S upcast() { return (S) value; } + public S upcast() { return (S) valueA; } } """; @@ -1525,12 +1356,14 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $value; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.valueB + private static final VarHandle $edu_wpi_first_epilogue_Example_valueB; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $value = lookup.findVarHandle(Example.class, "value", java.lang.String.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_valueB = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "valueB", java.lang.String.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -1543,7 +1376,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("value", ((java.lang.String) $value.get(object))); + backend.log("valueA", object.valueA); + backend.log("valueB", ((java.lang.String) $edu_wpi_first_epilogue_Example_valueB.get(object))); backend.log("upcast", object.upcast()); } } @@ -1586,23 +1420,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $child; - private static final VarHandle $io; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $child = lookup.findVarHandle(Example.class, "child", edu.wpi.first.epilogue.Child.class); - $io = lookup.findVarHandle(Example.class, "io", edu.wpi.first.epilogue.IO.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1610,8 +1429,8 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - Epilogue.childLogger.tryUpdate(backend.getNested("child"), ((edu.wpi.first.epilogue.Child) $child.get(object)), Epilogue.getConfig().errorHandler); - Epilogue.ioLogger.tryUpdate(backend.getNested("io"), ((edu.wpi.first.epilogue.IO) $io.get(object)), Epilogue.getConfig().errorHandler); + Epilogue.childLogger.tryUpdate(backend.getNested("child"), object.child, Epilogue.getConfig().errorHandler); + Epilogue.ioLogger.tryUpdate(backend.getNested("io"), object.io, Epilogue.getConfig().errorHandler); } } } @@ -1688,27 +1507,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $asInterface; - private static final VarHandle $firstImpl; - private static final VarHandle $secondImpl; - private static final VarHandle $complex; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $asInterface = lookup.findVarHandle(Example.class, "asInterface", edu.wpi.first.epilogue.IFace.class); - $firstImpl = lookup.findVarHandle(Example.class, "firstImpl", edu.wpi.first.epilogue.Impl1.class); - $secondImpl = lookup.findVarHandle(Example.class, "secondImpl", edu.wpi.first.epilogue.Impl2.class); - $complex = lookup.findVarHandle(Example.class, "complex", edu.wpi.first.epilogue.I.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1716,7 +1516,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - var $$asInterface = ((edu.wpi.first.epilogue.IFace) $asInterface.get(object)); + var $$asInterface = object.asInterface; if ($$asInterface instanceof edu.wpi.first.epilogue.Impl1 edu_wpi_first_epilogue_Impl1) { Epilogue.impl1Logger.tryUpdate(backend.getNested("asInterface"), edu_wpi_first_epilogue_Impl1, Epilogue.getConfig().errorHandler); } else if ($$asInterface instanceof edu.wpi.first.epilogue.Impl2 edu_wpi_first_epilogue_Impl2) { @@ -1725,9 +1525,9 @@ class AnnotationProcessorTest { // Base type edu.wpi.first.epilogue.IFace Epilogue.iFaceLogger.tryUpdate(backend.getNested("asInterface"), $$asInterface, Epilogue.getConfig().errorHandler); }; - Epilogue.impl1Logger.tryUpdate(backend.getNested("firstImpl"), ((edu.wpi.first.epilogue.Impl1) $firstImpl.get(object)), Epilogue.getConfig().errorHandler); - Epilogue.impl2Logger.tryUpdate(backend.getNested("secondImpl"), ((edu.wpi.first.epilogue.Impl2) $secondImpl.get(object)), Epilogue.getConfig().errorHandler); - var $$complex = ((edu.wpi.first.epilogue.I) $complex.get(object)); + Epilogue.impl1Logger.tryUpdate(backend.getNested("firstImpl"), object.firstImpl, Epilogue.getConfig().errorHandler); + Epilogue.impl2Logger.tryUpdate(backend.getNested("secondImpl"), object.secondImpl, Epilogue.getConfig().errorHandler); + var $$complex = object.complex; if ($$complex instanceof edu.wpi.first.epilogue.ConcreteLogged edu_wpi_first_epilogue_ConcreteLogged) { Epilogue.concreteLoggedLogger.tryUpdate(backend.getNested("complex"), edu_wpi_first_epilogue_ConcreteLogged, Epilogue.getConfig().errorHandler); } else if ($$complex instanceof edu.wpi.first.epilogue.I4 edu_wpi_first_epilogue_I4) { @@ -1770,21 +1570,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class Outer$ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Outer.Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Outer.Example.class, "x", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public Outer$ExampleLogger() { super(Outer.Example.class); } @@ -1792,7 +1579,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Outer.Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", object.x); } } } @@ -1829,21 +1616,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class A$B$C$D$ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(A.B.C.D.Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(A.B.C.D.Example.class, "x", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public A$B$C$D$ExampleLogger() { super(A.B.C.D.Example.class); } @@ -1851,7 +1625,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, A.B.C.D.Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", object.x); } } } @@ -1882,21 +1656,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class CustomExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Outer.Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Outer.Example.class, "x", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public CustomExampleLogger() { super(Outer.Example.class); } @@ -1904,7 +1665,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Outer.Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", object.x); } } } @@ -1948,21 +1709,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $theField; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $theField = lookup.findVarHandle(Example.class, "theField", edu.wpi.first.epilogue.I.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -1970,7 +1718,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - var $$theField = ((edu.wpi.first.epilogue.I) $theField.get(object)); + var $$theField = object.theField; if ($$theField instanceof edu.wpi.first.epilogue.Base edu_wpi_first_epilogue_Base) { Epilogue.baseLogger.tryUpdate(backend.getNested("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler); } else if ($$theField instanceof edu.wpi.first.epilogue.ExtendingInterface edu_wpi_first_epilogue_ExtendingInterface) { @@ -2017,12 +1765,14 @@ class AnnotationProcessorTest { import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $theField; + // Accesses private or superclass field edu.wpi.first.epilogue.Example.theField + private static final VarHandle $edu_wpi_first_epilogue_Example_theField; static { try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $theField = lookup.findVarHandle(Example.class, "theField", edu.wpi.first.epilogue.I.class); + var rootLookup = MethodHandles.lookup(); + var lookup$$edu_wpi_first_epilogue_Example = MethodHandles.privateLookupIn(edu.wpi.first.epilogue.Example.class, rootLookup); + $edu_wpi_first_epilogue_Example_theField = lookup$$edu_wpi_first_epilogue_Example.findVarHandle(edu.wpi.first.epilogue.Example.class, "theField", edu.wpi.first.epilogue.I.class); } catch (ReflectiveOperationException e) { throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); } @@ -2035,7 +1785,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - var $$theField = ((edu.wpi.first.epilogue.I) $theField.get(object)); + var $$theField = ((edu.wpi.first.epilogue.I) $edu_wpi_first_epilogue_Example_theField.get(object)); if ($$theField instanceof edu.wpi.first.epilogue.Base edu_wpi_first_epilogue_Base) { Epilogue.baseLogger.tryUpdate(backend.getNested("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler); } else { @@ -2073,21 +1823,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $i; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $i = lookup.findVarHandle(Example.class, "i", edu.wpi.first.epilogue.Implicit.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -2095,7 +1832,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - Epilogue.implicitLogger.tryUpdate(backend.getNested("i"), ((edu.wpi.first.epilogue.Implicit) $i.get(object)), Epilogue.getConfig().errorHandler); + Epilogue.implicitLogger.tryUpdate(backend.getNested("i"), object.i, Epilogue.getConfig().errorHandler); } } } @@ -2140,21 +1877,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $point; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $point = lookup.findVarHandle(Example.class, "point", edu.wpi.first.epilogue.Point.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -2162,7 +1886,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - Epilogue.customPointLogger.tryUpdate(backend.getNested("point"), ((edu.wpi.first.epilogue.Point) $point.get(object)), Epilogue.getConfig().errorHandler); + Epilogue.customPointLogger.tryUpdate(backend.getNested("point"), object.point, Epilogue.getConfig().errorHandler); } } } @@ -2208,21 +1932,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $vec; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $vec = lookup.findVarHandle(Example.class, "vec", edu.wpi.first.math.Vector.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -2230,7 +1941,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - Epilogue.vectorLogger.tryUpdate(backend.getNested("vec"), ((edu.wpi.first.math.Vector) $vec.get(object)), Epilogue.getConfig().errorHandler); + Epilogue.vectorLogger.tryUpdate(backend.getNested("vec"), object.vec, Epilogue.getConfig().errorHandler); } } } @@ -2417,21 +2128,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $x; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $x = lookup.findVarHandle(Example.class, "x", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -2439,7 +2137,7 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("x", ((double) $x.get(object))); + backend.log("x", object.x); backend.log("withANoOpTransform", object.withANoOpTransform()); backend.log("withTemp", object.withTemp()); } @@ -2482,27 +2180,8 @@ class AnnotationProcessorTest { import edu.wpi.first.epilogue.Epilogue; import edu.wpi.first.epilogue.logging.ClassSpecificLogger; import edu.wpi.first.epilogue.logging.EpilogueBackend; - import java.lang.invoke.MethodHandles; - import java.lang.invoke.VarHandle; public class ExampleLogger extends ClassSpecificLogger { - private static final VarHandle $m_memberPrefix; - private static final VarHandle $kConstantPrefix; - private static final VarHandle $k_otherConstantPrefix; - private static final VarHandle $s_otherPrefix; - - static { - try { - var lookup = MethodHandles.privateLookupIn(Example.class, MethodHandles.lookup()); - $m_memberPrefix = lookup.findVarHandle(Example.class, "m_memberPrefix", double.class); - $kConstantPrefix = lookup.findVarHandle(Example.class, "kConstantPrefix", double.class); - $k_otherConstantPrefix = lookup.findVarHandle(Example.class, "k_otherConstantPrefix", double.class); - $s_otherPrefix = lookup.findVarHandle(Example.class, "s_otherPrefix", double.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("[EPILOGUE] Could not load private fields for logging!", e); - } - } - public ExampleLogger() { super(Example.class); } @@ -2510,10 +2189,10 @@ class AnnotationProcessorTest { @Override public void update(EpilogueBackend backend, Example object) { if (Epilogue.shouldLog(Logged.Importance.DEBUG)) { - backend.log("Member Prefix", ((double) $m_memberPrefix.get(object))); - backend.log("Constant Prefix", ((double) $kConstantPrefix.get(object))); - backend.log("Other Constant Prefix", ((double) $k_otherConstantPrefix.get(object))); - backend.log("Other Prefix", ((double) $s_otherPrefix.get(object))); + backend.log("Member Prefix", object.m_memberPrefix); + backend.log("Constant Prefix", object.kConstantPrefix); + backend.log("Other Constant Prefix", object.k_otherConstantPrefix); + backend.log("Other Prefix", object.s_otherPrefix); backend.log("The Getter Method", object.getTheGetterMethod()); backend.log("optedOut", object.optedOut()); }