Merge branch 'wpilibsuite:main' into change-swervekinematics-overload

Author: falOn-Dev

Diff for: .github/workflows/comment-command.yml

@@ -43,7 +43,7 @@ jobs:
           distribution: 'temurin'
           java-version: 17
       - name: Install wpiformat
-        run: pip3 install wpiformat==2024.45
+        run: pip3 install wpiformat==2024.50
       - name: Run wpiformat
         run: wpiformat
       - name: Run spotlessApply

Diff for: .github/workflows/gradle.yml

@@ -15,10 +15,10 @@ jobs:
           - container: wpilib/roborio-cross-ubuntu:2025-22.04
             artifact-name: Athena
             build-options: "-Ponlylinuxathena"
-          - container: wpilib/raspbian-cross-ubuntu:bullseye-22.04
+          - container: wpilib/raspbian-cross-ubuntu:bookworm-22.04
             artifact-name: Arm32
             build-options: "-Ponlylinuxarm32"
-          - container: wpilib/aarch64-cross-ubuntu:bullseye-22.04
+          - container: wpilib/aarch64-cross-ubuntu:bookworm-22.04
             artifact-name: Arm64
             build-options: "-Ponlylinuxarm64"
           - container: wpilib/ubuntu-base:22.04

Diff for: .github/workflows/lint-format.yml

@@ -27,7 +27,7 @@ jobs:
         with:
           python-version: '3.12'
       - name: Install wpiformat
-        run: pip3 install wpiformat==2024.45
+        run: pip3 install wpiformat==2024.50
       - name: Run
         run: wpiformat
       - name: Check output
@@ -66,7 +66,7 @@ jobs:
         with:
           python-version: '3.12'
       - name: Install wpiformat
-        run: pip3 install wpiformat==2024.45
+        run: pip3 install wpiformat==2024.50
       - name: Create compile_commands.json
         run: |
           ./gradlew generateCompileCommands -Ptoolchain-optional-roboRio

Diff for: .github/workflows/sentinel-build.yml

@@ -19,10 +19,10 @@ jobs:
           - container: wpilib/roborio-cross-ubuntu:2025-22.04
             artifact-name: Athena
             build-options: "-Ponlylinuxathena"
-          - container: wpilib/raspbian-cross-ubuntu:bullseye-22.04
+          - container: wpilib/raspbian-cross-ubuntu:bookworm-22.04
             artifact-name: Arm32
             build-options: "-Ponlylinuxarm32"
-          - container: wpilib/aarch64-cross-ubuntu:bullseye-22.04
+          - container: wpilib/aarch64-cross-ubuntu:bookworm-22.04
             artifact-name: Arm64
             build-options: "-Ponlylinuxarm64"
           - container: wpilib/ubuntu-base:22.04

Diff for: buildSrc/build.gradle

@@ -9,5 +9,5 @@ repositories {
     }
 }
 dependencies {
-    implementation "edu.wpi.first:native-utils:2025.7.1"
+    implementation "edu.wpi.first:native-utils:2025.9.0"
 }

Diff for: developerRobot/README.md

@@ -9,7 +9,12 @@ This command builds everything.
 
 ## Simulation
 
-This command runs the C++ subproject on desktop.
+This command runs the Java project on desktop.
+```bash
+./gradlew developerRobot:run
+```
+
+This command runs the C++ project on desktop.
 ```bash
 ./gradlew developerRobot:runCpp
 ```

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/AnnotationProcessor.java

@@ -11,9 +11,12 @@
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import javax.annotation.processing.AbstractProcessor;
 import javax.annotation.processing.RoundEnvironment;
 import javax.annotation.processing.SupportedAnnotationTypes;
@@ -90,15 +93,15 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
                       e);
             });
 
+    var loggedTypes = getLoggedTypes(roundEnv);
+
     // Handlers are declared in order of priority. If an element could be logged in more than one
     // way (eg a class implements both Sendable and StructSerializable), the order of the handlers
     // in this list will determine how it gets logged.
     m_handlers =
         List.of(
             new LoggableHandler(
-                processingEnv,
-                roundEnv.getElementsAnnotatedWith(
-                    Logged.class)), // prioritize epilogue logging over Sendable
+                processingEnv, loggedTypes), // prioritize epilogue logging over Sendable
             new ConfiguredLoggerHandler(
                 processingEnv, customLoggers), // then customized logging configs
             new ArrayHandler(processingEnv),
@@ -118,12 +121,39 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         .findAny()
         .ifPresent(
             epilogue -> {
-              processEpilogue(roundEnv, epilogue);
+              processEpilogue(roundEnv, epilogue, loggedTypes);
             });
 
     return false;
   }
 
