Internal changes

dagger-android-processor/main/java/dagger/android/processor/DelegateAndroidProcessor.java

@@ -28,6 +28,8 @@
 final class DelegateAndroidProcessor {
   static final XProcessingEnvConfig PROCESSING_ENV_CONFIG =
       new XProcessingEnvConfig.Builder()
+          // TODO: b/526607713 - Remove this once we properly handle property annotations in KSP.
+          .includePropertyAnnotationsInFields(true)
           .build();
   static final String FLAG_EXPERIMENTAL_USE_STRING_KEYS =
       "dagger.android.experimentalUseStringKeys";

dagger-android-processor/main/java/dagger/android/processor/DuplicateAndroidInjectorsChecker.java

@@ -25,6 +25,7 @@
 import static javax.tools.Diagnostic.Kind.ERROR;
 
 import androidx.room3.compiler.processing.XAnnotation;
+import androidx.room3.compiler.processing.XProcessingEnv;
 import androidx.room3.compiler.processing.XType;
 import androidx.room3.compiler.processing.XTypeArgument;
 import com.google.auto.service.AutoService;
@@ -56,11 +57,19 @@
  */
 @AutoService(BindingGraphPlugin.class)
 public final class DuplicateAndroidInjectorsChecker implements BindingGraphPlugin {
-  private DaggerProcessingEnv processingEnv;
+  private DaggerProcessingEnv daggerProcessingEnv;
+  private XProcessingEnv processingEnv;
 
   @Override
-  public void init(DaggerProcessingEnv processingEnv, Map<String, String> options) {
-    this.processingEnv = processingEnv;
+  public void init(DaggerProcessingEnv daggerProcessingEnv, Map<String, String> options) {
+    this.daggerProcessingEnv = daggerProcessingEnv;
+  }
+
+  @Override
+  public void onProcessingRoundBegin() {
+    // The XProcessingEnv must be reconstructed each round to ensure it uses the Resolver from the
+    // current round.
+    this.processingEnv = DaggerElements.toXProcessing(daggerProcessingEnv);
   }
 
   @Override

dagger-android-proguard-processor/main/java/dagger/android/internal/proguard/KspProguardProcessor.java

@@ -42,6 +42,8 @@
 public final class KspProguardProcessor extends KspBasicAnnotationProcessor {
   private static final XProcessingEnvConfig PROCESSING_ENV_CONFIG =
       new XProcessingEnvConfig.Builder()
+          // TODO: b/526607713 - Remove this once we properly handle property annotations in KSP.
+          .includePropertyAnnotationsInFields(true)
           .build();
   private XProcessingEnv env;
 

dagger-compiler/main/java/dagger/internal/codegen/DelegateComponentProcessor.java

@@ -71,6 +71,8 @@
 final class DelegateComponentProcessor {
   static final XProcessingEnvConfig PROCESSING_ENV_CONFIG =
       new XProcessingEnvConfig.Builder()
+          // TODO: b/526607713 - Remove this once we properly handle property annotations in KSP.
+          .includePropertyAnnotationsInFields(true)
           .disableAnnotatedElementValidation(true)
           .build();
 

dagger-compiler/main/java/dagger/internal/codegen/xprocessing/DaggerElements.java

@@ -19,6 +19,7 @@
 import androidx.room3.compiler.processing.XElement;
 import androidx.room3.compiler.processing.XProcessingEnv;
 import androidx.room3.compiler.processing.XType;
+import androidx.room3.compiler.processing.XTypeElement;
 import androidx.room3.compiler.processing.compat.XConverters;
 import com.google.devtools.ksp.symbol.KSClassDeclaration;
 import com.google.devtools.ksp.symbol.KSFunctionDeclaration;
@@ -27,12 +28,11 @@
 import dagger.spi.model.DaggerElement;
 import dagger.spi.model.DaggerProcessingEnv;
 import dagger.spi.model.DaggerType;
+import dagger.spi.model.DaggerTypeElement;
 
 /** Convert Dagger model types to XProcessing types. */
 public final class DaggerElements {
-  public static XElement toXProcessing(
-      DaggerElement element, DaggerProcessingEnv daggerProcessingEnv) {
-    XProcessingEnv processingEnv = toXProcessing(daggerProcessingEnv);
+  public static XElement toXProcessing(DaggerElement element, XProcessingEnv processingEnv) {
     switch (element.backend()) {
       case JAVAC:
         return XConverters.toXProcessing(element.javac(), processingEnv);
@@ -53,8 +53,7 @@ public static XElement toXProcessing(
         String.format("Backend %s not supported yet.", element.backend()));
   }
 
-  public static XType toXProcessing(DaggerType type, DaggerProcessingEnv daggerProcessingEnv) {
-    XProcessingEnv processingEnv = toXProcessing(daggerProcessingEnv);
+  public static XType toXProcessing(DaggerType type, XProcessingEnv processingEnv) {
     switch (type.backend()) {
       case JAVAC:
         return XConverters.toXProcessing(type.javac(), processingEnv);
@@ -64,6 +63,25 @@ public static XType toXProcessing(DaggerType type, DaggerProcessingEnv daggerPro
     throw new IllegalStateException(String.format("Backend %s not supported yet.", type.backend()));
   }
 
+  public static XTypeElement toXProcessing(
+      DaggerTypeElement element, XProcessingEnv processingEnv) {
+    switch (element.backend()) {
+      case JAVAC:
+        return XConverters.toXProcessing(element.javac(), processingEnv);
+      case KSP:
+        return XConverters.toXProcessing(element.ksp(), processingEnv);
+    }
+    throw new IllegalStateException(
+        String.format("Backend %s not supported yet.", element.backend()));
+  }
+
+  /**
+   * Returns a new {@link XProcessingEnv} for the given {@link DaggerProcessingEnv}.
+   *
+   * <p>Callers should invoke this method once per processing round and pass the resulting {@link
+   * XProcessingEnv} to the other {@code toXProcessing} methods so that element and type wrappers
+   * are cached across conversions within the round.
+   */
   public static XProcessingEnv toXProcessing(DaggerProcessingEnv processingEnv) {
     switch (processingEnv.backend()) {
       case JAVAC:

dagger-compiler/main/java/dagger/internal/codegen/xprocessing/XElements.java

@@ -20,6 +20,7 @@
 import static androidx.room3.compiler.processing.XElementKt.isField;
 import static androidx.room3.compiler.processing.XElementKt.isMethod;
 import static androidx.room3.compiler.processing.XElementKt.isMethodParameter;
+import static androidx.room3.compiler.processing.XElementKt.isProperty;
 import static androidx.room3.compiler.processing.XElementKt.isTypeElement;
 import static androidx.room3.compiler.processing.XElementKt.isVariableElement;
 import static androidx.room3.compiler.processing.compat.XConverters.getProcessingEnv;
@@ -45,6 +46,7 @@
 import androidx.room3.compiler.processing.XMemberContainer;
 import androidx.room3.compiler.processing.XMethodElement;
 import androidx.room3.compiler.processing.XProcessingEnv;
+import androidx.room3.compiler.processing.XPropertyElement;
 import androidx.room3.compiler.processing.XTypeElement;
 import androidx.room3.compiler.processing.XTypeParameterElement;
 import androidx.room3.compiler.processing.XVariableElement;
@@ -254,6 +256,11 @@ public static XFieldElement asField(XElement element) {
     return (XFieldElement) element;
   }
 
+  public static XPropertyElement asProperty(XElement element) {
+    checkState(isProperty(element));
+    return (XPropertyElement) element;
+  }
+
   public static XEnumEntry asEnumEntry(XElement element) {
     return (XEnumEntry) element;
   }

hilt-compiler/main/java/dagger/hilt/processor/internal/HiltProcessingEnvConfigs.java

@@ -22,6 +22,8 @@
 public final class HiltProcessingEnvConfigs {
   public static final XProcessingEnvConfig CONFIGS =
       new XProcessingEnvConfig.Builder()
+          // TODO: b/526607713 - Remove this once we properly handle property annotations in KSP.
+          .includePropertyAnnotationsInFields(true)
           // In Hilt we disable the default element validation because we would otherwise run into a
           // cycle where our Hilt processors are waiting on the "Hilt_Foo" classes to be generated
           // before processing "Foo", but "Hilt_Foo" can't be generated until "Foo" is processed.

java/dagger/testing/compile/CompilerTests.java

@@ -64,6 +64,8 @@ public final class CompilerTests {
   // dagger-compiler/main/java/dagger/internal/codegen/DelegateComponentProcessor.java
   static final XProcessingEnvConfig PROCESSING_ENV_CONFIG =
       new XProcessingEnvConfig.Builder()
+          // TODO: b/526607713 - Remove this once we properly handle property annotations in KSP.
+          .includePropertyAnnotationsInFields(true)
           .disableAnnotatedElementValidation(true)
           .build();