Update XProcessing jar and provide XProcessingEnv to the Dagger component.
This CL uses the latest changes to XProcessingEnv which allow XProcessingEnv to be accessed early and cached across rounds in Dagger's component.
https://android-review.googlesource.com/c/platform/frameworks/support/+/1788655
I've also replaced all bindings relying on ProcessingEnvironment with XProcessingEnv, and rely on XConverters.toJavac() to convert back when needed.
RELNOTES=N/A
PiperOrigin-RevId: 390498574
diff --git a/java/dagger/internal/codegen/ComponentProcessor.java b/java/dagger/internal/codegen/ComponentProcessor.java
index 0684dde..1bb896b 100644
--- a/java/dagger/internal/codegen/ComponentProcessor.java
+++ b/java/dagger/internal/codegen/ComponentProcessor.java
@@ -54,7 +54,6 @@
import java.util.Arrays;
import java.util.Optional;
import java.util.Set;
-import javax.annotation.processing.ProcessingEnvironment;
import javax.annotation.processing.Processor;
import javax.inject.Inject;
import javax.inject.Singleton;
@@ -123,7 +122,7 @@
@Override
public Iterable<XProcessingStep> processingSteps() {
ProcessorComponent.factory()
- .create(processingEnv, testingPlugins.orElseGet(this::loadExternalPlugins))
+ .create(getXProcessingEnv(), testingPlugins.orElseGet(this::loadExternalPlugins))
.inject(this);
validationBindingGraphPlugins.initializePlugins();
@@ -159,7 +158,7 @@
interface Factory {
@CheckReturnValue
ProcessorComponent create(
- @BindsInstance ProcessingEnvironment processingEnv,
+ @BindsInstance XProcessingEnv xProcessingEnv,
@BindsInstance ImmutableSet<BindingGraphPlugin> externalPlugins);
}
}
diff --git a/java/dagger/internal/codegen/ProcessingEnvironmentModule.java b/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
index d43df35..60dabc6 100644
--- a/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
+++ b/java/dagger/internal/codegen/ProcessingEnvironmentModule.java
@@ -16,6 +16,9 @@
package dagger.internal.codegen;
+import androidx.room.compiler.processing.XMessager;
+import androidx.room.compiler.processing.XProcessingEnv;
+import androidx.room.compiler.processing.compat.XConverters;
import com.google.googlejavaformat.java.filer.FormattingFiler;
import dagger.Binds;
import dagger.Module;
@@ -31,11 +34,10 @@
import java.util.Map;
import javax.annotation.processing.Filer;
import javax.annotation.processing.Messager;
-import javax.annotation.processing.ProcessingEnvironment;
import javax.inject.Singleton;
import javax.lang.model.SourceVersion;
-/** Bindings that depend on the {@link ProcessingEnvironment}. */
+/** Bindings that depend on the {@link XProcessingEnv}. */
@Module
interface ProcessingEnvironmentModule {
@Binds
@@ -45,41 +47,47 @@
@Provides
@ProcessingOptions
- static Map<String, String> processingOptions(ProcessingEnvironment processingEnvironment) {
- return processingEnvironment.getOptions();
+ static Map<String, String> processingOptions(XProcessingEnv xProcessingEnv) {
+ return xProcessingEnv.getOptions();
}
@Provides
- static Messager messager(ProcessingEnvironment processingEnvironment) {
- return processingEnvironment.getMessager();
+ static XMessager xMessager(XProcessingEnv xProcessingEnv) {
+ return xProcessingEnv.getMessager();
+ }
+
+ // TODO(bcorso): Remove this once we've replaced all inject sites with XMessager.
+ @Provides
+ static Messager messager(XMessager messager) {
+ return XConverters.toJavac(messager);
+ }
+
+ // TODO(bcorso): Return XFiler. We'll likely need a XConverters.toXProcessing(Filer) so that we
+ // can convert our custom FormattingFiler into an XFiler.
+ @Provides
+ static Filer filer(CompilerOptions compilerOptions, XProcessingEnv xProcessingEnv) {
+ return compilerOptions.headerCompilation() || !compilerOptions.formatGeneratedSource()
+ ? XConverters.toJavac(xProcessingEnv).getFiler()
+ : new FormattingFiler(XConverters.toJavac(xProcessingEnv).getFiler());
}
@Provides
- static Filer filer(CompilerOptions compilerOptions, ProcessingEnvironment processingEnvironment) {
- if (compilerOptions.headerCompilation() || !compilerOptions.formatGeneratedSource()) {
- return processingEnvironment.getFiler();
- } else {
- return new FormattingFiler(processingEnvironment.getFiler());
- }
- }
-
- @Provides
- static SourceVersion sourceVersion(ProcessingEnvironment processingEnvironment) {
- return processingEnvironment.getSourceVersion();
+ static SourceVersion sourceVersion(XProcessingEnv xProcessingEnv) {
+ return XConverters.toJavac(xProcessingEnv).getSourceVersion();
}
@Provides
@Singleton
- static DaggerElements daggerElements(ProcessingEnvironment processingEnvironment) {
+ static DaggerElements daggerElements(XProcessingEnv xProcessingEnv) {
return new DaggerElements(
- processingEnvironment.getElementUtils(), processingEnvironment.getTypeUtils());
+ XConverters.toJavac(xProcessingEnv).getElementUtils(),
+ XConverters.toJavac(xProcessingEnv).getTypeUtils());
}
@Provides
@Singleton
- static DaggerTypes daggerTypes(
- ProcessingEnvironment processingEnvironment, DaggerElements elements) {
- return new DaggerTypes(processingEnvironment.getTypeUtils(), elements);
+ static DaggerTypes daggerTypes(XProcessingEnv xProcessingEnv, DaggerElements elements) {
+ return new DaggerTypes(XConverters.toJavac(xProcessingEnv).getTypeUtils(), elements);
}
@Binds
diff --git a/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java b/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java
index df1dd38..985f81e 100644
--- a/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java
+++ b/java/dagger/internal/codegen/compileroption/ProcessingEnvironmentCompilerOptions.java
@@ -50,7 +50,6 @@
import static java.util.stream.Collectors.joining;
import static java.util.stream.Stream.concat;
-import com.google.auto.common.MoreElements;
import com.google.common.base.Ascii;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
@@ -64,17 +63,18 @@
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;
-import javax.annotation.processing.ProcessingEnvironment;
+import javax.annotation.processing.Messager;
import javax.inject.Inject;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
-/** {@link CompilerOptions} for the given {@link ProcessingEnvironment}. */
+/** {@link CompilerOptions} for the given processor. */
public final class ProcessingEnvironmentCompilerOptions extends CompilerOptions {
// EnumOption<T> doesn't support integer inputs so just doing this as a 1-off for now.
private static final String KEYS_PER_COMPONENT_SHARD = "dagger.keysPerComponentShard";
- private final ProcessingEnvironment processingEnvironment;
+ private final Messager messager;
+ private final Map<String, String> options;
private final DaggerElements elements;
private final Map<EnumOption<?>, Object> enumOptions = new HashMap<>();
private final Map<EnumOption<?>, ImmutableMap<String, ? extends Enum<?>>> allCommandLineOptions =
@@ -82,9 +82,9 @@
@Inject
ProcessingEnvironmentCompilerOptions(
- ProcessingEnvironment processingEnvironment,
- DaggerElements elements) {
- this.processingEnvironment = processingEnvironment;
+ Messager messager, @ProcessingOptions Map<String, String> options, DaggerElements elements) {
+ this.messager = messager;
+ this.options = options;
this.elements = elements;
checkValid();
}
@@ -181,17 +181,18 @@
@Override
public int keysPerComponentShard(TypeElement component) {
- if (processingEnvironment.getOptions().containsKey(KEYS_PER_COMPONENT_SHARD)) {
+ if (options.containsKey(KEYS_PER_COMPONENT_SHARD)) {
checkArgument(
- MoreElements.getPackage(component).getQualifiedName().toString().startsWith("dagger."),
+ com.google.auto.common.MoreElements.getPackage(component)
+ .getQualifiedName().toString().startsWith("dagger."),
"Cannot set %s. It is only meant for internal testing.", KEYS_PER_COMPONENT_SHARD);
- return Integer.parseInt(processingEnvironment.getOptions().get(KEYS_PER_COMPONENT_SHARD));
+ return Integer.parseInt(options.get(KEYS_PER_COMPONENT_SHARD));
}
return super.keysPerComponentShard(component);
}
private boolean isEnabled(KeyOnlyOption keyOnlyOption) {
- return processingEnvironment.getOptions().containsKey(keyOnlyOption.toString());
+ return options.containsKey(keyOnlyOption.toString());
}
private boolean isEnabled(Feature feature) {
@@ -221,11 +222,9 @@
}
private void noLongerRecognized(CommandLineOption commandLineOption) {
- if (processingEnvironment.getOptions().containsKey(commandLineOption.toString())) {
- processingEnvironment
- .getMessager()
- .printMessage(
- Diagnostic.Kind.WARNING, commandLineOption + " is no longer recognized by Dagger");
+ if (options.containsKey(commandLineOption.toString())) {
+ messager.printMessage(
+ Diagnostic.Kind.WARNING, commandLineOption + " is no longer recognized by Dagger");
}
}
@@ -456,13 +455,11 @@
private void reportUseOfDifferentNamesForOption(
Diagnostic.Kind diagnosticKind, EnumOption<?> option, ImmutableSet<String> usedNames) {
- processingEnvironment
- .getMessager()
- .printMessage(
- diagnosticKind,
- String.format(
- "Only one of the equivalent options (%s) should be used; prefer -A%s",
- usedNames.stream().map(name -> "-A" + name).collect(joining(", ")), option));
+ messager.printMessage(
+ diagnosticKind,
+ String.format(
+ "Only one of the equivalent options (%s) should be used; prefer -A%s",
+ usedNames.stream().map(name -> "-A" + name).collect(joining(", ")), option));
}
private <T extends Enum<T>> ImmutableMap<String, T> parseOptionWithAllNames(
@@ -484,12 +481,10 @@
}
private <T extends Enum<T>> Optional<T> parseOptionWithName(EnumOption<T> option, String key) {
- checkArgument(processingEnvironment.getOptions().containsKey(key), "key %s not found", key);
- String stringValue = processingEnvironment.getOptions().get(key);
+ checkArgument(options.containsKey(key), "key %s not found", key);
+ String stringValue = options.get(key);
if (stringValue == null) {
- processingEnvironment
- .getMessager()
- .printMessage(Diagnostic.Kind.ERROR, "Processor option -A" + key + " needs a value");
+ messager.printMessage(Diagnostic.Kind.ERROR, "Processor option -A" + key + " needs a value");
} else {
try {
T value =
@@ -500,19 +495,16 @@
} catch (IllegalArgumentException e) {
// handled below
}
- processingEnvironment
- .getMessager()
- .printMessage(
- Diagnostic.Kind.ERROR,
- String.format(
- "Processor option -A%s may only have the values %s "
- + "(case insensitive), found: %s",
- key, option.validValues(), stringValue));
+ messager.printMessage(
+ Diagnostic.Kind.ERROR,
+ String.format(
+ "Processor option -A%s may only have the values %s (case insensitive), found: %s",
+ key, option.validValues(), stringValue));
}
return Optional.empty();
}
private Stream<String> getUsedNames(CommandLineOption option) {
- return option.allNames().filter(name -> processingEnvironment.getOptions().containsKey(name));
+ return option.allNames().filter(options::containsKey);
}
}
diff --git a/java/dagger/internal/codegen/xprocessing/xprocessing.jar b/java/dagger/internal/codegen/xprocessing/xprocessing.jar
index ce60485..44ac790 100644
--- a/java/dagger/internal/codegen/xprocessing/xprocessing.jar
+++ b/java/dagger/internal/codegen/xprocessing/xprocessing.jar
Binary files differ
