Model private synthetic record fields for annotation processing

bazelbuild/bazel#27810

PiperOrigin-RevId: 838647742

Author: cushon

java/com/google/turbine/binder/CanonicalTypeBinder.java

@@ -16,8 +16,6 @@
 
 package com.google.turbine.binder;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.turbine.binder.bound.SourceTypeBoundClass;
@@ -64,7 +62,7 @@ static SourceTypeBoundClass bind(
     ImmutableList<RecordComponentInfo> components =
         components(base.source(), env, sym, pos, base.components());
     ImmutableList<MethodInfo> methods = methods(base.source(), pos, env, sym, base.methods());
-    ImmutableList<FieldInfo> fields = fields(base.source(), env, sym, base.fields());
+    ImmutableList<FieldInfo> fields = fields(base.source(), pos, env, sym, base.fields());
     return new SourceTypeBoundClass(
         interfaceTypes.build(),
         base.permits(),
@@ -89,6 +87,7 @@ static SourceTypeBoundClass bind(
 
   private static ImmutableList<FieldInfo> fields(
       SourceFile source,
+      int position,
       Env<ClassSymbol, TypeBoundClass> env,
       ClassSymbol sym,
       ImmutableList<FieldInfo> fields) {
@@ -99,8 +98,7 @@ private static ImmutableList<FieldInfo> fields(
               base.sym(),
               Canonicalize.canonicalize(
                   source,
-                  // we're processing fields bound from sources in the compilation
-                  requireNonNull(base.decl()).position(),
+                  base.decl() != null ? base.decl().position() : position,
                   env,
                   sym,
                   base.type()),

java/com/google/turbine/binder/TypeBinder.java

@@ -259,7 +259,10 @@ private SourceTypeBoundClass bind() {
               .build();
     }
 
-    ImmutableList<FieldInfo> fields = bindFields(scope, base.decl().members());
+    ImmutableList<FieldInfo> fields =
+        base.kind().equals(TurbineTyKind.RECORD)
+            ? recordFields(components)
+            : bindFields(scope, base.decl().members());
 
     return new SourceTypeBoundClass(
         interfaceTypes.build(),
@@ -397,6 +400,21 @@ private ImmutableList<MethodInfo> recordMethods(
     return methods.build();
   }
 
+  private ImmutableList<FieldInfo> recordFields(ImmutableList<RecordComponentInfo> components) {
+    ImmutableList.Builder<FieldInfo> fields = ImmutableList.builder();
+    for (RecordComponentInfo c : components) {
+      fields.add(
+          new FieldInfo(
+              new FieldSymbol(owner, c.name()),
+              c.type(),
+              TurbineFlag.ACC_PRIVATE | TurbineFlag.ACC_FINAL,
+              c.annotations(),
+              /* decl= */ null,
+              /* value= */ null));
+    }
+    return fields.build();
+  }
+
   private MethodInfo defaultRecordConstructor(
       SyntheticMethods syntheticMethods, ImmutableList<RecordComponentInfo> components) {
     MethodSymbol symbol = syntheticMethods.create(owner, "<init>");

javatests/com/google/turbine/processing/ProcessingIntegrationTest.java

@@ -625,7 +625,9 @@ public void recordProcessing() throws IOException {
             "METHOD hashCode()",
             "METHOD equals(java.lang.Object)",
             "METHOD x()",
-            "METHOD y()");
+            "METHOD y()",
+            "FIELD x",
+            "FIELD y");
   }
 
   @SupportedAnnotationTypes("*")
@@ -1207,6 +1209,110 @@ class B {}
         .containsExactly("package '' contains A", "package '' contains B");
   }
 
+  @SupportedAnnotationTypes("*")
+  public static class RecordMembers extends AbstractProcessor {
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+      return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+      if (!roundEnv.processingOver()) {
+        return false;
+      }
+      for (Element e :
+          processingEnv.getElementUtils().getTypeElement("Person").getEnclosedElements()) {
+        processingEnv.getMessager().printError(e + " " + e.getKind(), e);
+      }
+      return false;
+    }
+  }
+
+  @Test
+  public void recordMembers() throws Exception {
+    ImmutableList<Tree.CompUnit> units =
+        parseUnit(
+            """
+            === Person.java ===
+            public record Person(String name) {
+            }
+            """);
+    TurbineError e = runProcessors(units, new RecordMembers());
+    assertThat(
+            e.diagnostics().stream()
+                .filter(d -> d.severity().equals(Diagnostic.Kind.ERROR))
+                .map(d -> d.message()))
+        .containsExactly(
+            "name RECORD_COMPONENT",
+            "name FIELD",
+            "Person(java.lang.String) CONSTRUCTOR",
+            "toString() METHOD",
+            "hashCode() METHOD",
+            "equals(java.lang.Object) METHOD",
+            "name() METHOD");
+  }
+
+  @SupportedAnnotationTypes("*")
+  public static class RecordFields extends AbstractProcessor {
+    @Override
+    public SourceVersion getSupportedSourceVersion() {
+      return SourceVersion.latestSupported();
+    }
+
+    @Override
+    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
+      if (!roundEnv.processingOver()) {
+        return false;
+      }
+      for (VariableElement e :
+          fieldsIn(
+              processingEnv.getElementUtils().getTypeElement("Person").getEnclosedElements())) {
+        processingEnv
+            .getMessager()
+            .printError(
+                String.format(
+                    "%s: modifiers %s, type %s, annotations %s",
+                    e.getSimpleName(), e.getModifiers(), e.asType(), e.getAnnotationMirrors()),
+                e);
+      }
+      return false;
+    }
+  }
+
+  @Test
+  public void recordFields() throws Exception {
+    ImmutableList<Tree.CompUnit> units =
+        parseUnit(
+            """
+            === A.java ===
+            import java.lang.annotation.ElementType;
+            import java.lang.annotation.Target;
+            @Target({ElementType.FIELD, ElementType.TYPE_USE})
+            public @interface A {}
+            === B.java ===
+            import java.lang.annotation.ElementType;
+            import java.lang.annotation.Target;
+            @Target({ElementType.PARAMETER})
+            public @interface B {}
+            === Person.java ===
+            import java.util.List;
+            public record Person(String name, List<@A String> b, final @A int c, @B int d) {
+            }
+            """);
+    TurbineError e = runProcessors(units, new RecordFields());
+    assertThat(
+            e.diagnostics().stream()
+                .filter(d -> d.severity().equals(Diagnostic.Kind.ERROR))
+                .map(d -> d.message()))
+        .containsExactly(
+            "name: modifiers [private, final], type java.lang.String, annotations []",
+            "b: modifiers [private, final], type java.util.List<java.lang.@A String>, annotations"
+                + " []",
+            "c: modifiers [private, final], type @A int, annotations [@A]",
+            "d: modifiers [private, final], type int, annotations []");
+  }
+
   private TurbineError runProcessors(ImmutableList<Tree.CompUnit> units, Processor... processors) {
     return assertThrows(
         TurbineError.class,