+  /**
+   * Gets the set of all loggable types in the compilation unit. A type is considered loggable if it
+   * is directly annotated with {@code @Logged} or contains a field or method with a {@code @Logged}
+   * annotation.
+   *
+   * @param roundEnv the compilation round environment
+   * @return the set of all loggable types
+   */
+  private Set<TypeElement> getLoggedTypes(RoundEnvironment roundEnv) {
+    // Fetches everything annotated with @Logged; classes, methods, values, etc.
+    var annotatedElements = roundEnv.getElementsAnnotatedWith(Logged.class);
+    return Stream.concat(
+            // 1. All type elements (classes, interfaces, or enums) with the @Logged annotation
+            annotatedElements.stream()
+                .filter(e -> e instanceof TypeElement)
+                .map(e -> (TypeElement) e),
+            // 2. All type elements containing a field or method with the @Logged annotation
+            annotatedElements.stream()
+                .filter(e -> e instanceof VariableElement || e instanceof ExecutableElement)
+                .map(Element::getEnclosingElement)
+                .filter(e -> e instanceof TypeElement)
+                .map(e -> (TypeElement) e))
+        .sorted(Comparator.comparing(e -> e.getSimpleName().toString()))
+        .collect(
+            Collectors.toCollection(LinkedHashSet::new)); // Collect to a set to avoid duplicates
+  }
+
   private boolean validateFields(Set<? extends Element> annotatedElements) {
     var fields =
         annotatedElements.stream()
@@ -340,7 +370,8 @@ private Map<DeclaredType, DeclaredType> processCustomLoggers(
     return customLoggers;
   }
 
-  private void processEpilogue(RoundEnvironment roundEnv, TypeElement epilogueAnnotation) {
+  private void processEpilogue(
+      RoundEnvironment roundEnv, TypeElement epilogueAnnotation, Set<TypeElement> loggedTypes) {
     var annotatedElements = roundEnv.getElementsAnnotatedWith(epilogueAnnotation);
 
     List<String> loggerClassNames = new ArrayList<>();
@@ -358,12 +389,7 @@ private void processEpilogue(RoundEnvironment roundEnv, TypeElement epilogueAnno
       return;
     }
 
-    var classes =
-        annotatedElements.stream()
-            .filter(e -> e instanceof TypeElement)
-            .map(e -> (TypeElement) e)
-            .toList();
-    for (TypeElement clazz : classes) {
+    for (TypeElement clazz : loggedTypes) {
       try {
         warnOfNonLoggableElements(clazz);
         m_loggerGenerator.writeLoggerFile(clazz);
@@ -391,7 +417,7 @@ private void processEpilogue(RoundEnvironment roundEnv, TypeElement epilogueAnno
 
   private void warnOfNonLoggableElements(TypeElement clazz) {
     var config = clazz.getAnnotation(Logged.class);
-    if (config.strategy() == Logged.Strategy.OPT_IN) {
+    if (config == null || config.strategy() == Logged.Strategy.OPT_IN) {
       // field and method validations will have already checked everything
       return;
     }

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java

@@ -127,8 +127,10 @@ public String elementAccess(Element element) {
 
   private static String fieldAccess(VariableElement field) {
     if (field.getModifiers().contains(Modifier.PRIVATE)) {
-      // (com.example.Foo) $fooField.get(object)
-      return "(" + field.asType() + ") $" + field.getSimpleName() + ".get(object)";
+      // ((com.example.Foo) $fooField.get(object))
+      // Extra parentheses so cast evaluates before appended methods
+      // (e.g. when appending .getAsDouble())
+      return "((" + field.asType() + ") $" + field.getSimpleName() + ".get(object))";
     } else {
       // object.fooField
       return "object." + field.getSimpleName();

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java

@@ -15,7 +15,6 @@
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.element.VariableElement;
-import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
 
@@ -35,10 +34,8 @@ protected LoggableHandler(
 
   @Override
   public boolean isLoggable(Element element) {
-    var dataType = dataType(element);
-    return dataType.getAnnotation(Logged.class) != null
-        || dataType instanceof DeclaredType decl
-            && decl.asElement().getAnnotation(Logged.class) != null;
+    return m_processingEnv.getTypeUtils().asElement(dataType(element)) instanceof TypeElement t
+        && m_loggedTypes.contains(t);
   }
 
   @Override

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java

@@ -15,6 +15,7 @@
 import edu.wpi.first.epilogue.NotLogged;
 import java.io.IOException;
 import java.io.PrintWriter;
+import java.lang.annotation.Annotation;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
@@ -42,6 +43,33 @@ public class LoggerGenerator {
       LoggerGenerator::isBuiltInJavaMethod;
   private final ProcessingEnvironment m_processingEnv;
   private final List<ElementHandler> m_handlers;
+  private final Logged m_defaultConfig =
+      new Logged() {
+        @Override
+        public Class<? extends Annotation> annotationType() {
+          return Logged.class;
+        }
+
+        @Override
+        public String name() {
+          return "";
+        }
+
+        @Override
+        public Strategy strategy() {
+          return Strategy.OPT_IN;
+        }
+
+        @Override
+        public Importance importance() {
+          return Importance.DEBUG;
+        }
+
+        @Override
+        public Naming defaultNaming() {
+          return Naming.USE_CODE_NAME;
+        }
+      };
 
   public LoggerGenerator(ProcessingEnvironment processingEnv, List<ElementHandler> handlers) {
     this.m_processingEnv = processingEnv;
@@ -76,6 +104,9 @@ private static boolean isBuiltInJavaMethod(ExecutableElement e) {
    */
   public void writeLoggerFile(TypeElement clazz) throws IOException {
     var config = clazz.getAnnotation(Logged.class);
+    if (config == null) {
+      config = m_defaultConfig;
+    }
     boolean requireExplicitOptIn = config.strategy() == Logged.Strategy.OPT_IN;
 
     Predicate<Element> notSkipped = LoggerGenerator::isNotSkipped;

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java

@@ -4,24 +4,32 @@
 
 package edu.wpi.first.epilogue.processor;
 
+import java.util.Optional;
 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 SendableHandler extends ElementHandler {
-  private final TypeMirror m_sendableType;
-  private final TypeMirror m_commandType;
-  private final TypeMirror m_subsystemType;
+  private final Optional<TypeMirror> m_sendableType;
+  private final Optional<TypeMirror> m_commandType;
+  private final Optional<TypeMirror> m_subsystemType;
 
   protected SendableHandler(ProcessingEnvironment processingEnv) {
     super(processingEnv);
 
     m_sendableType =
-        lookupTypeElement(processingEnv, "edu.wpi.first.util.sendable.Sendable").asType();
+        Optional.ofNullable(
+                lookupTypeElement(processingEnv, "edu.wpi.first.util.sendable.Sendable"))
+            .map(TypeElement::asType);
     m_commandType =
-        lookupTypeElement(processingEnv, "edu.wpi.first.wpilibj2.command.Command").asType();
+        Optional.ofNullable(
+                lookupTypeElement(processingEnv, "edu.wpi.first.wpilibj2.command.Command"))
+            .map(TypeElement::asType);
     m_subsystemType =
-        lookupTypeElement(processingEnv, "edu.wpi.first.wpilibj2.command.SubsystemBase").asType();
+        Optional.ofNullable(
+                lookupTypeElement(processingEnv, "edu.wpi.first.wpilibj2.command.SubsystemBase"))
+            .map(TypeElement::asType);
   }
 
   @Override
@@ -30,20 +38,28 @@ public boolean isLoggable(Element element) {
 
     // Accept any sendable type. However, the log invocation will return null
     // for sendable types that should not be logged (commands, subsystems)
-    return m_processingEnv.getTypeUtils().isAssignable(dataType, m_sendableType);
+    return m_sendableType
+        .map(t -> m_processingEnv.getTypeUtils().isAssignable(dataType, t))
+        .orElse(false);
   }
 
   @Override
   public String logInvocation(Element element) {
     var dataType = dataType(element);
 
-    if (m_processingEnv.getTypeUtils().isAssignable(dataType, m_commandType)
-        || m_processingEnv.getTypeUtils().isAssignable(dataType, m_subsystemType)) {
-      // Do not log commands or subsystems via their sendable implementations
-      // We accept all sendable objects to prevent them from being reported as not loggable,
-      // but their sendable implementations do not include helpful information.
-      // Users are free to provide custom logging implementations for commands, and tag their
-      // subsystems with @Logged to log their contents automatically
+    // Do not log commands or subsystems via their sendable implementations
+    // We accept all sendable objects to prevent them from being reported as not loggable,
+    // but their sendable implementations do not include helpful information.
+    // Users are free to provide custom logging implementations for commands, and tag their
+    // subsystems with @Logged to log their contents automatically
+    if (m_commandType
+        .map(t -> m_processingEnv.getTypeUtils().isAssignable(dataType, t))
+        .orElse(false)) {
+      return null;
+    }
+    if (m_subsystemType
+        .map(t -> m_processingEnv.getTypeUtils().isAssignable(dataType, t))
+        .orElse(false)) {
       return null;
     }
 

Diff for: epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StringUtils.java

@@ -123,7 +123,7 @@ public static String loggerClassName(TypeElement clazz) {
     String packageName = p.getQualifiedName().toString();
 
     String className;
-    if (config.name().isEmpty()) {
+    if (config == null || config.name().isEmpty()) {
       className = String.join("$", nesting);
     } else {
       className = capitalize(config.name()).replaceAll(" ", "");